From dc186e33525da12eb2c83924090c12444ed4c017 Mon Sep 17 00:00:00 2001 From: Maurizio Cimadamore Date: Wed, 7 Oct 2020 18:07:02 +0100 Subject: [PATCH 01/70] RFR 8254162: Implementation of Foreign-Memory Access API (Third Incubator) This patch contains the changes associated with the third incubation round of the foreign memory access API incubation (see JEP 393 [1]). This iteration focus on improving the usability of the API in 3 main ways: * first, by providing a way to obtain truly *shared* segments, which can be accessed and closed concurrently from multiple threads * second, by providing a way to register a memory segment against a `Cleaner`, so as to have some (optional) guarantee that the memory will be deallocated, eventually * third, by not requiring users to dive deep into var handles when they first pick up the API; a new `MemoryAccess` class has been added, which defines several useful dereference routines; these are really just thin wrappers around memory access var handles, but they make the barrier of entry for using this API somewhat lower. A big conceptual shift that comes with this API refresh is that the role of `MemorySegment` and `MemoryAddress` is not the same as it used to be; it used to be the case that a memory address could (sometimes, not always) have a back link to the memory segment which originated it; additionally, memory access var handles used `MemoryAddress` as a basic unit of dereference. This has all changed as per this API refresh; now a `MemoryAddress` is just a dumb carrier which wraps a pair of object/long addressing coordinates; `MemorySegment` has become the star of the show, as far as dereferencing memory is concerned. You cannot dereference memory if you don't have a segment. This improves usability in a number of ways - first, it is a lot easier to wrap native addresses (`long`, essentially) into a `MemoryAddress`; secondly, it is crystal clear what a client has to do in order to dereference memory: if a client has a segment, it can use that; otherwise, if the client only has an address, it will have to create a segment *unsafely* (this can be done by calling `MemoryAddress::asSegmentRestricted`). A list of the API, implementation and test changes is provided below. If you have any questions, or need more detailed explanations, I (and the rest of the Panama team) will be happy to point at existing discussions, and/or to provide the feedback required. A big thank to Erik Osterlund, Vladimir Ivanov and David Holmes, without whom the work on shared memory segment would not have been possible. Thanks Maurizio Javadoc: http://cr.openjdk.java.net/~mcimadamore/8254162_v1/javadoc/jdk/incubator/foreign/package-summary.html Specdiff: http://cr.openjdk.java.net/~mcimadamore/8254162_v1/specdiff/jdk/incubator/foreign/package-summary.html CSR: https://bugs.openjdk.java.net/browse/JDK-8254163 * `MemorySegment` * drop factory for restricted segment (this has been moved to `MemoryAddress`, see below) * added a no-arg factory for a native restricted segment representing entire native heap * rename `withOwnerThread` to `handoff` * add new `share` method, to create shared segments * add new `registerCleaner` method, to register a segment against a cleaner * add more helpers to create arrays from a segment e.g. `toIntArray` * add some `asSlice` overloads (to make up for the fact that now segments are more frequently used as cursors) * rename `baseAddress` to `address` (so that `MemorySegment` can implement `Addressable`) * `MemoryAddress` * drop `segment` accessor * drop `rebase` method and replace it with `segmentOffset` which returns the offset (a `long`) of this address relative to a given segment * `MemoryAccess` * New class supporting several static dereference helpers; the helpers are organized by carrier and access mode, where a carrier is one of the usual suspect (a Java primitive, minus `boolean`); the access mode can be simple (e.g. access base address of given segment), or indexed, in which case the accessor takes a segment and either a low-level byte offset,or a high level logical index. The classification is reflected in the naming scheme (e.g. `getByte` vs. `getByteAtOffset` vs `getByteAtIndex`). * `MemoryHandles` * drop `withOffset` combinator * drop `withStride` combinator * the basic memory access handle factory now returns a var handle which takes a `MemorySegment` and a `long` - from which it is easy to derive all the other handles using plain var handle combinators. * `Addressable` * This is a new interface which is attached to entities which can be projected to a `MemoryAddress`. For now, both `MemoryAddress` and `MemorySegment` implement it; we have plans, with JEP 389 [2] to add more implementations. Clients can largely ignore this interface, which comes in really handy when defining native bindings with tools like `jextract`. * `MemoryLayouts` * A new layout, for machine addresses, has been added to the mix. There are two main things to discuss here: support for shared segments, and the general simplification of the memory access var handle support. The support for shared segments cuts in pretty deep in the VM. Support for shared segments is notoriously hard to achieve, at least in a way that guarantees optimal access performances. This is caused by the fact that, if a segment is shared, it would be possible for a thread to close it while another is accessing it. After considering several options (see [3]), we zeroed onto an approach which is inspired by an happy idea that Andrew Haley had (and that he reminded me of at this year OpenJDK committer workshop - thanks!). The idea is that if we could *freeze* the world (e.g. with a GC pause), while a segment is closed, we could then prevent segments from being accessed concurrently to a close operation. For this to work, it is crucial that no GC safepoints can occur between a segment liveness check and the access itself (otherwise it would be possible for the accessing thread to stop just right before an unsafe call). It also relies on the fact that hotspot/C2 should not be able to propagate loads across safepoints. Sadly, none of these conditions seems to be valid in the current implementation, so we needed to resort to a bit of creativity. First, we noted that, if we could mark so called *scoped* method with an annotation, it would be very simply to check as to whether a thread was in the middle of a scoped method when we stopped the world for a close operation (btw, instead of stopping the world, we do a much more efficient, thread-local polling, thanks to JEP 312 [4]). The question is, then, once we detect that a thread is accessing the very segment we're about to close, what should happen? We first experimented with a solution which would install an *asynchronous* exception on the accessing thread, thus making it fail. This solution has some desirable properties, in that a `close` operation always succeeds. Unfortunately the machinery for async exceptions is a bit fragile (e.g. not all the code in hotspot checks for async exceptions); to minimize risks, we decided to revert to a simpler strategy, where `close` might fail when it finds that another thread is accessing the segment being closed. As written in the javadoc, this doesn't mean that clients should just catch and try again; an exception on `close` is a bug in the user code, likely arising from lack of synchronization, and should be treated as such. In terms of gritty implementation, we needed to centralize memory access routines in a single place, so that we could have a set of routines closely mimicking the primitives exposed by `Unsafe` but which, in addition, also provided a liveness check. This way we could mark all these routines with the special `@Scoped` annotation, which tells the VM that something important is going on. To achieve this, we created a new (autogenerated) class, called `ScopedMemoryAccess`. This class contains all the main memory access primitives (including bulk access, like `copyMemory`, or `setMemory`), and accepts, in addition to the access coordinates, also a scope object, which is tested before access. A reachability fence is also thrown in the mix to make sure that the scope is kept alive during access (which is important when registering segments against cleaners). Of course, to make memory access safe, memory access var handles, byte buffer var handles, and byte buffer API should use the new `ScopedMemoryAccess` class instead of unsafe, so that a liveness check can be triggered (in case a scope is present). `ScopedMemoryAccess` has a `closeScope` method, which initiates the thread-local handshakes, and returns `true` if the handshake completed successfully. The implementation of `MemoryScope` (now significantly simplified from what we had before), has two implementations, one for confined segments and one for shared segments; the main difference between the two is what happens when the scope is closed; a confined segment sets a boolean flag to false, and returns, whereas a shared segment goes into a `CLOSING` state, then starts the handshake, and then updates the state again, to either `CLOSED` or `ALIVE` depending on whether the handshake was successful or not. Note that when a shared segment is in the `CLOSING` state, `MemorySegment::isAlive` will still return `true`, while the liveness check upon memory access will fail. The key realization here was that if all memory access var handles took a coordinate pair of `MemorySegment` and `long`, all other access types could be derived from this basic var handle form. This allowed us to remove the on-the-fly var handle generation, and to simply derive structural access var handles (such as those obtained by calling `MemoryLayout::varHandle`) using *plain* var handle combinators, so that e.g. additional offset is injected into a base memory access var handle. This also helped in simplifying the implementation by removing the special `withStride` and `withOffset` combinators, which previously needed low-level access on the innards of the memory access var handle. All that code is now gone. Not much to see here - most of the tests needed to be updated because of the API changes. Some were beefed up (like the array test, since now segments can be projected into many different kinds of arrays). A test has been added to test the `Cleaner` functionality, and another stress test has been added for shared segments (`TestHandshake`). Some of the microbenchmarks also needed some tweaks - and some of them were also updated to also test performance in the shared segment case. [1] - https://openjdk.java.net/jeps/393 [2] - https://openjdk.java.net/jeps/389 [3] - https://mail.openjdk.java.net/pipermail/panama-dev/2020-May/009004.html [4] - https://openjdk.java.net/jeps/312 --- .../gensrc/GensrcScopedMemoryAccess.gmk | 155 ++ .../share/prims/scopedMemoryAccess.cpp | 166 ++ .../share/prims/scopedMemoryAccess.hpp | 35 + .../X-ScopedMemoryAccess-bin.java.template | 698 ++++++ .../misc/X-ScopedMemoryAccess.java.template | 239 ++ .../jdk/incubator/foreign/Addressable.java | 46 + .../jdk/incubator/foreign/MemoryAccess.java | 2078 +++++++++++++++++ test/jdk/java/foreign/TestCleaner.java | 191 ++ test/jdk/java/foreign/TestHandshake.java | 244 ++ .../foreign/LoopOverNonConstantShared.java | 166 ++ 10 files changed, 4018 insertions(+) create mode 100644 make/modules/java.base/gensrc/GensrcScopedMemoryAccess.gmk create mode 100644 src/hotspot/share/prims/scopedMemoryAccess.cpp create mode 100644 src/hotspot/share/prims/scopedMemoryAccess.hpp create mode 100644 src/java.base/share/classes/jdk/internal/misc/X-ScopedMemoryAccess-bin.java.template create mode 100644 src/java.base/share/classes/jdk/internal/misc/X-ScopedMemoryAccess.java.template create mode 100644 src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/Addressable.java create mode 100644 src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MemoryAccess.java create mode 100644 test/jdk/java/foreign/TestCleaner.java create mode 100644 test/jdk/java/foreign/TestHandshake.java create mode 100644 test/micro/org/openjdk/bench/jdk/incubator/foreign/LoopOverNonConstantShared.java diff --git a/make/modules/java.base/gensrc/GensrcScopedMemoryAccess.gmk b/make/modules/java.base/gensrc/GensrcScopedMemoryAccess.gmk new file mode 100644 index 0000000000000..cb51d4f30d945 --- /dev/null +++ b/make/modules/java.base/gensrc/GensrcScopedMemoryAccess.gmk @@ -0,0 +1,155 @@ +# +# Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved. +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# This code is free software; you can redistribute it and/or modify it +# under the terms of the GNU General Public License version 2 only, as +# published by the Free Software Foundation. Oracle designates this +# particular file as subject to the "Classpath" exception as provided +# by Oracle in the LICENSE file that accompanied this code. +# +# This code 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 +# version 2 for more details (a copy is included in the LICENSE file that +# accompanied this code). +# +# You should have received a copy of the GNU General Public License version +# 2 along with this work; if not, write to the Free Software Foundation, +# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. +# +# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA +# or visit www.oracle.com if you need additional information or have any +# questions. +# + +GENSRC_SCOPED_MEMORY_ACCESS := + + +SCOPED_MEMORY_ACCESS_GENSRC_DIR := $(SUPPORT_OUTPUTDIR)/gensrc/java.base/jdk/internal/misc +SCOPED_MEMORY_ACCESS_SRC_DIR := $(TOPDIR)/src/java.base/share/classes/jdk/internal/misc + +SCOPED_MEMORY_ACCESS_TEMPLATE := $(TOPDIR)/src/java.base/share/classes/jdk/internal/misc/X-ScopedMemoryAccess.java.template +SCOPED_MEMORY_ACCESS_BIN_TEMPLATE := $(TOPDIR)/src/java.base/share/classes/jdk/internal/misc/X-ScopedMemoryAccess-bin.java.template +DEST := $(SCOPED_MEMORY_ACCESS_GENSRC_DIR)/ScopedMemoryAccess.java + +################################################################################ +# Setup a rule for generating the ScopedMemoryAccess java class +# Param 1 - Variable declaration prefix +# Param 2 - Type with first letter capitalized +define GenerateScopedOp + + $1_Type := $2 + + ifeq ($$($1_Type), Byte) + $1_type := byte + $1_BoxType := $$($1_Type) + + $1_rawType := $$($1_type) + $1_RawType := $$($1_Type) + $1_RawBoxType := $$($1_BoxType) + + $1_ARGS += -Kbyte + endif + + ifeq ($$($1_Type), Short) + $1_type := short + $1_BoxType := $$($1_Type) + + $1_rawType := $$($1_type) + $1_RawType := $$($1_Type) + $1_RawBoxType := $$($1_BoxType) + $1_ARGS += -KUnaligned + endif + + ifeq ($$($1_Type), Char) + $1_type := char + $1_BoxType := Character + + $1_rawType := $$($1_type) + $1_RawType := $$($1_Type) + $1_RawBoxType := $$($1_BoxType) + $1_ARGS += -KUnaligned + endif + + ifeq ($$($1_Type), Int) + $1_type := int + $1_BoxType := Integer + + $1_rawType := $$($1_type) + $1_RawType := $$($1_Type) + $1_RawBoxType := $$($1_BoxType) + + $1_ARGS += -KCAS + $1_ARGS += -KAtomicAdd + $1_ARGS += -KBitwise + $1_ARGS += -KUnaligned + endif + + ifeq ($$($1_Type), Long) + $1_type := long + $1_BoxType := $$($1_Type) + + $1_rawType := $$($1_type) + $1_RawType := $$($1_Type) + $1_RawBoxType := $$($1_BoxType) + + $1_ARGS += -KCAS + $1_ARGS += -KAtomicAdd + $1_ARGS += -KBitwise + $1_ARGS += -KUnaligned + endif + + ifeq ($$($1_Type), Float) + $1_type := float + $1_BoxType := $$($1_Type) + + $1_rawType := int + $1_RawType := Int + $1_RawBoxType := Integer + + $1_ARGS += -KCAS + $1_ARGS += -KfloatingPoint + endif + + ifeq ($$($1_Type), Double) + $1_type := double + $1_BoxType := $$($1_Type) + + $1_rawType := long + $1_RawType := Long + $1_RawBoxType := Long + + $1_ARGS += -KCAS + $1_ARGS += -KfloatingPoint + endif + + ifneq ($$(findstring $$($1_Type), Byte Short Char Int Long Float Double), ) + $1_ARGS += -KAtomicAdd + endif + + ifneq ($$(findstring $$($1_Type), Boolean Byte Short Char Int Long), ) + $1_ARGS += -KBitwise + endif + + ifneq ($$(findstring $$($1_Type), Byte Short Char), ) + $1_ARGS += -KShorterThanInt + endif +endef + +################################################################################ +# Setup a rule for generating the ScopedMemoryAccess java class + +SCOPE_MEMORY_ACCESS_TYPES := Byte Short Char Int Long Float Double +$(foreach t, $(SCOPE_MEMORY_ACCESS_TYPES), \ + $(eval $(call GenerateScopedOp,BIN_$t,$t))) + +$(DEST): $(BUILD_TOOLS_JDK) $(SCOPED_MEMORY_ACCESS_TEMPLATE) $(SCOPED_MEMORY_ACCESS_BIN_TEMPLATE) + $(MKDIR) -p $(SCOPED_MEMORY_ACCESS_GENSRC_DIR) + $(CP) $(SCOPED_MEMORY_ACCESS_TEMPLATE) $(DEST) + $(foreach t, $(SCOPE_MEMORY_ACCESS_TYPES), \ + $(TOOL_SPP) -nel -K$(BIN_$t_type) -Dtype=$(BIN_$t_type) -DType=$(BIN_$t_Type) $(BIN_$t_ARGS) \ + -i$(SCOPED_MEMORY_ACCESS_BIN_TEMPLATE) -o$(DEST) ;) + $(PRINTF) "}\n" >> $(DEST) + +TARGETS += $(DEST) \ No newline at end of file diff --git a/src/hotspot/share/prims/scopedMemoryAccess.cpp b/src/hotspot/share/prims/scopedMemoryAccess.cpp new file mode 100644 index 0000000000000..92fbfc170f73c --- /dev/null +++ b/src/hotspot/share/prims/scopedMemoryAccess.cpp @@ -0,0 +1,166 @@ + +#include "precompiled.hpp" +#include "jni.h" +#include "jvm.h" +#include "classfile/vmSymbols.hpp" +#include "oops/access.inline.hpp" +#include "oops/oop.inline.hpp" +#include "runtime/jniHandles.inline.hpp" +#include "runtime/interfaceSupport.inline.hpp" +#include "runtime/sharedRuntime.hpp" +#include "runtime/vframe.inline.hpp" +#include "runtime/deoptimization.hpp" +#include "prims/stackwalk.hpp" + + +class CloseScopedMemoryFindOopClosure : public OopClosure { + oop _deopt; + bool _found; + +public: + CloseScopedMemoryFindOopClosure(jobject deopt) : + _deopt(JNIHandles::resolve(deopt)), + _found(false) {} + + template + void do_oop_work(T* p) { + if (_found) { + return; + } + if (RawAccess<>::oop_load(p) == _deopt) { + _found = true; + } + } + + virtual void do_oop(oop* p) { + do_oop_work(p); + } + + virtual void do_oop(narrowOop* p) { + do_oop_work(p); + } + + bool found() { + return _found; + } +}; + +class CloseScopedMemoryClosure : public HandshakeClosure { + jobject _deopt; + jobject _exception; + +public: + jboolean _found; + + CloseScopedMemoryClosure(jobject deopt, jobject exception) + : HandshakeClosure("CloseScopedMemory") + , _deopt(deopt) + , _exception(exception) + , _found(false) {} + + void do_thread(Thread* thread) { + + JavaThread* jt = (JavaThread*)thread; + + if (!jt->has_last_Java_frame()) { + return; + } + + frame last_frame = jt->last_frame(); + RegisterMap register_map(jt, true); + + if (last_frame.is_safepoint_blob_frame()) { + last_frame = last_frame.sender(®ister_map); + } + + ResourceMark rm; + if (_deopt != NULL && last_frame.is_compiled_frame() && last_frame.can_be_deoptimized()) { + CloseScopedMemoryFindOopClosure cl(_deopt); + CompiledMethod* cm = last_frame.cb()->as_compiled_method(); + + //FIXME: this doesn't work if reachability fences are violated by C2 + // last_frame.oops_do(&cl, NULL, ®ister_map); + + // if (cl.found()) { + // // Found the deopt oop in a compiled method; deoptimize. + // Deoptimization::deoptimize(jt, last_frame); + // } + + // so... we unconditionally deoptimize, for now + Deoptimization::deoptimize(jt, last_frame); + } + + const int max_critical_stack_depth = 10; + int depth = 0; + vframeStream stream(jt); + for (; !stream.at_end(); stream.next()) { + Method* m = stream.method(); + if (m->is_scoped()) { + StackValueCollection* locals = stream.asJavaVFrame()->locals(); + for (int i = 0; i < locals->size(); i++) { + StackValue* var = locals->at(i); + if (var->type() == T_OBJECT) { + if (var->get_obj() == JNIHandles::resolve(_deopt)) { + assert(depth < max_critical_stack_depth, "can't have more than %d critical frames", max_critical_stack_depth); + _found = true; + return; + } + } + } + break; + } + depth++; +#ifndef ASSERT + if (depth >= max_critical_stack_depth) { + break; + } +#endif + } + } +}; + +/* + * This function issues a global handshake operation with all + * Java threads. This is useful for implementing asymmetric + * dekker synchronization schemes, where expensive synchronization + * in performance sensitive common paths, may be shifted to + * a less common slow path instead. + * Top frames containg obj will be deoptimized. + */ +JVM_ENTRY(jboolean, ScopedMemoryAccess_closeScope(JNIEnv *env, jobject receiver, jobject deopt, jobject exception)) { + CloseScopedMemoryClosure cl(deopt, exception); + Handshake::execute(&cl); + return !cl._found; +} JVM_END + +/// JVM_RegisterUnsafeMethods + +#define LANG "Ljdk/internal/misc/" + +#define MEMACCESS "ScopedMemoryAccess" +#define SCOPE LANG MEMACCESS "$Scope;" +#define SCOPED_ERR LANG MEMACCESS "$Scope$ScopedAccessError;" + +#define CC (char*) /*cast a literal from (const char*)*/ +#define FN_PTR(f) CAST_FROM_FN_PTR(void*, &f) + +static JNINativeMethod jdk_internal_misc_ScopedMemoryAccess_methods[] = { + {CC "closeScope0", CC "(" SCOPE SCOPED_ERR ")Z", FN_PTR(ScopedMemoryAccess_closeScope)}, +}; + +#undef CC +#undef FN_PTR + +#undef LANG +#undef MEMACCESS +#undef SCOPE +#undef SCOPED_EXC + +// This function is exported, used by NativeLookup. + +JVM_ENTRY(void, JVM_RegisterJDKInternalMiscScopedMemoryAccessMethods(JNIEnv *env, jclass scopedMemoryAccessClass)) { + ThreadToNativeFromVM ttnfv(thread); + + int ok = env->RegisterNatives(scopedMemoryAccessClass, jdk_internal_misc_ScopedMemoryAccess_methods, sizeof(jdk_internal_misc_ScopedMemoryAccess_methods)/sizeof(JNINativeMethod)); + guarantee(ok == 0, "register jdk.internal.misc.ScopedMemoryAccess natives"); +} JVM_END diff --git a/src/hotspot/share/prims/scopedMemoryAccess.hpp b/src/hotspot/share/prims/scopedMemoryAccess.hpp new file mode 100644 index 0000000000000..050e729f84481 --- /dev/null +++ b/src/hotspot/share/prims/scopedMemoryAccess.hpp @@ -0,0 +1,35 @@ +/* + * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code 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 + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + + +#ifndef SHARE_PRIMS_SCOPED_MEMORY_ACCESS_HPP +#define SHARE_PRIMS_SCOPED_MEMORY_ACCESS_HPP + +#include "jni.h" + +extern "C" { + void JNICALL JVM_RegisterJDKInternalMiscScopedMemoryAccessMethods(JNIEnv *env, jobject rec, jobject scope, jthrowable exception); +} + +#endif // SHARE_PRIMS_SCOPED_MEMORY_ACCESS_HPP diff --git a/src/java.base/share/classes/jdk/internal/misc/X-ScopedMemoryAccess-bin.java.template b/src/java.base/share/classes/jdk/internal/misc/X-ScopedMemoryAccess-bin.java.template new file mode 100644 index 0000000000000..0f1a978724457 --- /dev/null +++ b/src/java.base/share/classes/jdk/internal/misc/X-ScopedMemoryAccess-bin.java.template @@ -0,0 +1,698 @@ + @ForceInline + public $type$ get$Type$(Scope scope, Object base, long offset) { + try { + return get$Type$Internal(scope, base, offset); + } catch (Scope.ScopedAccessError ex) { + throw new IllegalStateException("This segment is already closed"); + } + } + + @ForceInline @Scoped + private $type$ get$Type$Internal(Scope scope, Object base, long offset) { + try { + if (scope != null) { + scope.checkValidState(); + } + return UNSAFE.get$Type$(base, offset); + } finally { + Reference.reachabilityFence(scope); + } + } + + @ForceInline + public void put$Type$(Scope scope, Object base, long offset, $type$ value) { + try { + put$Type$Internal(scope, base, offset, value); + } catch (Scope.ScopedAccessError ex) { + throw new IllegalStateException("This segment is already closed"); + } + } + + @ForceInline @Scoped + private void put$Type$Internal(Scope scope, Object base, long offset, $type$ value) { + try { + if (scope != null) { + scope.checkValidState(); + } + UNSAFE.put$Type$(base, offset, value); + } finally { + Reference.reachabilityFence(scope); + } + } + +#if[Unaligned] + @ForceInline + public $type$ get$Type$Unaligned(Scope scope, Object base, long offset, boolean be) { + try { + return get$Type$UnalignedInternal(scope, base, offset, be); + } catch (Scope.ScopedAccessError ex) { + throw new IllegalStateException("This segment is already closed"); + } + } + + @ForceInline @Scoped + private $type$ get$Type$UnalignedInternal(Scope scope, Object base, long offset, boolean be) { + try { + if (scope != null) { + scope.checkValidState(); + } + return UNSAFE.get$Type$Unaligned(base, offset, be); + } finally { + Reference.reachabilityFence(scope); + } + } + + @ForceInline + public void put$Type$Unaligned(Scope scope, Object base, long offset, $type$ value, boolean be) { + try { + put$Type$UnalignedInternal(scope, base, offset, value, be); + } catch (Scope.ScopedAccessError ex) { + throw new IllegalStateException("This segment is already closed"); + } + } + + @ForceInline @Scoped + private void put$Type$UnalignedInternal(Scope scope, Object base, long offset, $type$ value, boolean be) { + try { + if (scope != null) { + scope.checkValidState(); + } + UNSAFE.put$Type$Unaligned(base, offset, value, be); + } finally { + Reference.reachabilityFence(scope); + } + } +#end[Unaligned] + + @ForceInline + public $type$ get$Type$Volatile(Scope scope, Object base, long offset) { + try { + return get$Type$VolatileInternal(scope, base, offset); + } catch (Scope.ScopedAccessError ex) { + throw new IllegalStateException("This segment is already closed"); + } + } + + @ForceInline @Scoped + private $type$ get$Type$VolatileInternal(Scope scope, Object base, long offset) { + try { + if (scope != null) { + scope.checkValidState(); + } + return UNSAFE.get$Type$Volatile(base, offset); + } finally { + Reference.reachabilityFence(scope); + } + } + + @ForceInline + public void put$Type$Volatile(Scope scope, Object base, long offset, $type$ value) { + try { + put$Type$VolatileInternal(scope, base, offset, value); + } catch (Scope.ScopedAccessError ex) { + throw new IllegalStateException("This segment is already closed"); + } + } + + @ForceInline @Scoped + private void put$Type$VolatileInternal(Scope scope, Object base, long offset, $type$ value) { + try { + if (scope != null) { + scope.checkValidState(); + } + UNSAFE.put$Type$Volatile(base, offset, value); + } finally { + Reference.reachabilityFence(scope); + } + } + + @ForceInline + public $type$ get$Type$Acquire(Scope scope, Object base, long offset) { + try { + return get$Type$AcquireInternal(scope, base, offset); + } catch (Scope.ScopedAccessError ex) { + throw new IllegalStateException("This segment is already closed"); + } + } + + @ForceInline @Scoped + private $type$ get$Type$AcquireInternal(Scope scope, Object base, long offset) { + try { + if (scope != null) { + scope.checkValidState(); + } + return UNSAFE.get$Type$Acquire(base, offset); + } finally { + Reference.reachabilityFence(scope); + } + } + + @ForceInline + public void put$Type$Release(Scope scope, Object base, long offset, $type$ value) { + try { + put$Type$ReleaseInternal(scope, base, offset, value); + } catch (Scope.ScopedAccessError ex) { + throw new IllegalStateException("This segment is already closed"); + } + } + + @ForceInline @Scoped + private void put$Type$ReleaseInternal(Scope scope, Object base, long offset, $type$ value) { + try { + if (scope != null) { + scope.checkValidState(); + } + UNSAFE.put$Type$Release(base, offset, value); + } finally { + Reference.reachabilityFence(scope); + } + } + + @ForceInline + public $type$ get$Type$Opaque(Scope scope, Object base, long offset) { + try { + return get$Type$OpaqueInternal(scope, base, offset); + } catch (Scope.ScopedAccessError ex) { + throw new IllegalStateException("This segment is already closed"); + } + } + + @ForceInline @Scoped + private $type$ get$Type$OpaqueInternal(Scope scope, Object base, long offset) { + try { + if (scope != null) { + scope.checkValidState(); + } + return UNSAFE.get$Type$Opaque(base, offset); + } finally { + Reference.reachabilityFence(scope); + } + } + @ForceInline + public void put$Type$Opaque(Scope scope, Object base, long offset, $type$ value) { + try { + put$Type$OpaqueInternal(scope, base, offset, value); + } catch (Scope.ScopedAccessError ex) { + throw new IllegalStateException("This segment is already closed"); + } + } + + @ForceInline @Scoped + private void put$Type$OpaqueInternal(Scope scope, Object base, long offset, $type$ value) { + try { + if (scope != null) { + scope.checkValidState(); + } + UNSAFE.put$Type$Opaque(base, offset, value); + } finally { + Reference.reachabilityFence(scope); + } + } +#if[CAS] + @ForceInline + public boolean compareAndSet$Type$(Scope scope, Object base, long offset, $type$ expected, $type$ value) { + try { + return compareAndSet$Type$Internal(scope, base, offset, expected, value); + } catch (Scope.ScopedAccessError ex) { + throw new IllegalStateException("This segment is already closed"); + } + } + + @ForceInline @Scoped + private boolean compareAndSet$Type$Internal(Scope scope, Object base, long offset, $type$ expected, $type$ value) { + try { + if (scope != null) { + scope.checkValidState(); + } + return UNSAFE.compareAndSet$Type$(base, offset, expected, value); + } finally { + Reference.reachabilityFence(scope); + } + } + + @ForceInline + public $type$ compareAndExchange$Type$(Scope scope, Object base, long offset, $type$ expected, $type$ value) { + try { + return compareAndExchange$Type$Internal(scope, base, offset, expected, value); + } catch (Scope.ScopedAccessError ex) { + throw new IllegalStateException("This segment is already closed"); + } + } + + @ForceInline @Scoped + private $type$ compareAndExchange$Type$Internal(Scope scope, Object base, long offset, $type$ expected, $type$ value) { + try { + if (scope != null) { + scope.checkValidState(); + } + return UNSAFE.compareAndExchange$Type$(base, offset, expected, value); + } finally { + Reference.reachabilityFence(scope); + } + } + + @ForceInline + public $type$ compareAndExchange$Type$Acquire(Scope scope, Object base, long offset, $type$ expected, $type$ value) { + try { + return compareAndExchange$Type$AcquireInternal(scope, base, offset, expected, value); + } catch (Scope.ScopedAccessError ex) { + throw new IllegalStateException("This segment is already closed"); + } + } + + @ForceInline @Scoped + private $type$ compareAndExchange$Type$AcquireInternal(Scope scope, Object base, long offset, $type$ expected, $type$ value) { + try { + if (scope != null) { + scope.checkValidState(); + } + return UNSAFE.compareAndExchange$Type$Acquire(base, offset, expected, value); + } finally { + Reference.reachabilityFence(scope); + } + } + + @ForceInline + public $type$ compareAndExchange$Type$Release(Scope scope, Object base, long offset, $type$ expected, $type$ value) { + try { + return compareAndExchange$Type$ReleaseInternal(scope, base, offset, expected, value); + } catch (Scope.ScopedAccessError ex) { + throw new IllegalStateException("This segment is already closed"); + } + } + + @ForceInline @Scoped + private $type$ compareAndExchange$Type$ReleaseInternal(Scope scope, Object base, long offset, $type$ expected, $type$ value) { + try { + if (scope != null) { + scope.checkValidState(); + } + return UNSAFE.compareAndExchange$Type$Release(base, offset, expected, value); + } finally { + Reference.reachabilityFence(scope); + } + } + + @ForceInline + public boolean weakCompareAndSet$Type$Plain(Scope scope, Object base, long offset, $type$ expected, $type$ value) { + try { + return weakCompareAndSet$Type$PlainInternal(scope, base, offset, expected, value); + } catch (Scope.ScopedAccessError ex) { + throw new IllegalStateException("This segment is already closed"); + } + } + + @ForceInline @Scoped + private boolean weakCompareAndSet$Type$PlainInternal(Scope scope, Object base, long offset, $type$ expected, $type$ value) { + try { + if (scope != null) { + scope.checkValidState(); + } + return UNSAFE.weakCompareAndSet$Type$Plain(base, offset, expected, value); + } finally { + Reference.reachabilityFence(scope); + } + } + + @ForceInline + public boolean weakCompareAndSet$Type$(Scope scope, Object base, long offset, $type$ expected, $type$ value) { + try { + return weakCompareAndSet$Type$Internal(scope, base, offset, expected, value); + } catch (Scope.ScopedAccessError ex) { + throw new IllegalStateException("This segment is already closed"); + } + } + + @ForceInline @Scoped + private boolean weakCompareAndSet$Type$Internal(Scope scope, Object base, long offset, $type$ expected, $type$ value) { + try { + if (scope != null) { + scope.checkValidState(); + } + return UNSAFE.weakCompareAndSet$Type$(base, offset, expected, value); + } finally { + Reference.reachabilityFence(scope); + } + } + + @ForceInline + public boolean weakCompareAndSet$Type$Acquire(Scope scope, Object base, long offset, $type$ expected, $type$ value) { + try { + return weakCompareAndSet$Type$AcquireInternal(scope, base, offset, expected, value); + } catch (Scope.ScopedAccessError ex) { + throw new IllegalStateException("This segment is already closed"); + } + } + + @ForceInline @Scoped + private boolean weakCompareAndSet$Type$AcquireInternal(Scope scope, Object base, long offset, $type$ expected, $type$ value) { + try { + if (scope != null) { + scope.checkValidState(); + } + return UNSAFE.weakCompareAndSet$Type$Acquire(base, offset, expected, value); + } finally { + Reference.reachabilityFence(scope); + } + } + + @ForceInline + public boolean weakCompareAndSet$Type$Release(Scope scope, Object base, long offset, $type$ expected, $type$ value) { + try { + return weakCompareAndSet$Type$ReleaseInternal(scope, base, offset, expected, value); + } catch (Scope.ScopedAccessError ex) { + throw new IllegalStateException("This segment is already closed"); + } + } + + @ForceInline @Scoped + private boolean weakCompareAndSet$Type$ReleaseInternal(Scope scope, Object base, long offset, $type$ expected, $type$ value) { + try { + if (scope != null) { + scope.checkValidState(); + } + return UNSAFE.weakCompareAndSet$Type$Release(base, offset, expected, value); + } finally { + Reference.reachabilityFence(scope); + } + } + + @ForceInline + public $type$ getAndSet$Type$(Scope scope, Object base, long offset, $type$ value) { + try { + return getAndSet$Type$Internal(scope, base, offset, value); + } catch (Scope.ScopedAccessError ex) { + throw new IllegalStateException("This segment is already closed"); + } + } + + @ForceInline @Scoped + private $type$ getAndSet$Type$Internal(Scope scope, Object base, long offset, $type$ value) { + try { + if (scope != null) { + scope.checkValidState(); + } + return UNSAFE.getAndSet$Type$(base, offset, value); + } finally { + Reference.reachabilityFence(scope); + } + } + + @ForceInline + public $type$ getAndSet$Type$Acquire(Scope scope, Object base, long offset, $type$ value) { + try { + return getAndSet$Type$AcquireInternal(scope, base, offset, value); + } catch (Scope.ScopedAccessError ex) { + throw new IllegalStateException("This segment is already closed"); + } + } + + @ForceInline @Scoped + private $type$ getAndSet$Type$AcquireInternal(Scope scope, Object base, long offset, $type$ value) { + try { + if (scope != null) { + scope.checkValidState(); + } + return UNSAFE.getAndSet$Type$Acquire(base, offset, value); + } finally { + Reference.reachabilityFence(scope); + } + } + + @ForceInline + public $type$ getAndSet$Type$Release(Scope scope, Object base, long offset, $type$ value) { + try { + return getAndSet$Type$ReleaseInternal(scope, base, offset, value); + } catch (Scope.ScopedAccessError ex) { + throw new IllegalStateException("This segment is already closed"); + } + } + + @ForceInline @Scoped + private $type$ getAndSet$Type$ReleaseInternal(Scope scope, Object base, long offset, $type$ value) { + try { + if (scope != null) { + scope.checkValidState(); + } + return UNSAFE.getAndSet$Type$Release(base, offset, value); + } finally { + Reference.reachabilityFence(scope); + } + } +#end[CAS] + +#if[AtomicAdd] + @ForceInline + public $type$ getAndAdd$Type$(Scope scope, Object base, long offset, $type$ delta) { + try { + return getAndAdd$Type$Internal(scope, base, offset, delta); + } catch (Scope.ScopedAccessError ex) { + throw new IllegalStateException("This segment is already closed"); + } + } + + @ForceInline @Scoped + private $type$ getAndAdd$Type$Internal(Scope scope, Object base, long offset, $type$ delta) { + try { + if (scope != null) { + scope.checkValidState(); + } + return UNSAFE.getAndAdd$Type$(base, offset, delta); + } finally { + Reference.reachabilityFence(scope); + } + } + + @ForceInline + public $type$ getAndAdd$Type$Acquire(Scope scope, Object base, long offset, $type$ delta) { + try { + return getAndAdd$Type$AcquireInternal(scope, base, offset, delta); + } catch (Scope.ScopedAccessError ex) { + throw new IllegalStateException("This segment is already closed"); + } + } + + @ForceInline @Scoped + private $type$ getAndAdd$Type$AcquireInternal(Scope scope, Object base, long offset, $type$ delta) { + try { + if (scope != null) { + scope.checkValidState(); + } + return UNSAFE.getAndAdd$Type$Acquire(base, offset, delta); + } finally { + Reference.reachabilityFence(scope); + } + } + + @ForceInline + public $type$ getAndAdd$Type$Release(Scope scope, Object base, long offset, $type$ delta) { + try { + return getAndAdd$Type$ReleaseInternal(scope, base, offset, delta); + } catch (Scope.ScopedAccessError ex) { + throw new IllegalStateException("This segment is already closed"); + } + } + + @ForceInline @Scoped + private $type$ getAndAdd$Type$ReleaseInternal(Scope scope, Object base, long offset, $type$ delta) { + try { + if (scope != null) { + scope.checkValidState(); + } + return UNSAFE.getAndAdd$Type$Release(base, offset, delta); + } finally { + Reference.reachabilityFence(scope); + } + } +#end[AtomicAdd] + +#if[Bitwise] + @ForceInline + public $type$ getAndBitwiseOr$Type$(Scope scope, Object base, long offset, $type$ value) { + try { + return getAndBitwiseOr$Type$Internal(scope, base, offset, value); + } catch (Scope.ScopedAccessError ex) { + throw new IllegalStateException("This segment is already closed"); + } + } + + @ForceInline @Scoped + private $type$ getAndBitwiseOr$Type$Internal(Scope scope, Object base, long offset, $type$ value) { + try { + if (scope != null) { + scope.checkValidState(); + } + return UNSAFE.getAndBitwiseOr$Type$(base, offset, value); + } finally { + Reference.reachabilityFence(scope); + } + } + + @ForceInline + public $type$ getAndBitwiseOr$Type$Acquire(Scope scope, Object base, long offset, $type$ value) { + try { + return getAndBitwiseOr$Type$AcquireInternal(scope, base, offset, value); + } catch (Scope.ScopedAccessError ex) { + throw new IllegalStateException("This segment is already closed"); + } + } + + @ForceInline @Scoped + private $type$ getAndBitwiseOr$Type$AcquireInternal(Scope scope, Object base, long offset, $type$ value) { + try { + if (scope != null) { + scope.checkValidState(); + } + return UNSAFE.getAndBitwiseOr$Type$Acquire(base, offset, value); + } finally { + Reference.reachabilityFence(scope); + } + } + + @ForceInline + public $type$ getAndBitwiseOr$Type$Release(Scope scope, Object base, long offset, $type$ value) { + try { + return getAndBitwiseOr$Type$ReleaseInternal(scope, base, offset, value); + } catch (Scope.ScopedAccessError ex) { + throw new IllegalStateException("This segment is already closed"); + } + } + + @ForceInline @Scoped + private $type$ getAndBitwiseOr$Type$ReleaseInternal(Scope scope, Object base, long offset, $type$ value) { + try { + if (scope != null) { + scope.checkValidState(); + } + return UNSAFE.getAndBitwiseOr$Type$Release(base, offset, value); + } finally { + Reference.reachabilityFence(scope); + } + } + + @ForceInline + public $type$ getAndBitwiseAnd$Type$(Scope scope, Object base, long offset, $type$ value) { + try { + return getAndBitwiseAnd$Type$Internal(scope, base, offset, value); + } catch (Scope.ScopedAccessError ex) { + throw new IllegalStateException("This segment is already closed"); + } + } + + @ForceInline @Scoped + private $type$ getAndBitwiseAnd$Type$Internal(Scope scope, Object base, long offset, $type$ value) { + try { + if (scope != null) { + scope.checkValidState(); + } + return UNSAFE.getAndBitwiseAnd$Type$(base, offset, value); + } finally { + Reference.reachabilityFence(scope); + } + } + + @ForceInline + public $type$ getAndBitwiseAnd$Type$Acquire(Scope scope, Object base, long offset, $type$ value) { + try { + return getAndBitwiseAnd$Type$AcquireInternal(scope, base, offset, value); + } catch (Scope.ScopedAccessError ex) { + throw new IllegalStateException("This segment is already closed"); + } + } + + @ForceInline @Scoped + private $type$ getAndBitwiseAnd$Type$AcquireInternal(Scope scope, Object base, long offset, $type$ value) { + try { + if (scope != null) { + scope.checkValidState(); + } + return UNSAFE.getAndBitwiseAnd$Type$Acquire(base, offset, value); + } finally { + Reference.reachabilityFence(scope); + } + } + + @ForceInline + public $type$ getAndBitwiseAnd$Type$Release(Scope scope, Object base, long offset, $type$ value) { + try { + return getAndBitwiseAnd$Type$ReleaseInternal(scope, base, offset, value); + } catch (Scope.ScopedAccessError ex) { + throw new IllegalStateException("This segment is already closed"); + } + } + + @ForceInline @Scoped + private $type$ getAndBitwiseAnd$Type$ReleaseInternal(Scope scope, Object base, long offset, $type$ value) { + try { + if (scope != null) { + scope.checkValidState(); + } + return UNSAFE.getAndBitwiseAnd$Type$Release(base, offset, value); + } finally { + Reference.reachabilityFence(scope); + } + } + + @ForceInline + public $type$ getAndBitwiseXor$Type$(Scope scope, Object base, long offset, $type$ value) { + try { + return getAndBitwiseXor$Type$Internal(scope, base, offset, value); + } catch (Scope.ScopedAccessError ex) { + throw new IllegalStateException("This segment is already closed"); + } + } + + @ForceInline @Scoped + private $type$ getAndBitwiseXor$Type$Internal(Scope scope, Object base, long offset, $type$ value) { + try { + if (scope != null) { + scope.checkValidState(); + } + return UNSAFE.getAndBitwiseXor$Type$(base, offset, value); + } finally { + Reference.reachabilityFence(scope); + } + } + + @ForceInline + public $type$ getAndBitwiseXor$Type$Acquire(Scope scope, Object base, long offset, $type$ value) { + try { + return getAndBitwiseXor$Type$AcquireInternal(scope, base, offset, value); + } catch (Scope.ScopedAccessError ex) { + throw new IllegalStateException("This segment is already closed"); + } + } + + @ForceInline @Scoped + private $type$ getAndBitwiseXor$Type$AcquireInternal(Scope scope, Object base, long offset, $type$ value) { + try { + if (scope != null) { + scope.checkValidState(); + } + return UNSAFE.getAndBitwiseXor$Type$Acquire(base, offset, value); + } finally { + Reference.reachabilityFence(scope); + } + } + + @ForceInline + public $type$ getAndBitwiseXor$Type$Release(Scope scope, Object base, long offset, $type$ value) { + try { + return getAndBitwiseXor$Type$ReleaseInternal(scope, base, offset, value); + } catch (Scope.ScopedAccessError ex) { + throw new IllegalStateException("This segment is already closed"); + } + } + + @ForceInline @Scoped + private $type$ getAndBitwiseXor$Type$ReleaseInternal(Scope scope, Object base, long offset, $type$ value) { + try { + if (scope != null) { + scope.checkValidState(); + } + return UNSAFE.getAndBitwiseXor$Type$Release(base, offset, value); + } finally { + Reference.reachabilityFence(scope); + } + } +#end[Bitwise] diff --git a/src/java.base/share/classes/jdk/internal/misc/X-ScopedMemoryAccess.java.template b/src/java.base/share/classes/jdk/internal/misc/X-ScopedMemoryAccess.java.template new file mode 100644 index 0000000000000..9c7494dba3bf7 --- /dev/null +++ b/src/java.base/share/classes/jdk/internal/misc/X-ScopedMemoryAccess.java.template @@ -0,0 +1,239 @@ +/* + * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code 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 + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +package jdk.internal.misc; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; +import java.lang.ref.Reference; + +import jdk.internal.util.ArraysSupport; +import jdk.internal.vm.annotation.ForceInline; + + +/** + * This class defines low-level methods to access on-heap and off-heap memory. The methods in this class + * can be thought of as thin wrappers around methods provided in the {@link Unsafe} class. All the methods in this + * class, accept one or more {@link Scope} parameter, which is used to validate as to whether access to memory + * can be performed in a safe fashion - more specifically, to ensure that the memory being accessed has not + * already been released (which would result in a hard VM crash). + *

+ * Accessing and releasing memory from a single thread is not problematic - after all, a given thread cannot, + * at the same time, access a memory region and free it. But ensuring correctness of memory access + * when multiple threads are involved is much trickier, as there can be cases where a thread is accessing + * a memory region while another thread is releasing it. + *

+ * This class provides tools to manages races when multiple threads are accessing and/or releasing the same memory + * region concurrently. More specifically, when a thread wants to release a memory region, it should call the + * {@link #closeScope(jdk.internal.misc.ScopedMemoryAccess.Scope)} method provided by this class. This method initiates + * thread-local handshakes with all the other VM threads, which are then stopped one by one. If any thread is found + * accessing memory that is associated to the very scope object being closed, that thread execution is asynchronously + * interrupted with a {@link Scope.ScopedAccessError}. + *

+ * This synchronization strategy relies on the idea that accessing memory is atomic with respect to checking the + * validity of the scope associated with that memory region - that is, a thread that wants to perform memory access will be + * suspended either before a scope check or after the memory access. To ensure this atomicity, + * all methods in this class are marked with the special {@link Scoped} annotation, which is recognized by the VM, + * and used during the thread-local handshake to detect (and stop) threads performing potentially problematic memory access + * operations. Additionally, to make sure that the scope object(s) of the memory being accessed is always + * reachable during an access operation, all the methods in this class add reachability fences around the underlying + * unsafe access. + *

+ * This form of synchronization allows APIs to use plain memory access without any other form of synchronization + * which might be deemed to expensive; in other words, this approach prioritizes the performance of memory access over + * that of releasing a shared memory resource. + */ +public class ScopedMemoryAccess { + + private static Unsafe UNSAFE = Unsafe.getUnsafe(); + + private static native void registerNatives(); + static { + registerNatives(); + } + + public boolean closeScope(Scope scope) { + return closeScope0(scope, Scope.ScopedAccessError.INSTANCE); + } + + native boolean closeScope0(Scope scope, Scope.ScopedAccessError exception); + + private ScopedMemoryAccess() {} + + private static final ScopedMemoryAccess theScopedMemoryAccess = new ScopedMemoryAccess(); + + public static ScopedMemoryAccess getScopedMemoryAccess() { + return theScopedMemoryAccess; + } + + /** + * Scope interface used during scoped memory access operations. A scope can be thought of as an object + * which embodies the temporal checks associated with a given memory region. + */ + public interface Scope { + void checkValidState(); + + /** + * Error thrown when memory access fails because the memory has already been released. + * Note: for performance reasons, this exception is never created by client; instead a shared instance + * is thrown (sometimes, this instance can be thrown asynchronously inside VM code). For this reason, + * it is important for clients to always catch this exception and throw a regular exception instead + * (which contains full stack information). + */ + final class ScopedAccessError extends Error { + private ScopedAccessError() { + super("Attempt to access an already released memory resource", null, false, false); + } + static final long serialVersionUID = 1L; + + public static final ScopedAccessError INSTANCE = new ScopedAccessError(); + } + } + + @Target({ElementType.METHOD, ElementType.CONSTRUCTOR}) + @Retention(RetentionPolicy.RUNTIME) + @interface Scoped { } + + // bulk ops + + @ForceInline + public void copyMemory(Scope srcScope, Scope dstScope, + Object srcBase, long srcOffset, + Object destBase, long destOffset, + long bytes) { + try { + copyMemoryInternal(srcScope, dstScope, srcBase, srcOffset, destBase, destOffset, bytes); + } catch (Scope.ScopedAccessError ex) { + throw new IllegalStateException("This segment is already closed"); + } + } + + @ForceInline @Scoped + private void copyMemoryInternal(Scope srcScope, Scope dstScope, + Object srcBase, long srcOffset, + Object destBase, long destOffset, + long bytes) { + try { + if (srcScope != null) { + srcScope.checkValidState(); + } + if (dstScope != null) { + dstScope.checkValidState(); + } + UNSAFE.copyMemory(srcBase, srcOffset, destBase, destOffset, bytes); + } finally { + Reference.reachabilityFence(srcScope); + Reference.reachabilityFence(dstScope); + } + } + + @ForceInline + public void copySwapMemory(Scope srcScope, Scope dstScope, + Object srcBase, long srcOffset, + Object destBase, long destOffset, + long bytes, long elemSize) { + try { + copySwapMemoryInternal(srcScope, dstScope, srcBase, srcOffset, destBase, destOffset, bytes, elemSize); + } catch (Scope.ScopedAccessError ex) { + throw new IllegalStateException("This segment is already closed"); + } + } + + @ForceInline @Scoped + private void copySwapMemoryInternal(Scope srcScope, Scope dstScope, + Object srcBase, long srcOffset, + Object destBase, long destOffset, + long bytes, long elemSize) { + try { + if (srcScope != null) { + srcScope.checkValidState(); + } + if (dstScope != null) { + dstScope.checkValidState(); + } + UNSAFE.copySwapMemory(srcBase, srcOffset, destBase, destOffset, bytes, elemSize); + } finally { + Reference.reachabilityFence(srcScope); + Reference.reachabilityFence(dstScope); + } + } + + @ForceInline + public void setMemory(Scope scope, Object o, long offset, long bytes, byte value) { + try { + setMemoryInternal(scope, o, offset, bytes, value); + } catch (Scope.ScopedAccessError ex) { + throw new IllegalStateException("This segment is already closed"); + } + } + + @ForceInline @Scoped + private void setMemoryInternal(Scope scope, Object o, long offset, long bytes, byte value) { + try { + if (scope != null) { + scope.checkValidState(); + } + UNSAFE.setMemory(o, offset, bytes, value); + } finally { + Reference.reachabilityFence(scope); + } + } + + @ForceInline + public int vectorizedMismatch(Scope aScope, Scope bScope, + Object a, long aOffset, + Object b, long bOffset, + int length, + int log2ArrayIndexScale) { + try { + return vectorizedMismatchInternal(aScope, bScope, a, aOffset, b, bOffset, length, log2ArrayIndexScale); + } catch (Scope.ScopedAccessError ex) { + throw new IllegalStateException("This segment is already closed"); + } + } + + @ForceInline @Scoped + private int vectorizedMismatchInternal(Scope aScope, Scope bScope, + Object a, long aOffset, + Object b, long bOffset, + int length, + int log2ArrayIndexScale) { + try { + if (aScope != null) { + aScope.checkValidState(); + } + if (bScope != null) { + bScope.checkValidState(); + } + return ArraysSupport.vectorizedMismatch(a, aOffset, b, bOffset, length, log2ArrayIndexScale); + } finally { + Reference.reachabilityFence(aScope); + Reference.reachabilityFence(bScope); + } + } + // typed-ops here + diff --git a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/Addressable.java b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/Addressable.java new file mode 100644 index 0000000000000..15a62f5e02ee9 --- /dev/null +++ b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/Addressable.java @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code 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 + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +package jdk.incubator.foreign; + +/** + * Represents a type which is addressable. An addressable type is one which can be projected down to + * a memory address instance (see {@link #address()}). Examples of addressable types are {@link MemorySegment}, + * and {@link MemoryAddress}. + * + * @apiNote In the future, if the Java language permits, {@link Addressable} + * may become a {@code sealed} interface, which would prohibit subclassing except by + * explicitly permitted types, such as {@link MemorySegment} and {@link MemoryAddress}. + * + * @implSpec + * Implementations of this interface value-based. + */ +public interface Addressable { + /** + * Map this object into a {@link MemoryAddress} instance. + * @return the {@link MemoryAddress} instance associated with this object. + */ + MemoryAddress address(); +} diff --git a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MemoryAccess.java b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MemoryAccess.java new file mode 100644 index 0000000000000..e7bbc6fa10979 --- /dev/null +++ b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MemoryAccess.java @@ -0,0 +1,2078 @@ +/* + * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code 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 + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +package jdk.incubator.foreign; + +import jdk.internal.access.foreign.MemorySegmentProxy; +import jdk.internal.vm.annotation.ForceInline; + +import java.lang.invoke.VarHandle; +import java.nio.ByteOrder; + +/** + * This class defines ready-made static accessors which can be used to dereference memory segments in many ways. + *

+ * The most primitive accessors (see {@link #getIntAtOffset(MemorySegment, long)}) take a segment and an offset (expressed in bytes). + * The final address at which the dereference will occur will be computed by offsetting the base address by + * the specified offset, as if by calling {@link MemoryAddress#addOffset(long)} on the specified base address. + *

+ * In cases where no offset is required, overloads are provided (see {@link #getInt(MemorySegment)}) so that + * clients can omit the offset coordinate. + *

+ * To help dereferencing in array-like use cases (e.g. where the layout of a given memory segment is a sequence + * layout of given size an element count), higher-level overloads are also provided (see {@link #getIntAtIndex(MemorySegment, long)}), + * which take a segment and a logical element index. The formula to obtain the byte offset {@code O} from an + * index {@code I} is given by {@code O = I * S} where {@code S} is the size (expressed in bytes) of the element to + * be dereferenced. + */ +public final class MemoryAccess { + + private MemoryAccess() { + // just the one + } + + private static final VarHandle byte_LE_handle = indexedHandle(MemoryLayouts.BITS_8_LE, byte.class); + private static final VarHandle char_LE_handle = indexedHandle(MemoryLayouts.BITS_16_LE, char.class); + private static final VarHandle short_LE_handle = indexedHandle(MemoryLayouts.BITS_16_LE, short.class); + private static final VarHandle int_LE_handle = indexedHandle(MemoryLayouts.BITS_32_LE, int.class); + private static final VarHandle float_LE_handle = indexedHandle(MemoryLayouts.BITS_32_LE, float.class); + private static final VarHandle long_LE_handle = indexedHandle(MemoryLayouts.BITS_64_LE, long.class); + private static final VarHandle double_LE_handle = indexedHandle(MemoryLayouts.BITS_64_LE, double.class); + private static final VarHandle byte_BE_handle = indexedHandle(MemoryLayouts.BITS_8_BE, byte.class); + private static final VarHandle char_BE_handle = indexedHandle(MemoryLayouts.BITS_16_BE, char.class); + private static final VarHandle short_BE_handle = indexedHandle(MemoryLayouts.BITS_16_BE, short.class); + private static final VarHandle int_BE_handle = indexedHandle(MemoryLayouts.BITS_32_BE, int.class); + private static final VarHandle float_BE_handle = indexedHandle(MemoryLayouts.BITS_32_BE, float.class); + private static final VarHandle long_BE_handle = indexedHandle(MemoryLayouts.BITS_64_BE, long.class); + private static final VarHandle double_BE_handle = indexedHandle(MemoryLayouts.BITS_64_BE, double.class); + private static final VarHandle address_handle; + + static { + Class carrier = switch ((int) MemoryLayouts.ADDRESS.byteSize()) { + case 4 -> int.class; + case 8 -> long.class; + default -> throw new ExceptionInInitializerError("Unsupported pointer size: " + MemoryLayouts.ADDRESS.byteSize()); + }; + address_handle = MemoryHandles.asAddressVarHandle(indexedHandle(MemoryLayouts.ADDRESS, carrier)); + } + + /** + * Read a byte from given segment and offset, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    VarHandle handle = MemoryHandles.withStride(BITS_8_LE.withBitAlignment(8).varHandle(byte.class), 1L);
+    byte value = (byte)handle.get(segment, offset);
+     * }
+ * + * @param segment the segment to be dereferenced. + * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}. + * @return a byte value read from {@code segment}. + */ + public static byte getByteAtOffset_LE(MemorySegment segment, long offset) { + return (byte)byte_LE_handle.get(segment, offset); + } + + /** + * Writes a byte at given segment and offset, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    VarHandle handle = MemoryHandles.withStride(BITS_8_LE.withBitAlignment(8).varHandle(byte.class), 1L);
+    handle.set(segment, offset, value);
+     * }
+ * @param segment the segment to be dereferenced. + * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}. + * @param value the byte value to be written. + */ + public static void setByteAtOffset_LE(MemorySegment segment, long offset, byte value) { + byte_LE_handle.set(segment, offset, value); + } + + /** + * Read a char from given segment and offset, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    VarHandle handle = MemoryHandles.withStride(BITS_16_LE.withBitAlignment(8).varHandle(char.class), 1L);
+    char value = (char)handle.get(segment, offset);
+     * }
+ * @param segment the segment to be dereferenced. + * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}. + * @return a char value read from {@code segment}. + */ + public static char getCharAtOffset_LE(MemorySegment segment, long offset) { + return (char)char_LE_handle.get(segment, offset); + } + + /** + * Writes a char at given segment and offset, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    VarHandle handle = MemoryHandles.withStride(BITS_16_LE.withBitAlignment(8).varHandle(char.class), 1L);
+    handle.set(segment, offset, value);
+     * }
+ * @param segment the segment to be dereferenced. + * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}. + * @param value the char value to be written. + */ + public static void setCharAtOffset_LE(MemorySegment segment, long offset, char value) { + char_LE_handle.set(segment, offset, value); + } + + /** + * Read a short from given segment and offset, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    VarHandle handle = MemoryHandles.withStride(BITS_16_LE.withBitAlignment(8).varHandle(short.class), 1L);
+    short value = (short)handle.get(segment, offset);
+     * }
+ * @param segment the segment to be dereferenced. + * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}. + * @return a short value read from {@code segment}. + */ + public static short getShortAtOffset_LE(MemorySegment segment, long offset) { + return (short)short_LE_handle.get(segment, offset); + } + + /** + * Writes a short at given segment and offset, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    VarHandle handle = MemoryHandles.withStride(BITS_16_LE.withBitAlignment(8).varHandle(short.class), 1L);
+    handle.set(segment, offset, value);
+     * }
+ * @param segment the segment to be dereferenced. + * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}. + * @param value the short value to be written. + */ + public static void setShortAtOffset_LE(MemorySegment segment, long offset, short value) { + short_LE_handle.set(segment, offset, value); + } + + /** + * Read an int from given segment and offset, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    VarHandle handle = MemoryHandles.withStride(BITS_32_LE.withBitAlignment(8).varHandle(int.class), 1L);
+    int value = (int)handle.get(segment, offset);
+     * }
+ * @param segment the segment to be dereferenced. + * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}. + * @return an int value read from {@code segment}. + */ + public static int getIntAtOffset_LE(MemorySegment segment, long offset) { + return (int)int_LE_handle.get(segment, offset); + } + + /** + * Writes an int at given segment and offset, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    VarHandle handle = MemoryHandles.withStride(BITS_32_LE.withBitAlignment(8).varHandle(int.class), 1L);
+    handle.set(segment, offset, value);
+     * }
+ * @param segment the segment to be dereferenced. + * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}. + * @param value the int value to be written. + */ + public static void setIntAtOffset_LE(MemorySegment segment, long offset, int value) { + int_LE_handle.set(segment, offset, value); + } + + /** + * Read a float from given segment and offset, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    VarHandle handle = MemoryHandles.withStride(BITS_32_LE.withBitAlignment(8).varHandle(float.class), 1L);
+    float value = (float)handle.get(segment, offset);
+     * }
+ * @param segment the segment to be dereferenced. + * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}. + * @return a float value read from {@code segment}. + */ + public static float getFloatAtOffset_LE(MemorySegment segment, long offset) { + return (float)float_LE_handle.get(segment, offset); + } + + /** + * Writes a float at given segment and offset, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    VarHandle handle = MemoryHandles.withStride(BITS_32_LE.withBitAlignment(8).varHandle(float.class), 1L);
+    handle.set(segment, offset, value);
+     * }
+ * @param segment the segment to be dereferenced. + * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}. + * @param value the float value to be written. + */ + public static void setFloatAtOffset_LE(MemorySegment segment, long offset, float value) { + float_LE_handle.set(segment, offset, value); + } + + /** + * Read a long from given segment and offset, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    VarHandle handle = MemoryHandles.withStride(BITS_64_LE.withBitAlignment(8).varHandle(long.class), 1L);
+    long value = (long)handle.get(segment, offset);
+     * }
+ * @param segment the segment to be dereferenced. + * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}. + * @return a long value read from {@code segment}. + */ + public static long getLongAtOffset_LE(MemorySegment segment, long offset) { + return (long)long_LE_handle.get(segment, offset); + } + + /** + * Writes a long at given segment and offset, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    VarHandle handle = MemoryHandles.withStride(BITS_64_LE.withBitAlignment(8).varHandle(long.class), 1L);
+    handle.set(segment, offset, value);
+     * }
+ * @param segment the segment to be dereferenced. + * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}. + * @param value the long value to be written. + */ + public static void setLongAtOffset_LE(MemorySegment segment, long offset, long value) { + long_LE_handle.set(segment, offset, value); + } + + /** + * Read a double from given segment and offset, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    VarHandle handle = MemoryHandles.withStride(BITS_64_LE.withBitAlignment(8).varHandle(double.class), 1L);
+    double value = (double)handle.get(segment, offset);
+     * }
+ * @param segment the segment to be dereferenced. + * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}. + * @return a double value read from {@code segment}. + */ + public static double getDoubleAtOffset_LE(MemorySegment segment, long offset) { + return (double)double_LE_handle.get(segment, offset); + } + + /** + * Writes a double at given segment and offset, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    VarHandle handle = MemoryHandles.withStride(BITS_64_LE.withBitAlignment(8).varHandle(double.class), 1L);
+    handle.set(segment, offset, value);
+     * }
+ * @param segment the segment to be dereferenced. + * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}. + * @param value the double value to be written. + */ + public static void setDoubleAtOffset_LE(MemorySegment segment, long offset, double value) { + double_LE_handle.set(segment, offset, value); + } + + /** + * Read a byte from given segment and offset, with byte order set to {@link ByteOrder#BIG_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    VarHandle handle = MemoryHandles.withStride(BITS_8_BE.withBitAlignment(8).varHandle(byte.class), 1L);
+    byte value = (byte)handle.get(segment, offset);
+     * }
+ * + * @param segment the segment to be dereferenced. + * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}. + * @return a byte value read from {@code segment}. + */ + public static byte getByteAtOffset_BE(MemorySegment segment, long offset) { + return (byte)byte_BE_handle.get(segment, offset); + } + + /** + * Writes a byte at given segment and offset, with byte order set to {@link ByteOrder#BIG_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    VarHandle handle = MemoryHandles.withStride(BITS_8_BE.withBitAlignment(8).varHandle(byte.class), 1L);
+    handle.set(segment, offset, value);
+     * }
+ * @param segment the segment to be dereferenced. + * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}. + * @param value the byte value to be written. + */ + public static void setByteAtOffset_BE(MemorySegment segment, long offset, byte value) { + byte_BE_handle.set(segment, offset, value); + } + + /** + * Read a char from given segment and offset, with byte order set to {@link ByteOrder#BIG_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    VarHandle handle = MemoryHandles.withStride(BITS_16_BE.withBitAlignment(8).varHandle(char.class), 1L);
+    char value = (char)handle.get(segment, offset);
+     * }
+ * @param segment the segment to be dereferenced. + * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}. + * @return a char value read from {@code segment}. + */ + public static char getCharAtOffset_BE(MemorySegment segment, long offset) { + return (char)char_BE_handle.get(segment, offset); + } + + /** + * Writes a char at given segment and offset, with byte order set to {@link ByteOrder#BIG_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    VarHandle handle = MemoryHandles.withStride(BITS_16_BE.withBitAlignment(8).varHandle(char.class), 1L);
+    handle.set(segment, offset, value);
+     * }
+ * @param segment the segment to be dereferenced. + * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}. + * @param value the char value to be written. + */ + public static void setCharAtOffset_BE(MemorySegment segment, long offset, char value) { + char_BE_handle.set(segment, offset, value); + } + + /** + * Read a short from given segment and offset, with byte order set to {@link ByteOrder#BIG_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    VarHandle handle = MemoryHandles.withStride(BITS_16_BE.withBitAlignment(8).varHandle(short.class), 1L);
+    short value = (short)handle.get(segment, offset);
+     * }
+ * @param segment the segment to be dereferenced. + * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}. + * @return a short value read from {@code segment}. + */ + public static short getShortAtOffset_BE(MemorySegment segment, long offset) { + return (short)short_BE_handle.get(segment, offset); + } + + /** + * Writes a short at given segment and offset, with byte order set to {@link ByteOrder#BIG_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    VarHandle handle = MemoryHandles.withStride(BITS_16_BE.withBitAlignment(8).varHandle(short.class), 1L);
+    handle.set(segment, offset, value);
+     * }
+ * @param segment the segment to be dereferenced. + * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}. + * @param value the short value to be written. + */ + public static void setShortAtOffset_BE(MemorySegment segment, long offset, short value) { + short_BE_handle.set(segment, offset, value); + } + + /** + * Read an int from given segment and offset, with byte order set to {@link ByteOrder#BIG_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    VarHandle handle = MemoryHandles.withStride(BITS_32_BE.withBitAlignment(8).varHandle(int.class), 1L);
+    int value = (int)handle.get(segment, offset);
+     * }
+ * @param segment the segment to be dereferenced. + * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}. + * @return an int value read from {@code segment}. + */ + public static int getIntAtOffset_BE(MemorySegment segment, long offset) { + return (int)int_BE_handle.get(segment, offset); + } + + /** + * Writes an int at given segment and offset, with byte order set to {@link ByteOrder#BIG_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    VarHandle handle = MemoryHandles.withStride(BITS_32_BE.withBitAlignment(8).varHandle(int.class), 1L);
+    handle.set(segment, offset, value);
+     * }
+ * @param segment the segment to be dereferenced. + * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}. + * @param value the int value to be written. + */ + public static void setIntAtOffset_BE(MemorySegment segment, long offset, int value) { + int_BE_handle.set(segment, offset, value); + } + + /** + * Read a float from given segment and offset, with byte order set to {@link ByteOrder#BIG_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    VarHandle handle = MemoryHandles.withStride(BITS_32_BE.withBitAlignment(8).varHandle(float.class), 1L);
+    float value = (float)handle.get(segment, offset);
+     * }
+ * @param segment the segment to be dereferenced. + * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}. + * @return a float value read from {@code segment}. + */ + public static float getFloatAtOffset_BE(MemorySegment segment, long offset) { + return (float)float_BE_handle.get(segment, offset); + } + + /** + * Writes a float at given segment and offset, with byte order set to {@link ByteOrder#BIG_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    VarHandle handle = MemoryHandles.withStride(BITS_32_BE.withBitAlignment(8).varHandle(float.class), 1L);
+    handle.set(segment, offset, value);
+     * }
+ * @param segment the segment to be dereferenced. + * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}. + * @param value the float value to be written. + */ + public static void setFloatAtOffset_BE(MemorySegment segment, long offset, float value) { + float_BE_handle.set(segment, offset, value); + } + + /** + * Read a long from given segment and offset, with byte order set to {@link ByteOrder#BIG_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    VarHandle handle = MemoryHandles.withStride(BITS_64_BE.withBitAlignment(8).varHandle(long.class), 1L);
+    long value = (long)handle.get(segment, offset);
+     * }
+ * @param segment the segment to be dereferenced. + * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}. + * @return a long value read from {@code segment}. + */ + public static long getLongAtOffset_BE(MemorySegment segment, long offset) { + return (long)long_BE_handle.get(segment, offset); + } + + /** + * Writes a long at given segment and offset, with byte order set to {@link ByteOrder#BIG_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    VarHandle handle = MemoryHandles.withStride(BITS_64_BE.withBitAlignment(8).varHandle(long.class), 1L);
+    handle.set(segment, offset, value);
+     * }
+ * @param segment the segment to be dereferenced. + * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}. + * @param value the long value to be written. + */ + public static void setLongAtOffset_BE(MemorySegment segment, long offset, long value) { + long_BE_handle.set(segment, offset, value); + } + + /** + * Read a double from given segment and offset, with byte order set to {@link ByteOrder#BIG_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    VarHandle handle = MemoryHandles.withStride(BITS_64_BE.withBitAlignment(8).varHandle(double.class), 1L);
+    double value = (double)handle.get(segment, offset);
+     * }
+ * @param segment the segment to be dereferenced. + * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}. + * @return a double value read from {@code segment}. + */ + public static double getDoubleAtOffset_BE(MemorySegment segment, long offset) { + return (double)double_BE_handle.get(segment, offset); + } + + /** + * Writes a double at given segment and offset, with byte order set to {@link ByteOrder#BIG_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    VarHandle handle = MemoryHandles.withStride(BITS_64_BE.withBitAlignment(8).varHandle(double.class), 1L);
+    handle.set(segment, offset, value);
+     * }
+ * @param segment the segment to be dereferenced. + * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}. + * @param value the double value to be written. + */ + public static void setDoubleAtOffset_BE(MemorySegment segment, long offset, double value) { + double_BE_handle.set(segment, offset, value); + } + + /** + * Read a byte from given segment and offset, with byte order set to {@link ByteOrder#nativeOrder()}. + *

+ * This is equivalent to the following code: + * 

{@code
+    VarHandle handle = MemoryHandles.withStride(JAVA_BYTE.withBitAlignment(8).varHandle(byte.class), 1L);
+    byte value = (byte)handle.get(segment, offset);
+     * }
+ * + * @param segment the segment to be dereferenced. + * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}. + * @return a byte value read from {@code segment}. + */ + public static byte getByteAtOffset(MemorySegment segment, long offset) { + return (byte)((ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN) ? byte_BE_handle : byte_LE_handle).get(segment, offset); + } + + /** + * Writes a byte at given segment and offset, with byte order set to {@link ByteOrder#nativeOrder()}. + *

+ * This is equivalent to the following code: + * 

{@code
+    VarHandle handle = MemoryHandles.withStride(JAVA_BYTE.withBitAlignment(8).varHandle(byte.class), 1L);
+    handle.set(segment, offset, value);
+     * }
+ * @param segment the segment to be dereferenced. + * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}. + * @param value the byte value to be written. + */ + public static void setByteAtOffset(MemorySegment segment, long offset, byte value) { + ((ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN) ? byte_BE_handle : byte_LE_handle).set(segment, offset, value); + } + + /** + * Read a char from given segment and offset, with byte order set to {@link ByteOrder#nativeOrder()}. + *

+ * This is equivalent to the following code: + * 

{@code
+    VarHandle handle = MemoryHandles.withStride(JAVA_CHAR.withBitAlignment(8).varHandle(char.class), 1L);
+    char value = (char)handle.get(segment, offset);
+     * }
+ * @param segment the segment to be dereferenced. + * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}. + * @return a char value read from {@code segment}. + */ + public static char getCharAtOffset(MemorySegment segment, long offset) { + return (char)((ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN) ? char_BE_handle : char_LE_handle).get(segment, offset); + } + + /** + * Writes a char at given segment and offset, with byte order set to {@link ByteOrder#nativeOrder()}. + *

+ * This is equivalent to the following code: + * 

{@code
+    VarHandle handle = MemoryHandles.withStride(JAVA_CHAR.withBitAlignment(8).varHandle(char.class), 1L);
+    handle.set(segment, offset, value);
+     * }
+ * @param segment the segment to be dereferenced. + * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}. + * @param value the char value to be written. + */ + public static void setCharAtOffset(MemorySegment segment, long offset, char value) { + ((ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN) ? char_BE_handle : char_LE_handle).set(segment, offset, value); + } + + /** + * Read a short from given segment and offset, with byte order set to {@link ByteOrder#nativeOrder()}. + *

+ * This is equivalent to the following code: + * 

{@code
+    VarHandle handle = MemoryHandles.withStride(JAVA_SHORT.withBitAlignment(8).varHandle(short.class), 1L);
+    short value = (short)handle.get(segment, offset);
+     * }
+ * @param segment the segment to be dereferenced. + * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}. + * @return a short value read from {@code segment}. + */ + public static short getShortAtOffset(MemorySegment segment, long offset) { + return (short)((ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN) ? short_BE_handle : short_LE_handle).get(segment, offset); + } + + /** + * Writes a short at given segment and offset, with byte order set to {@link ByteOrder#nativeOrder()}. + *

+ * This is equivalent to the following code: + * 

{@code
+    VarHandle handle = MemoryHandles.withStride(JAVA_SHORT.withBitAlignment(8).varHandle(short.class), 1L);
+    handle.set(segment, offset, value);
+     * }
+ * @param segment the segment to be dereferenced. + * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}. + * @param value the short value to be written. + */ + public static void setShortAtOffset(MemorySegment segment, long offset, short value) { + ((ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN) ? short_BE_handle : short_LE_handle).set(segment, offset, value); + } + + /** + * Read an int from given segment and offset, with byte order set to {@link ByteOrder#nativeOrder()}. + *

+ * This is equivalent to the following code: + * 

{@code
+    VarHandle handle = MemoryHandles.withStride(JAVA_INT.withBitAlignment(8).varHandle(int.class), 1L);
+    int value = (int)handle.get(segment, offset);
+     * }
+ * @param segment the segment to be dereferenced. + * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}. + * @return an int value read from {@code segment}. + */ + public static int getIntAtOffset(MemorySegment segment, long offset) { + return (int)((ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN) ? int_BE_handle : int_LE_handle).get(segment, offset); + } + + /** + * Writes an int at given segment and offset, with byte order set to {@link ByteOrder#nativeOrder()}. + *

+ * This is equivalent to the following code: + * 

{@code
+    VarHandle handle = MemoryHandles.withStride(JAVA_INT.withBitAlignment(8).varHandle(int.class), 1L);
+    handle.set(segment, offset, value);
+     * }
+ * @param segment the segment to be dereferenced. + * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}. + * @param value the int value to be written. + */ + public static void setIntAtOffset(MemorySegment segment, long offset, int value) { + ((ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN) ? int_BE_handle : int_LE_handle).set(segment, offset, value); + } + + /** + * Read a float from given segment and offset, with byte order set to {@link ByteOrder#nativeOrder()}. + *

+ * This is equivalent to the following code: + * 

{@code
+    VarHandle handle = MemoryHandles.withStride(JAVA_FLOAT.withBitAlignment(8).varHandle(float.class), 1L);
+    float value = (float)handle.get(segment, offset);
+     * }
+ * @param segment the segment to be dereferenced. + * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}. + * @return a float value read from {@code segment}. + */ + public static float getFloatAtOffset(MemorySegment segment, long offset) { + return (float)((ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN) ? float_BE_handle : float_LE_handle).get(segment, offset); + } + + /** + * Writes a float at given segment and offset, with byte order set to {@link ByteOrder#nativeOrder()}. + *

+ * This is equivalent to the following code: + * 

{@code
+    VarHandle handle = MemoryHandles.withStride(JAVA_FLOAT.withBitAlignment(8).varHandle(float.class), 1L);
+    handle.set(segment, offset, value);
+     * }
+ * @param segment the segment to be dereferenced. + * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}. + * @param value the float value to be written. + */ + public static void setFloatAtOffset(MemorySegment segment, long offset, float value) { + ((ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN) ? float_BE_handle : float_LE_handle).set(segment, offset, value); + } + + /** + * Read a long from given segment and offset, with byte order set to {@link ByteOrder#nativeOrder()}. + *

+ * This is equivalent to the following code: + * 

{@code
+    VarHandle handle = MemoryHandles.withStride(JAVA_LONG.withBitAlignment(8).varHandle(long.class), 1L);
+    long value = (long)handle.get(segment, offset);
+     * }
+ * @param segment the segment to be dereferenced. + * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}. + * @return a long value read from {@code segment}. + */ + public static long getLongAtOffset(MemorySegment segment, long offset) { + return (long)((ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN) ? long_BE_handle : long_LE_handle).get(segment, offset); + } + + /** + * Writes a long at given segment and offset, with byte order set to {@link ByteOrder#nativeOrder()}. + *

+ * This is equivalent to the following code: + * 

{@code
+    VarHandle handle = MemoryHandles.withStride(JAVA_LONG.withBitAlignment(8).varHandle(long.class), 1L);
+    handle.set(segment, offset, value);
+     * }
+ * @param segment the segment to be dereferenced. + * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}. + * @param value the long value to be written. + */ + public static void setLongAtOffset(MemorySegment segment, long offset, long value) { + ((ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN) ? long_BE_handle : long_LE_handle).set(segment, offset, value); + } + + /** + * Read a double from given segment and offset, with byte order set to {@link ByteOrder#nativeOrder()}. + *

+ * This is equivalent to the following code: + * 

{@code
+    VarHandle handle = MemoryHandles.withStride(JAVA_DOUBLE.withBitAlignment(8).varHandle(double.class), 1L);
+    double value = (double)handle.get(segment, offset);
+     * }
+ * @param segment the segment to be dereferenced. + * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}. + * @return a double value read from {@code segment}. + */ + public static double getDoubleAtOffset(MemorySegment segment, long offset) { + return (double)((ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN) ? double_BE_handle : double_LE_handle).get(segment, offset); + } + + /** + * Writes a double at given segment and offset, with byte order set to {@link ByteOrder#nativeOrder()}. + *

+ * This is equivalent to the following code: + * 

{@code
+    VarHandle handle = MemoryHandles.withStride(JAVA_DOUBLE.withBitAlignment(8).varHandle(double.class), 1L);
+    handle.set(segment, offset, value);
+     * }
+ * @param segment the segment to be dereferenced. + * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}. + * @param value the double value to be written. + */ + public static void setDoubleAtOffset(MemorySegment segment, long offset, double value) { + ((ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN) ? double_BE_handle : double_LE_handle).set(segment, offset, value); + } + + /** + * Read a memory address from given segment and offset, with byte order set to {@link ByteOrder#nativeOrder()}. + *

+ * This is equivalent to the following code: + * 

{@code
+    VarHandle handle = MemoryHandles.asAddressHandle(MemoryHandles.withStride(JAVA_LONG.withBitAlignment(8).varHandle(long.class), 1L));
+    MemoryAddress value = (MemoryAddress)handle.get(segment, offset);
+     * }
+ * @param segment the segment to be dereferenced. + * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}. + * @return a memory address read from {@code segment}. + */ + public static MemoryAddress getAddressAtOffset(MemorySegment segment, long offset) { + return (MemoryAddress)address_handle.get(segment, offset); + } + + /** + * Writes a memory address at given segment and offset, with byte order set to {@link ByteOrder#nativeOrder()}. + *

+ * This is equivalent to the following code: + * 

{@code
+    VarHandle handle = MemoryHandles.asAddressHandle(MemoryHandles.withStride(JAVA_LONG.withBitAlignment(8).varHandle(long.class), 1L));
+    handle.set(segment, offset, value.address());
+     * }
+ * @param segment the segment to be dereferenced. + * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}. + * @param value the memory address to be written (expressed as an {@link Addressable} instance). + */ + public static void setAddressAtOffset(MemorySegment segment, long offset, Addressable value) { + address_handle.set(segment, offset, value.address()); + } + + private static VarHandle indexedHandle(ValueLayout elementLayout, Class carrier) { + return MemoryHandles.varHandle(carrier, 1, elementLayout.order()); + } + + /** + * Read a byte from given segment, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    byte value = getByteAtOffset_LE(segment, 0L);
+     * }
+ * + * @param segment the segment to be dereferenced. + * @return a byte value read from {@code segment}. + */ + public static byte getByte_LE(MemorySegment segment) { + return getByteAtOffset_LE(segment, 0L); + } + + /** + * Writes a byte at given segment, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    setByteAtOffset_LE(segment, 0L, value);
+     * }
+ * @param segment the segment to be dereferenced. + * @param value the byte value to be written. + */ + public static void setByte_LE(MemorySegment segment, byte value) { + setByteAtOffset_LE(segment, 0L, value); + } + + /** + * Read a char from given segment, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    char value = getCharAtOffset_LE(segment, 0L);
+     * }
+ * @param segment the segment to be dereferenced. + * @return a char value read from {@code segment}. + */ + public static char getChar_LE(MemorySegment segment) { + return getCharAtOffset_LE(segment, 0L); + } + + /** + * Writes a char at given segment, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    setCharAtOffset_LE(segment, 0L, value);
+     * }
+ * @param segment the segment to be dereferenced. + * @param value the char value to be written. + */ + public static void setChar_LE(MemorySegment segment, char value) { + setCharAtOffset_LE(segment, 0L, value); + } + + /** + * Read a short from given segment, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    short value = getShortAtOffset_LE(segment, 0L);
+     * }
+ * @param segment the segment to be dereferenced. + * @return a short value read from {@code segment}. + */ + public static short getShort_LE(MemorySegment segment) { + return getShortAtOffset_LE(segment, 0L); + } + + /** + * Writes a short at given segment, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    setShortAtOffset_LE(segment, 0L, value);
+     * }
+ * @param segment the segment to be dereferenced. + * @param value the short value to be written. + */ + public static void setShort_LE(MemorySegment segment, short value) { + setShortAtOffset_LE(segment, 0L, value); + } + + /** + * Read an int from given segment, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    int value = getIntAtOffset_LE(segment, 0L);
+     * }
+ * @param segment the segment to be dereferenced. + * @return an int value read from {@code segment}. + */ + public static int getInt_LE(MemorySegment segment) { + return getIntAtOffset_LE(segment, 0L); + } + + /** + * Writes an int at given segment, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    setIntAtOffset_LE(segment, 0L, value);
+     * }
+ * @param segment the segment to be dereferenced. + * @param value the int value to be written. + */ + public static void setInt_LE(MemorySegment segment, int value) { + setIntAtOffset_LE(segment, 0L, value); + } + + /** + * Read a float from given segment, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    float value = getFloatAtOffset_LE(segment, 0L);
+     * }
+ * @param segment the segment to be dereferenced. + * @return a float value read from {@code segment}. + */ + public static float getFloat_LE(MemorySegment segment) { + return getFloatAtOffset_LE(segment, 0L); + } + + /** + * Writes a float at given segment, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    setFloatAtOffset_LE(segment, 0L, value);
+     * }
+ * @param segment the segment to be dereferenced. + * @param value the float value to be written. + */ + public static void setFloat_LE(MemorySegment segment, float value) { + setFloatAtOffset_LE(segment, 0L, value); + } + + /** + * Read a long from given segment, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    long value = getLongAtOffset_LE(segment, 0L);
+     * }
+ * @param segment the segment to be dereferenced. + * @return a long value read from {@code segment}. + */ + public static long getLong_LE(MemorySegment segment) { + return getLongAtOffset_LE(segment, 0L); + } + + /** + * Writes a long at given segment, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    setLongAtOffset_LE(segment, 0L, value);
+     * }
+ * @param segment the segment to be dereferenced. + * @param value the long value to be written. + */ + public static void setLong_LE(MemorySegment segment, long value) { + setLongAtOffset_LE(segment, 0L, value); + } + + /** + * Read a double from given segment, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    double value = getDoubleAtOffset_LE(segment, 0L);
+     * }
+ * @param segment the segment to be dereferenced. + * @return a double value read from {@code segment}. + */ + public static double getDouble_LE(MemorySegment segment) { + return getDoubleAtOffset_LE(segment, 0L); + } + + /** + * Writes a double at given segment, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    setDoubleAtOffset_LE(segment, 0L, value);
+     * }
+ * @param segment the segment to be dereferenced. + * @param value the double value to be written. + */ + public static void setDouble_LE(MemorySegment segment, double value) { + setDoubleAtOffset_LE(segment, 0L, value); + } + + /** + * Read a byte from given segment, with byte order set to {@link ByteOrder#BIG_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    byte value = getByteAtOffset_BE(segment, 0L);
+     * }
+ * + * @param segment the segment to be dereferenced. + * @return a byte value read from {@code segment}. + */ + public static byte getByte_BE(MemorySegment segment) { + return getByteAtOffset_BE(segment, 0L); + } + + /** + * Writes a byte at given segment, with byte order set to {@link ByteOrder#BIG_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    setByteAtOffset_BE(segment, 0L, value);
+     * }
+ * @param segment the segment to be dereferenced. + * @param value the byte value to be written. + */ + public static void setByte_BE(MemorySegment segment, byte value) { + setByteAtOffset_BE(segment, 0L, value); + } + + /** + * Read a char from given segment, with byte order set to {@link ByteOrder#BIG_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    char value = getCharAtOffset_BE(segment, 0L);
+     * }
+ * @param segment the segment to be dereferenced. + * @return a char value read from {@code segment}. + */ + public static char getChar_BE(MemorySegment segment) { + return getCharAtOffset_BE(segment, 0L); + } + + /** + * Writes a char at given segment, with byte order set to {@link ByteOrder#BIG_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    setCharAtOffset_BE(segment, 0L, value);
+     * }
+ * @param segment the segment to be dereferenced. + * @param value the char value to be written. + */ + public static void setChar_BE(MemorySegment segment, char value) { + setCharAtOffset_BE(segment, 0L, value); + } + + /** + * Read a short from given segment, with byte order set to {@link ByteOrder#BIG_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    short value = getShortAtOffset_BE(segment, 0L);
+     * }
+ * @param segment the segment to be dereferenced. + * @return a short value read from {@code segment}. + */ + public static short getShort_BE(MemorySegment segment) { + return getShortAtOffset_BE(segment, 0L); + } + + /** + * Writes a short at given segment, with byte order set to {@link ByteOrder#BIG_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    setShortAtOffset_BE(segment, 0L, value);
+     * }
+ * @param segment the segment to be dereferenced. + * @param value the short value to be written. + */ + public static void setShort_BE(MemorySegment segment, short value) { + setShortAtOffset_BE(segment, 0L, value); + } + + /** + * Read an int from given segment, with byte order set to {@link ByteOrder#BIG_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    int value = getIntAtOffset_BE(segment, 0L);
+     * }
+ * @param segment the segment to be dereferenced. + * @return an int value read from {@code segment}. + */ + public static int getInt_BE(MemorySegment segment) { + return getIntAtOffset_BE(segment, 0L); + } + + /** + * Writes an int at given segment, with byte order set to {@link ByteOrder#BIG_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    setIntAtOffset_BE(segment, 0L, value);
+     * }
+ * @param segment the segment to be dereferenced. + * @param value the int value to be written. + */ + public static void setInt_BE(MemorySegment segment, int value) { + setIntAtOffset_BE(segment, 0L, value); + } + + /** + * Read a float from given segment, with byte order set to {@link ByteOrder#BIG_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    float value = getFloatAtOffset_BE(segment, 0L);
+     * }
+ * @param segment the segment to be dereferenced. + * @return a float value read from {@code segment}. + */ + public static float getFloat_BE(MemorySegment segment) { + return getFloatAtOffset_BE(segment, 0L); + } + + /** + * Writes a float at given segment, with byte order set to {@link ByteOrder#BIG_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    setFloatAtOffset_BE(segment, 0L, value);
+     * }
+ * @param segment the segment to be dereferenced. + * @param value the float value to be written. + */ + public static void setFloat_BE(MemorySegment segment, float value) { + setFloatAtOffset_BE(segment, 0L, value); + } + + /** + * Read a long from given segment, with byte order set to {@link ByteOrder#BIG_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    long value = getLongAtOffset_BE(segment, 0L);
+     * }
+ * @param segment the segment to be dereferenced. + * @return a long value read from {@code segment}. + */ + public static long getLong_BE(MemorySegment segment) { + return getLongAtOffset_BE(segment, 0L); + } + + /** + * Writes a long at given segment, with byte order set to {@link ByteOrder#BIG_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    setLongAtOffset_BE(segment, 0L, value);
+     * }
+ * @param segment the segment to be dereferenced. + * @param value the long value to be written. + */ + public static void setLong_BE(MemorySegment segment, long value) { + setLongAtOffset_BE(segment, 0L, value); + } + + /** + * Read a double from given segment, with byte order set to {@link ByteOrder#BIG_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    double value = getDoubleAtOffset_BE(segment, 0L);
+     * }
+ * @param segment the segment to be dereferenced. + * @return a double value read from {@code segment}. + */ + public static double getDouble_BE(MemorySegment segment) { + return getDoubleAtOffset_BE(segment, 0L); + } + + /** + * Writes a double at given segment, with byte order set to {@link ByteOrder#BIG_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    setDoubleAtOffset_BE(segment, 0L, value);
+     * }
+ * @param segment the segment to be dereferenced. + * @param value the double value to be written. + */ + public static void setDouble_BE(MemorySegment segment, double value) { + setDoubleAtOffset_BE(segment, 0L, value); + } + + /** + * Read a byte from given segment, with byte order set to {@link ByteOrder#nativeOrder()}. + *

+ * This is equivalent to the following code: + * 

{@code
+    byte value = getByteAtOffset(segment, 0L);
+     * }
+ * + * @param segment the segment to be dereferenced. + * @return a byte value read from {@code segment}. + */ + public static byte getByte(MemorySegment segment) { + return getByteAtOffset(segment, 0L); + } + + /** + * Writes a byte at given segment, with byte order set to {@link ByteOrder#nativeOrder()}. + *

+ * This is equivalent to the following code: + * 

{@code
+    setByteAtOffset(segment, 0L, value);
+     * }
+ * @param segment the segment to be dereferenced. + * @param value the byte value to be written. + */ + public static void setByte(MemorySegment segment, byte value) { + setByteAtOffset(segment, 0L, value); + } + + /** + * Read a char from given segment, with byte order set to {@link ByteOrder#nativeOrder()}. + *

+ * This is equivalent to the following code: + * 

{@code
+    char value = getCharAtOffset(segment, 0L);
+     * }
+ * @param segment the segment to be dereferenced. + * @return a char value read from {@code segment}. + */ + public static char getChar(MemorySegment segment) { + return getCharAtOffset(segment, 0L); + } + + /** + * Writes a char at given segment, with byte order set to {@link ByteOrder#nativeOrder()}. + *

+ * This is equivalent to the following code: + * 

{@code
+    setCharAtOffset(segment, 0L, value);
+     * }
+ * @param segment the segment to be dereferenced. + * @param value the char value to be written. + */ + public static void setChar(MemorySegment segment, char value) { + setCharAtOffset(segment, 0L, value); + } + + /** + * Read a short from given segment, with byte order set to {@link ByteOrder#nativeOrder()}. + *

+ * This is equivalent to the following code: + * 

{@code
+    short value = getShortAtOffset(segment, 0L);
+     * }
+ * @param segment the segment to be dereferenced. + * @return a short value read from {@code segment}. + */ + public static short getShort(MemorySegment segment) { + return getShortAtOffset(segment, 0L); + } + + /** + * Writes a short at given segment, with byte order set to {@link ByteOrder#nativeOrder()}. + *

+ * This is equivalent to the following code: + * 

{@code
+    setShortAtOffset(segment, 0L, value);
+     * }
+ * @param segment the segment to be dereferenced. + * @param value the short value to be written. + */ + public static void setShort(MemorySegment segment, short value) { + setShortAtOffset(segment, 0L, value); + } + + /** + * Read an int from given segment, with byte order set to {@link ByteOrder#nativeOrder()}. + *

+ * This is equivalent to the following code: + * 

{@code
+    int value = getIntAtOffset(segment, 0L);
+     * }
+ * @param segment the segment to be dereferenced. + * @return an int value read from {@code segment}. + */ + public static int getInt(MemorySegment segment) { + return getIntAtOffset(segment, 0L); + } + + /** + * Writes an int at given segment, with byte order set to {@link ByteOrder#nativeOrder()}. + *

+ * This is equivalent to the following code: + * 

{@code
+    setIntAtOffset(segment, 0L, value);
+     * }
+ * @param segment the segment to be dereferenced. + * @param value the int value to be written. + */ + public static void setInt(MemorySegment segment, int value) { + setIntAtOffset(segment, 0L, value); + } + + /** + * Read a float from given segment, with byte order set to {@link ByteOrder#nativeOrder()}. + *

+ * This is equivalent to the following code: + * 

{@code
+    float value = getFloatAtOffset(segment, 0L);
+     * }
+ * @param segment the segment to be dereferenced. + * @return a float value read from {@code segment}. + */ + public static float getFloat(MemorySegment segment) { + return getFloatAtOffset(segment, 0L); + } + + /** + * Writes a float at given segment, with byte order set to {@link ByteOrder#nativeOrder()}. + *

+ * This is equivalent to the following code: + * 

{@code
+    setFloatAtOffset(segment, 0L, value);
+     * }
+ * @param segment the segment to be dereferenced. + * @param value the float value to be written. + */ + public static void setFloat(MemorySegment segment, float value) { + setFloatAtOffset(segment, 0L, value); + } + + /** + * Read a long from given segment, with byte order set to {@link ByteOrder#nativeOrder()}. + *

+ * This is equivalent to the following code: + * 

{@code
+    long value = getLongAtOffset(segment, 0L);
+     * }
+ * @param segment the segment to be dereferenced. + * @return a long value read from {@code segment}. + */ + public static long getLong(MemorySegment segment) { + return getLongAtOffset(segment, 0L); + } + + /** + * Writes a long at given segment, with byte order set to {@link ByteOrder#nativeOrder()}. + *

+ * This is equivalent to the following code: + * 

{@code
+    setLongAtOffset(segment, 0L, value);
+     * }
+ * @param segment the segment to be dereferenced. + * @param value the long value to be written. + */ + public static void setLong(MemorySegment segment, long value) { + setLongAtOffset(segment, 0L, value); + } + + /** + * Read a double from given segment, with byte order set to {@link ByteOrder#nativeOrder()}. + *

+ * This is equivalent to the following code: + * 

{@code
+    double value = getDoubleAtOffset(segment, 0L);
+     * }
+ * @param segment the segment to be dereferenced. + * @return a double value read from {@code segment}. + */ + public static double getDouble(MemorySegment segment) { + return getDoubleAtOffset(segment, 0L); + } + + /** + * Writes a double at given segment, with byte order set to {@link ByteOrder#nativeOrder()}. + *

+ * This is equivalent to the following code: + * 

{@code
+    setDoubleAtOffset(segment, 0L, value);
+     * }
+ * @param segment the segment to be dereferenced. + * @param value the double value to be written. + */ + public static void setDouble(MemorySegment segment, double value) { + setDoubleAtOffset(segment, 0L, value); + } + + /** + * Read a memory address from given segment, with byte order set to {@link ByteOrder#nativeOrder()}. + *

+ * This is equivalent to the following code: + * 

{@code
+    MemoryAddress value = getAddressAtOffset(segment, 0L);
+     * }
+ * @param segment the segment to be dereferenced. + * @return a memory address read from {@code segment}. + */ + public static MemoryAddress getAddress(MemorySegment segment) { + return getAddressAtOffset(segment, 0L); + } + + /** + * Writes a memory address at given segment, with byte order set to {@link ByteOrder#nativeOrder()}. + *

+ * This is equivalent to the following code: + * 

{@code
+    setAddressAtOffset(segment, 0L, value);
+     * }
+ * @param segment the segment to be dereferenced. + * @param value the memory address to be written (expressed as an {@link Addressable} instance). + */ + public static void setAddress(MemorySegment segment, Addressable value) { + setAddressAtOffset(segment, 0L, value); + } + + /** + * Read a byte from given segment and element index, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    byte value = getByteAtOffset_LE(segment, index);
+     * }
+ * + * @param segment the segment to be dereferenced. + * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index)}. + * @return a byte value read from {@code segment} at the element index specified by {@code index}. + */ + public static byte getByteAtIndex_LE(MemorySegment segment, long index) { + return getByteAtOffset_LE(segment, index); + } + + /** + * Writes a byte at given segment and element index, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    setByteAtOffset_LE(segment, index, value);
+     * }
+ * @param segment the segment to be dereferenced. + * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index)}. + * @param value the byte value to be written. + */ + public static void setByteAtIndex_LE(MemorySegment segment, long index, byte value) { + setByteAtOffset_LE(segment, index, value); + } + + /** + * Read a char from given segment and element index, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    char value = getCharAtOffset_LE(segment, 2 * index);
+     * }
+ * @param segment the segment to be dereferenced. + * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 2)}. + * @return a char value read from {@code segment} at the element index specified by {@code index}. + */ + public static char getCharAtIndex_LE(MemorySegment segment, long index) { + return getCharAtOffset_LE(segment, scale(segment, index, 2)); + } + + /** + * Writes a char at given segment and element index, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    setCharAtOffset_LE(segment, 2 * index, value);
+     * }
+ * @param segment the segment to be dereferenced. + * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 2)}. + * @param value the char value to be written. + */ + public static void setCharAtIndex_LE(MemorySegment segment, long index, char value) { + setCharAtOffset_LE(segment, scale(segment, index, 2), value); + } + + /** + * Read a short from given segment and element index, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    short value = getShortAtOffset_LE(segment, 2 * index);
+     * }
+ * @param segment the segment to be dereferenced. + * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 2)}. + * @return a short value read from {@code segment} at the element index specified by {@code index}. + */ + public static short getShortAtIndex_LE(MemorySegment segment, long index) { + return getShortAtOffset_LE(segment, scale(segment, index, 2)); + } + + /** + * Writes a short at given segment and element index, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    setShortAtOffset_LE(segment, 2 * index, value);
+     * }
+ * @param segment the segment to be dereferenced. + * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 2)}. + * @param value the short value to be written. + */ + public static void setShortAtIndex_LE(MemorySegment segment, long index, short value) { + setShortAtOffset_LE(segment, scale(segment, index, 2), value); + } + + /** + * Read an int from given segment and element index, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    int value = getIntAtOffset_LE(segment, 4 * index);
+     * }
+ * @param segment the segment to be dereferenced. + * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 4)}. + * @return an int value read from {@code segment} at the element index specified by {@code index}. + */ + public static int getIntAtIndex_LE(MemorySegment segment, long index) { + return getIntAtOffset_LE(segment, scale(segment, index, 4)); + } + + /** + * Writes an int at given segment and element index, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    setIntAtOffset_LE(segment, 4 * index, value);
+     * }
+ * @param segment the segment to be dereferenced. + * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 4)}. + * @param value the int value to be written. + */ + public static void setIntAtIndex_LE(MemorySegment segment, long index, int value) { + setIntAtOffset_LE(segment, scale(segment, index, 4), value); + } + + /** + * Read a float from given segment and element index, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    float value = getFloatAtOffset_LE(segment, 4 * index);
+     * }
+ * @param segment the segment to be dereferenced. + * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 4)}. + * @return a float value read from {@code segment} at the element index specified by {@code index}. + */ + public static float getFloatAtIndex_LE(MemorySegment segment, long index) { + return getFloatAtOffset_LE(segment, scale(segment, index, 4)); + } + + /** + * Writes a float at given segment and element index, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    setFloatAtOffset_LE(segment, 4 * index, value);
+     * }
+ * @param segment the segment to be dereferenced. + * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 4)}. + * @param value the float value to be written. + */ + public static void setFloatAtIndex_LE(MemorySegment segment, long index, float value) { + setFloatAtOffset_LE(segment, scale(segment, index, 4), value); + } + + /** + * Read a long from given segment and element index, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    return getLongAtOffset_LE(segment, 8 * index);
+     * }
+ * @param segment the segment to be dereferenced. + * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 8)}. + * @return a long value read from {@code segment} at the element index specified by {@code index}. + */ + public static long getLongAtIndex_LE(MemorySegment segment, long index) { + return getLongAtOffset_LE(segment, scale(segment, index, 8)); + } + + /** + * Writes a long at given segment and element index, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    setLongAtOffset_LE(segment, 8 * index, value);
+     * }
+ * @param segment the segment to be dereferenced. + * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 8)}. + * @param value the long value to be written. + */ + public static void setLongAtIndex_LE(MemorySegment segment, long index, long value) { + setLongAtOffset_LE(segment, scale(segment, index, 8), value); + } + + /** + * Read a double from given segment and element index, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    return getDoubleAtOffset_LE(segment, 8 * index);
+     * }
+ * @param segment the segment to be dereferenced. + * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 8)}. + * @return a double value read from {@code segment} at the element index specified by {@code index}. + */ + public static double getDoubleAtIndex_LE(MemorySegment segment, long index) { + return getDoubleAtOffset_LE(segment, scale(segment, index, 8)); + } + + /** + * Writes a double at given segment and element index, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    setDoubleAtOffset_LE(segment, 8 * index, value);
+     * }
+ * @param segment the segment to be dereferenced. + * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 8)}. + * @param value the double value to be written. + */ + public static void setDoubleAtIndex_LE(MemorySegment segment, long index, double value) { + setDoubleAtOffset_LE(segment, scale(segment, index, 8), value); + } + + /** + * Read a byte from given segment and element index, with byte order set to {@link ByteOrder#BIG_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    byte value = getByteAtOffset_BE(segment, index);
+     * }
+ * + * @param segment the segment to be dereferenced. + * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index)}. + * @return a byte value read from {@code segment} at the element index specified by {@code index}. + */ + public static byte getByteAtIndex_BE(MemorySegment segment, long index) { + return getByteAtOffset_BE(segment, index); + } + + /** + * Writes a byte at given segment and element index, with byte order set to {@link ByteOrder#BIG_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    setByteAtOffset_BE(segment, index, value);
+     * }
+ * @param segment the segment to be dereferenced. + * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index)}. + * @param value the byte value to be written. + */ + public static void setByteAtIndex_BE(MemorySegment segment, long index, byte value) { + setByteAtOffset_BE(segment, index, value); + } + + /** + * Read a char from given segment and element index, with byte order set to {@link ByteOrder#BIG_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    char value = getCharAtOffset_BE(segment, 2 * index);
+     * }
+ * @param segment the segment to be dereferenced. + * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 2)}. + * @return a char value read from {@code segment} at the element index specified by {@code index}. + */ + public static char getCharAtIndex_BE(MemorySegment segment, long index) { + return getCharAtOffset_BE(segment, scale(segment, index, 2)); + } + + /** + * Writes a char at given segment and element index, with byte order set to {@link ByteOrder#BIG_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    setCharAtOffset_BE(segment, 2 * index, value);
+     * }
+ * @param segment the segment to be dereferenced. + * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 2)}. + * @param value the char value to be written. + */ + public static void setCharAtIndex_BE(MemorySegment segment, long index, char value) { + setCharAtOffset_BE(segment, scale(segment, index, 2), value); + } + + /** + * Read a short from given segment and element index, with byte order set to {@link ByteOrder#BIG_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    short value = getShortAtOffset_BE(segment, 2 * index);
+     * }
+ * @param segment the segment to be dereferenced. + * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 2)}. + * @return a short value read from {@code segment} at the element index specified by {@code index}. + */ + public static short getShortAtIndex_BE(MemorySegment segment, long index) { + return getShortAtOffset_BE(segment, scale(segment, index, 2)); + } + + /** + * Writes a short at given segment and element index, with byte order set to {@link ByteOrder#BIG_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    setShortAtOffset_BE(segment, 2 * index, value);
+     * }
+ * @param segment the segment to be dereferenced. + * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 2)}. + * @param value the short value to be written. + */ + public static void setShortAtIndex_BE(MemorySegment segment, long index, short value) { + setShortAtOffset_BE(segment, scale(segment, index, 2), value); + } + + /** + * Read an int from given segment and element index, with byte order set to {@link ByteOrder#BIG_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    int value = getIntAtOffset_BE(segment, 4 * index);
+     * }
+ * @param segment the segment to be dereferenced. + * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 4)}. + * @return an int value read from {@code segment} at the element index specified by {@code index}. + */ + public static int getIntAtIndex_BE(MemorySegment segment, long index) { + return getIntAtOffset_BE(segment, scale(segment, index, 4)); + } + + /** + * Writes an int at given segment and element index, with byte order set to {@link ByteOrder#BIG_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    setIntAtOffset_BE(segment, 4 * index, value);
+     * }
+ * @param segment the segment to be dereferenced. + * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 4)}. + * @param value the int value to be written. + */ + public static void setIntAtIndex_BE(MemorySegment segment, long index, int value) { + setIntAtOffset_BE(segment, scale(segment, index, 4), value); + } + + /** + * Read a float from given segment and element index, with byte order set to {@link ByteOrder#BIG_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    float value = getFloatAtOffset_BE(segment, 4 * index);
+     * }
+ * @param segment the segment to be dereferenced. + * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 4)}. + * @return a float value read from {@code segment} at the element index specified by {@code index}. + */ + public static float getFloatAtIndex_BE(MemorySegment segment, long index) { + return getFloatAtOffset_BE(segment, scale(segment, index, 4)); + } + + /** + * Writes a float at given segment and element index, with byte order set to {@link ByteOrder#BIG_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    setFloatAtOffset_BE(segment, 4 * index, value);
+     * }
+ * @param segment the segment to be dereferenced. + * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 4)}. + * @param value the float value to be written. + */ + public static void setFloatAtIndex_BE(MemorySegment segment, long index, float value) { + setFloatAtOffset_BE(segment, scale(segment, index, 4), value); + } + + /** + * Read a long from given segment and element index, with byte order set to {@link ByteOrder#BIG_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    return getLongAtOffset_BE(segment, 8 * index);
+     * }
+ * @param segment the segment to be dereferenced. + * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 8)}. + * @return a long value read from {@code segment} at the element index specified by {@code index}. + */ + public static long getLongAtIndex_BE(MemorySegment segment, long index) { + return getLongAtOffset_BE(segment, scale(segment, index, 8)); + } + + /** + * Writes a long at given segment and element index, with byte order set to {@link ByteOrder#BIG_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    setLongAtOffset_BE(segment, 8 * index, value);
+     * }
+ * @param segment the segment to be dereferenced. + * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 8)}. + * @param value the long value to be written. + */ + public static void setLongAtIndex_BE(MemorySegment segment, long index, long value) { + setLongAtOffset_BE(segment, scale(segment, index, 8), value); + } + + /** + * Read a double from given segment and element index, with byte order set to {@link ByteOrder#BIG_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    return getDoubleAtOffset_BE(segment, 8 * index);
+     * }
+ * @param segment the segment to be dereferenced. + * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 8)}. + * @return a double value read from {@code segment} at the element index specified by {@code index}. + */ + public static double getDoubleAtIndex_BE(MemorySegment segment, long index) { + return getDoubleAtOffset_BE(segment, scale(segment, index, 8)); + } + + /** + * Writes a double at given segment and element index, with byte order set to {@link ByteOrder#BIG_ENDIAN}. + *

+ * This is equivalent to the following code: + * 

{@code
+    setDoubleAtOffset_BE(segment, 8 * index, value);
+     * }
+ * @param segment the segment to be dereferenced. + * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 8)}. + * @param value the double value to be written. + */ + public static void setDoubleAtIndex_BE(MemorySegment segment, long index, double value) { + setDoubleAtOffset_BE(segment, scale(segment, index, 8), value); + } + + /** + * Read a byte from given segment and element index, with byte order set to {@link ByteOrder#nativeOrder()}. + *

+ * This is equivalent to the following code: + * 

{@code
+    byte value = getByteAtOffset(segment, index);
+     * }
+ * + * @param segment the segment to be dereferenced. + * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index)}. + * @return a byte value read from {@code segment} at the element index specified by {@code index}. + */ + public static byte getByteAtIndex(MemorySegment segment, long index) { + return getByteAtOffset(segment, index); + } + + /** + * Writes a byte at given segment and element index, with byte order set to {@link ByteOrder#nativeOrder()}. + *

+ * This is equivalent to the following code: + * 

{@code
+    setByteAtOffset(segment, index, value);
+     * }
+ * @param segment the segment to be dereferenced. + * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index)}. + * @param value the byte value to be written. + */ + public static void setByteAtIndex(MemorySegment segment, long index, byte value) { + setByteAtOffset(segment, index, value); + } + + /** + * Read a char from given segment and element index, with byte order set to {@link ByteOrder#nativeOrder()}. + *

+ * This is equivalent to the following code: + * 

{@code
+    char value = getCharAtOffset(segment, 2 * index);
+     * }
+ * @param segment the segment to be dereferenced. + * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 2)}. + * @return a char value read from {@code segment} at the element index specified by {@code index}. + */ + public static char getCharAtIndex(MemorySegment segment, long index) { + return getCharAtOffset(segment, scale(segment, index, 2)); + } + + /** + * Writes a char at given segment and element index, with byte order set to {@link ByteOrder#nativeOrder()}. + *

+ * This is equivalent to the following code: + * 

{@code
+    setCharAtOffset(segment, 2 * index, value);
+     * }
+ * @param segment the segment to be dereferenced. + * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 2)}. + * @param value the char value to be written. + */ + public static void setCharAtIndex(MemorySegment segment, long index, char value) { + setCharAtOffset(segment, scale(segment, index, 2), value); + } + + /** + * Read a short from given segment and element index, with byte order set to {@link ByteOrder#nativeOrder()}. + *

+ * This is equivalent to the following code: + * 

{@code
+    short value = getShortAtOffset(segment, 2 * index);
+     * }
+ * @param segment the segment to be dereferenced. + * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 2)}. + * @return a short value read from {@code segment} at the element index specified by {@code index}. + */ + public static short getShortAtIndex(MemorySegment segment, long index) { + return getShortAtOffset(segment, scale(segment, index, 2)); + } + + /** + * Writes a short at given segment and element index, with byte order set to {@link ByteOrder#nativeOrder()}. + *

+ * This is equivalent to the following code: + * 

{@code
+    setShortAtOffset(segment, 2 * index, value);
+     * }
+ * @param segment the segment to be dereferenced. + * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 2)}. + * @param value the short value to be written. + */ + public static void setShortAtIndex(MemorySegment segment, long index, short value) { + setShortAtOffset(segment, scale(segment, index, 2), value); + } + + /** + * Read an int from given segment and element index, with byte order set to {@link ByteOrder#nativeOrder()}. + *

+ * This is equivalent to the following code: + * 

{@code
+    int value = getIntAtOffset(segment, 4 * index);
+     * }
+ * @param segment the segment to be dereferenced. + * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 4)}. + * @return an int value read from {@code segment} at the element index specified by {@code index}. + */ + public static int getIntAtIndex(MemorySegment segment, long index) { + return getIntAtOffset(segment, scale(segment, index, 4)); + } + + /** + * Writes an int at given segment and element index, with byte order set to {@link ByteOrder#nativeOrder()}. + *

+ * This is equivalent to the following code: + * 

{@code
+    setIntAtOffset(segment, 4 * index, value);
+     * }
+ * @param segment the segment to be dereferenced. + * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 4)}. + * @param value the int value to be written. + */ + public static void setIntAtIndex(MemorySegment segment, long index, int value) { + setIntAtOffset(segment, scale(segment, index, 4), value); + } + + /** + * Read a float from given segment and element index, with byte order set to {@link ByteOrder#nativeOrder()}. + *

+ * This is equivalent to the following code: + * 

{@code
+    float value = getFloatAtOffset(segment, 4 * index);
+     * }
+ * @param segment the segment to be dereferenced. + * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 4)}. + * @return a float value read from {@code segment} at the element index specified by {@code index}. + */ + public static float getFloatAtIndex(MemorySegment segment, long index) { + return getFloatAtOffset(segment, scale(segment, index, 4)); + } + + /** + * Writes a float at given segment and element index, with byte order set to {@link ByteOrder#nativeOrder()}. + *

+ * This is equivalent to the following code: + * 

{@code
+    setFloatAtOffset(segment, 4 * index, value);
+     * }
+ * @param segment the segment to be dereferenced. + * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 4)}. + * @param value the float value to be written. + */ + public static void setFloatAtIndex(MemorySegment segment, long index, float value) { + setFloatAtOffset(segment, scale(segment, index, 4), value); + } + + /** + * Read a long from given segment and element index, with byte order set to {@link ByteOrder#nativeOrder()}. + *

+ * This is equivalent to the following code: + * 

{@code
+    return getLongAtOffset(segment, 8 * index);
+     * }
+ * @param segment the segment to be dereferenced. + * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 8)}. + * @return a long value read from {@code segment} at the element index specified by {@code index}. + */ + public static long getLongAtIndex(MemorySegment segment, long index) { + return getLongAtOffset(segment, scale(segment, index, 8)); + } + + /** + * Writes a long at given segment and element index, with byte order set to {@link ByteOrder#nativeOrder()}. + *

+ * This is equivalent to the following code: + * 

{@code
+    setLongAtOffset(segment, 8 * index, value);
+     * }
+ * @param segment the segment to be dereferenced. + * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 8)}. + * @param value the long value to be written. + */ + public static void setLongAtIndex(MemorySegment segment, long index, long value) { + setLongAtOffset(segment, scale(segment, index, 8), value); + } + + /** + * Read a double from given segment and element index, with byte order set to {@link ByteOrder#nativeOrder()}. + *

+ * This is equivalent to the following code: + * 

{@code
+    return getDoubleAtOffset(segment, 8 * index);
+     * }
+ * @param segment the segment to be dereferenced. + * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 8)}. + * @return a double value read from {@code segment} at the element index specified by {@code index}. + */ + public static double getDoubleAtIndex(MemorySegment segment, long index) { + return getDoubleAtOffset(segment, scale(segment, index, 8)); + } + + /** + * Writes a double at given segment and element index, with byte order set to {@link ByteOrder#nativeOrder()}. + *

+ * This is equivalent to the following code: + * 

{@code
+    setDoubleAtOffset(segment, 8 * index, value);
+     * }
+ * @param segment the segment to be dereferenced. + * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 8)}. + * @param value the double value to be written. + */ + public static void setDoubleAtIndex(MemorySegment segment, long index, double value) { + setDoubleAtOffset(segment, scale(segment, index, 8), value); + } + + /** + * Read a memory address from given segment and element index, with byte order set to {@link ByteOrder#nativeOrder()}. + *

+ * This is equivalent to the following code: + * 

{@code
+    return getAddressAtOffset(segment, index * 8);
+     * }
+ * @param segment the segment to be dereferenced. + * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 8)}. + * @return a memory address read from {@code segment} at the element index specified by {@code index}. + */ + public static MemoryAddress getAddressAtIndex(MemorySegment segment, long index) { + return getAddressAtOffset(segment, scale(segment, index, 8)); + } + + /** + * Writes a memory address at given segment and element index, with byte order set to {@link ByteOrder#nativeOrder()}. + *

+ * This is equivalent to the following code: + * 

{@code
+    setAddressAtOffset(segment, index * 8, value);
+     * }
+ * @param segment the segment to be dereferenced. + * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 8)}. + * @param value the memory address to be written (expressed as an {@link Addressable} instance). + */ + public static void setAddressAtIndex(MemorySegment segment, long index, Addressable value) { + setAddressAtOffset(segment, scale(segment, index, 8), value); + } + + @ForceInline + private static long scale(MemorySegment address, long index, int size) { + return MemorySegmentProxy.multiplyOffsets(index, size, (MemorySegmentProxy)address); + } +} diff --git a/test/jdk/java/foreign/TestCleaner.java b/test/jdk/java/foreign/TestCleaner.java new file mode 100644 index 0000000000000..c14f12f8b9c18 --- /dev/null +++ b/test/jdk/java/foreign/TestCleaner.java @@ -0,0 +1,191 @@ +/* + * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code 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 + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/* + * @test + * @modules java.base/jdk.internal.ref + * jdk.incubator.foreign/jdk.incubator.foreign + * @run testng/othervm -Dforeign.restricted=permit TestCleaner + */ + +import jdk.incubator.foreign.MemorySegment; +import java.lang.ref.Cleaner; +import jdk.internal.ref.CleanerFactory; + +import org.testng.annotations.DataProvider; +import org.testng.annotations.Test; +import static org.testng.Assert.*; + +import java.util.concurrent.atomic.AtomicInteger; +import java.util.function.Function; +import java.util.function.Supplier; +import java.util.stream.Stream; + +public class TestCleaner { + + static class SegmentState { + private AtomicInteger cleanupCalls = new AtomicInteger(0); + + void cleanup() { + cleanupCalls.incrementAndGet(); + } + + int cleanupCalls() { + return cleanupCalls.get(); + } + } + + @Test(dataProvider = "cleaners") + public void testAtMostOnce(RegisterKind registerKind, Supplier cleanerFactory, SegmentFunction segmentFunction) { + SegmentState segmentState = new SegmentState(); + MemorySegment root = MemorySegment.allocateNative(10).share(); + MemorySegment segment = root.address().asSegmentRestricted(10, () -> { + root.close(); + segmentState.cleanup(); + }, null); + + if (registerKind == RegisterKind.BEFORE) { + // register cleaners before + segment = segment.registerCleaner(cleanerFactory.get()); + } + + kickGCAndCheck(segmentState, segment); + + segment = segmentFunction.apply(segment); + + kickGCAndCheck(segmentState, segment); + + if (segment.isAlive() && registerKind == RegisterKind.AFTER) { + // register cleaners after + segment = segment.registerCleaner(cleanerFactory.get()); + } + + kickGCAndCheck(segmentState, segment); + segment = null; + while (segmentState.cleanupCalls() == 0) { + byte[] b = new byte[100]; + System.gc(); + try { + Thread.sleep(10); + } catch (InterruptedException ex) { + throw new AssertionError(ex); + } + } + assertEquals(segmentState.cleanupCalls(), 1); + } + + private void kickGCAndCheck(SegmentState segmentState, MemorySegment segment) { + for (int i = 0 ; i < 100 ; i++) { + byte[] b = new byte[100]; + System.gc(); + Thread.onSpinWait(); + } + //check that cleanup has not been called by any cleaner yet! + assertEquals(segmentState.cleanupCalls(), segment.isAlive() ? 0 : 1); + } + + @Test(dataProvider = "segmentFunctions") + public void testBadDoubleRegister(Supplier cleanerFactory, SegmentFunction segmentFunction) { + MemorySegment segment = MemorySegment.allocateNative(10); + segment = segment.registerCleaner(cleanerFactory.get()); + segment = segmentFunction.apply(segment); + try { + segment.registerCleaner(cleanerFactory.get()); // error here! + fail(); + } catch (IllegalStateException ex) { + if (!segment.isAlive()) { + assertTrue(ex.getMessage().contains("This segment is already closed")); + } else { + assertTrue(ex.getMessage().contains("Already registered with a cleaner")); + } + } + } + + enum SegmentFunction implements Function { + IDENTITY(Function.identity()), + CLOSE(s -> { s.close(); return s; }), + SHARE(s -> { return s.share(); }); + + private final Function segmentFunction; + + SegmentFunction(Function segmentFunction) { + this.segmentFunction = segmentFunction; + } + + @Override + public MemorySegment apply(MemorySegment segment) { + return segmentFunction.apply(segment); + } + } + + @DataProvider + static Object[][] segmentFunctions() { + Supplier[] cleaners = { + (Supplier)Cleaner::create, + (Supplier)CleanerFactory::cleaner + }; + + SegmentFunction[] segmentFunctions = SegmentFunction.values(); + Object[][] data = new Object[cleaners.length * segmentFunctions.length][3]; + + for (int cleaner = 0 ; cleaner < cleaners.length ; cleaner++) { + for (int segmentFunction = 0 ; segmentFunction < segmentFunctions.length ; segmentFunction++) { + data[cleaner + (cleaners.length * segmentFunction)] = + new Object[] { cleaners[cleaner], segmentFunctions[segmentFunction] }; + } + } + + return data; + } + + enum RegisterKind { + BEFORE, + AFTER; + } + + @DataProvider + static Object[][] cleaners() { + Supplier[] cleaners = { + (Supplier)Cleaner::create, + (Supplier)CleanerFactory::cleaner + }; + + RegisterKind[] kinds = RegisterKind.values(); + + SegmentFunction[] segmentFunctions = SegmentFunction.values(); + Object[][] data = new Object[cleaners.length * kinds.length * segmentFunctions.length][3]; + + for (int kind = 0 ; kind < kinds.length ; kind++) { + for (int cleaner = 0 ; cleaner < cleaners.length ; cleaner++) { + for (int segmentFunction = 0 ; segmentFunction < segmentFunctions.length ; segmentFunction++) { + data[kind + kinds.length * cleaner + (cleaners.length * kinds.length * segmentFunction)] = + new Object[] { kinds[kind], cleaners[cleaner], segmentFunctions[segmentFunction] }; + } + } + } + + return data; + } +} diff --git a/test/jdk/java/foreign/TestHandshake.java b/test/jdk/java/foreign/TestHandshake.java new file mode 100644 index 0000000000000..5ff40ae6e2ada --- /dev/null +++ b/test/jdk/java/foreign/TestHandshake.java @@ -0,0 +1,244 @@ +/* + * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code 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 + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/* + * @test + * @modules jdk.incubator.foreign java.base/jdk.internal.vm.annotation java.base/jdk.internal.misc + * @key randomness + * @run testng/othervm TestHandshake + * @run testng/othervm -Xint TestHandshake + * @run testng/othervm -XX:TieredStopAtLevel=1 TestHandshake + * @run testng/othervm -XX:-TieredCompilation TestHandshake + */ + +import jdk.incubator.foreign.MemoryAccess; +import jdk.incubator.foreign.MemorySegment; + +import java.lang.invoke.MethodHandles; +import java.lang.invoke.VarHandle; +import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.ThreadLocalRandom; +import java.util.concurrent.TimeUnit; +import java.util.function.Function; + +import org.testng.annotations.DataProvider; +import org.testng.annotations.Test; +import static org.testng.Assert.*; + +public class TestHandshake { + + static final int ITERATIONS = 5; + static final int SEGMENT_SIZE = 1_000_000; + static final int MAX_DELAY_MILLIS = 500; + static final int MAX_EXECUTOR_WAIT_SECONDS = 10; + static final int MAX_THREAD_SPIN_WAIT_MILLIS = 200; + + @Test(dataProvider = "accessors") + public void testHandshake(Function accessorFactory) throws InterruptedException { + for (int it = 0 ; it < ITERATIONS ; it++) { + MemorySegment segment = MemorySegment.allocateNative(SEGMENT_SIZE).share(); + System.err.println("ITERATION " + it); + ExecutorService accessExecutor = Executors.newCachedThreadPool(); + for (int i = 0; i < Runtime.getRuntime().availableProcessors() ; i++) { + accessExecutor.execute(accessorFactory.apply(segment)); + } + Thread.sleep(ThreadLocalRandom.current().nextInt(MAX_DELAY_MILLIS)); + accessExecutor.execute(new Handshaker(segment)); + accessExecutor.shutdown(); + assertTrue(accessExecutor.awaitTermination(MAX_EXECUTOR_WAIT_SECONDS, TimeUnit.SECONDS)); + assertTrue(!segment.isAlive()); + } + } + + static abstract class AbstractSegmentAccessor implements Runnable { + final MemorySegment segment; + + AbstractSegmentAccessor(MemorySegment segment) { + this.segment = segment; + } + + @Override + public final void run() { + outer: while (segment.isAlive()) { + try { + doAccess(); + } catch (IllegalStateException ex) { + backoff(); + continue outer; + } + } + } + + abstract void doAccess(); + + private void backoff() { + try { + Thread.sleep(ThreadLocalRandom.current().nextInt(MAX_THREAD_SPIN_WAIT_MILLIS)); + } catch (InterruptedException ex) { + throw new AssertionError(ex); + } + } + } + + static abstract class AbstractBufferAccessor extends AbstractSegmentAccessor { + final ByteBuffer bb; + + AbstractBufferAccessor(MemorySegment segment) { + super(segment); + this.bb = segment.asByteBuffer(); + } + } + + static class SegmentAccessor extends AbstractSegmentAccessor { + + SegmentAccessor(MemorySegment segment) { + super(segment); + } + + @Override + void doAccess() { + int sum = 0; + for (int i = 0; i < segment.byteSize(); i++) { + sum += MemoryAccess.getByteAtIndex(segment, i); + } + } + } + + static class SegmentCopyAccessor extends AbstractSegmentAccessor { + + MemorySegment first, second; + + + SegmentCopyAccessor(MemorySegment segment) { + super(segment); + long split = segment.byteSize() / 2; + first = segment.asSlice(0, split); + second = segment.asSlice(split); + } + + @Override + public void doAccess() { + first.copyFrom(second); + } + } + + static class SegmentFillAccessor extends AbstractSegmentAccessor { + + SegmentFillAccessor(MemorySegment segment) { + super(segment); + } + + @Override + public void doAccess() { + segment.fill((byte) ThreadLocalRandom.current().nextInt(10)); + } + } + + static class SegmentMismatchAccessor extends AbstractSegmentAccessor { + + final MemorySegment copy; + + SegmentMismatchAccessor(MemorySegment segment) { + super(segment); + this.copy = MemorySegment.allocateNative(SEGMENT_SIZE).share(); + copy.copyFrom(segment); + MemoryAccess.setByteAtIndex(copy, ThreadLocalRandom.current().nextInt(SEGMENT_SIZE), (byte)42); + } + + @Override + public void doAccess() { + segment.mismatch(copy); + } + } + + static class BufferAccessor extends AbstractBufferAccessor { + + BufferAccessor(MemorySegment segment) { + super(segment); + } + + @Override + public void doAccess() { + int sum = 0; + for (int i = 0; i < bb.capacity(); i++) { + sum += bb.get(i); + } + } + } + + static class BufferHandleAccessor extends AbstractBufferAccessor { + + static VarHandle handle = MethodHandles.byteBufferViewVarHandle(short[].class, ByteOrder.nativeOrder()); + + public BufferHandleAccessor(MemorySegment segment) { + super(segment); + } + + @Override + public void doAccess() { + int sum = 0; + for (int i = 0; i < bb.capacity() / 2; i++) { + sum += (short) handle.get(bb, i); + } + } + }; + + static class Handshaker implements Runnable { + + final MemorySegment segment; + + Handshaker(MemorySegment segment) { + this.segment = segment; + } + + @Override + public void run() { + long prev = System.currentTimeMillis(); + while (true) { + try { + segment.close(); + break; + } catch (IllegalStateException ex) { + Thread.onSpinWait(); + } + } + long delay = System.currentTimeMillis() - prev; + System.out.println("Segment closed - delay (ms): " + delay); + } + } + + @DataProvider + static Object[][] accessors() { + return new Object[][] { + { (Function)SegmentAccessor::new }, + { (Function)SegmentCopyAccessor::new }, + { (Function)SegmentMismatchAccessor::new }, + { (Function)SegmentFillAccessor::new }, + { (Function)BufferAccessor::new }, + { (Function)BufferHandleAccessor::new } + }; + } +} diff --git a/test/micro/org/openjdk/bench/jdk/incubator/foreign/LoopOverNonConstantShared.java b/test/micro/org/openjdk/bench/jdk/incubator/foreign/LoopOverNonConstantShared.java new file mode 100644 index 0000000000000..0d629a16dc913 --- /dev/null +++ b/test/micro/org/openjdk/bench/jdk/incubator/foreign/LoopOverNonConstantShared.java @@ -0,0 +1,166 @@ +/* + * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code 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 + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ +package org.openjdk.bench.jdk.incubator.foreign; + +import jdk.incubator.foreign.MemoryAccess; +import jdk.incubator.foreign.MemoryLayout; +import jdk.incubator.foreign.MemorySegment; +import org.openjdk.jmh.annotations.Benchmark; +import org.openjdk.jmh.annotations.BenchmarkMode; +import org.openjdk.jmh.annotations.Fork; +import org.openjdk.jmh.annotations.Measurement; +import org.openjdk.jmh.annotations.Mode; +import org.openjdk.jmh.annotations.OutputTimeUnit; +import org.openjdk.jmh.annotations.Setup; +import org.openjdk.jmh.annotations.State; +import org.openjdk.jmh.annotations.TearDown; +import org.openjdk.jmh.annotations.Warmup; +import sun.misc.Unsafe; + +import java.lang.invoke.VarHandle; +import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import java.util.concurrent.TimeUnit; + +import static jdk.incubator.foreign.MemoryLayout.PathElement.sequenceElement; +import static jdk.incubator.foreign.MemoryLayouts.JAVA_INT; + +@BenchmarkMode(Mode.AverageTime) +@Warmup(iterations = 5, time = 500, timeUnit = TimeUnit.MILLISECONDS) +@Measurement(iterations = 10, time = 500, timeUnit = TimeUnit.MILLISECONDS) +@State(org.openjdk.jmh.annotations.Scope.Thread) +@OutputTimeUnit(TimeUnit.MILLISECONDS) +@Fork(3) +public class LoopOverNonConstantShared { + + static final Unsafe unsafe = Utils.unsafe; + + static final int ELEM_SIZE = 1_000_000; + static final int CARRIER_SIZE = (int)JAVA_INT.byteSize(); + static final int ALLOC_SIZE = ELEM_SIZE * CARRIER_SIZE; + + static final VarHandle VH_int = MemoryLayout.ofSequence(JAVA_INT).varHandle(int.class, sequenceElement()); + MemorySegment segment; + long unsafe_addr; + + ByteBuffer byteBuffer; + + @Setup + public void setup() { + unsafe_addr = unsafe.allocateMemory(ALLOC_SIZE); + for (int i = 0; i < ELEM_SIZE; i++) { + unsafe.putInt(unsafe_addr + (i * CARRIER_SIZE) , i); + } + segment = MemorySegment.allocateNative(ALLOC_SIZE).share(); + for (int i = 0; i < ELEM_SIZE; i++) { + VH_int.set(segment, (long) i, i); + } + byteBuffer = ByteBuffer.allocateDirect(ALLOC_SIZE).order(ByteOrder.nativeOrder()); + for (int i = 0; i < ELEM_SIZE; i++) { + byteBuffer.putInt(i * CARRIER_SIZE , i); + } + } + + @TearDown + public void tearDown() { + segment.close(); + unsafe.invokeCleaner(byteBuffer); + unsafe.freeMemory(unsafe_addr); + } + + @Benchmark + @OutputTimeUnit(TimeUnit.NANOSECONDS) + public int unsafe_get() { + return unsafe.getInt(unsafe_addr); + } + + @Benchmark + @OutputTimeUnit(TimeUnit.NANOSECONDS) + public int segment_get() { + return (int) VH_int.get(segment, 0L); + } + + @Benchmark + @OutputTimeUnit(TimeUnit.NANOSECONDS) + public int BB_get() { + return byteBuffer.getInt(0); + } + + @Benchmark + public int unsafe_loop() { + int res = 0; + for (int i = 0; i < ELEM_SIZE; i ++) { + res += unsafe.getInt(unsafe_addr + (i * CARRIER_SIZE)); + } + return res; + } + + @Benchmark + public int segment_loop_static() { + int res = 0; + for (int i = 0; i < ELEM_SIZE; i ++) { + res += MemoryAccess.getIntAtIndex(segment, i); + } + return res; + } + + @Benchmark + public int segment_loop() { + int sum = 0; + for (int i = 0; i < ELEM_SIZE; i++) { + sum += (int) VH_int.get(segment, (long) i); + } + return sum; + } + + @Benchmark + public int segment_loop_slice() { + int sum = 0; + MemorySegment base = segment.asSlice(0, segment.byteSize()); + for (int i = 0; i < ELEM_SIZE; i++) { + sum += (int) VH_int.get(base, (long) i); + } + return sum; + } + + @Benchmark + public int segment_loop_readonly() { + int sum = 0; + MemorySegment base = segment.withAccessModes(MemorySegment.READ); + for (int i = 0; i < ELEM_SIZE; i++) { + sum += (int) VH_int.get(base, (long) i); + } + return sum; + } + + @Benchmark + public int BB_loop() { + int sum = 0; + ByteBuffer bb = byteBuffer; + for (int i = 0; i < ELEM_SIZE; i++) { + sum += bb.getInt(i * CARRIER_SIZE); + } + return sum; + } + +} From e4eb2c7432f35e35ab88322d58658802be57b1d7 Mon Sep 17 00:00:00 2001 From: Maurizio Cimadamore Date: Wed, 7 Oct 2020 18:09:26 +0100 Subject: [PATCH 02/70] Add modified files --- make/modules/java.base/Gensrc.gmk | 1 + .../share/classfile/classFileParser.cpp | 8 + src/hotspot/share/classfile/vmSymbols.hpp | 1 + src/hotspot/share/oops/method.hpp | 11 +- src/hotspot/share/prims/nativeLookup.cpp | 2 + .../invoke/MemoryAccessVarHandleBase.java | 17 +- .../MemoryAccessVarHandleGenerator.java | 510 ------------------ .../java/lang/invoke/MethodHandleImpl.java | 57 +- .../classes/java/lang/invoke/VarHandles.java | 32 +- .../X-VarHandleByteArrayView.java.template | 96 ++-- .../X-VarHandleMemoryAccess.java.template | 358 ++++++------ .../share/classes/java/nio/Bits.java | 6 +- .../share/classes/java/nio/Buffer.java | 31 +- .../classes/java/nio/BufferMismatch.java | 17 +- .../nio/ByteBufferAs-X-Buffer.java.template | 14 +- .../nio/Direct-X-Buffer-bin.java.template | 6 +- .../java/nio/Direct-X-Buffer.java.template | 37 +- .../java/nio/Heap-X-Buffer.java.template | 87 ++- .../classes/java/nio/X-Buffer.java.template | 4 +- .../internal/access/JavaLangInvokeAccess.java | 40 +- .../jdk/internal/access/JavaNioAccess.java | 15 + .../access/foreign/MemorySegmentProxy.java | 70 ++- .../jdk/internal/util/ArraysSupport.java | 31 -- src/java.base/share/classes/module-info.java | 3 +- .../jdk/incubator/foreign/MemoryAddress.java | 137 +++-- .../jdk/incubator/foreign/MemoryHandles.java | 168 +----- .../jdk/incubator/foreign/MemoryLayout.java | 24 +- .../jdk/incubator/foreign/MemoryLayouts.java | 9 +- .../jdk/incubator/foreign/MemorySegment.java | 441 +++++++++++---- .../jdk/incubator/foreign/package-info.java | 22 +- .../foreign/AbstractMemorySegmentImpl.java | 254 ++++++--- .../foreign/HeapMemorySegmentImpl.java | 2 +- .../jdk/internal/foreign/LayoutPath.java | 57 +- .../foreign/MappedMemorySegmentImpl.java | 5 +- .../internal/foreign/MemoryAddressImpl.java | 85 +-- .../jdk/internal/foreign/MemoryScope.java | 421 ++++++++------- .../foreign/NativeMemorySegmentImpl.java | 32 +- .../classes/jdk/internal/foreign/Utils.java | 11 +- .../jdk/java/foreign/TestAdaptVarHandles.java | 142 ++--- test/jdk/java/foreign/TestAddressHandle.java | 51 +- test/jdk/java/foreign/TestArrays.java | 129 +++-- test/jdk/java/foreign/TestByteBuffer.java | 168 +++--- test/jdk/java/foreign/TestLayouts.java | 22 +- test/jdk/java/foreign/TestMemoryAccess.java | 167 +++--- .../jdk/java/foreign/TestMemoryAlignment.java | 25 +- test/jdk/java/foreign/TestMemoryCopy.java | 9 +- .../foreign/TestMemoryHandleAsUnsigned.java | 53 +- test/jdk/java/foreign/TestMismatch.java | 9 +- test/jdk/java/foreign/TestNative.java | 86 +-- .../foreign/TestNoForeignUnsafeOverride.java | 4 +- test/jdk/java/foreign/TestRebase.java | 23 +- test/jdk/java/foreign/TestSegments.java | 118 ++-- test/jdk/java/foreign/TestSharedAccess.java | 118 +--- test/jdk/java/foreign/TestSlices.java | 10 +- test/jdk/java/foreign/TestSpliterator.java | 16 +- .../foreign/TestVarHandleCombinators.java | 96 +--- .../util/stream/SegmentTestDataProvider.java | 25 +- .../incubator/foreign/LoopOverConstant.java | 8 +- .../jdk/incubator/foreign/LoopOverNew.java | 12 +- .../foreign/LoopOverNonConstant.java | 21 +- .../foreign/LoopOverNonConstantHeap.java | 19 +- .../foreign/LoopOverNonConstantMapped.java | 21 +- .../jdk/incubator/foreign/ParallelSum.java | 31 +- .../foreign/TestAdaptVarHandles.java | 6 +- .../foreign/points/support/PanamaPoint.java | 8 +- 65 files changed, 2076 insertions(+), 2443 deletions(-) delete mode 100644 src/java.base/share/classes/java/lang/invoke/MemoryAccessVarHandleGenerator.java diff --git a/make/modules/java.base/Gensrc.gmk b/make/modules/java.base/Gensrc.gmk index 3d473df7a1c2c..f1eb5ff7e8000 100644 --- a/make/modules/java.base/Gensrc.gmk +++ b/make/modules/java.base/Gensrc.gmk @@ -35,6 +35,7 @@ include gensrc/GensrcExceptions.gmk include gensrc/GensrcVarHandles.gmk include gensrc/GensrcModuleLoaderMap.gmk include gensrc/GensrcEmojiData.gmk +include gensrc/GensrcScopedMemoryAccess.gmk # GensrcLocaleData.gmk does not set TARGETS, so we must choose which targets # to include. diff --git a/src/hotspot/share/classfile/classFileParser.cpp b/src/hotspot/share/classfile/classFileParser.cpp index e6ab199417bdf..dd814f6f0d683 100644 --- a/src/hotspot/share/classfile/classFileParser.cpp +++ b/src/hotspot/share/classfile/classFileParser.cpp @@ -1079,6 +1079,7 @@ class AnnotationCollector : public ResourceObj{ _method_InjectedProfile, _method_LambdaForm_Compiled, _method_Hidden, + _method_Scoped, _method_IntrinsicCandidate, _jdk_internal_vm_annotation_Contended, _field_Stable, @@ -2102,6 +2103,11 @@ AnnotationCollector::annotation_index(const ClassLoaderData* loader_data, if (!privileged) break; // only allow in privileged code return _method_Hidden; } + case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_internal_misc_Scoped_signature): { + if (_location != _in_method) break; // only allow for methods + if (!privileged) break; // only allow in privileged code + return _method_Scoped; + } case vmSymbols::VM_SYMBOL_ENUM_NAME(jdk_internal_vm_annotation_IntrinsicCandidate_signature): { if (_location != _in_method) break; // only allow for methods if (!privileged) break; // only allow in privileged code @@ -2159,6 +2165,8 @@ void MethodAnnotationCollector::apply_to(const methodHandle& m) { m->set_intrinsic_id(vmIntrinsics::_compiledLambdaForm); if (has_annotation(_method_Hidden)) m->set_hidden(true); + if (has_annotation(_method_Scoped)) + m->set_scoped(true); if (has_annotation(_method_IntrinsicCandidate) && !m->is_synthetic()) m->set_intrinsic_candidate(true); if (has_annotation(_jdk_internal_vm_annotation_ReservedStackAccess)) diff --git a/src/hotspot/share/classfile/vmSymbols.hpp b/src/hotspot/share/classfile/vmSymbols.hpp index d3289e5e9ed9f..4965c630fb0df 100644 --- a/src/hotspot/share/classfile/vmSymbols.hpp +++ b/src/hotspot/share/classfile/vmSymbols.hpp @@ -287,6 +287,7 @@ template(jdk_internal_vm_annotation_DontInline_signature, "Ljdk/internal/vm/annotation/DontInline;") \ template(jdk_internal_vm_annotation_ForceInline_signature, "Ljdk/internal/vm/annotation/ForceInline;") \ template(jdk_internal_vm_annotation_Hidden_signature, "Ljdk/internal/vm/annotation/Hidden;") \ + template(jdk_internal_misc_Scoped_signature, "Ljdk/internal/misc/ScopedMemoryAccess$Scoped;") \ template(jdk_internal_vm_annotation_IntrinsicCandidate_signature, "Ljdk/internal/vm/annotation/IntrinsicCandidate;") \ template(jdk_internal_vm_annotation_Stable_signature, "Ljdk/internal/vm/annotation/Stable;") \ \ diff --git a/src/hotspot/share/oops/method.hpp b/src/hotspot/share/oops/method.hpp index 4ae64cf7e7913..6e6657be1b6d5 100644 --- a/src/hotspot/share/oops/method.hpp +++ b/src/hotspot/share/oops/method.hpp @@ -90,7 +90,8 @@ class Method : public Metadata { _has_injected_profile = 1 << 4, _running_emcp = 1 << 5, _intrinsic_candidate = 1 << 6, - _reserved_stack_access = 1 << 7 + _reserved_stack_access = 1 << 7, + _scoped = 1 << 8 }; mutable u2 _flags; @@ -900,6 +901,14 @@ class Method : public Metadata { _flags = x ? (_flags | _hidden) : (_flags & ~_hidden); } + bool is_scoped() const { + return (_flags & _scoped) != 0; + } + + void set_scoped(bool x) { + _flags = x ? (_flags | _scoped) : (_flags & ~_scoped); + } + bool intrinsic_candidate() { return (_flags & _intrinsic_candidate) != 0; } diff --git a/src/hotspot/share/prims/nativeLookup.cpp b/src/hotspot/share/prims/nativeLookup.cpp index 9e3e96f295319..c3a8a48f0647a 100644 --- a/src/hotspot/share/prims/nativeLookup.cpp +++ b/src/hotspot/share/prims/nativeLookup.cpp @@ -38,6 +38,7 @@ #include "prims/jvm_misc.hpp" #include "prims/nativeLookup.hpp" #include "prims/unsafe.hpp" +#include "prims/scopedMemoryAccess.hpp" #include "runtime/arguments.hpp" #include "runtime/handles.inline.hpp" #include "runtime/interfaceSupport.inline.hpp" @@ -139,6 +140,7 @@ static JNINativeMethod lookup_special_native_methods[] = { #if INCLUDE_JFR { CC"Java_jdk_jfr_internal_JVM_registerNatives", NULL, FN_PTR(jfr_register_natives) }, #endif + { CC"Java_jdk_internal_misc_ScopedMemoryAccess_registerNatives", NULL, FN_PTR(JVM_RegisterJDKInternalMiscScopedMemoryAccessMethods) }, }; static address lookup_special_native(const char* jni_name) { diff --git a/src/java.base/share/classes/java/lang/invoke/MemoryAccessVarHandleBase.java b/src/java.base/share/classes/java/lang/invoke/MemoryAccessVarHandleBase.java index dee289fa1573a..3e0a26d6aae3a 100644 --- a/src/java.base/share/classes/java/lang/invoke/MemoryAccessVarHandleBase.java +++ b/src/java.base/share/classes/java/lang/invoke/MemoryAccessVarHandleBase.java @@ -36,28 +36,21 @@ abstract class MemoryAccessVarHandleBase extends VarHandle { /** access size (in bytes, computed from var handle carrier type) **/ final long length; - /** access offset (in bytes); must be compatible with {@code alignmentMask} **/ - final long offset; - /** alignment constraint (in bytes, expressed as a bit mask) **/ final long alignmentMask; - MemoryAccessVarHandleBase(VarForm form, boolean be, long length, long offset, long alignmentMask) { + /** if true, only the base part of the address will be checked for alignment **/ + final boolean skipAlignmentMaskCheck; + + MemoryAccessVarHandleBase(VarForm form, boolean skipOffetCheck, boolean be, long length, long alignmentMask) { super(form); + this.skipAlignmentMaskCheck = skipOffetCheck; this.be = be; this.length = length; - this.offset = offset; this.alignmentMask = alignmentMask; } static IllegalStateException newIllegalStateExceptionForMisalignedAccess(long address) { return new IllegalStateException("Misaligned access at address: " + address); } - - /** - * Strides used for multi-dimensional access; each stride must be compatible with {@code alignmentMask}. - */ - abstract long[] strides(); - - abstract Class carrier(); } diff --git a/src/java.base/share/classes/java/lang/invoke/MemoryAccessVarHandleGenerator.java b/src/java.base/share/classes/java/lang/invoke/MemoryAccessVarHandleGenerator.java deleted file mode 100644 index 6e66fc1ab4298..0000000000000 --- a/src/java.base/share/classes/java/lang/invoke/MemoryAccessVarHandleGenerator.java +++ /dev/null @@ -1,510 +0,0 @@ -/* - * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. Oracle designates this - * particular file as subject to the "Classpath" exception as provided - * by Oracle in the LICENSE file that accompanied this code. - * - * This code 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 - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - */ - -package java.lang.invoke; - -import jdk.internal.access.foreign.MemoryAddressProxy; -import jdk.internal.org.objectweb.asm.ClassReader; -import jdk.internal.org.objectweb.asm.ClassWriter; -import jdk.internal.org.objectweb.asm.ConstantDynamic; -import jdk.internal.org.objectweb.asm.Handle; -import jdk.internal.org.objectweb.asm.MethodVisitor; -import jdk.internal.org.objectweb.asm.Opcodes; -import jdk.internal.org.objectweb.asm.Type; -import jdk.internal.org.objectweb.asm.util.TraceClassVisitor; -import jdk.internal.vm.annotation.ForceInline; -import sun.security.action.GetBooleanAction; -import sun.security.action.GetPropertyAction; - -import java.io.File; -import java.io.FileOutputStream; -import java.io.IOException; -import java.io.PrintWriter; -import java.io.StringWriter; -import java.util.Arrays; -import java.util.HashMap; - -import static jdk.internal.org.objectweb.asm.Opcodes.AALOAD; -import static jdk.internal.org.objectweb.asm.Opcodes.ACC_FINAL; -import static jdk.internal.org.objectweb.asm.Opcodes.ACC_PRIVATE; -import static jdk.internal.org.objectweb.asm.Opcodes.ACC_PUBLIC; -import static jdk.internal.org.objectweb.asm.Opcodes.ACC_STATIC; -import static jdk.internal.org.objectweb.asm.Opcodes.ACC_SUPER; -import static jdk.internal.org.objectweb.asm.Opcodes.ALOAD; -import static jdk.internal.org.objectweb.asm.Opcodes.ARETURN; -import static jdk.internal.org.objectweb.asm.Opcodes.ASTORE; -import static jdk.internal.org.objectweb.asm.Opcodes.BIPUSH; -import static jdk.internal.org.objectweb.asm.Opcodes.CHECKCAST; -import static jdk.internal.org.objectweb.asm.Opcodes.GETFIELD; -import static jdk.internal.org.objectweb.asm.Opcodes.GETSTATIC; -import static jdk.internal.org.objectweb.asm.Opcodes.H_INVOKESTATIC; -import static jdk.internal.org.objectweb.asm.Opcodes.ICONST_0; -import static jdk.internal.org.objectweb.asm.Opcodes.ICONST_1; -import static jdk.internal.org.objectweb.asm.Opcodes.ICONST_2; -import static jdk.internal.org.objectweb.asm.Opcodes.ICONST_3; -import static jdk.internal.org.objectweb.asm.Opcodes.ILOAD; -import static jdk.internal.org.objectweb.asm.Opcodes.INVOKESPECIAL; -import static jdk.internal.org.objectweb.asm.Opcodes.INVOKESTATIC; -import static jdk.internal.org.objectweb.asm.Opcodes.INVOKEVIRTUAL; -import static jdk.internal.org.objectweb.asm.Opcodes.LALOAD; -import static jdk.internal.org.objectweb.asm.Opcodes.LASTORE; -import static jdk.internal.org.objectweb.asm.Opcodes.LLOAD; -import static jdk.internal.org.objectweb.asm.Opcodes.NEWARRAY; -import static jdk.internal.org.objectweb.asm.Opcodes.PUTFIELD; -import static jdk.internal.org.objectweb.asm.Opcodes.PUTSTATIC; -import static jdk.internal.org.objectweb.asm.Opcodes.RETURN; -import static jdk.internal.org.objectweb.asm.Opcodes.DUP; -import static jdk.internal.org.objectweb.asm.Opcodes.SIPUSH; -import static jdk.internal.org.objectweb.asm.Opcodes.T_LONG; -import static jdk.internal.org.objectweb.asm.Opcodes.V14; - -class MemoryAccessVarHandleGenerator { - private static final String DEBUG_DUMP_CLASSES_DIR_PROPERTY = "jdk.internal.foreign.ClassGenerator.DEBUG_DUMP_CLASSES_DIR"; - - private static final boolean DEBUG = - GetBooleanAction.privilegedGetProperty("jdk.internal.foreign.ClassGenerator.DEBUG"); - - private static final Class BASE_CLASS = MemoryAccessVarHandleBase.class; - - private static final HashMap, Class> helperClassCache; - - private final static MethodType OFFSET_OP_TYPE; - - private final static MethodHandle ADD_OFFSETS_HANDLE; - private final static MethodHandle MUL_OFFSETS_HANDLE; - - static { - helperClassCache = new HashMap<>(); - helperClassCache.put(byte.class, MemoryAccessVarHandleByteHelper.class); - helperClassCache.put(short.class, MemoryAccessVarHandleShortHelper.class); - helperClassCache.put(char.class, MemoryAccessVarHandleCharHelper.class); - helperClassCache.put(int.class, MemoryAccessVarHandleIntHelper.class); - helperClassCache.put(long.class, MemoryAccessVarHandleLongHelper.class); - helperClassCache.put(float.class, MemoryAccessVarHandleFloatHelper.class); - helperClassCache.put(double.class, MemoryAccessVarHandleDoubleHelper.class); - - OFFSET_OP_TYPE = MethodType.methodType(long.class, long.class, long.class, MemoryAddressProxy.class); - - try { - ADD_OFFSETS_HANDLE = MethodHandles.Lookup.IMPL_LOOKUP.findStatic(MemoryAddressProxy.class, "addOffsets", OFFSET_OP_TYPE); - MUL_OFFSETS_HANDLE = MethodHandles.Lookup.IMPL_LOOKUP.findStatic(MemoryAddressProxy.class, "multiplyOffsets", OFFSET_OP_TYPE); - } catch (Throwable ex) { - throw new ExceptionInInitializerError(ex); - } - } - - private static final File DEBUG_DUMP_CLASSES_DIR; - - static { - String path = GetPropertyAction.privilegedGetProperty(DEBUG_DUMP_CLASSES_DIR_PROPERTY); - if (path == null) { - DEBUG_DUMP_CLASSES_DIR = null; - } else { - DEBUG_DUMP_CLASSES_DIR = new File(path); - } - } - - private final String implClassName; - private final int dimensions; - private final Class carrier; - private final Class helperClass; - private final VarForm form; - private final Object[] classData; - - MemoryAccessVarHandleGenerator(Class carrier, int dims) { - this.dimensions = dims; - this.carrier = carrier; - Class[] components = new Class[dimensions]; - Arrays.fill(components, long.class); - this.form = new VarForm(BASE_CLASS, MemoryAddressProxy.class, carrier, components); - this.helperClass = helperClassCache.get(carrier); - this.implClassName = helperClass.getName().replace('.', '/') + dimensions; - // live constants - Class[] intermediate = new Class[dimensions]; - Arrays.fill(intermediate, long.class); - this.classData = new Object[] { carrier, intermediate, ADD_OFFSETS_HANDLE, MUL_OFFSETS_HANDLE }; - } - - /* - * Generate a VarHandle memory access factory. - * The factory has type (ZJJ[J)VarHandle. - */ - MethodHandle generateHandleFactory() { - byte[] classBytes = generateClassBytes(); - if (DEBUG_DUMP_CLASSES_DIR != null) { - debugWriteClassToFile(classBytes); - } - try { - MethodHandles.Lookup lookup = MethodHandles.lookup().defineHiddenClassWithClassData(classBytes, classData); - Class implCls = lookup.lookupClass(); - Class[] components = new Class[dimensions]; - Arrays.fill(components, long.class); - - VarForm form = new VarForm(implCls, MemoryAddressProxy.class, carrier, components); - - MethodType constrType = MethodType.methodType(void.class, VarForm.class, boolean.class, long.class, long.class, long.class, long[].class); - MethodHandle constr = lookup.findConstructor(implCls, constrType); - constr = MethodHandles.insertArguments(constr, 0, form); - return constr; - } catch (Throwable ex) { - debugPrintClass(classBytes); - throw new AssertionError(ex); - } - } - - /* - * Generate a specialized VarHandle class for given carrier - * and access coordinates. - */ - byte[] generateClassBytes() { - ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_FRAMES | ClassWriter.COMPUTE_MAXS); - - if (DEBUG) { - System.out.println("Generating header implementation class"); - } - - cw.visit(V14, ACC_PUBLIC | ACC_SUPER, implClassName, null, Type.getInternalName(BASE_CLASS), null); - - //add dimension fields - for (int i = 0; i < dimensions; i++) { - cw.visitField(ACC_PRIVATE | ACC_FINAL, "dim" + i, "J", null, null); - } - - addStaticInitializer(cw); - - addConstructor(cw); - - addAccessModeTypeMethod(cw); - - addStridesAccessor(cw); - - addCarrierAccessor(cw); - - for (VarHandle.AccessMode mode : VarHandle.AccessMode.values()) { - addAccessModeMethodIfNeeded(mode, cw); - } - - cw.visitEnd(); - return cw.toByteArray(); - } - - void addStaticInitializer(ClassWriter cw) { - // carrier and intermediate - cw.visitField(ACC_PRIVATE | ACC_STATIC | ACC_FINAL, "carrier", Class.class.descriptorString(), null, null); - cw.visitField(ACC_PRIVATE | ACC_STATIC | ACC_FINAL, "intermediate", Class[].class.descriptorString(), null, null); - cw.visitField(ACC_PRIVATE | ACC_STATIC | ACC_FINAL, "addHandle", MethodHandle.class.descriptorString(), null, null); - cw.visitField(ACC_PRIVATE | ACC_STATIC | ACC_FINAL, "mulHandle", MethodHandle.class.descriptorString(), null, null); - - MethodVisitor mv = cw.visitMethod(Opcodes.ACC_STATIC, "", "()V", null, null); - mv.visitCode(); - // extract class data in static final fields - MethodType mtype = MethodType.methodType(Object.class, MethodHandles.Lookup.class, String.class, Class.class); - Handle bsm = new Handle(H_INVOKESTATIC, Type.getInternalName(MethodHandles.class), "classData", - mtype.descriptorString(), false); - ConstantDynamic dynamic = new ConstantDynamic("classData", Object[].class.descriptorString(), bsm); - mv.visitLdcInsn(dynamic); - mv.visitTypeInsn(CHECKCAST, Type.getInternalName(Object[].class)); - mv.visitVarInsn(ASTORE, 0); - mv.visitVarInsn(ALOAD, 0); - mv.visitInsn(ICONST_0); - mv.visitInsn(AALOAD); - mv.visitTypeInsn(CHECKCAST, Type.getInternalName(Class.class)); - mv.visitFieldInsn(PUTSTATIC, implClassName, "carrier", Class.class.descriptorString()); - mv.visitVarInsn(ALOAD, 0); - mv.visitInsn(ICONST_1); - mv.visitInsn(AALOAD); - mv.visitTypeInsn(CHECKCAST, Type.getInternalName(Class[].class)); - mv.visitFieldInsn(PUTSTATIC, implClassName, "intermediate", Class[].class.descriptorString()); - mv.visitVarInsn(ALOAD, 0); - mv.visitInsn(ICONST_2); - mv.visitInsn(AALOAD); - mv.visitTypeInsn(CHECKCAST, Type.getInternalName(MethodHandle.class)); - mv.visitFieldInsn(PUTSTATIC, implClassName, "addHandle", MethodHandle.class.descriptorString()); - mv.visitVarInsn(ALOAD, 0); - mv.visitInsn(ICONST_3); - mv.visitInsn(AALOAD); - mv.visitTypeInsn(CHECKCAST, Type.getInternalName(MethodHandle.class)); - mv.visitFieldInsn(PUTSTATIC, implClassName, "mulHandle", MethodHandle.class.descriptorString()); - mv.visitInsn(Opcodes.RETURN); - mv.visitMaxs(0, 0); - mv.visitEnd(); - } - - void addConstructor(ClassWriter cw) { - MethodType constrType = MethodType.methodType(void.class, VarForm.class, boolean.class, long.class, long.class, long.class, long[].class); - MethodVisitor mv = cw.visitMethod(0, "", constrType.toMethodDescriptorString(), null, null); - mv.visitCode(); - //super call - mv.visitVarInsn(ALOAD, 0); - mv.visitVarInsn(ALOAD, 1); - mv.visitTypeInsn(CHECKCAST, Type.getInternalName(VarForm.class)); - mv.visitVarInsn(ILOAD, 2); - mv.visitVarInsn(LLOAD, 3); - mv.visitVarInsn(LLOAD, 5); - mv.visitVarInsn(LLOAD, 7); - mv.visitMethodInsn(INVOKESPECIAL, Type.getInternalName(BASE_CLASS), "", - MethodType.methodType(void.class, VarForm.class, boolean.class, long.class, long.class, long.class).toMethodDescriptorString(), false); - //init dimensions - for (int i = 0 ; i < dimensions ; i++) { - mv.visitVarInsn(ALOAD, 0); - mv.visitVarInsn(ALOAD, 9); - mv.visitLdcInsn(i); - mv.visitInsn(LALOAD); - mv.visitFieldInsn(PUTFIELD, implClassName, "dim" + i, "J"); - } - mv.visitInsn(RETURN); - mv.visitMaxs(0, 0); - mv.visitEnd(); - } - - void addAccessModeTypeMethod(ClassWriter cw) { - MethodType modeMethType = MethodType.methodType(MethodType.class, VarHandle.AccessMode.class); - MethodVisitor mv = cw.visitMethod(ACC_FINAL, "accessModeTypeUncached", modeMethType.toMethodDescriptorString(), null, null); - mv.visitCode(); - mv.visitVarInsn(ALOAD, 1); - mv.visitFieldInsn(GETFIELD, Type.getInternalName(VarHandle.AccessMode.class), "at", VarHandle.AccessType.class.descriptorString()); - mv.visitLdcInsn(Type.getType(MemoryAddressProxy.class)); - mv.visitTypeInsn(CHECKCAST, Type.getInternalName(Class.class)); - mv.visitFieldInsn(GETSTATIC, implClassName, "carrier", Class.class.descriptorString()); - mv.visitFieldInsn(GETSTATIC, implClassName, "intermediate", Class[].class.descriptorString()); - - mv.visitMethodInsn(INVOKEVIRTUAL, Type.getInternalName(VarHandle.AccessType.class), - "accessModeType", MethodType.methodType(MethodType.class, Class.class, Class.class, Class[].class).toMethodDescriptorString(), false); - - mv.visitInsn(ARETURN); - - mv.visitMaxs(0, 0); - mv.visitEnd(); - } - - void addAccessModeMethodIfNeeded(VarHandle.AccessMode mode, ClassWriter cw) { - String methName = mode.methodName(); - MethodType methType = form.getMethodType(mode.at.ordinal()) - .insertParameterTypes(0, VarHandle.class); - - try { - MethodType helperType = methType.insertParameterTypes(2, long.class); - if (dimensions > 0) { - helperType = helperType.dropParameterTypes(3, 3 + dimensions); - } - //try to resolve... - String helperMethodName = methName + "0"; - MethodHandles.Lookup.IMPL_LOOKUP - .findStatic(helperClass, - helperMethodName, - helperType); - - - MethodVisitor mv = cw.visitMethod(ACC_STATIC, methName, methType.toMethodDescriptorString(), null, null); - mv.visitAnnotation(Type.getDescriptor(ForceInline.class), true); - mv.visitCode(); - - mv.visitVarInsn(ALOAD, 0); // handle impl - mv.visitVarInsn(ALOAD, 1); // receiver - - // offset calculation - int slot = 2; - mv.visitVarInsn(ALOAD, 0); // load recv - mv.visitTypeInsn(CHECKCAST, Type.getInternalName(BASE_CLASS)); - mv.visitFieldInsn(GETFIELD, Type.getInternalName(BASE_CLASS), "offset", "J"); - for (int i = 0 ; i < dimensions ; i++) { - // load ADD MH - mv.visitFieldInsn(GETSTATIC, implClassName, "addHandle", MethodHandle.class.descriptorString()); - - //fixup stack so that ADD MH ends up bottom - mv.visitInsn(Opcodes.DUP_X2); - mv.visitInsn(Opcodes.POP); - - // load MUL MH - mv.visitFieldInsn(GETSTATIC, implClassName, "mulHandle", MethodHandle.class.descriptorString()); - mv.visitTypeInsn(CHECKCAST, Type.getInternalName(MethodHandle.class)); - - mv.visitVarInsn(ALOAD, 0); // load recv - mv.visitTypeInsn(CHECKCAST, implClassName); - mv.visitFieldInsn(GETFIELD, implClassName, "dim" + i, "J"); - mv.visitVarInsn(LLOAD, slot); - - mv.visitVarInsn(ALOAD, 1); // receiver - mv.visitTypeInsn(CHECKCAST, Type.getInternalName(MemoryAddressProxy.class)); - - //MUL - mv.visitMethodInsn(INVOKEVIRTUAL, Type.getInternalName(MethodHandle.class), "invokeExact", - OFFSET_OP_TYPE.toMethodDescriptorString(), false); - - mv.visitVarInsn(ALOAD, 1); // receiver - mv.visitTypeInsn(CHECKCAST, Type.getInternalName(MemoryAddressProxy.class)); - - //ADD - mv.visitMethodInsn(INVOKEVIRTUAL, Type.getInternalName(MethodHandle.class), "invokeExact", - OFFSET_OP_TYPE.toMethodDescriptorString(), false); - slot += 2; - } - - for (int i = 2 + dimensions; i < methType.parameterCount() ; i++) { - Class param = methType.parameterType(i); - mv.visitVarInsn(loadInsn(param), slot); // load index - slot += getSlotsForType(param); - } - - //call helper - mv.visitMethodInsn(INVOKESTATIC, Type.getInternalName(helperClass), helperMethodName, - helperType.toMethodDescriptorString(), false); - - mv.visitInsn(returnInsn(helperType.returnType())); - - mv.visitMaxs(0, 0); - mv.visitEnd(); - } catch (ReflectiveOperationException ex) { - //not found, skip - } - } - - void addStridesAccessor(ClassWriter cw) { - MethodVisitor mv = cw.visitMethod(ACC_FINAL, "strides", "()[J", null, null); - mv.visitCode(); - iConstInsn(mv, dimensions); - mv.visitIntInsn(NEWARRAY, T_LONG); - - for (int i = 0 ; i < dimensions ; i++) { - mv.visitInsn(DUP); - iConstInsn(mv, i); - mv.visitVarInsn(ALOAD, 0); - mv.visitFieldInsn(GETFIELD, implClassName, "dim" + i, "J"); - mv.visitInsn(LASTORE); - } - - mv.visitInsn(ARETURN); - mv.visitMaxs(0, 0); - mv.visitEnd(); - } - - void addCarrierAccessor(ClassWriter cw) { - MethodVisitor mv = cw.visitMethod(ACC_FINAL, "carrier", "()Ljava/lang/Class;", null, null); - mv.visitCode(); - mv.visitFieldInsn(GETSTATIC, implClassName, "carrier", Class.class.descriptorString()); - mv.visitInsn(ARETURN); - mv.visitMaxs(0, 0); - mv.visitEnd(); - } - - // shared code generation helpers - - private static int getSlotsForType(Class c) { - if (c == long.class || c == double.class) { - return 2; - } - return 1; - } - - /** - * Emits an actual return instruction conforming to the given return type. - */ - private int returnInsn(Class type) { - return switch (LambdaForm.BasicType.basicType(type)) { - case I_TYPE -> Opcodes.IRETURN; - case J_TYPE -> Opcodes.LRETURN; - case F_TYPE -> Opcodes.FRETURN; - case D_TYPE -> Opcodes.DRETURN; - case L_TYPE -> Opcodes.ARETURN; - case V_TYPE -> RETURN; - }; - } - - private int loadInsn(Class type) { - return switch (LambdaForm.BasicType.basicType(type)) { - case I_TYPE -> Opcodes.ILOAD; - case J_TYPE -> LLOAD; - case F_TYPE -> Opcodes.FLOAD; - case D_TYPE -> Opcodes.DLOAD; - case L_TYPE -> Opcodes.ALOAD; - case V_TYPE -> throw new IllegalStateException("Cannot load void"); - }; - } - - private static void iConstInsn(MethodVisitor mv, int i) { - switch (i) { - case -1, 0, 1, 2, 3, 4, 5: - mv.visitInsn(ICONST_0 + i); - break; - default: - if(i >= Byte.MIN_VALUE && i <= Byte.MAX_VALUE) { - mv.visitIntInsn(BIPUSH, i); - } else if (i >= Short.MIN_VALUE && i <= Short.MAX_VALUE) { - mv.visitIntInsn(SIPUSH, i); - } else { - mv.visitLdcInsn(i); - } - } - } - - // debug helpers - - private static String debugPrintClass(byte[] classFile) { - ClassReader cr = new ClassReader(classFile); - StringWriter sw = new StringWriter(); - cr.accept(new TraceClassVisitor(new PrintWriter(sw)), 0); - return sw.toString(); - } - - private void debugWriteClassToFile(byte[] classFile) { - File file = new File(DEBUG_DUMP_CLASSES_DIR, implClassName + ".class"); - - if (DEBUG) { - System.err.println("Dumping class " + implClassName + " to " + file); - } - - try { - debugWriteDataToFile(classFile, file); - } catch (Exception e) { - throw new RuntimeException("Failed to write class " + implClassName + " to file " + file); - } - } - - private void debugWriteDataToFile(byte[] data, File file) { - if (file.exists()) { - file.delete(); - } - if (file.exists()) { - throw new RuntimeException("Failed to remove pre-existing file " + file); - } - - File parent = file.getParentFile(); - if (!parent.exists()) { - parent.mkdirs(); - } - if (!parent.exists()) { - throw new RuntimeException("Failed to create " + parent); - } - if (!parent.isDirectory()) { - throw new RuntimeException(parent + " is not a directory"); - } - - try (FileOutputStream fos = new FileOutputStream(file)) { - fos.write(data); - } catch (IOException e) { - throw new RuntimeException("Failed to write class " + implClassName + " to file " + file); - } - } -} diff --git a/src/java.base/share/classes/java/lang/invoke/MethodHandleImpl.java b/src/java.base/share/classes/java/lang/invoke/MethodHandleImpl.java index d282e58cf9620..ea5d80ad1e801 100644 --- a/src/java.base/share/classes/java/lang/invoke/MethodHandleImpl.java +++ b/src/java.base/share/classes/java/lang/invoke/MethodHandleImpl.java @@ -1769,40 +1769,9 @@ public Map generateHolderClasses(Stream traces) { } @Override - public VarHandle memoryAccessVarHandle(Class carrier, long alignmentMask, - ByteOrder order, long offset, long[] strides) { - return VarHandles.makeMemoryAddressViewHandle(carrier, alignmentMask, order, offset, strides); - } - - @Override - public Class memoryAddressCarrier(VarHandle handle) { - return checkMemoryAccessHandle(handle).carrier(); - } - - @Override - public long memoryAddressAlignmentMask(VarHandle handle) { - return checkMemoryAccessHandle(handle).alignmentMask; - } - - @Override - public ByteOrder memoryAddressByteOrder(VarHandle handle) { - return checkMemoryAccessHandle(handle).be ? - ByteOrder.BIG_ENDIAN : ByteOrder.LITTLE_ENDIAN; - } - - @Override - public long memoryAddressOffset(VarHandle handle) { - return checkMemoryAccessHandle(handle).offset; - } - - @Override - public long[] memoryAddressStrides(VarHandle handle) { - return checkMemoryAccessHandle(handle).strides(); - } - - @Override - public boolean isMemoryAccessVarHandle(VarHandle handle) { - return asMemoryAccessVarHandle(handle) != null; + public VarHandle memoryAccessVarHandle(Class carrier, boolean skipAlignmentMaskCheck, long alignmentMask, + ByteOrder order) { + return VarHandles.makeMemoryAddressViewHandle(carrier, skipAlignmentMaskCheck, alignmentMask, order); } @Override @@ -1834,26 +1803,6 @@ public VarHandle collectCoordinates(VarHandle target, int pos, MethodHandle filt public VarHandle insertCoordinates(VarHandle target, int pos, Object... values) { return VarHandles.insertCoordinates(target, pos, values); } - - private MemoryAccessVarHandleBase asMemoryAccessVarHandle(VarHandle handle) { - if (handle instanceof MemoryAccessVarHandleBase) { - return (MemoryAccessVarHandleBase)handle; - } else if (handle.target() instanceof MemoryAccessVarHandleBase) { - // skip first adaptation, since we have to step over MemoryAddressProxy - // see JDK-8237349 - return (MemoryAccessVarHandleBase)handle.target(); - } else { - return null; - } - } - - private MemoryAccessVarHandleBase checkMemoryAccessHandle(VarHandle handle) { - MemoryAccessVarHandleBase base = asMemoryAccessVarHandle(handle); - if (base == null) { - throw new IllegalArgumentException("Not a memory access varhandle: " + handle); - } - return base; - } }); } diff --git a/src/java.base/share/classes/java/lang/invoke/VarHandles.java b/src/java.base/share/classes/java/lang/invoke/VarHandles.java index 60d90104a982a..2d5a8e253fbed 100644 --- a/src/java.base/share/classes/java/lang/invoke/VarHandles.java +++ b/src/java.base/share/classes/java/lang/invoke/VarHandles.java @@ -311,29 +311,35 @@ else if (viewComponentType == float.class) { * to a single fixed offset to compute an effective offset from the given MemoryAddress for the access. * * @param carrier the Java carrier type. + * @param skipAlignmentMaskCheck if true, only the base part of the address will be checked for alignment. * @param alignmentMask alignment requirement to be checked upon access. In bytes. Expressed as a mask. * @param byteOrder the byte order. - * @param offset a constant offset for the access. - * @param strides the scale factors with which to multiply given access coordinates. * @return the created VarHandle. */ - static VarHandle makeMemoryAddressViewHandle(Class carrier, long alignmentMask, - ByteOrder byteOrder, long offset, long[] strides) { + static VarHandle makeMemoryAddressViewHandle(Class carrier, boolean skipAlignmentMaskCheck, long alignmentMask, + ByteOrder byteOrder) { if (!carrier.isPrimitive() || carrier == void.class || carrier == boolean.class) { throw new IllegalArgumentException("Invalid carrier: " + carrier.getName()); } long size = Wrapper.forPrimitiveType(carrier).bitWidth() / 8; boolean be = byteOrder == ByteOrder.BIG_ENDIAN; - Map carrierFactory = ADDRESS_FACTORIES.get(carrier); - MethodHandle fac = carrierFactory.computeIfAbsent(strides.length, - dims -> new MemoryAccessVarHandleGenerator(carrier, dims) - .generateHandleFactory()); - - try { - return maybeAdapt((VarHandle)fac.invoke(be, size, offset, alignmentMask, strides)); - } catch (Throwable ex) { - throw new IllegalStateException(ex); + if (carrier == byte.class) { + return maybeAdapt(new MemoryAccessVarHandleByteHelper(skipAlignmentMaskCheck, be, size, alignmentMask)); + } else if (carrier == char.class) { + return maybeAdapt(new MemoryAccessVarHandleCharHelper(skipAlignmentMaskCheck, be, size, alignmentMask)); + } else if (carrier == short.class) { + return maybeAdapt(new MemoryAccessVarHandleShortHelper(skipAlignmentMaskCheck, be, size, alignmentMask)); + } else if (carrier == int.class) { + return maybeAdapt(new MemoryAccessVarHandleIntHelper(skipAlignmentMaskCheck, be, size, alignmentMask)); + } else if (carrier == float.class) { + return maybeAdapt(new MemoryAccessVarHandleFloatHelper(skipAlignmentMaskCheck, be, size, alignmentMask)); + } else if (carrier == long.class) { + return maybeAdapt(new MemoryAccessVarHandleLongHelper(skipAlignmentMaskCheck, be, size, alignmentMask)); + } else if (carrier == double.class) { + return maybeAdapt(new MemoryAccessVarHandleDoubleHelper(skipAlignmentMaskCheck, be, size, alignmentMask)); + } else { + throw new IllegalStateException("Cannot get here"); } } diff --git a/src/java.base/share/classes/java/lang/invoke/X-VarHandleByteArrayView.java.template b/src/java.base/share/classes/java/lang/invoke/X-VarHandleByteArrayView.java.template index 9ac3d25866eb5..aca3ef1ab089a 100644 --- a/src/java.base/share/classes/java/lang/invoke/X-VarHandleByteArrayView.java.template +++ b/src/java.base/share/classes/java/lang/invoke/X-VarHandleByteArrayView.java.template @@ -27,6 +27,8 @@ package java.lang.invoke; import jdk.internal.access.JavaNioAccess; import jdk.internal.access.SharedSecrets; import jdk.internal.access.foreign.MemorySegmentProxy; +import jdk.internal.misc.ScopedMemoryAccess; +import jdk.internal.misc.ScopedMemoryAccess.Scope; import jdk.internal.misc.Unsafe; import jdk.internal.util.Preconditions; import jdk.internal.vm.annotation.ForceInline; @@ -41,9 +43,11 @@ import static java.lang.invoke.MethodHandleStatics.UNSAFE; final class VarHandleByteArrayAs$Type$s extends VarHandleByteArrayBase { - static JavaNioAccess nioAccess = SharedSecrets.getJavaNioAccess(); + static final JavaNioAccess NIO_ACCESS = SharedSecrets.getJavaNioAccess(); static final int ALIGN = $BoxType$.BYTES - 1; + + static final ScopedMemoryAccess SCOPED_MEMORY_ACCESS = ScopedMemoryAccess.getScopedMemoryAccess(); #if[floatingPoint] @ForceInline @@ -565,13 +569,17 @@ final class VarHandleByteArrayAs$Type$s extends VarHandleByteArrayBase { @ForceInline static int index(ByteBuffer bb, int index) { - MemorySegmentProxy segmentProxy = nioAccess.bufferSegment(bb); - if (segmentProxy != null) { - segmentProxy.checkValidState(); - } + MemorySegmentProxy segmentProxy = NIO_ACCESS.bufferSegment(bb); return Preconditions.checkIndex(index, UNSAFE.getInt(bb, BUFFER_LIMIT) - ALIGN, null); } + @ForceInline + static Scope scope(ByteBuffer bb) { + MemorySegmentProxy segmentProxy = NIO_ACCESS.bufferSegment(bb); + return segmentProxy != null ? + segmentProxy.scope() : null; + } + @ForceInline static int indexRO(ByteBuffer bb, int index) { if (UNSAFE.getBoolean(bb, BYTE_BUFFER_IS_READ_ONLY)) @@ -592,13 +600,13 @@ final class VarHandleByteArrayAs$Type$s extends VarHandleByteArrayBase { ByteBufferHandle handle = (ByteBufferHandle)ob; ByteBuffer bb = (ByteBuffer) Objects.requireNonNull(obb); #if[floatingPoint] - $rawType$ rawValue = UNSAFE.get$RawType$Unaligned( + $rawType$ rawValue = SCOPED_MEMORY_ACCESS.get$RawType$Unaligned(scope(bb), UNSAFE.getReference(bb, BYTE_BUFFER_HB), ((long) index(bb, index)) + UNSAFE.getLong(bb, BUFFER_ADDRESS), handle.be); return $Type$.$rawType$BitsTo$Type$(rawValue); #else[floatingPoint] - return UNSAFE.get$Type$Unaligned( + return SCOPED_MEMORY_ACCESS.get$Type$Unaligned(scope(bb), UNSAFE.getReference(bb, BYTE_BUFFER_HB), ((long) index(bb, index)) + UNSAFE.getLong(bb, BUFFER_ADDRESS), handle.be); @@ -610,13 +618,13 @@ final class VarHandleByteArrayAs$Type$s extends VarHandleByteArrayBase { ByteBufferHandle handle = (ByteBufferHandle)ob; ByteBuffer bb = (ByteBuffer) Objects.requireNonNull(obb); #if[floatingPoint] - UNSAFE.put$RawType$Unaligned( + SCOPED_MEMORY_ACCESS.put$RawType$Unaligned(scope(bb), UNSAFE.getReference(bb, BYTE_BUFFER_HB), ((long) indexRO(bb, index)) + UNSAFE.getLong(bb, BUFFER_ADDRESS), $Type$.$type$ToRaw$RawType$Bits(value), handle.be); #else[floatingPoint] - UNSAFE.put$Type$Unaligned( + SCOPED_MEMORY_ACCESS.put$Type$Unaligned(scope(bb), UNSAFE.getReference(bb, BYTE_BUFFER_HB), ((long) indexRO(bb, index)) + UNSAFE.getLong(bb, BUFFER_ADDRESS), value, @@ -629,7 +637,7 @@ final class VarHandleByteArrayAs$Type$s extends VarHandleByteArrayBase { ByteBufferHandle handle = (ByteBufferHandle)ob; ByteBuffer bb = (ByteBuffer) Objects.requireNonNull(obb); return convEndian(handle.be, - UNSAFE.get$RawType$Volatile( + SCOPED_MEMORY_ACCESS.get$RawType$Volatile(scope(bb), UNSAFE.getReference(bb, BYTE_BUFFER_HB), address(bb, index(bb, index)))); } @@ -638,7 +646,7 @@ final class VarHandleByteArrayAs$Type$s extends VarHandleByteArrayBase { static void setVolatile(VarHandle ob, Object obb, int index, $type$ value) { ByteBufferHandle handle = (ByteBufferHandle)ob; ByteBuffer bb = (ByteBuffer) Objects.requireNonNull(obb); - UNSAFE.put$RawType$Volatile( + SCOPED_MEMORY_ACCESS.put$RawType$Volatile(scope(bb), UNSAFE.getReference(bb, BYTE_BUFFER_HB), address(bb, indexRO(bb, index)), convEndian(handle.be, value)); @@ -649,7 +657,7 @@ final class VarHandleByteArrayAs$Type$s extends VarHandleByteArrayBase { ByteBufferHandle handle = (ByteBufferHandle)ob; ByteBuffer bb = (ByteBuffer) Objects.requireNonNull(obb); return convEndian(handle.be, - UNSAFE.get$RawType$Acquire( + SCOPED_MEMORY_ACCESS.get$RawType$Acquire(scope(bb), UNSAFE.getReference(bb, BYTE_BUFFER_HB), address(bb, index(bb, index)))); } @@ -658,7 +666,7 @@ final class VarHandleByteArrayAs$Type$s extends VarHandleByteArrayBase { static void setRelease(VarHandle ob, Object obb, int index, $type$ value) { ByteBufferHandle handle = (ByteBufferHandle)ob; ByteBuffer bb = (ByteBuffer) Objects.requireNonNull(obb); - UNSAFE.put$RawType$Release( + SCOPED_MEMORY_ACCESS.put$RawType$Release(scope(bb), UNSAFE.getReference(bb, BYTE_BUFFER_HB), address(bb, indexRO(bb, index)), convEndian(handle.be, value)); @@ -669,7 +677,7 @@ final class VarHandleByteArrayAs$Type$s extends VarHandleByteArrayBase { ByteBufferHandle handle = (ByteBufferHandle)ob; ByteBuffer bb = (ByteBuffer) Objects.requireNonNull(obb); return convEndian(handle.be, - UNSAFE.get$RawType$Opaque( + SCOPED_MEMORY_ACCESS.get$RawType$Opaque(scope(bb), UNSAFE.getReference(bb, BYTE_BUFFER_HB), address(bb, index(bb, index)))); } @@ -678,7 +686,7 @@ final class VarHandleByteArrayAs$Type$s extends VarHandleByteArrayBase { static void setOpaque(VarHandle ob, Object obb, int index, $type$ value) { ByteBufferHandle handle = (ByteBufferHandle)ob; ByteBuffer bb = (ByteBuffer) Objects.requireNonNull(obb); - UNSAFE.put$RawType$Opaque( + SCOPED_MEMORY_ACCESS.put$RawType$Opaque(scope(bb), UNSAFE.getReference(bb, BYTE_BUFFER_HB), address(bb, indexRO(bb, index)), convEndian(handle.be, value)); @@ -690,12 +698,12 @@ final class VarHandleByteArrayAs$Type$s extends VarHandleByteArrayBase { ByteBufferHandle handle = (ByteBufferHandle)ob; ByteBuffer bb = (ByteBuffer) Objects.requireNonNull(obb); #if[Object] - return UNSAFE.compareAndSetReference( + return SCOPED_MEMORY_ACCESS.compareAndSetReference(scope(bb), UNSAFE.getReference(bb, BYTE_BUFFER_HB), address(bb, indexRO(bb, index)), convEndian(handle.be, expected), convEndian(handle.be, value)); #else[Object] - return UNSAFE.compareAndSet$RawType$( + return SCOPED_MEMORY_ACCESS.compareAndSet$RawType$(scope(bb), UNSAFE.getReference(bb, BYTE_BUFFER_HB), address(bb, indexRO(bb, index)), convEndian(handle.be, expected), convEndian(handle.be, value)); @@ -707,7 +715,7 @@ final class VarHandleByteArrayAs$Type$s extends VarHandleByteArrayBase { ByteBufferHandle handle = (ByteBufferHandle)ob; ByteBuffer bb = (ByteBuffer) Objects.requireNonNull(obb); return convEndian(handle.be, - UNSAFE.compareAndExchange$RawType$( + SCOPED_MEMORY_ACCESS.compareAndExchange$RawType$(scope(bb), UNSAFE.getReference(bb, BYTE_BUFFER_HB), address(bb, indexRO(bb, index)), convEndian(handle.be, expected), convEndian(handle.be, value))); @@ -718,7 +726,7 @@ final class VarHandleByteArrayAs$Type$s extends VarHandleByteArrayBase { ByteBufferHandle handle = (ByteBufferHandle)ob; ByteBuffer bb = (ByteBuffer) Objects.requireNonNull(obb); return convEndian(handle.be, - UNSAFE.compareAndExchange$RawType$Acquire( + SCOPED_MEMORY_ACCESS.compareAndExchange$RawType$Acquire(scope(bb), UNSAFE.getReference(bb, BYTE_BUFFER_HB), address(bb, indexRO(bb, index)), convEndian(handle.be, expected), convEndian(handle.be, value))); @@ -729,7 +737,7 @@ final class VarHandleByteArrayAs$Type$s extends VarHandleByteArrayBase { ByteBufferHandle handle = (ByteBufferHandle)ob; ByteBuffer bb = (ByteBuffer) Objects.requireNonNull(obb); return convEndian(handle.be, - UNSAFE.compareAndExchange$RawType$Release( + SCOPED_MEMORY_ACCESS.compareAndExchange$RawType$Release(scope(bb), UNSAFE.getReference(bb, BYTE_BUFFER_HB), address(bb, indexRO(bb, index)), convEndian(handle.be, expected), convEndian(handle.be, value))); @@ -739,7 +747,7 @@ final class VarHandleByteArrayAs$Type$s extends VarHandleByteArrayBase { static boolean weakCompareAndSetPlain(VarHandle ob, Object obb, int index, $type$ expected, $type$ value) { ByteBufferHandle handle = (ByteBufferHandle)ob; ByteBuffer bb = (ByteBuffer) Objects.requireNonNull(obb); - return UNSAFE.weakCompareAndSet$RawType$Plain( + return SCOPED_MEMORY_ACCESS.weakCompareAndSet$RawType$Plain(scope(bb), UNSAFE.getReference(bb, BYTE_BUFFER_HB), address(bb, indexRO(bb, index)), convEndian(handle.be, expected), convEndian(handle.be, value)); @@ -749,7 +757,7 @@ final class VarHandleByteArrayAs$Type$s extends VarHandleByteArrayBase { static boolean weakCompareAndSet(VarHandle ob, Object obb, int index, $type$ expected, $type$ value) { ByteBufferHandle handle = (ByteBufferHandle)ob; ByteBuffer bb = (ByteBuffer) Objects.requireNonNull(obb); - return UNSAFE.weakCompareAndSet$RawType$( + return SCOPED_MEMORY_ACCESS.weakCompareAndSet$RawType$(scope(bb), UNSAFE.getReference(bb, BYTE_BUFFER_HB), address(bb, indexRO(bb, index)), convEndian(handle.be, expected), convEndian(handle.be, value)); @@ -759,7 +767,7 @@ final class VarHandleByteArrayAs$Type$s extends VarHandleByteArrayBase { static boolean weakCompareAndSetAcquire(VarHandle ob, Object obb, int index, $type$ expected, $type$ value) { ByteBufferHandle handle = (ByteBufferHandle)ob; ByteBuffer bb = (ByteBuffer) Objects.requireNonNull(obb); - return UNSAFE.weakCompareAndSet$RawType$Acquire( + return SCOPED_MEMORY_ACCESS.weakCompareAndSet$RawType$Acquire(scope(bb), UNSAFE.getReference(bb, BYTE_BUFFER_HB), address(bb, indexRO(bb, index)), convEndian(handle.be, expected), convEndian(handle.be, value)); @@ -769,7 +777,7 @@ final class VarHandleByteArrayAs$Type$s extends VarHandleByteArrayBase { static boolean weakCompareAndSetRelease(VarHandle ob, Object obb, int index, $type$ expected, $type$ value) { ByteBufferHandle handle = (ByteBufferHandle)ob; ByteBuffer bb = (ByteBuffer) Objects.requireNonNull(obb); - return UNSAFE.weakCompareAndSet$RawType$Release( + return SCOPED_MEMORY_ACCESS.weakCompareAndSet$RawType$Release(scope(bb), UNSAFE.getReference(bb, BYTE_BUFFER_HB), address(bb, indexRO(bb, index)), convEndian(handle.be, expected), convEndian(handle.be, value)); @@ -781,13 +789,13 @@ final class VarHandleByteArrayAs$Type$s extends VarHandleByteArrayBase { ByteBuffer bb = (ByteBuffer) Objects.requireNonNull(obb); #if[Object] return convEndian(handle.be, - UNSAFE.getAndSetReference( + SCOPED_MEMORY_ACCESS.getAndSetReference(scope(bb), UNSAFE.getReference(bb, BYTE_BUFFER_HB), address(bb, indexRO(bb, index)), convEndian(handle.be, value))); #else[Object] return convEndian(handle.be, - UNSAFE.getAndSet$RawType$( + SCOPED_MEMORY_ACCESS.getAndSet$RawType$(scope(bb), UNSAFE.getReference(bb, BYTE_BUFFER_HB), address(bb, indexRO(bb, index)), convEndian(handle.be, value))); @@ -799,7 +807,7 @@ final class VarHandleByteArrayAs$Type$s extends VarHandleByteArrayBase { ByteBufferHandle handle = (ByteBufferHandle)ob; ByteBuffer bb = (ByteBuffer) Objects.requireNonNull(obb); return convEndian(handle.be, - UNSAFE.getAndSet$RawType$Acquire( + SCOPED_MEMORY_ACCESS.getAndSet$RawType$Acquire(scope(bb), UNSAFE.getReference(bb, BYTE_BUFFER_HB), address(bb, indexRO(bb, index)), convEndian(handle.be, value))); @@ -810,7 +818,7 @@ final class VarHandleByteArrayAs$Type$s extends VarHandleByteArrayBase { ByteBufferHandle handle = (ByteBufferHandle)ob; ByteBuffer bb = (ByteBuffer) Objects.requireNonNull(obb); return convEndian(handle.be, - UNSAFE.getAndSet$RawType$Release( + SCOPED_MEMORY_ACCESS.getAndSet$RawType$Release(scope(bb), UNSAFE.getReference(bb, BYTE_BUFFER_HB), address(bb, indexRO(bb, index)), convEndian(handle.be, value))); @@ -823,7 +831,7 @@ final class VarHandleByteArrayAs$Type$s extends VarHandleByteArrayBase { ByteBufferHandle handle = (ByteBufferHandle)ob; ByteBuffer bb = (ByteBuffer) Objects.requireNonNull(obb); if (handle.be == BE) { - return UNSAFE.getAndAdd$RawType$( + return SCOPED_MEMORY_ACCESS.getAndAdd$RawType$(scope(bb), UNSAFE.getReference(bb, BYTE_BUFFER_HB), address(bb, indexRO(bb, index)), delta); @@ -837,7 +845,7 @@ final class VarHandleByteArrayAs$Type$s extends VarHandleByteArrayBase { ByteBufferHandle handle = (ByteBufferHandle)ob; ByteBuffer bb = (ByteBuffer) Objects.requireNonNull(obb); if (handle.be == BE) { - return UNSAFE.getAndAdd$RawType$Acquire( + return SCOPED_MEMORY_ACCESS.getAndAdd$RawType$Acquire(scope(bb), UNSAFE.getReference(bb, BYTE_BUFFER_HB), address(bb, indexRO(bb, index)), delta); @@ -851,7 +859,7 @@ final class VarHandleByteArrayAs$Type$s extends VarHandleByteArrayBase { ByteBufferHandle handle = (ByteBufferHandle)ob; ByteBuffer bb = (ByteBuffer) Objects.requireNonNull(obb); if (handle.be == BE) { - return UNSAFE.getAndAdd$RawType$Release( + return SCOPED_MEMORY_ACCESS.getAndAdd$RawType$Release(scope(bb), UNSAFE.getReference(bb, BYTE_BUFFER_HB), address(bb, indexRO(bb, index)), delta); @@ -866,7 +874,7 @@ final class VarHandleByteArrayAs$Type$s extends VarHandleByteArrayBase { Object base = UNSAFE.getReference(bb, BYTE_BUFFER_HB); long offset = address(bb, indexRO(bb, index)); do { - nativeExpectedValue = UNSAFE.get$RawType$Volatile(base, offset); + nativeExpectedValue = SCOPED_MEMORY_ACCESS.get$RawType$Volatile(scope(bb), base, offset); expectedValue = $RawBoxType$.reverseBytes(nativeExpectedValue); } while (!UNSAFE.weakCompareAndSet$RawType$(base, offset, nativeExpectedValue, $RawBoxType$.reverseBytes(expectedValue + delta))); @@ -880,7 +888,7 @@ final class VarHandleByteArrayAs$Type$s extends VarHandleByteArrayBase { ByteBufferHandle handle = (ByteBufferHandle)ob; ByteBuffer bb = (ByteBuffer) Objects.requireNonNull(obb); if (handle.be == BE) { - return UNSAFE.getAndBitwiseOr$RawType$( + return SCOPED_MEMORY_ACCESS.getAndBitwiseOr$RawType$(scope(bb), UNSAFE.getReference(bb, BYTE_BUFFER_HB), address(bb, indexRO(bb, index)), value); @@ -894,7 +902,7 @@ final class VarHandleByteArrayAs$Type$s extends VarHandleByteArrayBase { ByteBufferHandle handle = (ByteBufferHandle)ob; ByteBuffer bb = (ByteBuffer) Objects.requireNonNull(obb); if (handle.be == BE) { - return UNSAFE.getAndBitwiseOr$RawType$Release( + return SCOPED_MEMORY_ACCESS.getAndBitwiseOr$RawType$Release(scope(bb), UNSAFE.getReference(bb, BYTE_BUFFER_HB), address(bb, indexRO(bb, index)), value); @@ -908,7 +916,7 @@ final class VarHandleByteArrayAs$Type$s extends VarHandleByteArrayBase { ByteBufferHandle handle = (ByteBufferHandle)ob; ByteBuffer bb = (ByteBuffer) Objects.requireNonNull(obb); if (handle.be == BE) { - return UNSAFE.getAndBitwiseOr$RawType$Acquire( + return SCOPED_MEMORY_ACCESS.getAndBitwiseOr$RawType$Acquire(scope(bb), UNSAFE.getReference(bb, BYTE_BUFFER_HB), address(bb, indexRO(bb, index)), value); @@ -923,7 +931,7 @@ final class VarHandleByteArrayAs$Type$s extends VarHandleByteArrayBase { Object base = UNSAFE.getReference(bb, BYTE_BUFFER_HB); long offset = address(bb, indexRO(bb, index)); do { - nativeExpectedValue = UNSAFE.get$RawType$Volatile(base, offset); + nativeExpectedValue = SCOPED_MEMORY_ACCESS.get$RawType$Volatile(scope(bb), base, offset); expectedValue = $RawBoxType$.reverseBytes(nativeExpectedValue); } while (!UNSAFE.weakCompareAndSet$RawType$(base, offset, nativeExpectedValue, $RawBoxType$.reverseBytes(expectedValue | value))); @@ -935,7 +943,7 @@ final class VarHandleByteArrayAs$Type$s extends VarHandleByteArrayBase { ByteBufferHandle handle = (ByteBufferHandle)ob; ByteBuffer bb = (ByteBuffer) Objects.requireNonNull(obb); if (handle.be == BE) { - return UNSAFE.getAndBitwiseAnd$RawType$( + return SCOPED_MEMORY_ACCESS.getAndBitwiseAnd$RawType$(scope(bb), UNSAFE.getReference(bb, BYTE_BUFFER_HB), address(bb, indexRO(bb, index)), value); @@ -949,7 +957,7 @@ final class VarHandleByteArrayAs$Type$s extends VarHandleByteArrayBase { ByteBufferHandle handle = (ByteBufferHandle)ob; ByteBuffer bb = (ByteBuffer) Objects.requireNonNull(obb); if (handle.be == BE) { - return UNSAFE.getAndBitwiseAnd$RawType$Release( + return SCOPED_MEMORY_ACCESS.getAndBitwiseAnd$RawType$Release(scope(bb), UNSAFE.getReference(bb, BYTE_BUFFER_HB), address(bb, indexRO(bb, index)), value); @@ -963,7 +971,7 @@ final class VarHandleByteArrayAs$Type$s extends VarHandleByteArrayBase { ByteBufferHandle handle = (ByteBufferHandle)ob; ByteBuffer bb = (ByteBuffer) Objects.requireNonNull(obb); if (handle.be == BE) { - return UNSAFE.getAndBitwiseAnd$RawType$Acquire( + return SCOPED_MEMORY_ACCESS.getAndBitwiseAnd$RawType$Acquire(scope(bb), UNSAFE.getReference(bb, BYTE_BUFFER_HB), address(bb, indexRO(bb, index)), value); @@ -978,7 +986,7 @@ final class VarHandleByteArrayAs$Type$s extends VarHandleByteArrayBase { Object base = UNSAFE.getReference(bb, BYTE_BUFFER_HB); long offset = address(bb, indexRO(bb, index)); do { - nativeExpectedValue = UNSAFE.get$RawType$Volatile(base, offset); + nativeExpectedValue = SCOPED_MEMORY_ACCESS.get$RawType$Volatile(scope(bb), base, offset); expectedValue = $RawBoxType$.reverseBytes(nativeExpectedValue); } while (!UNSAFE.weakCompareAndSet$RawType$(base, offset, nativeExpectedValue, $RawBoxType$.reverseBytes(expectedValue & value))); @@ -991,7 +999,7 @@ final class VarHandleByteArrayAs$Type$s extends VarHandleByteArrayBase { ByteBufferHandle handle = (ByteBufferHandle)ob; ByteBuffer bb = (ByteBuffer) Objects.requireNonNull(obb); if (handle.be == BE) { - return UNSAFE.getAndBitwiseXor$RawType$( + return SCOPED_MEMORY_ACCESS.getAndBitwiseXor$RawType$(scope(bb), UNSAFE.getReference(bb, BYTE_BUFFER_HB), address(bb, indexRO(bb, index)), value); @@ -1005,7 +1013,7 @@ final class VarHandleByteArrayAs$Type$s extends VarHandleByteArrayBase { ByteBufferHandle handle = (ByteBufferHandle)ob; ByteBuffer bb = (ByteBuffer) Objects.requireNonNull(obb); if (handle.be == BE) { - return UNSAFE.getAndBitwiseXor$RawType$Release( + return SCOPED_MEMORY_ACCESS.getAndBitwiseXor$RawType$Release(scope(bb), UNSAFE.getReference(bb, BYTE_BUFFER_HB), address(bb, indexRO(bb, index)), value); @@ -1019,7 +1027,7 @@ final class VarHandleByteArrayAs$Type$s extends VarHandleByteArrayBase { ByteBufferHandle handle = (ByteBufferHandle)ob; ByteBuffer bb = (ByteBuffer) Objects.requireNonNull(obb); if (handle.be == BE) { - return UNSAFE.getAndBitwiseXor$RawType$Acquire( + return SCOPED_MEMORY_ACCESS.getAndBitwiseXor$RawType$Acquire(scope(bb), UNSAFE.getReference(bb, BYTE_BUFFER_HB), address(bb, indexRO(bb, index)), value); @@ -1034,7 +1042,7 @@ final class VarHandleByteArrayAs$Type$s extends VarHandleByteArrayBase { Object base = UNSAFE.getReference(bb, BYTE_BUFFER_HB); long offset = address(bb, indexRO(bb, index)); do { - nativeExpectedValue = UNSAFE.get$RawType$Volatile(base, offset); + nativeExpectedValue = SCOPED_MEMORY_ACCESS.get$RawType$Volatile(scope(bb), base, offset); expectedValue = $RawBoxType$.reverseBytes(nativeExpectedValue); } while (!UNSAFE.weakCompareAndSet$RawType$(base, offset, nativeExpectedValue, $RawBoxType$.reverseBytes(expectedValue ^ value))); diff --git a/src/java.base/share/classes/java/lang/invoke/X-VarHandleMemoryAccess.java.template b/src/java.base/share/classes/java/lang/invoke/X-VarHandleMemoryAccess.java.template index 49b18c124f9c4..5dbeed68ddd9e 100644 --- a/src/java.base/share/classes/java/lang/invoke/X-VarHandleMemoryAccess.java.template +++ b/src/java.base/share/classes/java/lang/invoke/X-VarHandleMemoryAccess.java.template @@ -24,21 +24,37 @@ */ package java.lang.invoke; -import jdk.internal.access.foreign.MemoryAddressProxy; +import jdk.internal.access.foreign.MemorySegmentProxy; +import jdk.internal.misc.ScopedMemoryAccess; import jdk.internal.vm.annotation.ForceInline; +import java.lang.ref.Reference; + import java.util.Objects; import static java.lang.invoke.MethodHandleStatics.UNSAFE; #warn -final class MemoryAccessVarHandle$Type$Helper { +final class MemoryAccessVarHandle$Type$Helper extends MemoryAccessVarHandleBase { static final boolean BE = UNSAFE.isBigEndian(); + + static final ScopedMemoryAccess SCOPED_MEMORY_ACCESS = ScopedMemoryAccess.getScopedMemoryAccess(); static final int VM_ALIGN = $BoxType$.BYTES - 1; + static final VarForm FORM = new VarForm(MemoryAccessVarHandle$Type$Helper.class, MemorySegmentProxy.class, $type$.class, long.class); + + MemoryAccessVarHandle$Type$Helper(boolean skipAlignmentMaskCheck, boolean be, long length, long alignmentMask) { + super(FORM, skipAlignmentMaskCheck, be, length, alignmentMask); + } + + @Override + final MethodType accessModeTypeUncached(AccessMode accessMode) { + return accessMode.at.accessModeType(MemorySegmentProxy.class, $type$.class, long.class); + } + #if[floatingPoint] @ForceInline static $rawType$ convEndian(boolean big, $type$ v) { @@ -66,15 +82,15 @@ final class MemoryAccessVarHandle$Type$Helper { #end[floatingPoint] @ForceInline - static MemoryAddressProxy checkAddress(Object obb, long offset, long length, boolean ro) { - MemoryAddressProxy oo = (MemoryAddressProxy)Objects.requireNonNull(obb); + static MemorySegmentProxy checkAddress(Object obb, long offset, long length, boolean ro) { + MemorySegmentProxy oo = (MemorySegmentProxy)Objects.requireNonNull(obb); oo.checkAccess(offset, length, ro); return oo; } - + @ForceInline - static long offset(MemoryAddressProxy bb, long offset, long alignmentMask) { - long address = offsetNoVMAlignCheck(bb, offset, alignmentMask); + static long offset(boolean skipAlignmentMaskCheck, MemorySegmentProxy bb, long offset, long alignmentMask) { + long address = offsetNoVMAlignCheck(skipAlignmentMaskCheck, bb, offset, alignmentMask); if ((address & VM_ALIGN) != 0) { throw MemoryAccessVarHandleBase.newIllegalStateExceptionForMisalignedAccess(address); } @@ -82,60 +98,66 @@ final class MemoryAccessVarHandle$Type$Helper { } @ForceInline - static long offsetNoVMAlignCheck(MemoryAddressProxy bb, long offset, long alignmentMask) { + static long offsetNoVMAlignCheck(boolean skipAlignmentMaskCheck, MemorySegmentProxy bb, long offset, long alignmentMask) { long base = bb.unsafeGetOffset(); long address = base + offset; - //note: the offset portion has already been aligned-checked, by construction - if ((base & alignmentMask) != 0) { - throw MemoryAccessVarHandleBase.newIllegalStateExceptionForMisalignedAccess(address); + if (skipAlignmentMaskCheck) { + //note: the offset portion has already been aligned-checked, by construction + if ((base & alignmentMask) != 0) { + throw MemoryAccessVarHandleBase.newIllegalStateExceptionForMisalignedAccess(address); + } + } else { + if ((address & alignmentMask) != 0) { + throw MemoryAccessVarHandleBase.newIllegalStateExceptionForMisalignedAccess(address); + } } return address; } - + @ForceInline - static $type$ get0(VarHandle ob, Object obb, long base) { + static $type$ get(VarHandle ob, Object obb, long base) { MemoryAccessVarHandleBase handle = (MemoryAccessVarHandleBase)ob; - MemoryAddressProxy bb = checkAddress(obb, base, handle.length, true); + MemorySegmentProxy bb = checkAddress(obb, base, handle.length, true); #if[floatingPoint] - $rawType$ rawValue = UNSAFE.get$RawType$Unaligned( + $rawType$ rawValue = SCOPED_MEMORY_ACCESS.get$RawType$Unaligned(bb.scope(), bb.unsafeGetBase(), - offsetNoVMAlignCheck(bb, base, handle.alignmentMask), + offsetNoVMAlignCheck(handle.skipAlignmentMaskCheck, bb, base, handle.alignmentMask), handle.be); return $Type$.$rawType$BitsTo$Type$(rawValue); #else[floatingPoint] #if[byte] - return UNSAFE.get$Type$( + return SCOPED_MEMORY_ACCESS.get$Type$(bb.scope(), bb.unsafeGetBase(), - offsetNoVMAlignCheck(bb, base, handle.alignmentMask)); + offsetNoVMAlignCheck(handle.skipAlignmentMaskCheck, bb, base, handle.alignmentMask)); #else[byte] - return UNSAFE.get$Type$Unaligned( + return SCOPED_MEMORY_ACCESS.get$Type$Unaligned(bb.scope(), bb.unsafeGetBase(), - offsetNoVMAlignCheck(bb, base, handle.alignmentMask), + offsetNoVMAlignCheck(handle.skipAlignmentMaskCheck, bb, base, handle.alignmentMask), handle.be); #end[byte] #end[floatingPoint] } @ForceInline - static void set0(VarHandle ob, Object obb, long base, $type$ value) { + static void set(VarHandle ob, Object obb, long base, $type$ value) { MemoryAccessVarHandleBase handle = (MemoryAccessVarHandleBase)ob; - MemoryAddressProxy bb = checkAddress(obb, base, handle.length, false); + MemorySegmentProxy bb = checkAddress(obb, base, handle.length, false); #if[floatingPoint] - UNSAFE.put$RawType$Unaligned( + SCOPED_MEMORY_ACCESS.put$RawType$Unaligned(bb.scope(), bb.unsafeGetBase(), - offsetNoVMAlignCheck(bb, base, handle.alignmentMask), + offsetNoVMAlignCheck(handle.skipAlignmentMaskCheck, bb, base, handle.alignmentMask), $Type$.$type$ToRaw$RawType$Bits(value), handle.be); #else[floatingPoint] #if[byte] - UNSAFE.put$Type$( + SCOPED_MEMORY_ACCESS.put$Type$(bb.scope(), bb.unsafeGetBase(), - offsetNoVMAlignCheck(bb, base, handle.alignmentMask), + offsetNoVMAlignCheck(handle.skipAlignmentMaskCheck, bb, base, handle.alignmentMask), value); #else[byte] - UNSAFE.put$Type$Unaligned( + SCOPED_MEMORY_ACCESS.put$Type$Unaligned(bb.scope(), bb.unsafeGetBase(), - offsetNoVMAlignCheck(bb, base, handle.alignmentMask), + offsetNoVMAlignCheck(handle.skipAlignmentMaskCheck, bb, base, handle.alignmentMask), value, handle.be); #end[byte] @@ -143,234 +165,234 @@ final class MemoryAccessVarHandle$Type$Helper { } @ForceInline - static $type$ getVolatile0(VarHandle ob, Object obb, long base) { + static $type$ getVolatile(VarHandle ob, Object obb, long base) { MemoryAccessVarHandleBase handle = (MemoryAccessVarHandleBase)ob; - MemoryAddressProxy bb = checkAddress(obb, base, handle.length, true); + MemorySegmentProxy bb = checkAddress(obb, base, handle.length, true); return convEndian(handle.be, - UNSAFE.get$RawType$Volatile( + SCOPED_MEMORY_ACCESS.get$RawType$Volatile(bb.scope(), bb.unsafeGetBase(), - offset(bb, base, handle.alignmentMask))); + offset(handle.skipAlignmentMaskCheck, bb, base, handle.alignmentMask))); } @ForceInline - static void setVolatile0(VarHandle ob, Object obb, long base, $type$ value) { + static void setVolatile(VarHandle ob, Object obb, long base, $type$ value) { MemoryAccessVarHandleBase handle = (MemoryAccessVarHandleBase)ob; - MemoryAddressProxy bb = checkAddress(obb, base, handle.length, false); - UNSAFE.put$RawType$Volatile( + MemorySegmentProxy bb = checkAddress(obb, base, handle.length, false); + SCOPED_MEMORY_ACCESS.put$RawType$Volatile(bb.scope(), bb.unsafeGetBase(), - offset(bb, base, handle.alignmentMask), + offset(handle.skipAlignmentMaskCheck, bb, base, handle.alignmentMask), convEndian(handle.be, value)); } @ForceInline - static $type$ getAcquire0(VarHandle ob, Object obb, long base) { + static $type$ getAcquire(VarHandle ob, Object obb, long base) { MemoryAccessVarHandleBase handle = (MemoryAccessVarHandleBase)ob; - MemoryAddressProxy bb = checkAddress(obb, base, handle.length, true); + MemorySegmentProxy bb = checkAddress(obb, base, handle.length, true); return convEndian(handle.be, - UNSAFE.get$RawType$Acquire( + SCOPED_MEMORY_ACCESS.get$RawType$Acquire(bb.scope(), bb.unsafeGetBase(), - offset(bb, base, handle.alignmentMask))); + offset(handle.skipAlignmentMaskCheck, bb, base, handle.alignmentMask))); } @ForceInline - static void setRelease0(VarHandle ob, Object obb, long base, $type$ value) { + static void setRelease(VarHandle ob, Object obb, long base, $type$ value) { MemoryAccessVarHandleBase handle = (MemoryAccessVarHandleBase)ob; - MemoryAddressProxy bb = checkAddress(obb, base, handle.length, false); - UNSAFE.put$RawType$Release( + MemorySegmentProxy bb = checkAddress(obb, base, handle.length, false); + SCOPED_MEMORY_ACCESS.put$RawType$Release(bb.scope(), bb.unsafeGetBase(), - offset(bb, base, handle.alignmentMask), + offset(handle.skipAlignmentMaskCheck, bb, base, handle.alignmentMask), convEndian(handle.be, value)); } @ForceInline - static $type$ getOpaque0(VarHandle ob, Object obb, long base) { + static $type$ getOpaque(VarHandle ob, Object obb, long base) { MemoryAccessVarHandleBase handle = (MemoryAccessVarHandleBase)ob; - MemoryAddressProxy bb = checkAddress(obb, base, handle.length, true); + MemorySegmentProxy bb = checkAddress(obb, base, handle.length, true); return convEndian(handle.be, - UNSAFE.get$RawType$Opaque( + SCOPED_MEMORY_ACCESS.get$RawType$Opaque(bb.scope(), bb.unsafeGetBase(), - offset(bb, base, handle.alignmentMask))); + offset(handle.skipAlignmentMaskCheck, bb, base, handle.alignmentMask))); } @ForceInline - static void setOpaque0(VarHandle ob, Object obb, long base, $type$ value) { + static void setOpaque(VarHandle ob, Object obb, long base, $type$ value) { MemoryAccessVarHandleBase handle = (MemoryAccessVarHandleBase)ob; - MemoryAddressProxy bb = checkAddress(obb, base, handle.length, false); - UNSAFE.put$RawType$Opaque( + MemorySegmentProxy bb = checkAddress(obb, base, handle.length, false); + SCOPED_MEMORY_ACCESS.put$RawType$Opaque(bb.scope(), bb.unsafeGetBase(), - offset(bb, base, handle.alignmentMask), + offset(handle.skipAlignmentMaskCheck, bb, base, handle.alignmentMask), convEndian(handle.be, value)); } #if[CAS] @ForceInline - static boolean compareAndSet0(VarHandle ob, Object obb, long base, $type$ expected, $type$ value) { + static boolean compareAndSet(VarHandle ob, Object obb, long base, $type$ expected, $type$ value) { MemoryAccessVarHandleBase handle = (MemoryAccessVarHandleBase)ob; - MemoryAddressProxy bb = checkAddress(obb, base, handle.length, false); - return UNSAFE.compareAndSet$RawType$( + MemorySegmentProxy bb = checkAddress(obb, base, handle.length, false); + return SCOPED_MEMORY_ACCESS.compareAndSet$RawType$(bb.scope(), bb.unsafeGetBase(), - offset(bb, base, handle.alignmentMask), + offset(handle.skipAlignmentMaskCheck, bb, base, handle.alignmentMask), convEndian(handle.be, expected), convEndian(handle.be, value)); } @ForceInline - static $type$ compareAndExchange0(VarHandle ob, Object obb, long base, $type$ expected, $type$ value) { + static $type$ compareAndExchange(VarHandle ob, Object obb, long base, $type$ expected, $type$ value) { MemoryAccessVarHandleBase handle = (MemoryAccessVarHandleBase)ob; - MemoryAddressProxy bb = checkAddress(obb, base, handle.length, false); + MemorySegmentProxy bb = checkAddress(obb, base, handle.length, false); return convEndian(handle.be, - UNSAFE.compareAndExchange$RawType$( + SCOPED_MEMORY_ACCESS.compareAndExchange$RawType$(bb.scope(), bb.unsafeGetBase(), - offset(bb, base, handle.alignmentMask), + offset(handle.skipAlignmentMaskCheck, bb, base, handle.alignmentMask), convEndian(handle.be, expected), convEndian(handle.be, value))); } @ForceInline - static $type$ compareAndExchangeAcquire0(VarHandle ob, Object obb, long base, $type$ expected, $type$ value) { + static $type$ compareAndExchangeAcquire(VarHandle ob, Object obb, long base, $type$ expected, $type$ value) { MemoryAccessVarHandleBase handle = (MemoryAccessVarHandleBase)ob; - MemoryAddressProxy bb = checkAddress(obb, base, handle.length, false); + MemorySegmentProxy bb = checkAddress(obb, base, handle.length, false); return convEndian(handle.be, - UNSAFE.compareAndExchange$RawType$Acquire( + SCOPED_MEMORY_ACCESS.compareAndExchange$RawType$Acquire(bb.scope(), bb.unsafeGetBase(), - offset(bb, base, handle.alignmentMask), + offset(handle.skipAlignmentMaskCheck, bb, base, handle.alignmentMask), convEndian(handle.be, expected), convEndian(handle.be, value))); } @ForceInline - static $type$ compareAndExchangeRelease0(VarHandle ob, Object obb, long base, $type$ expected, $type$ value) { + static $type$ compareAndExchangeRelease(VarHandle ob, Object obb, long base, $type$ expected, $type$ value) { MemoryAccessVarHandleBase handle = (MemoryAccessVarHandleBase)ob; - MemoryAddressProxy bb = checkAddress(obb, base, handle.length, false); + MemorySegmentProxy bb = checkAddress(obb, base, handle.length, false); return convEndian(handle.be, - UNSAFE.compareAndExchange$RawType$Release( + SCOPED_MEMORY_ACCESS.compareAndExchange$RawType$Release(bb.scope(), bb.unsafeGetBase(), - offset(bb, base, handle.alignmentMask), + offset(handle.skipAlignmentMaskCheck, bb, base, handle.alignmentMask), convEndian(handle.be, expected), convEndian(handle.be, value))); } @ForceInline - static boolean weakCompareAndSetPlain0(VarHandle ob, Object obb, long base, $type$ expected, $type$ value) { + static boolean weakCompareAndSetPlain(VarHandle ob, Object obb, long base, $type$ expected, $type$ value) { MemoryAccessVarHandleBase handle = (MemoryAccessVarHandleBase)ob; - MemoryAddressProxy bb = checkAddress(obb, base, handle.length, false); - return UNSAFE.weakCompareAndSet$RawType$Plain( + MemorySegmentProxy bb = checkAddress(obb, base, handle.length, false); + return SCOPED_MEMORY_ACCESS.weakCompareAndSet$RawType$Plain(bb.scope(), bb.unsafeGetBase(), - offset(bb, base, handle.alignmentMask), + offset(handle.skipAlignmentMaskCheck, bb, base, handle.alignmentMask), convEndian(handle.be, expected), convEndian(handle.be, value)); } @ForceInline - static boolean weakCompareAndSet0(VarHandle ob, Object obb, long base, $type$ expected, $type$ value) { + static boolean weakCompareAndSet(VarHandle ob, Object obb, long base, $type$ expected, $type$ value) { MemoryAccessVarHandleBase handle = (MemoryAccessVarHandleBase)ob; - MemoryAddressProxy bb = checkAddress(obb, base, handle.length, false); - return UNSAFE.weakCompareAndSet$RawType$( + MemorySegmentProxy bb = checkAddress(obb, base, handle.length, false); + return SCOPED_MEMORY_ACCESS.weakCompareAndSet$RawType$(bb.scope(), bb.unsafeGetBase(), - offset(bb, base, handle.alignmentMask), + offset(handle.skipAlignmentMaskCheck, bb, base, handle.alignmentMask), convEndian(handle.be, expected), convEndian(handle.be, value)); } @ForceInline - static boolean weakCompareAndSetAcquire0(VarHandle ob, Object obb, long base, $type$ expected, $type$ value) { + static boolean weakCompareAndSetAcquire(VarHandle ob, Object obb, long base, $type$ expected, $type$ value) { MemoryAccessVarHandleBase handle = (MemoryAccessVarHandleBase)ob; - MemoryAddressProxy bb = checkAddress(obb, base, handle.length, false); - return UNSAFE.weakCompareAndSet$RawType$Acquire( + MemorySegmentProxy bb = checkAddress(obb, base, handle.length, false); + return SCOPED_MEMORY_ACCESS.weakCompareAndSet$RawType$Acquire(bb.scope(), bb.unsafeGetBase(), - offset(bb, base, handle.alignmentMask), + offset(handle.skipAlignmentMaskCheck, bb, base, handle.alignmentMask), convEndian(handle.be, expected), convEndian(handle.be, value)); } @ForceInline - static boolean weakCompareAndSetRelease0(VarHandle ob, Object obb, long base, $type$ expected, $type$ value) { + static boolean weakCompareAndSetRelease(VarHandle ob, Object obb, long base, $type$ expected, $type$ value) { MemoryAccessVarHandleBase handle = (MemoryAccessVarHandleBase)ob; - MemoryAddressProxy bb = checkAddress(obb, base, handle.length, false); - return UNSAFE.weakCompareAndSet$RawType$Release( + MemorySegmentProxy bb = checkAddress(obb, base, handle.length, false); + return SCOPED_MEMORY_ACCESS.weakCompareAndSet$RawType$Release(bb.scope(), bb.unsafeGetBase(), - offset(bb, base, handle.alignmentMask), + offset(handle.skipAlignmentMaskCheck, bb, base, handle.alignmentMask), convEndian(handle.be, expected), convEndian(handle.be, value)); } @ForceInline - static $type$ getAndSet0(VarHandle ob, Object obb, long base, $type$ value) { + static $type$ getAndSet(VarHandle ob, Object obb, long base, $type$ value) { MemoryAccessVarHandleBase handle = (MemoryAccessVarHandleBase)ob; - MemoryAddressProxy bb = checkAddress(obb, base, handle.length, false); + MemorySegmentProxy bb = checkAddress(obb, base, handle.length, false); return convEndian(handle.be, - UNSAFE.getAndSet$RawType$( + SCOPED_MEMORY_ACCESS.getAndSet$RawType$(bb.scope(), bb.unsafeGetBase(), - offset(bb, base, handle.alignmentMask), + offset(handle.skipAlignmentMaskCheck, bb, base, handle.alignmentMask), convEndian(handle.be, value))); } @ForceInline - static $type$ getAndSetAcquire0(VarHandle ob, Object obb, long base, $type$ value) { + static $type$ getAndSetAcquire(VarHandle ob, Object obb, long base, $type$ value) { MemoryAccessVarHandleBase handle = (MemoryAccessVarHandleBase)ob; - MemoryAddressProxy bb = checkAddress(obb, base, handle.length, false); + MemorySegmentProxy bb = checkAddress(obb, base, handle.length, false); return convEndian(handle.be, - UNSAFE.getAndSet$RawType$Acquire( + SCOPED_MEMORY_ACCESS.getAndSet$RawType$Acquire(bb.scope(), bb.unsafeGetBase(), - offset(bb, base, handle.alignmentMask), + offset(handle.skipAlignmentMaskCheck, bb, base, handle.alignmentMask), convEndian(handle.be, value))); } @ForceInline - static $type$ getAndSetRelease0(VarHandle ob, Object obb, long base, $type$ value) { + static $type$ getAndSetRelease(VarHandle ob, Object obb, long base, $type$ value) { MemoryAccessVarHandleBase handle = (MemoryAccessVarHandleBase)ob; - MemoryAddressProxy bb = checkAddress(obb, base, handle.length, false); + MemorySegmentProxy bb = checkAddress(obb, base, handle.length, false); return convEndian(handle.be, - UNSAFE.getAndSet$RawType$Release( + SCOPED_MEMORY_ACCESS.getAndSet$RawType$Release(bb.scope(), bb.unsafeGetBase(), - offset(bb, base, handle.alignmentMask), + offset(handle.skipAlignmentMaskCheck, bb, base, handle.alignmentMask), convEndian(handle.be, value))); } #end[CAS] #if[AtomicAdd] @ForceInline - static $type$ getAndAdd0(VarHandle ob, Object obb, long base, $type$ delta) { + static $type$ getAndAdd(VarHandle ob, Object obb, long base, $type$ delta) { MemoryAccessVarHandleBase handle = (MemoryAccessVarHandleBase)ob; - MemoryAddressProxy bb = checkAddress(obb, base, handle.length, false); + MemorySegmentProxy bb = checkAddress(obb, base, handle.length, false); if (handle.be == BE) { - return UNSAFE.getAndAdd$RawType$( + return SCOPED_MEMORY_ACCESS.getAndAdd$RawType$(bb.scope(), bb.unsafeGetBase(), - offset(bb, base, handle.alignmentMask), + offset(handle.skipAlignmentMaskCheck, bb, base, handle.alignmentMask), delta); } else { - return getAndAddConvEndianWithCAS(bb, offset(bb, base, handle.alignmentMask), delta); + return getAndAddConvEndianWithCAS(bb, offset(handle.skipAlignmentMaskCheck, bb, base, handle.alignmentMask), delta); } } @ForceInline - static $type$ getAndAddAcquire0(VarHandle ob, Object obb, long base, $type$ delta) { + static $type$ getAndAddAcquire(VarHandle ob, Object obb, long base, $type$ delta) { MemoryAccessVarHandleBase handle = (MemoryAccessVarHandleBase)ob; - MemoryAddressProxy bb = checkAddress(obb, base, handle.length, false); + MemorySegmentProxy bb = checkAddress(obb, base, handle.length, false); if (handle.be == BE) { - return UNSAFE.getAndAdd$RawType$Acquire( + return SCOPED_MEMORY_ACCESS.getAndAdd$RawType$Acquire(bb.scope(), bb.unsafeGetBase(), - offset(bb, base, handle.alignmentMask), + offset(handle.skipAlignmentMaskCheck, bb, base, handle.alignmentMask), delta); } else { - return getAndAddConvEndianWithCAS(bb, offset(bb, base, handle.alignmentMask), delta); + return getAndAddConvEndianWithCAS(bb, offset(handle.skipAlignmentMaskCheck, bb, base, handle.alignmentMask), delta); } } @ForceInline - static $type$ getAndAddRelease0(VarHandle ob, Object obb, long base, $type$ delta) { + static $type$ getAndAddRelease(VarHandle ob, Object obb, long base, $type$ delta) { MemoryAccessVarHandleBase handle = (MemoryAccessVarHandleBase)ob; - MemoryAddressProxy bb = checkAddress(obb, base, handle.length, false); + MemorySegmentProxy bb = checkAddress(obb, base, handle.length, false); if (handle.be == BE) { - return UNSAFE.getAndAdd$RawType$Release( + return SCOPED_MEMORY_ACCESS.getAndAdd$RawType$Release(bb.scope(), bb.unsafeGetBase(), - offset(bb, base, handle.alignmentMask), + offset(handle.skipAlignmentMaskCheck, bb, base, handle.alignmentMask), delta); } else { - return getAndAddConvEndianWithCAS(bb, offset(bb, base, handle.alignmentMask), delta); + return getAndAddConvEndianWithCAS(bb, offset(handle.skipAlignmentMaskCheck, bb, base, handle.alignmentMask), delta); } } @ForceInline - static $type$ getAndAddConvEndianWithCAS(MemoryAddressProxy bb, long offset, $type$ delta) { + static $type$ getAndAddConvEndianWithCAS(MemorySegmentProxy bb, long offset, $type$ delta) { $type$ nativeExpectedValue, expectedValue; Object base = bb.unsafeGetBase(); do { - nativeExpectedValue = UNSAFE.get$RawType$Volatile(base, offset); + nativeExpectedValue = SCOPED_MEMORY_ACCESS.get$RawType$Volatile(bb.scope(),base, offset); expectedValue = $RawBoxType$.reverseBytes(nativeExpectedValue); - } while (!UNSAFE.weakCompareAndSet$RawType$(base, offset, + } while (!SCOPED_MEMORY_ACCESS.weakCompareAndSet$RawType$(bb.scope(),base, offset, nativeExpectedValue, $RawBoxType$.reverseBytes(expectedValue + delta))); return expectedValue; } @@ -378,164 +400,164 @@ final class MemoryAccessVarHandle$Type$Helper { #if[Bitwise] @ForceInline - static $type$ getAndBitwiseOr0(VarHandle ob, Object obb, long base, $type$ value) { + static $type$ getAndBitwiseOr(VarHandle ob, Object obb, long base, $type$ value) { MemoryAccessVarHandleBase handle = (MemoryAccessVarHandleBase)ob; - MemoryAddressProxy bb = checkAddress(obb, base, handle.length, false); + MemorySegmentProxy bb = checkAddress(obb, base, handle.length, false); if (handle.be == BE) { - return UNSAFE.getAndBitwiseOr$RawType$( + return SCOPED_MEMORY_ACCESS.getAndBitwiseOr$RawType$(bb.scope(), bb.unsafeGetBase(), - offset(bb, base, handle.alignmentMask), + offset(handle.skipAlignmentMaskCheck, bb, base, handle.alignmentMask), value); } else { - return getAndBitwiseOrConvEndianWithCAS(bb, offset(bb, base, handle.alignmentMask), value); + return getAndBitwiseOrConvEndianWithCAS(bb, offset(handle.skipAlignmentMaskCheck, bb, base, handle.alignmentMask), value); } } @ForceInline - static $type$ getAndBitwiseOrRelease0(VarHandle ob, Object obb, long base, $type$ value) { + static $type$ getAndBitwiseOrRelease(VarHandle ob, Object obb, long base, $type$ value) { MemoryAccessVarHandleBase handle = (MemoryAccessVarHandleBase)ob; - MemoryAddressProxy bb = checkAddress(obb, base, handle.length, false); + MemorySegmentProxy bb = checkAddress(obb, base, handle.length, false); if (handle.be == BE) { - return UNSAFE.getAndBitwiseOr$RawType$Release( + return SCOPED_MEMORY_ACCESS.getAndBitwiseOr$RawType$Release(bb.scope(), bb.unsafeGetBase(), - offset(bb, base, handle.alignmentMask), + offset(handle.skipAlignmentMaskCheck, bb, base, handle.alignmentMask), value); } else { - return getAndBitwiseOrConvEndianWithCAS(bb, offset(bb, base, handle.alignmentMask), value); + return getAndBitwiseOrConvEndianWithCAS(bb, offset(handle.skipAlignmentMaskCheck, bb, base, handle.alignmentMask), value); } } @ForceInline - static $type$ getAndBitwiseOrAcquire0(VarHandle ob, Object obb, long base, $type$ value) { + static $type$ getAndBitwiseOrAcquire(VarHandle ob, Object obb, long base, $type$ value) { MemoryAccessVarHandleBase handle = (MemoryAccessVarHandleBase)ob; - MemoryAddressProxy bb = checkAddress(obb, base, handle.length, false); + MemorySegmentProxy bb = checkAddress(obb, base, handle.length, false); if (handle.be == BE) { - return UNSAFE.getAndBitwiseOr$RawType$Acquire( + return SCOPED_MEMORY_ACCESS.getAndBitwiseOr$RawType$Acquire(bb.scope(), bb.unsafeGetBase(), - offset(bb, base, handle.alignmentMask), + offset(handle.skipAlignmentMaskCheck, bb, base, handle.alignmentMask), value); } else { - return getAndBitwiseOrConvEndianWithCAS(bb, offset(bb, base, handle.alignmentMask), value); + return getAndBitwiseOrConvEndianWithCAS(bb, offset(handle.skipAlignmentMaskCheck, bb, base, handle.alignmentMask), value); } } @ForceInline - static $type$ getAndBitwiseOrConvEndianWithCAS(MemoryAddressProxy bb, long offset, $type$ value) { + static $type$ getAndBitwiseOrConvEndianWithCAS(MemorySegmentProxy bb, long offset, $type$ value) { $type$ nativeExpectedValue, expectedValue; Object base = bb.unsafeGetBase(); do { - nativeExpectedValue = UNSAFE.get$RawType$Volatile(base, offset); + nativeExpectedValue = SCOPED_MEMORY_ACCESS.get$RawType$Volatile(bb.scope(),base, offset); expectedValue = $RawBoxType$.reverseBytes(nativeExpectedValue); - } while (!UNSAFE.weakCompareAndSet$RawType$(base, offset, + } while (!SCOPED_MEMORY_ACCESS.weakCompareAndSet$RawType$(bb.scope(),base, offset, nativeExpectedValue, $RawBoxType$.reverseBytes(expectedValue | value))); return expectedValue; } @ForceInline - static $type$ getAndBitwiseAnd0(VarHandle ob, Object obb, long base, $type$ value) { + static $type$ getAndBitwiseAnd(VarHandle ob, Object obb, long base, $type$ value) { MemoryAccessVarHandleBase handle = (MemoryAccessVarHandleBase)ob; - MemoryAddressProxy bb = checkAddress(obb, base, handle.length, false); + MemorySegmentProxy bb = checkAddress(obb, base, handle.length, false); if (handle.be == BE) { - return UNSAFE.getAndBitwiseAnd$RawType$( + return SCOPED_MEMORY_ACCESS.getAndBitwiseAnd$RawType$(bb.scope(), bb.unsafeGetBase(), - offset(bb, base, handle.alignmentMask), + offset(handle.skipAlignmentMaskCheck, bb, base, handle.alignmentMask), value); } else { - return getAndBitwiseAndConvEndianWithCAS(bb, offset(bb, base, handle.alignmentMask), value); + return getAndBitwiseAndConvEndianWithCAS(bb, offset(handle.skipAlignmentMaskCheck, bb, base, handle.alignmentMask), value); } } @ForceInline - static $type$ getAndBitwiseAndRelease0(VarHandle ob, Object obb, long base, $type$ value) { + static $type$ getAndBitwiseAndRelease(VarHandle ob, Object obb, long base, $type$ value) { MemoryAccessVarHandleBase handle = (MemoryAccessVarHandleBase)ob; - MemoryAddressProxy bb = checkAddress(obb, base, handle.length, false); + MemorySegmentProxy bb = checkAddress(obb, base, handle.length, false); if (handle.be == BE) { - return UNSAFE.getAndBitwiseAnd$RawType$Release( + return SCOPED_MEMORY_ACCESS.getAndBitwiseAnd$RawType$Release(bb.scope(), bb.unsafeGetBase(), - offset(bb, base, handle.alignmentMask), + offset(handle.skipAlignmentMaskCheck, bb, base, handle.alignmentMask), value); } else { - return getAndBitwiseAndConvEndianWithCAS(bb, offset(bb, base, handle.alignmentMask), value); + return getAndBitwiseAndConvEndianWithCAS(bb, offset(handle.skipAlignmentMaskCheck, bb, base, handle.alignmentMask), value); } } @ForceInline - static $type$ getAndBitwiseAndAcquire0(VarHandle ob, Object obb, long base, $type$ value) { + static $type$ getAndBitwiseAndAcquire(VarHandle ob, Object obb, long base, $type$ value) { MemoryAccessVarHandleBase handle = (MemoryAccessVarHandleBase)ob; - MemoryAddressProxy bb = checkAddress(obb, base, handle.length, false); + MemorySegmentProxy bb = checkAddress(obb, base, handle.length, false); if (handle.be == BE) { - return UNSAFE.getAndBitwiseAnd$RawType$Acquire( + return SCOPED_MEMORY_ACCESS.getAndBitwiseAnd$RawType$Acquire(bb.scope(), bb.unsafeGetBase(), - offset(bb, base, handle.alignmentMask), + offset(handle.skipAlignmentMaskCheck, bb, base, handle.alignmentMask), value); } else { - return getAndBitwiseAndConvEndianWithCAS(bb, offset(bb, base, handle.alignmentMask), value); + return getAndBitwiseAndConvEndianWithCAS(bb, offset(handle.skipAlignmentMaskCheck, bb, base, handle.alignmentMask), value); } } @ForceInline - static $type$ getAndBitwiseAndConvEndianWithCAS(MemoryAddressProxy bb, long offset, $type$ value) { + static $type$ getAndBitwiseAndConvEndianWithCAS(MemorySegmentProxy bb, long offset, $type$ value) { $type$ nativeExpectedValue, expectedValue; Object base = bb.unsafeGetBase(); do { - nativeExpectedValue = UNSAFE.get$RawType$Volatile(base, offset); + nativeExpectedValue = SCOPED_MEMORY_ACCESS.get$RawType$Volatile(bb.scope(),base, offset); expectedValue = $RawBoxType$.reverseBytes(nativeExpectedValue); - } while (!UNSAFE.weakCompareAndSet$RawType$(base, offset, + } while (!SCOPED_MEMORY_ACCESS.weakCompareAndSet$RawType$(bb.scope(),base, offset, nativeExpectedValue, $RawBoxType$.reverseBytes(expectedValue & value))); return expectedValue; } @ForceInline - static $type$ getAndBitwiseXor0(VarHandle ob, Object obb, long base, $type$ value) { + static $type$ getAndBitwiseXor(VarHandle ob, Object obb, long base, $type$ value) { MemoryAccessVarHandleBase handle = (MemoryAccessVarHandleBase)ob; - MemoryAddressProxy bb = checkAddress(obb, base, handle.length, false); + MemorySegmentProxy bb = checkAddress(obb, base, handle.length, false); if (handle.be == BE) { - return UNSAFE.getAndBitwiseXor$RawType$( + return SCOPED_MEMORY_ACCESS.getAndBitwiseXor$RawType$(bb.scope(), bb.unsafeGetBase(), - offset(bb, base, handle.alignmentMask), + offset(handle.skipAlignmentMaskCheck, bb, base, handle.alignmentMask), value); } else { - return getAndBitwiseXorConvEndianWithCAS(bb, offset(bb, base, handle.alignmentMask), value); + return getAndBitwiseXorConvEndianWithCAS(bb, offset(handle.skipAlignmentMaskCheck, bb, base, handle.alignmentMask), value); } } @ForceInline - static $type$ getAndBitwiseXorRelease0(VarHandle ob, Object obb, long base, $type$ value) { + static $type$ getAndBitwiseXorRelease(VarHandle ob, Object obb, long base, $type$ value) { MemoryAccessVarHandleBase handle = (MemoryAccessVarHandleBase)ob; - MemoryAddressProxy bb = checkAddress(obb, base, handle.length, false); + MemorySegmentProxy bb = checkAddress(obb, base, handle.length, false); if (handle.be == BE) { - return UNSAFE.getAndBitwiseXor$RawType$Release( + return SCOPED_MEMORY_ACCESS.getAndBitwiseXor$RawType$Release(bb.scope(), bb.unsafeGetBase(), - offset(bb, base, handle.alignmentMask), + offset(handle.skipAlignmentMaskCheck, bb, base, handle.alignmentMask), value); } else { - return getAndBitwiseXorConvEndianWithCAS(bb, offset(bb, base, handle.alignmentMask), value); + return getAndBitwiseXorConvEndianWithCAS(bb, offset(handle.skipAlignmentMaskCheck, bb, base, handle.alignmentMask), value); } } @ForceInline - static $type$ getAndBitwiseXorAcquire0(VarHandle ob, Object obb, long base, $type$ value) { + static $type$ getAndBitwiseXorAcquire(VarHandle ob, Object obb, long base, $type$ value) { MemoryAccessVarHandleBase handle = (MemoryAccessVarHandleBase)ob; - MemoryAddressProxy bb = checkAddress(obb, base, handle.length, false); + MemorySegmentProxy bb = checkAddress(obb, base, handle.length, false); if (handle.be == BE) { - return UNSAFE.getAndBitwiseXor$RawType$Acquire( + return SCOPED_MEMORY_ACCESS.getAndBitwiseXor$RawType$Acquire(bb.scope(), bb.unsafeGetBase(), - offset(bb, base, handle.alignmentMask), + offset(handle.skipAlignmentMaskCheck, bb, base, handle.alignmentMask), value); } else { - return getAndBitwiseXorConvEndianWithCAS(bb, offset(bb, base, handle.alignmentMask), value); + return getAndBitwiseXorConvEndianWithCAS(bb, offset(handle.skipAlignmentMaskCheck, bb, base, handle.alignmentMask), value); } } @ForceInline - static $type$ getAndBitwiseXorConvEndianWithCAS(MemoryAddressProxy bb, long offset, $type$ value) { + static $type$ getAndBitwiseXorConvEndianWithCAS(MemorySegmentProxy bb, long offset, $type$ value) { $type$ nativeExpectedValue, expectedValue; Object base = bb.unsafeGetBase(); do { - nativeExpectedValue = UNSAFE.get$RawType$Volatile(base, offset); + nativeExpectedValue = SCOPED_MEMORY_ACCESS.get$RawType$Volatile(bb.scope(),base, offset); expectedValue = $RawBoxType$.reverseBytes(nativeExpectedValue); - } while (!UNSAFE.weakCompareAndSet$RawType$(base, offset, + } while (!SCOPED_MEMORY_ACCESS.weakCompareAndSet$RawType$(bb.scope(),base, offset, nativeExpectedValue, $RawBoxType$.reverseBytes(expectedValue ^ value))); return expectedValue; } diff --git a/src/java.base/share/classes/java/nio/Bits.java b/src/java.base/share/classes/java/nio/Bits.java index 7e8b833dbea9c..262ccb4e8ac53 100644 --- a/src/java.base/share/classes/java/nio/Bits.java +++ b/src/java.base/share/classes/java/nio/Bits.java @@ -106,7 +106,7 @@ static boolean unaligned() { // These methods should be called whenever direct memory is allocated or // freed. They allow the user to control the amount of direct memory // which a process may access. All sizes are specified in bytes. - static void reserveMemory(long size, int cap) { + static void reserveMemory(long size, long cap) { if (!MEMORY_LIMIT_SET && VM.initLevel() >= 1) { MAX_MEMORY = VM.maxDirectMemory(); @@ -185,7 +185,7 @@ static void reserveMemory(long size, int cap) { } } - private static boolean tryReserveMemory(long size, int cap) { + private static boolean tryReserveMemory(long size, long cap) { // -XX:MaxDirectMemorySize limits the total capacity rather than the // actual memory usage, which will differ when buffers are page @@ -203,7 +203,7 @@ private static boolean tryReserveMemory(long size, int cap) { } - static void unreserveMemory(long size, int cap) { + static void unreserveMemory(long size, long cap) { long cnt = COUNT.decrementAndGet(); long reservedMem = RESERVED_MEMORY.addAndGet(-size); long totalCap = TOTAL_CAPACITY.addAndGet(-cap); diff --git a/src/java.base/share/classes/java/nio/Buffer.java b/src/java.base/share/classes/java/nio/Buffer.java index b47b3d2b68a31..8e286584b1fd6 100644 --- a/src/java.base/share/classes/java/nio/Buffer.java +++ b/src/java.base/share/classes/java/nio/Buffer.java @@ -29,6 +29,7 @@ import jdk.internal.access.SharedSecrets; import jdk.internal.access.foreign.MemorySegmentProxy; import jdk.internal.access.foreign.UnmapperProxy; +import jdk.internal.misc.ScopedMemoryAccess; import jdk.internal.misc.Unsafe; import jdk.internal.misc.VM.BufferPool; import jdk.internal.vm.annotation.ForceInline; @@ -193,6 +194,8 @@ public abstract class Buffer { // Cached unsafe-access object static final Unsafe UNSAFE = Unsafe.getUnsafe(); + static final ScopedMemoryAccess SCOPED_MEMORY_ACCESS = ScopedMemoryAccess.getScopedMemoryAccess(); + /** * The characteristics of Spliterators that traverse and split elements * maintained in Buffers. @@ -754,9 +757,18 @@ final void discardMark() { // package-private } @ForceInline - final void checkSegment() { + final ScopedMemoryAccess.Scope scope() { if (segment != null) { - segment.checkValidState(); + return segment.scope(); + } else { + return null; + } + } + + final void checkScope() { + ScopedMemoryAccess.Scope scope = scope(); + if (scope != null) { + scope.checkValidState(); } } @@ -827,6 +839,21 @@ public void unload(long address, boolean isSync, long size) { public boolean isLoaded(long address, boolean isSync, long size) { return MappedMemoryUtils.isLoaded(address, isSync, size); } + + @Override + public void reserveMemory(long size, long cap) { + Bits.reserveMemory(size, cap); + } + + @Override + public void unreserveMemory(long size, long cap) { + Bits.unreserveMemory(size, cap); + } + + @Override + public int pageSize() { + return Bits.pageSize(); + } }); } diff --git a/src/java.base/share/classes/java/nio/BufferMismatch.java b/src/java.base/share/classes/java/nio/BufferMismatch.java index 4a69eb6d99c79..8a6069d751b73 100644 --- a/src/java.base/share/classes/java/nio/BufferMismatch.java +++ b/src/java.base/share/classes/java/nio/BufferMismatch.java @@ -24,6 +24,7 @@ */ package java.nio; +import jdk.internal.misc.ScopedMemoryAccess; import jdk.internal.util.ArraysSupport; /** @@ -31,12 +32,14 @@ */ final class BufferMismatch { + final static ScopedMemoryAccess SCOPED_MEMORY_ACCESS = ScopedMemoryAccess.getScopedMemoryAccess(); + static int mismatch(ByteBuffer a, int aOff, ByteBuffer b, int bOff, int length) { int i = 0; if (length > 7) { if (a.get(aOff) != b.get(bOff)) return 0; - i = ArraysSupport.vectorizedMismatch( + i = SCOPED_MEMORY_ACCESS.vectorizedMismatch(a.scope(), b.scope(), a.base(), a.address + aOff, b.base(), b.address + bOff, length, @@ -60,7 +63,7 @@ static int mismatch(CharBuffer a, int aOff, CharBuffer b, int bOff, int length) && a.charRegionOrder() != null && b.charRegionOrder() != null) { if (a.get(aOff) != b.get(bOff)) return 0; - i = ArraysSupport.vectorizedMismatch( + i = SCOPED_MEMORY_ACCESS.vectorizedMismatch(a.scope(), b.scope(), a.base(), a.address + (aOff << ArraysSupport.LOG2_ARRAY_CHAR_INDEX_SCALE), b.base(), b.address + (bOff << ArraysSupport.LOG2_ARRAY_CHAR_INDEX_SCALE), length, @@ -80,7 +83,7 @@ static int mismatch(ShortBuffer a, int aOff, ShortBuffer b, int bOff, int length if (length > 3 && a.order() == b.order()) { if (a.get(aOff) != b.get(bOff)) return 0; - i = ArraysSupport.vectorizedMismatch( + i = SCOPED_MEMORY_ACCESS.vectorizedMismatch(a.scope(), b.scope(), a.base(), a.address + (aOff << ArraysSupport.LOG2_ARRAY_SHORT_INDEX_SCALE), b.base(), b.address + (bOff << ArraysSupport.LOG2_ARRAY_SHORT_INDEX_SCALE), length, @@ -100,7 +103,7 @@ static int mismatch(IntBuffer a, int aOff, IntBuffer b, int bOff, int length) { if (length > 1 && a.order() == b.order()) { if (a.get(aOff) != b.get(bOff)) return 0; - i = ArraysSupport.vectorizedMismatch( + i = SCOPED_MEMORY_ACCESS.vectorizedMismatch(a.scope(), b.scope(), a.base(), a.address + (aOff << ArraysSupport.LOG2_ARRAY_INT_INDEX_SCALE), b.base(), b.address + (bOff << ArraysSupport.LOG2_ARRAY_INT_INDEX_SCALE), length, @@ -119,7 +122,7 @@ static int mismatch(FloatBuffer a, int aOff, FloatBuffer b, int bOff, int length int i = 0; if (length > 1 && a.order() == b.order()) { if (Float.floatToRawIntBits(a.get(aOff)) == Float.floatToRawIntBits(b.get(bOff))) { - i = ArraysSupport.vectorizedMismatch( + i = SCOPED_MEMORY_ACCESS.vectorizedMismatch(a.scope(), b.scope(), a.base(), a.address + (aOff << ArraysSupport.LOG2_ARRAY_FLOAT_INDEX_SCALE), b.base(), b.address + (bOff << ArraysSupport.LOG2_ARRAY_FLOAT_INDEX_SCALE), length, @@ -158,7 +161,7 @@ static int mismatch(LongBuffer a, int aOff, LongBuffer b, int bOff, int length) if (length > 0 && a.order() == b.order()) { if (a.get(aOff) != b.get(bOff)) return 0; - i = ArraysSupport.vectorizedMismatch( + i = SCOPED_MEMORY_ACCESS.vectorizedMismatch(a.scope(), b.scope(), a.base(), a.address + (aOff << ArraysSupport.LOG2_ARRAY_LONG_INDEX_SCALE), b.base(), b.address + (bOff << ArraysSupport.LOG2_ARRAY_LONG_INDEX_SCALE), length, @@ -176,7 +179,7 @@ static int mismatch(DoubleBuffer a, int aOff, DoubleBuffer b, int bOff, int leng int i = 0; if (length > 0 && a.order() == b.order()) { if (Double.doubleToRawLongBits(a.get(aOff)) == Double.doubleToRawLongBits(b.get(bOff))) { - i = ArraysSupport.vectorizedMismatch( + i = SCOPED_MEMORY_ACCESS.vectorizedMismatch(a.scope(), b.scope(), a.base(), a.address + (aOff << ArraysSupport.LOG2_ARRAY_DOUBLE_INDEX_SCALE), b.base(), b.address + (bOff << ArraysSupport.LOG2_ARRAY_DOUBLE_INDEX_SCALE), length, diff --git a/src/java.base/share/classes/java/nio/ByteBufferAs-X-Buffer.java.template b/src/java.base/share/classes/java/nio/ByteBufferAs-X-Buffer.java.template index 048a48a68141e..12788a2b9985f 100644 --- a/src/java.base/share/classes/java/nio/ByteBufferAs-X-Buffer.java.template +++ b/src/java.base/share/classes/java/nio/ByteBufferAs-X-Buffer.java.template @@ -130,22 +130,20 @@ class ByteBufferAs$Type$Buffer$RW$$BO$ // package-private } public $type$ get() { - checkSegment(); - $memtype$ x = UNSAFE.get$Memtype$Unaligned(bb.hb, byteOffset(nextGetIndex()), + $memtype$ x = SCOPED_MEMORY_ACCESS.get$Memtype$Unaligned(scope(), bb.hb, byteOffset(nextGetIndex()), {#if[boB]?true:false}); return $fromBits$(x); } public $type$ get(int i) { - checkSegment(); - $memtype$ x = UNSAFE.get$Memtype$Unaligned(bb.hb, byteOffset(checkIndex(i)), + $memtype$ x = SCOPED_MEMORY_ACCESS.get$Memtype$Unaligned(scope(), bb.hb, byteOffset(checkIndex(i)), {#if[boB]?true:false}); return $fromBits$(x); } #if[streamableType] $type$ getUnchecked(int i) { - $memtype$ x = UNSAFE.get$Memtype$Unaligned(bb.hb, byteOffset(i), + $memtype$ x = SCOPED_MEMORY_ACCESS.get$Memtype$Unaligned(null, bb.hb, byteOffset(i), {#if[boB]?true:false}); return $fromBits$(x); } @@ -155,9 +153,8 @@ class ByteBufferAs$Type$Buffer$RW$$BO$ // package-private public $Type$Buffer put($type$ x) { #if[rw] - checkSegment(); $memtype$ y = $toBits$(x); - UNSAFE.put$Memtype$Unaligned(bb.hb, byteOffset(nextPutIndex()), y, + SCOPED_MEMORY_ACCESS.put$Memtype$Unaligned(scope(), bb.hb, byteOffset(nextPutIndex()), y, {#if[boB]?true:false}); return this; #else[rw] @@ -167,9 +164,8 @@ class ByteBufferAs$Type$Buffer$RW$$BO$ // package-private public $Type$Buffer put(int i, $type$ x) { #if[rw] - checkSegment(); $memtype$ y = $toBits$(x); - UNSAFE.put$Memtype$Unaligned(bb.hb, byteOffset(checkIndex(i)), y, + SCOPED_MEMORY_ACCESS.put$Memtype$Unaligned(scope(), bb.hb, byteOffset(checkIndex(i)), y, {#if[boB]?true:false}); return this; #else[rw] diff --git a/src/java.base/share/classes/java/nio/Direct-X-Buffer-bin.java.template b/src/java.base/share/classes/java/nio/Direct-X-Buffer-bin.java.template index d6e0f58e0c3ab..4a1eb380f03b2 100644 --- a/src/java.base/share/classes/java/nio/Direct-X-Buffer-bin.java.template +++ b/src/java.base/share/classes/java/nio/Direct-X-Buffer-bin.java.template @@ -33,8 +33,7 @@ class XXX { private $type$ get$Type$(long a) { try { - checkSegment(); - $memtype$ x = UNSAFE.get$Memtype$Unaligned(null, a, bigEndian); + $memtype$ x = SCOPED_MEMORY_ACCESS.get$Memtype$Unaligned(scope(), null, a, bigEndian); return $fromBits$(x); } finally { Reference.reachabilityFence(this); @@ -62,9 +61,8 @@ class XXX { private ByteBuffer put$Type$(long a, $type$ x) { #if[rw] try { - checkSegment(); $memtype$ y = $toBits$(x); - UNSAFE.put$Memtype$Unaligned(null, a, y, bigEndian); + SCOPED_MEMORY_ACCESS.put$Memtype$Unaligned(scope(), null, a, y, bigEndian); } finally { Reference.reachabilityFence(this); } diff --git a/src/java.base/share/classes/java/nio/Direct-X-Buffer.java.template b/src/java.base/share/classes/java/nio/Direct-X-Buffer.java.template index 09c48e86bfc9f..270fb8f41adc3 100644 --- a/src/java.base/share/classes/java/nio/Direct-X-Buffer.java.template +++ b/src/java.base/share/classes/java/nio/Direct-X-Buffer.java.template @@ -273,8 +273,7 @@ class Direct$Type$Buffer$RW$$BO$ public $type$ get() { try { - checkSegment(); - return $fromBits$($swap$(UNSAFE.get$Swaptype$(ix(nextGetIndex())))); + return $fromBits$($swap$(SCOPED_MEMORY_ACCESS.get$Swaptype$(scope(), null, ix(nextGetIndex())))); } finally { Reference.reachabilityFence(this); } @@ -282,8 +281,7 @@ class Direct$Type$Buffer$RW$$BO$ public $type$ get(int i) { try { - checkSegment(); - return $fromBits$($swap$(UNSAFE.get$Swaptype$(ix(checkIndex(i))))); + return $fromBits$($swap$(SCOPED_MEMORY_ACCESS.get$Swaptype$(scope(), null, ix(checkIndex(i))))); } finally { Reference.reachabilityFence(this); } @@ -292,7 +290,7 @@ class Direct$Type$Buffer$RW$$BO$ #if[streamableType] $type$ getUnchecked(int i) { try { - return $fromBits$($swap$(UNSAFE.get$Swaptype$(ix(i)))); + return $fromBits$($swap$(SCOPED_MEMORY_ACCESS.get$Swaptype$(null, null, ix(i)))); } finally { Reference.reachabilityFence(this); } @@ -301,7 +299,6 @@ class Direct$Type$Buffer$RW$$BO$ public $Type$Buffer get($type$[] dst, int offset, int length) { #if[rw] - checkSegment(); if (((long)length << $LG_BYTES_PER_VALUE$) > Bits.JNI_COPY_TO_ARRAY_THRESHOLD) { Objects.checkFromIndexSize(offset, length, dst.length); int pos = position(); @@ -315,7 +312,7 @@ class Direct$Type$Buffer$RW$$BO$ try { #if[!byte] if (order() != ByteOrder.nativeOrder()) - UNSAFE.copySwapMemory(null, + SCOPED_MEMORY_ACCESS.copySwapMemory(scope(), null, null, ix(pos), dst, dstOffset, @@ -323,7 +320,7 @@ class Direct$Type$Buffer$RW$$BO$ (long)1 << $LG_BYTES_PER_VALUE$); else #end[!byte] - UNSAFE.copyMemory(null, + SCOPED_MEMORY_ACCESS.copyMemory(scope(), null, null, ix(pos), dst, dstOffset, @@ -343,7 +340,6 @@ class Direct$Type$Buffer$RW$$BO$ public $Type$Buffer get(int index, $type$[] dst, int offset, int length) { #if[rw] - checkSegment(); if (((long)length << $LG_BYTES_PER_VALUE$) > Bits.JNI_COPY_TO_ARRAY_THRESHOLD) { Objects.checkFromIndexSize(index, length, limit()); Objects.checkFromIndexSize(offset, length, dst.length); @@ -352,7 +348,7 @@ class Direct$Type$Buffer$RW$$BO$ try { #if[!byte] if (order() != ByteOrder.nativeOrder()) - UNSAFE.copySwapMemory(null, + SCOPED_MEMORY_ACCESS.copySwapMemory(scope(), null, null, ix(index), dst, dstOffset, @@ -360,7 +356,7 @@ class Direct$Type$Buffer$RW$$BO$ (long)1 << $LG_BYTES_PER_VALUE$); else #end[!byte] - UNSAFE.copyMemory(null, + SCOPED_MEMORY_ACCESS.copyMemory(scope(), null, null, ix(index), dst, dstOffset, @@ -381,8 +377,7 @@ class Direct$Type$Buffer$RW$$BO$ public $Type$Buffer put($type$ x) { #if[rw] try { - checkSegment(); - UNSAFE.put$Swaptype$(ix(nextPutIndex()), $swap$($toBits$(x))); + SCOPED_MEMORY_ACCESS.put$Swaptype$(scope(), null, ix(nextPutIndex()), $swap$($toBits$(x))); } finally { Reference.reachabilityFence(this); } @@ -395,8 +390,7 @@ class Direct$Type$Buffer$RW$$BO$ public $Type$Buffer put(int i, $type$ x) { #if[rw] try { - checkSegment(); - UNSAFE.put$Swaptype$(ix(checkIndex(i)), $swap$($toBits$(x))); + SCOPED_MEMORY_ACCESS.put$Swaptype$(scope(), null, ix(checkIndex(i)), $swap$($toBits$(x))); } finally { Reference.reachabilityFence(this); } @@ -408,7 +402,6 @@ class Direct$Type$Buffer$RW$$BO$ public $Type$Buffer put($Type$Buffer src) { #if[rw] - checkSegment(); super.put(src); return this; #else[rw] @@ -418,7 +411,6 @@ class Direct$Type$Buffer$RW$$BO$ public $Type$Buffer put($type$[] src, int offset, int length) { #if[rw] - checkSegment(); if (((long)length << $LG_BYTES_PER_VALUE$) > Bits.JNI_COPY_FROM_ARRAY_THRESHOLD) { Objects.checkFromIndexSize(offset, length, src.length); int pos = position(); @@ -432,7 +424,7 @@ class Direct$Type$Buffer$RW$$BO$ try { #if[!byte] if (order() != ByteOrder.nativeOrder()) - UNSAFE.copySwapMemory(src, + SCOPED_MEMORY_ACCESS.copySwapMemory(scope(), null, src, srcOffset, null, ix(pos), @@ -440,7 +432,7 @@ class Direct$Type$Buffer$RW$$BO$ (long)1 << $LG_BYTES_PER_VALUE$); else #end[!byte] - UNSAFE.copyMemory(src, + SCOPED_MEMORY_ACCESS.copyMemory(scope(), null, src, srcOffset, null, ix(pos), @@ -460,7 +452,6 @@ class Direct$Type$Buffer$RW$$BO$ public $Type$Buffer put(int index, $type$[] src, int offset, int length) { #if[rw] - checkSegment(); if (((long)length << $LG_BYTES_PER_VALUE$) > Bits.JNI_COPY_FROM_ARRAY_THRESHOLD) { Objects.checkFromIndexSize(index, length, limit()); Objects.checkFromIndexSize(offset, length, src.length); @@ -470,7 +461,7 @@ class Direct$Type$Buffer$RW$$BO$ try { #if[!byte] if (order() != ByteOrder.nativeOrder()) - UNSAFE.copySwapMemory(src, + SCOPED_MEMORY_ACCESS.copySwapMemory(scope(), null, src, srcOffset, null, ix(index), @@ -478,7 +469,7 @@ class Direct$Type$Buffer$RW$$BO$ (long)1 << $LG_BYTES_PER_VALUE$); else #end[!byte] - UNSAFE.copyMemory(src, + SCOPED_MEMORY_ACCESS.copyMemory(scope(), null, src, srcOffset, null, ix(index), @@ -502,7 +493,7 @@ class Direct$Type$Buffer$RW$$BO$ assert (pos <= lim); int rem = (pos <= lim ? lim - pos : 0); try { - UNSAFE.copyMemory(ix(pos), ix(0), (long)rem << $LG_BYTES_PER_VALUE$); + SCOPED_MEMORY_ACCESS.copyMemory(scope(), null, null, ix(pos), null, ix(0), (long)rem << $LG_BYTES_PER_VALUE$); } finally { Reference.reachabilityFence(this); } diff --git a/src/java.base/share/classes/java/nio/Heap-X-Buffer.java.template b/src/java.base/share/classes/java/nio/Heap-X-Buffer.java.template index 263e699ac1f23..5c6d488d591e4 100644 --- a/src/java.base/share/classes/java/nio/Heap-X-Buffer.java.template +++ b/src/java.base/share/classes/java/nio/Heap-X-Buffer.java.template @@ -162,12 +162,10 @@ class Heap$Type$Buffer$RW$ #end[byte] public $type$ get() { - checkSegment(); return hb[ix(nextGetIndex())]; } public $type$ get(int i) { - checkSegment(); return hb[ix(checkIndex(i))]; } @@ -178,7 +176,7 @@ class Heap$Type$Buffer$RW$ #end[streamableType] public $Type$Buffer get($type$[] dst, int offset, int length) { - checkSegment(); + checkScope(); Objects.checkFromIndexSize(offset, length, dst.length); int pos = position(); if (length > limit() - pos) @@ -189,7 +187,7 @@ class Heap$Type$Buffer$RW$ } public $Type$Buffer get(int index, $type$[] dst, int offset, int length) { - checkSegment(); + checkScope(); Objects.checkFromIndexSize(index, length, limit()); Objects.checkFromIndexSize(offset, length, dst.length); System.arraycopy(hb, ix(index), dst, offset, length); @@ -208,7 +206,6 @@ class Heap$Type$Buffer$RW$ public $Type$Buffer put($type$ x) { #if[rw] - checkSegment(); hb[ix(nextPutIndex())] = x; return this; #else[rw] @@ -218,7 +215,6 @@ class Heap$Type$Buffer$RW$ public $Type$Buffer put(int i, $type$ x) { #if[rw] - checkSegment(); hb[ix(checkIndex(i))] = x; return this; #else[rw] @@ -228,7 +224,7 @@ class Heap$Type$Buffer$RW$ public $Type$Buffer put($type$[] src, int offset, int length) { #if[rw] - checkSegment(); + checkScope(); Objects.checkFromIndexSize(offset, length, src.length); int pos = position(); if (length > limit() - pos) @@ -243,7 +239,7 @@ class Heap$Type$Buffer$RW$ public $Type$Buffer put($Type$Buffer src) { #if[rw] - checkSegment(); + checkScope(); super.put(src); return this; #else[rw] @@ -253,7 +249,7 @@ class Heap$Type$Buffer$RW$ public $Type$Buffer put(int index, $type$[] src, int offset, int length) { #if[rw] - checkSegment(); + checkScope(); Objects.checkFromIndexSize(index, length, limit()); Objects.checkFromIndexSize(offset, length, src.length); System.arraycopy(src, offset, hb, ix(index), length); @@ -266,7 +262,7 @@ class Heap$Type$Buffer$RW$ #if[char] public $Type$Buffer put(String src, int start, int end) { - checkSegment(); + checkScope(); int length = end - start; Objects.checkFromIndexSize(start, length, src.length()); if (isReadOnly()) @@ -318,20 +314,18 @@ class Heap$Type$Buffer$RW$ #if[rw] public char getChar() { - checkSegment(); - return UNSAFE.getCharUnaligned(hb, byteOffset(nextGetIndex(2)), bigEndian); + return SCOPED_MEMORY_ACCESS.getCharUnaligned(scope(), hb, byteOffset(nextGetIndex(2)), bigEndian); } public char getChar(int i) { - return UNSAFE.getCharUnaligned(hb, byteOffset(checkIndex(i, 2)), bigEndian); + return SCOPED_MEMORY_ACCESS.getCharUnaligned(scope(), hb, byteOffset(checkIndex(i, 2)), bigEndian); } #end[rw] public $Type$Buffer putChar(char x) { #if[rw] - checkSegment(); - UNSAFE.putCharUnaligned(hb, byteOffset(nextPutIndex(2)), x, bigEndian); + SCOPED_MEMORY_ACCESS.putCharUnaligned(scope(), hb, byteOffset(nextPutIndex(2)), x, bigEndian); return this; #else[rw] throw new ReadOnlyBufferException(); @@ -340,8 +334,7 @@ class Heap$Type$Buffer$RW$ public $Type$Buffer putChar(int i, char x) { #if[rw] - checkSegment(); - UNSAFE.putCharUnaligned(hb, byteOffset(checkIndex(i, 2)), x, bigEndian); + SCOPED_MEMORY_ACCESS.putCharUnaligned(scope(), hb, byteOffset(checkIndex(i, 2)), x, bigEndian); return this; #else[rw] throw new ReadOnlyBufferException(); @@ -373,21 +366,18 @@ class Heap$Type$Buffer$RW$ #if[rw] public short getShort() { - checkSegment(); - return UNSAFE.getShortUnaligned(hb, byteOffset(nextGetIndex(2)), bigEndian); + return SCOPED_MEMORY_ACCESS.getShortUnaligned(scope(), hb, byteOffset(nextGetIndex(2)), bigEndian); } public short getShort(int i) { - checkSegment(); - return UNSAFE.getShortUnaligned(hb, byteOffset(checkIndex(i, 2)), bigEndian); + return SCOPED_MEMORY_ACCESS.getShortUnaligned(scope(), hb, byteOffset(checkIndex(i, 2)), bigEndian); } #end[rw] public $Type$Buffer putShort(short x) { #if[rw] - checkSegment(); - UNSAFE.putShortUnaligned(hb, byteOffset(nextPutIndex(2)), x, bigEndian); + SCOPED_MEMORY_ACCESS.putShortUnaligned(scope(), hb, byteOffset(nextPutIndex(2)), x, bigEndian); return this; #else[rw] throw new ReadOnlyBufferException(); @@ -396,8 +386,7 @@ class Heap$Type$Buffer$RW$ public $Type$Buffer putShort(int i, short x) { #if[rw] - checkSegment(); - UNSAFE.putShortUnaligned(hb, byteOffset(checkIndex(i, 2)), x, bigEndian); + SCOPED_MEMORY_ACCESS.putShortUnaligned(scope(), hb, byteOffset(checkIndex(i, 2)), x, bigEndian); return this; #else[rw] throw new ReadOnlyBufferException(); @@ -429,21 +418,18 @@ class Heap$Type$Buffer$RW$ #if[rw] public int getInt() { - checkSegment(); - return UNSAFE.getIntUnaligned(hb, byteOffset(nextGetIndex(4)), bigEndian); + return SCOPED_MEMORY_ACCESS.getIntUnaligned(scope(), hb, byteOffset(nextGetIndex(4)), bigEndian); } public int getInt(int i) { - checkSegment(); - return UNSAFE.getIntUnaligned(hb, byteOffset(checkIndex(i, 4)), bigEndian); + return SCOPED_MEMORY_ACCESS.getIntUnaligned(scope(), hb, byteOffset(checkIndex(i, 4)), bigEndian); } #end[rw] public $Type$Buffer putInt(int x) { #if[rw] - checkSegment(); - UNSAFE.putIntUnaligned(hb, byteOffset(nextPutIndex(4)), x, bigEndian); + SCOPED_MEMORY_ACCESS.putIntUnaligned(scope(), hb, byteOffset(nextPutIndex(4)), x, bigEndian); return this; #else[rw] throw new ReadOnlyBufferException(); @@ -452,8 +438,7 @@ class Heap$Type$Buffer$RW$ public $Type$Buffer putInt(int i, int x) { #if[rw] - checkSegment(); - UNSAFE.putIntUnaligned(hb, byteOffset(checkIndex(i, 4)), x, bigEndian); + SCOPED_MEMORY_ACCESS.putIntUnaligned(scope(), hb, byteOffset(checkIndex(i, 4)), x, bigEndian); return this; #else[rw] throw new ReadOnlyBufferException(); @@ -485,21 +470,18 @@ class Heap$Type$Buffer$RW$ #if[rw] public long getLong() { - checkSegment(); - return UNSAFE.getLongUnaligned(hb, byteOffset(nextGetIndex(8)), bigEndian); + return SCOPED_MEMORY_ACCESS.getLongUnaligned(scope(), hb, byteOffset(nextGetIndex(8)), bigEndian); } public long getLong(int i) { - checkSegment(); - return UNSAFE.getLongUnaligned(hb, byteOffset(checkIndex(i, 8)), bigEndian); + return SCOPED_MEMORY_ACCESS.getLongUnaligned(scope(), hb, byteOffset(checkIndex(i, 8)), bigEndian); } #end[rw] public $Type$Buffer putLong(long x) { #if[rw] - checkSegment(); - UNSAFE.putLongUnaligned(hb, byteOffset(nextPutIndex(8)), x, bigEndian); + SCOPED_MEMORY_ACCESS.putLongUnaligned(scope(), hb, byteOffset(nextPutIndex(8)), x, bigEndian); return this; #else[rw] throw new ReadOnlyBufferException(); @@ -508,8 +490,7 @@ class Heap$Type$Buffer$RW$ public $Type$Buffer putLong(int i, long x) { #if[rw] - checkSegment(); - UNSAFE.putLongUnaligned(hb, byteOffset(checkIndex(i, 8)), x, bigEndian); + SCOPED_MEMORY_ACCESS.putLongUnaligned(scope(), hb, byteOffset(checkIndex(i, 8)), x, bigEndian); return this; #else[rw] throw new ReadOnlyBufferException(); @@ -541,14 +522,12 @@ class Heap$Type$Buffer$RW$ #if[rw] public float getFloat() { - checkSegment(); - int x = UNSAFE.getIntUnaligned(hb, byteOffset(nextGetIndex(4)), bigEndian); + int x = SCOPED_MEMORY_ACCESS.getIntUnaligned(scope(), hb, byteOffset(nextGetIndex(4)), bigEndian); return Float.intBitsToFloat(x); } public float getFloat(int i) { - checkSegment(); - int x = UNSAFE.getIntUnaligned(hb, byteOffset(checkIndex(i, 4)), bigEndian); + int x = SCOPED_MEMORY_ACCESS.getIntUnaligned(scope(), hb, byteOffset(checkIndex(i, 4)), bigEndian); return Float.intBitsToFloat(x); } @@ -556,9 +535,8 @@ class Heap$Type$Buffer$RW$ public $Type$Buffer putFloat(float x) { #if[rw] - checkSegment(); int y = Float.floatToRawIntBits(x); - UNSAFE.putIntUnaligned(hb, byteOffset(nextPutIndex(4)), y, bigEndian); + SCOPED_MEMORY_ACCESS.putIntUnaligned(scope(), hb, byteOffset(nextPutIndex(4)), y, bigEndian); return this; #else[rw] throw new ReadOnlyBufferException(); @@ -567,9 +545,8 @@ class Heap$Type$Buffer$RW$ public $Type$Buffer putFloat(int i, float x) { #if[rw] - checkSegment(); int y = Float.floatToRawIntBits(x); - UNSAFE.putIntUnaligned(hb, byteOffset(checkIndex(i, 4)), y, bigEndian); + SCOPED_MEMORY_ACCESS.putIntUnaligned(scope(), hb, byteOffset(checkIndex(i, 4)), y, bigEndian); return this; #else[rw] throw new ReadOnlyBufferException(); @@ -601,14 +578,12 @@ class Heap$Type$Buffer$RW$ #if[rw] public double getDouble() { - checkSegment(); - long x = UNSAFE.getLongUnaligned(hb, byteOffset(nextGetIndex(8)), bigEndian); + long x = SCOPED_MEMORY_ACCESS.getLongUnaligned(scope(), hb, byteOffset(nextGetIndex(8)), bigEndian); return Double.longBitsToDouble(x); } public double getDouble(int i) { - checkSegment(); - long x = UNSAFE.getLongUnaligned(hb, byteOffset(checkIndex(i, 8)), bigEndian); + long x = SCOPED_MEMORY_ACCESS.getLongUnaligned(scope(), hb, byteOffset(checkIndex(i, 8)), bigEndian); return Double.longBitsToDouble(x); } @@ -616,9 +591,8 @@ class Heap$Type$Buffer$RW$ public $Type$Buffer putDouble(double x) { #if[rw] - checkSegment(); long y = Double.doubleToRawLongBits(x); - UNSAFE.putLongUnaligned(hb, byteOffset(nextPutIndex(8)), y, bigEndian); + SCOPED_MEMORY_ACCESS.putLongUnaligned(scope(), hb, byteOffset(nextPutIndex(8)), y, bigEndian); return this; #else[rw] throw new ReadOnlyBufferException(); @@ -627,9 +601,8 @@ class Heap$Type$Buffer$RW$ public $Type$Buffer putDouble(int i, double x) { #if[rw] - checkSegment(); long y = Double.doubleToRawLongBits(x); - UNSAFE.putLongUnaligned(hb, byteOffset(checkIndex(i, 8)), y, bigEndian); + SCOPED_MEMORY_ACCESS.putLongUnaligned(scope(), hb, byteOffset(checkIndex(i, 8)), y, bigEndian); return this; #else[rw] throw new ReadOnlyBufferException(); diff --git a/src/java.base/share/classes/java/nio/X-Buffer.java.template b/src/java.base/share/classes/java/nio/X-Buffer.java.template index db59a2623157a..c9ddf053eaf67 100644 --- a/src/java.base/share/classes/java/nio/X-Buffer.java.template +++ b/src/java.base/share/classes/java/nio/X-Buffer.java.template @@ -975,7 +975,7 @@ public abstract class $Type$Buffer if (this.order() == src.order()) { #end[!byte] try { - UNSAFE.copyMemory(srcBase, + SCOPED_MEMORY_ACCESS.copyMemory(scope(), src.scope(), srcBase, srcAddr, base, addr, @@ -987,7 +987,7 @@ public abstract class $Type$Buffer #if[!byte] } else { try { - UNSAFE.copySwapMemory(srcBase, + SCOPED_MEMORY_ACCESS.copySwapMemory(scope(), src.scope(), srcBase, srcAddr, base, addr, diff --git a/src/java.base/share/classes/jdk/internal/access/JavaLangInvokeAccess.java b/src/java.base/share/classes/jdk/internal/access/JavaLangInvokeAccess.java index f47bf5efcbea5..20090014264c9 100644 --- a/src/java.base/share/classes/jdk/internal/access/JavaLangInvokeAccess.java +++ b/src/java.base/share/classes/jdk/internal/access/JavaLangInvokeAccess.java @@ -81,44 +81,8 @@ public interface JavaLangInvokeAccess { * Used by {@code jdk.internal.foreign.LayoutPath} and * {@code jdk.incubator.foreign.MemoryHandles}. */ - VarHandle memoryAccessVarHandle(Class carrier, long alignmentMask, - ByteOrder order, long offset, long[] strides); - - /** - * Is {@code handle} a memory access varhandle? - * Used by {@code jdk.incubator.foreign.MemoryHandles}. - */ - boolean isMemoryAccessVarHandle(VarHandle handle); - - /** - * Returns the carrier associated with a memory access var handle. - * Used by {@code jdk.incubator.foreign.MemoryHandles}. - */ - Class memoryAddressCarrier(VarHandle handle); - - /** - * Returns the alignment mask associated with a memory access var handle. - * Used by {@code jdk.incubator.foreign.MemoryHandles}. - */ - long memoryAddressAlignmentMask(VarHandle handle); - - /** - * Returns the byte order associated with a memory access var handle. - * Used by {@code jdk.incubator.foreign.MemoryHandles}. - */ - ByteOrder memoryAddressByteOrder(VarHandle handle); - - /** - * Returns the offset associated with a memory access var handle. - * Used by {@code jdk.incubator.foreign.MemoryHandles}. - */ - long memoryAddressOffset(VarHandle handle); - - /** - * Returns the strides associated with a memory access var handle. - * Used by {@code jdk.incubator.foreign.MemoryHandles}. - */ - long[] memoryAddressStrides(VarHandle handle); + VarHandle memoryAccessVarHandle(Class carrier, boolean skipAlignmentMaskCheck, long alignmentMask, + ByteOrder order); /** * Var handle carrier combinator. diff --git a/src/java.base/share/classes/jdk/internal/access/JavaNioAccess.java b/src/java.base/share/classes/jdk/internal/access/JavaNioAccess.java index 3baf67cad7739..aedac5960f8f3 100644 --- a/src/java.base/share/classes/jdk/internal/access/JavaNioAccess.java +++ b/src/java.base/share/classes/jdk/internal/access/JavaNioAccess.java @@ -104,4 +104,19 @@ public interface JavaNioAccess { * Used by {@code jdk.internal.foreign.MappedMemorySegmentImpl} and byte buffer var handle views. */ boolean isLoaded(long address, boolean isSync, long size); + + /** + * Used by {@code jdk.internal.foreign.NativeMemorySegmentImpl}. + */ + void reserveMemory(long size, long cap); + + /** + * Used by {@code jdk.internal.foreign.NativeMemorySegmentImpl}. + */ + void unreserveMemory(long size, long cap); + + /** + * Used by {@code jdk.internal.foreign.NativeMemorySegmentImpl}. + */ + int pageSize(); } diff --git a/src/java.base/share/classes/jdk/internal/access/foreign/MemorySegmentProxy.java b/src/java.base/share/classes/jdk/internal/access/foreign/MemorySegmentProxy.java index 6c6ec80987a26..e45ad08f8fecc 100644 --- a/src/java.base/share/classes/jdk/internal/access/foreign/MemorySegmentProxy.java +++ b/src/java.base/share/classes/jdk/internal/access/foreign/MemorySegmentProxy.java @@ -26,10 +26,78 @@ package jdk.internal.access.foreign; +import jdk.internal.misc.ScopedMemoryAccess; + /** * This proxy interface is required to allow instances of the {@code MemorySegment} interface (which is defined inside * an incubating module) to be accessed from the memory access var handles. */ public interface MemorySegmentProxy { - void checkValidState(); + /** + * Check that memory access is within spatial bounds and that access is compatible with segment access modes. + * @throws UnsupportedOperationException if underlying segment has incompatible access modes (e.g. attempting to write + * a read-only segment). + * @throws IndexOutOfBoundsException if access is out-of-bounds. + */ + void checkAccess(long offset, long length, boolean readOnly); + long unsafeGetOffset(); + Object unsafeGetBase(); + boolean isSmall(); + ScopedMemoryAccess.Scope scope(); + + /* Helper functions for offset computations. These are required so that we can avoid issuing long opcodes + * (e.g. LMUL, LADD) when we're operating on 'small' segments (segments whose length can be expressed with an int). + * C2 BCE code is very sensitive to the kind of opcode being emitted, and this workaround allows us to rescue + * BCE when working with small segments. This workaround should be dropped when JDK-8223051 is resolved. + */ + + static long addOffsets(long op1, long op2, MemorySegmentProxy segmentProxy) { + if (segmentProxy.isSmall()) { + // force ints for BCE + if (op1 > Integer.MAX_VALUE || op2 > Integer.MAX_VALUE + || op1 < Integer.MIN_VALUE || op2 < Integer.MIN_VALUE) { + throw overflowException(Integer.MIN_VALUE, Integer.MAX_VALUE); + } + int i1 = (int)op1; + int i2 = (int)op2; + try { + return Math.addExact(i1, i2); + } catch (ArithmeticException ex) { + throw overflowException(Integer.MIN_VALUE, Integer.MAX_VALUE); + } + } else { + try { + return Math.addExact(op1, op2); + } catch (ArithmeticException ex) { + throw overflowException(Long.MIN_VALUE, Long.MAX_VALUE); + } + } + } + + static long multiplyOffsets(long op1, long op2, MemorySegmentProxy segmentProxy) { + if (segmentProxy.isSmall()) { + if (op1 > Integer.MAX_VALUE || op2 > Integer.MAX_VALUE + || op1 < Integer.MIN_VALUE || op2 < Integer.MIN_VALUE) { + throw overflowException(Integer.MIN_VALUE, Integer.MAX_VALUE); + } + // force ints for BCE + int i1 = (int)op1; + int i2 = (int)op2; + try { + return Math.multiplyExact(i1, i2); + } catch (ArithmeticException ex) { + throw overflowException(Integer.MIN_VALUE, Integer.MAX_VALUE); + } + } else { + try { + return Math.multiplyExact(op1, op2); + } catch (ArithmeticException ex) { + throw overflowException(Long.MIN_VALUE, Long.MAX_VALUE); + } + } + } + + private static IndexOutOfBoundsException overflowException(long min, long max) { + return new IndexOutOfBoundsException(String.format("Overflow occurred during offset computation ; offset exceeded range { %d .. %d }", min, max)); + } } diff --git a/src/java.base/share/classes/jdk/internal/util/ArraysSupport.java b/src/java.base/share/classes/jdk/internal/util/ArraysSupport.java index e7ffb7a0ed851..777905ea6a303 100644 --- a/src/java.base/share/classes/jdk/internal/util/ArraysSupport.java +++ b/src/java.base/share/classes/jdk/internal/util/ArraysSupport.java @@ -160,37 +160,6 @@ public static int vectorizedMismatch(Object a, long aOffset, } } - /** - * Mismatch over long lengths. - */ - public static long vectorizedMismatchLargeForBytes(Object a, long aOffset, - Object b, long bOffset, - long length) { - long off = 0; - long remaining = length; - int i, size; - boolean lastSubRange = false; - while (remaining > 7 && !lastSubRange) { - if (remaining > Integer.MAX_VALUE) { - size = Integer.MAX_VALUE; - } else { - size = (int) remaining; - lastSubRange = true; - } - i = vectorizedMismatch( - a, aOffset + off, - b, bOffset + off, - size, LOG2_ARRAY_BYTE_INDEX_SCALE); - if (i >= 0) - return off + i; - - i = size - ~i; - off += i; - remaining -= i; - } - return ~remaining; - } - // Booleans // Each boolean element takes up one byte diff --git a/src/java.base/share/classes/module-info.java b/src/java.base/share/classes/module-info.java index 2a72b409014b5..d5cd74eb79025 100644 --- a/src/java.base/share/classes/module-info.java +++ b/src/java.base/share/classes/module-info.java @@ -215,7 +215,8 @@ exports jdk.internal.platform to jdk.management; exports jdk.internal.ref to - java.desktop; + java.desktop, + jdk.incubator.foreign; exports jdk.internal.reflect to java.logging, java.sql, diff --git a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MemoryAddress.java b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MemoryAddress.java index f5774d79eb7a0..2cc9905e29d99 100644 --- a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MemoryAddress.java +++ b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MemoryAddress.java @@ -26,19 +26,18 @@ package jdk.incubator.foreign; +import jdk.internal.foreign.AbstractMemorySegmentImpl; import jdk.internal.foreign.MemoryAddressImpl; +import jdk.internal.foreign.NativeMemorySegmentImpl; +import jdk.internal.foreign.Utils; + +import java.lang.ref.Cleaner; /** * A memory address models a reference into a memory location. Memory addresses are typically obtained using the - * {@link MemorySegment#baseAddress()} method; such addresses are said to be checked, and can be expressed - * as offsets into some underlying memory segment (see {@link #segment()} and {@link #segmentOffset()}). - * Since checked memory addresses feature both spatial and temporal bounds, these addresses can safely be - * dereferenced using a memory access var handle (see {@link MemoryHandles}). - *

- * If an address does not have any associated segment, it is said to be unchecked. Unchecked memory - * addresses do not feature known spatial or temporal bounds; as such, attempting a memory dereference operation - * using an unchecked memory address will result in a runtime exception. Unchecked addresses can be obtained - * e.g. by calling the {@link #ofLong(long)} method. + * {@link MemorySegment#address()} method, and can refer to either off-heap or on-heap memory. + * Given an address, it is possible to compute its offset relative to a given segment, which can be useful + * when performing memory dereference operations using a memory access var handle (see {@link MemoryHandles}). *

* All implementations of this interface must be value-based; * use of identity-sensitive operations (including reference equality ({@code ==}), identity hash code, or synchronization) on @@ -54,7 +53,13 @@ * @implSpec * Implementations of this interface are immutable, thread-safe and value-based. */ -public interface MemoryAddress { +public interface MemoryAddress extends Addressable { + + @Override + default MemoryAddress address() { + return this; + } + /** * Creates a new memory address with given offset (in bytes), which might be negative, from current one. * @param offset specified offset (in bytes), relative to this address, which should be used to create the new address. @@ -63,34 +68,99 @@ public interface MemoryAddress { MemoryAddress addOffset(long offset); /** - * Returns the offset of this memory address into the underlying segment (if any). - * @return the offset of this memory address into the underlying segment (if any). - * @throws UnsupportedOperationException if no segment is associated with this memory address, - * e.g. if {@code segment() == null}. + * Returns the offset of this memory address into the given segment. More specifically, if both the segment's + * base address and this address are off-heap addresses, the result is computed as + * {@code this.toRawLongValue() - segment.address().toRawLongValue()}. Otherwise, if both addresses in the form + * {@code (B, O1)}, {@code (B, O2)}, where {@code B} is the same base heap object and {@code O1}, {@code O2} + * are byte offsets (relative to the base object) associated with this address and the segment's base address, + * the result is computed as {@code O1 - O2}. + *

+ * If the segment's base address and this address are both heap addresses, but with different base objects, the result is undefined + * and an exception is thrown. Similarly, if the segment's base address is an heap address (resp. off-heap) and + * this address is an off-heap (resp. heap) address, the result is undefined and an exception is thrown. + * Otherwise, the result is a byte offset {@code SO}. If this address falls within the + * spatial bounds of the given segment, then {@code 0 <= SO < segment.byteSize()}; otherwise, {@code SO < 0 || SO > segment.byteSize()}. + * @return the offset of this memory address into the given segment. + * @param segment the segment relative to which this address offset should be computed + * @throws IllegalArgumentException if {@code segment} is not compatible with this address; this can happen, for instance, + * when {@code segment} models an heap memory region, while this address models an off-heap memory address. */ - long segmentOffset(); + long segmentOffset(MemorySegment segment); /** - * Returns the raw long value associated to this memory address. - * @return The raw long value associated to this memory address. - * @throws UnsupportedOperationException if this memory address is associated with an heap segment. + * Returns a new confined native memory segment with given size, and whose base address is this address; the returned segment has its own temporal + * bounds, and can therefore be closed. This method can be useful when interacting with custom native memory sources (e.g. custom allocators), + * where an address to some underlying memory region is typically obtained from native code (often as a plain {@code long} value). + *

+ * The returned segment will feature all access modes + * (see {@link MemorySegment#ALL_ACCESS}), and its confinement thread is the current thread (see {@link Thread#currentThread()}). + *

+ * Clients should ensure that the address and bounds refers to a valid region of memory that is accessible for reading and, + * if appropriate, writing; an attempt to access an invalid memory location from Java code will either return an arbitrary value, + * have no visible effect, or cause an unspecified exception to be thrown. + *

+ * Calling {@link MemorySegment#close()} on the returned segment will not result in releasing any + * memory resources which might implicitly be associated with the segment. This method is equivalent to the following code: + * 

{@code
+    asSegmentRestricted(byteSize, null, null);
+     * }
+ * This method is restricted. Restricted methods are unsafe, and, if used incorrectly, their use might crash + * the JVM or, worse, silently result in memory corruption. Thus, clients should refrain from depending on + * restricted methods, and use safe and supported functionalities, where possible. + * + * @param bytesSize the desired size. + * @return a new confined native memory segment with given base address and size. + * @throws IllegalArgumentException if {@code bytesSize <= 0}. + * @throws UnsupportedOperationException if this address is an heap address. + * @throws IllegalAccessError if the runtime property {@code foreign.restricted} is not set to either + * {@code permit}, {@code warn} or {@code debug} (the default value is set to {@code deny}). */ - long toRawLongValue(); + default MemorySegment asSegmentRestricted(long bytesSize) { + return asSegmentRestricted(bytesSize, null, null); + } /** - * Returns the memory segment (if any) this address belongs to. - * @return The memory segment this address belongs to, or {@code null} if no such segment exists. + * Returns a new confined native memory segment with given size, and whose base address is this address; the returned segment has its own temporal + * bounds, and can therefore be closed. This method can be useful when interacting with custom native memory sources (e.g. custom allocators), + * where an address to some underlying memory region is typically obtained from native code (often as a plain {@code long} value). + *

+ * The returned segment will feature all access modes + * (see {@link MemorySegment#ALL_ACCESS}), and its confinement thread is the current thread (see {@link Thread#currentThread()}). + * Moreover, the returned segment will keep a strong reference to the supplied attachment object (if any), which can + * be useful in cases where the lifecycle of the segment is dependent on that of some other external resource. + *

+ * Clients should ensure that the address and bounds refers to a valid region of memory that is accessible for reading and, + * if appropriate, writing; an attempt to access an invalid memory location from Java code will either return an arbitrary value, + * have no visible effect, or cause an unspecified exception to be thrown. + *

+ * Calling {@link MemorySegment#close()} on the returned segment will not result in releasing any + * memory resources which might implicitly be associated with the segment, but will result in calling the + * provided cleanup action (if any). + *

+ * Both the cleanup action and the attachment object (if any) will be preserved under terminal operations such as + * {@link MemorySegment#handoff(Thread)}, {@link MemorySegment#share()} and {@link MemorySegment#registerCleaner(Cleaner)}. + *

+ * This method is restricted. Restricted methods are unsafe, and, if used incorrectly, their use might crash + * the JVM or, worse, silently result in memory corruption. Thus, clients should refrain from depending on + * restricted methods, and use safe and supported functionalities, where possible. + * + * @param bytesSize the desired size. + * @param cleanupAction the cleanup action; can be {@code null}. + * @param attachment an attachment object that will be kept strongly reachable by the returned segment; can be {@code null}. + * @return a new confined native memory segment with given base address and size. + * @throws IllegalArgumentException if {@code bytesSize <= 0}. + * @throws UnsupportedOperationException if this address is an heap address. + * @throws IllegalAccessError if the runtime property {@code foreign.restricted} is not set to either + * {@code permit}, {@code warn} or {@code debug} (the default value is set to {@code deny}). */ - MemorySegment segment(); + MemorySegment asSegmentRestricted(long bytesSize, Runnable cleanupAction, Object attachment); /** - * Reinterpret this address as an offset into the provided segment. - * @param segment the segment to be rebased - * @return a new address pointing to the same memory location through the provided segment - * @throws IllegalArgumentException if the provided segment is not a valid rebase target for this address. This - * can happen, for instance, if an heap-based addressed is rebased to an off-heap memory segment. + * Returns the raw long value associated with this memory address. + * @return The raw long value associated with this memory address. + * @throws UnsupportedOperationException if this memory address is an heap address. */ - MemoryAddress rebase(MemorySegment segment); + long toRawLongValue(); /** * Compares the specified object with this address for equality. Returns {@code true} if and only if the specified @@ -116,21 +186,18 @@ public interface MemoryAddress { int hashCode(); /** - * The unchecked memory address instance modelling the {@code NULL} address. This address is not backed by - * a memory segment and hence it cannot be dereferenced. + * The off-heap memory address instance modelling the {@code NULL} address. */ - MemoryAddress NULL = new MemoryAddressImpl( 0L); + MemoryAddress NULL = new MemoryAddressImpl(null, 0L); /** - * Obtain a new unchecked memory address instance from given long address. The returned address is not backed by - * a memory segment and hence it cannot be dereferenced. + * Obtain an off-heap memory address instance from given long address. * @param value the long address. * @return the new memory address instance. */ static MemoryAddress ofLong(long value) { return value == 0 ? NULL : - new MemoryAddressImpl(value); + new MemoryAddressImpl(null, value); } - } diff --git a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MemoryHandles.java b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MemoryHandles.java index 9e0abe8e1aa75..07f65eb1e3cc7 100644 --- a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MemoryHandles.java +++ b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MemoryHandles.java @@ -46,44 +46,22 @@ * (all primitive types but {@code void} and {@code boolean} are supported), as well as the alignment constraint and the * byte order associated to a memory access var handle. The resulting memory access var handle can then be combined in various ways * to emulate different addressing modes. The var handles created by this class feature a mandatory coordinate type - * (of type {@link MemoryAddress}), and zero or more {@code long} coordinate types, which can be used to emulate - * multi-dimensional array indexing. + * (of type {@link MemorySegment}), and one {@code long} coordinate type, which represents the offset, in bytes, relative + * to the segment, at which dereference should occur. *

- * As an example, consider the memory layout expressed by a {@link SequenceLayout} instance constructed as follows: + * As an example, consider the memory layout expressed by a {@link GroupLayout} instance constructed as follows: * 

{@code
-SequenceLayout seq = MemoryLayout.ofSequence(5,
-    MemoryLayout.ofStruct(
+GroupLayout seq = MemoryLayout.ofStruct(
         MemoryLayout.ofPaddingBits(32),
         MemoryLayout.ofValueBits(32, ByteOrder.BIG_ENDIAN).withName("value")
-    ));
+);
  * }
* To access the member layout named {@code value}, we can construct a memory access var handle as follows: * 
{@code
-VarHandle handle = MemoryHandles.varHandle(int.class, ByteOrder.BIG_ENDIAN); //(MemoryAddress) -> int
-handle = MemoryHandles.withOffset(handle, 4); //(MemoryAddress) -> int
-handle = MemoryHandles.withStride(handle, 8); //(MemoryAddress, long) -> int
+VarHandle handle = MemoryHandles.varHandle(int.class, ByteOrder.BIG_ENDIAN); //(MemorySegment, long) -> int
+handle = MemoryHandles.insertCoordinates(handle, 1, 4); //(MemorySegment) -> int
  * }
* - *

Addressing mode

- * - * The final memory location accessed by a memory access var handle can be computed as follows: - * - * 
{@code
-address = base + offset
- * }
- * - * where {@code base} denotes the address expressed by the {@link MemoryAddress} access coordinate, and {@code offset} - * can be expressed in the following form: - * - * 
{@code
-offset = c_1 + c_2 + ... + c_m + (x_1 * s_1) + (x_2 * s_2) + ... + (x_n * s_n)
- * }
- * - * where {@code x_1}, {@code x_2}, ... {@code x_n} are dynamic values provided as optional {@code long} - * access coordinates, whereas {@code c_1}, {@code c_2}, ... {@code c_m} and {@code s_0}, {@code s_1}, ... {@code s_n} are - * static constants which are can be acquired through the {@link MemoryHandles#withOffset(VarHandle, long)} - * and the {@link MemoryHandles#withStride(VarHandle, long)} combinators, respectively. - * *

Alignment and access modes

* * A memory access var handle is associated with an access size {@code S} and an alignment constraint {@code B} @@ -130,9 +108,6 @@ private MemoryHandles() { private static final MethodHandle LONG_TO_ADDRESS; private static final MethodHandle ADDRESS_TO_LONG; - private static final MethodHandle ADD_OFFSET; - private static final MethodHandle ADD_STRIDE; - private static final MethodHandle INT_TO_BYTE; private static final MethodHandle BYTE_TO_UNSIGNED_INT; private static final MethodHandle INT_TO_SHORT; @@ -150,12 +125,6 @@ private MemoryHandles() { MethodType.methodType(MemoryAddress.class, long.class)); ADDRESS_TO_LONG = MethodHandles.lookup().findStatic(MemoryHandles.class, "addressToLong", MethodType.methodType(long.class, MemoryAddress.class)); - ADD_OFFSET = MethodHandles.lookup().findStatic(MemoryHandles.class, "addOffset", - MethodType.methodType(MemoryAddress.class, MemoryAddress.class, long.class)); - - ADD_STRIDE = MethodHandles.lookup().findStatic(MemoryHandles.class, "addStride", - MethodType.methodType(MemoryAddress.class, MemoryAddress.class, long.class, long.class)); - INT_TO_BYTE = MethodHandles.explicitCastArguments(MethodHandles.identity(byte.class), MethodType.methodType(byte.class, int.class)); BYTE_TO_UNSIGNED_INT = MethodHandles.lookup().findStatic(Byte.class, "toUnsignedInt", @@ -184,11 +153,12 @@ private MemoryHandles() { /** * Creates a memory access var handle with the given carrier type and byte order. * - * The resulting memory access var handle features a single {@link MemoryAddress} access coordinate, - * and its variable type is set by the given carrier type. - * - * The alignment constraint for the resulting memory access var handle is the same as the in memory size of the - * carrier type, and the accessed offset is set at zero. + * The returned var handle's type is {@code carrier} and the list of coordinate types is + * {@code (MemorySegment, long)}, where the {@code long} coordinate type corresponds to byte offset into + * a given memory segment. The returned var handle accesses bytes at an offset in a given + * memory segment, composing bytes to or from a value of the type {@code carrier} according to the given endianness; + * the alignment constraint (in bytes) for the resulting memory access var handle is the same as the size (in bytes) of the + * carrier type {@code carrier}. * * @apiNote the resulting var handle features certain access mode restrictions, * which are common to all memory access var handles. @@ -209,10 +179,11 @@ public static VarHandle varHandle(Class carrier, ByteOrder byteOrder) { /** * Creates a memory access var handle with the given carrier type, alignment constraint, and byte order. * - * The resulting memory access var handle features a single {@link MemoryAddress} access coordinate, - * and its variable type is set by the given carrier type. - * - * The accessed offset is zero. + * The returned var handle's type is {@code carrier} and the list of coordinate types is + * {@code (MemorySegment, long)}, where the {@code long} coordinate type corresponds to byte offset into + * a given memory segment. The returned var handle accesses bytes at an offset in a given + * memory segment, composing bytes to or from a value of the type {@code carrier} according to the given endianness; + * the alignment constraint (in bytes) for the resulting memory access var handle is given by {@code alignmentBytes}. * * @apiNote the resulting var handle features certain access mode restrictions, * which are common to all memory access var handles. @@ -232,94 +203,11 @@ public static VarHandle varHandle(Class carrier, long alignmentBytes, ByteOrd throw new IllegalArgumentException("Bad alignment: " + alignmentBytes); } - return Utils.fixUpVarHandle(JLI.memoryAccessVarHandle(carrier, alignmentBytes - 1, byteOrder, 0, new long[]{})); - } - - /** - * Returns a var handle that adds a fixed offset to the incoming {@link MemoryAddress} coordinate - * and then propagates such value to the target var handle. That is, - * when the returned var handle receives a memory address coordinate pointing at a memory location at - * offset O, a memory address coordinate pointing at a memory location at offset O' + O - * is created, and then passed to the target var handle. - * - * The returned var handle will feature the same type and access coordinates as the target var handle. - * - * @param target the target memory access handle to access after the offset adjustment. - * @param bytesOffset the offset, in bytes. Must be positive or zero. - * @return the adapted var handle. - * @throws IllegalArgumentException if the first access coordinate type is not of type {@link MemoryAddress}. - */ - public static VarHandle withOffset(VarHandle target, long bytesOffset) { - if (bytesOffset == 0) { - return target; //nothing to do - } - - checkAddressFirstCoordinate(target); - - if (JLI.isMemoryAccessVarHandle(target) && - (bytesOffset & JLI.memoryAddressAlignmentMask(target)) == 0) { - //flatten - return Utils.fixUpVarHandle(JLI.memoryAccessVarHandle( - JLI.memoryAddressCarrier(target), - JLI.memoryAddressAlignmentMask(target), - JLI.memoryAddressByteOrder(target), - JLI.memoryAddressOffset(target) + bytesOffset, - JLI.memoryAddressStrides(target))); - } else { - //slow path - VarHandle res = collectCoordinates(target, 0, ADD_OFFSET); - return insertCoordinates(res, 1, bytesOffset); - } - } - - /** - * Returns a var handle which adds a variable offset to the incoming {@link MemoryAddress} - * access coordinate value and then propagates such value to the target var handle. - * That is, when the returned var handle receives a memory address coordinate pointing at a memory location at - * offset O, a new memory address coordinate pointing at a memory location at offset (S * X) + O - * is created, and then passed to the target var handle, - * where S is a constant stride, whereas X is a dynamic value that will be - * provided as an additional access coordinate (of type {@code long}). - * - * The returned var handle will feature the same type as the target var handle; an additional access coordinate - * of type {@code long} will be added to the access coordinate types of the target var handle at the position - * immediately following the leading access coordinate of type {@link MemoryAddress}. - * - * @param target the target memory access handle to access after the scale adjustment. - * @param bytesStride the stride, in bytes, by which to multiply the coordinate value. - * @return the adapted var handle. - * @throws IllegalArgumentException if the first access coordinate type is not of type {@link MemoryAddress}. - */ - public static VarHandle withStride(VarHandle target, long bytesStride) { - if (bytesStride == 0) { - return dropCoordinates(target, 1, long.class); // dummy coordinate - } - - checkAddressFirstCoordinate(target); - - if (JLI.isMemoryAccessVarHandle(target) && - (bytesStride & JLI.memoryAddressAlignmentMask(target)) == 0) { - //flatten - long[] strides = JLI.memoryAddressStrides(target); - long[] newStrides = new long[strides.length + 1]; - System.arraycopy(strides, 0, newStrides, 1, strides.length); - newStrides[0] = bytesStride; - - return Utils.fixUpVarHandle(JLI.memoryAccessVarHandle( - JLI.memoryAddressCarrier(target), - JLI.memoryAddressAlignmentMask(target), - JLI.memoryAddressByteOrder(target), - JLI.memoryAddressOffset(target), - newStrides)); - } else { - //slow path - VarHandle res = collectCoordinates(target, 0, ADD_STRIDE); - return insertCoordinates(res, 2, bytesStride); - } + return Utils.fixUpVarHandle(JLI.memoryAccessVarHandle(carrier, false, alignmentBytes - 1, byteOrder)); } /** - * Adapt an existing var handle into a new var handle whose carrier type is {@link MemoryAddress}. + * Adapt an existing var handle into a new var handle whose carrier type is {@link MemorySegment}. * That is, when calling {@link VarHandle#get(Object...)} on the returned var handle, * the read numeric value will be turned into a memory address (as if by calling {@link MemoryAddress#ofLong(long)}); * similarly, when calling {@link VarHandle#set(Object...)}, the memory address to be set will be converted @@ -362,8 +250,8 @@ public static VarHandle asAddressVarHandle(VarHandle target) { MemorySegment segment = MemorySegment.allocateNative(2); VarHandle SHORT_VH = MemoryLayouts.JAVA_SHORT.varHandle(short.class); VarHandle INT_VH = MemoryHandles.asUnsigned(SHORT_VH, int.class); - SHORT_VH.set(segment.baseAddress(), (short)-1); - INT_VH.get(segment.baseAddress()); // returns 65535 + SHORT_VH.set(segment, (short)-1); + INT_VH.get(segment); // returns 65535 * } *

* When calling e.g. {@link VarHandle#set(Object...)} on the resulting var @@ -620,8 +508,8 @@ public static VarHandle dropCoordinates(VarHandle target, int pos, Class... v private static void checkAddressFirstCoordinate(VarHandle handle) { if (handle.coordinateTypes().size() < 1 || - handle.coordinateTypes().get(0) != MemoryAddress.class) { - throw new IllegalArgumentException("Expected var handle with leading coordinate of type MemoryAddress"); + handle.coordinateTypes().get(0) != MemorySegment.class) { + throw new IllegalArgumentException("Expected var handle with leading coordinate of type MemorySegment"); } } @@ -662,12 +550,4 @@ private static MemoryAddress longToAddress(long value) { private static long addressToLong(MemoryAddress value) { return value.toRawLongValue(); } - - private static MemoryAddress addOffset(MemoryAddress address, long offset) { - return address.addOffset(offset); - } - - private static MemoryAddress addStride(MemoryAddress address, long index, long stride) { - return address.addOffset(index * stride); - } } diff --git a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MemoryLayout.java b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MemoryLayout.java index b9a6d145f39cd..45487c7d76acd 100644 --- a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MemoryLayout.java +++ b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MemoryLayout.java @@ -68,9 +68,9 @@ * 

{@code
 SequenceLayout taggedValues = MemoryLayout.ofSequence(5,
     MemoryLayout.ofStruct(
-        MemoryLayout.ofValueBits(8, ByteOrder.NATIVE_ORDER).withName("kind"),
+        MemoryLayout.ofValueBits(8, ByteOrder.nativeOrder()).withName("kind"),
         MemoryLayout.ofPaddingBits(24),
-        MemoryLayout.ofValueBits(32, ByteOrder.NATIVE_ORDER).withName("value")
+        MemoryLayout.ofValueBits(32, ByteOrder.nativeOrder()).withName("value")
     )
 ).withName("TaggedValues");
  * }
@@ -147,7 +147,7 @@ * 
{@code
 MemoryLayout taggedValuesWithHole = MemoryLayout.ofSequence(5,
     MemoryLayout.ofStruct(
-        MemoryLayout.ofValueBits(8, ByteOrder.NATIVE_ORDER).withName("kind").
+        MemoryLayout.ofValueBits(8, ByteOrder.nativeOrder()).withName("kind").
         MemoryLayout.ofPaddingBits(32),
         MemoryLayout.ofPaddingBits(32)
 ));
@@ -370,6 +370,24 @@ default long byteOffset(PathElement... elements) {
     /**
      * Creates a memory access var handle that can be used to dereference memory at the layout selected by a given layout path,
      * where the path is considered rooted in this layout.
+     * 

+     * The final memory location accessed by the returned memory access var handle can be computed as follows:
+     *
+     * 
{@code
+    address = base + offset
+     * }

+     *
+     * where {@code base} denotes the base address expressed by the {@link MemorySegment} access coordinate
+     * (see {@link MemorySegment#address()} and {@link MemoryAddress#toRawLongValue()}) and {@code offset}
+     * can be expressed in the following form:
+     *
+     * 
{@code
+    offset = c_1 + c_2 + ... + c_m + (x_1 * s_1) + (x_2 * s_2) + ... + (x_n * s_n)
+     * }

+     *
+     * where {@code x_1}, {@code x_2}, ... {@code x_n} are dynamic values provided as optional {@code long}
+     * access coordinates, whereas {@code c_1}, {@code c_2}, ... {@code c_m} and {@code s_0}, {@code s_1}, ... {@code s_n} are
+     * static stride constants which are derived from the layout path.
      *
      * @apiNote the resulting var handle will feature an additional {@code long} access coordinate for every
      * unspecified sequence access component contained in this layout path. Moreover, the resulting var handle
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MemoryLayouts.java b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MemoryLayouts.java
index f6ed7dd265f8a..fb71e12cf6f23 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MemoryLayouts.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MemoryLayouts.java
@@ -1,5 +1,5 @@
 /*
- *  Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
+ *  Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
  *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  *  This code is free software; you can redistribute it and/or modify it
@@ -26,6 +26,8 @@
 
 package jdk.incubator.foreign;
 
+import jdk.internal.misc.Unsafe;
+
 import java.nio.ByteOrder;
 
 /**
@@ -135,4 +137,9 @@ private MemoryLayouts() {
      * A value layout constant whose size is the same as that of a Java {@code double}, and byte order set to {@link ByteOrder#nativeOrder()}.
      */
     public static final ValueLayout JAVA_DOUBLE = MemoryLayout.ofValueBits(64, ByteOrder.nativeOrder());
+
+    /**
+     * A value layout constant whose size is the same as that of a machine address (e.g. {@code size_t}), and byte order set to {@link ByteOrder#nativeOrder()}.
+     */
+    public static final ValueLayout ADDRESS = MemoryLayout.ofValueBits(Unsafe.ADDRESS_SIZE * 8, ByteOrder.nativeOrder());
 }
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MemorySegment.java b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MemorySegment.java
index 239d14b8f5e1e..728a3883f6fdb 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MemorySegment.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MemorySegment.java
@@ -26,6 +26,7 @@
 
 package jdk.incubator.foreign;
 
+import java.lang.ref.Cleaner;
 import java.nio.ByteBuffer;
 
 import jdk.internal.foreign.AbstractMemorySegmentImpl;
@@ -54,7 +55,7 @@
  * 

  * Non-platform classes should not implement {@linkplain MemorySegment} directly.
  *
- * 
Constructing memory segments from different sources

+ * 
Constructing memory segments

  *
  * There are multiple ways to obtain a memory segment. First, memory segments backed by off-heap memory can
  * be allocated using one of the many factory methods provided (see {@link MemorySegment#allocateNative(MemoryLayout)},
@@ -84,7 +85,7 @@
  * associated with such segments remain inaccessible, and that said memory sources are never aliased by more than one segment
  * at a time - e.g. so as to prevent concurrent modifications of the contents of an array, or buffer segment.
  *
- * 
Closing a memory segment

+ * 
Explicit deallocation

  *
  * Memory segments are closed explicitly (see {@link MemorySegment#close()}). When a segment is closed, it is no longer
  * alive (see {@link #isAlive()}, and subsequent operation on the segment (or on any {@link MemoryAddress} instance
@@ -105,7 +106,7 @@
  * 
Access modes

  *
  * Memory segments supports zero or more access modes. Supported access modes are {@link #READ},
- * {@link #WRITE}, {@link #CLOSE}, {@link #ACQUIRE} and {@link #HANDOFF}. The set of access modes supported by a segment alters the
+ * {@link #WRITE}, {@link #CLOSE}, {@link #SHARE} and {@link #HANDOFF}. The set of access modes supported by a segment alters the
  * set of operations that are supported by that segment. For instance, attempting to call {@link #close()} on
  * a segment which does not support the {@link #CLOSE} access mode will result in an exception.
  * 

@@ -144,24 +145,73 @@
  * the segment using a memory access var handle. Any attempt to perform such operations from a thread other than the
  * owner thread will result in a runtime failure.
  * 

- * Memory segments support serial thread confinement; that is, ownership of a memory segment can change (see
- * {@link #withOwnerThread(Thread)}). This allows, for instance, for two threads {@code A} and {@code B} to share
- * a segment in a controlled, cooperative and race-free fashion.
+ * The {@link #handoff(Thread)} method can be used to change the thread-confinement properties of a memory segment.
+ * This method is, like {@link #close()}, a terminal operation which marks the original segment as not alive
+ * (see {@link #isAlive()}) and creates a new segment with the desired thread-confinement properties. Calling
+ * {@link #handoff(Thread)} is only possible if the segment features the corresponding {@link #HANDOFF} access mode.
  * 

- * In some cases, it might be useful for multiple threads to process the contents of the same memory segment concurrently
- * (e.g. in the case of parallel processing); while memory segments provide strong confinement guarantees, it is possible
- * to obtain a {@link Spliterator} from a segment, which can be used to slice the segment and allow multiple thread to
- * work in parallel on disjoint segment slices (this assumes that the access mode {@link #ACQUIRE} is set).
- * For instance, the following code can be used to sum all int values in a memory segment in parallel:
+ * For instance, if a client wants to transfer ownership of a segment to another (known) thread, it can do so as follows:
+ *
  * 
{@code
 MemorySegment segment = ...
+MemorySegment aSegment = segment.handoff(threadA);
+ * }

+ *
+ * By doing so, the original segment is marked as not alive, and a new segment is returned whose owner thread
+ * is {@code threadA}; this allows, for instance, for two threads {@code A} and {@code B} to share
+ * a segment in a controlled, cooperative and race-free fashion (also known as serial thread confinement).
+ * 

+ * Alternatively, the {@link #share()} method can be used to remove thread ownership altogether; this is only possible
+ * if the segment features the corresponding {@link #SHARE} access mode. The following code shows how clients can
+ * obtain a shared segment:
+ *
+ * 
{@code
+MemorySegment segment = ...
+MemorySegment sharedSegment = segment.share();
+ * }

+ *
+ * Again here, the original segment is marked as not alive, and a new shared segment is returned which features no owner
+ * thread (e.g. {@link #ownerThread()} returns {@code null}). This might be useful when multiple threads need to process
+ * the contents of the same memory segment concurrently (e.g. in the case of parallel processing). For instance, a client
+ * might obtain a {@link Spliterator} from a shared segment, which can then be used to slice the segment and allow multiple
+ * threads to work in parallel on disjoint segment slices. The following code can be used to sum all int values in a memory segment in parallel:
+ *
+ * 
{@code
 SequenceLayout SEQUENCE_LAYOUT = MemoryLayout.ofSequence(1024, MemoryLayouts.JAVA_INT);
-VarHandle VH_int = SEQUENCE_LAYOUT.elementLayout().varHandle(int.class);
-int sum = StreamSupport.stream(MemorySegment.spliterator(segment, SEQUENCE_LAYOUT), true)
-                       .mapToInt(s -> (int)VH_int.get(s.baseAddress()))
-                       .sum();
+try (MemorySegment segment = MemorySegment.allocateNative(SEQUENCE_LAYOUT).share()) {
+    VarHandle VH_int = SEQUENCE_LAYOUT.elementLayout().varHandle(int.class);
+    int sum = StreamSupport.stream(MemorySegment.spliterator(segment, SEQUENCE_LAYOUT), true)
+                           .mapToInt(s -> (int)VH_int.get(s.address()))
+                           .sum();
+}
+ * }

+ *
+ * Once shared, a segment can be claimed back by a given thread (again using {@link #handoff(Thread)}); in fact, many threads
+ * can attempt to gain ownership of the same segment, concurrently, and only one of them is guaranteed to succeed.
+ * 

+ * When using shared segments, clients should make sure that no other thread is accessing the segment while
+ * the segment is being closed. If one or more threads attempts to access a segment concurrently while the
+ * segment is being closed, an exception might occur on both the accessing and the closing threads. Clients should
+ * refrain from attempting to close a segment repeatedly (e.g. keep calling {@link #close()} until no exception is thrown);
+ * such exceptions should instead be seen as an indication that the client code is lacking appropriate synchronization between the threads
+ * accessing/closing the segment.
+ *
+ * 
Implicit deallocation

+ *
+ * Clients can register a memory segment against a {@link Cleaner}, to make sure that underlying resources associated with
+ * that segment will be released when the segment becomes unreachable, which can be useful to prevent native memory
+ * leaks. This can be achieved using the {@link #registerCleaner(Cleaner)} method, as follows:
+ *
+ * 
{@code
+MemorySegment segment = ...
+MemorySegment gcSegment = segment.registerCleaner(cleaner);
  * }

  *
+ * Here, the original segment is marked as not alive, and a new segment is returned (the owner thread of the returned
+ * segment set is set to that of the current thread, see {@link #ownerThread()}); the new segment
+ * will also be registered with the the {@link Cleaner} instance provided to the {@link #registerCleaner(Cleaner)} method;
+ * as such, if not closed explicitly (see {@link #close()}), the new segment will be automatically closed by the cleaner.
+ *
  * @apiNote In the future, if the Java language permits, {@link MemorySegment}
  * may become a {@code sealed} interface, which would prohibit subclassing except by
  * {@link MappedMemorySegment} and other explicitly permitted subtypes.
@@ -169,15 +219,18 @@
  * @implSpec
  * Implementations of this interface are immutable, thread-safe and value-based.
  */
-public interface MemorySegment extends AutoCloseable {
+public interface MemorySegment extends Addressable, AutoCloseable {
 
     /**
      * The base memory address associated with this memory segment. The returned address is
-     * a checked memory address and can therefore be used in derefrence operations
+     * a checked memory address and can therefore be used in dereference operations
      * (see {@link MemoryAddress}).
      * @return The base memory address.
+     * @throws IllegalStateException if this segment is not alive, or if access occurs from a thread other than the
+     * thread owning this segment
      */
-    MemoryAddress baseAddress();
+    @Override
+    MemoryAddress address();
 
     /**
      * Returns a spliterator for the given memory segment. The returned spliterator reports {@link Spliterator#SIZED},
@@ -191,7 +244,7 @@ public interface MemorySegment extends AutoCloseable {
      * access modes as the given segment less the {@link #CLOSE} access mode.
      * 

      * The returned spliterator effectively allows to slice a segment into disjoint sub-segments, which can then
-     * be processed in parallel by multiple threads (if the access mode {@link #ACQUIRE} is set).
+     * be processed in parallel by multiple threads (if the segment is shared).
      * While closing the segment (see {@link #close()}) during pending concurrent execution will generally
      * fail with an exception, it is possible to close a segment when a spliterator has been obtained but no thread
      * is actively working on it using {@link Spliterator#tryAdvance(Consumer)}; in such cases, any subsequent call
@@ -213,27 +266,6 @@ static  Spliterator spliterator(S segment, SequenceL
      */
     Thread ownerThread();
 
-    /**
-     * Obtains a new memory segment backed by the same underlying memory region as this segment,
-     * but with different owner thread. As a side-effect, this segment will be marked as not alive,
-     * and subsequent operations on this segment will result in runtime errors.
-     * 

-     * Write accesses to the segment's content happens-before
-     * hand-over from the current owner thread to the new owner thread, which in turn happens before read accesses to the segment's contents on
-     * the new owner thread.
-     *
-     * @param newOwner the new owner thread.
-     * @return a new memory segment backed by the same underlying memory region as this segment,
-     *      owned by {@code newOwner}.
-     * @throws IllegalStateException if this segment is not alive, or if access occurs from a thread other than the
-     * thread owning this segment, or if the segment cannot be closed because it is being operated upon by a different
-     * thread (see {@link #spliterator(MemorySegment, SequenceLayout)}).
-     * @throws NullPointerException if {@code newOwner == null}
-     * @throws IllegalArgumentException if the segment is already a confined segment owner by {@code newOnwer}.
-     * @throws UnsupportedOperationException if this segment does not support the {@link #HANDOFF} access mode.
-     */
-    MemorySegment withOwnerThread(Thread newOwner);
-
     /**
      * The size (in bytes) of this memory segment.
      * @return The size (in bytes) of this memory segment.
@@ -242,7 +274,7 @@ static  Spliterator spliterator(S segment, SequenceL
 
     /**
      * Obtains a segment view with specific access modes. Supported access modes are {@link #READ}, {@link #WRITE},
-     * {@link #CLOSE}, {@link #ACQUIRE} and {@link #HANDOFF}. It is generally not possible to go from a segment with stricter access modes
+     * {@link #CLOSE}, {@link #SHARE} and {@link #HANDOFF}. It is generally not possible to go from a segment with stricter access modes
      * to one with less strict access modes. For instance, attempting to add {@link #WRITE} access mode to a read-only segment
      * will be met with an exception.
      * @param accessModes an ORed mask of zero or more access modes.
@@ -262,7 +294,7 @@ static  Spliterator spliterator(S segment, SequenceL
 
     /**
      * Returns the access modes associated with this segment; the result is represented as ORed values from
-     * {@link #READ}, {@link #WRITE}, {@link #CLOSE}, {@link #ACQUIRE} and {@link #HANDOFF}.
+     * {@link #READ}, {@link #WRITE}, {@link #CLOSE}, {@link #SHARE} and {@link #HANDOFF}.
      * @return the access modes associated with this segment.
      */
     int accessModes();
@@ -270,6 +302,11 @@ static  Spliterator spliterator(S segment, SequenceL
     /**
      * Obtains a new memory segment view whose base address is the same as the base address of this segment plus a given offset,
      * and whose new size is specified by the given argument.
+     *
+     * @see #asSlice(long)
+     * @see #asSlice(MemoryAddress)
+     * @see #asSlice(MemoryAddress, long)
+     *
      * @param offset The new segment base offset (relative to the current segment base address), specified in bytes.
      * @param newSize The new segment size, specified in bytes.
      * @return a new memory segment view with updated base/limit addresses.
@@ -277,6 +314,73 @@ static  Spliterator spliterator(S segment, SequenceL
      */
     MemorySegment asSlice(long offset, long newSize);
 
+    /**
+     * Obtains a new memory segment view whose base address is the given address, and whose new size is specified by the given argument.
+     * 

+     * Equivalent to the following code:
+     * 
{@code
+    asSlice(newBase.segmentOffset(this), newSize);
+     * }

+     *
+     * @see #asSlice(long)
+     * @see #asSlice(MemoryAddress)
+     * @see #asSlice(long, long)
+     *
+     * @param newBase The new segment base address.
+     * @param newSize The new segment size, specified in bytes.
+     * @return a new memory segment view with updated base/limit addresses.
+     * @throws NullPointerException if {@code newBase == null}.
+     * @throws IndexOutOfBoundsException if {@code offset < 0}, {@code offset > byteSize()}, {@code newSize < 0}, or {@code newSize > byteSize() - offset}
+     */
+    default MemorySegment asSlice(MemoryAddress newBase, long newSize) {
+        Objects.requireNonNull(newBase);
+        return asSlice(newBase.segmentOffset(this), newSize);
+    }
+
+    /**
+     * Obtains a new memory segment view whose base address is the same as the base address of this segment plus a given offset,
+     * and whose new size is computed by subtracting the specified offset from this segment size.
+     * 

+     * Equivalent to the following code:
+     * 
{@code
+    asSlice(offset, byteSize() - offset);
+     * }

+     *
+     * @see #asSlice(MemoryAddress)
+     * @see #asSlice(MemoryAddress, long)
+     * @see #asSlice(long, long)
+     *
+     * @param offset The new segment base offset (relative to the current segment base address), specified in bytes.
+     * @return a new memory segment view with updated base/limit addresses.
+     * @throws IndexOutOfBoundsException if {@code offset < 0}, or {@code offset > byteSize()}.
+     */
+    default MemorySegment asSlice(long offset) {
+        return asSlice(offset, byteSize() - offset);
+    }
+
+    /**
+     * Obtains a new memory segment view whose base address is the given address, and whose new size is computed by subtracting
+     * the address offset relative to this segment (see {@link MemoryAddress#segmentOffset(MemorySegment)}) from this segment size.
+     * 

+     * Equivalent to the following code:
+     * 
{@code
+    asSlice(newBase.segmentOffset(this));
+     * }

+     *
+     * @see #asSlice(long)
+     * @see #asSlice(MemoryAddress, long)
+     * @see #asSlice(long, long)
+     *
+     * @param newBase The new segment base offset (relative to the current segment base address), specified in bytes.
+     * @return a new memory segment view with updated base/limit addresses.
+     * @throws NullPointerException if {@code newBase == null}.
+     * @throws IndexOutOfBoundsException if {@code address.segmentOffset(this) < 0}, or {@code address.segmentOffset(this) > byteSize()}.
+     */
+    default MemorySegment asSlice(MemoryAddress newBase) {
+        Objects.requireNonNull(newBase);
+        return asSlice(newBase.segmentOffset(this));
+    }
+
     /**
      * Is this segment alive?
      * @return true, if the segment is alive.
@@ -285,17 +389,83 @@ static  Spliterator spliterator(S segment, SequenceL
     boolean isAlive();
 
     /**
-     * Closes this memory segment. Once a memory segment has been closed, any attempt to use the memory segment,
-     * or to access any {@link MemoryAddress} instance associated with it will fail with {@link IllegalStateException}.
+     * Closes this memory segment. This is a terminal operation; as a side-effect, this segment will be marked
+     * as not alive, and subsequent operations on this segment will fail with {@link IllegalStateException}.
      * Depending on the kind of memory segment being closed, calling this method further triggers deallocation of all the resources
      * associated with the memory segment.
      * @throws IllegalStateException if this segment is not alive, or if access occurs from a thread other than the
-     * thread owning this segment, or if the segment cannot be closed because it is being operated upon by a different
+     * thread owning this segment, or if this segment is shared and the segment is concurrently accessed while this method is
+     * called.
      * thread (see {@link #spliterator(MemorySegment, SequenceLayout)}).
      * @throws UnsupportedOperationException if this segment does not support the {@link #CLOSE} access mode.
      */
     void close();
 
+    /**
+     * Obtains a new confined memory segment backed by the same underlying memory region as this segment. The returned segment will
+     * be confined on the specified thread, and will feature the same spatial bounds and access modes (see {@link #accessModes()})
+     * as this segment.
+     * 

+     * This is a terminal operation; as a side-effect, this segment will be
+     * marked as not alive, and subsequent operations on this segment will fail with {@link IllegalStateException}.
+     * 

+     * In case where the owner thread of the returned segment differs from that of this segment, write accesses to this
+     * segment's content happens-before
+     * hand-over from the current owner thread to the new owner thread, which in turn happens before read accesses
+     * to the returned segment's contents on the new owner thread.
+     *
+     * @param thread the new owner thread
+     * @return a new confined memory segment whose owner thread is set to {@code thread}.
+     * @throws IllegalStateException if this segment is not alive, or if access occurs from a thread other than the
+     * thread owning this segment.
+     * @throws UnsupportedOperationException if this segment does not support the {@link #HANDOFF} access mode.
+     * @throws NullPointerException if {@code thread == null}
+     */
+    MemorySegment handoff(Thread thread);
+
+    /**
+     * Obtains a new shared memory segment backed by the same underlying memory region as this segment. The returned segment will
+     * not be confined on any thread and can therefore be accessed concurrently from multiple threads; moreover, the
+     * returned segment will feature the same spatial bounds and access modes (see {@link #accessModes()})
+     * as this segment.
+     * 

+     * This is a terminal operation; as a side-effect, this segment will be
+     * marked as not alive, and subsequent operations on this segment will fail with {@link IllegalStateException}.
+     * 

+     * Write accesses to this segment's content happens-before
+     * hand-over from the current owner thread to the new owner thread, which in turn happens before read accesses
+     * to the returned segment's contents on a new thread.
+     *
+     * @return a new memory shared segment backed by the same underlying memory region as this segment.
+     * @throws IllegalStateException if this segment is not alive, or if access occurs from a thread other than the
+     * thread owning this segment.
+     * @throws NullPointerException if {@code thread == null}
+     */
+    MemorySegment share();
+
+    /**
+     * Register this memory segment instance against a {@link Cleaner} object, by returning a new memory segment backed
+     * by the same underlying memory region as this segment. The returned segment will feature the same confinement,
+     * spatial bounds and access modes (see {@link #accessModes()}) as this segment. Moreover, the returned segment
+     * will be associated with the specified {@link Cleaner} object; this allows for the segment to be closed
+     * as soon as it becomes unreachable, which might be helpful in preventing native memory leaks.
+     * 

+     * This is a terminal operation; as a side-effect, this segment will be
+     * marked as not alive, and subsequent operations on this segment will fail with {@link IllegalStateException}.
+     * 

+     * The implicit deallocation behavior associated with the returned segment will be preserved under terminal
+     * operations such as {@link #handoff(Thread)} and {@link #share()}.
+     *
+     * @param cleaner the cleaner object, responsible for implicit deallocation of the returned segment.
+     * @return a new memory segment backed by the same underlying memory region as this segment, which features
+     * implicit deallocation.
+     * @throws IllegalStateException if this segment is not alive, or if access occurs from a thread other than the
+     * thread owning this segment, or if this segment is already associated with a cleaner.
+     * @throws UnsupportedOperationException if this segment does not support the {@link #CLOSE} access mode.
+     * @throws NullPointerException if {@code thread == null}
+     */
+    MemorySegment registerCleaner(Cleaner cleaner);
+
     /**
      * Fills a value into this memory segment.
      * 

@@ -306,7 +476,7 @@ static  Spliterator spliterator(S segment, SequenceL
 byteHandle = MemoryLayout.ofSequence(MemoryLayouts.JAVA_BYTE)
          .varHandle(byte.class, MemoryLayout.PathElement.sequenceElement());
 for (long l = 0; l < segment.byteSize(); l++) {
-     byteHandle.set(segment.baseAddress(), l, value);
+     byteHandle.set(segment.address(), l, value);
 }
      * }
* @@ -349,7 +519,7 @@ static Spliterator spliterator(S segment, SequenceL /** * Finds and returns the offset, in bytes, of the first mismatch between * this segment and a given other segment. The offset is relative to the - * {@link #baseAddress() base address} of each segment and will be in the + * {@link #address() base address} of each segment and will be in the * range of 0 (inclusive) up to the {@link #byteSize() size} (in bytes) of * the smaller memory segment (exclusive). *

@@ -404,123 +574,190 @@ static Spliterator spliterator(S segment, SequenceL byte[] toByteArray(); /** - * Creates a new buffer memory segment that models the memory associated with the given byte + * Copy the contents of this memory segment into a fresh short array. + * @return a fresh short array copy of this memory segment. + * @throws UnsupportedOperationException if this segment does not feature the {@link #READ} access mode, or if this + * segment's contents cannot be copied into a {@link short[]} instance, e.g. because {@code byteSize() % 2 != 0}, + * or {@code byteSize() / 2 > Integer#MAX_VALUE}. + * @throws IllegalStateException if this segment has been closed, or if access occurs from a thread other than the + * thread owning this segment. + */ + short[] toShortArray(); + + /** + * Copy the contents of this memory segment into a fresh char array. + * @return a fresh char array copy of this memory segment. + * @throws UnsupportedOperationException if this segment does not feature the {@link #READ} access mode, or if this + * segment's contents cannot be copied into a {@link char[]} instance, e.g. because {@code byteSize() % 2 != 0}, + * or {@code byteSize() / 2 > Integer#MAX_VALUE}. + * @throws IllegalStateException if this segment has been closed, or if access occurs from a thread other than the + * thread owning this segment. + */ + char[] toCharArray(); + + /** + * Copy the contents of this memory segment into a fresh int array. + * @return a fresh int array copy of this memory segment. + * @throws UnsupportedOperationException if this segment does not feature the {@link #READ} access mode, or if this + * segment's contents cannot be copied into a {@link int[]} instance, e.g. because {@code byteSize() % 4 != 0}, + * or {@code byteSize() / 4 > Integer#MAX_VALUE}. + * @throws IllegalStateException if this segment has been closed, or if access occurs from a thread other than the + * thread owning this segment. + */ + int[] toIntArray(); + + /** + * Copy the contents of this memory segment into a fresh float array. + * @return a fresh float array copy of this memory segment. + * @throws UnsupportedOperationException if this segment does not feature the {@link #READ} access mode, or if this + * segment's contents cannot be copied into a {@link float[]} instance, e.g. because {@code byteSize() % 4 != 0}, + * or {@code byteSize() / 4 > Integer#MAX_VALUE}. + * @throws IllegalStateException if this segment has been closed, or if access occurs from a thread other than the + * thread owning this segment. + */ + float[] toFloatArray(); + + /** + * Copy the contents of this memory segment into a fresh long array. + * @return a fresh long array copy of this memory segment. + * @throws UnsupportedOperationException if this segment does not feature the {@link #READ} access mode, or if this + * segment's contents cannot be copied into a {@link long[]} instance, e.g. because {@code byteSize() % 8 != 0}, + * or {@code byteSize() / 8 > Integer#MAX_VALUE}. + * @throws IllegalStateException if this segment has been closed, or if access occurs from a thread other than the + * thread owning this segment. + */ + long[] toLongArray(); + + /** + * Copy the contents of this memory segment into a fresh double array. + * @return a fresh double array copy of this memory segment. + * @throws UnsupportedOperationException if this segment does not feature the {@link #READ} access mode, or if this + * segment's contents cannot be copied into a {@link double[]} instance, e.g. because {@code byteSize() % 8 != 0}, + * or {@code byteSize() / 8 > Integer#MAX_VALUE}. + * @throws IllegalStateException if this segment has been closed, or if access occurs from a thread other than the + * thread owning this segment. + */ + double[] toDoubleArray(); + + /** + * Creates a new confined buffer memory segment that models the memory associated with the given byte * buffer. The segment starts relative to the buffer's position (inclusive) * and ends relative to the buffer's limit (exclusive). *

* The segment will feature all access modes (see {@link #ALL_ACCESS}), * unless the given buffer is {@linkplain ByteBuffer#isReadOnly() read-only} in which case the segment will - * not feature the {@link #WRITE} access mode. + * not feature the {@link #WRITE} access mode, and its confinement thread is the current thread (see {@link Thread#currentThread()}). *

* The resulting memory segment keeps a reference to the backing buffer, to ensure it remains reachable * for the life-time of the segment. * * @param bb the byte buffer backing the buffer memory segment. - * @return a new buffer memory segment. + * @return a new confined buffer memory segment. */ static MemorySegment ofByteBuffer(ByteBuffer bb) { return AbstractMemorySegmentImpl.ofBuffer(bb); } /** - * Creates a new array memory segment that models the memory associated with a given heap-allocated byte array. + * Creates a new confined array memory segment that models the memory associated with a given heap-allocated byte array. *

* The resulting memory segment keeps a reference to the backing array, to ensure it remains reachable * for the life-time of the segment. The segment will feature all access modes - * (see {@link #ALL_ACCESS}). + * (see {@link #ALL_ACCESS}), and its confinement thread is the current thread (see {@link Thread#currentThread()}). * * @param arr the primitive array backing the array memory segment. - * @return a new array memory segment. + * @return a new confined array memory segment. */ static MemorySegment ofArray(byte[] arr) { return HeapMemorySegmentImpl.makeArraySegment(arr); } /** - * Creates a new array memory segment that models the memory associated with a given heap-allocated char array. + * Creates a new confined array memory segment that models the memory associated with a given heap-allocated char array. *

* The resulting memory segment keeps a reference to the backing array, to ensure it remains reachable * for the life-time of the segment. The segment will feature all access modes - * (see {@link #ALL_ACCESS}). + * (see {@link #ALL_ACCESS}), and its confinement thread is the current thread (see {@link Thread#currentThread()}). * * @param arr the primitive array backing the array memory segment. - * @return a new array memory segment. + * @return a new confined array memory segment. */ static MemorySegment ofArray(char[] arr) { return HeapMemorySegmentImpl.makeArraySegment(arr); } /** - * Creates a new array memory segment that models the memory associated with a given heap-allocated short array. + * Creates a new confined array memory segment that models the memory associated with a given heap-allocated short array. *

* The resulting memory segment keeps a reference to the backing array, to ensure it remains reachable * for the life-time of the segment. The segment will feature all access modes - * (see {@link #ALL_ACCESS}). + * (see {@link #ALL_ACCESS}), and its confinement thread is the current thread (see {@link Thread#currentThread()}). * * @param arr the primitive array backing the array memory segment. - * @return a new array memory segment. + * @return a new confined array memory segment. */ static MemorySegment ofArray(short[] arr) { return HeapMemorySegmentImpl.makeArraySegment(arr); } /** - * Creates a new array memory segment that models the memory associated with a given heap-allocated int array. + * Creates a new confined array memory segment that models the memory associated with a given heap-allocated int array. *

* The resulting memory segment keeps a reference to the backing array, to ensure it remains reachable - * for the life-time of the segment. The segment will feature all access modes. + * for the life-time of the segment. The segment will feature all access modes + * (see {@link #ALL_ACCESS}), and its confinement thread is the current thread (see {@link Thread#currentThread()}). * * @param arr the primitive array backing the array memory segment. - * @return a new array memory segment. + * @return a new confined array memory segment. */ static MemorySegment ofArray(int[] arr) { return HeapMemorySegmentImpl.makeArraySegment(arr); } /** - * Creates a new array memory segment that models the memory associated with a given heap-allocated float array. + * Creates a new confined array memory segment that models the memory associated with a given heap-allocated float array. *

* The resulting memory segment keeps a reference to the backing array, to ensure it remains reachable * for the life-time of the segment. The segment will feature all access modes - * (see {@link #ALL_ACCESS}). + * (see {@link #ALL_ACCESS}), and its confinement thread is the current thread (see {@link Thread#currentThread()}). * * @param arr the primitive array backing the array memory segment. - * @return a new array memory segment. + * @return a new confined array memory segment. */ static MemorySegment ofArray(float[] arr) { return HeapMemorySegmentImpl.makeArraySegment(arr); } /** - * Creates a new array memory segment that models the memory associated with a given heap-allocated long array. + * Creates a new confined array memory segment that models the memory associated with a given heap-allocated long array. *

* The resulting memory segment keeps a reference to the backing array, to ensure it remains reachable * for the life-time of the segment. The segment will feature all access modes - * (see {@link #ALL_ACCESS}). + * (see {@link #ALL_ACCESS}), and its confinement thread is the current thread (see {@link Thread#currentThread()}). * * @param arr the primitive array backing the array memory segment. - * @return a new array memory segment. + * @return a new confined array memory segment. */ static MemorySegment ofArray(long[] arr) { return HeapMemorySegmentImpl.makeArraySegment(arr); } /** - * Creates a new array memory segment that models the memory associated with a given heap-allocated double array. + * Creates a new confined array memory segment that models the memory associated with a given heap-allocated double array. *

* The resulting memory segment keeps a reference to the backing array, to ensure it remains reachable * for the life-time of the segment. The segment will feature all access modes * (see {@link #ALL_ACCESS}). * * @param arr the primitive array backing the array memory segment. - * @return a new array memory segment. + * @return a new confined array memory segment. */ static MemorySegment ofArray(double[] arr) { return HeapMemorySegmentImpl.makeArraySegment(arr); } /** - * Creates a new native memory segment that models a newly allocated block of off-heap memory with given layout. + * Creates a new confined native memory segment that models a newly allocated block of off-heap memory with given layout. *

* This is equivalent to the following code: * 

{@code
@@ -540,7 +777,7 @@ static MemorySegment allocateNative(MemoryLayout layout) {
     }
 
     /**
-     * Creates a new native memory segment that models a newly allocated block of off-heap memory with given size (in bytes).
+     * Creates a new confined native memory segment that models a newly allocated block of off-heap memory with given size (in bytes).
      * 

      * This is equivalent to the following code:
      * 
{@code
@@ -552,7 +789,7 @@ static MemorySegment allocateNative(MemoryLayout layout) {
      * to make sure the backing off-heap memory block is deallocated accordingly. Failure to do so will result in off-heap memory leaks.
      *
      * @param bytesSize the size (in bytes) of the off-heap memory block backing the native memory segment.
-     * @return a new native memory segment.
+     * @return a new confined native memory segment.
      * @throws IllegalArgumentException if {@code bytesSize < 0}.
      */
     static MemorySegment allocateNative(long bytesSize) {
@@ -560,11 +797,11 @@ static MemorySegment allocateNative(long bytesSize) {
     }
 
     /**
-     * Creates a new mapped memory segment that models a memory-mapped region of a file from a given path.
+     * Creates a new confined mapped memory segment that models a memory-mapped region of a file from a given path.
      * 

      * The segment will feature all access modes (see {@link #ALL_ACCESS}),
      * unless the given mapping mode is {@linkplain FileChannel.MapMode#READ_ONLY READ_ONLY}, in which case
-     * the segment will not feature the {@link #WRITE} access mode.
+     * the segment will not feature the {@link #WRITE} access mode, and its confinement thread is the current thread (see {@link Thread#currentThread()}).
      *
      * @implNote When obtaining a mapped segment from a newly created file, the initialization state of the contents of the block
      * of mapped memory associated with the returned mapped memory segment is unspecified and should not be relied upon.
@@ -574,7 +811,7 @@ static MemorySegment allocateNative(long bytesSize) {
      * @param bytesSize the size (in bytes) of the mapped memory backing the memory segment.
      * @param mapMode a file mapping mode, see {@link FileChannel#map(FileChannel.MapMode, long, long)}; the chosen mapping mode
      *                might affect the behavior of the returned memory mapped segment (see {@link MappedMemorySegment#force()}).
-     * @return a new mapped memory segment.
+     * @return a new confined mapped memory segment.
      * @throws IllegalArgumentException if {@code bytesOffset < 0}.
      * @throws IllegalArgumentException if {@code bytesSize < 0}.
      * @throws UnsupportedOperationException if an unsupported map mode is specified.
@@ -585,9 +822,9 @@ static MappedMemorySegment mapFromPath(Path path, long bytesOffset, long bytesSi
     }
 
     /**
-     * Creates a new native memory segment that models a newly allocated block of off-heap memory with given size and
+     * Creates a new confined native memory segment that models a newly allocated block of off-heap memory with given size and
      * alignment constraint (in bytes). The segment will feature all access modes
-     * (see {@link #ALL_ACCESS}).
+     * (see {@link #ALL_ACCESS}), and its confinement thread is the current thread (see {@link Thread#currentThread()}).
      *
      * @implNote The block of off-heap memory associated with the returned native memory segment is initialized to zero.
      * Moreover, a client is responsible to call the {@link MemorySegment#close()} on a native memory segment,
@@ -595,7 +832,7 @@ static MappedMemorySegment mapFromPath(Path path, long bytesOffset, long bytesSi
      *
      * @param bytesSize the size (in bytes) of the off-heap memory block backing the native memory segment.
      * @param alignmentBytes the alignment constraint (in bytes) of the off-heap memory block backing the native memory segment.
-     * @return a new native memory segment.
+     * @return a new confined native memory segment.
      * @throws IllegalArgumentException if {@code bytesSize < 0}, {@code alignmentBytes < 0}, or if {@code alignmentBytes}
      * is not a power of 2.
      */
@@ -613,39 +850,27 @@ static MemorySegment allocateNative(long bytesSize, long alignmentBytes) {
     }
 
     /**
-     * Returns a new native memory segment with given base address and size; the returned segment has its own temporal
-     * bounds, and can therefore be closed; closing such a segment can optionally result in calling an user-provided cleanup
-     * action. This method can be very useful when interacting with custom native memory sources (e.g. custom allocators,
-     * GPU memory, etc.), where an address to some underlying memory region is typically obtained from native code
-     * (often as a plain {@code long} value). The segment will feature all access modes
-     * (see {@link #ALL_ACCESS}).
+     * Returns a shared native memory segment whose base address is {@link MemoryAddress#NULL} and whose size is {@link Long#MAX_VALUE}.
+     * This method can be very useful when dereferencing memory addresses obtained when interacting with native libraries.
+     * The segment will feature the {@link #READ} and {@link #WRITE} access modes.
+     * Equivalent to (but likely more efficient than) the following code:
+     * 
{@code
+    MemoryAddress.NULL.asSegmentRestricted(Long.MAX_VALUE)
+                 .withOwnerThread(null)
+                 .withAccessModes(READ | WRITE);
+     * }

      * 

      * This method is restricted. Restricted methods are unsafe, and, if used incorrectly, their use might crash
      * the JVM or, worse, silently result in memory corruption. Thus, clients should refrain from depending on
      * restricted methods, and use safe and supported functionalities, where possible.
      *
-     * @param addr the desired base address
-     * @param bytesSize the desired size.
-     * @param owner the desired owner thread. If {@code owner == null}, the returned segment is not confined.
-     * @param cleanup a cleanup action to be executed when the {@link MemorySegment#close()} method is called on the
-     *                returned segment. If {@code cleanup == null}, no cleanup action is executed.
-     * @param attachment an object that must be kept alive by the returned segment; this can be useful when
-     *                   the returned segment depends on memory which could be released if a certain object
-     *                   is determined to be unreacheable. In most cases this will be set to {@code null}.
-     * @return a new native memory segment with given base address, size, owner, cleanup action and object attachment.
-     * @throws IllegalArgumentException if {@code bytesSize <= 0}.
-     * @throws UnsupportedOperationException if {@code addr} is associated with an heap segment.
+     * @return a memory segment whose base address is {@link MemoryAddress#NULL} and whose size is {@link Long#MAX_VALUE}.
      * @throws IllegalAccessError if the runtime property {@code foreign.restricted} is not set to either
      * {@code permit}, {@code warn} or {@code debug} (the default value is set to {@code deny}).
-     * @throws NullPointerException if {@code addr == null}.
      */
-    static MemorySegment ofNativeRestricted(MemoryAddress addr, long bytesSize, Thread owner, Runnable cleanup, Object attachment) {
-        Objects.requireNonNull(addr);
-        if (bytesSize <= 0) {
-            throw new IllegalArgumentException("Invalid size : " + bytesSize);
-        }
+    static MemorySegment ofNativeRestricted() {
         Utils.checkRestrictedAccess("MemorySegment.ofNativeRestricted");
-        return NativeMemorySegmentImpl.makeNativeSegmentUnchecked(addr, bytesSize, owner, cleanup, attachment);
+        return NativeMemorySegmentImpl.EVERYTHING;
     }
 
     // access mode masks
@@ -672,25 +897,25 @@ static MemorySegment ofNativeRestricted(MemoryAddress addr, long bytesSize, Thre
     int CLOSE = WRITE << 1;
 
     /**
-     * Acquire access mode; this segment support sharing with threads other than the owner thread, via spliterator
+     * Share access mode; this segment support sharing with threads other than the owner thread (see {@link #share()}).
      * (see {@link #spliterator(MemorySegment, SequenceLayout)}).
      * @see MemorySegment#accessModes()
      * @see MemorySegment#withAccessModes(int)
      */
-    int ACQUIRE = CLOSE << 1;
+    int SHARE = CLOSE << 1;
 
     /**
      * Handoff access mode; this segment support serial thread-confinement via thread ownership changes
-     * (see {@link #withOwnerThread(Thread)}).
+     * (see {@link #handoff(Thread)}).
      * @see MemorySegment#accessModes()
      * @see MemorySegment#withAccessModes(int)
      */
-    int HANDOFF = ACQUIRE << 1;
+    int HANDOFF = SHARE << 1;
 
     /**
      * Default access mode; this is a union of all the access modes supported by memory segments.
      * @see MemorySegment#accessModes()
      * @see MemorySegment#withAccessModes(int)
      */
-    int ALL_ACCESS = READ | WRITE | CLOSE | ACQUIRE | HANDOFF;
+    int ALL_ACCESS = READ | WRITE | CLOSE | SHARE | HANDOFF;
 }
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/package-info.java b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/package-info.java
index d7906221e94b0..e318e9c69f249 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/package-info.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/package-info.java
@@ -28,8 +28,9 @@
  * 
 Classes to support low-level, safe and efficient memory access.
  * 

  * The key abstractions introduced by this package are {@link jdk.incubator.foreign.MemorySegment} and {@link jdk.incubator.foreign.MemoryAddress}.
- * The first models a contiguous memory region, which can reside either inside or outside the Java heap; the latter models an address - which can
- * sometimes be expressed as an offset into a given segment. A memory address represents the main access coordinate of a memory access var handle, which can be obtained
+ * The first models a contiguous memory region, which can reside either inside or outside the Java heap; the latter models an address - which also can
+ * reside either inside or outside the Java heap (and can sometimes be expressed as an offset into a given segment).
+ * A memory segment represents the main access coordinate of a memory access var handle, which can be obtained
  * using the combinator methods defined in the {@link jdk.incubator.foreign.MemoryHandles} class. Finally, the {@link jdk.incubator.foreign.MemoryLayout} class
  * hierarchy enables description of memory layouts and basic operations such as computing the size in bytes of a given
  * layout, obtain its alignment requirements, and so on. Memory layouts also provide an alternate, more abstract way, to produce
@@ -42,9 +43,8 @@
 static final VarHandle intHandle = MemoryHandles.varHandle(int.class, ByteOrder.nativeOrder());
 
 try (MemorySegment segment = MemorySegment.allocateNative(10 * 4)) {
-    MemoryAddress base = segment.baseAddress();
     for (long i = 0 ; i < 10 ; i++) {
-       intHandle.set(base.addOffset(i * 4), (int)i);
+       intHandle.set(base.asSlice(i * 4), (int)i);
     }
 }
  * }

@@ -77,18 +77,18 @@
  *
  * 
Safety

  *
- * This API provides strong safety guarantees when it comes to memory access. First, when dereferencing a memory segment using
- * a memory address, such an address is validated (upon access), to make sure that it does not point to a memory location
- * which resides outside the boundaries of the memory segment it refers to. We call this guarantee spatial safety;
+ * This API provides strong safety guarantees when it comes to memory access. First, when dereferencing a memory segment,
+ * the access coordinates are validated (upon access), to make sure that access does not occur at an address which resides
+ * outside the boundaries of the memory segment used by the dereference operation. We call this guarantee spatial safety;
  * in other words, access to memory segments is bounds-checked, in the same way as array access is, as described in
  * Section {@jls 15.10.4} of The Java Language Specification.
  * 

- * Since memory segments can be closed (see above), a memory address is also validated (upon access) to make sure that
- * the segment it belongs to has not been closed prematurely. We call this guarantee temporal safety. Note that,
+ * Since memory segments can be closed (see above), segments are also validated (upon access) to make sure that
+ * the segment being accessed has not been closed prematurely. We call this guarantee temporal safety. Note that,
  * in the general case, guaranteeing temporal safety can be hard, as multiple threads could attempt to access and/or close
  * the same memory segment concurrently. The memory access API addresses this problem by imposing strong
- * thread-confinement guarantees on memory segments: each
- * memory segment is associated with an owner thread, which is the only thread that can either access or close the segment.
+ * thread-confinement guarantees on memory segments: upon creation, a memory segment is associated with an owner thread,
+ * which is the only thread that can either access or close the segment.
  * 

  * Together, spatial and temporal safety ensure that each memory access operation either succeeds - and accesses a valid
  * memory location - or fails.
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/AbstractMemorySegmentImpl.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/AbstractMemorySegmentImpl.java
index 9c45b02e5c2b7..1ad5b905ea2e8 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/AbstractMemorySegmentImpl.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/AbstractMemorySegmentImpl.java
@@ -25,21 +25,19 @@
 
 package jdk.internal.foreign;
 
-import jdk.incubator.foreign.MemoryAddress;
-import jdk.incubator.foreign.MemoryLayout;
-import jdk.incubator.foreign.MemoryLayouts;
-import jdk.incubator.foreign.MemorySegment;
-import jdk.incubator.foreign.SequenceLayout;
+import jdk.incubator.foreign.*;
 import jdk.internal.access.JavaNioAccess;
 import jdk.internal.access.SharedSecrets;
 import jdk.internal.access.foreign.MemorySegmentProxy;
 import jdk.internal.access.foreign.UnmapperProxy;
+import jdk.internal.misc.ScopedMemoryAccess;
 import jdk.internal.misc.Unsafe;
 import jdk.internal.util.ArraysSupport;
 import jdk.internal.vm.annotation.ForceInline;
 import sun.security.action.GetPropertyAction;
 
 import java.lang.invoke.VarHandle;
+import java.lang.ref.Cleaner;
 import java.nio.ByteBuffer;
 import java.util.ArrayList;
 import java.util.List;
@@ -47,6 +45,8 @@
 import java.util.Random;
 import java.util.Spliterator;
 import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.IntFunction;
 
 /**
  * This abstract class provides an immutable implementation for the {@code MemorySegment} interface. This class contains information
@@ -60,6 +60,7 @@
 public abstract class AbstractMemorySegmentImpl implements MemorySegment, MemorySegmentProxy {
 
     private static final Unsafe UNSAFE = Unsafe.getUnsafe();
+    private static final ScopedMemoryAccess SCOPED_MEMORY_ACCESS = ScopedMemoryAccess.getScopedMemoryAccess();
 
     private static final boolean enableSmallSegments =
             Boolean.parseBoolean(GetPropertyAction.privilegedGetProperty("jdk.incubator.foreign.SmallSegments", "true"));
@@ -101,6 +102,12 @@ public AbstractMemorySegmentImpl asSlice(long offset, long newSize) {
         return asSliceNoCheck(offset, newSize);
     }
 
+    @Override
+    public AbstractMemorySegmentImpl asSlice(long offset) {
+        checkBounds(offset, 0);
+        return asSliceNoCheck(offset, length - offset);
+    }
+
     private AbstractMemorySegmentImpl asSliceNoCheck(long offset, long newSize) {
         return dup(offset, newSize, mask, scope);
     }
@@ -117,17 +124,17 @@ public static  Spliterator spliterator(S segment, Se
 
     @Override
     public final MemorySegment fill(byte value){
-        checkRange(0, length, true);
-        UNSAFE.setMemory(base(), min(), length, value);
+        checkAccess(0, length, false);
+        SCOPED_MEMORY_ACCESS.setMemory(scope, base(), min(), length, value);
         return this;
     }
 
     public void copyFrom(MemorySegment src) {
         AbstractMemorySegmentImpl that = (AbstractMemorySegmentImpl)src;
         long size = that.byteSize();
-        checkRange(0, size, true);
-        that.checkRange(0, size, false);
-        UNSAFE.copyMemory(
+        checkAccess(0, size, false);
+        that.checkAccess(0, size, true);
+        SCOPED_MEMORY_ACCESS.copyMemory(scope, that.scope,
                 that.base(), that.min(),
                 base(), min(), size);
     }
@@ -141,18 +148,19 @@ public long mismatch(MemorySegment other) {
         final long thisSize = this.byteSize();
         final long thatSize = that.byteSize();
         final long length = Math.min(thisSize, thatSize);
-        this.checkRange(0, length, false);
-        that.checkRange(0, length, false);
+        this.checkAccess(0, length, true);
+        that.checkAccess(0, length, true);
         if (this == other) {
+            checkValidState();
             return -1;
         }
 
         long i = 0;
         if (length > 7) {
-            if ((byte) BYTE_HANDLE.get(this.baseAddress(), 0) != (byte) BYTE_HANDLE.get(that.baseAddress(), 0)) {
+            if ((byte) BYTE_HANDLE.get(this, 0) != (byte) BYTE_HANDLE.get(that, 0)) {
                 return 0;
             }
-            i = ArraysSupport.vectorizedMismatchLargeForBytes(
+            i = vectorizedMismatchLargeForBytes(scope, that.scope,
                     this.base(), this.min(),
                     that.base(), that.min(),
                     length);
@@ -163,20 +171,51 @@ public long mismatch(MemorySegment other) {
             assert remaining < 8 : "remaining greater than 7: " + remaining;
             i = length - remaining;
         }
-        MemoryAddress thisAddress = this.baseAddress();
-        MemoryAddress thatAddress = that.baseAddress();
         for (; i < length; i++) {
-            if ((byte) BYTE_HANDLE.get(thisAddress, i) != (byte) BYTE_HANDLE.get(thatAddress, i)) {
+            if ((byte) BYTE_HANDLE.get(this, i) != (byte) BYTE_HANDLE.get(that, i)) {
                 return i;
             }
         }
         return thisSize != thatSize ? length : -1;
     }
 
+    /**
+     * Mismatch over long lengths.
+     */
+    private static long vectorizedMismatchLargeForBytes(MemoryScope aScope, MemoryScope bScope,
+                                                       Object a, long aOffset,
+                                                       Object b, long bOffset,
+                                                       long length) {
+        long off = 0;
+        long remaining = length;
+        int i, size;
+        boolean lastSubRange = false;
+        while (remaining > 7 && !lastSubRange) {
+            if (remaining > Integer.MAX_VALUE) {
+                size = Integer.MAX_VALUE;
+            } else {
+                size = (int) remaining;
+                lastSubRange = true;
+            }
+            i = SCOPED_MEMORY_ACCESS.vectorizedMismatch(aScope, bScope,
+                    a, aOffset + off,
+                    b, bOffset + off,
+                    size, ArraysSupport.LOG2_ARRAY_BYTE_INDEX_SCALE);
+            if (i >= 0)
+                return off + i;
+
+            i = size - ~i;
+            off += i;
+            remaining -= i;
+        }
+        return ~remaining;
+    }
+
     @Override
     @ForceInline
-    public final MemoryAddress baseAddress() {
-        return new MemoryAddressImpl(this, 0);
+    public final MemoryAddress address() {
+        checkValidState();
+        return new MemoryAddressImpl(base(), min());
     }
 
     @Override
@@ -184,7 +223,7 @@ public final ByteBuffer asByteBuffer() {
         if (!isSet(READ)) {
             throw unsupportedAccessMode(READ);
         }
-        checkIntSize("ByteBuffer");
+        checkArraySize("ByteBuffer", 1);
         ByteBuffer _bb = makeByteBuffer();
         if (!isSet(WRITE)) {
             //scope is IMMUTABLE - obtain a RO byte buffer
@@ -234,69 +273,132 @@ private void checkAccessModes(int accessModes) {
         }
     }
 
-    @Override
-    public MemorySegment withOwnerThread(Thread newOwner) {
-        Objects.requireNonNull(newOwner);
+    public MemorySegment handoff(Thread thread) {
+        Objects.requireNonNull(thread);
+        checkValidState();
         if (!isSet(HANDOFF)) {
             throw unsupportedAccessMode(HANDOFF);
         }
-        if (scope.ownerThread() == newOwner) {
-            throw new IllegalArgumentException("Segment already owned by thread: " + newOwner);
-        } else {
-            try {
-                return dup(0L, length, mask, scope.dup(newOwner));
-            } finally {
-                //flush read/writes to segment memory before returning the new segment
-                VarHandle.fullFence();
-            }
+        try {
+            return dup(0L, length, mask, scope.confineTo(thread));
+        } finally {
+            //flush read/writes to segment memory before returning the new segment
+            VarHandle.fullFence();
         }
     }
 
     @Override
-    public final void close() {
+    public MemorySegment share() {
+        checkValidState();
+        if (!isSet(SHARE)) {
+            throw unsupportedAccessMode(SHARE);
+        }
+        try {
+            return dup(0L, length, mask, scope.share());
+        } finally {
+            //flush read/writes to segment memory before returning the new segment
+            VarHandle.fullFence();
+        }
+    }
+
+    @Override
+    public MemorySegment registerCleaner(Cleaner cleaner) {
+        Objects.requireNonNull(cleaner);
+        checkValidState();
         if (!isSet(CLOSE)) {
             throw unsupportedAccessMode(CLOSE);
         }
-        closeNoCheck();
+        return dup(0L, length, mask, scope.cleanable(cleaner));
     }
 
-    private final void closeNoCheck() {
+    @Override
+    public final void close() {
+        checkValidState();
+        if (!isSet(CLOSE)) {
+            throw unsupportedAccessMode(CLOSE);
+        }
         scope.close();
     }
 
-    final AbstractMemorySegmentImpl acquire() {
-        if (Thread.currentThread() != ownerThread() && !isSet(ACQUIRE)) {
-            throw unsupportedAccessMode(ACQUIRE);
-        }
-        return dup(0, length, mask, scope.acquire());
+    @Override
+    public final byte[] toByteArray() {
+        return toArray(byte[].class, 1, byte[]::new, MemorySegment::ofArray);
     }
 
     @Override
-    public final byte[] toByteArray() {
-        checkIntSize("byte[]");
-        byte[] arr = new byte[(int)length];
-        MemorySegment arrSegment = MemorySegment.ofArray(arr);
+    public final short[] toShortArray() {
+        return toArray(short[].class, 2, short[]::new, MemorySegment::ofArray);
+    }
+
+    @Override
+    public final char[] toCharArray() {
+        return toArray(char[].class, 2, char[]::new, MemorySegment::ofArray);
+    }
+
+    @Override
+    public final int[] toIntArray() {
+        return toArray(int[].class, 4, int[]::new, MemorySegment::ofArray);
+    }
+
+    @Override
+    public final float[] toFloatArray() {
+        return toArray(float[].class, 4, float[]::new, MemorySegment::ofArray);
+    }
+
+    @Override
+    public final long[] toLongArray() {
+        return toArray(long[].class, 8, long[]::new, MemorySegment::ofArray);
+    }
+
+    @Override
+    public final double[] toDoubleArray() {
+        return toArray(double[].class, 8, double[]::new, MemorySegment::ofArray);
+    }
+
+    private  Z toArray(Class arrayClass, int elemSize, IntFunction arrayFactory, Function segmentFactory) {
+        int size = checkArraySize(arrayClass.getSimpleName(), elemSize);
+        Z arr = arrayFactory.apply(size);
+        MemorySegment arrSegment = segmentFactory.apply(arr);
         arrSegment.copyFrom(this);
         return arr;
     }
 
-    boolean isSmall() {
+    @Override
+    public boolean isSmall() {
         return isSet(SMALL);
     }
 
-    void checkRange(long offset, long length, boolean writeAccess) {
-        scope.checkValidState();
-        if (writeAccess && !isSet(WRITE)) {
+    @Override
+    public void checkAccess(long offset, long length, boolean readOnly) {
+        if (!readOnly && !isSet(WRITE)) {
             throw unsupportedAccessMode(WRITE);
-        } else if (!writeAccess && !isSet(READ)) {
+        } else if (readOnly && !isSet(READ)) {
             throw unsupportedAccessMode(READ);
         }
         checkBounds(offset, length);
     }
 
+    private void checkAccessAndScope(long offset, long length, boolean readOnly) {
+        checkValidState();
+        checkAccess(offset, length, readOnly);
+    }
+
+    private void checkValidState() {
+        try {
+            scope.checkValidState();
+        } catch (ScopedMemoryAccess.Scope.ScopedAccessError ex) {
+            throw new IllegalStateException("This segment is already closed");
+        }
+    }
+
     @Override
-    public final void checkValidState() {
-        scope.checkValidState();
+    public long unsafeGetOffset() {
+        return min();
+    }
+
+    @Override
+    public Object unsafeGetBase() {
+        return base();
     }
 
     // Helper methods
@@ -305,10 +407,15 @@ private boolean isSet(int mask) {
         return (this.mask & mask) != 0;
     }
 
-    private void checkIntSize(String typeName) {
-        if (length > (Integer.MAX_VALUE - 8)) { //conservative check
+    private int checkArraySize(String typeName, int elemSize) {
+        if (length % elemSize != 0) {
+            throw new UnsupportedOperationException(String.format("Segment size is not a multiple of %d. Size: %d", elemSize, length));
+        }
+        long arraySize = length / elemSize;
+        if (arraySize > (Integer.MAX_VALUE - 8)) { //conservative check
             throw new UnsupportedOperationException(String.format("Segment is too large to wrap as %s. Size: %d", typeName, length));
         }
+        return (int)arraySize;
     }
 
     private void checkBounds(long offset, long length) {
@@ -323,6 +430,11 @@ private void checkBounds(long offset, long length) {
         }
     }
 
+    @Override
+    public MemoryScope scope() {
+        return scope;
+    }
+
     private void checkBoundsSmall(int offset, int length) {
         if (length < 0 ||
                 offset < 0 ||
@@ -347,8 +459,8 @@ private List modeStrings(int mode) {
         if ((mode & CLOSE) != 0) {
             modes.add("CLOSE");
         }
-        if ((mode & ACQUIRE) != 0) {
-            modes.add("ACQUIRE");
+        if ((mode & SHARE) != 0) {
+            modes.add("SHARE");
         }
         if ((mode & HANDOFF) != 0) {
             modes.add("HANDOFF");
@@ -398,11 +510,10 @@ public SegmentSplitter trySplit() {
         public boolean tryAdvance(Consumer action) {
             Objects.requireNonNull(action);
             if (currentIndex < elemCount) {
-                AbstractMemorySegmentImpl acquired = segment.acquire();
+                AbstractMemorySegmentImpl acquired = segment;
                 try {
                     action.accept(acquired.asSliceNoCheck(currentIndex * elementSize, elementSize));
                 } finally {
-                    acquired.closeNoCheck();
                     currentIndex++;
                     if (currentIndex == elemCount) {
                         segment = null;
@@ -418,7 +529,7 @@ public boolean tryAdvance(Consumer action) {
         public void forEachRemaining(Consumer action) {
             Objects.requireNonNull(action);
             if (currentIndex < elemCount) {
-                AbstractMemorySegmentImpl acquired = segment.acquire();
+                AbstractMemorySegmentImpl acquired = segment;
                 try {
                     if (acquired.isSmall()) {
                         int index = (int) currentIndex;
@@ -433,7 +544,6 @@ public void forEachRemaining(Consumer action) {
                         }
                     }
                 } finally {
-                    acquired.closeNoCheck();
                     currentIndex = elemCount;
                     segment = null;
                 }
@@ -474,7 +584,7 @@ public static AbstractMemorySegmentImpl ofBuffer(ByteBuffer bb) {
             bufferScope = bufferSegment.scope;
             modes = bufferSegment.mask;
         } else {
-            bufferScope = MemoryScope.create(bb, null);
+            bufferScope = MemoryScope.createConfined(bb, MemoryScope.DUMMY_CLEANUP_ACTION, null);
             modes = defaultAccessModes(size);
         }
         if (bb.isReadOnly()) {
@@ -488,28 +598,4 @@ public static AbstractMemorySegmentImpl ofBuffer(ByteBuffer bb) {
             return new MappedMemorySegmentImpl(bbAddress + pos, unmapper, size, modes, bufferScope);
         }
     }
-
-    public static final AbstractMemorySegmentImpl NOTHING = new AbstractMemorySegmentImpl(
-        0, 0, MemoryScope.createUnchecked(null, null, null)
-    ) {
-        @Override
-        ByteBuffer makeByteBuffer() {
-            throw new UnsupportedOperationException();
-        }
-
-        @Override
-        long min() {
-            return 0;
-        }
-
-        @Override
-        Object base() {
-            return null;
-        }
-
-        @Override
-        AbstractMemorySegmentImpl dup(long offset, long size, int mask, MemoryScope scope) {
-            throw new UnsupportedOperationException();
-        }
-    };
 }
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/HeapMemorySegmentImpl.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/HeapMemorySegmentImpl.java
index 27e8429515c62..1a88f5f1635cd 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/HeapMemorySegmentImpl.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/HeapMemorySegmentImpl.java
@@ -121,7 +121,7 @@ public static MemorySegment makeArraySegment(double[] arr) {
 
     static  HeapMemorySegmentImpl makeHeapSegment(Supplier obj, int length, int base, int scale) {
         int byteSize = length * scale;
-        MemoryScope scope = MemoryScope.create(null, null);
+        MemoryScope scope = MemoryScope.createConfined(null, MemoryScope.DUMMY_CLEANUP_ACTION, null);
         return new HeapMemorySegmentImpl<>(base, obj, byteSize, defaultAccessModes(byteSize), scope);
     }
 }
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/LayoutPath.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/LayoutPath.java
index d789957f9437a..a0b6b5ebce574 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/LayoutPath.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/LayoutPath.java
@@ -25,21 +25,28 @@
  */
 package jdk.internal.foreign;
 
+import jdk.incubator.foreign.MemoryHandles;
 import jdk.incubator.foreign.MemoryLayout;
+import jdk.incubator.foreign.MemorySegment;
 import jdk.internal.access.JavaLangInvokeAccess;
 import jdk.internal.access.SharedSecrets;
-import sun.invoke.util.Wrapper;
+import jdk.internal.access.foreign.MemorySegmentProxy;
 
 import jdk.incubator.foreign.GroupLayout;
 import jdk.incubator.foreign.SequenceLayout;
 import jdk.incubator.foreign.ValueLayout;
+import sun.invoke.util.Wrapper;
 
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
 import java.lang.invoke.VarHandle;
+import java.util.ArrayDeque;
 import java.util.ArrayList;
+import java.util.Deque;
 import java.util.List;
 import java.util.function.ToLongFunction;
 import java.util.function.UnaryOperator;
-import java.util.stream.LongStream;
 
 /**
  * This class provide support for constructing layout paths; that is, starting from a root path (see {@link #rootPath(MemoryLayout, ToLongFunction)},
@@ -53,6 +60,17 @@ public class LayoutPath {
 
     private static final JavaLangInvokeAccess JLI = SharedSecrets.getJavaLangInvokeAccess();
 
+    private static final MethodHandle ADD_STRIDE;
+
+    static {
+        try {
+            ADD_STRIDE = MethodHandles.lookup().findStatic(LayoutPath.class, "addStride",
+                    MethodType.methodType(long.class, MemorySegment.class, long.class, long.class, long.class));
+        } catch (Throwable ex) {
+            throw new ExceptionInInitializerError(ex);
+        }
+    }
+
     private final MemoryLayout layout;
     private final long offset;
     private final LayoutPath enclosing;
@@ -141,12 +159,30 @@ public VarHandle dereferenceHandle(Class carrier) {
 
         checkAlignment(this);
 
-        return Utils.fixUpVarHandle(JLI.memoryAccessVarHandle(
-                carrier,
-                layout.byteAlignment() - 1, //mask
-                ((ValueLayout) layout).order(),
-                Utils.bitsToBytesOrThrow(offset, IllegalStateException::new),
-                LongStream.of(strides).map(s -> Utils.bitsToBytesOrThrow(s, IllegalStateException::new)).toArray()));
+        List> expectedCoordinates = new ArrayList<>();
+        Deque perms = new ArrayDeque<>();
+        perms.addFirst(0);
+        expectedCoordinates.add(MemorySegment.class);
+
+        VarHandle handle = Utils.fixUpVarHandle(JLI.memoryAccessVarHandle(carrier, true, layout.byteAlignment() - 1,
+                ((ValueLayout)layout).order()));
+
+        for (int i = 0 ; i < strides.length ; i++) {
+            expectedCoordinates.add(long.class);
+            perms.addFirst(0);
+            perms.addLast(i + 1);
+            //add stride
+            handle = MemoryHandles.collectCoordinates(handle, 1 + i,
+                    MethodHandles.insertArguments(ADD_STRIDE, 1, Utils.bitsToBytesOrThrow(strides[strides.length - 1 - i], IllegalStateException::new))); // MS, long, MS_n, long_n, long
+        }
+        //add offset
+        handle = MemoryHandles.insertCoordinates(handle, 1 + strides.length, Utils.bitsToBytesOrThrow(offset, IllegalStateException::new));
+
+        if (strides.length > 0) {
+            // remove duplicate MS args
+            handle = MemoryHandles.permuteCoordinates(handle, expectedCoordinates, perms.stream().mapToInt(i -> i).toArray());
+        }
+        return handle;
     }
 
     public MemoryLayout layout() {
@@ -284,4 +320,9 @@ public PathKind kind() {
             return kind;
         }
     }
+
+    private static long addStride(MemorySegment segment, long stride, long base, long index) {
+        return MemorySegmentProxy.addOffsets(base,
+                    MemorySegmentProxy.multiplyOffsets(stride, index, ((MemorySegmentProxy)segment)), (MemorySegmentProxy)segment);
+    }
 }
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/MappedMemorySegmentImpl.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/MappedMemorySegmentImpl.java
index c5321195b099f..54dd038ccc0dd 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/MappedMemorySegmentImpl.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/MappedMemorySegmentImpl.java
@@ -26,8 +26,6 @@
 package jdk.internal.foreign;
 
 import jdk.incubator.foreign.MappedMemorySegment;
-import jdk.internal.access.JavaNioAccess;
-import jdk.internal.access.SharedSecrets;
 import jdk.internal.access.foreign.UnmapperProxy;
 import sun.nio.ch.FileChannelImpl;
 
@@ -55,7 +53,6 @@ public class MappedMemorySegmentImpl extends NativeMemorySegmentImpl implements
 
     @Override
     ByteBuffer makeByteBuffer() {
-        JavaNioAccess nioAccess = SharedSecrets.getJavaNioAccess();
         return nioAccess.newMappedByteBuffer(unmapper, min, (int)length, null, this);
     }
 
@@ -104,7 +101,7 @@ public static MappedMemorySegment makeMappedSegment(Path path, long bytesOffset,
         if (bytesOffset < 0) throw new IllegalArgumentException("Requested bytes offset must be >= 0.");
         try (FileChannelImpl channelImpl = (FileChannelImpl)FileChannel.open(path, openOptions(mapMode))) {
             UnmapperProxy unmapperProxy = channelImpl.mapInternal(mapMode, bytesOffset, bytesSize);
-            MemoryScope scope = MemoryScope.create(null, unmapperProxy::unmap);
+            MemoryScope scope = MemoryScope.createConfined(null, unmapperProxy::unmap, null);
             int modes = defaultAccessModes(bytesSize);
             if (mapMode == FileChannel.MapMode.READ_ONLY) {
                 modes &= ~WRITE;
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/MemoryAddressImpl.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/MemoryAddressImpl.java
index feed358562ddd..dc76c0e87fa3c 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/MemoryAddressImpl.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/MemoryAddressImpl.java
@@ -25,9 +25,6 @@
  */
 package jdk.internal.foreign;
 
-import jdk.internal.access.foreign.MemoryAddressProxy;
-import jdk.internal.misc.Unsafe;
-
 import jdk.incubator.foreign.MemoryAddress;
 import jdk.incubator.foreign.MemorySegment;
 
@@ -37,93 +34,54 @@
  * This class provides an immutable implementation for the {@code MemoryAddress} interface. This class contains information
  * about the segment this address is associated with, as well as an offset into such segment.
  */
-public final class MemoryAddressImpl implements MemoryAddress, MemoryAddressProxy {
-
-    private static final Unsafe UNSAFE = Unsafe.getUnsafe();
+public final class MemoryAddressImpl implements MemoryAddress {
 
-    private final AbstractMemorySegmentImpl segment;
+    private final Object base;
     private final long offset;
 
-    public MemoryAddressImpl(long offset) {
-        this.segment = AbstractMemorySegmentImpl.NOTHING;
-        this.offset = offset;
-    }
-
-    public MemoryAddressImpl(AbstractMemorySegmentImpl segment, long offset) {
-        this.segment = Objects.requireNonNull(segment);
+    public MemoryAddressImpl(Object base, long offset) {
+        this.base = base;
         this.offset = offset;
     }
 
     // MemoryAddress methods
 
     @Override
-    public long segmentOffset() {
-        if (segment() == null) {
-            throw new UnsupportedOperationException("Address does not have a segment");
+    public long segmentOffset(MemorySegment segment) {
+        Objects.requireNonNull(segment);
+        AbstractMemorySegmentImpl segmentImpl = (AbstractMemorySegmentImpl)segment;
+        if (segmentImpl.base() != base) {
+            throw new IllegalArgumentException("Invalid segment: " + segment);
         }
-        return offset;
+        return offset - segmentImpl.min();
     }
 
     @Override
     public long toRawLongValue() {
-        if (unsafeGetBase() != null) {
+        if (base != null) {
             throw new UnsupportedOperationException("Not a native address");
         }
-        return unsafeGetOffset();
-    }
-
-    @Override
-    public MemorySegment segment() {
-        return segment != AbstractMemorySegmentImpl.NOTHING ?
-                segment : null;
+        return offset;
     }
 
     @Override
     public MemoryAddress addOffset(long bytes) {
-        return new MemoryAddressImpl(segment, offset + bytes);
+        return new MemoryAddressImpl(base, offset + bytes);
     }
 
-    @Override
-    public MemoryAddress rebase(MemorySegment segment) {
-        AbstractMemorySegmentImpl segmentImpl = (AbstractMemorySegmentImpl)segment;
-        if (segmentImpl.base() != this.segment.base()) {
-            throw new IllegalArgumentException("Invalid rebase target: " + segment);
-        }
-        return new MemoryAddressImpl((AbstractMemorySegmentImpl)segment,
-                unsafeGetOffset() - ((MemoryAddressImpl)segment.baseAddress()).unsafeGetOffset());
-    }
-
-    // MemoryAddressProxy methods
-
-    public void checkAccess(long offset, long length, boolean readOnly) {
-        segment.checkRange(MemoryAddressProxy.addOffsets(this.offset, offset, this), length, !readOnly);
-    }
-
-    public long unsafeGetOffset() {
-        return segment.min() + offset;
-    }
-
-    public Object unsafeGetBase() {
-        return segment.base();
-    }
-
-    @Override
-    public boolean isSmall() {
-        return segment.isSmall();
-    }
     // Object methods
 
     @Override
     public int hashCode() {
-        return Objects.hash(unsafeGetBase(), unsafeGetOffset());
+        return Objects.hash(base, offset);
     }
 
     @Override
     public boolean equals(Object that) {
         if (that instanceof MemoryAddressImpl) {
             MemoryAddressImpl addr = (MemoryAddressImpl)that;
-            return Objects.equals(unsafeGetBase(), ((MemoryAddressImpl) that).unsafeGetBase()) &&
-                    unsafeGetOffset() == addr.unsafeGetOffset();
+            return Objects.equals(base, addr.base) &&
+                    offset == addr.offset;
         } else {
             return false;
         }
@@ -131,6 +89,15 @@ public boolean equals(Object that) {
 
     @Override
     public String toString() {
-        return "MemoryAddress{ region: " + segment + " offset=0x" + Long.toHexString(offset) + " }";
+        return "MemoryAddress{ base: " + base + " offset=0x" + Long.toHexString(offset) + " }";
+    }
+
+    @Override
+    public MemorySegment asSegmentRestricted(long bytesSize, Runnable cleanupAction, Object attachment) {
+        Utils.checkRestrictedAccess("MemoryAddress.asSegmentRestricted");
+        if (bytesSize <= 0) {
+            throw new IllegalArgumentException("Invalid size : " + bytesSize);
+        }
+        return NativeMemorySegmentImpl.makeNativeSegmentUnchecked(this, bytesSize, cleanupAction, attachment);
     }
 }
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/MemoryScope.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/MemoryScope.java
index 43706a97588c9..c89d8777ab882 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/MemoryScope.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/MemoryScope.java
@@ -1,5 +1,5 @@
 /*
- *  Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
+ *  Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
  *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  *  This code is free software; you can redistribute it and/or modify it
@@ -26,287 +26,290 @@
 
 package jdk.internal.foreign;
 
+import jdk.internal.misc.ScopedMemoryAccess;
+import jdk.internal.ref.PhantomCleanable;
 import jdk.internal.vm.annotation.ForceInline;
 
 import java.lang.invoke.MethodHandles;
 import java.lang.invoke.VarHandle;
+import java.lang.ref.Cleaner;
+import java.lang.ref.Reference;
 import java.util.Objects;
-import java.util.concurrent.atomic.LongAdder;
-import java.util.concurrent.locks.StampedLock;
 
 /**
  * This class manages the temporal bounds associated with a memory segment as well
- * as thread confinement.
- * A scope has a liveness bit, which is updated when the scope is closed
- * (this operation is triggered by {@link AbstractMemorySegmentImpl#close()}).
- * A scope may also have an associated "owner" thread that confines some operations to
- * associated owner thread such as {@link #close()} or {@link #dup(Thread)}.
- * Furthermore, a scope is either root scope ({@link #create(Object, Runnable) created}
- * when memory segment is allocated) or child scope ({@link #acquire() acquired} from root scope).
- * When a child scope is acquired from another child scope, it is actually acquired from
- * the root scope. There is only a single level of children. All child scopes are peers.
- * A child scope can be {@link #close() closed} at any time, but root scope can only
- * be closed after all its children have been closed, at which time any associated
- * cleanup action is executed (the associated memory segment is freed).
- * Besides thread-confined checked scopes, {@linkplain #createUnchecked(Thread, Object, Runnable)}
- * method may be used passing {@code null} as the "owner" thread to create a
- * scope that doesn't check for thread-confinement while its temporal bounds are
- * enforced reliably only under condition that thread that closes the scope is also
- * the single thread performing the checked access or there is an external synchronization
- * in place that prevents concurrent access and closing of the scope.
+ * as thread confinement. A scope has a liveness bit, which is updated when the scope is closed
+ * (this operation is triggered by {@link AbstractMemorySegmentImpl#close()}). This bit is consulted prior
+ * to memory access (see {@link #checkValidState()}).
+ * There are two kinds of memory scope: confined memory scope and shared memory scope.
+ * A confined memory scope has an associated owner thread that confines some operations to
+ * associated owner thread such as {@link #close()} or {@link #checkValidState()}.
+ * Shared scopes do not feature an owner thread - meaning their operations can be called, in a racy
+ * manner, by multiple threads. To guarantee temporal safety in the presence of concurrent thread,
+ * shared scopes use a more sophisticated synchronization mechanism, which guarantees that no concurrent
+ * access is possible when a scope is being closed (see {@link jdk.internal.misc.ScopedMemoryAccess}).
  */
-abstract class MemoryScope {
+abstract class MemoryScope implements ScopedMemoryAccess.Scope {
+
+    static final Runnable DUMMY_CLEANUP_ACTION = () -> { };
+
+    private MemoryScope(Object ref, Runnable cleanupAction, Cleaner cleaner) {
+        Objects.requireNonNull(cleanupAction);
+        this.ref = ref;
+        this.cleanupAction = cleanupAction;
+        this.scopeCleanable = cleaner != null ?
+                new ScopeCleanable(this, cleaner, cleanupAction) :
+                null;
+    }
 
     /**
-     * Creates a root MemoryScope with given ref, cleanupAction and current
-     * thread as the "owner" thread.
-     * This method may be called in any thread.
-     * The returned instance may be published unsafely to and used in any thread,
-     * but methods that explicitly state that they may only be called in "owner" thread,
-     * must strictly be called in the thread that created the scope
-     * or else IllegalStateException is thrown.
-     *
+     * Creates a confined memory scope with given attachment and cleanup action. The returned scope
+     * is assumed to be confined on the current thread.
      * @param ref           an optional reference to an instance that needs to be kept reachable
-     * @param cleanupAction an optional cleanup action to be executed when returned scope is closed
-     * @return a root MemoryScope
+     * @param cleanupAction a cleanup action to be executed when returned scope is closed
+     * @return a confined memory scope
      */
-    static MemoryScope create(Object ref, Runnable cleanupAction) {
-        return new Root(Thread.currentThread(), ref, cleanupAction);
+    static MemoryScope createConfined(Object ref, Runnable cleanupAction, Cleaner cleaner) {
+        return new ConfinedScope(Thread.currentThread(), ref, cleanupAction, cleaner);
     }
 
     /**
-     * Creates a root MemoryScope with given ref, cleanupAction and "owner" thread.
-     * This method may be called in any thread.
-     * The returned instance may be published unsafely to and used in any thread,
-     * but methods that explicitly state that they may only be called in "owner" thread,
-     * must strictly be called in given owner thread or else IllegalStateException is thrown.
-     * If given owner thread is null, the returned MemoryScope is unchecked, meaning
-     * that all methods may be called in any thread and that {@link #checkValidState()}
-     * does not check for temporal bounds.
-     *
-     * @param owner         the desired owner thread. If {@code owner == null},
-     *                      the returned scope is not thread-confined and not checked.
+     * Creates a shared memory scope with given attachment and cleanup action.
      * @param ref           an optional reference to an instance that needs to be kept reachable
-     * @param cleanupAction an optional cleanup action to be executed when returned scope is closed
-     * @return a root MemoryScope
+     * @param cleanupAction a cleanup action to be executed when returned scope is closed
+     * @return a shared memory scope
      */
-    static MemoryScope createUnchecked(Thread owner, Object ref, Runnable cleanupAction) {
-        return new Root(owner, ref, cleanupAction);
+    static MemoryScope createShared(Object ref, Runnable cleanupAction, Cleaner cleaner) {
+        return new SharedScope(ref, cleanupAction, cleaner);
     }
 
-    private final Thread owner;
-    private boolean closed; // = false
-    private static final VarHandle CLOSED;
+    protected final Object ref;
+    protected final ScopeCleanable scopeCleanable;
+    protected final Runnable cleanupAction;
 
-    static {
+    /**
+     * Closes this scope, executing any cleanup action (where provided).
+     * @throws IllegalStateException if this scope is already closed or if this is
+     * a confined scope and this method is called outside of the owner thread.
+     */
+    final void close() {
         try {
-            CLOSED = MethodHandles.lookup().findVarHandle(MemoryScope.class, "closed", boolean.class);
-        } catch (Throwable ex) {
-            throw new ExceptionInInitializerError(ex);
+            justClose();
+            cleanupAction.run();
+            if (scopeCleanable != null) {
+                scopeCleanable.clear();
+            }
+        } finally {
+            Reference.reachabilityFence(this);
         }
     }
 
-    private MemoryScope(Thread owner) {
-        this.owner = owner;
-    }
+    abstract void justClose();
 
     /**
-     * Acquires a child scope (or peer scope if this is a child) with current
-     * thread as the "owner" thread.
-     * This method may be called in any thread.
-     * The returned instance may be published unsafely to and used in any thread,
-     * but methods that explicitly state that they may only be called in "owner" thread,
-     * must strictly be called in the thread that acquired the scope
-     * or else IllegalStateException is thrown.
-     *
-     * @return a child (or peer) scope
-     * @throws IllegalStateException if root scope is already closed
-     */
-    abstract MemoryScope acquire();
-
-    /**
-     * Closes this scope, executing any cleanup action if this is the root scope.
-     * This method may only be called in the "owner" thread of this scope unless the
-     * scope is a root scope with no owner thread - i.e. is not checked.
-     *
+     * Duplicates this scope with given new "owner" thread and {@link #close() closes} it.
+     * @param newOwner new owner thread of the returned memory scope
+     * @return a new confined scope, which is a duplicate of this scope, but with a new owner thread.
      * @throws IllegalStateException if this scope is already closed or if this is
-     *                               a root scope and there is/are still active child
-     *                               scope(s) or if this method is called outside of
-     *                               owner thread in checked scope
+     * a confined scope and this method is called outside of the owner thread.
      */
-    abstract void close();
+    MemoryScope confineTo(Thread newOwner) {
+        try {
+            justClose();
+            if (scopeCleanable != null) {
+                scopeCleanable.clear();
+            }
+            return new ConfinedScope(newOwner, ref, cleanupAction, scopeCleanable != null ?
+                    scopeCleanable.cleaner : null);
+        } finally {
+            Reference.reachabilityFence(this);
+        }
+    }
 
     /**
      * Duplicates this scope with given new "owner" thread and {@link #close() closes} it.
-     * If this is a root scope, a new root scope is returned; this root scope is closed, but
-     * without executing the cleanup action, which is instead transferred to the duped scope.
-     * If this is a child scope, a new child scope is returned.
-     * This method may only be called in the "owner" thread of this scope unless the
-     * scope is a root scope with no owner thread - i.e. is not checked.
-     * The returned instance may be published unsafely to and used in any thread,
-     * but methods that explicitly state that they may only be called in "owner" thread,
-     * must strictly be called in given new "owner" thread
-     * or else IllegalStateException is thrown.
-     *
-     * @param newOwner new owner thread of the returned MemoryScope
-     * @return a duplicate of this scope
-     * @throws NullPointerException  if given owner thread is null
+     * @return a new shared scope, which is a duplicate of this scope.
      * @throws IllegalStateException if this scope is already closed or if this is
-     *                               a root scope and there is/are still active child
-     *                               scope(s) or if this method is called outside of
-     *                               owner thread in checked scope
+     * a confined scope and this method is called outside of the owner thread,
+     * or if this is already a shared scope.
      */
-    abstract MemoryScope dup(Thread newOwner);
+    MemoryScope share() {
+        try {
+            justClose();
+            if (scopeCleanable != null) {
+                scopeCleanable.clear();
+            }
+            return new SharedScope(ref, cleanupAction, scopeCleanable != null ?
+                    scopeCleanable.cleaner : null);
+        } finally {
+            Reference.reachabilityFence(this);
+        }
+    }
+
+    MemoryScope cleanable(Cleaner cleaner) {
+        if (scopeCleanable != null) {
+            throw new IllegalStateException("Already registered with a cleaner");
+        }
+        try {
+            justClose();
+            return ownerThread() == null ?
+                    new SharedScope(ref, cleanupAction, cleaner) :
+                    new ConfinedScope(ownerThread(), ref, cleanupAction, cleaner);
+        } finally {
+            Reference.reachabilityFence(this);
+        }
+    }
 
     /**
      * Returns "owner" thread of this scope.
-     *
-     * @return owner thread (or null for unchecked scope)
+     * @return owner thread (or null for a shared scope)
      */
-    final Thread ownerThread() {
-        return owner;
-    }
+    abstract Thread ownerThread();
 
     /**
-     * This method may be called in any thread.
-     *
+     * Returns true, if this scope is still alive. This method may be called in any thread.
      * @return {@code true} if this scope is not closed yet.
      */
-    final boolean isAlive() {
-        return !((boolean)CLOSED.getVolatile(this));
-    }
+    public abstract boolean isAlive();
 
     /**
-     * Checks that this scope is still alive and that this method is executed
-     * in the "owner" thread of this scope or this scope is unchecked (not associated
-     * with owner thread).
-     *
-     * @throws IllegalStateException if this scope is already closed or this
-     *                               method is executed outside owning thread
-     *                               in checked scope
+     * Checks that this scope is still alive (see {@link #isAlive()}).
+     * @throws IllegalStateException if this scope is already closed or if this is
+     * a confined scope and this method is called outside of the owner thread.
      */
-    @ForceInline
-    final void checkValidState() {
-        if (owner != null && owner != Thread.currentThread()) {
-            throw new IllegalStateException("Attempted access outside owning thread");
-        }
-        checkAliveConfined(this);
+    public abstract void checkValidState();
+
+    @Override
+    protected Object clone() throws CloneNotSupportedException {
+        throw new CloneNotSupportedException();
     }
 
     /**
-     * Checks that this scope is still alive.
-     *
-     * @throws IllegalStateException if this scope is already closed
+     * A confined scope, which features an owner thread. The liveness check features an additional
+     * confinement check - that is, calling any operation on this scope from a thread other than the
+     * owner thread will result in an exception. Because of this restriction, checking the liveness bit
+     * can be performed in plain mode (see {@link #checkAliveRaw(MemoryScope)}).
      */
-    @ForceInline
-    private static void checkAliveConfined(MemoryScope scope) {
-        if (scope.closed) {
-            throw new IllegalStateException("This segment is already closed");
-        }
-    }
+    static class ConfinedScope extends MemoryScope {
 
-    private static final class Root extends MemoryScope {
-        private final StampedLock lock = new StampedLock();
-        private final LongAdder acquired = new LongAdder();
-        private final Object ref;
-        private final Runnable cleanupAction;
+        private boolean closed; // = false
+        final Thread owner;
 
-        private Root(Thread owner, Object ref, Runnable cleanupAction) {
-            super(owner);
-            this.ref = ref;
-            this.cleanupAction = cleanupAction;
+        public ConfinedScope(Thread owner, Object ref, Runnable cleanupAction, Cleaner cleaner) {
+            super(ref, cleanupAction, cleaner);
+            this.owner = owner;
         }
 
-        @Override
-        MemoryScope acquire() {
-            // try to optimistically acquire the lock
-            long stamp = lock.tryOptimisticRead();
-            try {
-                for (; ; stamp = lock.readLock()) {
-                    if (stamp == 0L)
-                        continue;
-                    checkAliveConfined(this); // plain read is enough here (either successful optimistic read, or full read lock)
-
-                    // increment acquires
-                    acquired.increment();
-                    // did a call to close() occur since we acquired the lock?
-                    if (lock.validate(stamp)) {
-                        // no, just return the acquired scope
-                        return new Child(Thread.currentThread());
-                    } else {
-                        // yes, just back off and retry (close might have failed, after all)
-                        acquired.decrement();
-                    }
-                }
-            } finally {
-                if (StampedLock.isReadLockStamp(stamp))
-                    lock.unlockRead(stamp);
+        @ForceInline
+        public final void checkValidState() {
+            if (owner != Thread.currentThread()) {
+                throw new IllegalStateException("Attempted access outside owning thread");
+            }
+            if (closed) {
+                throw ScopedAccessError.INSTANCE;
             }
         }
 
         @Override
-        MemoryScope dup(Thread newOwner) {
-            Objects.requireNonNull(newOwner, "newOwner");
-            // pre-allocate duped scope so we don't get OOME later and be left with this scope closed
-            var duped = new Root(newOwner, ref, cleanupAction);
-            justClose();
-            return duped;
+        public boolean isAlive() {
+            return !closed;
+        }
+
+        void justClose() {
+            checkValidState();
+            closed = true;
         }
 
         @Override
-        void close() {
-            justClose();
-            if (cleanupAction != null) {
-                cleanupAction.run();
+        MemoryScope confineTo(Thread newOwner) {
+            if (newOwner == owner) {
+                throw new IllegalArgumentException("Segment already owned by thread: " + newOwner);
             }
+            return super.confineTo(newOwner);
         }
 
-        @ForceInline
-        private void justClose() {
-            // enter critical section - no acquires are possible past this point
-            long stamp = lock.writeLock();
+        @Override
+        Thread ownerThread() {
+            return owner;
+        }
+    }
+
+    /**
+     * A shared scope, which can be shared across multiple threads. Closing a shared scope has to ensure that
+     * (i) only one thread can successfully close a scope (e.g. in a close vs. close race) and that
+     * (ii) no other thread is accessing the memory associated with this scope while the segment is being
+     * closed. To ensure the former condition, a CAS is performed on the liveness bit. Ensuring the latter
+     * is trickier, and require a complex synchronization protocol (see {@link jdk.internal.misc.ScopedMemoryAccess}).
+     * Since it is the responsibility of the closing thread to make sure that no concurrent access is possible,
+     * checking the liveness bit upon access can be performed in plain mode (see {@link #checkAliveRaw(MemoryScope)}),
+     * as in the confined case.
+     */
+    static class SharedScope extends MemoryScope {
+
+        static ScopedMemoryAccess SCOPED_MEMORY_ACCESS = ScopedMemoryAccess.getScopedMemoryAccess();
+
+        final static int ALIVE = 0;
+        final static int CLOSING = 1;
+        final static int CLOSED = 2;
+
+        int state = ALIVE;
+
+        private static final VarHandle STATE;
+
+        static {
             try {
-                checkValidState(); // plain read is enough here (full write lock)
-                // check for absence of active acquired children
-                if (acquired.sum() > 0) {
-                    throw new IllegalStateException("Cannot close this scope as it has active acquired children");
-                }
-                // now that we made sure there's no active acquired children, we can mark scope as closed
-                CLOSED.set(this, true); // plain write is enough here (full write lock)
-            } finally {
-                // leave critical section
-                lock.unlockWrite(stamp);
+                STATE = MethodHandles.lookup().findVarHandle(SharedScope.class, "state", int.class);
+            } catch (Throwable ex) {
+                throw new ExceptionInInitializerError(ex);
             }
         }
 
-        private final class Child extends MemoryScope {
+        SharedScope(Object ref, Runnable cleanupAction, Cleaner cleaner) {
+            super(ref, cleanupAction, cleaner);
+        }
 
-            private Child(Thread owner) {
-                super(owner);
-            }
+        @Override
+        Thread ownerThread() {
+            return null;
+        }
 
-            @Override
-            MemoryScope acquire() {
-                return Root.this.acquire();
+        @Override
+        public void checkValidState() {
+            if (state != ALIVE) {
+                throw ScopedAccessError.INSTANCE;
             }
+        }
 
-            @Override
-            MemoryScope dup(Thread newOwner) {
-                checkValidState(); // child scope is always checked
-                // pre-allocate duped scope so we don't get OOME later and be left with this scope closed
-                var duped = new Child(newOwner);
-                CLOSED.setVolatile(this, true);
-                return duped;
+        void justClose() {
+            if (!STATE.compareAndSet(this, ALIVE, CLOSING)) {
+                throw new IllegalStateException("Already closed");
             }
-
-            @Override
-            void close() {
-                checkValidState(); // child scope is always checked
-                CLOSED.set(this, true);
-                // following acts as a volatile write after plain write above so
-                // plain write gets flushed too (which is important for isAliveThreadSafe())
-                Root.this.acquired.decrement();
+            boolean success = SCOPED_MEMORY_ACCESS.closeScope(this);
+            STATE.setVolatile(this, success ? CLOSED : ALIVE);
+            if (!success) {
+                throw new IllegalStateException("Cannot close while another thread is accessing the segment");
             }
         }
+
+        @Override
+        public boolean isAlive() {
+            return (int)STATE.getVolatile(this) != CLOSED;
+        }
+    }
+
+    static class ScopeCleanable extends PhantomCleanable {
+        final Cleaner cleaner;
+        final Runnable cleanupAction;
+
+        public ScopeCleanable(MemoryScope referent, Cleaner cleaner, Runnable cleanupAction) {
+            super(referent, cleaner);
+            this.cleaner = cleaner;
+            this.cleanupAction = cleanupAction;
+        }
+
+        @Override
+        protected void performCleanup() {
+            cleanupAction.run();
+        }
     }
 }
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/NativeMemorySegmentImpl.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/NativeMemorySegmentImpl.java
index e650bbd188649..395f21f4d51bd 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/NativeMemorySegmentImpl.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/NativeMemorySegmentImpl.java
@@ -28,9 +28,8 @@
 
 import jdk.incubator.foreign.MemoryAddress;
 import jdk.incubator.foreign.MemorySegment;
-import jdk.internal.access.JavaNioAccess;
-import jdk.internal.access.SharedSecrets;
 import jdk.internal.misc.Unsafe;
+import jdk.internal.misc.VM;
 import jdk.internal.vm.annotation.ForceInline;
 import sun.security.action.GetBooleanAction;
 
@@ -42,11 +41,15 @@
  */
 public class NativeMemorySegmentImpl extends AbstractMemorySegmentImpl {
 
+    public static final MemorySegment EVERYTHING = makeNativeSegmentUnchecked(MemoryAddress.NULL, Long.MAX_VALUE, MemoryScope.DUMMY_CLEANUP_ACTION, null)
+            .share()
+            .withAccessModes(READ | WRITE);
+
     private static final Unsafe unsafe = Unsafe.getUnsafe();
 
     // The maximum alignment supported by malloc - typically 16 on
     // 64-bit platforms and 8 on 32-bit platforms.
-    private final static long MAX_ALIGN = Unsafe.ADDRESS_SIZE == 4 ? 8 : 16;
+    private final static long MAX_MALLOC_ALIGN = Unsafe.ADDRESS_SIZE == 4 ? 8 : 16;
 
     private static final boolean skipZeroMemory = GetBooleanAction.privilegedGetProperty("jdk.internal.foreign.skipZeroMemory");
 
@@ -65,7 +68,6 @@ NativeMemorySegmentImpl dup(long offset, long size, int mask, MemoryScope scope)
 
     @Override
     ByteBuffer makeByteBuffer() {
-        JavaNioAccess nioAccess = SharedSecrets.getJavaNioAccess();
         return nioAccess.newDirectByteBuffer(min(), (int) this.length, null, this);
     }
 
@@ -82,18 +84,24 @@ Object base() {
     // factories
 
     public static MemorySegment makeNativeSegment(long bytesSize, long alignmentBytes) {
-        long alignedSize = bytesSize;
-
-        if (alignmentBytes > MAX_ALIGN) {
-            alignedSize = bytesSize + (alignmentBytes - 1);
+        if (VM.isDirectMemoryPageAligned()) {
+            alignmentBytes = Math.max(alignmentBytes, nioAccess.pageSize());
         }
+        long alignedSize = alignmentBytes > MAX_MALLOC_ALIGN ?
+                bytesSize + (alignmentBytes - 1) :
+                bytesSize;
+
+        nioAccess.reserveMemory(alignedSize, bytesSize);
 
         long buf = unsafe.allocateMemory(alignedSize);
         if (!skipZeroMemory) {
             unsafe.setMemory(buf, alignedSize, (byte)0);
         }
         long alignedBuf = Utils.alignUp(buf, alignmentBytes);
-        MemoryScope scope = MemoryScope.create(null, () -> unsafe.freeMemory(buf));
+        MemoryScope scope = MemoryScope.createConfined(null, () -> {
+                unsafe.freeMemory(buf);
+                nioAccess.unreserveMemory(alignedSize, bytesSize);
+            }, null);
         MemorySegment segment = new NativeMemorySegmentImpl(buf, alignedSize,
                 defaultAccessModes(alignedSize), scope);
         if (alignedSize != bytesSize) {
@@ -103,8 +111,8 @@ public static MemorySegment makeNativeSegment(long bytesSize, long alignmentByte
         return segment;
     }
 
-    public static MemorySegment makeNativeSegmentUnchecked(MemoryAddress min, long bytesSize, Thread owner, Runnable cleanup, Object attachment) {
-        MemoryScope scope = MemoryScope.createUnchecked(owner, attachment, cleanup);
-        return new NativeMemorySegmentImpl(min.toRawLongValue(), bytesSize, defaultAccessModes(bytesSize), scope);
+    public static MemorySegment makeNativeSegmentUnchecked(MemoryAddress min, long bytesSize, Runnable cleanupAction, Object ref) {
+        return new NativeMemorySegmentImpl(min.toRawLongValue(), bytesSize, defaultAccessModes(bytesSize),
+                MemoryScope.createConfined(ref, cleanupAction == null ? MemoryScope.DUMMY_CLEANUP_ACTION : cleanupAction, null));
     }
 }
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/Utils.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/Utils.java
index 8ddbb4cca03f0..dbb8086414202 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/Utils.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/Utils.java
@@ -28,7 +28,8 @@
 
 import jdk.incubator.foreign.MemoryAddress;
 import jdk.incubator.foreign.MemoryHandles;
-import jdk.internal.access.foreign.MemoryAddressProxy;
+import jdk.incubator.foreign.MemorySegment;
+import jdk.internal.access.foreign.MemorySegmentProxy;
 import jdk.internal.misc.VM;
 
 import java.lang.invoke.MethodHandle;
@@ -50,8 +51,8 @@ public final class Utils {
 
     static {
         try {
-            ADDRESS_FILTER = MethodHandles.lookup().findStatic(Utils.class, "filterAddress",
-                    MethodType.methodType(MemoryAddressProxy.class, MemoryAddress.class));
+            ADDRESS_FILTER = MethodHandles.lookup().findStatic(Utils.class, "filterSegment",
+                    MethodType.methodType(MemorySegmentProxy.class, MemorySegment.class));
         } catch (Throwable ex) {
             throw new ExceptionInInitializerError(ex);
         }
@@ -75,8 +76,8 @@ public static VarHandle fixUpVarHandle(VarHandle handle) {
         return MemoryHandles.filterCoordinates(handle, 0, ADDRESS_FILTER);
     }
 
-    private static MemoryAddressProxy filterAddress(MemoryAddress addr) {
-        return (MemoryAddressImpl)addr;
+    private static MemorySegmentProxy filterSegment(MemorySegment segment) {
+        return (AbstractMemorySegmentImpl)segment;
     }
 
     public static void checkRestrictedAccess(String method) {
diff --git a/test/jdk/java/foreign/TestAdaptVarHandles.java b/test/jdk/java/foreign/TestAdaptVarHandles.java
index 0ab4adf4656ce..709aef3fc8836 100644
--- a/test/jdk/java/foreign/TestAdaptVarHandles.java
+++ b/test/jdk/java/foreign/TestAdaptVarHandles.java
@@ -33,6 +33,7 @@
 
 import jdk.incubator.foreign.MemoryAddress;
 import jdk.incubator.foreign.MemoryHandles;
+import jdk.incubator.foreign.MemoryLayout;
 import jdk.incubator.foreign.MemoryLayouts;
 import jdk.incubator.foreign.MemorySegment;
 import jdk.incubator.foreign.ValueLayout;
@@ -70,7 +71,7 @@ public class TestAdaptVarHandles {
             I2O = MethodHandles.explicitCastArguments(I2S, MethodType.methodType(Object.class, int.class));
             S2L = MethodHandles.lookup().findStatic(TestAdaptVarHandles.class, "stringToLong", MethodType.methodType(long.class, String.class));
             S2L_EX = MethodHandles.lookup().findStatic(TestAdaptVarHandles.class, "stringToLongException", MethodType.methodType(long.class, String.class));
-            BASE_ADDR = MethodHandles.lookup().findStatic(TestAdaptVarHandles.class, "baseAddress", MethodType.methodType(MemoryAddress.class, MemorySegment.class));
+            BASE_ADDR = MethodHandles.lookup().findStatic(TestAdaptVarHandles.class, "baseAddress", MethodType.methodType(MemorySegment.class, MemorySegment.class));
             SUM_OFFSETS = MethodHandles.lookup().findStatic(TestAdaptVarHandles.class, "sumOffsets", MethodType.methodType(long.class, long.class, long.class));
             VOID_FILTER = MethodHandles.lookup().findStatic(TestAdaptVarHandles.class, "void_filter", MethodType.methodType(void.class, String.class));
 
@@ -86,22 +87,29 @@ public class TestAdaptVarHandles {
         }
     }
 
+    static final VarHandle intHandleIndexed = MemoryLayout.ofSequence(MemoryLayouts.JAVA_INT)
+            .varHandle(int.class, MemoryLayout.PathElement.sequenceElement());
+
+    static final VarHandle intHandle = MemoryLayouts.JAVA_INT.varHandle(int.class);
+
+    static final VarHandle floatHandle = MemoryLayouts.JAVA_FLOAT.varHandle(float.class);
+
     @Test
     public void testFilterValue() throws Throwable {
         ValueLayout layout = MemoryLayouts.JAVA_INT;
         MemorySegment segment = MemorySegment.allocateNative(layout);
         VarHandle intHandle = layout.varHandle(int.class);
         VarHandle i2SHandle = MemoryHandles.filterValue(intHandle, S2I, I2S);
-        i2SHandle.set(segment.baseAddress(), "1");
-        String oldValue = (String)i2SHandle.getAndAdd(segment.baseAddress(), "42");
+        i2SHandle.set(segment, "1");
+        String oldValue = (String)i2SHandle.getAndAdd(segment, "42");
         assertEquals(oldValue, "1");
-        String value = (String)i2SHandle.get(segment.baseAddress());
+        String value = (String)i2SHandle.get(segment);
         assertEquals(value, "43");
-        boolean swapped = (boolean)i2SHandle.compareAndSet(segment.baseAddress(), "43", "12");
+        boolean swapped = (boolean)i2SHandle.compareAndSet(segment, "43", "12");
         assertTrue(swapped);
-        oldValue = (String)i2SHandle.compareAndExchange(segment.baseAddress(), "12", "42");
+        oldValue = (String)i2SHandle.compareAndExchange(segment, "12", "42");
         assertEquals(oldValue, "12");
-        value = (String)i2SHandle.toMethodHandle(VarHandle.AccessMode.GET).invokeExact(segment.baseAddress());
+        value = (String)i2SHandle.toMethodHandle(VarHandle.AccessMode.GET).invokeExact(segment);
         assertEquals(value, "42");
     }
 
@@ -113,16 +121,16 @@ public void testFilterValueComposite() throws Throwable {
         MethodHandle CTX_S2I = MethodHandles.dropArguments(S2I, 0, String.class, String.class);
         VarHandle i2SHandle = MemoryHandles.filterValue(intHandle, CTX_S2I, CTX_I2S);
         i2SHandle = MemoryHandles.insertCoordinates(i2SHandle, 1, "a", "b");
-        i2SHandle.set(segment.baseAddress(), "1");
-        String oldValue = (String)i2SHandle.getAndAdd(segment.baseAddress(), "42");
+        i2SHandle.set(segment, "1");
+        String oldValue = (String)i2SHandle.getAndAdd(segment, "42");
         assertEquals(oldValue, "ab1");
-        String value = (String)i2SHandle.get(segment.baseAddress());
+        String value = (String)i2SHandle.get(segment);
         assertEquals(value, "ab43");
-        boolean swapped = (boolean)i2SHandle.compareAndSet(segment.baseAddress(), "43", "12");
+        boolean swapped = (boolean)i2SHandle.compareAndSet(segment, "43", "12");
         assertTrue(swapped);
-        oldValue = (String)i2SHandle.compareAndExchange(segment.baseAddress(), "12", "42");
+        oldValue = (String)i2SHandle.compareAndExchange(segment, "12", "42");
         assertEquals(oldValue, "ab12");
-        value = (String)i2SHandle.toMethodHandle(VarHandle.AccessMode.GET).invokeExact(segment.baseAddress());
+        value = (String)i2SHandle.toMethodHandle(VarHandle.AccessMode.GET).invokeExact(segment);
         assertEquals(value, "ab42");
     }
 
@@ -132,16 +140,16 @@ public void testFilterValueLoose() throws Throwable {
         MemorySegment segment = MemorySegment.allocateNative(layout);
         VarHandle intHandle = layout.varHandle(int.class);
         VarHandle i2SHandle = MemoryHandles.filterValue(intHandle, O2I, I2O);
-        i2SHandle.set(segment.baseAddress(), "1");
-        String oldValue = (String)i2SHandle.getAndAdd(segment.baseAddress(), "42");
+        i2SHandle.set(segment, "1");
+        String oldValue = (String)i2SHandle.getAndAdd(segment, "42");
         assertEquals(oldValue, "1");
-        String value = (String)i2SHandle.get(segment.baseAddress());
+        String value = (String)i2SHandle.get(segment);
         assertEquals(value, "43");
-        boolean swapped = (boolean)i2SHandle.compareAndSet(segment.baseAddress(), "43", "12");
+        boolean swapped = (boolean)i2SHandle.compareAndSet(segment, "43", "12");
         assertTrue(swapped);
-        oldValue = (String)i2SHandle.compareAndExchange(segment.baseAddress(), "12", "42");
+        oldValue = (String)i2SHandle.compareAndExchange(segment, "12", "42");
         assertEquals(oldValue, "12");
-        value = (String)(Object)i2SHandle.toMethodHandle(VarHandle.AccessMode.GET).invokeExact(segment.baseAddress());
+        value = (String)(Object)i2SHandle.toMethodHandle(VarHandle.AccessMode.GET).invokeExact(segment);
         assertEquals(value, "42");
     }
 
@@ -152,19 +160,16 @@ public void testBadFilterNullTarget() {
 
     @Test(expectedExceptions = NullPointerException.class)
     public void testBadFilterNullUnbox() {
-        VarHandle intHandle = MemoryLayouts.JAVA_INT.varHandle(int.class);
         MemoryHandles.filterValue(intHandle, null, I2S);
     }
 
     @Test(expectedExceptions = NullPointerException.class)
     public void testBadFilterNullBox() {
-        VarHandle intHandle = MemoryLayouts.JAVA_INT.varHandle(int.class);
         MemoryHandles.filterValue(intHandle, S2I, null);
     }
 
     @Test(expectedExceptions = IllegalArgumentException.class)
     public void testBadFilterCarrier() {
-        VarHandle floatHandle = MemoryLayouts.JAVA_FLOAT.varHandle(float.class);
         MemoryHandles.filterValue(floatHandle, S2I, I2S);
     }
 
@@ -216,8 +221,7 @@ public void testBadFilterUnboxHandleException() {
     public void testFilterCoordinates() throws Throwable {
         ValueLayout layout = MemoryLayouts.JAVA_INT;
         MemorySegment segment = MemorySegment.allocateNative(layout);
-        VarHandle intHandle = MemoryHandles.withStride(layout.varHandle(int.class), 4);
-        VarHandle intHandle_longIndex = MemoryHandles.filterCoordinates(intHandle, 0, BASE_ADDR, S2L);
+        VarHandle intHandle_longIndex = MemoryHandles.filterCoordinates(intHandleIndexed, 0, BASE_ADDR, S2L);
         intHandle_longIndex.set(segment, "0", 1);
         int oldValue = (int)intHandle_longIndex.getAndAdd(segment, "0", 42);
         assertEquals(oldValue, 1);
@@ -238,46 +242,39 @@ public void testBadFilterCoordinatesNullTarget() {
 
     @Test(expectedExceptions = NullPointerException.class)
     public void testBadFilterCoordinatesNullFilters() {
-        VarHandle intHandle = MemoryLayouts.JAVA_INT.varHandle(int.class);
         MemoryHandles.filterCoordinates(intHandle, 0, null);
     }
 
     @Test(expectedExceptions = IllegalArgumentException.class)
     public void testBadFilterCoordinatesNegativePos() {
-        VarHandle intHandle = MemoryLayouts.JAVA_INT.varHandle(int.class);
         MemoryHandles.filterCoordinates(intHandle, -1, SUM_OFFSETS);
     }
 
     @Test(expectedExceptions = IllegalArgumentException.class)
     public void testBadFilterCoordinatesPosTooBig() {
-        VarHandle intHandle = MemoryLayouts.JAVA_INT.varHandle(int.class);
         MemoryHandles.filterCoordinates(intHandle, 1, SUM_OFFSETS);
     }
 
     @Test(expectedExceptions = IllegalArgumentException.class)
     public void testBadFilterCoordinatesWrongFilterType() {
-        VarHandle intHandle = MemoryHandles.withStride(MemoryLayouts.JAVA_INT.varHandle(int.class), 4);
-        MemoryHandles.filterCoordinates(intHandle, 1, S2I);
+        MemoryHandles.filterCoordinates(intHandleIndexed, 1, S2I);
     }
 
     @Test(expectedExceptions = IllegalArgumentException.class)
     public void testBadFilterCoordinatesWrongFilterException() {
-        VarHandle intHandle = MemoryHandles.withStride(MemoryLayouts.JAVA_INT.varHandle(int.class), 4);
-        MemoryHandles.filterCoordinates(intHandle, 1, S2L_EX);
+        MemoryHandles.filterCoordinates(intHandleIndexed, 1, S2L_EX);
     }
 
     @Test(expectedExceptions = IllegalArgumentException.class)
     public void testBadFilterCoordinatesTooManyFilters() {
-        VarHandle intHandle = MemoryHandles.withStride(MemoryLayouts.JAVA_INT.varHandle(int.class), 4);
-        MemoryHandles.filterCoordinates(intHandle, 1, S2L, S2L);
+        MemoryHandles.filterCoordinates(intHandleIndexed, 1, S2L, S2L);
     }
 
     @Test
     public void testInsertCoordinates() throws Throwable {
         ValueLayout layout = MemoryLayouts.JAVA_INT;
         MemorySegment segment = MemorySegment.allocateNative(layout);
-        VarHandle intHandle = MemoryHandles.withStride(layout.varHandle(int.class), 4);
-        VarHandle intHandle_longIndex = MemoryHandles.insertCoordinates(intHandle, 0, segment.baseAddress(), 0L);
+        VarHandle intHandle_longIndex = MemoryHandles.insertCoordinates(intHandleIndexed, 0, segment, 0L);
         intHandle_longIndex.set(1);
         int oldValue = (int)intHandle_longIndex.getAndAdd(42);
         assertEquals(oldValue, 1);
@@ -298,51 +295,45 @@ public void testBadInsertCoordinatesNullTarget() {
 
     @Test(expectedExceptions = NullPointerException.class)
     public void testBadInsertCoordinatesNullValues() {
-        VarHandle intHandle = MemoryLayouts.JAVA_INT.varHandle(int.class);
         MemoryHandles.insertCoordinates(intHandle, 0, null);
     }
 
     @Test(expectedExceptions = IllegalArgumentException.class)
     public void testBadInsertCoordinatesNegativePos() {
-        VarHandle intHandle = MemoryLayouts.JAVA_INT.varHandle(int.class);
         MemoryHandles.insertCoordinates(intHandle, -1, 42);
     }
 
     @Test(expectedExceptions = IllegalArgumentException.class)
     public void testBadInsertCoordinatesPosTooBig() {
-        VarHandle intHandle = MemoryLayouts.JAVA_INT.varHandle(int.class);
         MemoryHandles.insertCoordinates(intHandle, 1, 42);
     }
 
     @Test(expectedExceptions = ClassCastException.class)
     public void testBadInsertCoordinatesWrongCoordinateType() {
-        VarHandle intHandle = MemoryHandles.withStride(MemoryLayouts.JAVA_INT.varHandle(int.class), 4);
-        MemoryHandles.insertCoordinates(intHandle, 1, "Hello");
+        MemoryHandles.insertCoordinates(intHandleIndexed, 1, "Hello");
     }
 
     @Test(expectedExceptions = IllegalArgumentException.class)
     public void testBadInsertCoordinatesTooManyValues() {
-        VarHandle intHandle = MemoryHandles.withStride(MemoryLayouts.JAVA_INT.varHandle(int.class), 4);
-        MemoryHandles.insertCoordinates(intHandle, 1, 0L, 0L);
+        MemoryHandles.insertCoordinates(intHandleIndexed, 1, 0L, 0L);
     }
 
     @Test
     public void testPermuteCoordinates() throws Throwable {
         ValueLayout layout = MemoryLayouts.JAVA_INT;
         MemorySegment segment = MemorySegment.allocateNative(layout);
-        VarHandle intHandle = MemoryHandles.withStride(layout.varHandle(int.class), 4);
-        VarHandle intHandle_swap = MemoryHandles.permuteCoordinates(intHandle,
-                List.of(long.class, MemoryAddress.class), 1, 0);
-        intHandle_swap.set(0L, segment.baseAddress(), 1);
-        int oldValue = (int)intHandle_swap.getAndAdd(0L, segment.baseAddress(), 42);
+        VarHandle intHandle_swap = MemoryHandles.permuteCoordinates(intHandleIndexed,
+                List.of(long.class, MemorySegment.class), 1, 0);
+        intHandle_swap.set(0L, segment, 1);
+        int oldValue = (int)intHandle_swap.getAndAdd(0L, segment, 42);
         assertEquals(oldValue, 1);
-        int value = (int)intHandle_swap.get(0L, segment.baseAddress());
+        int value = (int)intHandle_swap.get(0L, segment);
         assertEquals(value, 43);
-        boolean swapped = (boolean)intHandle_swap.compareAndSet(0L, segment.baseAddress(), 43, 12);
+        boolean swapped = (boolean)intHandle_swap.compareAndSet(0L, segment, 43, 12);
         assertTrue(swapped);
-        oldValue = (int)intHandle_swap.compareAndExchange(0L, segment.baseAddress(), 12, 42);
+        oldValue = (int)intHandle_swap.compareAndExchange(0L, segment, 12, 42);
         assertEquals(oldValue, 12);
-        value = (int)intHandle_swap.toMethodHandle(VarHandle.AccessMode.GET).invokeExact(0L, segment.baseAddress());
+        value = (int)intHandle_swap.toMethodHandle(VarHandle.AccessMode.GET).invokeExact(0L, segment);
         assertEquals(value, 42);
     }
 
@@ -353,37 +344,31 @@ public void testBadPermuteCoordinatesNullTarget() {
 
     @Test(expectedExceptions = NullPointerException.class)
     public void testBadPermuteCoordinatesNullCoordinates() {
-        VarHandle intHandle = MemoryLayouts.JAVA_INT.varHandle(int.class);
         MemoryHandles.permuteCoordinates(intHandle, null);
     }
 
     @Test(expectedExceptions = NullPointerException.class)
     public void testBadPermuteCoordinatesNullReorder() {
-        VarHandle intHandle = MemoryLayouts.JAVA_INT.varHandle(int.class);
         MemoryHandles.permuteCoordinates(intHandle, List.of(int.class), null);
     }
 
     @Test(expectedExceptions = IllegalArgumentException.class)
     public void testBadPermuteCoordinatesTooManyCoordinates() {
-        VarHandle intHandle = MemoryLayouts.JAVA_INT.varHandle(int.class);
         MemoryHandles.permuteCoordinates(intHandle, List.of(int.class, int.class), new int[2]);
     }
 
     @Test(expectedExceptions = IllegalArgumentException.class)
     public void testBadPermuteCoordinatesTooFewCoordinates() {
-        VarHandle intHandle = MemoryLayouts.JAVA_INT.varHandle(int.class);
         MemoryHandles.permuteCoordinates(intHandle, List.of());
     }
 
     @Test(expectedExceptions = IllegalArgumentException.class)
     public void testBadPermuteCoordinatesIndexTooBig() {
-        VarHandle intHandle = MemoryLayouts.JAVA_INT.varHandle(int.class);
         MemoryHandles.permuteCoordinates(intHandle, List.of(int.class, int.class), 3);
     }
 
     @Test(expectedExceptions = IllegalArgumentException.class)
     public void testBadPermuteCoordinatesIndexTooSmall() {
-        VarHandle intHandle = MemoryLayouts.JAVA_INT.varHandle(int.class);
         MemoryHandles.permuteCoordinates(intHandle, List.of(int.class, int.class), -1);
     }
 
@@ -391,18 +376,17 @@ public void testBadPermuteCoordinatesIndexTooSmall() {
     public void testCollectCoordinates() throws Throwable {
         ValueLayout layout = MemoryLayouts.JAVA_INT;
         MemorySegment segment = MemorySegment.allocateNative(layout);
-        VarHandle intHandle = MemoryHandles.withStride(layout.varHandle(int.class), 4);
-        VarHandle intHandle_sum = MemoryHandles.collectCoordinates(intHandle, 1, SUM_OFFSETS);
-        intHandle_sum.set(segment.baseAddress(), -2L, 2L, 1);
-        int oldValue = (int)intHandle_sum.getAndAdd(segment.baseAddress(), -2L, 2L, 42);
+        VarHandle intHandle_sum = MemoryHandles.collectCoordinates(intHandleIndexed, 1, SUM_OFFSETS);
+        intHandle_sum.set(segment, -2L, 2L, 1);
+        int oldValue = (int)intHandle_sum.getAndAdd(segment, -2L, 2L, 42);
         assertEquals(oldValue, 1);
-        int value = (int)intHandle_sum.get(segment.baseAddress(), -2L, 2L);
+        int value = (int)intHandle_sum.get(segment, -2L, 2L);
         assertEquals(value, 43);
-        boolean swapped = (boolean)intHandle_sum.compareAndSet(segment.baseAddress(), -2L, 2L, 43, 12);
+        boolean swapped = (boolean)intHandle_sum.compareAndSet(segment, -2L, 2L, 43, 12);
         assertTrue(swapped);
-        oldValue = (int)intHandle_sum.compareAndExchange(segment.baseAddress(), -2L, 2L, 12, 42);
+        oldValue = (int)intHandle_sum.compareAndExchange(segment, -2L, 2L, 12, 42);
         assertEquals(oldValue, 12);
-        value = (int)intHandle_sum.toMethodHandle(VarHandle.AccessMode.GET).invokeExact(segment.baseAddress(), -2L, 2L);
+        value = (int)intHandle_sum.toMethodHandle(VarHandle.AccessMode.GET).invokeExact(segment, -2L, 2L);
         assertEquals(value, 42);
     }
 
@@ -413,37 +397,31 @@ public void testBadCollectCoordinatesNullTarget() {
 
     @Test(expectedExceptions = NullPointerException.class)
     public void testBadCollectCoordinatesNullFilters() {
-        VarHandle intHandle = MemoryLayouts.JAVA_INT.varHandle(int.class);
         MemoryHandles.collectCoordinates(intHandle, 0, null);
     }
 
     @Test(expectedExceptions = IllegalArgumentException.class)
     public void testBadCollectCoordinatesNegativePos() {
-        VarHandle intHandle = MemoryLayouts.JAVA_INT.varHandle(int.class);
         MemoryHandles.collectCoordinates(intHandle, -1, SUM_OFFSETS);
     }
 
     @Test(expectedExceptions = IllegalArgumentException.class)
     public void testBadCollectCoordinatesPosTooBig() {
-        VarHandle intHandle = MemoryLayouts.JAVA_INT.varHandle(int.class);
         MemoryHandles.collectCoordinates(intHandle, 1, SUM_OFFSETS);
     }
 
     @Test(expectedExceptions = IllegalArgumentException.class)
     public void testBadCollectCoordinatesWrongFilterType() {
-        VarHandle intHandle = MemoryLayouts.JAVA_INT.varHandle(int.class);
         MemoryHandles.collectCoordinates(intHandle, 0, SUM_OFFSETS);
     }
 
     @Test(expectedExceptions = IllegalArgumentException.class)
     public void testBadCollectCoordinatesWrongVoidFilterType() {
-        VarHandle intHandle = MemoryLayouts.JAVA_INT.varHandle(int.class);
         MemoryHandles.collectCoordinates(intHandle, 0, VOID_FILTER);
     }
 
     @Test(expectedExceptions = IllegalArgumentException.class)
     public void testBadCollectCoordinatesWrongFilterException() {
-        VarHandle intHandle = MemoryLayouts.JAVA_INT.varHandle(int.class);
         MemoryHandles.collectCoordinates(intHandle, 0, S2L_EX);
     }
 
@@ -451,36 +429,32 @@ public void testBadCollectCoordinatesWrongFilterException() {
     public void testDropCoordinates() throws Throwable {
         ValueLayout layout = MemoryLayouts.JAVA_INT;
         MemorySegment segment = MemorySegment.allocateNative(layout);
-        VarHandle intHandle = MemoryHandles.withStride(layout.varHandle(int.class), 4);
-        VarHandle intHandle_dummy = MemoryHandles.dropCoordinates(intHandle, 1, float.class, String.class);
-        intHandle_dummy.set(segment.baseAddress(), 1f, "hello", 0L, 1);
-        int oldValue = (int)intHandle_dummy.getAndAdd(segment.baseAddress(), 1f, "hello", 0L, 42);
+        VarHandle intHandle_dummy = MemoryHandles.dropCoordinates(intHandleIndexed, 1, float.class, String.class);
+        intHandle_dummy.set(segment, 1f, "hello", 0L, 1);
+        int oldValue = (int)intHandle_dummy.getAndAdd(segment, 1f, "hello", 0L, 42);
         assertEquals(oldValue, 1);
-        int value = (int)intHandle_dummy.get(segment.baseAddress(), 1f, "hello", 0L);
+        int value = (int)intHandle_dummy.get(segment, 1f, "hello", 0L);
         assertEquals(value, 43);
-        boolean swapped = (boolean)intHandle_dummy.compareAndSet(segment.baseAddress(), 1f, "hello", 0L, 43, 12);
+        boolean swapped = (boolean)intHandle_dummy.compareAndSet(segment, 1f, "hello", 0L, 43, 12);
         assertTrue(swapped);
-        oldValue = (int)intHandle_dummy.compareAndExchange(segment.baseAddress(), 1f, "hello", 0L, 12, 42);
+        oldValue = (int)intHandle_dummy.compareAndExchange(segment, 1f, "hello", 0L, 12, 42);
         assertEquals(oldValue, 12);
-        value = (int)intHandle_dummy.toMethodHandle(VarHandle.AccessMode.GET).invokeExact(segment.baseAddress(), 1f, "hello", 0L);
+        value = (int)intHandle_dummy.toMethodHandle(VarHandle.AccessMode.GET).invokeExact(segment, 1f, "hello", 0L);
         assertEquals(value, 42);
     }
 
     @Test(expectedExceptions = IllegalArgumentException.class)
     public void testBadDropCoordinatesNegativePos() {
-        VarHandle intHandle = MemoryLayouts.JAVA_INT.varHandle(int.class);
         MemoryHandles.dropCoordinates(intHandle, -1);
     }
 
     @Test(expectedExceptions = IllegalArgumentException.class)
     public void testBadDropCoordinatesPosTooBig() {
-        VarHandle intHandle = MemoryLayouts.JAVA_INT.varHandle(int.class);
         MemoryHandles.dropCoordinates(intHandle, 2);
     }
 
     @Test(expectedExceptions = NullPointerException.class)
     public void testBadDropCoordinatesNullValueTypes() {
-        VarHandle intHandle = MemoryLayouts.JAVA_INT.varHandle(int.class);
         MemoryHandles.dropCoordinates(intHandle, 1, null);
     }
 
@@ -507,8 +481,8 @@ static long stringToLongException(String s) throws Throwable {
         return Long.valueOf(s);
     }
 
-    static MemoryAddress baseAddress(MemorySegment segment) {
-        return segment.baseAddress();
+    static MemorySegment baseAddress(MemorySegment segment) {
+        return segment;
     }
 
     static long sumOffsets(long l1, long l2) {
diff --git a/test/jdk/java/foreign/TestAddressHandle.java b/test/jdk/java/foreign/TestAddressHandle.java
index ca97946391572..13abca5420a4c 100644
--- a/test/jdk/java/foreign/TestAddressHandle.java
+++ b/test/jdk/java/foreign/TestAddressHandle.java
@@ -61,58 +61,52 @@ public class TestAddressHandle {
 
     @Test(dataProvider = "addressHandles")
     public void testAddressHandle(VarHandle addrHandle, int byteSize) {
-        VarHandle longHandle = MemoryHandles.varHandle(long.class, ByteOrder.nativeOrder());
+        VarHandle longHandle = MemoryLayouts.JAVA_LONG.varHandle(long.class);
         try (MemorySegment segment = MemorySegment.allocateNative(8)) {
-            MemoryAddress target = ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN ?
-                    segment.baseAddress().addOffset(8 - byteSize) :
-                    segment.baseAddress();
-            longHandle.set(segment.baseAddress(), 42L);
+            MemorySegment target = ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN ?
+                    segment.asSlice(8 - byteSize) :
+                    segment;
+            longHandle.set(segment, 42L);
             MemoryAddress address = (MemoryAddress)addrHandle.get(target);
             assertEquals(address.toRawLongValue(), 42L);
-            try {
-                longHandle.get(address); // check that address cannot be de-referenced
-                fail();
-            } catch (UnsupportedOperationException ex) {
-                assertTrue(true);
-            }
             addrHandle.set(target, address.addOffset(1));
-            long result = (long)longHandle.get(segment.baseAddress());
+            long result = (long)longHandle.get(segment);
             assertEquals(43L, result);
         }
     }
 
     @Test(dataProvider = "addressHandles")
     public void testNull(VarHandle addrHandle, int byteSize) {
-        VarHandle longHandle = MemoryHandles.varHandle(long.class, ByteOrder.nativeOrder());
+        VarHandle longHandle = MemoryLayouts.JAVA_LONG.varHandle(long.class);
         try (MemorySegment segment = MemorySegment.allocateNative(8)) {
-            longHandle.set(segment.baseAddress(), 0L);
-            MemoryAddress address = (MemoryAddress)addrHandle.get(segment.baseAddress());
+            longHandle.set(segment, 0L);
+            MemoryAddress address = (MemoryAddress)addrHandle.get(segment);
             assertTrue(address == MemoryAddress.NULL);
         }
     }
 
     @Test(expectedExceptions = IllegalArgumentException.class)
     public void testBadAdaptFloat() {
-        VarHandle floatHandle = MemoryHandles.varHandle(float.class, ByteOrder.nativeOrder());
+        VarHandle floatHandle = MemoryLayouts.JAVA_FLOAT.varHandle(float.class);
         MemoryHandles.asAddressVarHandle(floatHandle);
     }
 
     @Test(expectedExceptions = IllegalArgumentException.class)
     public void testBadAdaptDouble() {
-        VarHandle doubleHandle = MemoryHandles.varHandle(double.class, ByteOrder.nativeOrder());
+        VarHandle doubleHandle = MemoryLayouts.JAVA_DOUBLE.varHandle(double.class);
         MemoryHandles.asAddressVarHandle(doubleHandle);
     }
 
     @Test(expectedExceptions = IllegalArgumentException.class)
     public void testBadAdaptBoolean() {
-        VarHandle intHandle = MemoryHandles.varHandle(int.class, ByteOrder.nativeOrder());
+        VarHandle intHandle = MemoryLayouts.JAVA_INT.varHandle(int.class);
         VarHandle boolHandle = MemoryHandles.filterValue(intHandle, BOOL_TO_INT, INT_TO_BOOL);
         MemoryHandles.asAddressVarHandle(boolHandle);
     }
 
     @Test(expectedExceptions = IllegalArgumentException.class)
     public void testBadAdaptString() {
-        VarHandle intHandle = MemoryHandles.varHandle(int.class, ByteOrder.nativeOrder());
+        VarHandle intHandle = MemoryLayouts.JAVA_INT.varHandle(int.class);
         VarHandle stringHandle = MemoryHandles.filterValue(intHandle, STRING_TO_INT, INT_TO_STRING);
         MemoryHandles.asAddressVarHandle(stringHandle);
     }
@@ -121,32 +115,31 @@ public void testBadAdaptString() {
     static Object[][] addressHandles() {
         return new Object[][] {
                 // long
-                { MemoryHandles.asAddressVarHandle(MemoryHandles.varHandle(long.class, ByteOrder.nativeOrder())), 8 },
-                { MemoryHandles.asAddressVarHandle(MemoryHandles.withOffset(MemoryHandles.varHandle(long.class, ByteOrder.nativeOrder()), 0)), 8 },
+                { MemoryHandles.asAddressVarHandle(at(MemoryHandles.varHandle(long.class, ByteOrder.nativeOrder()), 0)), 8 },
                 { MemoryHandles.asAddressVarHandle(MemoryLayouts.JAVA_LONG.varHandle(long.class)), 8 },
 
                 // int
-                { MemoryHandles.asAddressVarHandle(MemoryHandles.varHandle(int.class, ByteOrder.nativeOrder())), 4 },
-                { MemoryHandles.asAddressVarHandle(MemoryHandles.withOffset(MemoryHandles.varHandle(int.class, ByteOrder.nativeOrder()), 0)), 4 },
+                { MemoryHandles.asAddressVarHandle(at(MemoryHandles.varHandle(int.class, ByteOrder.nativeOrder()), 0)), 4 },
                 { MemoryHandles.asAddressVarHandle(MemoryLayouts.JAVA_INT.varHandle(int.class)), 4 },
 
                 // short
-                { MemoryHandles.asAddressVarHandle(MemoryHandles.varHandle(short.class, ByteOrder.nativeOrder())), 2 },
-                { MemoryHandles.asAddressVarHandle(MemoryHandles.withOffset(MemoryHandles.varHandle(short.class, ByteOrder.nativeOrder()), 0)), 2 },
+                { MemoryHandles.asAddressVarHandle(at(MemoryHandles.varHandle(short.class, ByteOrder.nativeOrder()), 0)), 2 },
                 { MemoryHandles.asAddressVarHandle(MemoryLayouts.JAVA_SHORT.varHandle(short.class)), 2 },
 
                 // char
-                { MemoryHandles.asAddressVarHandle(MemoryHandles.varHandle(char.class, ByteOrder.nativeOrder())), 2 },
-                { MemoryHandles.asAddressVarHandle(MemoryHandles.withOffset(MemoryHandles.varHandle(char.class, ByteOrder.nativeOrder()), 0)), 2 },
+                { MemoryHandles.asAddressVarHandle(at(MemoryHandles.varHandle(char.class, ByteOrder.nativeOrder()), 0)), 2 },
                 { MemoryHandles.asAddressVarHandle(MemoryLayouts.JAVA_CHAR.varHandle(char.class)), 2 },
 
                 // byte
-                { MemoryHandles.asAddressVarHandle(MemoryHandles.varHandle(byte.class, ByteOrder.nativeOrder())), 1 },
-                { MemoryHandles.asAddressVarHandle(MemoryHandles.withOffset(MemoryHandles.varHandle(byte.class, ByteOrder.nativeOrder()), 0)), 1 },
+                { MemoryHandles.asAddressVarHandle(at(MemoryHandles.varHandle(byte.class, ByteOrder.nativeOrder()), 0)), 1 },
                 { MemoryHandles.asAddressVarHandle(MemoryLayouts.JAVA_BYTE.varHandle(byte.class)), 1 }
         };
     }
 
+    static VarHandle at(VarHandle handle, long offset) {
+        return MemoryHandles.insertCoordinates(handle, 1, offset);
+    }
+
     static int boolToInt(boolean value) {
         return value ? 1 : 0;
     }
diff --git a/test/jdk/java/foreign/TestArrays.java b/test/jdk/java/foreign/TestArrays.java
index 2a5d597b858a5..b8be313ba4d4c 100644
--- a/test/jdk/java/foreign/TestArrays.java
+++ b/test/jdk/java/foreign/TestArrays.java
@@ -36,7 +36,9 @@
 
 import java.lang.invoke.VarHandle;
 import java.util.function.BiConsumer;
+import java.util.function.BiFunction;
 import java.util.function.Consumer;
+import java.util.function.Function;
 
 import org.testng.annotations.*;
 
@@ -81,83 +83,126 @@ public class TestArrays {
     static VarHandle longHandle = longs.varHandle(long.class, PathElement.sequenceElement());
     static VarHandle doubleHandle = doubles.varHandle(double.class, PathElement.sequenceElement());
 
-    static void initBytes(MemoryAddress base, SequenceLayout seq, BiConsumer handleSetter) {
+    static void initBytes(MemorySegment base, SequenceLayout seq, BiConsumer handleSetter) {
         for (long i = 0; i < seq.elementCount().getAsLong() ; i++) {
             handleSetter.accept(base, i);
         }
     }
 
-    static void checkBytes(MemoryAddress base, SequenceLayout layout) {
-        long nBytes = layout.elementCount().getAsLong() * layout.elementLayout().byteSize();
-        byte[] arr = base.segment().toByteArray();
-        for (long i = 0 ; i < nBytes ; i++) {
-            byte expected = (byte)byteHandle.get(base, i);
-            byte found = arr[(int)i];
+    static void checkBytes(MemorySegment base, SequenceLayout layout, Function arrayFactory, BiFunction handleGetter) {
+        int nelems = (int)layout.elementCount().getAsLong();
+        Object arr = arrayFactory.apply(base);
+        for (int i = 0; i < nelems; i++) {
+            Object found = handleGetter.apply(base, (long) i);
+            Object expected = java.lang.reflect.Array.get(arr, i);
             assertEquals(expected, found);
         }
     }
 
     @Test(dataProvider = "arrays")
-    public void testArrays(Consumer init, SequenceLayout layout) {
+    public void testArrays(Consumer init, Consumer checker, MemoryLayout layout) {
         try (MemorySegment segment = MemorySegment.allocateNative(layout)) {
-            init.accept(segment.baseAddress());
-            checkBytes(segment.baseAddress(), layout);
+            init.accept(segment);
+            checker.accept(segment);
         }
     }
 
-    @Test(expectedExceptions = UnsupportedOperationException.class)
-    public void testTooBigForArray() {
-        try (MemorySegment segment = MemorySegment.ofNativeRestricted(MemoryAddress.NULL, (long)Integer.MAX_VALUE + 10L, null, null, null)) {
-            segment.toByteArray();
+    @Test(dataProvider = "elemLayouts",
+            expectedExceptions = UnsupportedOperationException.class)
+    public void testTooBigForArray(MemoryLayout layout, Function arrayFactory) {
+        MemoryLayout seq = MemoryLayout.ofSequence((Integer.MAX_VALUE * layout.byteSize()) + 1, layout);
+        //do not really allocate here, as it's way too much memory
+        try (MemorySegment segment = MemoryAddress.NULL.asSegmentRestricted(seq.byteSize())) {
+            arrayFactory.apply(segment);
         }
     }
 
-    @Test(expectedExceptions = IllegalStateException.class)
-    public void testArrayFromClosedSegment() {
-        MemorySegment segment = MemorySegment.allocateNative(8);
+    @Test(dataProvider = "elemLayouts",
+            expectedExceptions = UnsupportedOperationException.class)
+    public void testBadSize(MemoryLayout layout, Function arrayFactory) {
+        if (layout.byteSize() == 1) throw new UnsupportedOperationException(); //make it fail
+        try (MemorySegment segment = MemorySegment.allocateNative(layout.byteSize() + 1)) {
+            arrayFactory.apply(segment);
+        }
+    }
+
+    @Test(dataProvider = "elemLayouts",
+            expectedExceptions = IllegalStateException.class)
+    public void testArrayFromClosedSegment(MemoryLayout layout, Function arrayFactory) {
+        MemorySegment segment = MemorySegment.allocateNative(layout);
         segment.close();
-        segment.toByteArray();
+        arrayFactory.apply(segment);
     }
 
-    @Test(expectedExceptions = UnsupportedOperationException.class)
-    public void testArrayFromHeapSegmentWithoutAccess() {
-        MemorySegment segment = MemorySegment.ofArray(new byte[8]);
-        segment = segment.withAccessModes(segment.accessModes() & ~READ);
-        segment.toByteArray();
+    @Test(dataProvider = "elemLayouts",
+            expectedExceptions = UnsupportedOperationException.class)
+    public void testArrayFromHeapSegmentWithoutAccess(MemoryLayout layout, Function arrayFactory) {
+        MemorySegment segment = MemorySegment.ofArray(new byte[(int)layout.byteSize()]);
+        segment = segment.withAccessModes(MemorySegment.ALL_ACCESS & ~READ);
+        arrayFactory.apply(segment);
     }
 
-    @Test(expectedExceptions = UnsupportedOperationException.class)
-    public void testArrayFromNativeSegmentWithoutAccess() {
-        MemorySegment segment = MemorySegment.allocateNative(8);
-        segment = segment.withAccessModes(segment.accessModes() & ~READ);
-        segment.toByteArray();
+    @Test(dataProvider = "elemLayouts",
+            expectedExceptions = UnsupportedOperationException.class)
+    public void testArrayFromNativeSegmentWithoutAccess(MemoryLayout layout, Function arrayFactory) {
+        try (MemorySegment segment = MemorySegment.allocateNative(layout).withAccessModes(MemorySegment.ALL_ACCESS & ~READ)) {
+            arrayFactory.apply(segment);
+        }
     }
 
     @DataProvider(name = "arrays")
     public Object[][] nativeAccessOps() {
-        Consumer byteInitializer =
+        Consumer byteInitializer =
                 (base) -> initBytes(base, bytes, (addr, pos) -> byteHandle.set(addr, pos, (byte)(long)pos));
-        Consumer charInitializer =
+        Consumer charInitializer =
                 (base) -> initBytes(base, chars, (addr, pos) -> charHandle.set(addr, pos, (char)(long)pos));
-        Consumer shortInitializer =
+        Consumer shortInitializer =
                 (base) -> initBytes(base, shorts, (addr, pos) -> shortHandle.set(addr, pos, (short)(long)pos));
-        Consumer intInitializer =
+        Consumer intInitializer =
                 (base) -> initBytes(base, ints, (addr, pos) -> intHandle.set(addr, pos, (int)(long)pos));
-        Consumer floatInitializer =
+        Consumer floatInitializer =
                 (base) -> initBytes(base, floats, (addr, pos) -> floatHandle.set(addr, pos, (float)(long)pos));
-        Consumer longInitializer =
+        Consumer longInitializer =
                 (base) -> initBytes(base, longs, (addr, pos) -> longHandle.set(addr, pos, (long)pos));
-        Consumer doubleInitializer =
+        Consumer doubleInitializer =
                 (base) -> initBytes(base, doubles, (addr, pos) -> doubleHandle.set(addr, pos, (double)(long)pos));
 
+        Consumer byteChecker =
+                (base) -> checkBytes(base, bytes, MemorySegment::toByteArray, (addr, pos) -> (byte)byteHandle.get(addr, pos));
+        Consumer shortChecker =
+                (base) -> checkBytes(base, shorts, MemorySegment::toShortArray, (addr, pos) -> (short)shortHandle.get(addr, pos));
+        Consumer charChecker =
+                (base) -> checkBytes(base, chars, MemorySegment::toCharArray, (addr, pos) -> (char)charHandle.get(addr, pos));
+        Consumer intChecker =
+                (base) -> checkBytes(base, ints, MemorySegment::toIntArray, (addr, pos) -> (int)intHandle.get(addr, pos));
+        Consumer floatChecker =
+                (base) -> checkBytes(base, floats, MemorySegment::toFloatArray, (addr, pos) -> (float)floatHandle.get(addr, pos));
+        Consumer longChecker =
+                (base) -> checkBytes(base, longs, MemorySegment::toLongArray, (addr, pos) -> (long)longHandle.get(addr, pos));
+        Consumer doubleChecker =
+                (base) -> checkBytes(base, doubles, MemorySegment::toDoubleArray, (addr, pos) -> (double)doubleHandle.get(addr, pos));
+
         return new Object[][]{
-                {byteInitializer, bytes},
-                {charInitializer, chars},
-                {shortInitializer, shorts},
-                {intInitializer, ints},
-                {floatInitializer, floats},
-                {longInitializer, longs},
-                {doubleInitializer, doubles}
+                {byteInitializer, byteChecker, bytes},
+                {charInitializer, charChecker, chars},
+                {shortInitializer, shortChecker, shorts},
+                {intInitializer, intChecker, ints},
+                {floatInitializer, floatChecker, floats},
+                {longInitializer, longChecker, longs},
+                {doubleInitializer, doubleChecker, doubles}
+        };
+    }
+
+    @DataProvider(name = "elemLayouts")
+    public Object[][] elemLayouts() {
+        return new Object[][] {
+                { MemoryLayouts.JAVA_BYTE, (Function) MemorySegment::toByteArray },
+                { MemoryLayouts.JAVA_SHORT, (Function) MemorySegment::toShortArray },
+                { MemoryLayouts.JAVA_CHAR, (Function) MemorySegment::toCharArray },
+                { MemoryLayouts.JAVA_INT, (Function) MemorySegment::toIntArray },
+                { MemoryLayouts.JAVA_FLOAT, (Function) MemorySegment::toFloatArray },
+                { MemoryLayouts.JAVA_LONG, (Function) MemorySegment::toLongArray },
+                { MemoryLayouts.JAVA_DOUBLE, (Function) MemorySegment::toDoubleArray }
         };
     }
 }
diff --git a/test/jdk/java/foreign/TestByteBuffer.java b/test/jdk/java/foreign/TestByteBuffer.java
index 5960d95a5d409..fcbc6b2c11880 100644
--- a/test/jdk/java/foreign/TestByteBuffer.java
+++ b/test/jdk/java/foreign/TestByteBuffer.java
@@ -4,9 +4,7 @@
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.  Oracle designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
+ * published by the Free Software Foundation.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
@@ -32,6 +30,7 @@
 
 
 import jdk.incubator.foreign.MappedMemorySegment;
+import jdk.incubator.foreign.MemoryAccess;
 import jdk.incubator.foreign.MemoryLayouts;
 import jdk.incubator.foreign.MemoryLayout;
 import jdk.incubator.foreign.MemoryAddress;
@@ -134,23 +133,14 @@ public class TestByteBuffer {
     static VarHandle indexHandle = tuples.varHandle(int.class, PathElement.sequenceElement(), PathElement.groupElement("index"));
     static VarHandle valueHandle = tuples.varHandle(float.class, PathElement.sequenceElement(), PathElement.groupElement("value"));
 
-    static VarHandle byteHandle = bytes.varHandle(byte.class, PathElement.sequenceElement());
-    static VarHandle charHandle = chars.varHandle(char.class, PathElement.sequenceElement());
-    static VarHandle shortHandle = shorts.varHandle(short.class, PathElement.sequenceElement());
-    static VarHandle intHandle = ints.varHandle(int.class, PathElement.sequenceElement());
-    static VarHandle floatHandle = floats.varHandle(float.class, PathElement.sequenceElement());
-    static VarHandle longHandle = longs.varHandle(long.class, PathElement.sequenceElement());
-    static VarHandle doubleHandle = doubles.varHandle(double.class, PathElement.sequenceElement());
-
-
-    static void initTuples(MemoryAddress base, long count) {
+    static void initTuples(MemorySegment base, long count) {
         for (long i = 0; i < count ; i++) {
             indexHandle.set(base, i, (int)i);
             valueHandle.set(base, i, (float)(i / 500f));
         }
     }
 
-    static void checkTuples(MemoryAddress base, ByteBuffer bb, long count) {
+    static void checkTuples(MemorySegment base, ByteBuffer bb, long count) {
         for (long i = 0; i < count ; i++) {
             int index;
             float value;
@@ -160,25 +150,25 @@ static void checkTuples(MemoryAddress base, ByteBuffer bb, long count) {
         }
     }
 
-    static void initBytes(MemoryAddress base, SequenceLayout seq, BiConsumer handleSetter) {
+    static void initBytes(MemorySegment base, SequenceLayout seq, BiConsumer handleSetter) {
         for (long i = 0; i < seq.elementCount().getAsLong() ; i++) {
             handleSetter.accept(base, i);
         }
     }
 
-    static  void checkBytes(MemoryAddress base, SequenceLayout layout,
+    static  void checkBytes(MemorySegment base, SequenceLayout layout,
                                               Function bufFactory,
-                                              BiFunction handleExtractor,
+                                              BiFunction handleExtractor,
                                               Function bufferExtractor) {
         long nelems = layout.elementCount().getAsLong();
         long elemSize = layout.elementLayout().byteSize();
         for (long i = 0 ; i < nelems ; i++) {
             long limit = nelems - i;
-            MemorySegment resizedSegment = base.segment().asSlice(i * elemSize, limit * elemSize);
+            MemorySegment resizedSegment = base.asSlice(i * elemSize, limit * elemSize);
             ByteBuffer bb = resizedSegment.asByteBuffer();
             Z z = bufFactory.apply(bb);
             for (long j = i ; j < limit ; j++) {
-                Object handleValue = handleExtractor.apply(resizedSegment.baseAddress(), j - i);
+                Object handleValue = handleExtractor.apply(resizedSegment, j - i);
                 Object bufferValue = bufferExtractor.apply(z);
                 if (handleValue instanceof Number) {
                     assertEquals(((Number)handleValue).longValue(), j);
@@ -194,11 +184,10 @@ static  void checkBytes(MemoryAddress base, SequenceLayout lay
     @Test
     public void testOffheap() {
         try (MemorySegment segment = MemorySegment.allocateNative(tuples)) {
-            MemoryAddress base = segment.baseAddress();
-            initTuples(base, tuples.elementCount().getAsLong());
+            initTuples(segment, tuples.elementCount().getAsLong());
 
             ByteBuffer bb = segment.asByteBuffer();
-            checkTuples(base, bb, tuples.elementCount().getAsLong());
+            checkTuples(segment, bb, tuples.elementCount().getAsLong());
         }
     }
 
@@ -206,11 +195,10 @@ public void testOffheap() {
     public void testHeap() {
         byte[] arr = new byte[(int) tuples.byteSize()];
         MemorySegment region = MemorySegment.ofArray(arr);
-        MemoryAddress base = region.baseAddress();
-        initTuples(base, tuples.elementCount().getAsLong());
+        initTuples(region, tuples.elementCount().getAsLong());
 
         ByteBuffer bb = region.asByteBuffer();
-        checkTuples(base, bb, tuples.elementCount().getAsLong());
+        checkTuples(region, bb, tuples.elementCount().getAsLong());
     }
 
     @Test
@@ -223,8 +211,7 @@ public void testChannel() throws Throwable {
         try (FileChannel channel = FileChannel.open(f.toPath(), StandardOpenOption.READ, StandardOpenOption.WRITE)) {
             withMappedBuffer(channel, FileChannel.MapMode.READ_WRITE, 0, tuples.byteSize(), mbb -> {
                 MemorySegment segment = MemorySegment.ofByteBuffer(mbb);
-                MemoryAddress base = segment.baseAddress();
-                initTuples(base, tuples.elementCount().getAsLong());
+                initTuples(segment, tuples.elementCount().getAsLong());
                 mbb.force();
             });
         }
@@ -233,8 +220,7 @@ public void testChannel() throws Throwable {
         try (FileChannel channel = FileChannel.open(f.toPath(), StandardOpenOption.READ)) {
             withMappedBuffer(channel, FileChannel.MapMode.READ_ONLY, 0, tuples.byteSize(), mbb -> {
                 MemorySegment segment = MemorySegment.ofByteBuffer(mbb);
-                MemoryAddress base = segment.baseAddress();
-                checkTuples(base, mbb, tuples.elementCount().getAsLong());
+                checkTuples(segment, mbb, tuples.elementCount().getAsLong());
             });
         }
     }
@@ -260,15 +246,13 @@ public void testMappedSegment() throws Throwable {
 
         //write to channel
         try (MappedMemorySegment segment = MemorySegment.mapFromPath(f.toPath(), 0L, tuples.byteSize(), FileChannel.MapMode.READ_WRITE)) {
-            MemoryAddress base = segment.baseAddress();
-            initTuples(base, tuples.elementCount().getAsLong());
+            initTuples(segment, tuples.elementCount().getAsLong());
             segment.force();
         }
 
         //read from channel
         try (MemorySegment segment = MemorySegment.mapFromPath(f.toPath(), 0L, tuples.byteSize(), FileChannel.MapMode.READ_ONLY)) {
-            MemoryAddress base = segment.baseAddress();
-            checkTuples(base, segment.asByteBuffer(), tuples.elementCount().getAsLong());
+            checkTuples(segment, segment.asByteBuffer(), tuples.elementCount().getAsLong());
         }
     }
 
@@ -284,8 +268,7 @@ public void testMappedSegmentOffset() throws Throwable {
         for (int i = 0 ; i < tuples.byteSize() ; i += tupleLayout.byteSize()) {
             //write to channel
             try (MappedMemorySegment segment = MemorySegment.mapFromPath(f.toPath(), i, tuples.byteSize(), FileChannel.MapMode.READ_WRITE)) {
-                MemoryAddress base = segment.baseAddress();
-                initTuples(base, 1);
+                initTuples(segment, 1);
                 segment.force();
             }
         }
@@ -294,8 +277,7 @@ public void testMappedSegmentOffset() throws Throwable {
         for (int i = 0 ; i < tuples.byteSize() ; i += tupleLayout.byteSize()) {
             //read from channel
             try (MemorySegment segment = MemorySegment.mapFromPath(f.toPath(), 0L, tuples.byteSize(), FileChannel.MapMode.READ_ONLY)) {
-                MemoryAddress base = segment.baseAddress();
-                checkTuples(base, segment.asByteBuffer(), 1);
+                checkTuples(segment, segment.asByteBuffer(), 1);
             }
         }
     }
@@ -323,13 +305,13 @@ static void checkByteArrayAlignment(MemoryLayout layout) {
     public void testScopedBuffer(Function bufferFactory, Map members) {
         Buffer bb;
         try (MemorySegment segment = MemorySegment.allocateNative(bytes)) {
-            MemoryAddress base = segment.baseAddress();
             bb = bufferFactory.apply(segment.asByteBuffer());
         }
         //outside of scope!!
         for (Map.Entry e : members.entrySet()) {
-            if (!e.getKey().getName().contains("get") &&
-                            !e.getKey().getName().contains("put")) {
+            if ((!e.getKey().getName().contains("get") &&
+                    !e.getKey().getName().contains("put"))
+                    || e.getValue().length > 2) { // skip bulk ops
                 //skip
                 return;
             }
@@ -389,61 +371,57 @@ public void testScopedBufferAndVarHandle(VarHandle bufferHandle) {
     @Test(dataProvider = "bufferOps")
     public void testDirectBuffer(Function bufferFactory, Map members) {
         try (MemorySegment segment = MemorySegment.allocateNative(bytes)) {
-            MemoryAddress base = segment.baseAddress();
             Buffer bb = bufferFactory.apply(segment.asByteBuffer());
             assertTrue(bb.isDirect());
             DirectBuffer directBuffer = ((DirectBuffer)bb);
-            assertEquals(directBuffer.address(), ((MemoryAddressImpl)base).unsafeGetOffset());
+            assertEquals(directBuffer.address(), segment.address().toRawLongValue());
             assertTrue((directBuffer.attachment() == null) == (bb instanceof ByteBuffer));
             assertTrue(directBuffer.cleaner() == null);
         }
     }
 
     @Test(dataProvider="resizeOps")
-    public void testResizeOffheap(Consumer checker, Consumer initializer, SequenceLayout seq) {
+    public void testResizeOffheap(Consumer checker, Consumer initializer, SequenceLayout seq) {
         try (MemorySegment segment = MemorySegment.allocateNative(seq)) {
-            MemoryAddress base = segment.baseAddress();
-            initializer.accept(base);
-            checker.accept(base);
+            initializer.accept(segment);
+            checker.accept(segment);
         }
     }
 
     @Test(dataProvider="resizeOps")
-    public void testResizeHeap(Consumer checker, Consumer initializer, SequenceLayout seq) {
+    public void testResizeHeap(Consumer checker, Consumer initializer, SequenceLayout seq) {
         checkByteArrayAlignment(seq.elementLayout());
         int capacity = (int)seq.byteSize();
-        MemoryAddress base = MemorySegment.ofArray(new byte[capacity]).baseAddress();
+        MemorySegment base = MemorySegment.ofArray(new byte[capacity]);
         initializer.accept(base);
         checker.accept(base);
     }
 
     @Test(dataProvider="resizeOps")
-    public void testResizeBuffer(Consumer checker, Consumer initializer, SequenceLayout seq) {
+    public void testResizeBuffer(Consumer checker, Consumer initializer, SequenceLayout seq) {
         checkByteArrayAlignment(seq.elementLayout());
         int capacity = (int)seq.byteSize();
-        MemoryAddress base = MemorySegment.ofByteBuffer(ByteBuffer.wrap(new byte[capacity])).baseAddress();
+        MemorySegment base = MemorySegment.ofByteBuffer(ByteBuffer.wrap(new byte[capacity]));
         initializer.accept(base);
         checker.accept(base);
     }
 
     @Test(dataProvider="resizeOps")
-    public void testResizeRoundtripHeap(Consumer checker, Consumer initializer, SequenceLayout seq) {
+    public void testResizeRoundtripHeap(Consumer checker, Consumer initializer, SequenceLayout seq) {
         checkByteArrayAlignment(seq.elementLayout());
         int capacity = (int)seq.byteSize();
         byte[] arr = new byte[capacity];
         MemorySegment segment = MemorySegment.ofArray(arr);
-        MemoryAddress first = segment.baseAddress();
-        initializer.accept(first);
-        MemoryAddress second = MemorySegment.ofByteBuffer(segment.asByteBuffer()).baseAddress();
+        initializer.accept(segment);
+        MemorySegment second = MemorySegment.ofByteBuffer(segment.asByteBuffer());
         checker.accept(second);
     }
 
     @Test(dataProvider="resizeOps")
-    public void testResizeRoundtripNative(Consumer checker, Consumer initializer, SequenceLayout seq) {
+    public void testResizeRoundtripNative(Consumer checker, Consumer initializer, SequenceLayout seq) {
         try (MemorySegment segment = MemorySegment.allocateNative(seq)) {
-            MemoryAddress first = segment.baseAddress();
-            initializer.accept(first);
-            MemoryAddress second = MemorySegment.ofByteBuffer(segment.asByteBuffer()).baseAddress();
+            initializer.accept(segment);
+            MemorySegment second = MemorySegment.ofByteBuffer(segment.asByteBuffer());
             checker.accept(second);
         }
     }
@@ -460,7 +438,7 @@ public void testBufferOnClosedScope() {
 
     @Test(expectedExceptions = UnsupportedOperationException.class)
     public void testTooBigForByteBuffer() {
-        try (MemorySegment segment = MemorySegment.ofNativeRestricted(MemoryAddress.NULL, (long)Integer.MAX_VALUE + 10L, null, null, null)) {
+        try (MemorySegment segment = MemoryAddress.NULL.asSegmentRestricted(Integer.MAX_VALUE + 10L)) {
             segment.asByteBuffer();
         }
     }
@@ -491,26 +469,26 @@ public void testMapZeroSize() throws IOException {
     }
 
     @Test(dataProvider="resizeOps")
-    public void testCopyHeapToNative(Consumer checker, Consumer initializer, SequenceLayout seq) {
+    public void testCopyHeapToNative(Consumer checker, Consumer initializer, SequenceLayout seq) {
         checkByteArrayAlignment(seq.elementLayout());
         int bytes = (int)seq.byteSize();
         try (MemorySegment nativeArray = MemorySegment.allocateNative(bytes);
              MemorySegment heapArray = MemorySegment.ofArray(new byte[bytes])) {
-            initializer.accept(heapArray.baseAddress());
+            initializer.accept(heapArray);
             nativeArray.copyFrom(heapArray);
-            checker.accept(nativeArray.baseAddress());
+            checker.accept(nativeArray);
         }
     }
 
     @Test(dataProvider="resizeOps")
-    public void testCopyNativeToHeap(Consumer checker, Consumer initializer, SequenceLayout seq) {
+    public void testCopyNativeToHeap(Consumer checker, Consumer initializer, SequenceLayout seq) {
         checkByteArrayAlignment(seq.elementLayout());
         int bytes = (int)seq.byteSize();
         try (MemorySegment nativeArray = MemorySegment.allocateNative(seq);
              MemorySegment heapArray = MemorySegment.ofArray(new byte[bytes])) {
-            initializer.accept(nativeArray.baseAddress());
+            initializer.accept(nativeArray);
             heapArray.copyFrom(nativeArray);
-            checker.accept(heapArray.baseAddress());
+            checker.accept(heapArray);
         }
     }
 
@@ -562,7 +540,7 @@ public void testDeadAccessOnClosedBufferSegment() {
 
         s1.close(); // memory freed
 
-        intHandle.set(s2.baseAddress(), 0L, 10); // Dead access!
+        MemoryAccess.setInt(s2, 10); // Dead access!
     }
 
     @DataProvider(name = "bufferOps")
@@ -622,35 +600,35 @@ static Map varHandleMembers(ByteBuffer bb, VarHandle han
 
     @DataProvider(name = "resizeOps")
     public Object[][] resizeOps() {
-        Consumer byteInitializer =
-                (base) -> initBytes(base, bytes, (addr, pos) -> byteHandle.set(addr, pos, (byte)(long)pos));
-        Consumer charInitializer =
-                (base) -> initBytes(base, chars, (addr, pos) -> charHandle.set(addr, pos, (char)(long)pos));
-        Consumer shortInitializer =
-                (base) -> initBytes(base, shorts, (addr, pos) -> shortHandle.set(addr, pos, (short)(long)pos));
-        Consumer intInitializer =
-                (base) -> initBytes(base, ints, (addr, pos) -> intHandle.set(addr, pos, (int)(long)pos));
-        Consumer floatInitializer =
-                (base) -> initBytes(base, floats, (addr, pos) -> floatHandle.set(addr, pos, (float)(long)pos));
-        Consumer longInitializer =
-                (base) -> initBytes(base, longs, (addr, pos) -> longHandle.set(addr, pos, (long)pos));
-        Consumer doubleInitializer =
-                (base) -> initBytes(base, doubles, (addr, pos) -> doubleHandle.set(addr, pos, (double)(long)pos));
-
-        Consumer byteChecker =
-                (base) -> checkBytes(base, bytes, Function.identity(), byteHandle::get, ByteBuffer::get);
-        Consumer charChecker =
-                (base) -> checkBytes(base, chars, ByteBuffer::asCharBuffer, charHandle::get, CharBuffer::get);
-        Consumer shortChecker =
-                (base) -> checkBytes(base, shorts, ByteBuffer::asShortBuffer, shortHandle::get, ShortBuffer::get);
-        Consumer intChecker =
-                (base) -> checkBytes(base, ints, ByteBuffer::asIntBuffer, intHandle::get, IntBuffer::get);
-        Consumer floatChecker =
-                (base) -> checkBytes(base, floats, ByteBuffer::asFloatBuffer, floatHandle::get, FloatBuffer::get);
-        Consumer longChecker =
-                (base) -> checkBytes(base, longs, ByteBuffer::asLongBuffer, longHandle::get, LongBuffer::get);
-        Consumer doubleChecker =
-                (base) -> checkBytes(base, doubles, ByteBuffer::asDoubleBuffer, doubleHandle::get, DoubleBuffer::get);
+        Consumer byteInitializer =
+                (base) -> initBytes(base, bytes, (addr, pos) -> MemoryAccess.setByteAtIndex_BE(addr, pos, (byte)(long)pos));
+        Consumer charInitializer =
+                (base) -> initBytes(base, chars, (addr, pos) -> MemoryAccess.setCharAtIndex_BE(addr, pos, (char)(long)pos));
+        Consumer shortInitializer =
+                (base) -> initBytes(base, shorts, (addr, pos) -> MemoryAccess.setShortAtIndex_BE(addr, pos, (short)(long)pos));
+        Consumer intInitializer =
+                (base) -> initBytes(base, ints, (addr, pos) -> MemoryAccess.setIntAtIndex_BE(addr, pos, (int)(long)pos));
+        Consumer floatInitializer =
+                (base) -> initBytes(base, floats, (addr, pos) -> MemoryAccess.setFloatAtIndex_BE(addr, pos, (float)(long)pos));
+        Consumer longInitializer =
+                (base) -> initBytes(base, longs, (addr, pos) -> MemoryAccess.setLongAtIndex_BE(addr, pos, (long)pos));
+        Consumer doubleInitializer =
+                (base) -> initBytes(base, doubles, (addr, pos) -> MemoryAccess.setDoubleAtIndex_BE(addr, pos, (double)(long)pos));
+
+        Consumer byteChecker =
+                (base) -> checkBytes(base, bytes, Function.identity(), MemoryAccess::getByteAtIndex_BE, ByteBuffer::get);
+        Consumer charChecker =
+                (base) -> checkBytes(base, chars, ByteBuffer::asCharBuffer, MemoryAccess::getCharAtIndex_BE, CharBuffer::get);
+        Consumer shortChecker =
+                (base) -> checkBytes(base, shorts, ByteBuffer::asShortBuffer, MemoryAccess::getShortAtIndex_BE, ShortBuffer::get);
+        Consumer intChecker =
+                (base) -> checkBytes(base, ints, ByteBuffer::asIntBuffer, MemoryAccess::getIntAtIndex_BE, IntBuffer::get);
+        Consumer floatChecker =
+                (base) -> checkBytes(base, floats, ByteBuffer::asFloatBuffer, MemoryAccess::getFloatAtIndex_BE, FloatBuffer::get);
+        Consumer longChecker =
+                (base) -> checkBytes(base, longs, ByteBuffer::asLongBuffer, MemoryAccess::getLongAtIndex_BE, LongBuffer::get);
+        Consumer doubleChecker =
+                (base) -> checkBytes(base, doubles, ByteBuffer::asDoubleBuffer, MemoryAccess::getDoubleAtIndex_BE, DoubleBuffer::get);
 
         return new Object[][]{
                 {byteChecker, byteInitializer, bytes},
diff --git a/test/jdk/java/foreign/TestLayouts.java b/test/jdk/java/foreign/TestLayouts.java
index 9567c7b09cab9..aa683a4defe0e 100644
--- a/test/jdk/java/foreign/TestLayouts.java
+++ b/test/jdk/java/foreign/TestLayouts.java
@@ -64,14 +64,14 @@ public void testVLAInStruct() {
                 MemoryLayout.PathElement.sequenceElement());
         try (MemorySegment segment = MemorySegment.allocateNative(
                 layout.map(l -> ((SequenceLayout)l).withElementCount(4), MemoryLayout.PathElement.groupElement("arr")))) {
-            size_handle.set(segment.baseAddress(), 4);
+            size_handle.set(segment, 4);
             for (int i = 0 ; i < 4 ; i++) {
-                array_elem_handle.set(segment.baseAddress(), i, (double)i);
+                array_elem_handle.set(segment, i, (double)i);
             }
             //check
-            assertEquals(4, (int)size_handle.get(segment.baseAddress()));
+            assertEquals(4, (int)size_handle.get(segment));
             for (int i = 0 ; i < 4 ; i++) {
-                assertEquals((double)i, (double)array_elem_handle.get(segment.baseAddress(), i));
+                assertEquals((double)i, (double)array_elem_handle.get(segment, i));
             }
         }
     }
@@ -90,14 +90,14 @@ public void testVLAInSequence() {
                 MemoryLayout.PathElement.sequenceElement());
         try (MemorySegment segment = MemorySegment.allocateNative(
                 layout.map(l -> ((SequenceLayout)l).withElementCount(4), MemoryLayout.PathElement.groupElement("arr"), MemoryLayout.PathElement.sequenceElement()))) {
-            size_handle.set(segment.baseAddress(), 4);
+            size_handle.set(segment, 4);
             for (int i = 0 ; i < 4 ; i++) {
-                array_elem_handle.set(segment.baseAddress(), i, (double)i);
+                array_elem_handle.set(segment, i, (double)i);
             }
             //check
-            assertEquals(4, (int)size_handle.get(segment.baseAddress()));
+            assertEquals(4, (int)size_handle.get(segment));
             for (int i = 0 ; i < 4 ; i++) {
-                assertEquals((double)i, (double)array_elem_handle.get(segment.baseAddress(), i));
+                assertEquals((double)i, (double)array_elem_handle.get(segment, i));
             }
         }
     }
@@ -109,13 +109,13 @@ public void testIndexedSequencePath() {
             VarHandle indexHandle = seq.varHandle(int.class, MemoryLayout.PathElement.sequenceElement());
             // init segment
             for (int i = 0 ; i < 10 ; i++) {
-                indexHandle.set(segment.baseAddress(), (long)i, i);
+                indexHandle.set(segment, (long)i, i);
             }
             //check statically indexed handles
             for (int i = 0 ; i < 10 ; i++) {
                 VarHandle preindexHandle = seq.varHandle(int.class, MemoryLayout.PathElement.sequenceElement(i));
-                int expected = (int)indexHandle.get(segment.baseAddress(), (long)i);
-                int found = (int)preindexHandle.get(segment.baseAddress());
+                int expected = (int)indexHandle.get(segment, (long)i);
+                int found = (int)preindexHandle.get(segment);
                 assertEquals(expected, found);
             }
         }
diff --git a/test/jdk/java/foreign/TestMemoryAccess.java b/test/jdk/java/foreign/TestMemoryAccess.java
index d0d57af38c172..bcaf2b1756fc7 100644
--- a/test/jdk/java/foreign/TestMemoryAccess.java
+++ b/test/jdk/java/foreign/TestMemoryAccess.java
@@ -36,7 +36,7 @@
 import jdk.incubator.foreign.MemorySegment;
 import jdk.incubator.foreign.SequenceLayout;
 import jdk.incubator.foreign.ValueLayout;
-import jdk.incubator.foreign.MemoryAddress;
+
 import java.lang.invoke.VarHandle;
 import java.util.function.Function;
 
@@ -82,12 +82,11 @@ public void testPaddedArrayAccessByIndexSeq(Function viewFactory, MemoryLayout layout, VarHandle handle, Checker checker) {
-        MemoryAddress outer_address;
+        MemorySegment outer_segment;
         try (MemorySegment segment = viewFactory.apply(MemorySegment.allocateNative(layout))) {
             boolean isRO = !segment.hasAccessModes(MemorySegment.WRITE);
-            MemoryAddress addr = segment.baseAddress();
             try {
-                checker.check(handle, addr);
+                checker.check(handle, segment);
                 if (isRO) {
                     throw new AssertionError(); //not ok, memory should be immutable
                 }
@@ -98,15 +97,15 @@ private void testAccessInternal(Function viewFacto
                 return;
             }
             try {
-                checker.check(handle, addr.addOffset(layout.byteSize()));
+                checker.check(handle, segment.asSlice(layout.byteSize()));
                 throw new AssertionError(); //not ok, out of bounds
             } catch (IndexOutOfBoundsException ex) {
                 //ok, should fail (out of bounds)
             }
-            outer_address = addr; //leak!
+            outer_segment = segment; //leak!
         }
         try {
-            checker.check(handle, outer_address);
+            checker.check(handle, outer_segment);
             throw new AssertionError(); //not ok, scope is closed
         } catch (IllegalStateException ex) {
             //ok, should fail (scope is closed)
@@ -114,13 +113,12 @@ private void testAccessInternal(Function viewFacto
     }
 
     private void testArrayAccessInternal(Function viewFactory, SequenceLayout seq, VarHandle handle, ArrayChecker checker) {
-        MemoryAddress outer_address;
+        MemorySegment outer_segment;
         try (MemorySegment segment = viewFactory.apply(MemorySegment.allocateNative(seq))) {
             boolean isRO = !segment.hasAccessModes(MemorySegment.WRITE);
-            MemoryAddress addr = segment.baseAddress();
             try {
                 for (int i = 0; i < seq.elementCount().getAsLong(); i++) {
-                    checker.check(handle, addr, i);
+                    checker.check(handle, segment, i);
                 }
                 if (isRO) {
                     throw new AssertionError(); //not ok, memory should be immutable
@@ -132,15 +130,15 @@ private void testArrayAccessInternal(Function view
                 return;
             }
             try {
-                checker.check(handle, addr, seq.elementCount().getAsLong());
+                checker.check(handle, segment, seq.elementCount().getAsLong());
                 throw new AssertionError(); //not ok, out of bounds
             } catch (IndexOutOfBoundsException ex) {
                 //ok, should fail (out of bounds)
             }
-            outer_address = addr; //leak!
+            outer_segment = segment; //leak!
         }
         try {
-            checker.check(handle, outer_address, 0);
+            checker.check(handle, outer_segment, 0);
             throw new AssertionError(); //not ok, scope is closed
         } catch (IllegalStateException ex) {
             //ok, should fail (scope is closed)
@@ -183,14 +181,13 @@ public void testBadCarriers(Class carrier) {
     }
 
     private void testMatrixAccessInternal(Function viewFactory, SequenceLayout seq, VarHandle handle, MatrixChecker checker) {
-        MemoryAddress outer_address;
+        MemorySegment outer_segment;
         try (MemorySegment segment = viewFactory.apply(MemorySegment.allocateNative(seq))) {
             boolean isRO = !segment.hasAccessModes(MemorySegment.WRITE);
-            MemoryAddress addr = segment.baseAddress();
             try {
                 for (int i = 0; i < seq.elementCount().getAsLong(); i++) {
                     for (int j = 0; j < ((SequenceLayout) seq.elementLayout()).elementCount().getAsLong(); j++) {
-                        checker.check(handle, addr, i, j);
+                        checker.check(handle, segment, i, j);
                     }
                 }
                 if (isRO) {
@@ -203,16 +200,16 @@ private void testMatrixAccessInternal(Function vie
                 return;
             }
             try {
-                checker.check(handle, addr, seq.elementCount().getAsLong(),
+                checker.check(handle, segment, seq.elementCount().getAsLong(),
                         ((SequenceLayout)seq.elementLayout()).elementCount().getAsLong());
                 throw new AssertionError(); //not ok, out of bounds
             } catch (IndexOutOfBoundsException ex) {
                 //ok, should fail (out of bounds)
             }
-            outer_address = addr; //leak!
+            outer_segment = segment; //leak!
         }
         try {
-            checker.check(handle, outer_address, 0, 0);
+            checker.check(handle, outer_segment, 0, 0);
             throw new AssertionError(); //not ok, scope is closed
         } catch (IllegalStateException ex) {
             //ok, should fail (scope is closed)
@@ -261,41 +258,41 @@ public Object[][] createData() {
     }
 
     interface Checker {
-        void check(VarHandle handle, MemoryAddress addr);
+        void check(VarHandle handle, MemorySegment segment);
 
-        Checker BYTE = (handle, addr) -> {
-            handle.set(addr, (byte)42);
-            assertEquals(42, (byte)handle.get(addr));
+        Checker BYTE = (handle, segment) -> {
+            handle.set(segment, (byte)42);
+            assertEquals(42, (byte)handle.get(segment));
         };
 
-        Checker SHORT = (handle, addr) -> {
-            handle.set(addr, (short)42);
-            assertEquals(42, (short)handle.get(addr));
+        Checker SHORT = (handle, segment) -> {
+            handle.set(segment, (short)42);
+            assertEquals(42, (short)handle.get(segment));
         };
 
-        Checker CHAR = (handle, addr) -> {
-            handle.set(addr, (char)42);
-            assertEquals(42, (char)handle.get(addr));
+        Checker CHAR = (handle, segment) -> {
+            handle.set(segment, (char)42);
+            assertEquals(42, (char)handle.get(segment));
         };
 
-        Checker INT = (handle, addr) -> {
-            handle.set(addr, 42);
-            assertEquals(42, (int)handle.get(addr));
+        Checker INT = (handle, segment) -> {
+            handle.set(segment, 42);
+            assertEquals(42, (int)handle.get(segment));
         };
 
-        Checker LONG = (handle, addr) -> {
-            handle.set(addr, (long)42);
-            assertEquals(42, (long)handle.get(addr));
+        Checker LONG = (handle, segment) -> {
+            handle.set(segment, (long)42);
+            assertEquals(42, (long)handle.get(segment));
         };
 
-        Checker FLOAT = (handle, addr) -> {
-            handle.set(addr, (float)42);
-            assertEquals((float)42, (float)handle.get(addr));
+        Checker FLOAT = (handle, segment) -> {
+            handle.set(segment, (float)42);
+            assertEquals((float)42, (float)handle.get(segment));
         };
 
-        Checker DOUBLE = (handle, addr) -> {
-            handle.set(addr, (double)42);
-            assertEquals((double)42, (double)handle.get(addr));
+        Checker DOUBLE = (handle, segment) -> {
+            handle.set(segment, (double)42);
+            assertEquals((double)42, (double)handle.get(segment));
         };
     }
 
@@ -338,41 +335,41 @@ public Object[][] createArrayData() {
     }
 
     interface ArrayChecker {
-        void check(VarHandle handle, MemoryAddress addr, long index);
+        void check(VarHandle handle, MemorySegment segment, long index);
 
-        ArrayChecker BYTE = (handle, addr, i) -> {
-            handle.set(addr, i, (byte)i);
-            assertEquals(i, (byte)handle.get(addr, i));
+        ArrayChecker BYTE = (handle, segment, i) -> {
+            handle.set(segment, i, (byte)i);
+            assertEquals(i, (byte)handle.get(segment, i));
         };
 
-        ArrayChecker SHORT = (handle, addr, i) -> {
-            handle.set(addr, i, (short)i);
-            assertEquals(i, (short)handle.get(addr, i));
+        ArrayChecker SHORT = (handle, segment, i) -> {
+            handle.set(segment, i, (short)i);
+            assertEquals(i, (short)handle.get(segment, i));
         };
 
-        ArrayChecker CHAR = (handle, addr, i) -> {
-            handle.set(addr, i, (char)i);
-            assertEquals(i, (char)handle.get(addr, i));
+        ArrayChecker CHAR = (handle, segment, i) -> {
+            handle.set(segment, i, (char)i);
+            assertEquals(i, (char)handle.get(segment, i));
         };
 
-        ArrayChecker INT = (handle, addr, i) -> {
-            handle.set(addr, i, (int)i);
-            assertEquals(i, (int)handle.get(addr, i));
+        ArrayChecker INT = (handle, segment, i) -> {
+            handle.set(segment, i, (int)i);
+            assertEquals(i, (int)handle.get(segment, i));
         };
 
-        ArrayChecker LONG = (handle, addr, i) -> {
-            handle.set(addr, i, (long)i);
-            assertEquals(i, (long)handle.get(addr, i));
+        ArrayChecker LONG = (handle, segment, i) -> {
+            handle.set(segment, i, (long)i);
+            assertEquals(i, (long)handle.get(segment, i));
         };
 
-        ArrayChecker FLOAT = (handle, addr, i) -> {
-            handle.set(addr, i, (float)i);
-            assertEquals((float)i, (float)handle.get(addr, i));
+        ArrayChecker FLOAT = (handle, segment, i) -> {
+            handle.set(segment, i, (float)i);
+            assertEquals((float)i, (float)handle.get(segment, i));
         };
 
-        ArrayChecker DOUBLE = (handle, addr, i) -> {
-            handle.set(addr, i, (double)i);
-            assertEquals((double)i, (double)handle.get(addr, i));
+        ArrayChecker DOUBLE = (handle, segment, i) -> {
+            handle.set(segment, i, (double)i);
+            assertEquals((double)i, (double)handle.get(segment, i));
         };
     }
 
@@ -415,41 +412,41 @@ public Object[][] createMatrixData() {
     }
 
     interface MatrixChecker {
-        void check(VarHandle handle, MemoryAddress addr, long row, long col);
+        void check(VarHandle handle, MemorySegment segment, long row, long col);
 
-        MatrixChecker BYTE = (handle, addr, r, c) -> {
-            handle.set(addr, r, c, (byte)(r + c));
-            assertEquals(r + c, (byte)handle.get(addr, r, c));
+        MatrixChecker BYTE = (handle, segment, r, c) -> {
+            handle.set(segment, r, c, (byte)(r + c));
+            assertEquals(r + c, (byte)handle.get(segment, r, c));
         };
 
-        MatrixChecker SHORT = (handle, addr, r, c) -> {
-            handle.set(addr, r, c, (short)(r + c));
-            assertEquals(r + c, (short)handle.get(addr, r, c));
+        MatrixChecker SHORT = (handle, segment, r, c) -> {
+            handle.set(segment, r, c, (short)(r + c));
+            assertEquals(r + c, (short)handle.get(segment, r, c));
         };
 
-        MatrixChecker CHAR = (handle, addr, r, c) -> {
-            handle.set(addr, r, c, (char)(r + c));
-            assertEquals(r + c, (char)handle.get(addr, r, c));
+        MatrixChecker CHAR = (handle, segment, r, c) -> {
+            handle.set(segment, r, c, (char)(r + c));
+            assertEquals(r + c, (char)handle.get(segment, r, c));
         };
 
-        MatrixChecker INT = (handle, addr, r, c) -> {
-            handle.set(addr, r, c, (int)(r + c));
-            assertEquals(r + c, (int)handle.get(addr, r, c));
+        MatrixChecker INT = (handle, segment, r, c) -> {
+            handle.set(segment, r, c, (int)(r + c));
+            assertEquals(r + c, (int)handle.get(segment, r, c));
         };
 
-        MatrixChecker LONG = (handle, addr, r, c) -> {
-            handle.set(addr, r, c, r + c);
-            assertEquals(r + c, (long)handle.get(addr, r, c));
+        MatrixChecker LONG = (handle, segment, r, c) -> {
+            handle.set(segment, r, c, r + c);
+            assertEquals(r + c, (long)handle.get(segment, r, c));
         };
 
-        MatrixChecker FLOAT = (handle, addr, r, c) -> {
-            handle.set(addr, r, c, (float)(r + c));
-            assertEquals((float)(r + c), (float)handle.get(addr, r, c));
+        MatrixChecker FLOAT = (handle, segment, r, c) -> {
+            handle.set(segment, r, c, (float)(r + c));
+            assertEquals((float)(r + c), (float)handle.get(segment, r, c));
         };
 
-        MatrixChecker DOUBLE = (handle, addr, r, c) -> {
-            handle.set(addr, r, c, (double)(r + c));
-            assertEquals((double)(r + c), (double)handle.get(addr, r, c));
+        MatrixChecker DOUBLE = (handle, segment, r, c) -> {
+            handle.set(segment, r, c, (double)(r + c));
+            assertEquals((double)(r + c), (double)handle.get(segment, r, c));
         };
     }
 
diff --git a/test/jdk/java/foreign/TestMemoryAlignment.java b/test/jdk/java/foreign/TestMemoryAlignment.java
index 5fa7da33c00d0..2b6ee427151d6 100644
--- a/test/jdk/java/foreign/TestMemoryAlignment.java
+++ b/test/jdk/java/foreign/TestMemoryAlignment.java
@@ -31,7 +31,6 @@
 
 import jdk.incubator.foreign.GroupLayout;
 import jdk.incubator.foreign.MemoryLayout.PathElement;
-import jdk.incubator.foreign.MemoryAddress;
 import jdk.incubator.foreign.MemorySegment;
 import jdk.incubator.foreign.SequenceLayout;
 import jdk.incubator.foreign.ValueLayout;
@@ -51,9 +50,8 @@ public void testAlignedAccess(long align) {
         assertEquals(aligned.bitAlignment(), align); //unreasonable alignment here, to make sure access throws
         VarHandle vh = aligned.varHandle(int.class);
         try (MemorySegment segment = MemorySegment.allocateNative(aligned)) {
-            MemoryAddress addr = segment.baseAddress();
-            vh.set(addr, -42);
-            int val = (int)vh.get(addr);
+            vh.set(segment, -42);
+            int val = (int)vh.get(segment);
             assertEquals(val, -42);
         }
     }
@@ -67,8 +65,7 @@ public void testUnalignedAccess(long align) {
         assertEquals(alignedGroup.bitAlignment(), align);
         VarHandle vh = aligned.varHandle(int.class);
         try (MemorySegment segment = MemorySegment.allocateNative(alignedGroup)) {
-            MemoryAddress addr = segment.baseAddress();
-            vh.set(addr.addOffset(1L), -42);
+            vh.set(segment.asSlice(1L), -42);
             assertEquals(align, 8); //this is the only case where access is aligned
         } catch (IllegalStateException ex) {
             assertNotEquals(align, 8); //if align != 8, access is always unaligned
@@ -94,9 +91,8 @@ public void testUnalignedSequence(long align) {
         try {
             VarHandle vh = layout.varHandle(int.class, PathElement.sequenceElement());
             try (MemorySegment segment = MemorySegment.allocateNative(layout)) {
-                MemoryAddress addr = segment.baseAddress();
                 for (long i = 0 ; i < 5 ; i++) {
-                    vh.set(addr, i, -42);
+                    vh.set(segment, i, -42);
                 }
             }
         } catch (UnsupportedOperationException ex) {
@@ -118,13 +114,12 @@ public void testPackedAccess() {
         VarHandle vh_s = g.varHandle(short.class, PathElement.groupElement("b"));
         VarHandle vh_i = g.varHandle(int.class, PathElement.groupElement("c"));
         try (MemorySegment segment = MemorySegment.allocateNative(g)) {
-            MemoryAddress addr = segment.baseAddress();
-            vh_c.set(addr, Byte.MIN_VALUE);
-            assertEquals(vh_c.get(addr), Byte.MIN_VALUE);
-            vh_s.set(addr, Short.MIN_VALUE);
-            assertEquals(vh_s.get(addr), Short.MIN_VALUE);
-            vh_i.set(addr, Integer.MIN_VALUE);
-            assertEquals(vh_i.get(addr), Integer.MIN_VALUE);
+            vh_c.set(segment, Byte.MIN_VALUE);
+            assertEquals(vh_c.get(segment), Byte.MIN_VALUE);
+            vh_s.set(segment, Short.MIN_VALUE);
+            assertEquals(vh_s.get(segment), Short.MIN_VALUE);
+            vh_i.set(segment, Integer.MIN_VALUE);
+            assertEquals(vh_i.get(segment), Integer.MIN_VALUE);
         }
     }
 
diff --git a/test/jdk/java/foreign/TestMemoryCopy.java b/test/jdk/java/foreign/TestMemoryCopy.java
index b11bd52073399..4e5bfc974b9be 100644
--- a/test/jdk/java/foreign/TestMemoryCopy.java
+++ b/test/jdk/java/foreign/TestMemoryCopy.java
@@ -27,7 +27,6 @@
  * @run testng TestMemoryCopy
  */
 
-import jdk.incubator.foreign.MemoryAddress;
 import jdk.incubator.foreign.MemoryLayouts;
 import jdk.incubator.foreign.MemorySegment;
 import org.testng.annotations.DataProvider;
@@ -46,21 +45,19 @@ public class TestMemoryCopy {
 
     @Test(dataProvider = "slices")
     public void testCopy(SegmentSlice s1, SegmentSlice s2) {
-        MemoryAddress addr1 = s1.segment.baseAddress();
-        MemoryAddress addr2 = s2.segment.baseAddress();
         int size = Math.min(s1.size(), s2.size());
         //prepare source and target segments
         for (int i = 0 ; i < size ; i++) {
-            BYTE_HANDLE.set(addr2.addOffset(i), (byte)0);
+            BYTE_HANDLE.set(s2.segment.asSlice(i), (byte)0);
         }
         for (int i = 0 ; i < size ; i++) {
-            BYTE_HANDLE.set(addr1.addOffset(i), (byte) i);
+            BYTE_HANDLE.set(s1.segment.asSlice(i), (byte) i);
         }
         //perform copy
         s2.segment.copyFrom(s1.segment.asSlice(0, size));
         //check that copy actually worked
         for (int i = 0 ; i < size ; i++) {
-            assertEquals((byte)i, BYTE_HANDLE.get(addr2.addOffset(i)));
+            assertEquals((byte)i, BYTE_HANDLE.get(s2.segment.asSlice(i)));
         }
     }
 
diff --git a/test/jdk/java/foreign/TestMemoryHandleAsUnsigned.java b/test/jdk/java/foreign/TestMemoryHandleAsUnsigned.java
index f601d9683c7fa..a0678a7083b18 100644
--- a/test/jdk/java/foreign/TestMemoryHandleAsUnsigned.java
+++ b/test/jdk/java/foreign/TestMemoryHandleAsUnsigned.java
@@ -59,10 +59,10 @@ public void testUnsignedIntToByte(int intValue) {
         VarHandle intHandle = MemoryHandles.asUnsigned(byteHandle, int.class);
 
         try (MemorySegment segment = MemorySegment.allocateNative(layout)) {
-            intHandle.set(segment.baseAddress(), intValue);
+            intHandle.set(segment, intValue);
             int expectedIntValue = Byte.toUnsignedInt(byteValue);
-            assertEquals((int) intHandle.get(segment.baseAddress()), expectedIntValue);
-            assertEquals((byte) byteHandle.get(segment.baseAddress()), byteValue);
+            assertEquals((int) intHandle.get(segment), expectedIntValue);
+            assertEquals((byte) byteHandle.get(segment), byteValue);
         }
     }
 
@@ -81,10 +81,10 @@ public void testUnsignedLongToByte(long longValue) {
         VarHandle longHandle = MemoryHandles.asUnsigned(byteHandle, long.class);
 
         try (MemorySegment segment = MemorySegment.allocateNative(layout)) {
-            longHandle.set(segment.baseAddress(), longValue);
+            longHandle.set(segment, longValue);
             long expectedLongValue = Byte.toUnsignedLong(byteValue);
-            assertEquals((long) longHandle.get(segment.baseAddress()), expectedLongValue);
-            assertEquals((byte) byteHandle.get(segment.baseAddress()), byteValue);
+            assertEquals((long) longHandle.get(segment), expectedLongValue);
+            assertEquals((byte) byteHandle.get(segment), byteValue);
         }
     }
 
@@ -103,10 +103,10 @@ public void testUnsignedIntToShort(int intValue) {
         VarHandle intHandle = MemoryHandles.asUnsigned(shortHandle, int.class);
 
         try (MemorySegment segment = MemorySegment.allocateNative(layout)) {
-            intHandle.set(segment.baseAddress(), intValue);
+            intHandle.set(segment, intValue);
             int expectedIntValue = Short.toUnsignedInt(shortValue);
-            assertEquals((int) intHandle.get(segment.baseAddress()), expectedIntValue);
-            assertEquals((short) shortHandle.get(segment.baseAddress()), shortValue);
+            assertEquals((int) intHandle.get(segment), expectedIntValue);
+            assertEquals((short) shortHandle.get(segment), shortValue);
         }
     }
 
@@ -125,10 +125,10 @@ public void testUnsignedLongToShort(long longValue) {
         VarHandle longHandle = MemoryHandles.asUnsigned(shortHandle, long.class);
 
         try (MemorySegment segment = MemorySegment.allocateNative(layout)) {
-            longHandle.set(segment.baseAddress(), longValue);
+            longHandle.set(segment, longValue);
             long expectedLongValue = Short.toUnsignedLong(shortValue);
-            assertEquals((long) longHandle.get(segment.baseAddress()), expectedLongValue);
-            assertEquals((short) shortHandle.get(segment.baseAddress()), shortValue);
+            assertEquals((long) longHandle.get(segment), expectedLongValue);
+            assertEquals((short) shortHandle.get(segment), shortValue);
         }
     }
 
@@ -151,10 +151,10 @@ public void testUnsignedLongToInt(long longValue) {
         VarHandle longHandle = MemoryHandles.asUnsigned(intHandle, long.class);
 
         try (MemorySegment segment = MemorySegment.allocateNative(layout)) {
-            longHandle.set(segment.baseAddress(), longValue);
+            longHandle.set(segment, longValue);
             long expectedLongValue = Integer.toUnsignedLong(intValue);
-            assertEquals((long) longHandle.get(segment.baseAddress()), expectedLongValue);
-            assertEquals((int) intHandle.get(segment.baseAddress()), intValue);
+            assertEquals((long) longHandle.get(segment), expectedLongValue);
+            assertEquals((int) intHandle.get(segment), intValue);
         }
     }
 
@@ -165,10 +165,10 @@ public void testCoordinatesSequenceLayout() {
         VarHandle intHandle = MemoryHandles.asUnsigned(byteHandle, int.class);
 
         try (MemorySegment segment = MemorySegment.allocateNative(layout)) {
-            intHandle.set(segment.baseAddress(), 0L, (int) -1);
-            assertEquals((int) intHandle.get(segment.baseAddress(), 0L), 255);
-            intHandle.set(segment.baseAddress(), 1L, (int) 200);
-            assertEquals((int) intHandle.get(segment.baseAddress(), 1L), 200);
+            intHandle.set(segment, 0L, (int) -1);
+            assertEquals((int) intHandle.get(segment, 0L), 255);
+            intHandle.set(segment, 1L, (int) 200);
+            assertEquals((int) intHandle.get(segment, 1L), 200);
         }
     }
 
@@ -176,19 +176,18 @@ public void testCoordinatesSequenceLayout() {
     public void testCoordinatesStride() {
         byte[] arr = { 0, 0, (byte) 129, 0 };
         MemorySegment segment = MemorySegment.ofArray(arr);
-        MemoryAddress addr = segment.baseAddress();
 
         {
-            VarHandle byteHandle = MemoryHandles.varHandle(byte.class, ByteOrder.nativeOrder());
+            VarHandle byteHandle = MemoryLayout.ofSequence(MemoryLayouts.JAVA_BYTE)
+                    .varHandle(byte.class, PathElement.sequenceElement());
             VarHandle intHandle = MemoryHandles.asUnsigned(byteHandle, int.class);
-            VarHandle strideHandle = MemoryHandles.withStride(intHandle, 1);
-            assertEquals((int) strideHandle.get(addr, 2L), 129);
+            assertEquals((int) intHandle.get(segment, 2L), 129);
         }
         {
-            VarHandle byteHandle = MemoryHandles.varHandle(byte.class, ByteOrder.nativeOrder());
-            VarHandle strideHandle = MemoryHandles.withStride(byteHandle, 1);
-            VarHandle intHandle = MemoryHandles.asUnsigned(strideHandle, int.class);
-            assertEquals((int) intHandle.get(addr, 2L), 129);
+            VarHandle byteHandle = MemoryLayout.ofSequence(MemoryLayouts.JAVA_BYTE)
+                    .varHandle(byte.class, PathElement.sequenceElement());
+            VarHandle intHandle = MemoryHandles.asUnsigned(byteHandle, int.class);
+            assertEquals((int) intHandle.get(segment, 2L), 129);
         }
     }
 
diff --git a/test/jdk/java/foreign/TestMismatch.java b/test/jdk/java/foreign/TestMismatch.java
index 5c361a82fe985..b5e9ca3a60c9a 100644
--- a/test/jdk/java/foreign/TestMismatch.java
+++ b/test/jdk/java/foreign/TestMismatch.java
@@ -23,7 +23,7 @@
 
 /*
  * @test
- * @run testng TestMismatch
+ * @run testng/othervm -XX:MaxDirectMemorySize=5000000000 TestMismatch
  */
 
 import java.lang.invoke.VarHandle;
@@ -47,9 +47,8 @@ public class TestMismatch {
 
     // stores a increasing sequence of values into the memory of the given segment
     static MemorySegment initializeSegment(MemorySegment segment) {
-        MemoryAddress addr = segment.baseAddress();
         for (int i = 0 ; i < segment.byteSize() ; i++) {
-            BYTE_HANDLE.set(addr.addOffset(i), (byte)i);
+            BYTE_HANDLE.set(segment.asSlice(i), (byte)i);
         }
         return segment;
     }
@@ -81,7 +80,7 @@ public void testDifferentValues(MemorySegment s1, MemorySegment s2) {
 
         for (long i = s2.byteSize() -1 ; i >= 0; i--) {
             long expectedMismatchOffset = i;
-            BYTE_HANDLE.set(s2.baseAddress().addOffset(i), (byte) 0xFF);
+            BYTE_HANDLE.set(s2.asSlice(i), (byte) 0xFF);
 
             if (s1.byteSize() == s2.byteSize()) {
                 assertEquals(s1.mismatch(s2), expectedMismatchOffset);
@@ -135,7 +134,7 @@ private void testLargeAcrossMaxBoundary(MemorySegment s1, MemorySegment s2) {
 
     private void testLargeMismatchAcrossMaxBoundary(MemorySegment s1, MemorySegment s2) {
         for (long i = s2.byteSize() -1 ; i >= Integer.MAX_VALUE - 10L; i--) {
-            BYTE_HANDLE.set(s2.baseAddress().addOffset(i), (byte) 0xFF);
+            BYTE_HANDLE.set(s2.asSlice(i), (byte) 0xFF);
             long expectedMismatchOffset = i;
             assertEquals(s1.mismatch(s2), expectedMismatchOffset);
             assertEquals(s2.mismatch(s1), expectedMismatchOffset);
diff --git a/test/jdk/java/foreign/TestNative.java b/test/jdk/java/foreign/TestNative.java
index 5d7a37e010b9b..c922f4bf70391 100644
--- a/test/jdk/java/foreign/TestNative.java
+++ b/test/jdk/java/foreign/TestNative.java
@@ -24,18 +24,17 @@
 
 /*
  * @test
- * @modules java.base/jdk.internal.misc
- *          jdk.incubator.foreign/jdk.internal.foreign
+ * @modules jdk.incubator.foreign/jdk.internal.foreign
  * @run testng/othervm -Dforeign.restricted=permit TestNative
  */
 
+import jdk.incubator.foreign.MemoryAccess;
 import jdk.incubator.foreign.MemoryAddress;
 import jdk.incubator.foreign.MemoryLayout;
 import jdk.incubator.foreign.MemoryLayout.PathElement;
 import jdk.incubator.foreign.MemoryLayouts;
 import jdk.incubator.foreign.MemorySegment;
 import jdk.incubator.foreign.SequenceLayout;
-import jdk.internal.misc.Unsafe;
 import org.testng.annotations.DataProvider;
 import org.testng.annotations.Test;
 
@@ -58,12 +57,6 @@
 
 public class TestNative {
 
-    static Unsafe UNSAFE;
-
-    static {
-        UNSAFE = Unsafe.getUnsafe();
-    }
-
     static SequenceLayout bytes = MemoryLayout.ofSequence(100,
             MemoryLayouts.JAVA_BYTE.withOrder(ByteOrder.nativeOrder())
     );
@@ -100,24 +93,24 @@ public class TestNative {
     static VarHandle longHandle = doubles.varHandle(long.class, PathElement.sequenceElement());
     static VarHandle doubleHandle = longs.varHandle(double.class, PathElement.sequenceElement());
 
-    static void initBytes(MemoryAddress base, SequenceLayout seq, BiConsumer handleSetter) {
+    static void initBytes(MemorySegment base, SequenceLayout seq, BiConsumer handleSetter) {
         for (long i = 0; i < seq.elementCount().getAsLong() ; i++) {
             handleSetter.accept(base, i);
         }
     }
 
-    static  void checkBytes(MemoryAddress base, SequenceLayout layout,
-                                              BiFunction handleExtractor,
+    static  void checkBytes(MemorySegment base, SequenceLayout layout,
+                                              BiFunction handleExtractor,
                                               Function bufferFactory,
                                               BiFunction nativeBufferExtractor,
                                               BiFunction nativeRawExtractor) {
         long nelems = layout.elementCount().getAsLong();
-        ByteBuffer bb = base.segment().asSlice(base.segmentOffset(), (int)layout.byteSize()).asByteBuffer();
+        ByteBuffer bb = base.asByteBuffer();
         Z z = bufferFactory.apply(bb);
         for (long i = 0 ; i < nelems ; i++) {
             Object handleValue = handleExtractor.apply(base, i);
             Object bufferValue = nativeBufferExtractor.apply(z, (int)i);
-            Object rawValue = nativeRawExtractor.apply(base.toRawLongValue(), (int)i);
+            Object rawValue = nativeRawExtractor.apply(base.address().toRawLongValue(), (int)i);
             if (handleValue instanceof Number) {
                 assertEquals(((Number)handleValue).longValue(), i);
                 assertEquals(((Number)bufferValue).longValue(), i);
@@ -152,11 +145,10 @@ static  void checkBytes(MemoryAddress base, SequenceLayout lay
     public static native void free(long address);
 
     @Test(dataProvider="nativeAccessOps")
-    public void testNativeAccess(Consumer checker, Consumer initializer, SequenceLayout seq) {
+    public void testNativeAccess(Consumer checker, Consumer initializer, SequenceLayout seq) {
         try (MemorySegment segment = MemorySegment.allocateNative(seq)) {
-            MemoryAddress address = segment.baseAddress();
-            initializer.accept(address);
-            checker.accept(address);
+            initializer.accept(segment);
+            checker.accept(segment);
         }
     }
 
@@ -175,71 +167,79 @@ public void testNativeCapacity(Function bufferFunction, int
     @Test
     public void testDefaultAccessModes() {
         MemoryAddress addr = MemoryAddress.ofLong(allocate(12));
-        MemorySegment mallocSegment = MemorySegment.ofNativeRestricted(addr, 12, null,
-                () -> free(addr.toRawLongValue()), null);
+        MemorySegment mallocSegment = addr.asSegmentRestricted(12, () -> free(addr.toRawLongValue()), null);
         try (MemorySegment segment = mallocSegment) {
             assertTrue(segment.hasAccessModes(ALL_ACCESS));
             assertEquals(segment.accessModes(), ALL_ACCESS);
         }
     }
 
+    @Test
+    public void testDefaultAccessModesEverthing() {
+        MemorySegment everything = MemorySegment.ofNativeRestricted();
+        assertTrue(everything.hasAccessModes(READ | WRITE));
+        assertEquals(everything.accessModes(), READ | WRITE);
+    }
+
     @Test
     public void testMallocSegment() {
         MemoryAddress addr = MemoryAddress.ofLong(allocate(12));
-        assertNull(addr.segment());
-        MemorySegment mallocSegment = MemorySegment.ofNativeRestricted(addr, 12, null,
-                () -> free(addr.toRawLongValue()), null);
+        MemorySegment mallocSegment = addr.asSegmentRestricted(12, () -> free(addr.toRawLongValue()), null);
         assertEquals(mallocSegment.byteSize(), 12);
         mallocSegment.close(); //free here
         assertTrue(!mallocSegment.isAlive());
     }
 
+    @Test
+    public void testEverythingSegment() {
+        MemoryAddress addr = MemoryAddress.ofLong(allocate(4));
+        MemorySegment everything = MemorySegment.ofNativeRestricted();
+        MemoryAccess.setIntAtOffset(everything, addr.toRawLongValue(), 42);
+        assertEquals(MemoryAccess.getIntAtOffset(everything, addr.toRawLongValue()), 42);
+        free(addr.toRawLongValue());
+    }
+
     @Test(expectedExceptions = IllegalArgumentException.class)
     public void testBadResize() {
         try (MemorySegment segment = MemorySegment.allocateNative(4)) {
-            MemorySegment.ofNativeRestricted(segment.baseAddress(), 0, null, null, null);
+            segment.address().asSegmentRestricted(0);
         }
     }
 
-    @Test(expectedExceptions = NullPointerException.class)
-    public void testNullUnsafeSegment() {
-        MemorySegment.ofNativeRestricted(null, 10, null, null, null);
-    }
-
     static {
         System.loadLibrary("NativeAccess");
     }
 
     @DataProvider(name = "nativeAccessOps")
     public Object[][] nativeAccessOps() {
-        Consumer byteInitializer =
+        Consumer byteInitializer =
                 (base) -> initBytes(base, bytes, (addr, pos) -> byteHandle.set(addr, pos, (byte)(long)pos));
-        Consumer charInitializer =
+        Consumer charInitializer =
                 (base) -> initBytes(base, chars, (addr, pos) -> charHandle.set(addr, pos, (char)(long)pos));
-        Consumer shortInitializer =
+        Consumer shortInitializer =
                 (base) -> initBytes(base, shorts, (addr, pos) -> shortHandle.set(addr, pos, (short)(long)pos));
-        Consumer intInitializer =
+        Consumer intInitializer =
                 (base) -> initBytes(base, ints, (addr, pos) -> intHandle.set(addr, pos, (int)(long)pos));
-        Consumer floatInitializer =
+        Consumer floatInitializer =
                 (base) -> initBytes(base, floats, (addr, pos) -> floatHandle.set(addr, pos, (float)(long)pos));
-        Consumer longInitializer =
+        Consumer longInitializer =
                 (base) -> initBytes(base, longs, (addr, pos) -> longHandle.set(addr, pos, (long)pos));
-        Consumer doubleInitializer =
+        Consumer doubleInitializer =
                 (base) -> initBytes(base, doubles, (addr, pos) -> doubleHandle.set(addr, pos, (double)(long)pos));
 
-        Consumer byteChecker =
+        Consumer byteChecker =
                 (base) -> checkBytes(base, bytes, byteHandle::get, bb -> bb, TestNative::getByteBuffer, TestNative::getByteRaw);
-        Consumer charChecker =
+        Consumer charChecker =
                 (base) -> checkBytes(base, chars, charHandle::get, ByteBuffer::asCharBuffer, TestNative::getCharBuffer, TestNative::getCharRaw);
-        Consumer shortChecker =
+        Consumer shortChecker =
                 (base) -> checkBytes(base, shorts, shortHandle::get, ByteBuffer::asShortBuffer, TestNative::getShortBuffer, TestNative::getShortRaw);
-        Consumer intChecker =
+        Consumer intChecker =
                 (base) -> checkBytes(base, ints, intHandle::get, ByteBuffer::asIntBuffer, TestNative::getIntBuffer, TestNative::getIntRaw);
-        Consumer floatChecker =
+        Consumer floatChecker =
                 (base) -> checkBytes(base, floats, floatHandle::get, ByteBuffer::asFloatBuffer, TestNative::getFloatBuffer, TestNative::getFloatRaw);
-        Consumer longChecker =
+        Consumer longChecker =
                 (base) -> checkBytes(base, longs, longHandle::get, ByteBuffer::asLongBuffer, TestNative::getLongBuffer, TestNative::getLongRaw);
-        Consumer doubleChecker =
+        Consumer doubleChecker =
                 (base) -> checkBytes(base, doubles, doubleHandle::get, ByteBuffer::asDoubleBuffer, TestNative::getDoubleBuffer, TestNative::getDoubleRaw);
 
         return new Object[][]{
diff --git a/test/jdk/java/foreign/TestNoForeignUnsafeOverride.java b/test/jdk/java/foreign/TestNoForeignUnsafeOverride.java
index ac7752e9f5cd8..072506e42bf78 100644
--- a/test/jdk/java/foreign/TestNoForeignUnsafeOverride.java
+++ b/test/jdk/java/foreign/TestNoForeignUnsafeOverride.java
@@ -29,8 +29,8 @@
  */
 
 import jdk.incubator.foreign.MemoryAddress;
-import jdk.incubator.foreign.MemorySegment;
 
+import jdk.incubator.foreign.MemorySegment;
 import org.testng.annotations.Test;
 
 public class TestNoForeignUnsafeOverride {
@@ -40,6 +40,6 @@ public class TestNoForeignUnsafeOverride {
 
     @Test(expectedExceptions = IllegalAccessError.class)
     public void testUnsafeAccess() {
-        MemorySegment.ofNativeRestricted(MemoryAddress.ofLong(42), 10, null, null, null);
+        MemorySegment.ofNativeRestricted();
     }
 }
diff --git a/test/jdk/java/foreign/TestRebase.java b/test/jdk/java/foreign/TestRebase.java
index de7c4777a9800..c30bc3ec0689d 100644
--- a/test/jdk/java/foreign/TestRebase.java
+++ b/test/jdk/java/foreign/TestRebase.java
@@ -27,6 +27,7 @@
  * @run testng TestRebase
  */
 
+import jdk.incubator.foreign.MemoryAccess;
 import jdk.incubator.foreign.MemoryAddress;
 import jdk.incubator.foreign.MemoryLayouts;
 import jdk.incubator.foreign.MemorySegment;
@@ -44,35 +45,33 @@
 
 public class TestRebase {
 
-    static VarHandle BYTE_VH = MemoryLayouts.JAVA_BYTE.varHandle(byte.class);
-
     @Test(dataProvider = "slices")
     public void testRebase(SegmentSlice s1, SegmentSlice s2) {
         if (s1.contains(s2)) {
             //check that an address and its rebased counterpart point to same element
-            MemoryAddress base = s2.segment.baseAddress();
-            MemoryAddress rebased = base.rebase(s1.segment);
+            MemoryAddress base = s2.segment.address();
+            long offset = base.segmentOffset(s1.segment);
             for (int i = 0; i < s2.size(); i++) {
-                int expected = (int) BYTE_VH.get(base.addOffset(i));
-                int found = (int) BYTE_VH.get(rebased.addOffset(i));
+                int expected = MemoryAccess.getByteAtOffset(s2.segment, i);
+                int found = (int)MemoryAccess.getByteAtOffset(s1.segment, i + offset);
                 assertEquals(found, expected);
             }
         } else if (s1.kind != s2.kind) {
             // check that rebase s1 to s2 fails
             try {
-                s1.segment.baseAddress().rebase(s2.segment);
+                s1.segment.address().segmentOffset(s2.segment);
                 fail("Rebase unexpectedly passed!");
             } catch (IllegalArgumentException ex) {
                 assertTrue(true);
             }
         } else if (!s2.contains(s1)) {
             //disjoint segments - check that rebased address is out of bounds
-            MemoryAddress base = s2.segment.baseAddress();
-            MemoryAddress rebased = base.rebase(s1.segment);
+            MemoryAddress base = s2.segment.address();
+            long offset = base.segmentOffset(s1.segment);
             for (int i = 0; i < s2.size(); i++) {
-                BYTE_VH.get(base.addOffset(i));
+                MemoryAccess.getByteAtOffset(s2.segment, i);
                 try {
-                    BYTE_VH.get(rebased.addOffset(i));
+                    MemoryAccess.getByteAtOffset(s1.segment, i + offset);
                     fail("Rebased address on a disjoint segment is not out of bounds!");
                 } catch (IndexOutOfBoundsException ex) {
                     assertTrue(true);
@@ -129,7 +128,7 @@ static Object[][] slices() {
             //init root segment
             MemorySegment segment = kind.makeSegment(16);
             for (int i = 0 ; i < 16 ; i++) {
-                BYTE_VH.set(segment.baseAddress().addOffset(i), (byte)i);
+                MemoryAccess.setByteAtOffset(segment, i, (byte)i);
             }
             //compute all slices
             for (int size : sizes) {
diff --git a/test/jdk/java/foreign/TestSegments.java b/test/jdk/java/foreign/TestSegments.java
index ffd8a1cd2b4d1..a582690e48a37 100644
--- a/test/jdk/java/foreign/TestSegments.java
+++ b/test/jdk/java/foreign/TestSegments.java
@@ -26,7 +26,6 @@
  * @run testng TestSegments
  */
 
-import jdk.incubator.foreign.MemoryAddress;
 import jdk.incubator.foreign.MemoryLayout;
 import jdk.incubator.foreign.MemoryLayouts;
 import jdk.incubator.foreign.MemorySegment;
@@ -34,13 +33,13 @@
 import org.testng.annotations.Test;
 
 import java.lang.invoke.VarHandle;
+import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
 import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Spliterator;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.LongFunction;
@@ -74,9 +73,6 @@ public void testOpOutsideConfinement(SegmentMember member) throws Throwable {
             Thread t = new Thread(() -> {
                 try {
                     Object o = member.method.invoke(segment, member.params);
-                    if (member.method.getName().equals("acquire")) {
-                        ((MemorySegment)o).close();
-                    }
                 } catch (ReflectiveOperationException ex) {
                     throw new IllegalStateException(ex);
                 }
@@ -88,38 +84,33 @@ public void testOpOutsideConfinement(SegmentMember member) throws Throwable {
         }
     }
 
+    @Test(dataProvider = "segmentOperations")
+    public void testOpAfterClose(SegmentMember member) throws Throwable {
+        MemorySegment segment = MemorySegment.allocateNative(4);
+        segment.close();
+        try {
+            Object o = member.method.invoke(segment, member.params);
+            assertFalse(member.isConfined());
+        } catch (InvocationTargetException ex) {
+            assertTrue(member.isConfined());
+            Throwable target = ex.getTargetException();
+            assertTrue(target instanceof NullPointerException ||
+                          target instanceof UnsupportedOperationException ||
+                          target instanceof IllegalStateException);
+        }
+    }
+
     @Test
     public void testNativeSegmentIsZeroed() {
         VarHandle byteHandle = MemoryLayout.ofSequence(MemoryLayouts.JAVA_BYTE)
                 .varHandle(byte.class, MemoryLayout.PathElement.sequenceElement());
         try (MemorySegment segment = MemorySegment.allocateNative(1000)) {
             for (long i = 0 ; i < segment.byteSize() ; i++) {
-                assertEquals(0, (byte)byteHandle.get(segment.baseAddress(), i));
+                assertEquals(0, (byte)byteHandle.get(segment, i));
             }
         }
     }
 
-    @Test
-    public void testNothingSegmentAccess() {
-        VarHandle longHandle = MemoryLayouts.JAVA_LONG.varHandle(long.class);
-        long[] values = { 0L, Integer.MAX_VALUE - 1, (long) Integer.MAX_VALUE + 1 };
-        for (long value : values) {
-            MemoryAddress addr = MemoryAddress.ofLong(value);
-            try {
-                longHandle.get(addr);
-            } catch (UnsupportedOperationException ex) {
-                assertTrue(ex.getMessage().contains("Required access mode"));
-            }
-        }
-    }
-
-    @Test(expectedExceptions = UnsupportedOperationException.class)
-    public void testNothingSegmentOffset() {
-        MemoryAddress addr = MemoryAddress.ofLong(42);
-        assertNull(addr.segment());
-        addr.segmentOffset();
-    }
-
     @Test
     public void testSlices() {
         VarHandle byteHandle = MemoryLayout.ofSequence(MemoryLayouts.JAVA_BYTE)
@@ -127,21 +118,16 @@ public void testSlices() {
         try (MemorySegment segment = MemorySegment.allocateNative(10)) {
             //init
             for (byte i = 0 ; i < segment.byteSize() ; i++) {
-                byteHandle.set(segment.baseAddress(), (long)i, i);
+                byteHandle.set(segment, (long)i, i);
             }
-            long start = 0;
-            MemoryAddress base = segment.baseAddress();
-            MemoryAddress last = base.addOffset(10);
-            while (!base.equals(last)) {
-                MemorySegment slice = segment.asSlice(base.segmentOffset(), 10 - start);
-                for (long i = start ; i < 10 ; i++) {
+            for (int offset = 0 ; offset < 10 ; offset++) {
+                MemorySegment slice = segment.asSlice(offset);
+                for (long i = offset ; i < 10 ; i++) {
                     assertEquals(
-                            byteHandle.get(segment.baseAddress(), i),
-                            byteHandle.get(slice.baseAddress(), i - start)
+                            byteHandle.get(segment, i),
+                            byteHandle.get(slice, i - offset)
                     );
                 }
-                base = base.addOffset(1);
-                start++;
             }
         }
     }
@@ -197,20 +183,20 @@ public void testFill(Supplier memorySegmentSupplier) {
             try (MemorySegment segment = memorySegmentSupplier.get()) {
                 segment.fill(value);
                 for (long l = 0; l < segment.byteSize(); l++) {
-                    assertEquals((byte) byteHandle.get(segment.baseAddress(), l), value);
+                    assertEquals((byte) byteHandle.get(segment, l), value);
                 }
 
                 // fill a slice
                 var sliceSegment = segment.asSlice(1, segment.byteSize() - 2).fill((byte) ~value);
                 for (long l = 0; l < sliceSegment.byteSize(); l++) {
-                    assertEquals((byte) byteHandle.get(sliceSegment.baseAddress(), l), ~value);
+                    assertEquals((byte) byteHandle.get(sliceSegment, l), ~value);
                 }
                 // assert enclosing slice
-                assertEquals((byte) byteHandle.get(segment.baseAddress(), 0L), value);
+                assertEquals((byte) byteHandle.get(segment, 0L), value);
                 for (long l = 1; l < segment.byteSize() - 2; l++) {
-                    assertEquals((byte) byteHandle.get(segment.baseAddress(), l), (byte) ~value);
+                    assertEquals((byte) byteHandle.get(segment, l), (byte) ~value);
                 }
-                assertEquals((byte) byteHandle.get(segment.baseAddress(), segment.byteSize() - 1L), value);
+                assertEquals((byte) byteHandle.get(segment, segment.byteSize() - 1L), value);
             }
         }
     }
@@ -319,8 +305,9 @@ MemoryLayout make(long size) {
     static Object[][] segmentMembers() {
         List members = new ArrayList<>();
         for (Method m : MemorySegment.class.getDeclaredMethods()) {
-            //skip statics and method declared in j.l.Object
-            if (m.getDeclaringClass().equals(Object.class) ||
+            //skip defaults, statics and method declared in j.l.Object
+            if (m.isDefault() ||
+                    m.getDeclaringClass().equals(Object.class) ||
                     (m.getModifiers() & Modifier.STATIC) != 0) continue;
             Object[] args = Stream.of(m.getParameterTypes())
                     .map(TestSegments::defaultValue)
@@ -335,12 +322,21 @@ static class SegmentMember {
         final Object[] params;
 
         final static List CONFINED_NAMES = List.of(
+                "address",
                 "close",
+                "share",
+                "handoff",
+                "registerCleaner",
                 "fill",
                 "copyFrom",
                 "mismatch",
                 "toByteArray",
-                "withOwnerThread"
+                "toCharArray",
+                "toShortArray",
+                "toIntArray",
+                "toFloatArray",
+                "toLongArray",
+                "toDoubleArray"
         );
 
         public SegmentMember(Method method, Object[] params) {
@@ -395,30 +391,10 @@ public Object[][] accessModes() {
     }
 
     enum AccessActions {
-        ACQUIRE(MemorySegment.ACQUIRE) {
+        SHARE(MemorySegment.SHARE) {
             @Override
             void run(MemorySegment segment) {
-                Spliterator spliterator =
-                        MemorySegment.spliterator(segment, MemoryLayout.ofSequence(segment.byteSize(), MemoryLayouts.JAVA_BYTE));
-                AtomicReference exception = new AtomicReference<>();
-                Runnable action = () -> {
-                    try {
-                        spliterator.tryAdvance(s -> { });
-                    } catch (RuntimeException e) {
-                        exception.set(e);
-                    }
-                };
-                Thread thread = new Thread(action);
-                thread.start();
-                try {
-                    thread.join();
-                } catch (InterruptedException ex) {
-                    throw new AssertionError(ex);
-                }
-                RuntimeException e = exception.get();
-                if (e != null) {
-                    throw e;
-                }
+                segment.share();
             }
         },
         CLOSE(MemorySegment.CLOSE) {
@@ -430,19 +406,19 @@ void run(MemorySegment segment) {
         READ(MemorySegment.READ) {
             @Override
             void run(MemorySegment segment) {
-                INT_HANDLE.get(segment.baseAddress());
+                INT_HANDLE.get(segment);
             }
         },
         WRITE(MemorySegment.WRITE) {
             @Override
             void run(MemorySegment segment) {
-                INT_HANDLE.set(segment.baseAddress(), 42);
+                INT_HANDLE.set(segment, 42);
             }
         },
         HANDOFF(MemorySegment.HANDOFF) {
             @Override
             void run(MemorySegment segment) {
-                segment.withOwnerThread(new Thread());
+                segment.handoff(new Thread());
             }
         };
 
diff --git a/test/jdk/java/foreign/TestSharedAccess.java b/test/jdk/java/foreign/TestSharedAccess.java
index 24243e52b827f..3e58a61c9f2d4 100644
--- a/test/jdk/java/foreign/TestSharedAccess.java
+++ b/test/jdk/java/foreign/TestSharedAccess.java
@@ -27,12 +27,8 @@
  * @run testng/othervm -Dforeign.restricted=permit TestSharedAccess
  */
 
-import jdk.incubator.foreign.MemoryAddress;
-import jdk.incubator.foreign.MemoryLayout;
-import jdk.incubator.foreign.MemoryLayouts;
-import jdk.incubator.foreign.MemorySegment;
-import jdk.incubator.foreign.SequenceLayout;
-import org.testng.annotations.Test;
+import jdk.incubator.foreign.*;
+import org.testng.annotations.*;
 
 import java.lang.invoke.VarHandle;
 import java.nio.ByteBuffer;
@@ -41,14 +37,10 @@
 import java.util.Spliterator;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.ExecutionException;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicReference;
-import java.util.function.Consumer;
 
-import static org.testng.Assert.assertEquals;
-import static org.testng.Assert.assertTrue;
-import static org.testng.Assert.fail;
+import static org.testng.Assert.*;
 
 public class TestSharedAccess {
 
@@ -59,17 +51,17 @@ public void testConfined() throws Throwable {
         Thread owner = Thread.currentThread();
         MemorySegment s = MemorySegment.allocateNative(4);
         AtomicReference confined = new AtomicReference<>(s);
-        setInt(s.baseAddress(), 42);
-        assertEquals(getInt(s.baseAddress()), 42);
+        setInt(s, 42);
+        assertEquals(getInt(s), 42);
         List threads = new ArrayList<>();
         for (int i = 0 ; i < 1000 ; i++) {
             threads.add(new Thread(() -> {
-                assertEquals(getInt(confined.get().baseAddress()), 42);
-                confined.set(confined.get().withOwnerThread(owner));
+                assertEquals(getInt(confined.get()), 42);
+                confined.set(confined.get().handoff(owner));
             }));
         }
         threads.forEach(t -> {
-            confined.set(confined.get().withOwnerThread(t));
+            confined.set(confined.get().handoff(t));
             t.start();
             try {
                 t.join();
@@ -83,9 +75,9 @@ public void testConfined() throws Throwable {
     @Test
     public void testShared() throws Throwable {
         SequenceLayout layout = MemoryLayout.ofSequence(1024, MemoryLayouts.JAVA_INT);
-        try (MemorySegment s = MemorySegment.allocateNative(layout)) {
+        try (MemorySegment s = MemorySegment.allocateNative(layout).share()) {
             for (int i = 0 ; i < layout.elementCount().getAsLong() ; i++) {
-                setInt(s.baseAddress().addOffset(i * 4), 42);
+                setInt(s.asSlice(i * 4), 42);
             }
             List threads = new ArrayList<>();
             List> spliterators = new ArrayList<>();
@@ -108,7 +100,7 @@ public void testShared() throws Throwable {
             for (Spliterator spliterator : spliterators) {
                 threads.add(new Thread(() -> {
                     spliterator.tryAdvance(local -> {
-                        assertEquals(getInt(local.baseAddress()), 42);
+                        assertEquals(getInt(local), 42);
                         accessCount.incrementAndGet();
                     });
                 }));
@@ -128,14 +120,13 @@ public void testShared() throws Throwable {
     @Test
     public void testSharedUnsafe() throws Throwable {
         try (MemorySegment s = MemorySegment.allocateNative(4)) {
-            setInt(s.baseAddress(), 42);
-            assertEquals(getInt(s.baseAddress()), 42);
+            setInt(s, 42);
+            assertEquals(getInt(s), 42);
             List threads = new ArrayList<>();
-            MemorySegment sharedSegment = MemorySegment.ofNativeRestricted(
-                    s.baseAddress(), s.byteSize(), null, null, null);
+            MemorySegment sharedSegment = s.address().asSegmentRestricted(s.byteSize()).share();
             for (int i = 0 ; i < 1000 ; i++) {
                 threads.add(new Thread(() -> {
-                    assertEquals(getInt(sharedSegment.baseAddress()), 42);
+                    assertEquals(getInt(sharedSegment), 42);
                 }));
             }
             threads.forEach(Thread::start);
@@ -149,65 +140,16 @@ public void testSharedUnsafe() throws Throwable {
         }
     }
 
-    @Test(expectedExceptions=IllegalStateException.class)
-    public void testBadCloseWithPendingAcquire() {
-        withAcquired(MemorySegment::close);
+    @Test(expectedExceptions=UnsupportedOperationException.class)
+    public void testBadHandoffNoAccess() {
+        MemorySegment.ofArray(new int[4])
+            .withAccessModes(MemorySegment.CLOSE).handoff(new Thread());
     }
 
-    @Test(expectedExceptions=IllegalStateException.class)
-    public void testBadCloseWithPendingAcquireBuffer() {
-        withAcquired(segment -> {
-            segment = MemorySegment.ofByteBuffer(segment.asByteBuffer()); // original segment is lost
-            segment.close(); // this should still fail
-        });
-    }
-
-    @Test(expectedExceptions=IllegalStateException.class)
-    public void testBadHandoffWithPendingAcquire() {
-        withAcquired(segment -> segment.withOwnerThread(new Thread()));
-    }
-
-    @Test(expectedExceptions=IllegalStateException.class)
-    public void testBadHandoffWithPendingAcquireBuffer() {
-        withAcquired(segment -> {
-            segment = MemorySegment.ofByteBuffer(segment.asByteBuffer()); // original segment is lost
-            segment.withOwnerThread(new Thread()); // this should still fail
-        });
-    }
-
-    @Test(expectedExceptions=IllegalArgumentException.class)
-    public void testBadHandoffSameThread() {
-        MemorySegment.ofArray(new int[4]).withOwnerThread(Thread.currentThread());
-    }
-
-    @Test(expectedExceptions=NullPointerException.class)
-    public void testBadHandoffNullThread() {
-        MemorySegment.ofArray(new int[4]).withOwnerThread(null);
-    }
-
-    private void withAcquired(Consumer acquiredAction) {
-        CountDownLatch holder = new CountDownLatch(1);
-        MemorySegment segment = MemorySegment.allocateNative(16);
-        Spliterator spliterator = MemorySegment.spliterator(segment,
-                MemoryLayout.ofSequence(16, MemoryLayouts.JAVA_BYTE));
-        CountDownLatch acquired = new CountDownLatch(1);
-        Runnable r = () -> spliterator.tryAdvance(s -> {
-            try {
-                acquired.countDown();
-                holder.await();
-            } catch (InterruptedException ex) {
-                throw new AssertionError(ex);
-            }
-        });
-        new Thread(r).start();
-        try {
-            acquired.await();
-            acquiredAction.accept(segment);
-        } catch (InterruptedException ex) {
-            throw new AssertionError(ex);
-        } finally {
-            holder.countDown();
-        }
+    @Test(expectedExceptions=UnsupportedOperationException.class)
+    public void testBadShareNoAccess() {
+        MemorySegment.ofArray(new int[4])
+                .withAccessModes(MemorySegment.CLOSE).share();
     }
 
     @Test
@@ -228,8 +170,7 @@ public void testOutsideConfinementThread() throws Throwable {
                     } catch (InterruptedException e) {
                     }
 
-                    MemoryAddress base = s2.baseAddress();
-                    setInt(base.addOffset(4), -42);
+                    setInt(s2.asSlice(4), -42);
                     fail();
                 } catch (IllegalStateException ex) {
                     assertTrue(ex.getMessage().contains("owning thread"));
@@ -237,19 +178,18 @@ public void testOutsideConfinementThread() throws Throwable {
             });
 
             a.await();
-            MemoryAddress base = s1.baseAddress();
-            setInt(base.addOffset(4), 42);
+            setInt(s1.asSlice(4), 42);
         }
 
         b.countDown();
         r.get();
     }
 
-    static int getInt(MemoryAddress address) {
-        return (int)intHandle.getVolatile(address);
+    static int getInt(MemorySegment base) {
+        return (int)intHandle.getVolatile(base);
     }
 
-    static void setInt(MemoryAddress address, int value) {
-        intHandle.setVolatile(address, value);
+    static void setInt(MemorySegment base, int value) {
+        intHandle.setVolatile(base, value);
     }
 }
diff --git a/test/jdk/java/foreign/TestSlices.java b/test/jdk/java/foreign/TestSlices.java
index 7fe6436425b61..8225bf95a9336 100644
--- a/test/jdk/java/foreign/TestSlices.java
+++ b/test/jdk/java/foreign/TestSlices.java
@@ -44,15 +44,13 @@ public class TestSlices {
     static VarHandle VH_ALL = LAYOUT.varHandle(int.class,
             MemoryLayout.PathElement.sequenceElement(), MemoryLayout.PathElement.sequenceElement());
 
-    static VarHandle VH_INT = MemoryLayouts.JAVA_INT.varHandle(int.class);
-
     @Test(dataProvider = "slices")
     public void testSlices(VarHandle handle, int lo, int hi, int[] values) {
         try (MemorySegment segment = MemorySegment.allocateNative(LAYOUT)) {
             //init
             for (long i = 0 ; i < 2 ; i++) {
                 for (long j = 0 ; j < 5 ; j++) {
-                    VH_ALL.set(segment.baseAddress(), i, j, (int)j + 1 + ((int)i * 5));
+                    VH_ALL.set(segment, i, j, (int)j + 1 + ((int)i * 5));
                 }
             }
 
@@ -64,7 +62,7 @@ static void checkSlice(MemorySegment segment, VarHandle handle, long i_max, long
         int index = 0;
         for (long i = 0 ; i < i_max ; i++) {
             for (long j = 0 ; j < j_max ; j++) {
-                int x = (int) handle.get(segment.baseAddress(), i, j);
+                int x = (int) handle.get(segment, i, j);
                 assertEquals(x, values[index++]);
             }
         }
@@ -79,19 +77,15 @@ static Object[][] slices() {
                 // x[0::2]
                 { LAYOUT.varHandle(int.class, MemoryLayout.PathElement.sequenceElement(),
                         MemoryLayout.PathElement.sequenceElement(0, 2)), 2, 3, new int[] { 1, 3, 5, 6, 8, 10 } },
-                { MemoryHandles.withStride(MemoryHandles.withStride(VH_INT, 8), 20), 2, 3, new int[] { 1, 3, 5, 6, 8, 10 } },
                 // x[1::2]
                 { LAYOUT.varHandle(int.class, MemoryLayout.PathElement.sequenceElement(),
                         MemoryLayout.PathElement.sequenceElement(1, 2)), 2, 2, new int[] { 2, 4, 7, 9 } },
-                { MemoryHandles.withOffset(MemoryHandles.withStride(MemoryHandles.withStride(VH_INT, 8), 20), 4), 2, 2, new int[] { 2, 4, 7, 9 } },
                 // x[4::-2]
                 { LAYOUT.varHandle(int.class, MemoryLayout.PathElement.sequenceElement(),
                         MemoryLayout.PathElement.sequenceElement(4, -2)), 2, 3, new int[] { 5, 3, 1, 10, 8, 6 } },
-                { MemoryHandles.withOffset(MemoryHandles.withStride(MemoryHandles.withStride(VH_INT, -8), 20), 16), 2, 3, new int[] { 5, 3, 1, 10, 8, 6 } },
                 // x[3::-2]
                 { LAYOUT.varHandle(int.class, MemoryLayout.PathElement.sequenceElement(),
                         MemoryLayout.PathElement.sequenceElement(3, -2)), 2, 2, new int[] { 4, 2, 9, 7 } },
-                { MemoryHandles.withOffset(MemoryHandles.withStride(MemoryHandles.withStride(VH_INT, -8), 20), 12), 2, 2, new int[] { 4, 2, 9, 7 } },
         };
     }
 }
diff --git a/test/jdk/java/foreign/TestSpliterator.java b/test/jdk/java/foreign/TestSpliterator.java
index f0922b23ef3b9..2cc1b3a3a4d20 100644
--- a/test/jdk/java/foreign/TestSpliterator.java
+++ b/test/jdk/java/foreign/TestSpliterator.java
@@ -26,7 +26,6 @@
  * @run testng TestSpliterator
  */
 
-import jdk.incubator.foreign.MemoryAddress;
 import jdk.incubator.foreign.MemoryLayout;
 import jdk.incubator.foreign.MemoryLayouts;
 import jdk.incubator.foreign.MemorySegment;
@@ -61,9 +60,9 @@ public void testSum(int size, int threshold) {
         SequenceLayout layout = MemoryLayout.ofSequence(size, MemoryLayouts.JAVA_INT);
 
         //setup
-        MemorySegment segment = MemorySegment.allocateNative(layout);
+        MemorySegment segment = MemorySegment.allocateNative(layout).share();
         for (int i = 0; i < layout.elementCount().getAsLong(); i++) {
-            INT_HANDLE.set(segment.baseAddress(), (long) i, i);
+            INT_HANDLE.set(segment, (long) i, i);
         }
         long expected = LongStream.range(0, layout.elementCount().getAsLong()).sum();
         //serial
@@ -88,7 +87,7 @@ public void testSumSameThread() {
         //setup
         MemorySegment segment = MemorySegment.allocateNative(layout);
         for (int i = 0; i < layout.elementCount().getAsLong(); i++) {
-            INT_HANDLE.set(segment.baseAddress(), (long) i, i);
+            INT_HANDLE.set(segment, (long) i, i);
         }
         long expected = LongStream.range(0, layout.elementCount().getAsLong()).sum();
 
@@ -100,15 +99,14 @@ public void testSumSameThread() {
     }
 
     static long sumSingle(long acc, MemorySegment segment) {
-        return acc + (int)INT_HANDLE.get(segment.baseAddress(), 0L);
+        return acc + (int)INT_HANDLE.get(segment, 0L);
     }
 
     static long sum(long start, MemorySegment segment) {
         long sum = start;
-        MemoryAddress base = segment.baseAddress();
         int length = (int)segment.byteSize();
         for (int i = 0 ; i < length / CARRIER_SIZE ; i++) {
-            sum += (int)INT_HANDLE.get(base, (long)i);
+            sum += (int)INT_HANDLE.get(segment, (long)i);
         }
         return sum;
     }
@@ -216,8 +214,8 @@ public Object[][] accessScenarios() {
             () -> spliterator(mallocSegment.withAccessModes(READ), layout), READ,
             () -> spliterator(mallocSegment.withAccessModes(CLOSE), layout), 0,
             () -> spliterator(mallocSegment.withAccessModes(READ|WRITE), layout), READ|WRITE,
-            () -> spliterator(mallocSegment.withAccessModes(READ|WRITE|ACQUIRE), layout), READ|WRITE|ACQUIRE,
-            () -> spliterator(mallocSegment.withAccessModes(READ|WRITE|ACQUIRE|HANDOFF), layout), READ|WRITE|ACQUIRE|HANDOFF
+            () -> spliterator(mallocSegment.withAccessModes(READ|WRITE| SHARE), layout), READ|WRITE| SHARE,
+            () -> spliterator(mallocSegment.withAccessModes(READ|WRITE| SHARE |HANDOFF), layout), READ|WRITE| SHARE |HANDOFF
 
         );
         return l.entrySet().stream().map(e -> new Object[] { e.getKey(), e.getValue() }).toArray(Object[][]::new);
diff --git a/test/jdk/java/foreign/TestVarHandleCombinators.java b/test/jdk/java/foreign/TestVarHandleCombinators.java
index e9e69398f543e..c3840dbad3821 100644
--- a/test/jdk/java/foreign/TestVarHandleCombinators.java
+++ b/test/jdk/java/foreign/TestVarHandleCombinators.java
@@ -31,7 +31,6 @@
 import org.testng.annotations.DataProvider;
 import org.testng.annotations.Test;
 
-import jdk.incubator.foreign.MemoryAddress;
 import jdk.incubator.foreign.MemorySegment;
 
 import java.lang.invoke.MethodHandles;
@@ -45,36 +44,20 @@ public class TestVarHandleCombinators {
     @Test
     public void testElementAccess() {
         VarHandle vh = MemoryHandles.varHandle(byte.class, ByteOrder.nativeOrder());
-        vh = MemoryHandles.withStride(vh, 1);
 
         byte[] arr = { 0, 0, -1, 0 };
         MemorySegment segment = MemorySegment.ofArray(arr);
-        MemoryAddress addr = segment.baseAddress();
-
-        assertEquals((byte) vh.get(addr, 2), (byte) -1);
+        assertEquals((byte) vh.get(segment, 2), (byte) -1);
     }
 
     @Test(expectedExceptions = IllegalStateException.class)
     public void testUnalignedElement() {
         VarHandle vh = MemoryHandles.varHandle(byte.class, 4, ByteOrder.nativeOrder());
-        vh = MemoryHandles.withStride(vh, 2);
         MemorySegment segment = MemorySegment.ofArray(new byte[4]);
-        vh.get(segment.baseAddress(), 1L); //should throw
-    }
-
-    public void testZeroStrideElement() {
-        VarHandle vh = MemoryHandles.varHandle(int.class, ByteOrder.nativeOrder());
-        VarHandle strided_vh = MemoryHandles.withStride(vh, 0);
-        MemorySegment segment = MemorySegment.ofArray(new int[] { 42 });
-        for (int i = 0 ; i < 100 ; i++) {
-            assertEquals((int)vh.get(segment.baseAddress()), strided_vh.get(segment.baseAddress(), (long)i));
-        }
-    }
-
-    @Test(expectedExceptions = IllegalArgumentException.class)
-    public void testStrideWrongHandle() {
-        VarHandle vh = MethodHandles.byteArrayViewVarHandle(int[].class, ByteOrder.nativeOrder());
-        MemoryHandles.withStride(vh, 10);
+        vh.get(segment, 2L); //should throw
+        //FIXME: the VH only checks the alignment of the segment, which is fine if the VH is derived from layouts,
+        //FIXME: but not if the VH is just created from scratch - we need a VH variable to govern this property,
+        //FIXME: at least until the VM is fixed
     }
 
     @Test(expectedExceptions = IllegalArgumentException.class)
@@ -92,56 +75,8 @@ public void testAlign() {
         VarHandle vh = MemoryHandles.varHandle(byte.class, 2, ByteOrder.nativeOrder());
 
         MemorySegment segment = MemorySegment.allocateNative(1, 2);
-        MemoryAddress address = segment.baseAddress();
-
-        vh.set(address, (byte) 10); // fine, memory region is aligned
-        assertEquals((byte) vh.get(address), (byte) 10);
-    }
-
-    @Test(expectedExceptions = IllegalStateException.class)
-    public void testAlignBadAccess() {
-        VarHandle vh = MemoryHandles.varHandle(byte.class, 2, ByteOrder.nativeOrder());
-        vh = MemoryHandles.withOffset(vh, 1); // offset by 1 byte
-
-        MemorySegment segment = MemorySegment.allocateNative(2, 2);
-        MemoryAddress address = segment.baseAddress();
-
-        vh.set(address, (byte) 10); // should be bad align
-    }
-
-    public void testZeroOffsetElement() {
-        VarHandle vh = MemoryHandles.varHandle(int.class, ByteOrder.nativeOrder());
-        VarHandle offset_vh = MemoryHandles.withOffset(vh, 0);
-        MemorySegment segment = MemorySegment.ofArray(new int[] { 42 });
-        for (int i = 0 ; i < 100 ; i++) {
-            assertEquals((int)vh.get(segment.baseAddress()), offset_vh.get(segment.baseAddress(), (long)i));
-        }
-    }
-
-    @Test(expectedExceptions = IllegalArgumentException.class)
-    public void testOffsetWrongHandle() {
-        VarHandle vh = MethodHandles.byteArrayViewVarHandle(int[].class, ByteOrder.nativeOrder());
-        MemoryHandles.withOffset(vh, 1);
-    }
-
-    @Test(expectedExceptions = IllegalStateException.class)
-    public void testUnalignedOffset() {
-        VarHandle vh = MemoryHandles.varHandle(byte.class, 4, ByteOrder.nativeOrder());
-        vh = MemoryHandles.withOffset(vh, 2);
-        MemorySegment segment = MemorySegment.ofArray(new byte[4]);
-        vh.get(segment.baseAddress()); //should throw
-    }
-
-    @Test
-    public void testOffset() {
-        VarHandle vh = MemoryHandles.varHandle(byte.class, ByteOrder.nativeOrder());
-        vh = MemoryHandles.withOffset(vh, 1);
-
-        MemorySegment segment = MemorySegment.ofArray(new byte[2]);
-        MemoryAddress address = segment.baseAddress();
-
-        vh.set(address, (byte) 10);
-        assertEquals((byte) vh.get(address), (byte) 10);
+        vh.set(segment, 0L, (byte) 10); // fine, memory region is aligned
+        assertEquals((byte) vh.get(segment, 0L), (byte) 10);
     }
 
     @Test
@@ -149,9 +84,7 @@ public void testByteOrderLE() {
         VarHandle vh = MemoryHandles.varHandle(short.class, 2, ByteOrder.LITTLE_ENDIAN);
         byte[] arr = new byte[2];
         MemorySegment segment = MemorySegment.ofArray(arr);
-        MemoryAddress address = segment.baseAddress();
-
-        vh.set(address, (short) 0xFF);
+        vh.set(segment, 0L, (short) 0xFF);
         assertEquals(arr[0], (byte) 0xFF);
         assertEquals(arr[1], (byte) 0);
     }
@@ -161,9 +94,7 @@ public void testByteOrderBE() {
         VarHandle vh = MemoryHandles.varHandle(short.class, 2, ByteOrder.BIG_ENDIAN);
         byte[] arr = new byte[2];
         MemorySegment segment = MemorySegment.ofArray(arr);
-        MemoryAddress address = segment.baseAddress();
-
-        vh.set(address, (short) 0xFF);
+        vh.set(segment, 0L, (short) 0xFF);
         assertEquals(arr[0], (byte) 0);
         assertEquals(arr[1], (byte) 0xFF);
     }
@@ -176,16 +107,13 @@ public void testNestedSequenceAccess() {
         //[10 : [5 : [x32 i32]]]
 
         VarHandle vh = MemoryHandles.varHandle(int.class, ByteOrder.nativeOrder());
-        vh = MemoryHandles.withOffset(vh, 4);
-        VarHandle inner_vh = MemoryHandles.withStride(vh, 8);
-        VarHandle outer_vh = MemoryHandles.withStride(inner_vh, 5 * 8);
         int count = 0;
         try (MemorySegment segment = MemorySegment.allocateNative(inner_size * outer_size * 8)) {
             for (long i = 0; i < outer_size; i++) {
                 for (long j = 0; j < inner_size; j++) {
-                    outer_vh.set(segment.baseAddress(), i, j, count);
+                    vh.set(segment, i * 40 + j * 8, count);
                     assertEquals(
-                            (int)inner_vh.get(segment.baseAddress().addOffset(i * inner_size * 8), j),
+                            (int)vh.get(segment.asSlice(i * inner_size * 8), j * 8),
                             count);
                     count++;
                 }
@@ -205,7 +133,7 @@ public Object[][] createBadCarriers() {
                 { boolean.class },
                 { Object.class },
                 { int[].class },
-                { MemoryAddress.class }
+                { MemorySegment.class }
         };
     }
 
diff --git a/test/jdk/java/util/stream/test/org/openjdk/tests/java/util/stream/SegmentTestDataProvider.java b/test/jdk/java/util/stream/test/org/openjdk/tests/java/util/stream/SegmentTestDataProvider.java
index 2d2d33d0ab7ec..8c7d8c48921a7 100644
--- a/test/jdk/java/util/stream/test/org/openjdk/tests/java/util/stream/SegmentTestDataProvider.java
+++ b/test/jdk/java/util/stream/test/org/openjdk/tests/java/util/stream/SegmentTestDataProvider.java
@@ -23,6 +23,7 @@
 
 package org.openjdk.tests.java.util.stream;
 
+import jdk.incubator.foreign.MemoryAccess;
 import jdk.incubator.foreign.MemoryLayout;
 import jdk.incubator.foreign.MemoryLayouts;
 import jdk.incubator.foreign.MemorySegment;
@@ -39,16 +40,8 @@
 
 public class SegmentTestDataProvider {
 
-    static VarHandle BYTE_HANDLE = MemoryLayouts.JAVA_BYTE.varHandle(byte.class);
-    static VarHandle CHAR_HANDLE = MemoryLayouts.JAVA_CHAR.varHandle(char.class);
-    static VarHandle SHORT_HANDLE = MemoryLayouts.JAVA_SHORT.varHandle(short.class);
-    static VarHandle INT_HANDLE = MemoryLayouts.JAVA_INT.varHandle(int.class);
-    static VarHandle LONG_HANDLE = MemoryLayouts.JAVA_LONG.varHandle(long.class);
-    static VarHandle FLOAT_HANDLE = MemoryLayouts.JAVA_FLOAT.varHandle(float.class);
-    static VarHandle DOUBLE_HANDLE = MemoryLayouts.JAVA_DOUBLE.varHandle(double.class);
-
     static boolean compareSegmentsByte(Collection segments1, Collection segments2, boolean isOrdered) {
-        Function mapper = segment -> (byte)BYTE_HANDLE.get(segment.baseAddress());
+        Function mapper = MemoryAccess::getByte;
         List list1 = segments1.stream()
                 .map(mapper)
                 .collect(Collectors.toList());
@@ -59,7 +52,7 @@ static boolean compareSegmentsByte(Collection segments1, Collecti
     }
 
     static boolean compareSegmentsChar(Collection segments1, Collection segments2, boolean isOrdered) {
-        Function mapper = segment -> (char)CHAR_HANDLE.get(segment.baseAddress());
+        Function mapper = MemoryAccess::getChar;
         List list1 = segments1.stream()
                 .map(mapper)
                 .collect(Collectors.toList());
@@ -70,7 +63,7 @@ static boolean compareSegmentsChar(Collection segments1, Collecti
     }
 
     static boolean compareSegmentsShort(Collection segments1, Collection segments2, boolean isOrdered) {
-        Function mapper = segment -> (short)SHORT_HANDLE.get(segment.baseAddress());
+        Function mapper = MemoryAccess::getShort;
         List list1 = segments1.stream()
                 .map(mapper)
                 .collect(Collectors.toList());
@@ -81,7 +74,7 @@ static boolean compareSegmentsShort(Collection segments1, Collect
     }
 
     static boolean compareSegmentsInt(Collection segments1, Collection segments2, boolean isOrdered) {
-        Function mapper = segment -> (int)INT_HANDLE.get(segment.baseAddress());
+        Function mapper = MemoryAccess::getInt;
         List list1 = segments1.stream()
                 .map(mapper)
                 .collect(Collectors.toList());
@@ -92,7 +85,7 @@ static boolean compareSegmentsInt(Collection segments1, Collectio
     }
 
     static boolean compareSegmentsLong(Collection segments1, Collection segments2, boolean isOrdered) {
-        Function mapper = segment -> (long)LONG_HANDLE.get(segment.baseAddress());
+        Function mapper = MemoryAccess::getLong;
         List list1 = segments1.stream()
                 .map(mapper)
                 .collect(Collectors.toList());
@@ -103,7 +96,7 @@ static boolean compareSegmentsLong(Collection segments1, Collecti
     }
 
     static boolean compareSegmentsFloat(Collection segments1, Collection segments2, boolean isOrdered) {
-        Function mapper = segment -> (float)FLOAT_HANDLE.get(segment.baseAddress());
+        Function mapper = MemoryAccess::getFloat;
         List list1 = segments1.stream()
                 .map(mapper)
                 .collect(Collectors.toList());
@@ -122,7 +115,7 @@ static Consumer segmentCopier(Consumer input) {
     }
 
     static boolean compareSegmentsDouble(Collection segments1, Collection segments2, boolean isOrdered) {
-        Function mapper = segment -> (double)DOUBLE_HANDLE.get(segment.baseAddress());
+        Function mapper = MemoryAccess::getDouble;
         List list1 = segments1.stream()
                 .map(mapper)
                 .collect(Collectors.toList());
@@ -134,7 +127,7 @@ static boolean compareSegmentsDouble(Collection segments1, Collec
 
     static void initSegment(MemorySegment segment) {
         for (int i = 0 ; i < segment.byteSize() ; i++) {
-            BYTE_HANDLE.set(segment.baseAddress(), (byte)i);
+            MemoryAccess.setByte(segment, (byte)i);
         }
     }
 
diff --git a/test/micro/org/openjdk/bench/jdk/incubator/foreign/LoopOverConstant.java b/test/micro/org/openjdk/bench/jdk/incubator/foreign/LoopOverConstant.java
index 8837fa8045a90..f79b019b1a2cf 100644
--- a/test/micro/org/openjdk/bench/jdk/incubator/foreign/LoopOverConstant.java
+++ b/test/micro/org/openjdk/bench/jdk/incubator/foreign/LoopOverConstant.java
@@ -72,12 +72,12 @@ public class LoopOverConstant {
 
     //setup native memory segment
 
-    static final MemoryAddress segment_addr = MemorySegment.allocateNative(ALLOC_SIZE).baseAddress();
+    static final MemorySegment segment = MemorySegment.allocateNative(ALLOC_SIZE);
     static final VarHandle VH_int = MemoryLayout.ofSequence(JAVA_INT).varHandle(int.class, sequenceElement());
 
     static {
         for (int i = 0; i < ELEM_SIZE; i++) {
-            VH_int.set(segment_addr, (long) i, i);
+            VH_int.set(segment, (long) i, i);
         }
     }
 
@@ -100,7 +100,7 @@ public int unsafe_get() {
     @Benchmark
     @OutputTimeUnit(TimeUnit.NANOSECONDS)
     public int segment_get() {
-        return (int)VH_int.get(segment_addr, 0L);
+        return (int)VH_int.get(segment, 0L);
     }
 
     @Benchmark
@@ -122,7 +122,7 @@ public int unsafe_loop() {
     public int segment_loop() {
         int res = 0;
         for (int i = 0; i < ELEM_SIZE; i++) {
-            res += (int) VH_int.get(segment_addr, (long)i);
+            res += (int) VH_int.get(segment, (long)i);
         }
         return res;
     }
diff --git a/test/micro/org/openjdk/bench/jdk/incubator/foreign/LoopOverNew.java b/test/micro/org/openjdk/bench/jdk/incubator/foreign/LoopOverNew.java
index 194d7ab6ecf68..101f3dde8e96f 100644
--- a/test/micro/org/openjdk/bench/jdk/incubator/foreign/LoopOverNew.java
+++ b/test/micro/org/openjdk/bench/jdk/incubator/foreign/LoopOverNew.java
@@ -22,7 +22,6 @@
  */
 package org.openjdk.bench.jdk.incubator.foreign;
 
-import jdk.incubator.foreign.MemoryAddress;
 import jdk.incubator.foreign.MemoryLayout;
 import jdk.incubator.foreign.MemorySegment;
 import org.openjdk.jmh.annotations.Benchmark;
@@ -74,7 +73,16 @@ public void unsafe_loop() {
     public void segment_loop() {
         MemorySegment segment = MemorySegment.allocateNative(ALLOC_SIZE);
         for (int i = 0; i < ELEM_SIZE; i++) {
-            VH_int.set(segment.baseAddress(), (long) i, i);
+            VH_int.set(segment, (long) i, i);
+        }
+        segment.close();
+    }
+
+    @Benchmark
+    public void segment_loop_shared() {
+        MemorySegment segment = MemorySegment.allocateNative(ALLOC_SIZE).share();
+        for (int i = 0; i < ELEM_SIZE; i++) {
+            VH_int.set(segment, (long) i, i);
         }
         segment.close();
     }
diff --git a/test/micro/org/openjdk/bench/jdk/incubator/foreign/LoopOverNonConstant.java b/test/micro/org/openjdk/bench/jdk/incubator/foreign/LoopOverNonConstant.java
index f68e7892bd9a0..03cc9dab946de 100644
--- a/test/micro/org/openjdk/bench/jdk/incubator/foreign/LoopOverNonConstant.java
+++ b/test/micro/org/openjdk/bench/jdk/incubator/foreign/LoopOverNonConstant.java
@@ -22,6 +22,7 @@
  */
 package org.openjdk.bench.jdk.incubator.foreign;
 
+import jdk.incubator.foreign.MemoryAccess;
 import jdk.incubator.foreign.MemoryAddress;
 import jdk.incubator.foreign.MemoryLayout;
 import jdk.incubator.foreign.MemorySegment;
@@ -73,7 +74,7 @@ public void setup() {
         }
         segment = MemorySegment.allocateNative(ALLOC_SIZE);
         for (int i = 0; i < ELEM_SIZE; i++) {
-            VH_int.set(segment.baseAddress(), (long) i, i);
+            VH_int.set(segment, (long) i, i);
         }
         byteBuffer = ByteBuffer.allocateDirect(ALLOC_SIZE).order(ByteOrder.nativeOrder());
         for (int i = 0; i < ELEM_SIZE; i++) {
@@ -97,7 +98,7 @@ public int unsafe_get() {
     @Benchmark
     @OutputTimeUnit(TimeUnit.NANOSECONDS)
     public int segment_get() {
-        return (int) VH_int.get(segment.baseAddress(), 0L);
+        return (int) VH_int.get(segment, 0L);
     }
 
     @Benchmark
@@ -115,12 +116,20 @@ public int unsafe_loop() {
         return res;
     }
 
+    @Benchmark
+    public int segment_loop_static() {
+        int res = 0;
+        for (int i = 0; i < ELEM_SIZE; i ++) {
+            res += MemoryAccess.getIntAtIndex(segment, i);
+        }
+        return res;
+    }
+
     @Benchmark
     public int segment_loop() {
         int sum = 0;
-        MemoryAddress base = segment.baseAddress();
         for (int i = 0; i < ELEM_SIZE; i++) {
-            sum += (int) VH_int.get(base, (long) i);
+            sum += (int) VH_int.get(segment, (long) i);
         }
         return sum;
     }
@@ -128,7 +137,7 @@ public int segment_loop() {
     @Benchmark
     public int segment_loop_slice() {
         int sum = 0;
-        MemoryAddress base = segment.asSlice(0, segment.byteSize()).baseAddress();
+        MemorySegment base = segment.asSlice(0, segment.byteSize());
         for (int i = 0; i < ELEM_SIZE; i++) {
             sum += (int) VH_int.get(base, (long) i);
         }
@@ -138,7 +147,7 @@ public int segment_loop_slice() {
     @Benchmark
     public int segment_loop_readonly() {
         int sum = 0;
-        MemoryAddress base = segment.withAccessModes(MemorySegment.READ).baseAddress();
+        MemorySegment base = segment.withAccessModes(MemorySegment.READ);
         for (int i = 0; i < ELEM_SIZE; i++) {
             sum += (int) VH_int.get(base, (long) i);
         }
diff --git a/test/micro/org/openjdk/bench/jdk/incubator/foreign/LoopOverNonConstantHeap.java b/test/micro/org/openjdk/bench/jdk/incubator/foreign/LoopOverNonConstantHeap.java
index 8fb4c2d6e77cb..61fd7cb132012 100644
--- a/test/micro/org/openjdk/bench/jdk/incubator/foreign/LoopOverNonConstantHeap.java
+++ b/test/micro/org/openjdk/bench/jdk/incubator/foreign/LoopOverNonConstantHeap.java
@@ -22,6 +22,7 @@
  */
 package org.openjdk.bench.jdk.incubator.foreign;
 
+import jdk.incubator.foreign.MemoryAccess;
 import jdk.incubator.foreign.MemoryAddress;
 import jdk.incubator.foreign.MemoryLayout;
 import jdk.incubator.foreign.MemorySegment;
@@ -90,7 +91,7 @@ public int unsafe_get() {
     @Benchmark
     @OutputTimeUnit(TimeUnit.NANOSECONDS)
     public int segment_get() {
-        return (int) VH_int.get(segment.baseAddress(), 0L);
+        return (int) VH_int.get(segment, 0L);
     }
 
     @Benchmark
@@ -111,17 +112,25 @@ public int unsafe_loop() {
     @Benchmark
     public int segment_loop() {
         int sum = 0;
-        MemoryAddress base = segment.baseAddress();
         for (int i = 0; i < ELEM_SIZE; i++) {
-            sum += (int) VH_int.get(base, (long) i);
+            sum += (int) VH_int.get(segment, (long) i);
         }
         return sum;
     }
 
+    @Benchmark
+    public int segment_loop_static() {
+        int res = 0;
+        for (int i = 0; i < ELEM_SIZE; i ++) {
+            res += MemoryAccess.getIntAtIndex(segment, i);
+        }
+        return res;
+    }
+
     @Benchmark
     public int segment_loop_slice() {
         int sum = 0;
-        MemoryAddress base = segment.asSlice(0, segment.byteSize()).baseAddress();
+        MemorySegment base = segment.asSlice(0, segment.byteSize());
         for (int i = 0; i < ELEM_SIZE; i++) {
             sum += (int) VH_int.get(base, (long) i);
         }
@@ -131,7 +140,7 @@ public int segment_loop_slice() {
     @Benchmark
     public int segment_loop_readonly() {
         int sum = 0;
-        MemoryAddress base = segment.withAccessModes(MemorySegment.READ).baseAddress();
+        MemorySegment base = segment.withAccessModes(MemorySegment.READ);
         for (int i = 0; i < ELEM_SIZE; i++) {
             sum += (int) VH_int.get(base, (long) i);
         }
diff --git a/test/micro/org/openjdk/bench/jdk/incubator/foreign/LoopOverNonConstantMapped.java b/test/micro/org/openjdk/bench/jdk/incubator/foreign/LoopOverNonConstantMapped.java
index fb6b44274c875..651e8c7390121 100644
--- a/test/micro/org/openjdk/bench/jdk/incubator/foreign/LoopOverNonConstantMapped.java
+++ b/test/micro/org/openjdk/bench/jdk/incubator/foreign/LoopOverNonConstantMapped.java
@@ -22,6 +22,7 @@
  */
 package org.openjdk.bench.jdk.incubator.foreign;
 
+import jdk.incubator.foreign.MemoryAccess;
 import jdk.incubator.foreign.MemoryAddress;
 import jdk.incubator.foreign.MemoryLayout;
 import jdk.incubator.foreign.MemorySegment;
@@ -96,7 +97,7 @@ public void setup() throws IOException {
             ((MappedByteBuffer)byteBuffer).force();
         }
         segment = MemorySegment.mapFromPath(tempPath, 0L, ALLOC_SIZE, FileChannel.MapMode.READ_WRITE);
-        unsafe_addr = segment.baseAddress().toRawLongValue();
+        unsafe_addr = segment.address().toRawLongValue();
     }
 
     @TearDown
@@ -114,7 +115,7 @@ public int unsafe_get() {
     @Benchmark
     @OutputTimeUnit(TimeUnit.NANOSECONDS)
     public int segment_get() {
-        return (int) VH_int.get(segment.baseAddress(), 0L);
+        return (int) VH_int.get(segment, 0L);
     }
 
     @Benchmark
@@ -135,17 +136,25 @@ public int unsafe_loop() {
     @Benchmark
     public int segment_loop() {
         int sum = 0;
-        MemoryAddress base = segment.baseAddress();
         for (int i = 0; i < ELEM_SIZE; i++) {
-            sum += (int) VH_int.get(base, (long) i);
+            sum += (int) VH_int.get(segment, (long) i);
         }
         return sum;
     }
 
+    @Benchmark
+    public int segment_loop_static() {
+        int res = 0;
+        for (int i = 0; i < ELEM_SIZE; i ++) {
+            res += MemoryAccess.getIntAtIndex(segment, i);
+        }
+        return res;
+    }
+
     @Benchmark
     public int segment_loop_slice() {
         int sum = 0;
-        MemoryAddress base = segment.asSlice(0, segment.byteSize()).baseAddress();
+        MemorySegment base = segment.asSlice(0, segment.byteSize());
         for (int i = 0; i < ELEM_SIZE; i++) {
             sum += (int) VH_int.get(base, (long) i);
         }
@@ -155,7 +164,7 @@ public int segment_loop_slice() {
     @Benchmark
     public int segment_loop_readonly() {
         int sum = 0;
-        MemoryAddress base = segment.withAccessModes(MemorySegment.READ).baseAddress();
+        MemorySegment base = segment.withAccessModes(MemorySegment.READ);
         for (int i = 0; i < ELEM_SIZE; i++) {
             sum += (int) VH_int.get(base, (long) i);
         }
diff --git a/test/micro/org/openjdk/bench/jdk/incubator/foreign/ParallelSum.java b/test/micro/org/openjdk/bench/jdk/incubator/foreign/ParallelSum.java
index b84ff169bc04b..150261833623b 100644
--- a/test/micro/org/openjdk/bench/jdk/incubator/foreign/ParallelSum.java
+++ b/test/micro/org/openjdk/bench/jdk/incubator/foreign/ParallelSum.java
@@ -85,9 +85,9 @@ public void setup() {
         for (int i = 0; i < ELEM_SIZE; i++) {
             unsafe.putInt(address + (i * CARRIER_SIZE), i);
         }
-        segment = MemorySegment.allocateNative(ALLOC_SIZE);
+        segment = MemorySegment.allocateNative(ALLOC_SIZE).share();
         for (int i = 0; i < ELEM_SIZE; i++) {
-            VH_int.set(segment.baseAddress(), (long) i, i);
+            VH_int.set(segment, (long) i, i);
         }
     }
 
@@ -100,9 +100,8 @@ public void tearDown() throws Throwable {
     @Benchmark
     public int segment_serial() {
         int res = 0;
-        MemoryAddress base = segment.baseAddress();
         for (int i = 0; i < ELEM_SIZE; i++) {
-            res += (int)VH_int.get(base, (long) i);
+            res += (int)VH_int.get(segment, (long) i);
         }
         return res;
     }
@@ -139,13 +138,12 @@ public int segment_stream_parallel_bulk() {
     }
 
     final static ToIntFunction SEGMENT_TO_INT = slice ->
-            (int) VH_int.get(slice.baseAddress(), 0L);
+            (int) VH_int.get(slice, 0L);
 
     final static ToIntFunction SEGMENT_TO_INT_BULK = slice -> {
         int res = 0;
-        MemoryAddress base = slice.baseAddress();
         for (int i = 0; i < BULK_FACTOR ; i++) {
-            res += (int)VH_int.get(base, (long) i);
+            res += (int)VH_int.get(slice, (long) i);
         }
         return res;
     };
@@ -179,12 +177,11 @@ public Optional segment_stream_findany_parallel_bulk() {
     }
 
     final static Predicate FIND_SINGLE = slice ->
-            (int)VH_int.get(slice.baseAddress(), 0L) == (ELEM_SIZE - 1);
+            (int)VH_int.get(slice, 0L) == (ELEM_SIZE - 1);
 
     final static Predicate FIND_BULK = slice -> {
-        MemoryAddress base = slice.baseAddress();
         for (int i = 0; i < BULK_FACTOR ; i++) {
-            if ((int)VH_int.get(base, (long)i) == (ELEM_SIZE - 1)) {
+            if ((int)VH_int.get(slice, (long)i) == (ELEM_SIZE - 1)) {
                 return true;
             }
         }
@@ -193,7 +190,7 @@ public Optional segment_stream_findany_parallel_bulk() {
 
     @Benchmark
     public int unsafe_parallel() {
-        return new SumUnsafe(address, 0, ALLOC_SIZE).invoke();
+        return new SumUnsafe(address, 0, ALLOC_SIZE / CARRIER_SIZE).invoke();
     }
 
     static class SumUnsafe extends RecursiveTask {
@@ -212,15 +209,19 @@ static class SumUnsafe extends RecursiveTask {
         @Override
         protected Integer compute() {
             if (length > SPLIT_THRESHOLD) {
-                SumUnsafe s1 = new SumUnsafe(address, start, length / 2);
-                SumUnsafe s2 = new SumUnsafe(address, length / 2, length / 2);
+                int rem = length % 2;
+                int split = length / 2;
+                int lobound = split;
+                int hibound = lobound + rem;
+                SumUnsafe s1 = new SumUnsafe(address, start, lobound);
+                SumUnsafe s2 = new SumUnsafe(address, start + lobound, hibound);
                 s1.fork();
                 s2.fork();
                 return s1.join() + s2.join();
             } else {
                 int res = 0;
-                for (int i = 0; i < length; i += CARRIER_SIZE) {
-                    res += unsafe.getInt(start + address + i);
+                for (int i = 0; i < length; i ++) {
+                    res += unsafe.getInt(address + (start + i) * CARRIER_SIZE);
                 }
                 return res;
             }
diff --git a/test/micro/org/openjdk/bench/jdk/incubator/foreign/TestAdaptVarHandles.java b/test/micro/org/openjdk/bench/jdk/incubator/foreign/TestAdaptVarHandles.java
index bcda35b2ce526..2a35b36955ea4 100644
--- a/test/micro/org/openjdk/bench/jdk/incubator/foreign/TestAdaptVarHandles.java
+++ b/test/micro/org/openjdk/bench/jdk/incubator/foreign/TestAdaptVarHandles.java
@@ -144,9 +144,8 @@ public int mh_box_loop() throws Throwable {
     @Benchmark
     public int segment_loop() throws Throwable {
         int sum = 0;
-        MemoryAddress baseAddress = segment.baseAddress();
         for (int i = 0; i < ELEM_SIZE; i++) {
-            sum += (int)VH_addr_int.get(baseAddress, (long)i);
+            sum += (int)VH_addr_int.get(segment, (long)i);
         }
         return sum;
     }
@@ -154,9 +153,8 @@ public int segment_loop() throws Throwable {
     @Benchmark
     public int segment_box_loop() throws Throwable {
         int sum = 0;
-        MemoryAddress baseAddress = segment.baseAddress();
         for (int i = 0; i < ELEM_SIZE; i++) {
-            sum += ((IntBox)VH_addr_box_int.get(baseAddress, (long)i)).intValue();
+            sum += ((IntBox)VH_addr_box_int.get(segment, (long)i)).intValue();
         }
         return sum;
     }
diff --git a/test/micro/org/openjdk/bench/jdk/incubator/foreign/points/support/PanamaPoint.java b/test/micro/org/openjdk/bench/jdk/incubator/foreign/points/support/PanamaPoint.java
index 6b199ab62cfc9..0a3127bb50800 100644
--- a/test/micro/org/openjdk/bench/jdk/incubator/foreign/points/support/PanamaPoint.java
+++ b/test/micro/org/openjdk/bench/jdk/incubator/foreign/points/support/PanamaPoint.java
@@ -58,19 +58,19 @@ public PanamaPoint(MemorySegment segment) {
     }
 
     public void setX(int x) {
-        VH_x.set(segment.baseAddress(), x);
+        VH_x.set(segment, x);
     }
 
     public int getX() {
-        return (int) VH_x.get(segment.baseAddress());
+        return (int) VH_x.get(segment);
     }
 
     public void setY(int y) {
-        VH_y.set(segment.baseAddress(), y);
+        VH_y.set(segment, y);
     }
 
     public int getY() {
-        return (int) VH_y.get(segment.baseAddress());
+        return (int) VH_y.get(segment);
     }
 
     @Override

From fa051abf895d113674851b73084114afa03f6843 Mon Sep 17 00:00:00 2001
From: Maurizio Cimadamore 
Date: Thu, 8 Oct 2020 11:22:33 +0100
Subject: [PATCH 03/70] Address review comments

---
 .../gensrc/GensrcScopedMemoryAccess.gmk       |  8 +--
 .../share/prims/scopedMemoryAccess.cpp        | 58 +++++++++++++------
 .../invoke/MemoryAccessVarHandleBase.java     |  4 +-
 test/jdk/java/foreign/TestMismatch.java       | 19 +++---
 test/jdk/java/foreign/TestSegments.java       |  9 ++-
 5 files changed, 64 insertions(+), 34 deletions(-)

diff --git a/make/modules/java.base/gensrc/GensrcScopedMemoryAccess.gmk b/make/modules/java.base/gensrc/GensrcScopedMemoryAccess.gmk
index cb51d4f30d945..71d337e3ac068 100644
--- a/make/modules/java.base/gensrc/GensrcScopedMemoryAccess.gmk
+++ b/make/modules/java.base/gensrc/GensrcScopedMemoryAccess.gmk
@@ -29,8 +29,8 @@ GENSRC_SCOPED_MEMORY_ACCESS :=
 SCOPED_MEMORY_ACCESS_GENSRC_DIR := $(SUPPORT_OUTPUTDIR)/gensrc/java.base/jdk/internal/misc
 SCOPED_MEMORY_ACCESS_SRC_DIR := $(TOPDIR)/src/java.base/share/classes/jdk/internal/misc
 
-SCOPED_MEMORY_ACCESS_TEMPLATE := $(TOPDIR)/src/java.base/share/classes/jdk/internal/misc/X-ScopedMemoryAccess.java.template
-SCOPED_MEMORY_ACCESS_BIN_TEMPLATE := $(TOPDIR)/src/java.base/share/classes/jdk/internal/misc/X-ScopedMemoryAccess-bin.java.template
+SCOPED_MEMORY_ACCESS_TEMPLATE := $(SCOPED_MEMORY_ACCESS_SRC_DIR)/X-ScopedMemoryAccess.java.template
+SCOPED_MEMORY_ACCESS_BIN_TEMPLATE := $(SCOPED_MEMORY_ACCESS_SRC_DIR)/X-ScopedMemoryAccess-bin.java.template
 DEST := $(SCOPED_MEMORY_ACCESS_GENSRC_DIR)/ScopedMemoryAccess.java
 
 ################################################################################
@@ -142,7 +142,7 @@ endef
 
 SCOPE_MEMORY_ACCESS_TYPES := Byte Short Char Int Long Float Double
 $(foreach t, $(SCOPE_MEMORY_ACCESS_TYPES), \
-  $(eval $(call GenerateScopedOp,BIN_$t,$t)))
+	  $(eval $(call GenerateScopedOp,BIN_$t,$t)))
 	
 $(DEST): $(BUILD_TOOLS_JDK) $(SCOPED_MEMORY_ACCESS_TEMPLATE) $(SCOPED_MEMORY_ACCESS_BIN_TEMPLATE)
 	$(MKDIR) -p $(SCOPED_MEMORY_ACCESS_GENSRC_DIR)
@@ -152,4 +152,4 @@ $(DEST): $(BUILD_TOOLS_JDK) $(SCOPED_MEMORY_ACCESS_TEMPLATE) $(SCOPED_MEMORY_ACC
 		-i$(SCOPED_MEMORY_ACCESS_BIN_TEMPLATE) -o$(DEST) ;)
 	$(PRINTF) "}\n" >> $(DEST)
 	
-TARGETS += $(DEST)
\ No newline at end of file
+TARGETS += $(DEST)
diff --git a/src/hotspot/share/prims/scopedMemoryAccess.cpp b/src/hotspot/share/prims/scopedMemoryAccess.cpp
index 92fbfc170f73c..3f03a25fc679e 100644
--- a/src/hotspot/share/prims/scopedMemoryAccess.cpp
+++ b/src/hotspot/share/prims/scopedMemoryAccess.cpp
@@ -1,3 +1,26 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ *
+ */
 
 #include "precompiled.hpp"
 #include "jni.h"
@@ -78,22 +101,19 @@ class CloseScopedMemoryClosure : public HandshakeClosure {
       CloseScopedMemoryFindOopClosure cl(_deopt);
       CompiledMethod* cm = last_frame.cb()->as_compiled_method();
 
-      //FIXME: this doesn't work if reachability fences are violated by C2
-      // last_frame.oops_do(&cl, NULL, ®ister_map);
-
-      // if (cl.found()) {
-      //   // Found the deopt oop in a compiled method; deoptimize.
-      //   Deoptimization::deoptimize(jt, last_frame);
-      // }
-
-      // so... we unconditionally deoptimize, for now
+      /* FIXME: this doesn't work if reachability fences are violated by C2
+      last_frame.oops_do(&cl, NULL, ®ister_map);
+      if (cl.found()) {
+           //Found the deopt oop in a compiled method; deoptimize.
+           Deoptimization::deoptimize(jt, last_frame);
+      }
+      so... we unconditionally deoptimize, for now: */
       Deoptimization::deoptimize(jt, last_frame);
     }
 
     const int max_critical_stack_depth = 10;
     int depth = 0;
-    vframeStream stream(jt);
-    for (; !stream.at_end(); stream.next()) {
+    for (vframeStream stream(jt); !stream.at_end(); stream.next()) {
       Method* m = stream.method();
       if (m->is_scoped()) {
         StackValueCollection* locals = stream.asJavaVFrame()->locals();
@@ -127,19 +147,19 @@ class CloseScopedMemoryClosure : public HandshakeClosure {
  * a less common slow path instead.
  * Top frames containg obj will be deoptimized.
  */
-JVM_ENTRY(jboolean, ScopedMemoryAccess_closeScope(JNIEnv *env, jobject receiver, jobject deopt, jobject exception)) {
+JVM_ENTRY(jboolean, ScopedMemoryAccess_closeScope(JNIEnv *env, jobject receiver, jobject deopt, jobject exception))
   CloseScopedMemoryClosure cl(deopt, exception);
   Handshake::execute(&cl);
   return !cl._found;
-} JVM_END
+JVM_END
 
 /// JVM_RegisterUnsafeMethods
 
-#define LANG "Ljdk/internal/misc/"
+#define PKG "Ljdk/internal/misc/"
 
 #define MEMACCESS "ScopedMemoryAccess"
-#define SCOPE LANG MEMACCESS "$Scope;"
-#define SCOPED_ERR LANG MEMACCESS "$Scope$ScopedAccessError;"
+#define SCOPE PKG MEMACCESS "$Scope;"
+#define SCOPED_ERR PKG MEMACCESS "$Scope$ScopedAccessError;"
 
 #define CC (char*)  /*cast a literal from (const char*)*/
 #define FN_PTR(f) CAST_FROM_FN_PTR(void*, &f)
@@ -151,16 +171,16 @@ static JNINativeMethod jdk_internal_misc_ScopedMemoryAccess_methods[] = {
 #undef CC
 #undef FN_PTR
 
-#undef LANG
+#undef PKG
 #undef MEMACCESS
 #undef SCOPE
 #undef SCOPED_EXC
 
 // This function is exported, used by NativeLookup.
 
-JVM_ENTRY(void, JVM_RegisterJDKInternalMiscScopedMemoryAccessMethods(JNIEnv *env, jclass scopedMemoryAccessClass)) {
+JVM_ENTRY(void, JVM_RegisterJDKInternalMiscScopedMemoryAccessMethods(JNIEnv *env, jclass scopedMemoryAccessClass))
   ThreadToNativeFromVM ttnfv(thread);
 
   int ok = env->RegisterNatives(scopedMemoryAccessClass, jdk_internal_misc_ScopedMemoryAccess_methods, sizeof(jdk_internal_misc_ScopedMemoryAccess_methods)/sizeof(JNINativeMethod));
   guarantee(ok == 0, "register jdk.internal.misc.ScopedMemoryAccess natives");
-} JVM_END
+JVM_END
diff --git a/src/java.base/share/classes/java/lang/invoke/MemoryAccessVarHandleBase.java b/src/java.base/share/classes/java/lang/invoke/MemoryAccessVarHandleBase.java
index 3e0a26d6aae3a..dddfca9589c09 100644
--- a/src/java.base/share/classes/java/lang/invoke/MemoryAccessVarHandleBase.java
+++ b/src/java.base/share/classes/java/lang/invoke/MemoryAccessVarHandleBase.java
@@ -42,9 +42,9 @@ abstract class MemoryAccessVarHandleBase extends VarHandle {
     /** if true, only the base part of the address will be checked for alignment **/
     final boolean skipAlignmentMaskCheck;
 
-    MemoryAccessVarHandleBase(VarForm form, boolean skipOffetCheck, boolean be, long length, long alignmentMask) {
+    MemoryAccessVarHandleBase(VarForm form, boolean skipAlignmentMaskCheck, boolean be, long length, long alignmentMask) {
         super(form);
-        this.skipAlignmentMaskCheck = skipOffetCheck;
+        this.skipAlignmentMaskCheck = skipAlignmentMaskCheck;
         this.be = be;
         this.length = length;
         this.alignmentMask = alignmentMask;
diff --git a/test/jdk/java/foreign/TestMismatch.java b/test/jdk/java/foreign/TestMismatch.java
index b5e9ca3a60c9a..dc35054e411a0 100644
--- a/test/jdk/java/foreign/TestMismatch.java
+++ b/test/jdk/java/foreign/TestMismatch.java
@@ -23,7 +23,7 @@
 
 /*
  * @test
- * @run testng/othervm -XX:MaxDirectMemorySize=5000000000 TestMismatch
+ * @run testng TestMismatch
  */
 
 import java.lang.invoke.VarHandle;
@@ -110,15 +110,18 @@ public void testEmpty() {
 
     @Test
     public void testLarge() {
-        try (var s1 = MemorySegment.allocateNative((long)Integer.MAX_VALUE + 10L);
-             var s2 = MemorySegment.allocateNative((long)Integer.MAX_VALUE + 10L)) {
-            assertEquals(s1.mismatch(s1), -1);
-            assertEquals(s1.mismatch(s2), -1);
-            assertEquals(s2.mismatch(s1), -1);
+        // skip if not on 64 bits
+        if (MemoryLayouts.ADDRESS.byteSize() > 32) {
+            try (var s1 = MemorySegment.allocateNative((long) Integer.MAX_VALUE + 10L);
+                 var s2 = MemorySegment.allocateNative((long) Integer.MAX_VALUE + 10L)) {
+                assertEquals(s1.mismatch(s1), -1);
+                assertEquals(s1.mismatch(s2), -1);
+                assertEquals(s2.mismatch(s1), -1);
 
-            testLargeAcrossMaxBoundary(s1, s2);
+                testLargeAcrossMaxBoundary(s1, s2);
 
-            testLargeMismatchAcrossMaxBoundary(s1, s2);
+                testLargeMismatchAcrossMaxBoundary(s1, s2);
+            }
         }
     }
 
diff --git a/test/jdk/java/foreign/TestSegments.java b/test/jdk/java/foreign/TestSegments.java
index a582690e48a37..4fe5774149e98 100644
--- a/test/jdk/java/foreign/TestSegments.java
+++ b/test/jdk/java/foreign/TestSegments.java
@@ -23,7 +23,7 @@
 
 /*
  * @test
- * @run testng TestSegments
+ * @run testng/othervm -XX:MaxDirectMemorySize=1M TestSegments
  */
 
 import jdk.incubator.foreign.MemoryLayout;
@@ -100,6 +100,13 @@ public void testOpAfterClose(SegmentMember member) throws Throwable {
         }
     }
 
+    @Test(expectedExceptions = OutOfMemoryError.class)
+    public void testNativeAllocationTooBig() {
+        try (MemorySegment segment = MemorySegment.allocateNative(1024 * 1024 * 8 * 2)) { // 2M
+            // do nothing
+        }
+    }
+
     @Test
     public void testNativeSegmentIsZeroed() {
         VarHandle byteHandle = MemoryLayout.ofSequence(MemoryLayouts.JAVA_BYTE)

From b941c4a2ae1f4a99744e2e3787df76612f90b4d0 Mon Sep 17 00:00:00 2001
From: Maurizio Cimadamore 
Date: Thu, 8 Oct 2020 14:53:48 +0100
Subject: [PATCH 04/70] Fix indent in GensrcScopedMemoryAccess.gmk

---
 make/modules/java.base/gensrc/GensrcScopedMemoryAccess.gmk | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/make/modules/java.base/gensrc/GensrcScopedMemoryAccess.gmk b/make/modules/java.base/gensrc/GensrcScopedMemoryAccess.gmk
index 71d337e3ac068..ec0d8dd6087de 100644
--- a/make/modules/java.base/gensrc/GensrcScopedMemoryAccess.gmk
+++ b/make/modules/java.base/gensrc/GensrcScopedMemoryAccess.gmk
@@ -142,14 +142,14 @@ endef
 
 SCOPE_MEMORY_ACCESS_TYPES := Byte Short Char Int Long Float Double
 $(foreach t, $(SCOPE_MEMORY_ACCESS_TYPES), \
-	  $(eval $(call GenerateScopedOp,BIN_$t,$t)))
+  $(eval $(call GenerateScopedOp,BIN_$t,$t)))
 	
 $(DEST): $(BUILD_TOOLS_JDK) $(SCOPED_MEMORY_ACCESS_TEMPLATE) $(SCOPED_MEMORY_ACCESS_BIN_TEMPLATE)
 	$(MKDIR) -p $(SCOPED_MEMORY_ACCESS_GENSRC_DIR)
 	$(CP) $(SCOPED_MEMORY_ACCESS_TEMPLATE) $(DEST)
 	$(foreach t, $(SCOPE_MEMORY_ACCESS_TYPES), \
-		$(TOOL_SPP) -nel -K$(BIN_$t_type) -Dtype=$(BIN_$t_type) -DType=$(BIN_$t_Type) $(BIN_$t_ARGS) \
-		-i$(SCOPED_MEMORY_ACCESS_BIN_TEMPLATE) -o$(DEST) ;)
+	  $(TOOL_SPP) -nel -K$(BIN_$t_type) -Dtype=$(BIN_$t_type) -DType=$(BIN_$t_Type) $(BIN_$t_ARGS) \
+	  -i$(SCOPED_MEMORY_ACCESS_BIN_TEMPLATE) -o$(DEST) ;)
 	$(PRINTF) "}\n" >> $(DEST)
 	
 TARGETS += $(DEST)

From d96c32ac4a57f6d0fdd0e551659bd2106bd18db5 Mon Sep 17 00:00:00 2001
From: Maurizio Cimadamore 
Date: Fri, 9 Oct 2020 11:34:38 +0100
Subject: [PATCH 05/70] Address review comments

---
 src/hotspot/share/classfile/vmSymbols.hpp     |  2 +-
 .../misc/X-ScopedMemoryAccess.java.template   |  2 +-
 test/jdk/java/foreign/TestCleaner.java        | 20 ++++++++-----------
 3 files changed, 10 insertions(+), 14 deletions(-)

diff --git a/src/hotspot/share/classfile/vmSymbols.hpp b/src/hotspot/share/classfile/vmSymbols.hpp
index 4965c630fb0df..cee7081905a73 100644
--- a/src/hotspot/share/classfile/vmSymbols.hpp
+++ b/src/hotspot/share/classfile/vmSymbols.hpp
@@ -287,7 +287,7 @@
   template(jdk_internal_vm_annotation_DontInline_signature,  "Ljdk/internal/vm/annotation/DontInline;")  \
   template(jdk_internal_vm_annotation_ForceInline_signature, "Ljdk/internal/vm/annotation/ForceInline;") \
   template(jdk_internal_vm_annotation_Hidden_signature,      "Ljdk/internal/vm/annotation/Hidden;") \
-  template(jdk_internal_misc_Scoped_signature,    "Ljdk/internal/misc/ScopedMemoryAccess$Scoped;") \
+  template(jdk_internal_misc_Scoped_signature,               "Ljdk/internal/misc/ScopedMemoryAccess$Scoped;") \
   template(jdk_internal_vm_annotation_IntrinsicCandidate_signature, "Ljdk/internal/vm/annotation/IntrinsicCandidate;") \
   template(jdk_internal_vm_annotation_Stable_signature,      "Ljdk/internal/vm/annotation/Stable;") \
                                                                                                   \
diff --git a/src/java.base/share/classes/jdk/internal/misc/X-ScopedMemoryAccess.java.template b/src/java.base/share/classes/jdk/internal/misc/X-ScopedMemoryAccess.java.template
index 9c7494dba3bf7..7a261c5ad6ac3 100644
--- a/src/java.base/share/classes/jdk/internal/misc/X-ScopedMemoryAccess.java.template
+++ b/src/java.base/share/classes/jdk/internal/misc/X-ScopedMemoryAccess.java.template
@@ -47,7 +47,7 @@ import jdk.internal.vm.annotation.ForceInline;
  * when multiple threads are involved is much trickier, as there can be cases where a thread is accessing
  * a memory region while another thread is releasing it.
  * 

- * This class provides tools to manages races when multiple threads are accessing and/or releasing the same memory
+ * This class provides tools to manage races when multiple threads are accessing and/or releasing the same memory
  * region concurrently. More specifically, when a thread wants to release a memory region, it should call the
  * {@link #closeScope(jdk.internal.misc.ScopedMemoryAccess.Scope)} method provided by this class. This method initiates
  * thread-local handshakes with all the other VM threads, which are then stopped one by one. If any thread is found
diff --git a/test/jdk/java/foreign/TestCleaner.java b/test/jdk/java/foreign/TestCleaner.java
index c14f12f8b9c18..fc54c201d1496 100644
--- a/test/jdk/java/foreign/TestCleaner.java
+++ b/test/jdk/java/foreign/TestCleaner.java
@@ -38,6 +38,8 @@
 import org.testng.annotations.Test;
 import static org.testng.Assert.*;
 
+import java.util.ArrayList;
+import java.util.List;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.function.Function;
 import java.util.function.Supplier;
@@ -172,20 +174,14 @@ static Object[][] cleaners() {
                 (Supplier)CleanerFactory::cleaner
         };
 
-        RegisterKind[] kinds = RegisterKind.values();
-
-        SegmentFunction[] segmentFunctions = SegmentFunction.values();
-        Object[][] data = new Object[cleaners.length * kinds.length * segmentFunctions.length][3];
-
-        for (int kind = 0 ; kind < kinds.length ; kind++) {
-            for (int cleaner = 0 ; cleaner < cleaners.length ; cleaner++) {
-                for (int segmentFunction = 0 ; segmentFunction < segmentFunctions.length ; segmentFunction++) {
-                    data[kind + kinds.length * cleaner + (cleaners.length * kinds.length * segmentFunction)] =
-                            new Object[] { kinds[kind], cleaners[cleaner], segmentFunctions[segmentFunction] };
+        List data = new ArrayList<>();
+        for (RegisterKind kind : RegisterKind.values()) {
+            for (Object cleaner : cleaners) {
+                for (SegmentFunction segmentFunction : SegmentFunction.values()) {
+                    data.add(new Object[] {kind, cleaner, segmentFunction});
                 }
             }
         }
-
-        return data;
+        return data.toArray(Object[][]::new);
     }
 }

From 9b3fc2271e89fbea8d5381244826d05f800a4b74 Mon Sep 17 00:00:00 2001
From: Maurizio Cimadamore 
Date: Fri, 9 Oct 2020 12:30:57 +0100
Subject: [PATCH 06/70] Fix performance issue with "small" segment mismatch

---
 .../jdk/internal/foreign/AbstractMemorySegmentImpl.java  | 9 ++-------
 1 file changed, 2 insertions(+), 7 deletions(-)

diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/AbstractMemorySegmentImpl.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/AbstractMemorySegmentImpl.java
index 1ad5b905ea2e8..2b27d557b3c9d 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/AbstractMemorySegmentImpl.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/AbstractMemorySegmentImpl.java
@@ -31,7 +31,6 @@
 import jdk.internal.access.foreign.MemorySegmentProxy;
 import jdk.internal.access.foreign.UnmapperProxy;
 import jdk.internal.misc.ScopedMemoryAccess;
-import jdk.internal.misc.Unsafe;
 import jdk.internal.util.ArraysSupport;
 import jdk.internal.vm.annotation.ForceInline;
 import sun.security.action.GetPropertyAction;
@@ -59,7 +58,6 @@
  */
 public abstract class AbstractMemorySegmentImpl implements MemorySegment, MemorySegmentProxy {
 
-    private static final Unsafe UNSAFE = Unsafe.getUnsafe();
     private static final ScopedMemoryAccess SCOPED_MEMORY_ACCESS = ScopedMemoryAccess.getScopedMemoryAccess();
 
     private static final boolean enableSmallSegments =
@@ -139,9 +137,6 @@ public void copyFrom(MemorySegment src) {
                 base(), min(), size);
     }
 
-    private final static VarHandle BYTE_HANDLE = MemoryLayout.ofSequence(MemoryLayouts.JAVA_BYTE)
-            .varHandle(byte.class, MemoryLayout.PathElement.sequenceElement());
-
     @Override
     public long mismatch(MemorySegment other) {
         AbstractMemorySegmentImpl that = (AbstractMemorySegmentImpl)other;
@@ -157,7 +152,7 @@ public long mismatch(MemorySegment other) {
 
         long i = 0;
         if (length > 7) {
-            if ((byte) BYTE_HANDLE.get(this, 0) != (byte) BYTE_HANDLE.get(that, 0)) {
+            if (MemoryAccess.getByte(this) != MemoryAccess.getByte(that)) {
                 return 0;
             }
             i = vectorizedMismatchLargeForBytes(scope, that.scope,
@@ -172,7 +167,7 @@ public long mismatch(MemorySegment other) {
             i = length - remaining;
         }
         for (; i < length; i++) {
-            if ((byte) BYTE_HANDLE.get(this, i) != (byte) BYTE_HANDLE.get(that, i)) {
+            if (MemoryAccess.getByteAtOffset(this, i) != MemoryAccess.getByteAtOffset(that, i)) {
                 return i;
             }
         }

From 770b1e9c6550f628cb2b8378a9fa272ce27ec277 Mon Sep 17 00:00:00 2001
From: Maurizio Cimadamore 
Date: Mon, 12 Oct 2020 11:45:42 +0100
Subject: [PATCH 07/70] Tweak referenced to MemoryAddressProxy in Utils.java

---
 .../share/classes/jdk/internal/foreign/Utils.java     | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/Utils.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/Utils.java
index dbb8086414202..dd4d7b8bbfc91 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/Utils.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/Utils.java
@@ -26,7 +26,6 @@
 
 package jdk.internal.foreign;
 
-import jdk.incubator.foreign.MemoryAddress;
 import jdk.incubator.foreign.MemoryHandles;
 import jdk.incubator.foreign.MemorySegment;
 import jdk.internal.access.foreign.MemorySegmentProxy;
@@ -47,11 +46,11 @@ public final class Utils {
     private static final String foreignRestrictedAccess = Optional.ofNullable(VM.getSavedProperty("foreign.restricted"))
             .orElse("deny");
 
-    private static final MethodHandle ADDRESS_FILTER;
+    private static final MethodHandle SEGMENT_FILTER;
 
     static {
         try {
-            ADDRESS_FILTER = MethodHandles.lookup().findStatic(Utils.class, "filterSegment",
+            SEGMENT_FILTER = MethodHandles.lookup().findStatic(Utils.class, "filterSegment",
                     MethodType.methodType(MemorySegmentProxy.class, MemorySegment.class));
         } catch (Throwable ex) {
             throw new ExceptionInInitializerError(ex);
@@ -71,9 +70,9 @@ public static long bitsToBytesOrThrow(long bits, Supplier exFa
     }
 
     public static VarHandle fixUpVarHandle(VarHandle handle) {
-        // This adaptation is required, otherwise the memory access var handle will have type MemoryAddressProxy,
-        // and not MemoryAddress (which the user expects), which causes performance issues with asType() adaptations.
-        return MemoryHandles.filterCoordinates(handle, 0, ADDRESS_FILTER);
+        // This adaptation is required, otherwise the memory access var handle will have type MemorySegmentProxy,
+        // and not MemorySegment (which the user expects), which causes performance issues with asType() adaptations.
+        return MemoryHandles.filterCoordinates(handle, 0, SEGMENT_FILTER);
     }
 
     private static MemorySegmentProxy filterSegment(MemorySegment segment) {

From 75e406c0b46380b5ed0aeffaaa523794fca69e3f Mon Sep 17 00:00:00 2001
From: Maurizio Cimadamore 
Date: Mon, 12 Oct 2020 18:53:45 +0100
Subject: [PATCH 08/70] Tweak support for mapped memory segments

---
 .../classes/java/nio/MappedByteBuffer.java    |   9 +-
 .../misc/X-ScopedMemoryAccess.java.template   |  86 ++++++++++
 .../foreign/MappedMemorySegment.java          | 132 ---------------
 .../foreign/MappedMemorySegments.java         | 159 ++++++++++++++++++
 .../jdk/incubator/foreign/MemorySegment.java  |  59 ++++---
 .../foreign/AbstractMemorySegmentImpl.java    |  24 +--
 .../foreign/MappedMemorySegmentImpl.java      |  32 ++--
 test/jdk/java/foreign/TestByteBuffer.java     |  55 +++++-
 test/jdk/java/foreign/TestSegments.java       |   1 +
 test/jdk/java/foreign/TestSharedAccess.java   |   2 +-
 test/jdk/java/foreign/TestSpliterator.java    |  22 +--
 .../java/util/stream/SpliteratorTest.java     |   2 +-
 .../jdk/incubator/foreign/ParallelSum.java    |  16 +-
 13 files changed, 392 insertions(+), 207 deletions(-)
 delete mode 100644 src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MappedMemorySegment.java
 create mode 100644 src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MappedMemorySegments.java

diff --git a/src/java.base/share/classes/java/nio/MappedByteBuffer.java b/src/java.base/share/classes/java/nio/MappedByteBuffer.java
index d5461b639019b..3d89edec91e9a 100644
--- a/src/java.base/share/classes/java/nio/MappedByteBuffer.java
+++ b/src/java.base/share/classes/java/nio/MappedByteBuffer.java
@@ -31,6 +31,7 @@
 
 import jdk.internal.access.foreign.MemorySegmentProxy;
 import jdk.internal.access.foreign.UnmapperProxy;
+import jdk.internal.misc.ScopedMemoryAccess;
 
 
 /**
@@ -87,6 +88,8 @@ public abstract class MappedByteBuffer
     // determines the behavior of force operations.
     private final boolean isSync;
 
+    static ScopedMemoryAccess SCOPED_MEMORY_ACCESS = ScopedMemoryAccess.getScopedMemoryAccess();
+
     // This should only be invoked by the DirectByteBuffer constructors
     //
     MappedByteBuffer(int mark, int pos, int lim, int cap, // package-private
@@ -173,7 +176,7 @@ public final boolean isLoaded() {
         if (fd == null) {
             return true;
         }
-        return MappedMemoryUtils.isLoaded(address, isSync, capacity());
+        return SCOPED_MEMORY_ACCESS.isLoaded(scope(), address, isSync, capacity());
     }
 
     /**
@@ -191,7 +194,7 @@ public final MappedByteBuffer load() {
             return this;
         }
         try {
-            MappedMemoryUtils.load(address, isSync, capacity());
+            SCOPED_MEMORY_ACCESS.load(scope(), address, isSync, capacity());
         } finally {
             Reference.reachabilityFence(this);
         }
@@ -280,7 +283,7 @@ public final MappedByteBuffer force(int index, int length) {
         if ((address != 0) && (limit != 0)) {
             // check inputs
             Objects.checkFromIndexSize(index, length, limit);
-            MappedMemoryUtils.force(fd, address, isSync, index, length);
+            SCOPED_MEMORY_ACCESS.force(scope(), fd, address, isSync, index, length);
         }
         return this;
     }
diff --git a/src/java.base/share/classes/jdk/internal/misc/X-ScopedMemoryAccess.java.template b/src/java.base/share/classes/jdk/internal/misc/X-ScopedMemoryAccess.java.template
index 7a261c5ad6ac3..81c61fc47dbba 100644
--- a/src/java.base/share/classes/jdk/internal/misc/X-ScopedMemoryAccess.java.template
+++ b/src/java.base/share/classes/jdk/internal/misc/X-ScopedMemoryAccess.java.template
@@ -30,7 +30,9 @@ import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 import java.lang.ref.Reference;
+import java.io.FileDescriptor;
 
+import jdk.internal.access.SharedSecrets;
 import jdk.internal.util.ArraysSupport;
 import jdk.internal.vm.annotation.ForceInline;
 
@@ -235,5 +237,89 @@ public class ScopedMemoryAccess {
             Reference.reachabilityFence(bScope);
         }
     }
+
+    @ForceInline
+    public boolean isLoaded(Scope scope, long address, boolean isSync, long size) {
+        try {
+            return isLoadedInternal(scope, address, isSync, size);
+        } catch (Scope.ScopedAccessError ex) {
+            throw new IllegalStateException("This segment is already closed");
+        }
+    }
+
+    @ForceInline @Scoped
+    public boolean isLoadedInternal(Scope scope, long address, boolean isSync, long size) {
+        try {
+            if (scope != null) {
+                scope.checkValidState();
+            }
+            return SharedSecrets.getJavaNioAccess().isLoaded(address, isSync, size);
+        } finally {
+            Reference.reachabilityFence(scope);
+        }
+    }
+
+    @ForceInline
+    public void load(Scope scope, long address, boolean isSync, long size) {
+        try {
+            loadInternal(scope, address, isSync, size);
+        } catch (Scope.ScopedAccessError ex) {
+            throw new IllegalStateException("This segment is already closed");
+        }
+    }
+
+    @ForceInline @Scoped
+    public void loadInternal(Scope scope, long address, boolean isSync, long size) {
+        try {
+            if (scope != null) {
+                scope.checkValidState();
+            }
+            SharedSecrets.getJavaNioAccess().load(address, isSync, size);
+        } finally {
+            Reference.reachabilityFence(scope);
+        }
+    }
+
+    @ForceInline
+    public void unload(Scope scope, long address, boolean isSync, long size) {
+        try {
+            unloadInternal(scope, address, isSync, size);
+        } catch (Scope.ScopedAccessError ex) {
+            throw new IllegalStateException("This segment is already closed");
+        }
+    }
+
+    @ForceInline @Scoped
+    public void unloadInternal(Scope scope, long address, boolean isSync, long size) {
+        try {
+            if (scope != null) {
+                scope.checkValidState();
+            }
+            SharedSecrets.getJavaNioAccess().unload(address, isSync, size);
+        } finally {
+            Reference.reachabilityFence(scope);
+        }
+    }
+
+    @ForceInline
+    public void force(Scope scope, FileDescriptor fd, long address, boolean isSync, long index, long length) {
+        try {
+            forceInternal(scope, fd, address, isSync, index, length);
+        } catch (Scope.ScopedAccessError ex) {
+            throw new IllegalStateException("This segment is already closed");
+        }
+    }
+
+    @ForceInline @Scoped
+    public void forceInternal(Scope scope, FileDescriptor fd, long address, boolean isSync, long index, long length) {
+        try {
+            if (scope != null) {
+                scope.checkValidState();
+            }
+            SharedSecrets.getJavaNioAccess().force(fd, address, isSync, index, length);
+        } finally {
+            Reference.reachabilityFence(scope);
+        }
+    }
     // typed-ops here
 
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MappedMemorySegment.java b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MappedMemorySegment.java
deleted file mode 100644
index 1e573b865b212..0000000000000
--- a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MappedMemorySegment.java
+++ /dev/null
@@ -1,132 +0,0 @@
-/*
- * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.  Oracle designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code 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
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have any
- * questions.
- */
-
-package jdk.incubator.foreign;
-
-import java.nio.channels.FileChannel;
-import java.nio.file.Path;
-
-/**
- * A mapped memory segment, that is, a memory segment backed by memory-mapped file.
- *
- * 
 Mapped memory segments are created via the {@link MemorySegment#mapFromPath(Path, long, long, FileChannel.MapMode)}.
- * Mapped memory segments behave like ordinary segments, but provide additional capabilities to manipulate memory-mapped
- * memory regions, such as {@link #force()} and {@link #load()}.
- * 

- * All implementations of this interface must be value-based;
- * use of identity-sensitive operations (including reference equality ({@code ==}), identity hash code, or synchronization) on
- * instances of {@code MemoryLayout} may have unpredictable results and should be avoided. The {@code equals} method should
- * be used for comparisons.
- * 

- * Non-platform classes should not implement {@linkplain MappedMemorySegment} directly.
- *
- * 
 The content of a mapped memory segment can change at any time, for example
- * if the content of the corresponding region of the mapped file is changed by
- * this (or another) program.  Whether or not such changes occur, and when they
- * occur, is operating-system dependent and therefore unspecified.
- *
- * All or part of a mapped memory segment may become
- * inaccessible at any time, for example if the backing mapped file is truncated.  An
- * attempt to access an inaccessible region of a mapped memory segment will not
- * change the segment's content and will cause an unspecified exception to be
- * thrown either at the time of the access or at some later time.  It is
- * therefore strongly recommended that appropriate precautions be taken to
- * avoid the manipulation of a mapped file by this (or another) program, except to read or write
- * the file's content.
- *
- * @apiNote In the future, if the Java language permits, {@link MemorySegment}
- * may become a {@code sealed} interface, which would prohibit subclassing except by
- * explicitly permitted subtypes.
- */
-public interface MappedMemorySegment extends MemorySegment {
-
-    @Override
-    MappedMemorySegment withAccessModes(int accessModes);
-
-    @Override
-    MappedMemorySegment asSlice(long offset, long newSize);
-
-    /**
-     * Forces any changes made to this segment's content to be written to the
-     * storage device containing the mapped file.
-     *
-     * 
 If the file mapped into this segment resides on a local storage
-     * device then when this method returns it is guaranteed that all changes
-     * made to the segment since it was created, or since this method was last
-     * invoked, will have been written to that device.
-     *
-     * 
 If the file does not reside on a local device then no such guarantee
-     * is made.
-     *
-     * 
 If this segment was not mapped in read/write mode ({@link
-     * java.nio.channels.FileChannel.MapMode#READ_WRITE}) then
-     * invoking this method may have no effect. In particular, the
-     * method has no effect for segments mapped in read-only or private
-     * mapping modes. This method may or may not have an effect for
-     * implementation-specific mapping modes.
-     * 

-     */
-    void force();
-
-    /**
-     * Loads this segment's content into physical memory.
-     *
-     * 
 This method makes a best effort to ensure that, when it returns,
-     * this segment's contents is resident in physical memory.  Invoking this
-     * method may cause some number of page faults and I/O operations to
-     * occur. 

-     */
-    void load();
-
-    /**
-     * Unloads this segment's content from physical memory.
-     *
-     * 
 This method makes a best effort to ensure that this segment's contents are
-     * are no longer resident in physical memory. Accessing this segment's contents
-     * after invoking this method may cause some number of page faults and I/O operations to
-     * occur (as this segment's contents might need to be paged back in). 

-     */
-    void unload();
-
-    /**
-     * Tells whether or not this segment's content is resident in physical
-     * memory.
-     *
-     * 
 A return value of {@code true} implies that it is highly likely
-     * that all of the data in this segment is resident in physical memory and
-     * may therefore be accessed without incurring any virtual-memory page
-     * faults or I/O operations.  A return value of {@code false} does not
-     * necessarily imply that the segment's content is not resident in physical
-     * memory.
-     *
-     * 
 The returned value is a hint, rather than a guarantee, because the
-     * underlying operating system may have paged out some of the segment's data
-     * by the time that an invocation of this method returns.  

-     *
-     * @return  {@code true} if it is likely that this segment's content
-     *          is resident in physical memory
-     */
-    boolean isLoaded();
-}
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MappedMemorySegments.java b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MappedMemorySegments.java
new file mode 100644
index 0000000000000..04cccaf5f79c4
--- /dev/null
+++ b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MappedMemorySegments.java
@@ -0,0 +1,159 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package jdk.incubator.foreign;
+
+import jdk.internal.foreign.MappedMemorySegmentImpl;
+
+import java.nio.MappedByteBuffer;
+
+/**
+ * This class provides capabilities to manipulate mapped memory segments, such as {@link #force(MemorySegment)},
+ * and {@link #load(MemorySegment)}. The methods in these class are suitable replacements for some of the
+ * functionality in the {@link java.nio.MappedByteBuffer} class. Note that, while it is possible to map a segment
+ * into a byte buffer (see {@link MemorySegment#asByteBuffer()}), and call e.g. {@link MappedByteBuffer#force()} that way,
+ * this can only be done when the source segment is small enough, due to the size limitation inherent to the
+ * ByteBuffer API.
+ * 

+ * Clients requiring sophisticated, low-level control over mapped memory segments, should consider writing
+ * custom mapped memory segment factories; using JNI, e.g. on Linux, it is possible to call {@code mmap}
+ * with the desired parameters; the returned address can be easily wrapped into a memory segment, using
+ * {@link MemoryAddress#ofLong(long)} and {@link MemoryAddress#asSegmentRestricted(long, Runnable, Object)}.
+ *
+ * @implNote
+ * The behavior of the methods in this class is highly platform-dependent; as a result, calling these methods might
+ * be a no-op on certain platforms.
+ */
+public final class MappedMemorySegments {
+    private MappedMemorySegments() {
+        // no thanks
+    }
+
+    /**
+     * Tells whether or not the contents of the given segment is resident in physical
+     * memory.
+     *
+     * 
 A return value of {@code true} implies that it is highly likely
+     * that all of the data in the given segment is resident in physical memory and
+     * may therefore be accessed without incurring any virtual-memory page
+     * faults or I/O operations.  A return value of {@code false} does not
+     * necessarily imply that the segment's content is not resident in physical
+     * memory.
+     *
+     * 
 The returned value is a hint, rather than a guarantee, because the
+     * underlying operating system may have paged out some of the segment's data
+     * by the time that an invocation of this method returns.  

+     *
+     * @param segment the segment whose contents are to be tested.
+     * @return  {@code true} if it is likely that the contents of the given segment
+     *          is resident in physical memory
+     *
+     * @throws IllegalStateException if the given segment is not alive, or if the given segment is confined
+     * and this method is called from a thread other than the segment's owner thread.
+     * @throws UnsupportedOperationException if the given segment is not a mapped memory segment, e.g. if
+     * {@code segment.fileDescriptor().isEmpty()}.
+     */
+    public static boolean isLoaded(MemorySegment segment) {
+        return toMappedSegment(segment).isLoaded();
+    }
+
+    /**
+     * Loads the contents of the given segment into physical memory.
+     *
+     * 
 This method makes a best effort to ensure that, when it returns,
+     * this contents of the given segment is resident in physical memory.  Invoking this
+     * method may cause some number of page faults and I/O operations to
+     * occur. 

+     *
+     * @param segment the segment whose contents are to be loaded.
+     *
+     * @throws IllegalStateException if the given segment is not alive, or if the given segment is confined
+     * and this method is called from a thread other than the segment's owner thread.
+     * @throws UnsupportedOperationException if the given segment is not a mapped memory segment, e.g. if
+     * {@code segment.fileDescriptor().isEmpty()}.
+     */
+    public static void load(MemorySegment segment) {
+        toMappedSegment(segment).load();
+    }
+
+    /**
+     * Unloads the contents of the given segment from physical memory.
+     *
+     * 
 This method makes a best effort to ensure that the contents of the given segment are
+     * are no longer resident in physical memory. Accessing this segment's contents
+     * after invoking this method may cause some number of page faults and I/O operations to
+     * occur (as this segment's contents might need to be paged back in). 

+     *
+     * @param segment the segment whose contents are to be unloaded.
+     *
+     * @throws IllegalStateException if the given segment is not alive, or if the given segment is confined
+     * and this method is called from a thread other than the segment's owner thread.
+     * @throws UnsupportedOperationException if the given segment is not a mapped memory segment, e.g. if
+     * {@code segment.fileDescriptor().isEmpty()}.
+     */
+    public static void unload(MemorySegment segment) {
+        toMappedSegment(segment).unload();
+    }
+
+    /**
+     * Forces any changes made to the contents of the given segment to be written to the
+     * storage device described by the segment's file descriptor (see {@link MemorySegment#fileDescriptor()}).
+     *
+     * 
 If this mapping's file descriptor resides on a local storage
+     * device then when this method returns it is guaranteed that all changes
+     * made to the segment since it was created, or since this method was last
+     * invoked, will have been written to that device.
+     *
+     * 
 If this mapping's file descriptor does not reside on a local device then no such guarantee
+     * is made.
+     *
+     * 
 If the given segment was not mapped in read/write mode ({@link
+     * java.nio.channels.FileChannel.MapMode#READ_WRITE}) then
+     * invoking this method may have no effect. In particular, the
+     * method has no effect for segments mapped in read-only or private
+     * mapping modes. This method may or may not have an effect for
+     * implementation-specific mapping modes.
+     * 

+     *
+     * @param segment the segment whose contents are to be written to the storage device described by the
+     *                segment's file descriptor.
+     *
+     * @throws IllegalStateException if the given segment is not alive, or if the given segment is confined
+     * and this method is called from a thread other than the segment's owner thread.
+     * @throws UnsupportedOperationException if the given segment is not a mapped memory segment, e.g. if
+     * {@code segment.fileDescriptor().isEmpty()}.
+     */
+    public static void force(MemorySegment segment) {
+        toMappedSegment(segment).force();
+    }
+
+    static MappedMemorySegmentImpl toMappedSegment(MemorySegment segment) {
+        if (segment instanceof MappedMemorySegmentImpl) {
+            return (MappedMemorySegmentImpl)segment;
+        } else {
+            throw new UnsupportedOperationException("Not a mapped memory segment");
+        }
+    }
+}
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MemorySegment.java b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MemorySegment.java
index 728a3883f6fdb..a79ac33304653 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MemorySegment.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MemorySegment.java
@@ -26,6 +26,7 @@
 
 package jdk.incubator.foreign;
 
+import java.io.FileDescriptor;
 import java.lang.ref.Cleaner;
 import java.nio.ByteBuffer;
 
@@ -39,8 +40,8 @@
 import java.nio.channels.FileChannel;
 import java.nio.file.Path;
 import java.util.Objects;
+import java.util.Optional;
 import java.util.Spliterator;
-import java.util.function.Consumer;
 
 /**
  * A memory segment models a contiguous region of memory. A memory segment is associated with both spatial
@@ -75,8 +76,10 @@
  * by native memory.
  * 

  * Finally, it is also possible to obtain a memory segment backed by a memory-mapped file using the factory method
- * {@link MemorySegment#mapFromPath(Path, long, long, FileChannel.MapMode)}. Such memory segments are called mapped memory segments
- * (see {@link MappedMemorySegment}).
+ * {@link MemorySegment#mapFromPath(Path, long, long, FileChannel.MapMode)}. Such memory segments are called mapped memory segments;
+ * mapped memory segments are associated with a {@link FileDescriptor} instance which can be obtained calling the
+ * {@link #fileDescriptor()} method. For more operations on mapped memory segments, please refer to the
+ * {@link MappedMemorySegments} class.
  * 

  * Array and buffer segments are effectively views over existing memory regions which might outlive the
  * lifecycle of the segments derived from them, and can even be manipulated directly (e.g. via array access, or direct use
@@ -180,7 +183,7 @@
 SequenceLayout SEQUENCE_LAYOUT = MemoryLayout.ofSequence(1024, MemoryLayouts.JAVA_INT);
 try (MemorySegment segment = MemorySegment.allocateNative(SEQUENCE_LAYOUT).share()) {
     VarHandle VH_int = SEQUENCE_LAYOUT.elementLayout().varHandle(int.class);
-    int sum = StreamSupport.stream(MemorySegment.spliterator(segment, SEQUENCE_LAYOUT), true)
+    int sum = StreamSupport.stream(segment.spliterator(SEQUENCE_LAYOUT), true)
                            .mapToInt(s -> (int)VH_int.get(s.address()))
                            .sum();
 }
@@ -213,8 +216,7 @@
  * as such, if not closed explicitly (see {@link #close()}), the new segment will be automatically closed by the cleaner.
  *
  * @apiNote In the future, if the Java language permits, {@link MemorySegment}
- * may become a {@code sealed} interface, which would prohibit subclassing except by
- * {@link MappedMemorySegment} and other explicitly permitted subtypes.
+ * may become a {@code sealed} interface, which would prohibit subclassing except by other explicitly permitted subtypes.
  *
  * @implSpec
  * Implementations of this interface are immutable, thread-safe and value-based.
@@ -233,32 +235,25 @@ public interface MemorySegment extends Addressable, AutoCloseable {
     MemoryAddress address();
 
     /**
-     * Returns a spliterator for the given memory segment. The returned spliterator reports {@link Spliterator#SIZED},
+     * Returns a spliterator for this memory segment. The returned spliterator reports {@link Spliterator#SIZED},
      * {@link Spliterator#SUBSIZED}, {@link Spliterator#IMMUTABLE}, {@link Spliterator#NONNULL} and {@link Spliterator#ORDERED}
      * characteristics.
      * 

-     * The returned spliterator splits the segment according to the specified sequence layout; that is,
+     * The returned spliterator splits this segment according to the specified sequence layout; that is,
      * if the supplied layout is a sequence layout whose element count is {@code N}, then calling {@link Spliterator#trySplit()}
      * will result in a spliterator serving approximatively {@code N/2} elements (depending on whether N is even or not).
      * As such, splitting is possible as long as {@code N >= 2}. The spliterator returns segments that feature the same
      * access modes as the given segment less the {@link #CLOSE} access mode.
      * 

-     * The returned spliterator effectively allows to slice a segment into disjoint sub-segments, which can then
+     * The returned spliterator effectively allows to slice this segment into disjoint sub-segments, which can then
      * be processed in parallel by multiple threads (if the segment is shared).
-     * While closing the segment (see {@link #close()}) during pending concurrent execution will generally
-     * fail with an exception, it is possible to close a segment when a spliterator has been obtained but no thread
-     * is actively working on it using {@link Spliterator#tryAdvance(Consumer)}; in such cases, any subsequent call
-     * to {@link Spliterator#tryAdvance(Consumer)} will fail with an exception.
-     * @param segment the segment to be used for splitting.
+     *
      * @param layout the layout to be used for splitting.
-     * @param  the memory segment type
      * @return the element spliterator for this segment
      * @throws IllegalStateException if the segment is not alive, or if access occurs from a thread other than the
      * thread owning this segment
      */
-    static  Spliterator spliterator(S segment, SequenceLayout layout) {
-        return AbstractMemorySegmentImpl.spliterator(segment, layout);
-    }
+    Spliterator spliterator(SequenceLayout layout);
 
     /**
      * The thread owning this segment.
@@ -381,6 +376,14 @@ default MemorySegment asSlice(MemoryAddress newBase) {
         return asSlice(newBase.segmentOffset(this));
     }
 
+    /**
+     * Obtain the file descriptor with this memory segment, assuming this segment is a mapped memory segment,
+     * created using the {@link #mapFromPath(Path, long, long, FileChannel.MapMode)} factory, or a buffer segment
+     * derived from a {@link java.nio.MappedByteBuffer} using the {@link #ofByteBuffer(ByteBuffer)} factory.
+     * @return the file descriptor associated with this memory segment (if any).
+     */
+    Optional fileDescriptor();
+
     /**
      * Is this segment alive?
      * @return true, if the segment is alive.
@@ -396,7 +399,6 @@ default MemorySegment asSlice(MemoryAddress newBase) {
      * @throws IllegalStateException if this segment is not alive, or if access occurs from a thread other than the
      * thread owning this segment, or if this segment is shared and the segment is concurrently accessed while this method is
      * called.
-     * thread (see {@link #spliterator(MemorySegment, SequenceLayout)}).
      * @throws UnsupportedOperationException if this segment does not support the {@link #CLOSE} access mode.
      */
     void close();
@@ -802,6 +804,20 @@ static MemorySegment allocateNative(long bytesSize) {
      * The segment will feature all access modes (see {@link #ALL_ACCESS}),
      * unless the given mapping mode is {@linkplain FileChannel.MapMode#READ_ONLY READ_ONLY}, in which case
      * the segment will not feature the {@link #WRITE} access mode, and its confinement thread is the current thread (see {@link Thread#currentThread()}).
+     * 

+     * The content of a mapped memory segment can change at any time, for example
+     * if the content of the corresponding region of the mapped file is changed by
+     * this (or another) program.  Whether or not such changes occur, and when they
+     * occur, is operating-system dependent and therefore unspecified.
+     * 

+     * All or part of a mapped memory segment may become
+     * inaccessible at any time, for example if the backing mapped file is truncated.  An
+     * attempt to access an inaccessible region of a mapped memory segment will not
+     * change the segment's content and will cause an unspecified exception to be
+     * thrown either at the time of the access or at some later time.  It is
+     * therefore strongly recommended that appropriate precautions be taken to
+     * avoid the manipulation of a mapped file by this (or another) program, except to read or write
+     * the file's content.
      *
      * @implNote When obtaining a mapped segment from a newly created file, the initialization state of the contents of the block
      * of mapped memory associated with the returned mapped memory segment is unspecified and should not be relied upon.
@@ -810,14 +826,14 @@ static MemorySegment allocateNative(long bytesSize) {
      * @param bytesOffset the offset (expressed in bytes) within the file at which the mapped segment is to start.
      * @param bytesSize the size (in bytes) of the mapped memory backing the memory segment.
      * @param mapMode a file mapping mode, see {@link FileChannel#map(FileChannel.MapMode, long, long)}; the chosen mapping mode
-     *                might affect the behavior of the returned memory mapped segment (see {@link MappedMemorySegment#force()}).
+     *                might affect the behavior of the returned memory mapped segment (see {@link MappedMemorySegments#force(MemorySegment)}).
      * @return a new confined mapped memory segment.
      * @throws IllegalArgumentException if {@code bytesOffset < 0}.
      * @throws IllegalArgumentException if {@code bytesSize < 0}.
      * @throws UnsupportedOperationException if an unsupported map mode is specified.
      * @throws IOException if the specified path does not point to an existing file, or if some other I/O error occurs.
      */
-    static MappedMemorySegment mapFromPath(Path path, long bytesOffset, long bytesSize, FileChannel.MapMode mapMode) throws IOException {
+    static MemorySegment mapFromPath(Path path, long bytesOffset, long bytesSize, FileChannel.MapMode mapMode) throws IOException {
         return MappedMemorySegmentImpl.makeMappedSegment(path, bytesOffset, bytesSize, mapMode);
     }
 
@@ -898,7 +914,6 @@ static MemorySegment ofNativeRestricted() {
 
     /**
      * Share access mode; this segment support sharing with threads other than the owner thread (see {@link #share()}).
-     * (see {@link #spliterator(MemorySegment, SequenceLayout)}).
      * @see MemorySegment#accessModes()
      * @see MemorySegment#withAccessModes(int)
      */
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/AbstractMemorySegmentImpl.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/AbstractMemorySegmentImpl.java
index 2b27d557b3c9d..53278d6fbb5a5 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/AbstractMemorySegmentImpl.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/AbstractMemorySegmentImpl.java
@@ -35,14 +35,11 @@
 import jdk.internal.vm.annotation.ForceInline;
 import sun.security.action.GetPropertyAction;
 
+import java.io.FileDescriptor;
 import java.lang.invoke.VarHandle;
 import java.lang.ref.Cleaner;
 import java.nio.ByteBuffer;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Objects;
-import java.util.Random;
-import java.util.Spliterator;
+import java.util.*;
 import java.util.function.Consumer;
 import java.util.function.Function;
 import java.util.function.IntFunction;
@@ -110,14 +107,14 @@ private AbstractMemorySegmentImpl asSliceNoCheck(long offset, long newSize) {
         return dup(offset, newSize, mask, scope);
     }
 
-    @SuppressWarnings("unchecked")
-    public static  Spliterator spliterator(S segment, SequenceLayout sequenceLayout) {
-        ((AbstractMemorySegmentImpl)segment).checkValidState();
-        if (sequenceLayout.byteSize() != segment.byteSize()) {
+    @Override
+    public Spliterator spliterator(SequenceLayout sequenceLayout) {
+        checkValidState();
+        if (sequenceLayout.byteSize() != byteSize()) {
             throw new IllegalArgumentException();
         }
-        return (Spliterator)new SegmentSplitter(sequenceLayout.elementLayout().byteSize(), sequenceLayout.elementCount().getAsLong(),
-                (AbstractMemorySegmentImpl)segment.withAccessModes(segment.accessModes() & ~CLOSE));
+        return new SegmentSplitter(sequenceLayout.elementLayout().byteSize(), sequenceLayout.elementCount().getAsLong(),
+                withAccessModes(accessModes() & ~CLOSE));
     }
 
     @Override
@@ -315,6 +312,11 @@ public final void close() {
         scope.close();
     }
 
+    @Override
+    public Optional fileDescriptor() {
+        return Optional.empty();
+    }
+
     @Override
     public final byte[] toByteArray() {
         return toArray(byte[].class, 1, byte[]::new, MemorySegment::ofArray);
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/MappedMemorySegmentImpl.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/MappedMemorySegmentImpl.java
index 54dd038ccc0dd..4e644906d6c96 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/MappedMemorySegmentImpl.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/MappedMemorySegmentImpl.java
@@ -25,16 +25,19 @@
 
 package jdk.internal.foreign;
 
-import jdk.incubator.foreign.MappedMemorySegment;
+import jdk.incubator.foreign.MemorySegment;
 import jdk.internal.access.foreign.UnmapperProxy;
+import jdk.internal.misc.ScopedMemoryAccess;
 import sun.nio.ch.FileChannelImpl;
 
+import java.io.FileDescriptor;
 import java.io.IOException;
 import java.nio.ByteBuffer;
 import java.nio.channels.FileChannel;
 import java.nio.file.OpenOption;
 import java.nio.file.Path;
 import java.nio.file.StandardOpenOption;
+import java.util.Optional;
 
 /**
  * Implementation for a mapped memory segments. A mapped memory segment is a native memory segment, which
@@ -42,10 +45,12 @@
  * memory mapped segment, such as the file descriptor associated with the mapping. This information is crucial
  * in order to correctly reconstruct a byte buffer object from the segment (see {@link #makeByteBuffer()}).
  */
-public class MappedMemorySegmentImpl extends NativeMemorySegmentImpl implements MappedMemorySegment {
+public class MappedMemorySegmentImpl extends NativeMemorySegmentImpl {
 
     private final UnmapperProxy unmapper;
 
+    static ScopedMemoryAccess SCOPED_MEMORY_ACCESS = ScopedMemoryAccess.getScopedMemoryAccess();
+
     MappedMemorySegmentImpl(long min, UnmapperProxy unmapper, long length, int mask, MemoryScope scope) {
         super(min, length, mask, scope);
         this.unmapper = unmapper;
@@ -75,28 +80,35 @@ public MappedMemorySegmentImpl withAccessModes(int accessModes) {
     }
 
     @Override
+    public Optional fileDescriptor() {
+        return Optional.of(unmapper.fileDescriptor());
+    }
+
+    // support for mapped segments
+
+    public MemorySegment segment() {
+        return MappedMemorySegmentImpl.this;
+    }
+
     public void load() {
-        nioAccess.load(min, unmapper.isSync(), length);
+        SCOPED_MEMORY_ACCESS.load(scope, min, unmapper.isSync(), length);
     }
 
-    @Override
     public void unload() {
-        nioAccess.unload(min, unmapper.isSync(), length);
+        SCOPED_MEMORY_ACCESS.unload(scope, min, unmapper.isSync(), length);
     }
 
-    @Override
     public boolean isLoaded() {
-        return nioAccess.isLoaded(min, unmapper.isSync(), length);
+        return SCOPED_MEMORY_ACCESS.isLoaded(scope, min, unmapper.isSync(), length);
     }
 
-    @Override
     public void force() {
-        nioAccess.force(unmapper.fileDescriptor(), min, unmapper.isSync(), 0, length);
+        SCOPED_MEMORY_ACCESS.force(scope, unmapper.fileDescriptor(), min, unmapper.isSync(), 0, length);
     }
 
     // factories
 
-    public static MappedMemorySegment makeMappedSegment(Path path, long bytesOffset, long bytesSize, FileChannel.MapMode mapMode) throws IOException {
+    public static MemorySegment makeMappedSegment(Path path, long bytesOffset, long bytesSize, FileChannel.MapMode mapMode) throws IOException {
         if (bytesSize < 0) throw new IllegalArgumentException("Requested bytes size must be >= 0.");
         if (bytesOffset < 0) throw new IllegalArgumentException("Requested bytes offset must be >= 0.");
         try (FileChannelImpl channelImpl = (FileChannelImpl)FileChannel.open(path, openOptions(mapMode))) {
diff --git a/test/jdk/java/foreign/TestByteBuffer.java b/test/jdk/java/foreign/TestByteBuffer.java
index fcbc6b2c11880..823514a942111 100644
--- a/test/jdk/java/foreign/TestByteBuffer.java
+++ b/test/jdk/java/foreign/TestByteBuffer.java
@@ -29,7 +29,7 @@
  */
 
 
-import jdk.incubator.foreign.MappedMemorySegment;
+import jdk.incubator.foreign.MappedMemorySegments;
 import jdk.incubator.foreign.MemoryAccess;
 import jdk.incubator.foreign.MemoryLayouts;
 import jdk.incubator.foreign.MemoryLayout;
@@ -72,7 +72,6 @@
 
 import jdk.internal.foreign.HeapMemorySegmentImpl;
 import jdk.internal.foreign.MappedMemorySegmentImpl;
-import jdk.internal.foreign.MemoryAddressImpl;
 import jdk.internal.foreign.NativeMemorySegmentImpl;
 import org.testng.SkipException;
 import org.testng.annotations.*;
@@ -227,12 +226,12 @@ public void testChannel() throws Throwable {
 
     @Test
     public void testDefaultAccessModesMappedSegment() throws Throwable {
-        try (MappedMemorySegment segment = MemorySegment.mapFromPath(tempPath, 0L, 8, FileChannel.MapMode.READ_WRITE)) {
+        try (MemorySegment segment = MemorySegment.mapFromPath(tempPath, 0L, 8, FileChannel.MapMode.READ_WRITE)) {
             assertTrue(segment.hasAccessModes(ALL_ACCESS));
             assertEquals(segment.accessModes(), ALL_ACCESS);
         }
 
-        try (MappedMemorySegment segment = MemorySegment.mapFromPath(tempPath, 0L, 8, FileChannel.MapMode.READ_ONLY)) {
+        try (MemorySegment segment = MemorySegment.mapFromPath(tempPath, 0L, 8, FileChannel.MapMode.READ_ONLY)) {
             assertTrue(segment.hasAccessModes(ALL_ACCESS & ~WRITE));
             assertEquals(segment.accessModes(), ALL_ACCESS & ~WRITE);
         }
@@ -245,9 +244,9 @@ public void testMappedSegment() throws Throwable {
         f.deleteOnExit();
 
         //write to channel
-        try (MappedMemorySegment segment = MemorySegment.mapFromPath(f.toPath(), 0L, tuples.byteSize(), FileChannel.MapMode.READ_WRITE)) {
+        try (MemorySegment segment = MemorySegment.mapFromPath(f.toPath(), 0L, tuples.byteSize(), FileChannel.MapMode.READ_WRITE)) {
             initTuples(segment, tuples.elementCount().getAsLong());
-            segment.force();
+            MappedMemorySegments.force(segment);
         }
 
         //read from channel
@@ -256,6 +255,18 @@ public void testMappedSegment() throws Throwable {
         }
     }
 
+    @Test(dataProvider = "mappedOps", expectedExceptions = IllegalStateException.class)
+    public void testMappedSegmentOperations(MappedSegmentOp mappedBufferOp) throws Throwable {
+        File f = new File("test3.out");
+        f.createNewFile();
+        f.deleteOnExit();
+
+        MemorySegment segment = MemorySegment.mapFromPath(f.toPath(), 0L, 8, FileChannel.MapMode.READ_WRITE);
+        assertTrue(segment.fileDescriptor().isPresent());
+        segment.close();
+        mappedBufferOp.apply(segment);
+    }
+
     @Test
     public void testMappedSegmentOffset() throws Throwable {
         File f = new File("test3.out");
@@ -267,9 +278,9 @@ public void testMappedSegmentOffset() throws Throwable {
         // write one at a time
         for (int i = 0 ; i < tuples.byteSize() ; i += tupleLayout.byteSize()) {
             //write to channel
-            try (MappedMemorySegment segment = MemorySegment.mapFromPath(f.toPath(), i, tuples.byteSize(), FileChannel.MapMode.READ_WRITE)) {
+            try (MemorySegment segment = MemorySegment.mapFromPath(f.toPath(), i, tuples.byteSize(), FileChannel.MapMode.READ_WRITE)) {
                 initTuples(segment, 1);
-                segment.force();
+                MappedMemorySegments.force(segment);
             }
         }
 
@@ -709,4 +720,32 @@ public static Object[][] bufferSources() {
             throw new ExceptionInInitializerError(ex);
         }
     }
+
+    enum MappedSegmentOp {
+        LOAD(MappedMemorySegments::load),
+        UNLOAD(MappedMemorySegments::unload),
+        IS_LOADED(MappedMemorySegments::isLoaded),
+        FORCE(MappedMemorySegments::force),
+        BUFFER_LOAD(m -> ((MappedByteBuffer)m.asByteBuffer()).load()),
+        BUFFER_IS_LOADED(m -> ((MappedByteBuffer)m.asByteBuffer()).isLoaded()),
+        BUFFER_FORCE(m -> ((MappedByteBuffer)m.asByteBuffer()).force());
+
+
+        private Consumer segmentOp;
+
+        MappedSegmentOp(Consumer segmentOp) {
+            this.segmentOp = segmentOp;
+        }
+
+        void apply(MemorySegment segment) {
+            segmentOp.accept(segment);
+        }
+    }
+
+    @DataProvider(name = "mappedOps")
+    public static Object[][] mappedOps() {
+        return Stream.of(MappedSegmentOp.values())
+                .map(op -> new Object[] { op })
+                .toArray(Object[][]::new);
+    }
 }
diff --git a/test/jdk/java/foreign/TestSegments.java b/test/jdk/java/foreign/TestSegments.java
index 4fe5774149e98..5c702fb4626b1 100644
--- a/test/jdk/java/foreign/TestSegments.java
+++ b/test/jdk/java/foreign/TestSegments.java
@@ -335,6 +335,7 @@ static class SegmentMember {
                 "handoff",
                 "registerCleaner",
                 "fill",
+                "spliterator",
                 "copyFrom",
                 "mismatch",
                 "toByteArray",
diff --git a/test/jdk/java/foreign/TestSharedAccess.java b/test/jdk/java/foreign/TestSharedAccess.java
index 3e58a61c9f2d4..b908c129b66ee 100644
--- a/test/jdk/java/foreign/TestSharedAccess.java
+++ b/test/jdk/java/foreign/TestSharedAccess.java
@@ -81,7 +81,7 @@ public void testShared() throws Throwable {
             }
             List threads = new ArrayList<>();
             List> spliterators = new ArrayList<>();
-            spliterators.add(MemorySegment.spliterator(s, layout));
+            spliterators.add(s.spliterator(layout));
             while (true) {
                 boolean progress = false;
                 List> newSpliterators = new ArrayList<>();
diff --git a/test/jdk/java/foreign/TestSpliterator.java b/test/jdk/java/foreign/TestSpliterator.java
index 2cc1b3a3a4d20..233b2ed6a6382 100644
--- a/test/jdk/java/foreign/TestSpliterator.java
+++ b/test/jdk/java/foreign/TestSpliterator.java
@@ -69,13 +69,13 @@ public void testSum(int size, int threshold) {
         long serial = sum(0, segment);
         assertEquals(serial, expected);
         //parallel counted completer
-        long parallelCounted = new SumSegmentCounted(null, MemorySegment.spliterator(segment, layout), threshold).invoke();
+        long parallelCounted = new SumSegmentCounted(null, segment.spliterator(layout), threshold).invoke();
         assertEquals(parallelCounted, expected);
         //parallel recursive action
-        long parallelRecursive = new SumSegmentRecursive(MemorySegment.spliterator(segment, layout), threshold).invoke();
+        long parallelRecursive = new SumSegmentRecursive(segment.spliterator(layout), threshold).invoke();
         assertEquals(parallelRecursive, expected);
         //parallel stream
-        long streamParallel = StreamSupport.stream(MemorySegment.spliterator(segment, layout), true)
+        long streamParallel = StreamSupport.stream(segment.spliterator(layout), true)
                 .reduce(0L, TestSpliterator::sumSingle, Long::sum);
         assertEquals(streamParallel, expected);
         segment.close();
@@ -93,7 +93,7 @@ public void testSumSameThread() {
 
         //check that a segment w/o ACQUIRE access mode can still be used from same thread
         AtomicLong spliteratorSum = new AtomicLong();
-        spliterator(segment.withAccessModes(MemorySegment.READ), layout)
+        segment.withAccessModes(MemorySegment.READ).spliterator(layout)
                 .forEachRemaining(s -> spliteratorSum.addAndGet(sumSingle(0L, s)));
         assertEquals(spliteratorSum.get(), expected);
     }
@@ -209,13 +209,13 @@ public Object[][] accessScenarios() {
         var mallocSegment = MemorySegment.allocateNative(layout);
 
         Map>,Integer> l = Map.of(
-            () -> spliterator(mallocSegment.withAccessModes(ALL_ACCESS), layout), ALL_ACCESS,
-            () -> spliterator(mallocSegment.withAccessModes(0), layout), 0,
-            () -> spliterator(mallocSegment.withAccessModes(READ), layout), READ,
-            () -> spliterator(mallocSegment.withAccessModes(CLOSE), layout), 0,
-            () -> spliterator(mallocSegment.withAccessModes(READ|WRITE), layout), READ|WRITE,
-            () -> spliterator(mallocSegment.withAccessModes(READ|WRITE| SHARE), layout), READ|WRITE| SHARE,
-            () -> spliterator(mallocSegment.withAccessModes(READ|WRITE| SHARE |HANDOFF), layout), READ|WRITE| SHARE |HANDOFF
+            () -> mallocSegment.withAccessModes(ALL_ACCESS).spliterator(layout), ALL_ACCESS,
+            () -> mallocSegment.withAccessModes(0).spliterator(layout), 0,
+            () -> mallocSegment.withAccessModes(READ).spliterator(layout), READ,
+            () -> mallocSegment.withAccessModes(CLOSE).spliterator(layout), 0,
+            () -> mallocSegment.withAccessModes(READ|WRITE).spliterator(layout), READ|WRITE,
+            () -> mallocSegment.withAccessModes(READ|WRITE| SHARE).spliterator(layout), READ|WRITE| SHARE,
+            () -> mallocSegment.withAccessModes(READ|WRITE| SHARE |HANDOFF).spliterator(layout), READ|WRITE| SHARE |HANDOFF
 
         );
         return l.entrySet().stream().map(e -> new Object[] { e.getKey(), e.getValue() }).toArray(Object[][]::new);
diff --git a/test/jdk/java/util/stream/test/org/openjdk/tests/java/util/stream/SpliteratorTest.java b/test/jdk/java/util/stream/test/org/openjdk/tests/java/util/stream/SpliteratorTest.java
index 1a18ae4e7a253..1f9f52ff8e027 100644
--- a/test/jdk/java/util/stream/test/org/openjdk/tests/java/util/stream/SpliteratorTest.java
+++ b/test/jdk/java/util/stream/test/org/openjdk/tests/java/util/stream/SpliteratorTest.java
@@ -66,7 +66,7 @@ public void testDoubleSpliterator(String name, Supplier su
     public void testSegmentSpliterator(String name, SequenceLayout layout, SpliteratorTestHelper.ContentAsserter contentAsserter) {
         try (MemorySegment segment = MemorySegment.allocateNative(layout)) {
             SegmentTestDataProvider.initSegment(segment);
-            SpliteratorTestHelper.testSpliterator(() -> MemorySegment.spliterator(segment, layout),
+            SpliteratorTestHelper.testSpliterator(() -> segment.spliterator(layout),
                     SegmentTestDataProvider::segmentCopier, contentAsserter);
         }
     }
diff --git a/test/micro/org/openjdk/bench/jdk/incubator/foreign/ParallelSum.java b/test/micro/org/openjdk/bench/jdk/incubator/foreign/ParallelSum.java
index 150261833623b..4bebe01de09f7 100644
--- a/test/micro/org/openjdk/bench/jdk/incubator/foreign/ParallelSum.java
+++ b/test/micro/org/openjdk/bench/jdk/incubator/foreign/ParallelSum.java
@@ -117,23 +117,23 @@ public int unsafe_serial() {
 
     @Benchmark
     public int segment_parallel() {
-        return new SumSegment(MemorySegment.spliterator(segment, SEQUENCE_LAYOUT), SEGMENT_TO_INT).invoke();
+        return new SumSegment(segment.spliterator(SEQUENCE_LAYOUT), SEGMENT_TO_INT).invoke();
     }
 
     @Benchmark
     public int segment_parallel_bulk() {
-        return new SumSegment(MemorySegment.spliterator(segment, SEQUENCE_LAYOUT_BULK), SEGMENT_TO_INT_BULK).invoke();
+        return new SumSegment(segment.spliterator(SEQUENCE_LAYOUT_BULK), SEGMENT_TO_INT_BULK).invoke();
     }
 
     @Benchmark
     public int segment_stream_parallel() {
-        return StreamSupport.stream(MemorySegment.spliterator(segment, SEQUENCE_LAYOUT), true)
+        return StreamSupport.stream(segment.spliterator(SEQUENCE_LAYOUT), true)
                 .mapToInt(SEGMENT_TO_INT).sum();
     }
 
     @Benchmark
     public int segment_stream_parallel_bulk() {
-        return StreamSupport.stream(MemorySegment.spliterator(segment, SEQUENCE_LAYOUT_BULK), true)
+        return StreamSupport.stream(segment.spliterator(SEQUENCE_LAYOUT_BULK), true)
                 .mapToInt(SEGMENT_TO_INT_BULK).sum();
     }
 
@@ -150,28 +150,28 @@ public int segment_stream_parallel_bulk() {
 
     @Benchmark
     public Optional segment_stream_findany_serial() {
-        return StreamSupport.stream(MemorySegment.spliterator(segment, SEQUENCE_LAYOUT), false)
+        return StreamSupport.stream(segment.spliterator(SEQUENCE_LAYOUT), false)
                 .filter(FIND_SINGLE)
                 .findAny();
     }
 
     @Benchmark
     public Optional segment_stream_findany_parallel() {
-        return StreamSupport.stream(MemorySegment.spliterator(segment, SEQUENCE_LAYOUT), true)
+        return StreamSupport.stream(segment.spliterator(SEQUENCE_LAYOUT), true)
                 .filter(FIND_SINGLE)
                 .findAny();
     }
 
     @Benchmark
     public Optional segment_stream_findany_serial_bulk() {
-        return StreamSupport.stream(MemorySegment.spliterator(segment, SEQUENCE_LAYOUT_BULK), false)
+        return StreamSupport.stream(segment.spliterator(SEQUENCE_LAYOUT_BULK), false)
                 .filter(FIND_BULK)
                 .findAny();
     }
 
     @Benchmark
     public Optional segment_stream_findany_parallel_bulk() {
-        return StreamSupport.stream(MemorySegment.spliterator(segment, SEQUENCE_LAYOUT_BULK), true)
+        return StreamSupport.stream(segment.spliterator(SEQUENCE_LAYOUT_BULK), true)
                 .filter(FIND_BULK)
                 .findAny();
     }

From d14d06a4bdf54be3a6fe900f11010fa5aa5d5836 Mon Sep 17 00:00:00 2001
From: Maurizio Cimadamore 
Date: Mon, 12 Oct 2020 21:13:18 +0100
Subject: [PATCH 09/70] Simplify example in the toplevel javadoc

---
 .../jdk/incubator/foreign/package-info.java   | 19 +++++++++----------
 1 file changed, 9 insertions(+), 10 deletions(-)

diff --git a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/package-info.java b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/package-info.java
index e318e9c69f249..5d4000e0aa230 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/package-info.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/package-info.java
@@ -31,7 +31,9 @@
  * The first models a contiguous memory region, which can reside either inside or outside the Java heap; the latter models an address - which also can
  * reside either inside or outside the Java heap (and can sometimes be expressed as an offset into a given segment).
  * A memory segment represents the main access coordinate of a memory access var handle, which can be obtained
- * using the combinator methods defined in the {@link jdk.incubator.foreign.MemoryHandles} class. Finally, the {@link jdk.incubator.foreign.MemoryLayout} class
+ * using the combinator methods defined in the {@link jdk.incubator.foreign.MemoryHandles} class; a set of
+ * common dereference operations is provided also by the {@link jdk.incubator.foreign.MemoryAccess} class, which can
+ * be useful for simple, non-structured access. Finally, the {@link jdk.incubator.foreign.MemoryLayout} class
  * hierarchy enables description of memory layouts and basic operations such as computing the size in bytes of a given
  * layout, obtain its alignment requirements, and so on. Memory layouts also provide an alternate, more abstract way, to produce
  * memory access var handles, e.g. using layout paths.
@@ -40,24 +42,21 @@
  * ranging from {@code 0} to {@code 9}, we can use the following code:
  *
  * 
{@code
-static final VarHandle intHandle = MemoryHandles.varHandle(int.class, ByteOrder.nativeOrder());
-
 try (MemorySegment segment = MemorySegment.allocateNative(10 * 4)) {
-    for (long i = 0 ; i < 10 ; i++) {
-       intHandle.set(base.asSlice(i * 4), (int)i);
+    for (int i = 0 ; i < 10 ; i++) {
+       MemoryAccess.setIntAtIndex(segment, i);
     }
 }
  * }

  *
- * Here we create a var handle, namely {@code intHandle}, to manipulate values of the primitive type {@code int}, at
- * a given memory location. Also, {@code intHandle} is stored in a {@code static} and {@code final} field, to achieve
- * better performance and allow for inlining of the memory access operation through the {@link java.lang.invoke.VarHandle}
- * instance. We then create a native memory segment, that is, a memory segment backed by
+ * Here create a native memory segment, that is, a memory segment backed by
  * off-heap memory; the size of the segment is 40 bytes, enough to store 10 values of the primitive type {@code int}.
  * The segment is created inside a try-with-resources construct: this idiom ensures that all the memory resources
  * associated with the segment will be released at the end of the block, according to the semantics described in
  * Section {@jls 14.20.3} of The Java Language Specification. Inside the try-with-resources block, we initialize
- * the contents of the memory segment; more specifically, if we view the memory segment as a set of 10 adjacent slots,
+ * the contents of the memory segment using the
+ * {@link jdk.incubator.foreign.MemoryAccess#setIntAtIndex(jdk.incubator.foreign.MemorySegment, long, int)} helper method;
+ * more specifically, if we view the memory segment as a set of 10 adjacent slots,
  * {@code s[i]}, where {@code 0 <= i < 10}, where the size of each slot is exactly 4 bytes, the initialization logic above will set each slot
  * so that {@code s[i] = i}, again where {@code 0 <= i < 10}.
  *

From 8fb8ff2ff977a4fc7296163d0f9db4169fdea2e2 Mon Sep 17 00:00:00 2001
From: Maurizio Cimadamore 
Date: Tue, 13 Oct 2020 12:00:24 +0100
Subject: [PATCH 10/70] Remove spurious check on MemoryScope::confineTo Added
 tests to make sure no spurious exception is thrown when: * handing off a
 segment from A to A * sharing an already shared segment

---
 .../jdk/internal/foreign/MemoryScope.java        | 14 +++-----------
 test/jdk/java/foreign/TestSharedAccess.java      | 16 ++++++++++++++++
 2 files changed, 19 insertions(+), 11 deletions(-)

diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/MemoryScope.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/MemoryScope.java
index c89d8777ab882..3d093e76778c4 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/MemoryScope.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/MemoryScope.java
@@ -113,7 +113,7 @@ final void close() {
      * @throws IllegalStateException if this scope is already closed or if this is
      * a confined scope and this method is called outside of the owner thread.
      */
-    MemoryScope confineTo(Thread newOwner) {
+    final MemoryScope confineTo(Thread newOwner) {
         try {
             justClose();
             if (scopeCleanable != null) {
@@ -133,7 +133,7 @@ MemoryScope confineTo(Thread newOwner) {
      * a confined scope and this method is called outside of the owner thread,
      * or if this is already a shared scope.
      */
-    MemoryScope share() {
+    final MemoryScope share() {
         try {
             justClose();
             if (scopeCleanable != null) {
@@ -146,7 +146,7 @@ MemoryScope share() {
         }
     }
 
-    MemoryScope cleanable(Cleaner cleaner) {
+    final MemoryScope cleanable(Cleaner cleaner) {
         if (scopeCleanable != null) {
             throw new IllegalStateException("Already registered with a cleaner");
         }
@@ -220,14 +220,6 @@ void justClose() {
             closed = true;
         }
 
-        @Override
-        MemoryScope confineTo(Thread newOwner) {
-            if (newOwner == owner) {
-                throw new IllegalArgumentException("Segment already owned by thread: " + newOwner);
-            }
-            return super.confineTo(newOwner);
-        }
-
         @Override
         Thread ownerThread() {
             return owner;
diff --git a/test/jdk/java/foreign/TestSharedAccess.java b/test/jdk/java/foreign/TestSharedAccess.java
index b908c129b66ee..29e1fbeb2191b 100644
--- a/test/jdk/java/foreign/TestSharedAccess.java
+++ b/test/jdk/java/foreign/TestSharedAccess.java
@@ -140,6 +140,22 @@ public void testSharedUnsafe() throws Throwable {
         }
     }
 
+    @Test
+    public void testHandoffToSelf() {
+        MemorySegment s1 = MemorySegment.ofArray(new int[4]);
+        MemorySegment s2 = s1.handoff(Thread.currentThread());
+        assertFalse(s1.isAlive());
+        assertTrue(s2.isAlive());
+    }
+
+    @Test
+    public void testShareTwice() {
+        MemorySegment s1 = MemorySegment.ofArray(new int[4]).share();
+        MemorySegment s2 = s1.share();
+        assertFalse(s1.isAlive());
+        assertTrue(s2.isAlive());
+    }
+
     @Test(expectedExceptions=UnsupportedOperationException.class)
     public void testBadHandoffNoAccess() {
         MemorySegment.ofArray(new int[4])

From 4506d75c15a46b873e180670259f0f52a2e61fb6 Mon Sep 17 00:00:00 2001
From: Maurizio Cimadamore 
Date: Tue, 13 Oct 2020 12:19:46 +0100
Subject: [PATCH 11/70] Merge with master

---
 src/hotspot/cpu/aarch64/aarch64.ad            |   5 +
 .../cpu/aarch64/sharedRuntime_aarch64.cpp     |   7 +
 src/hotspot/cpu/aarch64/vmreg_aarch64.cpp     |  16 +-
 src/hotspot/cpu/x86/assembler_x86.cpp         |  38 ++--
 src/hotspot/cpu/x86/assembler_x86.hpp         |  13 +-
 src/hotspot/cpu/x86/frame_x86.cpp             |   5 +
 src/hotspot/cpu/x86/javaFrameAnchor_x86.hpp   |   9 +
 src/hotspot/cpu/x86/macroAssembler_x86.cpp    |  37 ++-
 src/hotspot/cpu/x86/macroAssembler_x86.hpp    |   7 +-
 src/hotspot/cpu/x86/methodHandles_x86.cpp     |  12 +-
 src/hotspot/cpu/x86/sharedRuntime_x86_64.cpp  | 214 +++++++++++++++++-
 src/hotspot/cpu/x86/vmreg_x86.cpp             |  18 +-
 src/hotspot/cpu/x86/x86_64.ad                 |  17 ++
 src/hotspot/share/adlc/formssel.cpp           |   5 +
 src/hotspot/share/c1/c1_GraphBuilder.cpp      |   3 +
 src/hotspot/share/c1/c1_IR.hpp                |   2 +-
 src/hotspot/share/ci/ciClassList.hpp          |   4 +-
 src/hotspot/share/ci/ciEnv.cpp                |   7 +-
 src/hotspot/share/ci/ciEnv.hpp                |   4 +-
 src/hotspot/share/ci/ciObjArray.cpp           |   4 +-
 src/hotspot/share/ci/ciObject.hpp             |   7 +-
 src/hotspot/share/ci/ciObjectFactory.cpp      |   3 +
 src/hotspot/share/classfile/javaClasses.cpp   |  59 +++++
 src/hotspot/share/classfile/javaClasses.hpp   |  46 ++++
 .../share/classfile/systemDictionary.hpp      |   1 +
 src/hotspot/share/classfile/vmIntrinsics.hpp  |   1 +
 src/hotspot/share/classfile/vmSymbols.hpp     |  11 +-
 src/hotspot/share/code/codeCache.cpp          |   4 +-
 src/hotspot/share/code/compiledMethod.cpp     |   1 +
 src/hotspot/share/code/debugInfoRec.cpp       |   2 +
 src/hotspot/share/code/debugInfoRec.hpp       |   1 +
 src/hotspot/share/code/nmethod.cpp            |  29 ++-
 src/hotspot/share/code/nmethod.hpp            |  15 +-
 src/hotspot/share/code/pcDesc.hpp             |  12 +-
 src/hotspot/share/code/scopeDesc.hpp          |   4 +
 src/hotspot/share/code/vmreg.hpp              |   4 +-
 .../share/jvmci/jvmciCodeInstaller.cpp        |   2 +-
 src/hotspot/share/jvmci/jvmciRuntime.cpp      |   2 +-
 src/hotspot/share/oops/method.cpp             |   3 +
 src/hotspot/share/opto/callGenerator.cpp      |  41 ++++
 src/hotspot/share/opto/callnode.cpp           |  87 +++++++
 src/hotspot/share/opto/callnode.hpp           |  38 +++-
 src/hotspot/share/opto/classes.hpp            |   3 +-
 src/hotspot/share/opto/compile.cpp            |   7 +
 src/hotspot/share/opto/compile.hpp            |   5 +
 src/hotspot/share/opto/graphKit.cpp           | 133 +++++++++++
 src/hotspot/share/opto/graphKit.hpp           |   8 +-
 src/hotspot/share/opto/lcm.cpp                |  13 +-
 src/hotspot/share/opto/machnode.cpp           |  17 ++
 src/hotspot/share/opto/machnode.hpp           |  30 ++-
 src/hotspot/share/opto/matcher.cpp            |  16 +-
 src/hotspot/share/opto/node.hpp               |   6 +
 src/hotspot/share/opto/output.cpp             |  41 +++-
 src/hotspot/share/opto/type.cpp               |   8 +
 src/hotspot/share/opto/type.hpp               |   1 +
 src/hotspot/share/prims/methodHandles.cpp     |   3 +
 src/hotspot/share/prims/methodHandles.hpp     |   2 +-
 src/hotspot/share/prims/nativeLookup.cpp      |   9 +
 src/hotspot/share/prims/whitebox.cpp          |  20 ++
 src/hotspot/share/runtime/frame.cpp           |   1 +
 src/hotspot/share/runtime/init.cpp            |   2 +
 src/hotspot/share/runtime/sharedRuntime.hpp   |   5 +
 src/hotspot/share/runtime/thread.hpp          |   4 +
 src/hotspot/share/runtime/vmStructs.cpp       |   3 +
 src/hotspot/share/utilities/growableArray.hpp |  15 ++
 .../share/classes/java/lang/System.java       |  15 +-
 .../java/lang/invoke/MethodHandle.java        |   4 +
 .../java/lang/invoke/MethodHandleImpl.java    |   6 +
 .../java/lang/invoke/MethodTypeForm.java      |   5 +-
 .../jdk/internal/access/JavaLangAccess.java   |   1 +
 .../internal/access/JavaLangInvokeAccess.java |  15 +-
 .../jdk/internal/loader/NativeLibraries.java  |  15 ++
 src/java.base/share/classes/module-info.java  |   5 +-
 .../share/native/libjava/NativeLibraries.c    |  23 ++
 src/java.base/share/native/libjava/jni_util.h |   2 +
 .../unix/native/libjava/jni_util_md.c         |   5 +
 .../windows/native/libjava/jni_util_md.c      |  26 +++
 .../jdk/incubator/foreign/AbstractLayout.java |  13 +-
 .../jdk/incubator/foreign/Addressable.java    |   5 +-
 .../jdk/incubator/foreign/GroupLayout.java    |   1 +
 .../jdk/incubator/foreign/MemorySegment.java  |  30 ++-
 .../jdk/incubator/foreign/package-info.java   | 148 +++++++++++-
 .../foreign/AbstractMemorySegmentImpl.java    |  26 +++
 .../jdk/internal/foreign/LayoutPath.java      |  10 +-
 .../internal/foreign/MemoryAddressImpl.java   |   8 +
 .../classes/jdk/internal/foreign/Utils.java   |  38 +++-
 .../jdk/java/foreign/TestAdaptVarHandles.java |   1 -
 .../jdk/java/foreign/TestLayoutConstants.java |  32 +++
 test/jdk/java/foreign/TestNative.java         |  22 +-
 .../foreign/TestNoForeignUnsafeOverride.java  |   2 -
 test/jdk/java/foreign/TestRebase.java         |   4 +-
 test/jdk/java/foreign/TestTypeAccess.java     |  34 +++
 test/jdk/java/foreign/libNativeAccess.c       |  10 -
 test/lib/sun/hotspot/WhiteBox.java            |   3 +
 .../bench/jdk/incubator/foreign/BulkOps.java  |   2 +-
 .../incubator/foreign/LoopOverConstant.java   |   2 +-
 .../jdk/incubator/foreign/LoopOverNew.java    |   2 +-
 .../foreign/LoopOverNonConstant.java          |   2 +-
 .../foreign/LoopOverNonConstantHeap.java      |   2 +-
 .../foreign/LoopOverNonConstantMapped.java    |   2 +-
 .../jdk/incubator/foreign/ParallelSum.java    |   2 +-
 .../foreign/TestAdaptVarHandles.java          |   2 +-
 .../foreign/points/PointsAccess.java          |   2 +-
 .../incubator/foreign/points/PointsAlloc.java |   2 +-
 .../incubator/foreign/points/PointsFree.java  |   2 +-
 .../foreign/points/support/BBPoint.java       |  10 +
 .../foreign/points/support/JNIPoint.java      |   6 +
 .../foreign/points/support/PanamaPoint.java   |  46 +++-
 .../foreign/points/support/libJNIPoint.c      |  21 ++
 109 files changed, 1589 insertions(+), 177 deletions(-)

diff --git a/src/hotspot/cpu/aarch64/aarch64.ad b/src/hotspot/cpu/aarch64/aarch64.ad
index 695c3bd61a0b4..b62954805e267 100644
--- a/src/hotspot/cpu/aarch64/aarch64.ad
+++ b/src/hotspot/cpu/aarch64/aarch64.ad
@@ -1770,6 +1770,11 @@ int MachCallRuntimeNode::ret_addr_offset() {
   }
 }
 
+int MachCallNativeNode::ret_addr_offset() {
+  ShouldNotReachHere();
+  return -1;
+}
+
 // Indicate if the safepoint node needs the polling page as an input
 
 // the shared code plants the oop data at the start of the generated
diff --git a/src/hotspot/cpu/aarch64/sharedRuntime_aarch64.cpp b/src/hotspot/cpu/aarch64/sharedRuntime_aarch64.cpp
index cac3e00ff9d12..640a813e375dd 100644
--- a/src/hotspot/cpu/aarch64/sharedRuntime_aarch64.cpp
+++ b/src/hotspot/cpu/aarch64/sharedRuntime_aarch64.cpp
@@ -3094,3 +3094,10 @@ void OptoRuntime::generate_exception_blob() {
   _exception_blob =  ExceptionBlob::create(&buffer, oop_maps, SimpleRuntimeFrame::framesize >> 1);
 }
 #endif // COMPILER2
+
+address SharedRuntime::make_native_invoker(address call_target,
+                                           int shadow_space_bytes,
+                                           const GrowableArray& input_registers,
+                                           const GrowableArray& output_registers) {
+  return NULL;
+}
diff --git a/src/hotspot/cpu/aarch64/vmreg_aarch64.cpp b/src/hotspot/cpu/aarch64/vmreg_aarch64.cpp
index 35d0adf5b9f95..d68edf59d4031 100644
--- a/src/hotspot/cpu/aarch64/vmreg_aarch64.cpp
+++ b/src/hotspot/cpu/aarch64/vmreg_aarch64.cpp
@@ -26,7 +26,7 @@
 #include "precompiled.hpp"
 #include "asm/assembler.hpp"
 #include "code/vmreg.hpp"
-
+#include "vmreg_aarch64.inline.hpp"
 
 
 void VMRegImpl::set_regName() {
@@ -51,3 +51,17 @@ void VMRegImpl::set_regName() {
     regName[i] = "NON-GPR-FPR";
   }
 }
+
+#define INTEGER_TYPE 0
+#define VECTOR_TYPE 1
+#define X87_TYPE 2
+#define STACK_TYPE 3
+
+VMReg VMRegImpl::vmStorageToVMReg(int type, int index) {
+  switch(type) {
+    case INTEGER_TYPE: return ::as_Register(index)->as_VMReg();
+    case VECTOR_TYPE: return ::as_FloatRegister(index)->as_VMReg();
+    case STACK_TYPE: return VMRegImpl::stack2reg(index LP64_ONLY(* 2));
+  }
+  return VMRegImpl::Bad();
+}
diff --git a/src/hotspot/cpu/x86/assembler_x86.cpp b/src/hotspot/cpu/x86/assembler_x86.cpp
index 3168567e069a2..1585ba2da914b 100644
--- a/src/hotspot/cpu/x86/assembler_x86.cpp
+++ b/src/hotspot/cpu/x86/assembler_x86.cpp
@@ -7081,13 +7081,6 @@ void Assembler::decl(Register dst) {
 
 // 64bit doesn't use the x87
 
-void Assembler::emit_operand32(Register reg, Address adr) {
-  assert(reg->encoding() < 8, "no extended registers");
-  assert(!adr.base_needs_rex() && !adr.index_needs_rex(), "no extended registers");
-  emit_operand(reg, adr._base, adr._index, adr._scale, adr._disp,
-               adr._rspec);
-}
-
 void Assembler::emit_farith(int b1, int b2, int i) {
   assert(isByte(b1) && isByte(b2), "wrong opcode");
   assert(0 <= i &&  i < 8, "illegal stack offset");
@@ -7272,12 +7265,6 @@ void Assembler::fld_s(int index) {
   emit_farith(0xD9, 0xC0, index);
 }
 
-void Assembler::fld_x(Address adr) {
-  InstructionMark im(this);
-  emit_int8((unsigned char)0xDB);
-  emit_operand32(rbp, adr);
-}
-
 void Assembler::fldcw(Address src) {
   InstructionMark im(this);
   emit_int8((unsigned char)0xD9);
@@ -7404,12 +7391,6 @@ void Assembler::fstp_s(Address adr) {
   emit_operand32(rbx, adr);
 }
 
-void Assembler::fstp_x(Address adr) {
-  InstructionMark im(this);
-  emit_int8((unsigned char)0xDB);
-  emit_operand32(rdi, adr);
-}
-
 void Assembler::fsub(int i) {
   emit_farith(0xD8, 0xE0, i);
 }
@@ -8574,6 +8555,25 @@ void Assembler::decq(Address dst) {
   emit_operand(rcx, dst);
 }
 
+void Assembler::fld_x(Address adr) {
+  InstructionMark im(this);
+  emit_int8((unsigned char)0xDB);
+  emit_operand32(rbp, adr);
+}
+
+void Assembler::fstp_x(Address adr) {
+  InstructionMark im(this);
+  emit_int8((unsigned char)0xDB);
+  emit_operand32(rdi, adr);
+}
+
+void Assembler::emit_operand32(Register reg, Address adr) {
+  assert(reg->encoding() < 8, "no extended registers");
+  assert(!adr.base_needs_rex() && !adr.index_needs_rex(), "no extended registers");
+  emit_operand(reg, adr._base, adr._index, adr._scale, adr._disp,
+               adr._rspec);
+}
+
 void Assembler::fxrstor(Address src) {
   emit_int24(get_prefixq(src), 0x0F, (unsigned char)0xAE);
   emit_operand(as_Register(1), src);
diff --git a/src/hotspot/cpu/x86/assembler_x86.hpp b/src/hotspot/cpu/x86/assembler_x86.hpp
index 23d8db4016434..a4c9d2fce7e71 100644
--- a/src/hotspot/cpu/x86/assembler_x86.hpp
+++ b/src/hotspot/cpu/x86/assembler_x86.hpp
@@ -41,9 +41,13 @@ class Argument {
 #ifdef _WIN64
     n_int_register_parameters_c   = 4, // rcx, rdx, r8, r9 (c_rarg0, c_rarg1, ...)
     n_float_register_parameters_c = 4,  // xmm0 - xmm3 (c_farg0, c_farg1, ... )
+    n_int_register_returns_c = 1, // rax
+    n_float_register_returns_c = 1, // xmm0
 #else
     n_int_register_parameters_c   = 6, // rdi, rsi, rdx, rcx, r8, r9 (c_rarg0, c_rarg1, ...)
     n_float_register_parameters_c = 8,  // xmm0 - xmm7 (c_farg0, c_farg1, ... )
+    n_int_register_returns_c = 2, // rax, rdx
+    n_float_register_returns_c = 2, // xmm0, xmm1
 #endif // _WIN64
     n_int_register_parameters_j   = 6, // j_rarg0, j_rarg1, ...
     n_float_register_parameters_j = 8  // j_farg0, j_farg1, ...
@@ -1133,8 +1137,6 @@ class Assembler : public AbstractAssembler  {
 
 #ifndef _LP64
  private:
-  // operands that only take the original 32bit registers
-  void emit_operand32(Register reg, Address adr);
 
   void emit_farith(int b1, int b2, int i);
 
@@ -1200,7 +1202,6 @@ class Assembler : public AbstractAssembler  {
   void fld_d(Address adr);
   void fld_s(Address adr);
   void fld_s(int index);
-  void fld_x(Address adr);  // extended-precision (80-bit) format
 
   void fldcw(Address src);
 
@@ -1245,7 +1246,6 @@ class Assembler : public AbstractAssembler  {
   void fstp_d(Address adr);
   void fstp_d(int index);
   void fstp_s(Address adr);
-  void fstp_x(Address adr); // extended-precision (80-bit) format
 
   void fsub(int i);
   void fsub_d(Address src);
@@ -1280,6 +1280,11 @@ class Assembler : public AbstractAssembler  {
   void fldl2e();
 #endif // !_LP64
 
+  // operands that only take the original 32bit registers
+  void emit_operand32(Register reg, Address adr);
+
+  void fld_x(Address adr);  // extended-precision (80-bit) format
+  void fstp_x(Address adr); // extended-precision (80-bit) format
   void fxrstor(Address src);
   void xrstor(Address src);
 
diff --git a/src/hotspot/cpu/x86/frame_x86.cpp b/src/hotspot/cpu/x86/frame_x86.cpp
index 1e9bf12cd2bf4..db54b729f80b5 100644
--- a/src/hotspot/cpu/x86/frame_x86.cpp
+++ b/src/hotspot/cpu/x86/frame_x86.cpp
@@ -344,6 +344,11 @@ frame frame::sender_for_entry_frame(RegisterMap* map) const {
   assert(map->include_argument_oops(), "should be set by clear");
   vmassert(jfa->last_Java_pc() != NULL, "not walkable");
   frame fr(jfa->last_Java_sp(), jfa->last_Java_fp(), jfa->last_Java_pc());
+
+  if (jfa->saved_rbp_address()) {
+    update_map_with_saved_link(map, jfa->saved_rbp_address());
+  }
+
   return fr;
 }
 
diff --git a/src/hotspot/cpu/x86/javaFrameAnchor_x86.hpp b/src/hotspot/cpu/x86/javaFrameAnchor_x86.hpp
index bb39c8e513e51..4579b7377a0e9 100644
--- a/src/hotspot/cpu/x86/javaFrameAnchor_x86.hpp
+++ b/src/hotspot/cpu/x86/javaFrameAnchor_x86.hpp
@@ -30,6 +30,9 @@
   // FP value associated with _last_Java_sp:
   intptr_t* volatile        _last_Java_fp;           // pointer is volatile not what it points to
 
+  // (Optional) location of saved RBP register, which GCs want to inspect
+  intptr_t** volatile _saved_rbp_address;
+
 public:
   // Each arch must define reset, save, restore
   // These are used by objects that only care about:
@@ -43,6 +46,7 @@
     // fence?
     _last_Java_fp = NULL;
     _last_Java_pc = NULL;
+    _saved_rbp_address = NULL;
   }
 
   void copy(JavaFrameAnchor* src) {
@@ -60,6 +64,8 @@
     _last_Java_pc = src->_last_Java_pc;
     // Must be last so profiler will always see valid frame if has_last_frame() is true
     _last_Java_sp = src->_last_Java_sp;
+
+    _saved_rbp_address = src->_saved_rbp_address;
   }
 
   bool walkable(void)                            { return _last_Java_sp != NULL && _last_Java_pc != NULL; }
@@ -70,9 +76,12 @@
 
   address last_Java_pc(void)                     { return _last_Java_pc; }
 
+  intptr_t** saved_rbp_address(void) const       { return _saved_rbp_address; }
+
 private:
 
   static ByteSize last_Java_fp_offset()          { return byte_offset_of(JavaFrameAnchor, _last_Java_fp); }
+  static ByteSize saved_rbp_address_offset()     { return byte_offset_of(JavaFrameAnchor, _saved_rbp_address); }
 
 public:
 
diff --git a/src/hotspot/cpu/x86/macroAssembler_x86.cpp b/src/hotspot/cpu/x86/macroAssembler_x86.cpp
index 84cb5eb9ad7fe..a43071eb7ce01 100644
--- a/src/hotspot/cpu/x86/macroAssembler_x86.cpp
+++ b/src/hotspot/cpu/x86/macroAssembler_x86.cpp
@@ -745,20 +745,6 @@ void MacroAssembler::pushptr(AddressLiteral src) {
   }
 }
 
-void MacroAssembler::reset_last_Java_frame(bool clear_fp) {
-  // we must set sp to zero to clear frame
-  movptr(Address(r15_thread, JavaThread::last_Java_sp_offset()), NULL_WORD);
-  // must clear fp, so that compiled frames are not confused; it is
-  // possible that we need it only for debugging
-  if (clear_fp) {
-    movptr(Address(r15_thread, JavaThread::last_Java_fp_offset()), NULL_WORD);
-  }
-
-  // Always clear the pc because it could have been set by make_walkable()
-  movptr(Address(r15_thread, JavaThread::last_Java_pc_offset()), NULL_WORD);
-  vzeroupper();
-}
-
 void MacroAssembler::set_last_Java_frame(Register last_java_sp,
                                          Register last_java_fp,
                                          address  last_java_pc) {
@@ -2042,10 +2028,6 @@ void MacroAssembler::fld_s(AddressLiteral src) {
   fld_s(as_Address(src));
 }
 
-void MacroAssembler::fld_x(AddressLiteral src) {
-  Assembler::fld_x(as_Address(src));
-}
-
 void MacroAssembler::fldcw(AddressLiteral src) {
   Assembler::fldcw(as_Address(src));
 }
@@ -2253,6 +2235,10 @@ void MacroAssembler::jump_cc(Condition cc, AddressLiteral dst) {
   }
 }
 
+void MacroAssembler::fld_x(AddressLiteral src) {
+  Assembler::fld_x(as_Address(src));
+}
+
 void MacroAssembler::ldmxcsr(AddressLiteral src) {
   if (reachable(src)) {
     Assembler::ldmxcsr(as_Address(src));
@@ -2667,20 +2653,25 @@ void MacroAssembler::push_IU_state() {
   pusha();
 }
 
+void MacroAssembler::reset_last_Java_frame(bool clear_fp) {
+  reset_last_Java_frame(r15_thread, clear_fp);
+}
+
 void MacroAssembler::reset_last_Java_frame(Register java_thread, bool clear_fp) { // determine java_thread register
   if (!java_thread->is_valid()) {
     java_thread = rdi;
     get_thread(java_thread);
   }
   // we must set sp to zero to clear frame
-  movptr(Address(java_thread, JavaThread::last_Java_sp_offset()), NULL_WORD);
+  movslq(Address(java_thread, JavaThread::last_Java_sp_offset()), NULL_WORD);
+  // must clear fp, so that compiled frames are not confused; it is
+  // possible that we need it only for debugging
   if (clear_fp) {
-    movptr(Address(java_thread, JavaThread::last_Java_fp_offset()), NULL_WORD);
+    movslq(Address(java_thread, JavaThread::last_Java_fp_offset()), NULL_WORD);
   }
-
   // Always clear the pc because it could have been set by make_walkable()
-  movptr(Address(java_thread, JavaThread::last_Java_pc_offset()), NULL_WORD);
-
+  movslq(Address(java_thread, JavaThread::last_Java_pc_offset()), NULL_WORD);
+  movslq(Address(java_thread, JavaThread::saved_rbp_address_offset()), NULL_WORD);
   vzeroupper();
 }
 
diff --git a/src/hotspot/cpu/x86/macroAssembler_x86.hpp b/src/hotspot/cpu/x86/macroAssembler_x86.hpp
index 677fbc76e3e5e..3246868588641 100644
--- a/src/hotspot/cpu/x86/macroAssembler_x86.hpp
+++ b/src/hotspot/cpu/x86/macroAssembler_x86.hpp
@@ -812,6 +812,7 @@ class MacroAssembler: public Assembler {
 
   void call(Label& L, relocInfo::relocType rtype);
   void call(Register entry);
+  void call(Address addr) { Assembler::call(addr); }
 
   // NOTE: this call transfers to the effective address of entry NOT
   // the address contained by entry. This is because this is more natural
@@ -866,13 +867,13 @@ class MacroAssembler: public Assembler {
   void fld_d(Address src) { Assembler::fld_d(src); }
   void fld_d(AddressLiteral src);
 
-  void fld_x(Address src) { Assembler::fld_x(src); }
-  void fld_x(AddressLiteral src);
-
   void fmul_s(Address src)        { Assembler::fmul_s(src); }
   void fmul_s(AddressLiteral src) { Assembler::fmul_s(as_Address(src)); }
 #endif // _LP64
 
+  void fld_x(Address src) { Assembler::fld_x(src); }
+  void fld_x(AddressLiteral src);
+
   void ldmxcsr(Address src) { Assembler::ldmxcsr(src); }
   void ldmxcsr(AddressLiteral src);
 
diff --git a/src/hotspot/cpu/x86/methodHandles_x86.cpp b/src/hotspot/cpu/x86/methodHandles_x86.cpp
index 3d4486867d60a..05165e7b87c1e 100644
--- a/src/hotspot/cpu/x86/methodHandles_x86.cpp
+++ b/src/hotspot/cpu/x86/methodHandles_x86.cpp
@@ -215,6 +215,13 @@ address MethodHandles::generate_method_handle_interpreter_entry(MacroAssembler*
     return NULL;
   }
 
+  // No need in interpreter entry for linkToNative for now.
+  // Interpreter calls compiled entry through i2c.
+  if (iid == vmIntrinsics::_linkToNative) {
+    __ hlt();
+    return NULL;
+  }
+
   // rsi/r13: sender SP (must preserve; see prepare_to_jump_from_interpreted)
   // rbx: Method*
   // rdx: argument locator (parameter slot count, added to rsp)
@@ -326,7 +333,10 @@ void MethodHandles::generate_method_handle_dispatch(MacroAssembler* _masm,
   assert_different_registers(temp1, temp2, temp3, receiver_reg);
   assert_different_registers(temp1, temp2, temp3, member_reg);
 
-  if (iid == vmIntrinsics::_invokeBasic) {
+  if (iid == vmIntrinsics::_invokeBasic || iid == vmIntrinsics::_linkToNative) {
+    if (iid == vmIntrinsics::_linkToNative) {
+      assert(for_compiler_entry, "only compiler entry is supported");
+    }
     // indirect through MH.form.vmentry.vmtarget
     jump_to_lambda_form(_masm, receiver_reg, rbx_method, temp1, for_compiler_entry);
 
diff --git a/src/hotspot/cpu/x86/sharedRuntime_x86_64.cpp b/src/hotspot/cpu/x86/sharedRuntime_x86_64.cpp
index 35320d85e917d..823cabc9b271e 100644
--- a/src/hotspot/cpu/x86/sharedRuntime_x86_64.cpp
+++ b/src/hotspot/cpu/x86/sharedRuntime_x86_64.cpp
@@ -1845,7 +1845,7 @@ static void gen_special_dispatch(MacroAssembler* masm,
     member_arg_pos = method->size_of_parameters() - 1;  // trailing MemberName argument
     member_reg = rbx;  // known to be free at this point
     has_receiver = MethodHandles::ref_kind_has_receiver(ref_kind);
-  } else if (iid == vmIntrinsics::_invokeBasic) {
+  } else if (iid == vmIntrinsics::_invokeBasic || iid == vmIntrinsics::_linkToNative) {
     has_receiver = true;
   } else {
     fatal("unexpected intrinsic id %d", iid);
@@ -3670,6 +3670,218 @@ RuntimeStub* SharedRuntime::generate_resolve_blob(address destination, const cha
   return RuntimeStub::new_runtime_stub(name, &buffer, frame_complete, frame_size_in_words, oop_maps, true);
 }
 
+static const int native_invoker_code_size = MethodHandles::adapter_code_size;
+
+class NativeInvokerGenerator : public StubCodeGenerator {
+  address _call_target;
+  int _shadow_space_bytes;
+
+  const GrowableArray& _input_registers;
+  const GrowableArray& _output_registers;
+public:
+  NativeInvokerGenerator(CodeBuffer* buffer,
+                         address call_target,
+                         int shadow_space_bytes,
+                         const GrowableArray& input_registers,
+                         const GrowableArray& output_registers)
+   : StubCodeGenerator(buffer, PrintMethodHandleStubs),
+     _call_target(call_target),
+     _shadow_space_bytes(shadow_space_bytes),
+     _input_registers(input_registers),
+     _output_registers(output_registers) {}
+  void generate();
+
+  void spill_register(VMReg reg) {
+    assert(reg->is_reg(), "must be a register");
+    MacroAssembler* masm = _masm;
+    if (reg->is_Register()) {
+      __ push(reg->as_Register());
+    } else if (reg->is_XMMRegister()) {
+      if (UseAVX >= 3) {
+        __ subptr(rsp, 64); // bytes
+        __ evmovdqul(Address(rsp, 0), reg->as_XMMRegister(), Assembler::AVX_512bit);
+      } else if (UseAVX >= 1) {
+        __ subptr(rsp, 32);
+        __ vmovdqu(Address(rsp, 0), reg->as_XMMRegister());
+      } else {
+        __ subptr(rsp, 16);
+        __ movdqu(Address(rsp, 0), reg->as_XMMRegister());
+      }
+    } else {
+      ShouldNotReachHere();
+    }
+  }
+
+  void fill_register(VMReg reg) {
+    assert(reg->is_reg(), "must be a register");
+    MacroAssembler* masm = _masm;
+    if (reg->is_Register()) {
+      __ pop(reg->as_Register());
+    } else if (reg->is_XMMRegister()) {
+      if (UseAVX >= 3) {
+        __ evmovdqul(reg->as_XMMRegister(), Address(rsp, 0), Assembler::AVX_512bit);
+        __ addptr(rsp, 64); // bytes
+      } else if (UseAVX >= 1) {
+        __ vmovdqu(reg->as_XMMRegister(), Address(rsp, 0));
+        __ addptr(rsp, 32);
+      } else {
+        __ movdqu(reg->as_XMMRegister(), Address(rsp, 0));
+        __ addptr(rsp, 16);
+      }
+    } else {
+      ShouldNotReachHere();
+    }
+  }
+
+private:
+#ifdef ASSERT
+bool target_uses_register(VMReg reg) {
+  return _input_registers.contains(reg) || _output_registers.contains(reg);
+}
+#endif
+};
+
+address SharedRuntime::make_native_invoker(address call_target,
+                                           int shadow_space_bytes,
+                                           const GrowableArray& input_registers,
+                                           const GrowableArray& output_registers) {
+  BufferBlob* _invoke_native_blob = BufferBlob::create("nep_invoker_blob", native_invoker_code_size);
+  if (_invoke_native_blob == NULL)
+    return NULL; // allocation failure
+
+  CodeBuffer code(_invoke_native_blob);
+  NativeInvokerGenerator g(&code, call_target, shadow_space_bytes, input_registers, output_registers);
+  g.generate();
+  code.log_section_sizes("nep_invoker_blob");
+
+  return _invoke_native_blob->code_begin();
+}
+
+void NativeInvokerGenerator::generate() {
+  assert(!(target_uses_register(r15_thread->as_VMReg()) || target_uses_register(rscratch1->as_VMReg())), "Register conflict");
+
+  MacroAssembler* masm = _masm;
+  __ enter();
+
+  Address java_pc(r15_thread, JavaThread::last_Java_pc_offset());
+  __ movptr(rscratch1, Address(rsp, 8)); // read return address from stack
+  __ movptr(java_pc, rscratch1);
+
+  __ movptr(rscratch1, rsp);
+  __ addptr(rscratch1, 16); // skip return and frame
+  __ movptr(Address(r15_thread, JavaThread::last_Java_sp_offset()), rscratch1);
+
+  __ movptr(Address(r15_thread, JavaThread::saved_rbp_address_offset()), rsp); // rsp points at saved RBP
+
+    // State transition
+  __ movl(Address(r15_thread, JavaThread::thread_state_offset()), _thread_in_native);
+
+  if (_shadow_space_bytes != 0) {
+    // needed here for correct stack args offset on Windows
+    __ subptr(rsp, _shadow_space_bytes);
+  }
+
+  __ call(RuntimeAddress(_call_target));
+
+  if (_shadow_space_bytes != 0) {
+    // needed here for correct stack args offset on Windows
+    __ addptr(rsp, _shadow_space_bytes);
+  }
+
+  assert(_output_registers.length() <= 1
+    || (_output_registers.length() == 2 && !_output_registers.at(1)->is_valid()), "no multi-reg returns");
+  bool need_spills = _output_registers.length() != 0;
+  VMReg ret_reg = need_spills ? _output_registers.at(0) : VMRegImpl::Bad();
+
+  __ restore_cpu_control_state_after_jni();
+
+  __ movl(Address(r15_thread, JavaThread::thread_state_offset()), _thread_in_native_trans);
+
+  if (os::is_MP()) {
+    // Force this write out before the read below
+    __ membar(Assembler::Membar_mask_bits(
+            Assembler::LoadLoad | Assembler::LoadStore |
+            Assembler::StoreLoad | Assembler::StoreStore));
+  }
+
+  Label L_after_safepoint_poll;
+  Label L_safepoint_poll_slow_path;
+
+  __ safepoint_poll(L_safepoint_poll_slow_path, r15_thread, true /* at_return */, false /* in_nmethod */);
+  __ cmpl(Address(r15_thread, JavaThread::suspend_flags_offset()), 0);
+  __ jcc(Assembler::notEqual, L_safepoint_poll_slow_path);
+
+  __ bind(L_after_safepoint_poll);
+
+  // change thread state
+  __ movl(Address(r15_thread, JavaThread::thread_state_offset()), _thread_in_Java);
+
+  __ block_comment("reguard stack check");
+  Label L_reguard;
+  Label L_after_reguard;
+  __ cmpl(Address(r15_thread, JavaThread::stack_guard_state_offset()), StackOverflow::stack_guard_yellow_reserved_disabled);
+  __ jcc(Assembler::equal, L_reguard);
+  __ bind(L_after_reguard);
+
+  __ reset_last_Java_frame(r15_thread, true);
+
+  __ leave(); // required for proper stackwalking of RuntimeStub frame
+  __ ret(0);
+
+  //////////////////////////////////////////////////////////////////////////////
+
+  __ block_comment("{ L_safepoint_poll_slow_path");
+  __ bind(L_safepoint_poll_slow_path);
+  __ vzeroupper();
+
+  if (need_spills) {
+    spill_register(ret_reg);
+  }
+
+  __ mov(c_rarg0, r15_thread);
+  __ mov(r12, rsp); // remember sp
+  __ subptr(rsp, frame::arg_reg_save_area_bytes); // windows
+  __ andptr(rsp, -16); // align stack as required by ABI
+  __ call(RuntimeAddress(CAST_FROM_FN_PTR(address, JavaThread::check_special_condition_for_native_trans)));
+  __ mov(rsp, r12); // restore sp
+  __ reinit_heapbase();
+
+  if (need_spills) {
+    fill_register(ret_reg);
+  }
+
+  __ jmp(L_after_safepoint_poll);
+  __ block_comment("} L_safepoint_poll_slow_path");
+
+  //////////////////////////////////////////////////////////////////////////////
+
+  __ block_comment("{ L_reguard");
+  __ bind(L_reguard);
+  __ vzeroupper();
+
+  if (need_spills) {
+    spill_register(ret_reg);
+  }
+
+  __ mov(r12, rsp); // remember sp
+  __ subptr(rsp, frame::arg_reg_save_area_bytes); // windows
+  __ andptr(rsp, -16); // align stack as required by ABI
+  __ call(RuntimeAddress(CAST_FROM_FN_PTR(address, SharedRuntime::reguard_yellow_pages)));
+  __ mov(rsp, r12); // restore sp
+  __ reinit_heapbase();
+
+  if (need_spills) {
+    fill_register(ret_reg);
+  }
+
+  __ jmp(L_after_reguard);
+
+  __ block_comment("} L_reguard");
+
+  //////////////////////////////////////////////////////////////////////////////
+
+  __ flush();
+}
 
 //------------------------------Montgomery multiplication------------------------
 //
diff --git a/src/hotspot/cpu/x86/vmreg_x86.cpp b/src/hotspot/cpu/x86/vmreg_x86.cpp
index 202230a05281c..2519a04bf3e3f 100644
--- a/src/hotspot/cpu/x86/vmreg_x86.cpp
+++ b/src/hotspot/cpu/x86/vmreg_x86.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006, 2012, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2006, 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -25,7 +25,7 @@
 #include "precompiled.hpp"
 #include "asm/assembler.hpp"
 #include "code/vmreg.hpp"
-
+#include "vmreg_x86.inline.hpp"
 
 
 void VMRegImpl::set_regName() {
@@ -66,3 +66,17 @@ void VMRegImpl::set_regName() {
     regName[i] = "NON-GPR-FPR-XMM-KREG";
   }
 }
+
+#define INTEGER_TYPE 0
+#define VECTOR_TYPE 1
+#define X87_TYPE 2
+#define STACK_TYPE 3
+
+VMReg VMRegImpl::vmStorageToVMReg(int type, int index) {
+  switch(type) {
+    case INTEGER_TYPE: return ::as_Register(index)->as_VMReg();
+    case VECTOR_TYPE: return ::as_XMMRegister(index)->as_VMReg();
+    case STACK_TYPE: return VMRegImpl::stack2reg(index LP64_ONLY(* 2)); // numbering on x64 goes per 64-bits
+  }
+  return VMRegImpl::Bad();
+}
diff --git a/src/hotspot/cpu/x86/x86_64.ad b/src/hotspot/cpu/x86/x86_64.ad
index 68bf134291ee5..3c428193b4a72 100644
--- a/src/hotspot/cpu/x86/x86_64.ad
+++ b/src/hotspot/cpu/x86/x86_64.ad
@@ -459,6 +459,11 @@ int MachCallRuntimeNode::ret_addr_offset() {
   return offset;
 }
 
+int MachCallNativeNode::ret_addr_offset() {
+  int offset = 13; // movq r10,#addr; callq (r10)
+  offset += clear_avx_size();
+  return offset;
+}
 //
 // Compute padding required for nodes which need alignment
 //
@@ -12353,6 +12358,18 @@ instruct CallLeafDirect(method meth)
   ins_pipe(pipe_slow);
 %}
 
+//
+instruct CallNativeDirect(method meth)
+%{
+  match(CallNative);
+  effect(USE meth);
+
+  ins_cost(300);
+  format %{ "call_native " %}
+  ins_encode(clear_avx, Java_To_Runtime(meth));
+  ins_pipe(pipe_slow);
+%}
+
 // Call runtime without safepoint
 instruct CallLeafNoFPDirect(method meth)
 %{
diff --git a/src/hotspot/share/adlc/formssel.cpp b/src/hotspot/share/adlc/formssel.cpp
index 4ac726bdf6df4..08e90cd92e1c3 100644
--- a/src/hotspot/share/adlc/formssel.cpp
+++ b/src/hotspot/share/adlc/formssel.cpp
@@ -419,6 +419,8 @@ Form::CallType InstructForm::is_ideal_call() const {
   idx = 0;
   if(_matrule->find_type("CallLeafNoFP",idx))     return Form::JAVA_LEAF;
   idx = 0;
+  if(_matrule->find_type("CallNative",idx))       return Form::JAVA_NATIVE;
+  idx = 0;
 
   return Form::invalid_type;
 }
@@ -1131,6 +1133,9 @@ const char *InstructForm::mach_base_class(FormDict &globals)  const {
   else if( is_ideal_call() == Form::JAVA_LEAF ) {
     return "MachCallLeafNode";
   }
+  else if( is_ideal_call() == Form::JAVA_NATIVE ) {
+    return "MachCallNativeNode";
+  }
   else if (is_ideal_return()) {
     return "MachReturnNode";
   }
diff --git a/src/hotspot/share/c1/c1_GraphBuilder.cpp b/src/hotspot/share/c1/c1_GraphBuilder.cpp
index 0b141091780f4..1fc2351cd8736 100644
--- a/src/hotspot/share/c1/c1_GraphBuilder.cpp
+++ b/src/hotspot/share/c1/c1_GraphBuilder.cpp
@@ -4129,6 +4129,9 @@ bool GraphBuilder::try_method_handle_inline(ciMethod* callee, bool ignore_return
     }
     break;
 
+  case vmIntrinsics::_linkToNative:
+    break; // TODO: NYI
+
   default:
     fatal("unexpected intrinsic %d: %s", iid, vmIntrinsics::name_at(iid));
     break;
diff --git a/src/hotspot/share/c1/c1_IR.hpp b/src/hotspot/share/c1/c1_IR.hpp
index ab63b32c14b23..36fe1ca23ea8a 100644
--- a/src/hotspot/share/c1/c1_IR.hpp
+++ b/src/hotspot/share/c1/c1_IR.hpp
@@ -244,7 +244,7 @@ class IRScopeDebugInfo: public CompilationResourceObj {
     bool reexecute = topmost ? should_reexecute() : false;
     bool return_oop = false; // This flag will be ignored since it used only for C2 with escape analysis.
     bool rethrow_exception = false;
-    recorder->describe_scope(pc_offset, methodHandle(), scope()->method(), bci(), reexecute, rethrow_exception, is_method_handle_invoke, return_oop, locvals, expvals, monvals);
+    recorder->describe_scope(pc_offset, methodHandle(), scope()->method(), bci(), reexecute, rethrow_exception, is_method_handle_invoke, false /* is opt native */, return_oop, locvals, expvals, monvals);
   }
 };
 
diff --git a/src/hotspot/share/ci/ciClassList.hpp b/src/hotspot/share/ci/ciClassList.hpp
index d49a8c797f698..cf0946a9a7440 100644
--- a/src/hotspot/share/ci/ciClassList.hpp
+++ b/src/hotspot/share/ci/ciClassList.hpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1999, 2019, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1999, 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -48,6 +48,7 @@ class   ciNullObject;
 class   ciInstance;
 class     ciCallSite;
 class     ciMemberName;
+class     ciNativeEntryPoint;
 class     ciMethodHandle;
 class     ciMethodType;
 class     ciArray;
@@ -97,6 +98,7 @@ friend class ciObject;                 \
 friend class ciNullObject;             \
 friend class ciInstance;               \
 friend class ciMemberName;             \
+friend class ciNativeEntryPoint;       \
 friend class ciMethod;                 \
 friend class ciMethodData;             \
 friend class ciMethodHandle;           \
diff --git a/src/hotspot/share/ci/ciEnv.cpp b/src/hotspot/share/ci/ciEnv.cpp
index 43a66cc7a084d..7c75e5e9cdb8f 100644
--- a/src/hotspot/share/ci/ciEnv.cpp
+++ b/src/hotspot/share/ci/ciEnv.cpp
@@ -968,7 +968,9 @@ void ciEnv::register_method(ciMethod* target,
                             AbstractCompiler* compiler,
                             bool has_unsafe_access,
                             bool has_wide_vectors,
-                            RTMState  rtm_state) {
+                            RTMState  rtm_state,
+                            address* native_stubs,
+                            int num_stubs) {
   VM_ENTRY_MARK;
   nmethod* nm = NULL;
   {
@@ -1057,7 +1059,8 @@ void ciEnv::register_method(ciMethod* target,
                                debug_info(), dependencies(), code_buffer,
                                frame_words, oop_map_set,
                                handler_table, inc_table,
-                               compiler, task()->comp_level());
+                               compiler, task()->comp_level(),
+                               native_stubs, num_stubs);
 
     // Free codeBlobs
     code_buffer->free_blob();
diff --git a/src/hotspot/share/ci/ciEnv.hpp b/src/hotspot/share/ci/ciEnv.hpp
index 65949bde48ab9..0526113cb10ff 100644
--- a/src/hotspot/share/ci/ciEnv.hpp
+++ b/src/hotspot/share/ci/ciEnv.hpp
@@ -377,7 +377,9 @@ class ciEnv : StackObj {
                        AbstractCompiler*         compiler,
                        bool                      has_unsafe_access,
                        bool                      has_wide_vectors,
-                       RTMState                  rtm_state = NoRTM);
+                       RTMState                  rtm_state = NoRTM,
+                       address*                  native_stubs = NULL,
+                       int                       num_stubs = 0);
 
 
   // Access to certain well known ciObjects.
diff --git a/src/hotspot/share/ci/ciObjArray.cpp b/src/hotspot/share/ci/ciObjArray.cpp
index ab747948cb2e3..09ade58e98592 100644
--- a/src/hotspot/share/ci/ciObjArray.cpp
+++ b/src/hotspot/share/ci/ciObjArray.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1999, 2015, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1999, 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -36,7 +36,7 @@
 ciObject* ciObjArray::obj_at(int index) {
   VM_ENTRY_MARK;
   objArrayOop array = get_objArrayOop();
-  if (index < 0 || index >= array->length()) return NULL;
+  assert(index >= 0 && index < array->length(), "OOB access");
   oop o = array->obj_at(index);
   if (o == NULL) {
     return ciNullObject::make();
diff --git a/src/hotspot/share/ci/ciObject.hpp b/src/hotspot/share/ci/ciObject.hpp
index 11362201c6903..8e3ffe64ef56f 100644
--- a/src/hotspot/share/ci/ciObject.hpp
+++ b/src/hotspot/share/ci/ciObject.hpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1999, 2019, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1999, 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -107,6 +107,7 @@ class ciObject : public ciBaseObject {
   virtual bool is_array()                   { return false; }
   virtual bool is_obj_array()               { return false; }
   virtual bool is_type_array()              { return false; }
+  virtual bool is_native_entry_point()const { return false; }
 
   // Is this a type or value which has no associated class?
   // It is true of primitive types and null objects.
@@ -160,6 +161,10 @@ class ciObject : public ciBaseObject {
     assert(is_type_array(), "bad cast");
     return (ciTypeArray*)this;
   }
+  ciNativeEntryPoint* as_native_entry_point() {
+    assert(is_native_entry_point(), "bad cast");
+    return (ciNativeEntryPoint*)this;
+  }
 
   // Print debugging output about this ciObject.
   void print(outputStream* st);
diff --git a/src/hotspot/share/ci/ciObjectFactory.cpp b/src/hotspot/share/ci/ciObjectFactory.cpp
index f74f5e627a05e..9f3eecaa9ba9c 100644
--- a/src/hotspot/share/ci/ciObjectFactory.cpp
+++ b/src/hotspot/share/ci/ciObjectFactory.cpp
@@ -27,6 +27,7 @@
 #include "ci/ciInstance.hpp"
 #include "ci/ciInstanceKlass.hpp"
 #include "ci/ciMemberName.hpp"
+#include "ci/ciNativeEntryPoint.hpp"
 #include "ci/ciMethod.hpp"
 #include "ci/ciMethodData.hpp"
 #include "ci/ciMethodHandle.hpp"
@@ -351,6 +352,8 @@ ciObject* ciObjectFactory::create_new_object(oop o) {
       return new (arena()) ciCallSite(h_i);
     else if (java_lang_invoke_MemberName::is_instance(o))
       return new (arena()) ciMemberName(h_i);
+    else if (jdk_internal_invoke_NativeEntryPoint::is_instance(o))
+      return new (arena()) ciNativeEntryPoint(h_i);
     else if (java_lang_invoke_MethodHandle::is_instance(o))
       return new (arena()) ciMethodHandle(h_i);
     else if (java_lang_invoke_MethodType::is_instance(o))
diff --git a/src/hotspot/share/classfile/javaClasses.cpp b/src/hotspot/share/classfile/javaClasses.cpp
index c005600ce2e5c..310a793a75ae9 100644
--- a/src/hotspot/share/classfile/javaClasses.cpp
+++ b/src/hotspot/share/classfile/javaClasses.cpp
@@ -3815,6 +3815,65 @@ bool java_lang_invoke_LambdaForm::is_instance(oop obj) {
   return obj != NULL && is_subclass(obj->klass());
 }
 
+int jdk_internal_invoke_NativeEntryPoint::_addr_offset;
+int jdk_internal_invoke_NativeEntryPoint::_shadow_space_offset;
+int jdk_internal_invoke_NativeEntryPoint::_argMoves_offset;
+int jdk_internal_invoke_NativeEntryPoint::_returnMoves_offset;
+int jdk_internal_invoke_NativeEntryPoint::_need_transition_offset;
+int jdk_internal_invoke_NativeEntryPoint::_method_type_offset;
+int jdk_internal_invoke_NativeEntryPoint::_name_offset;
+
+#define NEP_FIELDS_DO(macro) \
+  macro(_addr_offset,            k, "addr",           long_signature, false); \
+  macro(_shadow_space_offset,    k, "shadowSpace",    int_signature, false); \
+  macro(_argMoves_offset,        k, "argMoves",       long_array_signature, false); \
+  macro(_returnMoves_offset,     k, "returnMoves",    long_array_signature, false); \
+  macro(_need_transition_offset, k, "needTransition", bool_signature, false); \
+  macro(_method_type_offset,     k, "methodType",     java_lang_invoke_MethodType_signature, false); \
+  macro(_name_offset,            k, "name",           string_signature, false);
+
+bool jdk_internal_invoke_NativeEntryPoint::is_instance(oop obj) {
+  return obj != NULL && is_subclass(obj->klass());
+}
+
+void jdk_internal_invoke_NativeEntryPoint::compute_offsets() {
+  InstanceKlass* k = SystemDictionary::NativeEntryPoint_klass();
+  NEP_FIELDS_DO(FIELD_COMPUTE_OFFSET);
+}
+
+#if INCLUDE_CDS
+void jdk_internal_invoke_NativeEntryPoint::serialize_offsets(SerializeClosure* f) {
+  NEP_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
+}
+#endif
+
+address jdk_internal_invoke_NativeEntryPoint::addr(oop entry) {
+  return (address)entry->long_field(_addr_offset);
+}
+
+jint jdk_internal_invoke_NativeEntryPoint::shadow_space(oop entry) {
+  return entry->int_field(_shadow_space_offset);
+}
+
+oop jdk_internal_invoke_NativeEntryPoint::argMoves(oop entry) {
+  return entry->obj_field(_argMoves_offset);
+}
+
+oop jdk_internal_invoke_NativeEntryPoint::returnMoves(oop entry) {
+  return entry->obj_field(_returnMoves_offset);
+}
+
+jboolean jdk_internal_invoke_NativeEntryPoint::need_transition(oop entry) {
+  return entry->bool_field(_need_transition_offset);
+}
+
+oop jdk_internal_invoke_NativeEntryPoint::method_type(oop entry) {
+  return entry->obj_field(_method_type_offset);
+}
+
+oop jdk_internal_invoke_NativeEntryPoint::name(oop entry) {
+  return entry->obj_field(_name_offset);
+}
 
 oop java_lang_invoke_MethodHandle::type(oop mh) {
   return mh->obj_field(_type_offset);
diff --git a/src/hotspot/share/classfile/javaClasses.hpp b/src/hotspot/share/classfile/javaClasses.hpp
index a73be695ac2a7..6df34eeb534e9 100644
--- a/src/hotspot/share/classfile/javaClasses.hpp
+++ b/src/hotspot/share/classfile/javaClasses.hpp
@@ -74,6 +74,7 @@ class RecordComponent;
   f(java_lang_StackFrameInfo) \
   f(java_lang_LiveStackFrameInfo) \
   f(java_util_concurrent_locks_AbstractOwnableSynchronizer) \
+  f(jdk_internal_invoke_NativeEntryPoint) \
   f(jdk_internal_misc_UnsafeConstants) \
   f(java_lang_boxing_object) \
   //end
@@ -1034,6 +1035,51 @@ class java_lang_invoke_LambdaForm: AllStatic {
   static int vmentry_offset()          { CHECK_INIT(_vmentry_offset); }
 };
 
+// Interface to java.lang.invoke.NativeEntryPoint objects
+// (These are a private interface for managing adapter code generation.)
+
+class jdk_internal_invoke_NativeEntryPoint: AllStatic {
+  friend class JavaClasses;
+
+ private:
+  static int _addr_offset;  // type is jlong
+  static int _shadow_space_offset;
+  static int _argMoves_offset;
+  static int _returnMoves_offset;
+  static int _need_transition_offset;
+  static int _method_type_offset;
+  static int _name_offset;
+
+  static void compute_offsets();
+
+ public:
+  static void serialize_offsets(SerializeClosure* f) NOT_CDS_RETURN;
+
+  // Accessors
+  static address    addr(oop entry);
+  static jint       shadow_space(oop entry);
+  static oop        argMoves(oop entry);
+  static oop        returnMoves(oop entry);
+  static jboolean   need_transition(oop entry);
+  static oop        method_type(oop entry);
+  static oop        name(oop entry);
+
+  // Testers
+  static bool is_subclass(Klass* klass) {
+    return SystemDictionary::NativeEntryPoint_klass() != NULL &&
+      klass->is_subclass_of(SystemDictionary::NativeEntryPoint_klass());
+  }
+  static bool is_instance(oop obj);
+
+  // Accessors for code generation:
+  static int addr_offset_in_bytes()            { return _addr_offset;            }
+  static int shadow_space_offset_in_bytes()    { return _shadow_space_offset;    }
+  static int argMoves_offset_in_bytes()        { return _argMoves_offset;        }
+  static int returnMoves_offset_in_bytes()     { return _returnMoves_offset;     }
+  static int need_transition_offset_in_bytes() { return _need_transition_offset; }
+  static int method_type_offset_in_bytes()     { return _method_type_offset;     }
+  static int name_offset_in_bytes()            { return _name_offset;            }
+};
 
 // Interface to java.lang.invoke.MemberName objects
 // (These are a private interface for Java code to query the class hierarchy.)
diff --git a/src/hotspot/share/classfile/systemDictionary.hpp b/src/hotspot/share/classfile/systemDictionary.hpp
index 257b2da79461c..e80a324a3e31f 100644
--- a/src/hotspot/share/classfile/systemDictionary.hpp
+++ b/src/hotspot/share/classfile/systemDictionary.hpp
@@ -171,6 +171,7 @@ class TableStatistics;
   do_klass(MethodType_klass,                            java_lang_invoke_MethodType                           ) \
   do_klass(BootstrapMethodError_klass,                  java_lang_BootstrapMethodError                        ) \
   do_klass(CallSite_klass,                              java_lang_invoke_CallSite                             ) \
+  do_klass(NativeEntryPoint_klass,                      jdk_internal_invoke_NativeEntryPoint                  ) \
   do_klass(Context_klass,                               java_lang_invoke_MethodHandleNatives_CallSiteContext  ) \
   do_klass(ConstantCallSite_klass,                      java_lang_invoke_ConstantCallSite                     ) \
   do_klass(MutableCallSite_klass,                       java_lang_invoke_MutableCallSite                      ) \
diff --git a/src/hotspot/share/classfile/vmIntrinsics.hpp b/src/hotspot/share/classfile/vmIntrinsics.hpp
index 98427627f169b..62c11aaaa83f7 100644
--- a/src/hotspot/share/classfile/vmIntrinsics.hpp
+++ b/src/hotspot/share/classfile/vmIntrinsics.hpp
@@ -823,6 +823,7 @@
   do_intrinsic(_linkToStatic,             java_lang_invoke_MethodHandle, linkToStatic_name,     star_name, F_SN)        \
   do_intrinsic(_linkToSpecial,            java_lang_invoke_MethodHandle, linkToSpecial_name,    star_name, F_SN)        \
   do_intrinsic(_linkToInterface,          java_lang_invoke_MethodHandle, linkToInterface_name,  star_name, F_SN)        \
+  do_intrinsic(_linkToNative,             java_lang_invoke_MethodHandle, linkToNative_name,     star_name, F_SN)        \
   /* special marker for bytecode generated for the JVM from a LambdaForm: */                                            \
   do_intrinsic(_compiledLambdaForm,       java_lang_invoke_MethodHandle, compiledLambdaForm_name, star_name, F_RN)      \
                                                                                                                         \
diff --git a/src/hotspot/share/classfile/vmSymbols.hpp b/src/hotspot/share/classfile/vmSymbols.hpp
index 90b091d9183a5..c5ab5fb6418ad 100644
--- a/src/hotspot/share/classfile/vmSymbols.hpp
+++ b/src/hotspot/share/classfile/vmSymbols.hpp
@@ -261,6 +261,7 @@
   template(linkToStatic_name,                         "linkToStatic")                             \
   template(linkToSpecial_name,                        "linkToSpecial")                            \
   template(linkToInterface_name,                      "linkToInterface")                          \
+  template(linkToNative_name,                         "linkToNative")                             \
   template(compiledLambdaForm_name,                   "")  /*fake name*/      \
   template(star_name,                                 "*") /*not really a name*/                  \
   template(invoke_name,                               "invoke")                                   \
@@ -335,8 +336,11 @@
   template(DEFAULT_CONTEXT_name,                      "DEFAULT_CONTEXT")                          \
   NOT_LP64(  do_alias(intptr_signature,               int_signature)  )                           \
   LP64_ONLY( do_alias(intptr_signature,               long_signature) )                           \
-                                                                                                                                      \
-  /* Support for JVMCI */                                                                                                             \
+  /* Panama Support */                                                                                          \
+  template(jdk_internal_invoke_NativeEntryPoint,                 "jdk/internal/invoke/NativeEntryPoint")           \
+  template(jdk_internal_invoke_NativeEntryPoint_signature,       "Ljdk/internal/invoke/NativeEntryPoint;")         \
+                                                                                                  \
+  /* Support for JVMCI */                                                                         \
   JVMCI_VM_SYMBOLS_DO(template, do_alias)                                                         \
                                                                                                   \
   template(java_lang_StackWalker,                     "java/lang/StackWalker")                    \
@@ -508,6 +512,7 @@
   template(byte_array_signature,                      "[B")                                       \
   template(char_array_signature,                      "[C")                                       \
   template(int_array_signature,                       "[I")                                       \
+  template(long_array_signature,                      "[J")                                       \
   template(object_void_signature,                     "(Ljava/lang/Object;)V")                    \
   template(object_int_signature,                      "(Ljava/lang/Object;)I")                    \
   template(object_boolean_signature,                  "(Ljava/lang/Object;)Z")                    \
@@ -772,7 +777,7 @@ class vmIntrinsics: AllStatic {
     LAST_COMPILER_INLINE = _getAndSetReference,
     FIRST_MH_SIG_POLY    = _invokeGeneric,
     FIRST_MH_STATIC      = _linkToVirtual,
-    LAST_MH_SIG_POLY     = _linkToInterface,
+    LAST_MH_SIG_POLY     = _linkToNative,
 
     FIRST_ID = _none + 1
   };
diff --git a/src/hotspot/share/code/codeCache.cpp b/src/hotspot/share/code/codeCache.cpp
index 3b589844232a3..7ff9c50f300b9 100644
--- a/src/hotspot/share/code/codeCache.cpp
+++ b/src/hotspot/share/code/codeCache.cpp
@@ -559,10 +559,12 @@ void CodeCache::free(CodeBlob* cb) {
   CodeHeap* heap = get_code_heap(cb);
   print_trace("free", cb);
   if (cb->is_nmethod()) {
+    nmethod* ptr = (nmethod *)cb;
     heap->set_nmethod_count(heap->nmethod_count() - 1);
-    if (((nmethod *)cb)->has_dependencies()) {
+    if (ptr->has_dependencies()) {
       _number_of_nmethods_with_dependencies--;
     }
+    ptr->free_native_stubs();
   }
   if (cb->is_adapter_blob()) {
     heap->set_adapter_count(heap->adapter_count() - 1);
diff --git a/src/hotspot/share/code/compiledMethod.cpp b/src/hotspot/share/code/compiledMethod.cpp
index 78614548f6307..c189f4c2419fb 100644
--- a/src/hotspot/share/code/compiledMethod.cpp
+++ b/src/hotspot/share/code/compiledMethod.cpp
@@ -364,6 +364,7 @@ void CompiledMethod::preserve_callee_argument_oops(frame fr, const RegisterMap *
   if (method() != NULL && !method()->is_native()) {
     address pc = fr.pc();
     SimpleScopeDesc ssd(this, pc);
+    if (ssd.is_optimized_linkToNative()) return; // call was replaced
     Bytecode_invoke call(methodHandle(Thread::current(), ssd.method()), ssd.bci());
     bool has_receiver = call.has_receiver();
     bool has_appendix = call.has_appendix();
diff --git a/src/hotspot/share/code/debugInfoRec.cpp b/src/hotspot/share/code/debugInfoRec.cpp
index b19b9defc4de5..dd135644a85f0 100644
--- a/src/hotspot/share/code/debugInfoRec.cpp
+++ b/src/hotspot/share/code/debugInfoRec.cpp
@@ -287,6 +287,7 @@ void DebugInformationRecorder::describe_scope(int         pc_offset,
                                               bool        reexecute,
                                               bool        rethrow_exception,
                                               bool        is_method_handle_invoke,
+                                              bool        is_optimized_linkToNative,
                                               bool        return_oop,
                                               DebugToken* locals,
                                               DebugToken* expressions,
@@ -303,6 +304,7 @@ void DebugInformationRecorder::describe_scope(int         pc_offset,
   last_pd->set_should_reexecute(reexecute);
   last_pd->set_rethrow_exception(rethrow_exception);
   last_pd->set_is_method_handle_invoke(is_method_handle_invoke);
+  last_pd->set_is_optimized_linkToNative(is_optimized_linkToNative);
   last_pd->set_return_oop(return_oop);
 
   // serialize sender stream offest
diff --git a/src/hotspot/share/code/debugInfoRec.hpp b/src/hotspot/share/code/debugInfoRec.hpp
index 2f64d6b1bd482..d0a9f2b1b6176 100644
--- a/src/hotspot/share/code/debugInfoRec.hpp
+++ b/src/hotspot/share/code/debugInfoRec.hpp
@@ -104,6 +104,7 @@ class DebugInformationRecorder: public ResourceObj {
                       bool        reexecute,
                       bool        rethrow_exception = false,
                       bool        is_method_handle_invoke = false,
+                      bool        is_optimized_linkToNative = false,
                       bool        return_oop = false,
                       DebugToken* locals      = NULL,
                       DebugToken* expressions = NULL,
diff --git a/src/hotspot/share/code/nmethod.cpp b/src/hotspot/share/code/nmethod.cpp
index 57e8802ecb82a..e86804a44fd8c 100644
--- a/src/hotspot/share/code/nmethod.cpp
+++ b/src/hotspot/share/code/nmethod.cpp
@@ -495,7 +495,9 @@ nmethod* nmethod::new_nmethod(const methodHandle& method,
   ExceptionHandlerTable* handler_table,
   ImplicitExceptionTable* nul_chk_table,
   AbstractCompiler* compiler,
-  int comp_level
+  int comp_level,
+  address* native_stubs,
+  int num_stubs
 #if INCLUDE_JVMCI
   , char* speculations,
   int speculations_len,
@@ -532,7 +534,9 @@ nmethod* nmethod::new_nmethod(const methodHandle& method,
             handler_table,
             nul_chk_table,
             compiler,
-            comp_level
+            comp_level,
+            native_stubs,
+            num_stubs
 #if INCLUDE_JVMCI
             , speculations,
             speculations_len,
@@ -596,7 +600,8 @@ nmethod::nmethod(
   : CompiledMethod(method, "native nmethod", type, nmethod_size, sizeof(nmethod), code_buffer, offsets->value(CodeOffsets::Frame_Complete), frame_size, oop_maps, false),
   _is_unloading_state(0),
   _native_receiver_sp_offset(basic_lock_owner_sp_offset),
-  _native_basic_lock_sp_offset(basic_lock_sp_offset)
+  _native_basic_lock_sp_offset(basic_lock_sp_offset),
+  _native_stubs(NULL), _num_stubs(0)
 {
   {
     int scopes_data_offset   = 0;
@@ -716,7 +721,9 @@ nmethod::nmethod(
   ExceptionHandlerTable* handler_table,
   ImplicitExceptionTable* nul_chk_table,
   AbstractCompiler* compiler,
-  int comp_level
+  int comp_level,
+  address* native_stubs,
+  int num_stubs
 #if INCLUDE_JVMCI
   , char* speculations,
   int speculations_len,
@@ -726,7 +733,8 @@ nmethod::nmethod(
   : CompiledMethod(method, "nmethod", type, nmethod_size, sizeof(nmethod), code_buffer, offsets->value(CodeOffsets::Frame_Complete), frame_size, oop_maps, false),
   _is_unloading_state(0),
   _native_receiver_sp_offset(in_ByteSize(-1)),
-  _native_basic_lock_sp_offset(in_ByteSize(-1))
+  _native_basic_lock_sp_offset(in_ByteSize(-1)),
+  _native_stubs(native_stubs), _num_stubs(num_stubs)
 {
   assert(debug_info->oop_recorder() == code_buffer->oop_recorder(), "shared OR");
   {
@@ -1037,6 +1045,17 @@ void nmethod::copy_values(GrowableArray* array) {
   }
 }
 
+void nmethod::free_native_stubs() {
+  if (_native_stubs != NULL) {
+    for (int i = 0; i < _num_stubs; i++) {
+      CodeBlob* cb = CodeCache::find_blob((char*)  _native_stubs[i]);
+      assert(cb != NULL, "Expected to find blob");
+      CodeCache::free(cb);
+    }
+    FREE_C_HEAP_ARRAY(address, _native_stubs);
+  }
+}
+
 void nmethod::fix_oop_relocations(address begin, address end, bool initialize_immediates) {
   // re-patch all oop-bearing instructions, just in case some oops moved
   RelocIterator iter(this, begin, end);
diff --git a/src/hotspot/share/code/nmethod.hpp b/src/hotspot/share/code/nmethod.hpp
index 92b1e72aef81a..af4df1965a7e1 100644
--- a/src/hotspot/share/code/nmethod.hpp
+++ b/src/hotspot/share/code/nmethod.hpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 2019, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -282,6 +282,9 @@ class nmethod : public CompiledMethod {
   ByteSize _native_receiver_sp_offset;
   ByteSize _native_basic_lock_sp_offset;
 
+  address* _native_stubs;
+  int _num_stubs;
+
   friend class nmethodLocker;
 
   // For native wrappers
@@ -312,7 +315,9 @@ class nmethod : public CompiledMethod {
           ExceptionHandlerTable* handler_table,
           ImplicitExceptionTable* nul_chk_table,
           AbstractCompiler* compiler,
-          int comp_level
+          int comp_level,
+          address* native_stubs,
+          int num_stubs
 #if INCLUDE_JVMCI
           , char* speculations,
           int speculations_len,
@@ -360,7 +365,9 @@ class nmethod : public CompiledMethod {
                               ExceptionHandlerTable* handler_table,
                               ImplicitExceptionTable* nul_chk_table,
                               AbstractCompiler* compiler,
-                              int comp_level
+                              int comp_level,
+                              address* native_stubs = NULL,
+                              int num_stubs = 0
 #if INCLUDE_JVMCI
                               , char* speculations = NULL,
                               int speculations_len = 0,
@@ -525,6 +532,8 @@ class nmethod : public CompiledMethod {
   void copy_values(GrowableArray* oops);
   void copy_values(GrowableArray* metadata);
 
+  void free_native_stubs();
+
   // Relocation support
 private:
   void fix_oop_relocations(address begin, address end, bool initialize_immediates);
diff --git a/src/hotspot/share/code/pcDesc.hpp b/src/hotspot/share/code/pcDesc.hpp
index 263a13a353cee..4def290039964 100644
--- a/src/hotspot/share/code/pcDesc.hpp
+++ b/src/hotspot/share/code/pcDesc.hpp
@@ -39,10 +39,11 @@ class PcDesc {
   int _obj_decode_offset;
 
   enum {
-    PCDESC_reexecute               = 1 << 0,
-    PCDESC_is_method_handle_invoke = 1 << 1,
-    PCDESC_return_oop              = 1 << 2,
-    PCDESC_rethrow_exception       = 1 << 3
+    PCDESC_reexecute                 = 1 << 0,
+    PCDESC_is_method_handle_invoke   = 1 << 1,
+    PCDESC_return_oop                = 1 << 2,
+    PCDESC_rethrow_exception         = 1 << 3,
+    PCDESC_is_optimized_linkToNative = 1 << 4
   };
 
   int _flags;
@@ -86,6 +87,9 @@ class PcDesc {
   bool     is_method_handle_invoke()       const { return (_flags & PCDESC_is_method_handle_invoke) != 0;     }
   void set_is_method_handle_invoke(bool z)       { set_flag(PCDESC_is_method_handle_invoke, z); }
 
+  bool     is_optimized_linkToNative()     const { return (_flags & PCDESC_is_optimized_linkToNative) != 0;     }
+  void set_is_optimized_linkToNative(bool z)     { set_flag(PCDESC_is_optimized_linkToNative, z); }
+
   bool     return_oop()                    const { return (_flags & PCDESC_return_oop) != 0;     }
   void set_return_oop(bool z)                    { set_flag(PCDESC_return_oop, z); }
 
diff --git a/src/hotspot/share/code/scopeDesc.hpp b/src/hotspot/share/code/scopeDesc.hpp
index 44c7f160156f4..a60c0fe5f53a3 100644
--- a/src/hotspot/share/code/scopeDesc.hpp
+++ b/src/hotspot/share/code/scopeDesc.hpp
@@ -39,11 +39,14 @@ class SimpleScopeDesc : public StackObj {
  private:
   Method* _method;
   int _bci;
+  bool _is_optimized_linkToNative;
 
  public:
   SimpleScopeDesc(CompiledMethod* code, address pc) {
     PcDesc* pc_desc = code->pc_desc_at(pc);
     assert(pc_desc != NULL, "Must be able to find matching PcDesc");
+    // save this here so we only have to look up the PcDesc once
+    _is_optimized_linkToNative = pc_desc->is_optimized_linkToNative();
     DebugInfoReadStream buffer(code, pc_desc->scope_decode_offset());
     int ignore_sender = buffer.read_int();
     _method           = buffer.read_method();
@@ -52,6 +55,7 @@ class SimpleScopeDesc : public StackObj {
 
   Method* method() { return _method; }
   int bci() { return _bci; }
+  bool is_optimized_linkToNative() { return _is_optimized_linkToNative; }
 };
 
 // ScopeDescs contain the information that makes source-level debugging of
diff --git a/src/hotspot/share/code/vmreg.hpp b/src/hotspot/share/code/vmreg.hpp
index 30beb1dc2264d..1d4c93649bcbd 100644
--- a/src/hotspot/share/code/vmreg.hpp
+++ b/src/hotspot/share/code/vmreg.hpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2019, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -140,6 +140,8 @@ friend class OptoReg;
 
   static void set_regName();
 
+  static VMReg vmStorageToVMReg(int type, int index);
+
 #include CPU_HEADER(vmreg)
 
 };
diff --git a/src/hotspot/share/jvmci/jvmciCodeInstaller.cpp b/src/hotspot/share/jvmci/jvmciCodeInstaller.cpp
index cd12abb9226c7..8121fc5531feb 100644
--- a/src/hotspot/share/jvmci/jvmciCodeInstaller.cpp
+++ b/src/hotspot/share/jvmci/jvmciCodeInstaller.cpp
@@ -1187,7 +1187,7 @@ void CodeInstaller::record_scope(jint pc_offset, JVMCIObject position, ScopeMode
     throw_exception = jvmci_env()->get_BytecodeFrame_rethrowException(frame) == JNI_TRUE;
   }
 
-  _debug_recorder->describe_scope(pc_offset, method, NULL, bci, reexecute, throw_exception, is_mh_invoke, return_oop,
+  _debug_recorder->describe_scope(pc_offset, method, NULL, bci, reexecute, throw_exception, is_mh_invoke, false, return_oop,
                                   locals_token, expressions_token, monitors_token);
 }
 
diff --git a/src/hotspot/share/jvmci/jvmciRuntime.cpp b/src/hotspot/share/jvmci/jvmciRuntime.cpp
index eadd0e60a7da7..7a36e881afe09 100644
--- a/src/hotspot/share/jvmci/jvmciRuntime.cpp
+++ b/src/hotspot/share/jvmci/jvmciRuntime.cpp
@@ -1630,7 +1630,7 @@ JVMCI::CodeInstallResult JVMCIRuntime::register_method(JVMCIEnv* JVMCIENV,
                                  debug_info, dependencies, code_buffer,
                                  frame_words, oop_map_set,
                                  handler_table, implicit_exception_table,
-                                 compiler, comp_level,
+                                 compiler, comp_level, NULL, 0,
                                  speculations, speculations_len,
                                  nmethod_mirror_index, nmethod_mirror_name, failed_speculations);
 
diff --git a/src/hotspot/share/oops/method.cpp b/src/hotspot/share/oops/method.cpp
index 2b136be19c3f6..bef9bdd5aca19 100644
--- a/src/hotspot/share/oops/method.cpp
+++ b/src/hotspot/share/oops/method.cpp
@@ -1498,6 +1498,9 @@ methodHandle Method::make_method_handle_intrinsic(vmIntrinsics::ID iid,
   m->set_vtable_index(Method::nonvirtual_vtable_index);
   m->link_method(m, CHECK_(empty));
 
+  if (iid == vmIntrinsics::_linkToNative) {
+    m->set_interpreter_entry(m->adapter()->get_i2c_entry());
+  }
   if (log_is_enabled(Info, methodhandles) && (Verbose || WizardMode)) {
     LogTarget(Info, methodhandles) lt;
     LogStream ls(lt);
diff --git a/src/hotspot/share/opto/callGenerator.cpp b/src/hotspot/share/opto/callGenerator.cpp
index c2258779cfca3..85c713f55aa41 100644
--- a/src/hotspot/share/opto/callGenerator.cpp
+++ b/src/hotspot/share/opto/callGenerator.cpp
@@ -40,6 +40,8 @@
 #include "opto/runtime.hpp"
 #include "opto/subnode.hpp"
 #include "runtime/sharedRuntime.hpp"
+#include "ci/ciNativeEntryPoint.hpp"
+#include "utilities/debug.hpp"
 
 // Utility function.
 const TypeFunc* CallGenerator::tf() const {
@@ -845,6 +847,31 @@ CallGenerator* CallGenerator::for_method_handle_call(JVMState* jvms, ciMethod* c
   }
 }
 
+class NativeCallGenerator : public CallGenerator {
+private:
+  ciNativeEntryPoint* _nep;
+public:
+  NativeCallGenerator(ciMethod* m, ciNativeEntryPoint* nep)
+   : CallGenerator(m), _nep(nep) {}
+
+  virtual JVMState* generate(JVMState* jvms);
+};
+
+JVMState* NativeCallGenerator::generate(JVMState* jvms) {
+  GraphKit kit(jvms);
+
+  Node* call = kit.make_native_call(tf(), method()->arg_size(), _nep); // -fallback, - nep
+  if (call == NULL) return NULL;
+
+  kit.C->print_inlining_update(this);
+  address addr = _nep->entry_point();
+  if (kit.C->log() != NULL) {
+    kit.C->log()->elem("l2n_intrinsification_success bci='%d' entry_point='" INTPTR_FORMAT "'", jvms->bci(), p2i(addr));
+  }
+
+  return kit.transfer_exceptions_into_jvms();
+}
+
 CallGenerator* CallGenerator::for_method_handle_inline(JVMState* jvms, ciMethod* caller, ciMethod* callee, bool& input_not_const) {
   GraphKit kit(jvms);
   PhaseGVN& gvn = kit.gvn();
@@ -967,6 +994,20 @@ CallGenerator* CallGenerator::for_method_handle_inline(JVMState* jvms, ciMethod*
     }
     break;
 
+    case vmIntrinsics::_linkToNative:
+    {
+      Node* nep = kit.argument(callee->arg_size() - 1);
+      if (nep->Opcode() == Op_ConP) {
+        const TypeOopPtr* oop_ptr = nep->bottom_type()->is_oopptr();
+        ciNativeEntryPoint* nep = oop_ptr->const_oop()->as_native_entry_point();
+        return new NativeCallGenerator(callee, nep);
+      } else {
+        print_inlining_failure(C, callee, jvms->depth() - 1, jvms->bci(),
+                               "NativeEntryPoint not constant");
+      }
+    }
+    break;
+
   default:
     fatal("unexpected intrinsic %d: %s", iid, vmIntrinsics::name_at(iid));
     break;
diff --git a/src/hotspot/share/opto/callnode.cpp b/src/hotspot/share/opto/callnode.cpp
index 268cec7732c8d..5832fbbbbe392 100644
--- a/src/hotspot/share/opto/callnode.cpp
+++ b/src/hotspot/share/opto/callnode.cpp
@@ -43,6 +43,7 @@
 #include "opto/rootnode.hpp"
 #include "opto/runtime.hpp"
 #include "utilities/powerOfTwo.hpp"
+#include "code/vmreg.hpp"
 
 // Portions of code courtesy of Clifford Click
 
@@ -1081,11 +1082,97 @@ void CallRuntimeNode::dump_spec(outputStream *st) const {
 }
 #endif
 
+//=============================================================================
+uint CallNativeNode::size_of() const { return sizeof(*this); }
+bool CallNativeNode::cmp( const Node &n ) const {
+  CallNativeNode &call = (CallNativeNode&)n;
+  return CallNode::cmp(call) && !strcmp(_name,call._name)
+    && _arg_regs == call._arg_regs && _ret_regs == call._ret_regs;
+}
+Node* CallNativeNode::match(const ProjNode *proj, const Matcher *matcher) {
+  switch (proj->_con) {
+    case TypeFunc::Control:
+    case TypeFunc::I_O:
+    case TypeFunc::Memory:
+      return new MachProjNode(this,proj->_con,RegMask::Empty,MachProjNode::unmatched_proj);
+    case TypeFunc::ReturnAdr:
+    case TypeFunc::FramePtr:
+      ShouldNotReachHere();
+    case TypeFunc::Parms:
+    default: {
+      if(tf()->range()->field_at(proj->_con) == Type::HALF) {
+        assert(_ret_regs.at(proj->_con - TypeFunc::Parms) == VMRegImpl::Bad(), "Unexpected register for Type::HALF");
+        // 2nd half of doubles and longs
+        return new MachProjNode(this,proj->_con, RegMask::Empty, (uint)OptoReg::Bad);
+      }
+
+      const BasicType bt = tf()->range()->field_at(proj->_con)->basic_type();
+      OptoReg::Name optoreg = OptoReg::as_OptoReg(_ret_regs.at(proj->_con - TypeFunc::Parms));
+      OptoRegPair regs;
+      if (bt == T_DOUBLE || bt == T_LONG) {
+        regs.set2(optoreg);
+      } else {
+        regs.set1(optoreg);
+      }
+      RegMask rm = RegMask(regs.first());
+      if( OptoReg::is_valid(regs.second()) )
+        rm.Insert( regs.second() );
+      return new MachProjNode(this,proj->_con,rm,tf()->range()->field_at(proj->_con)->ideal_reg());
+    }
+  }
+  return NULL;
+}
+#ifndef PRODUCT
+void CallNativeNode::dump_spec(outputStream *st) const {
+  st->print("# ");
+  st->print("%s ", _name);
+  st->print("_arg_regs: ");
+  _arg_regs.print_on(st);
+  st->print("_ret_regs: ");
+  _ret_regs.print_on(st);
+  CallNode::dump_spec(st);
+}
+#endif
+
 //------------------------------calling_convention-----------------------------
 void CallRuntimeNode::calling_convention( BasicType* sig_bt, VMRegPair *parm_regs, uint argcnt ) const {
   Matcher::c_calling_convention( sig_bt, parm_regs, argcnt );
 }
 
+void CallNativeNode::calling_convention( BasicType* sig_bt, VMRegPair *parm_regs, uint argcnt ) const {
+  assert((tf()->domain()->cnt() - TypeFunc::Parms) == argcnt, "arg counts must match!");
+#ifndef PRODUCT
+  for (uint i = 0; i < argcnt; i++) {
+    assert(tf()->domain()->field_at(TypeFunc::Parms + i)->basic_type() == sig_bt[i], "types must match!");
+  }
+#endif
+  for (uint i = 0; i < argcnt; i++) {
+    switch (sig_bt[i]) {
+      case T_BOOLEAN:
+      case T_CHAR:
+      case T_BYTE:
+      case T_SHORT:
+      case T_INT:
+      case T_FLOAT:
+        parm_regs[i].set1(_arg_regs.at(i));
+        break;
+      case T_LONG:
+      case T_DOUBLE:
+        assert((i + 1) < argcnt && sig_bt[i + 1] == T_VOID, "expecting half");
+        parm_regs[i].set2(_arg_regs.at(i));
+        break;
+      case T_VOID: // Halves of longs and doubles
+        assert(i != 0 && (sig_bt[i - 1] == T_LONG || sig_bt[i - 1] == T_DOUBLE), "expecting half");
+        assert(_arg_regs.at(i) == VMRegImpl::Bad(), "expecting bad reg");
+        parm_regs[i].set_bad();
+        break;
+      default:
+        ShouldNotReachHere();
+        break;
+    }
+  }
+}
+
 //=============================================================================
 //------------------------------calling_convention-----------------------------
 
diff --git a/src/hotspot/share/opto/callnode.hpp b/src/hotspot/share/opto/callnode.hpp
index 16f5a0baae514..a7e61cd2093b3 100644
--- a/src/hotspot/share/opto/callnode.hpp
+++ b/src/hotspot/share/opto/callnode.hpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 2019, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -32,6 +32,7 @@
 #include "opto/phaseX.hpp"
 #include "opto/replacednodes.hpp"
 #include "opto/type.hpp"
+#include "utilities/growableArray.hpp"
 
 // Portions of code courtesy of Clifford Click
 
@@ -48,6 +49,7 @@ class       CallDynamicJavaNode;
 class     CallRuntimeNode;
 class       CallLeafNode;
 class         CallLeafNoFPNode;
+class     CallNativeNode;
 class     AllocateNode;
 class       AllocateArrayNode;
 class     BoxLockNode;
@@ -799,6 +801,40 @@ class CallLeafNode : public CallRuntimeNode {
 #endif
 };
 
+//------------------------------CallNativeNode-----------------------------------
+// Make a direct call into a foreign function with an arbitrary ABI
+// safepoints
+class CallNativeNode : public CallNode {
+  virtual bool cmp( const Node &n ) const;
+  virtual uint size_of() const;
+public:
+  GrowableArray _arg_regs;
+  GrowableArray _ret_regs;
+  const int _shadow_space_bytes;
+  const bool _need_transition;
+
+  CallNativeNode(const TypeFunc* tf, address addr, const char* name,
+                 const TypePtr* adr_type,
+                 const GrowableArray& arg_regs,
+                 const GrowableArray& ret_regs,
+                 int shadow_space_bytes,
+                 bool need_transition)
+    : CallNode(tf, addr, adr_type), _arg_regs(arg_regs),
+      _ret_regs(ret_regs), _shadow_space_bytes(shadow_space_bytes),
+      _need_transition(need_transition)
+  {
+    init_class_id(Class_CallNative);
+    _name = name;
+  }
+  virtual int   Opcode() const;
+  virtual bool  guaranteed_safepoint()  { return _need_transition; }
+  virtual Node* match(const ProjNode *proj, const Matcher *m);
+  virtual void  calling_convention( BasicType* sig_bt, VMRegPair *parm_regs, uint argcnt ) const;
+#ifndef PRODUCT
+  virtual void  dump_spec(outputStream *st) const;
+#endif
+};
+
 //------------------------------CallLeafNoFPNode-------------------------------
 // CallLeafNode, not using floating point or using it in the same manner as
 // the generated code
diff --git a/src/hotspot/share/opto/classes.hpp b/src/hotspot/share/opto/classes.hpp
index e03666fb359e0..0cf84c0a6e0d1 100644
--- a/src/hotspot/share/opto/classes.hpp
+++ b/src/hotspot/share/opto/classes.hpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 2019, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -59,6 +59,7 @@ macro(CallJava)
 macro(CallLeaf)
 macro(CallLeafNoFP)
 macro(CallRuntime)
+macro(CallNative)
 macro(CallStaticJava)
 macro(CastII)
 macro(CastX2P)
diff --git a/src/hotspot/share/opto/compile.cpp b/src/hotspot/share/opto/compile.cpp
index bfe60cbf31987..58ae6138fb749 100644
--- a/src/hotspot/share/opto/compile.cpp
+++ b/src/hotspot/share/opto/compile.cpp
@@ -547,6 +547,7 @@ Compile::Compile( ciEnv* ci_env, ciMethod* target, int osr_bci,
                   _boxing_late_inlines(comp_arena(), 2, 0, NULL),
                   _late_inlines_pos(0),
                   _number_of_mh_late_inlines(0),
+                  _native_stubs(NULL),
                   _print_inlining_stream(NULL),
                   _print_inlining_list(NULL),
                   _print_inlining_idx(0),
@@ -842,6 +843,7 @@ Compile::Compile( ciEnv* ci_env,
     _for_igvn(NULL),
     _warm_calls(NULL),
     _number_of_mh_late_inlines(0),
+    _native_stubs(NULL),
     _print_inlining_stream(NULL),
     _print_inlining_list(NULL),
     _print_inlining_idx(0),
@@ -1018,6 +1020,7 @@ void Compile::Init(int aliaslevel) {
   _expensive_nodes = new(comp_arena()) GrowableArray(comp_arena(), 8,  0, NULL);
   _range_check_casts = new(comp_arena()) GrowableArray(comp_arena(), 8,  0, NULL);
   _opaque4_nodes = new(comp_arena()) GrowableArray(comp_arena(), 8,  0, NULL);
+  _native_stubs = new(comp_arena()) GrowableArray
(comp_arena(), 1,  0, NULL);
   register_library_intrinsics();
 #ifdef ASSERT
   _type_verify_symmetry = true;
@@ -2899,6 +2902,7 @@ void Compile::final_graph_reshaping_main_switch(Node* n, Final_Reshape_Counts& f
     frc.inc_java_call_count(); // Count java call site;
   case Op_CallRuntime:
   case Op_CallLeaf:
+  case Op_CallNative:
   case Op_CallLeafNoFP: {
     assert (n->is_Call(), "");
     CallNode *call = n->as_Call();
@@ -4676,3 +4680,6 @@ void Compile::igv_print_method_to_network(const char* phase_name) {
 }
 #endif
 
+void Compile::add_native_stub(address stubAddress) {
+  _native_stubs->append(stubAddress);
+}
diff --git a/src/hotspot/share/opto/compile.hpp b/src/hotspot/share/opto/compile.hpp
index e63f7f33bbc9c..2ad5eb6ad8fb8 100644
--- a/src/hotspot/share/opto/compile.hpp
+++ b/src/hotspot/share/opto/compile.hpp
@@ -385,6 +385,7 @@ class Compile : public Phase {
   int                           _late_inlines_pos;    // Where in the queue should the next late inlining candidate go (emulate depth first inlining)
   uint                          _number_of_mh_late_inlines; // number of method handle late inlining still pending
 
+  GrowableArray
*       _native_stubs;
 
   // Inlining may not happen in parse order which would make
   // PrintInlining output confusing. Keep track of PrintInlining
@@ -940,6 +941,10 @@ class Compile : public Phase {
     _boxing_late_inlines.push(cg);
   }
 
+  void add_native_stub(address stub);
+
+  GrowableArray
* native_stubs() const { return _native_stubs; }
+
   void remove_useless_late_inlines(GrowableArray* inlines, Unique_Node_List &useful);
 
   void process_print_inlining();
diff --git a/src/hotspot/share/opto/graphKit.cpp b/src/hotspot/share/opto/graphKit.cpp
index 805c7b6d0b1eb..6cc6a193bc369 100644
--- a/src/hotspot/share/opto/graphKit.cpp
+++ b/src/hotspot/share/opto/graphKit.cpp
@@ -25,6 +25,9 @@
 #include "precompiled.hpp"
 #include "ci/ciUtilities.hpp"
 #include "classfile/javaClasses.hpp"
+#include "ci/ciNativeEntryPoint.hpp"
+#include "ci/ciObjArray.hpp"
+#include "asm/register.hpp"
 #include "compiler/compileLog.hpp"
 #include "gc/shared/barrierSet.hpp"
 #include "gc/shared/c2/barrierSetC2.hpp"
@@ -47,6 +50,7 @@
 #include "runtime/sharedRuntime.hpp"
 #include "utilities/bitMap.inline.hpp"
 #include "utilities/powerOfTwo.hpp"
+#include "utilities/growableArray.hpp"
 
 //----------------------------GraphKit-----------------------------------------
 // Main utility constructor.
@@ -2560,6 +2564,135 @@ Node* GraphKit::make_runtime_call(int flags,
 
 }
 
+// i2b
+Node* GraphKit::sign_extend_byte(Node* in) {
+  Node* tmp = _gvn.transform(new LShiftINode(in, _gvn.intcon(24)));
+  return _gvn.transform(new RShiftINode(tmp, _gvn.intcon(24)));
+}
+
+// i2s
+Node* GraphKit::sign_extend_short(Node* in) {
+  Node* tmp = _gvn.transform(new LShiftINode(in, _gvn.intcon(16)));
+  return _gvn.transform(new RShiftINode(tmp, _gvn.intcon(16)));
+}
+
+//-----------------------------make_native_call-------------------------------
+Node* GraphKit::make_native_call(const TypeFunc* call_type, uint nargs, ciNativeEntryPoint* nep) {
+  uint n_filtered_args = nargs - 2; // -fallback, -nep;
+  ResourceMark rm;
+  Node** argument_nodes = NEW_RESOURCE_ARRAY(Node*, n_filtered_args);
+  const Type** arg_types = NEW_RESOURCE_ARRAY(const Type*, n_filtered_args);
+  GrowableArray arg_regs(C->comp_arena(), n_filtered_args, n_filtered_args, VMRegImpl::Bad());
+
+  VMReg* argRegs = nep->argMoves();
+  {
+    for (uint vm_arg_pos = 0, java_arg_read_pos = 0;
+        vm_arg_pos < n_filtered_args; vm_arg_pos++) {
+      uint vm_unfiltered_arg_pos = vm_arg_pos + 1; // +1 to skip fallback handle argument
+      Node* node = argument(vm_unfiltered_arg_pos);
+      const Type* type = call_type->domain()->field_at(TypeFunc::Parms + vm_unfiltered_arg_pos);
+      VMReg reg = type == Type::HALF
+        ? VMRegImpl::Bad()
+        : argRegs[java_arg_read_pos++];
+
+      argument_nodes[vm_arg_pos] = node;
+      arg_types[vm_arg_pos] = type;
+      arg_regs.at_put(vm_arg_pos, reg);
+    }
+  }
+
+  uint n_returns = call_type->range()->cnt() - TypeFunc::Parms;
+  GrowableArray ret_regs(C->comp_arena(), n_returns, n_returns, VMRegImpl::Bad());
+  const Type** ret_types = NEW_RESOURCE_ARRAY(const Type*, n_returns);
+
+  VMReg* retRegs = nep->returnMoves();
+  {
+    for (uint vm_ret_pos = 0, java_ret_read_pos = 0;
+        vm_ret_pos < n_returns; vm_ret_pos++) { // 0 or 1
+      const Type* type = call_type->range()->field_at(TypeFunc::Parms + vm_ret_pos);
+      VMReg reg = type == Type::HALF
+        ? VMRegImpl::Bad()
+        : retRegs[java_ret_read_pos++];
+
+      ret_regs.at_put(vm_ret_pos, reg);
+      ret_types[vm_ret_pos] = type;
+    }
+  }
+
+  const TypeFunc* new_call_type = TypeFunc::make(
+    TypeTuple::make_func(n_filtered_args, arg_types),
+    TypeTuple::make_func(n_returns, ret_types)
+  );
+
+  address call_addr = nep->entry_point();
+  if (nep->need_transition()) {
+    call_addr = SharedRuntime::make_native_invoker(call_addr,
+                                                   nep->shadow_space(),
+                                                   arg_regs, ret_regs);
+    if (call_addr == NULL) return NULL;
+    C->add_native_stub(call_addr);
+  }
+  assert(call_addr != NULL, "sanity");
+
+  CallNativeNode* call = new CallNativeNode(new_call_type, call_addr, nep->name(), TypePtr::BOTTOM,
+                                            arg_regs,
+                                            ret_regs,
+                                            nep->shadow_space(),
+                                            nep->need_transition());
+
+  if (call->_need_transition) {
+    add_safepoint_edges(call);
+  }
+
+  set_predefined_input_for_runtime_call(call);
+
+  for (uint i = 0; i < n_filtered_args; i++) {
+    call->init_req(i + TypeFunc::Parms, argument_nodes[i]);
+  }
+
+  Node* c = gvn().transform(call);
+  assert(c == call, "cannot disappear");
+
+  set_predefined_output_for_runtime_call(call);
+
+  Node* ret;
+  if (method() == NULL || method()->return_type()->basic_type() == T_VOID) {
+    ret = top();
+  } else {
+    Node* current_value = NULL;
+    for (uint vm_ret_pos = 0; vm_ret_pos < n_returns; vm_ret_pos++) {
+      if (new_call_type->range()->field_at(TypeFunc::Parms + vm_ret_pos)  == Type::HALF) {
+        // FIXME is this needed?
+        gvn().transform(new ProjNode(call, TypeFunc::Parms + vm_ret_pos));
+      } else {
+        assert(current_value == NULL, "Must not overwrite");
+        current_value = gvn().transform(new ProjNode(call, TypeFunc::Parms + vm_ret_pos));
+      }
+    }
+    assert(current_value != NULL, "Should not be null");
+    // Unpack native results if needed
+    // Need this method type since it's unerased
+    switch (nep->method_type()->rtype()->basic_type()) {
+      case T_CHAR:
+        current_value = _gvn.transform(new AndINode(current_value, _gvn.intcon(0xFFFF)));
+        break;
+      case T_BYTE:
+        current_value = sign_extend_byte(current_value);
+        break;
+      case T_SHORT:
+        current_value = sign_extend_short(current_value);
+        break;
+      default: // do nothing
+        break;
+    }
+    ret = current_value;
+  }
+
+  push_node(method()->return_type()->basic_type(), ret);
+
+  return call;
+}
+
 //------------------------------merge_memory-----------------------------------
 // Merge memory from one path into the current memory state.
 void GraphKit::merge_memory(Node* new_mem, Node* region, int new_path) {
diff --git a/src/hotspot/share/opto/graphKit.hpp b/src/hotspot/share/opto/graphKit.hpp
index ff649d2cbb98f..9767e11429a07 100644
--- a/src/hotspot/share/opto/graphKit.hpp
+++ b/src/hotspot/share/opto/graphKit.hpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2001, 2019, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2001, 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -791,6 +791,12 @@ class GraphKit : public Phase {
                           Node* parm2 = NULL, Node* parm3 = NULL,
                           Node* parm4 = NULL, Node* parm5 = NULL,
                           Node* parm6 = NULL, Node* parm7 = NULL);
+
+  Node* sign_extend_byte(Node* in);
+  Node* sign_extend_short(Node* in);
+
+  Node* make_native_call(const TypeFunc* call_type, uint nargs, ciNativeEntryPoint* nep);
+
   enum {  // flag values for make_runtime_call
     RC_NO_FP = 1,               // CallLeafNoFPNode
     RC_NO_IO = 2,               // do not hook IO edges
diff --git a/src/hotspot/share/opto/lcm.cpp b/src/hotspot/share/opto/lcm.cpp
index 72c15722bd63f..920c1208f3bf6 100644
--- a/src/hotspot/share/opto/lcm.cpp
+++ b/src/hotspot/share/opto/lcm.cpp
@@ -861,6 +861,10 @@ uint PhaseCFG::sched_call(Block* block, uint node_cnt, Node_List& worklist, Grow
       // Calling Java code so use Java calling convention
       save_policy = _matcher._register_save_policy;
       break;
+    case Op_CallNative:
+      // FIXME compute actual save policy based on nep->abi
+      save_policy = _matcher._c_reg_save_policy;
+      break;
 
     default:
       ShouldNotReachHere();
@@ -874,7 +878,14 @@ uint PhaseCFG::sched_call(Block* block, uint node_cnt, Node_List& worklist, Grow
   // done for oops since idealreg2debugmask takes care of debug info
   // references but there no way to handle oops differently than other
   // pointers as far as the kill mask goes.
-  bool exclude_soe = op == Op_CallRuntime;
+  //
+  // Also, native callees can not save oops, so we kill the SOE registers
+  // here in case a native call has a safepoint. This doesn't work for
+  // RBP though, which seems to be special-cased elsewhere to always be
+  // treated as alive, so we instead manually save the location of RBP
+  // before doing the native call (see NativeInvokerGenerator::generate).
+  bool exclude_soe = op == Op_CallRuntime
+    || (op == Op_CallNative && mcall->guaranteed_safepoint());
 
   // If the call is a MethodHandle invoke, we need to exclude the
   // register which is used to save the SP value over MH invokes from
diff --git a/src/hotspot/share/opto/machnode.cpp b/src/hotspot/share/opto/machnode.cpp
index c51d6117cfb32..c29a66b7aefa9 100644
--- a/src/hotspot/share/opto/machnode.cpp
+++ b/src/hotspot/share/opto/machnode.cpp
@@ -818,6 +818,23 @@ void MachCallRuntimeNode::dump_spec(outputStream *st) const {
 }
 #endif
 //=============================================================================
+uint MachCallNativeNode::size_of() const { return sizeof(*this); }
+bool MachCallNativeNode::cmp( const Node &n ) const {
+  MachCallNativeNode &call = (MachCallNativeNode&)n;
+  return MachCallNode::cmp(call) && !strcmp(_name,call._name)
+    && _arg_regs == call._arg_regs && _ret_regs == call._ret_regs;
+}
+#ifndef PRODUCT
+void MachCallNativeNode::dump_spec(outputStream *st) const {
+  st->print("%s ",_name);
+  st->print("_arg_regs: ");
+  _arg_regs.print_on(st);
+  st->print("_ret_regs: ");
+  _ret_regs.print_on(st);
+  MachCallNode::dump_spec(st);
+}
+#endif
+//=============================================================================
 // A shared JVMState for all HaltNodes.  Indicates the start of debug info
 // is at TypeFunc::Parms.  Only required for SOE register spill handling -
 // to indicate where the stack-slot-only debug info inputs begin.
diff --git a/src/hotspot/share/opto/machnode.hpp b/src/hotspot/share/opto/machnode.hpp
index cb1d6d6937298..0322431003616 100644
--- a/src/hotspot/share/opto/machnode.hpp
+++ b/src/hotspot/share/opto/machnode.hpp
@@ -31,6 +31,7 @@
 #include "opto/multnode.hpp"
 #include "opto/node.hpp"
 #include "opto/regmask.hpp"
+#include "utilities/growableArray.hpp"
 
 class BiasedLockingCounters;
 class BufferBlob;
@@ -39,6 +40,7 @@ class JVMState;
 class MachCallDynamicJavaNode;
 class MachCallJavaNode;
 class MachCallLeafNode;
+class MachCallNativeNode;
 class MachCallNode;
 class MachCallRuntimeNode;
 class MachCallStaticJavaNode;
@@ -880,14 +882,16 @@ class MachCallNode : public MachSafePointNode {
   const TypeFunc *_tf;        // Function type
   address      _entry_point;  // Address of the method being called
   float        _cnt;          // Estimate of number of times called
+  bool         _guaranteed_safepoint; // Do we need to observe safepoint?
 
   const TypeFunc* tf()        const { return _tf; }
   const address entry_point() const { return _entry_point; }
   const float   cnt()         const { return _cnt; }
 
-  void set_tf(const TypeFunc* tf) { _tf = tf; }
-  void set_entry_point(address p) { _entry_point = p; }
-  void set_cnt(float c)           { _cnt = c; }
+  void set_tf(const TypeFunc* tf)       { _tf = tf; }
+  void set_entry_point(address p)       { _entry_point = p; }
+  void set_cnt(float c)                 { _cnt = c; }
+  void set_guaranteed_safepoint(bool b) { _guaranteed_safepoint = b; }
 
   MachCallNode() : MachSafePointNode() {
     init_class_id(Class_MachCall);
@@ -905,6 +909,8 @@ class MachCallNode : public MachSafePointNode {
   // Similar to cousin class CallNode::returns_pointer
   bool returns_pointer() const;
 
+  bool guaranteed_safepoint() const { return _guaranteed_safepoint; }
+
 #ifndef PRODUCT
   virtual void dump_spec(outputStream *st) const;
 #endif
@@ -1003,6 +1009,24 @@ class MachCallLeafNode: public MachCallRuntimeNode {
   }
 };
 
+class MachCallNativeNode: public MachCallNode {
+  virtual bool cmp( const Node &n ) const;
+  virtual uint size_of() const;
+public:
+  const char *_name;
+  GrowableArray _arg_regs;
+  GrowableArray _ret_regs;
+
+  MachCallNativeNode() : MachCallNode() {
+    init_class_id(Class_MachCallNative);
+  }
+
+  virtual int ret_addr_offset();
+#ifndef PRODUCT
+  virtual void dump_spec(outputStream *st) const;
+#endif
+};
+
 //------------------------------MachHaltNode-----------------------------------
 // Machine-specific versions of halt nodes
 class MachHaltNode : public MachReturnNode {
diff --git a/src/hotspot/share/opto/matcher.cpp b/src/hotspot/share/opto/matcher.cpp
index b07b4e03be9a4..2f75e22d08ecd 100644
--- a/src/hotspot/share/opto/matcher.cpp
+++ b/src/hotspot/share/opto/matcher.cpp
@@ -1180,9 +1180,10 @@ MachNode *Matcher::match_sfpt( SafePointNode *sfpt ) {
     // Copy data from the Ideal SafePoint to the machine version
     mcall = m->as_MachCall();
 
-    mcall->set_tf(         call->tf());
-    mcall->set_entry_point(call->entry_point());
-    mcall->set_cnt(        call->cnt());
+    mcall->set_tf(                  call->tf());
+    mcall->set_entry_point(         call->entry_point());
+    mcall->set_cnt(                 call->cnt());
+    mcall->set_guaranteed_safepoint(call->guaranteed_safepoint());
 
     if( mcall->is_MachCallJava() ) {
       MachCallJavaNode *mcall_java  = mcall->as_MachCallJava();
@@ -1208,6 +1209,13 @@ MachNode *Matcher::match_sfpt( SafePointNode *sfpt ) {
     else if( mcall->is_MachCallRuntime() ) {
       mcall->as_MachCallRuntime()->_name = call->as_CallRuntime()->_name;
     }
+    else if( mcall->is_MachCallNative() ) {
+      MachCallNativeNode* mach_call_native = mcall->as_MachCallNative();
+      CallNativeNode* call_native = call->as_CallNative();
+      mach_call_native->_name = call_native->_name;
+      mach_call_native->_arg_regs = call_native->_arg_regs;
+      mach_call_native->_ret_regs = call_native->_ret_regs;
+    }
     msfpt = mcall;
   }
   // This is a non-call safepoint
@@ -1241,6 +1249,8 @@ MachNode *Matcher::match_sfpt( SafePointNode *sfpt ) {
   // These are usually backing store for register arguments for varargs.
   if( call != NULL && call->is_CallRuntime() )
     out_arg_limit_per_call = OptoReg::add(out_arg_limit_per_call,C->varargs_C_out_slots_killed());
+  if( call != NULL && call->is_CallNative() )
+    out_arg_limit_per_call = OptoReg::add(out_arg_limit_per_call, call->as_CallNative()->_shadow_space_bytes);
 
 
   // Do the normal argument list (parameters) register masks
diff --git a/src/hotspot/share/opto/node.hpp b/src/hotspot/share/opto/node.hpp
index 12ad1c27b5288..c6fc567027704 100644
--- a/src/hotspot/share/opto/node.hpp
+++ b/src/hotspot/share/opto/node.hpp
@@ -50,6 +50,7 @@ class CallJavaNode;
 class CallLeafNode;
 class CallNode;
 class CallRuntimeNode;
+class CallNativeNode;
 class CallStaticJavaNode;
 class CastIINode;
 class CatchNode;
@@ -91,6 +92,7 @@ class MachCallDynamicJavaNode;
 class MachCallJavaNode;
 class MachCallLeafNode;
 class MachCallNode;
+class MachCallNativeNode;
 class MachCallRuntimeNode;
 class MachCallStaticJavaNode;
 class MachConstantBaseNode;
@@ -627,6 +629,7 @@ class Node {
             DEFINE_CLASS_ID(Lock,             AbstractLock, 0)
             DEFINE_CLASS_ID(Unlock,           AbstractLock, 1)
           DEFINE_CLASS_ID(ArrayCopy,        Call, 4)
+          DEFINE_CLASS_ID(CallNative,       Call, 5)
       DEFINE_CLASS_ID(MultiBranch, Multi, 1)
         DEFINE_CLASS_ID(PCTable,     MultiBranch, 0)
           DEFINE_CLASS_ID(Catch,       PCTable, 0)
@@ -650,6 +653,7 @@ class Node {
               DEFINE_CLASS_ID(MachCallDynamicJava,  MachCallJava, 1)
             DEFINE_CLASS_ID(MachCallRuntime,      MachCall, 1)
               DEFINE_CLASS_ID(MachCallLeaf,         MachCallRuntime, 0)
+            DEFINE_CLASS_ID(MachCallNative,       MachCall, 2)
       DEFINE_CLASS_ID(MachBranch, Mach, 1)
         DEFINE_CLASS_ID(MachIf,         MachBranch, 0)
         DEFINE_CLASS_ID(MachGoto,       MachBranch, 1)
@@ -801,6 +805,7 @@ class Node {
   DEFINE_CLASS_QUERY(Bool)
   DEFINE_CLASS_QUERY(BoxLock)
   DEFINE_CLASS_QUERY(Call)
+  DEFINE_CLASS_QUERY(CallNative)
   DEFINE_CLASS_QUERY(CallDynamicJava)
   DEFINE_CLASS_QUERY(CallJava)
   DEFINE_CLASS_QUERY(CallLeaf)
@@ -841,6 +846,7 @@ class Node {
   DEFINE_CLASS_QUERY(Mach)
   DEFINE_CLASS_QUERY(MachBranch)
   DEFINE_CLASS_QUERY(MachCall)
+  DEFINE_CLASS_QUERY(MachCallNative)
   DEFINE_CLASS_QUERY(MachCallDynamicJava)
   DEFINE_CLASS_QUERY(MachCallJava)
   DEFINE_CLASS_QUERY(MachCallLeaf)
diff --git a/src/hotspot/share/opto/output.cpp b/src/hotspot/share/opto/output.cpp
index 7b9dfc8d0e411..d58b9ec4d0feb 100644
--- a/src/hotspot/share/opto/output.cpp
+++ b/src/hotspot/share/opto/output.cpp
@@ -35,6 +35,7 @@
 #include "gc/shared/barrierSet.hpp"
 #include "gc/shared/c2/barrierSetC2.hpp"
 #include "memory/allocation.inline.hpp"
+#include "memory/allocation.hpp"
 #include "opto/ad.hpp"
 #include "opto/block.hpp"
 #include "opto/c2compiler.hpp"
@@ -1133,7 +1134,20 @@ void PhaseOutput::Process_OopMap_Node(MachNode *mach, int current_offset) {
     // Now we can describe the scope.
     methodHandle null_mh;
     bool rethrow_exception = false;
-    C->debug_info()->describe_scope(safepoint_pc_offset, null_mh, scope_method, jvms->bci(), jvms->should_reexecute(), rethrow_exception, is_method_handle_invoke, return_oop, locvals, expvals, monvals);
+    C->debug_info()->describe_scope(
+      safepoint_pc_offset,
+      null_mh,
+      scope_method,
+      jvms->bci(),
+      jvms->should_reexecute(),
+      rethrow_exception,
+      is_method_handle_invoke,
+      mach->is_MachCallNative(),
+      return_oop,
+      locvals,
+      expvals,
+      monvals
+    );
   } // End jvms loop
 
   // Mark the end of the scope set.
@@ -1511,6 +1525,7 @@ void PhaseOutput::fill_buffer(CodeBuffer* cb, uint* blk_starts) {
           current_offset = cb->insts_size();
         }
 
+        bool observe_safepoint = is_sfn;
         // Remember the start of the last call in a basic block
         if (is_mcall) {
           MachCallNode *mcall = mach->as_MachCall();
@@ -1521,15 +1536,11 @@ void PhaseOutput::fill_buffer(CodeBuffer* cb, uint* blk_starts) {
           // Save the return address
           call_returns[block->_pre_order] = current_offset + mcall->ret_addr_offset();
 
-          if (mcall->is_MachCallLeaf()) {
-            is_mcall = false;
-            is_sfn = false;
-          }
+          observe_safepoint = mcall->guaranteed_safepoint();
         }
 
         // sfn will be valid whenever mcall is valid now because of inheritance
-        if (is_sfn || is_mcall) {
-
+        if (observe_safepoint) {
           // Handle special safepoint nodes for synchronization
           if (!is_mcall) {
             MachSafePointNode *sfn = mach->as_MachSafePoint();
@@ -1674,6 +1685,8 @@ void PhaseOutput::fill_buffer(CodeBuffer* cb, uint* blk_starts) {
       n->emit(*cb, C->regalloc());
       current_offset  = cb->insts_size();
 
+      assert(!is_mcall || (call_returns[block->_pre_order] == (uint) current_offset), "ret_addr_offset() did not match size of emitted code");
+
       // Above we only verified that there is enough space in the instruction section.
       // However, the instruction may emit stubs that cause code buffer expansion.
       // Bail out here if expansion failed due to a lack of code cache space.
@@ -3370,6 +3383,16 @@ void PhaseOutput::install_code(ciMethod*         target,
       _code_offsets.set_value(CodeOffsets::OSR_Entry, 0);
     }
 
+    address* native_stubs = NULL;
+    int num_stubs = 0;
+    if (!C->native_stubs()->is_empty()) {
+      num_stubs = C->native_stubs()->length();
+      native_stubs = NEW_C_HEAP_ARRAY(address, num_stubs, mtInternal);
+      for (int i = 0; i < num_stubs; i++) {
+        native_stubs[i] = C->native_stubs()->at(i);
+      }
+    }
+
     C->env()->register_method(target,
                                      entry_bci,
                                      &_code_offsets,
@@ -3382,7 +3405,9 @@ void PhaseOutput::install_code(ciMethod*         target,
                                      compiler,
                                      has_unsafe_access,
                                      SharedRuntime::is_wide_vector(C->max_vector_size()),
-                                     C->rtm_state());
+                                     C->rtm_state(),
+                                     native_stubs,
+                                     num_stubs);
 
     if (C->log() != NULL) { // Print code cache state into compiler log
       C->log()->code_cache_state();
diff --git a/src/hotspot/share/opto/type.cpp b/src/hotspot/share/opto/type.cpp
index dc7af3d4b2951..b04e60431e26b 100644
--- a/src/hotspot/share/opto/type.cpp
+++ b/src/hotspot/share/opto/type.cpp
@@ -1977,6 +1977,14 @@ const TypeTuple *TypeTuple::make( uint cnt, const Type **fields ) {
   return (TypeTuple*)(new TypeTuple(cnt,fields))->hashcons();
 }
 
+const TypeTuple *TypeTuple::make_func( uint arg_cnt, const Type **arg_fields ) {
+  const Type** field_array = fields(arg_cnt);
+  for (uint i = 0; i < arg_cnt; i++) {
+    field_array[i + TypeFunc::Parms] = arg_fields[i];
+  }
+  return make(arg_cnt + TypeFunc::Parms, field_array);
+}
+
 //------------------------------fields-----------------------------------------
 // Subroutine call type with space allocated for argument types
 // Memory for Control, I_O, Memory, FramePtr, and ReturnAdr is allocated implicitly
diff --git a/src/hotspot/share/opto/type.hpp b/src/hotspot/share/opto/type.hpp
index 989630b17a87c..d79b9328d2fc0 100644
--- a/src/hotspot/share/opto/type.hpp
+++ b/src/hotspot/share/opto/type.hpp
@@ -667,6 +667,7 @@ class TypeTuple : public Type {
   static const TypeTuple *make( uint cnt, const Type **fields );
   static const TypeTuple *make_range(ciSignature *sig);
   static const TypeTuple *make_domain(ciInstanceKlass* recv, ciSignature *sig);
+  static const TypeTuple *make_func(uint arg_cnt, const Type **arg_fields);
 
   // Subroutine call type with space allocated for argument types
   // Memory for Control, I_O, Memory, FramePtr, and ReturnAdr is allocated implicitly
diff --git a/src/hotspot/share/prims/methodHandles.cpp b/src/hotspot/share/prims/methodHandles.cpp
index 0fe64b027af26..0f452bbf637d3 100644
--- a/src/hotspot/share/prims/methodHandles.cpp
+++ b/src/hotspot/share/prims/methodHandles.cpp
@@ -426,6 +426,7 @@ Symbol* MethodHandles::signature_polymorphic_intrinsic_name(vmIntrinsics::ID iid
   case vmIntrinsics::_linkToStatic:     return vmSymbols::linkToStatic_name();
   case vmIntrinsics::_linkToSpecial:    return vmSymbols::linkToSpecial_name();
   case vmIntrinsics::_linkToInterface:  return vmSymbols::linkToInterface_name();
+  case vmIntrinsics::_linkToNative:     return vmSymbols::linkToNative_name();
   default:
     fatal("unexpected intrinsic id: %d %s", iid, vmIntrinsics::name_at(iid));
     return 0;
@@ -448,6 +449,7 @@ Bytecodes::Code MethodHandles::signature_polymorphic_intrinsic_bytecode(vmIntrin
 int MethodHandles::signature_polymorphic_intrinsic_ref_kind(vmIntrinsics::ID iid) {
   switch (iid) {
   case vmIntrinsics::_invokeBasic:      return 0;
+  case vmIntrinsics::_linkToNative:     return 0;
   case vmIntrinsics::_linkToVirtual:    return JVM_REF_invokeVirtual;
   case vmIntrinsics::_linkToStatic:     return JVM_REF_invokeStatic;
   case vmIntrinsics::_linkToSpecial:    return JVM_REF_invokeSpecial;
@@ -471,6 +473,7 @@ vmIntrinsics::ID MethodHandles::signature_polymorphic_name_id(Symbol* name) {
   case vmSymbols::VM_SYMBOL_ENUM_NAME(linkToStatic_name):     return vmIntrinsics::_linkToStatic;
   case vmSymbols::VM_SYMBOL_ENUM_NAME(linkToSpecial_name):    return vmIntrinsics::_linkToSpecial;
   case vmSymbols::VM_SYMBOL_ENUM_NAME(linkToInterface_name):  return vmIntrinsics::_linkToInterface;
+  case vmSymbols::VM_SYMBOL_ENUM_NAME(linkToNative_name):     return vmIntrinsics::_linkToNative;
   default:                                                    break;
   }
 
diff --git a/src/hotspot/share/prims/methodHandles.hpp b/src/hotspot/share/prims/methodHandles.hpp
index ac1f95fe903f8..eb75324395014 100644
--- a/src/hotspot/share/prims/methodHandles.hpp
+++ b/src/hotspot/share/prims/methodHandles.hpp
@@ -118,7 +118,7 @@ class MethodHandles: AllStatic {
   static bool has_member_arg(vmIntrinsics::ID iid) {
     assert(is_signature_polymorphic(iid), "");
     return (iid >= vmIntrinsics::_linkToVirtual &&
-            iid <= vmIntrinsics::_linkToInterface);
+            iid <= vmIntrinsics::_linkToNative);
   }
   static bool has_member_arg(Symbol* klass, Symbol* name) {
     if ((klass == vmSymbols::java_lang_invoke_MethodHandle() ||
diff --git a/src/hotspot/share/prims/nativeLookup.cpp b/src/hotspot/share/prims/nativeLookup.cpp
index c3a8a48f0647a..9a3520837b281 100644
--- a/src/hotspot/share/prims/nativeLookup.cpp
+++ b/src/hotspot/share/prims/nativeLookup.cpp
@@ -117,6 +117,11 @@ char* NativeLookup::long_jni_name(const methodHandle& method) {
 
 extern "C" {
   void JNICALL JVM_RegisterMethodHandleMethods(JNIEnv *env, jclass unsafecls);
+  void JNICALL JVM_RegisterReferencesMethods(JNIEnv *env, jclass unsafecls);
+  void JNICALL JVM_RegisterUpcallHandlerMethods(JNIEnv *env, jclass unsafecls);
+  void JNICALL JVM_RegisterProgrammableUpcallHandlerMethods(JNIEnv *env, jclass unsafecls);
+  void JNICALL JVM_RegisterProgrammableInvokerMethods(JNIEnv *env, jclass unsafecls);
+  void JNICALL JVM_RegisterNativeEntryPointMethods(JNIEnv *env, jclass unsafecls);
   void JNICALL JVM_RegisterPerfMethods(JNIEnv *env, jclass perfclass);
   void JNICALL JVM_RegisterWhiteBoxMethods(JNIEnv *env, jclass wbclass);
 #if INCLUDE_JVMCI
@@ -131,6 +136,10 @@ extern "C" {
 static JNINativeMethod lookup_special_native_methods[] = {
   { CC"Java_jdk_internal_misc_Unsafe_registerNatives",             NULL, FN_PTR(JVM_RegisterJDKInternalMiscUnsafeMethods) },
   { CC"Java_java_lang_invoke_MethodHandleNatives_registerNatives", NULL, FN_PTR(JVM_RegisterMethodHandleMethods) },
+  { CC"Java_jdk_internal_foreign_abi_UpcallStubs_registerNatives",      NULL, FN_PTR(JVM_RegisterUpcallHandlerMethods) },
+  { CC"Java_jdk_internal_foreign_abi_ProgrammableUpcallHandler_registerNatives",      NULL, FN_PTR(JVM_RegisterProgrammableUpcallHandlerMethods) },
+  { CC"Java_jdk_internal_foreign_abi_ProgrammableInvoker_registerNatives",      NULL, FN_PTR(JVM_RegisterProgrammableInvokerMethods) },
+  { CC"Java_jdk_internal_invoke_NativeEntryPoint_registerNatives",      NULL, FN_PTR(JVM_RegisterNativeEntryPointMethods) },
   { CC"Java_jdk_internal_perf_Perf_registerNatives",               NULL, FN_PTR(JVM_RegisterPerfMethods)         },
   { CC"Java_sun_hotspot_WhiteBox_registerNatives",                 NULL, FN_PTR(JVM_RegisterWhiteBoxMethods)     },
 #if INCLUDE_JVMCI
diff --git a/src/hotspot/share/prims/whitebox.cpp b/src/hotspot/share/prims/whitebox.cpp
index 2df5c7acafad6..8c1d42e7e5995 100644
--- a/src/hotspot/share/prims/whitebox.cpp
+++ b/src/hotspot/share/prims/whitebox.cpp
@@ -2286,6 +2286,25 @@ WB_ENTRY(void, WB_CheckThreadObjOfTerminatingThread(JNIEnv* env, jobject wb, job
   }
 WB_END
 
+WB_ENTRY(void, WB_VerifyFrames(JNIEnv* env, jobject wb, jboolean log))
+  intx tty_token = -1;
+  if (log) {
+    tty_token = ttyLocker::hold_tty();
+    tty->print_cr("[WhiteBox::VerifyFrames] Walking Frames");
+  }
+  for (StackFrameStream fst(JavaThread::current(), true, true); !fst.is_done(); fst.next()) {
+    frame* current_frame = fst.current();
+    if (log) {
+      current_frame->print_value();
+    }
+    current_frame->verify(fst.register_map());
+  }
+  if (log) {
+    tty->print_cr("[WhiteBox::VerifyFrames] Done");
+    ttyLocker::release_tty(tty_token);
+  }
+WB_END
+
 WB_ENTRY(jboolean, WB_IsJVMTIIncluded(JNIEnv* env, jobject wb))
   return INCLUDE_JVMTI ? JNI_TRUE : JNI_FALSE;
 WB_END
@@ -2527,6 +2546,7 @@ static JNINativeMethod methods[] = {
   {CC"handshakeWalkStack", CC"(Ljava/lang/Thread;Z)I", (void*)&WB_HandshakeWalkStack },
   {CC"asyncHandshakeWalkStack", CC"(Ljava/lang/Thread;)V", (void*)&WB_AsyncHandshakeWalkStack },
   {CC"checkThreadObjOfTerminatingThread", CC"(Ljava/lang/Thread;)V", (void*)&WB_CheckThreadObjOfTerminatingThread },
+  {CC"verifyFrames",                CC"(Z)V",            (void*)&WB_VerifyFrames },
   {CC"addCompilerDirective",    CC"(Ljava/lang/String;)I",
                                                       (void*)&WB_AddCompilerDirective },
   {CC"removeCompilerDirective",   CC"(I)V",           (void*)&WB_RemoveCompilerDirective },
diff --git a/src/hotspot/share/runtime/frame.cpp b/src/hotspot/share/runtime/frame.cpp
index 3ec39954f11ae..04c1403f44cff 100644
--- a/src/hotspot/share/runtime/frame.cpp
+++ b/src/hotspot/share/runtime/frame.cpp
@@ -941,6 +941,7 @@ class CompiledArgumentOopFinder: public SignatureIterator {
     // In LP64-land, the high-order bits are valid but unhelpful.
     VMReg reg = _regs[_offset].first();
     oop *loc = _fr.oopmapreg_to_location(reg, _reg_map);
+    assert(loc != NULL, "missing register map entry");
     _f->do_oop(loc);
   }
 
diff --git a/src/hotspot/share/runtime/init.cpp b/src/hotspot/share/runtime/init.cpp
index 9d7014778d24d..63dfb88199892 100644
--- a/src/hotspot/share/runtime/init.cpp
+++ b/src/hotspot/share/runtime/init.cpp
@@ -36,6 +36,8 @@
 #include "memory/universe.hpp"
 #include "prims/jvmtiExport.hpp"
 #include "prims/methodHandles.hpp"
+#include "prims/universalNativeInvoker.hpp"
+#include "runtime/globals.hpp"
 #include "runtime/atomic.hpp"
 #include "runtime/flags/jvmFlag.hpp"
 #include "runtime/handles.inline.hpp"
diff --git a/src/hotspot/share/runtime/sharedRuntime.hpp b/src/hotspot/share/runtime/sharedRuntime.hpp
index 3dacd0a1750cf..9a075097bacbe 100644
--- a/src/hotspot/share/runtime/sharedRuntime.hpp
+++ b/src/hotspot/share/runtime/sharedRuntime.hpp
@@ -520,6 +520,11 @@ class SharedRuntime: AllStatic {
 
   static address handle_unsafe_access(JavaThread* thread, address next_pc);
 
+  static address make_native_invoker(address call_target,
+                                     int shadow_space_bytes,
+                                     const GrowableArray& input_registers,
+                                     const GrowableArray& output_registers);
+
 #ifndef PRODUCT
 
   // Collect and print inline cache miss statistics
diff --git a/src/hotspot/share/runtime/thread.hpp b/src/hotspot/share/runtime/thread.hpp
index cb6eaa024bcb1..a43a83609ef4e 100644
--- a/src/hotspot/share/runtime/thread.hpp
+++ b/src/hotspot/share/runtime/thread.hpp
@@ -1597,6 +1597,10 @@ class JavaThread: public Thread {
   static ByteSize frame_anchor_offset() {
     return byte_offset_of(JavaThread, _anchor);
   }
+  static ByteSize saved_rbp_address_offset() {
+    return byte_offset_of(JavaThread, _anchor) + JavaFrameAnchor::saved_rbp_address_offset();
+  }
+
   static ByteSize callee_target_offset()         { return byte_offset_of(JavaThread, _callee_target); }
   static ByteSize vm_result_offset()             { return byte_offset_of(JavaThread, _vm_result); }
   static ByteSize vm_result_2_offset()           { return byte_offset_of(JavaThread, _vm_result_2); }
diff --git a/src/hotspot/share/runtime/vmStructs.cpp b/src/hotspot/share/runtime/vmStructs.cpp
index a73b125977945..88f02987c01d1 100644
--- a/src/hotspot/share/runtime/vmStructs.cpp
+++ b/src/hotspot/share/runtime/vmStructs.cpp
@@ -1520,6 +1520,7 @@ typedef HashtableEntry  KlassHashtableEntry;
   declare_c2_type(CallDynamicJavaNode, CallJavaNode)                      \
   declare_c2_type(CallRuntimeNode, CallNode)                              \
   declare_c2_type(CallLeafNode, CallRuntimeNode)                          \
+  declare_c2_type(CallNativeNode, CallNode)                               \
   declare_c2_type(CallLeafNoFPNode, CallLeafNode)                         \
   declare_c2_type(AllocateNode, CallNode)                                 \
   declare_c2_type(AllocateArrayNode, AllocateNode)                        \
@@ -1636,6 +1637,7 @@ typedef HashtableEntry  KlassHashtableEntry;
   declare_c2_type(MachCallStaticJavaNode, MachCallJavaNode)               \
   declare_c2_type(MachCallDynamicJavaNode, MachCallJavaNode)              \
   declare_c2_type(MachCallRuntimeNode, MachCallNode)                      \
+  declare_c2_type(MachCallNativeNode, MachCallNode)                       \
   declare_c2_type(MachHaltNode, MachReturnNode)                           \
   declare_c2_type(MachTempNode, MachNode)                                 \
   declare_c2_type(MemNode, Node)                                          \
@@ -2533,6 +2535,7 @@ typedef HashtableEntry  KlassHashtableEntry;
   declare_constant(vmIntrinsics::_linkToStatic)                           \
   declare_constant(vmIntrinsics::_linkToSpecial)                          \
   declare_constant(vmIntrinsics::_linkToInterface)                        \
+  declare_constant(vmIntrinsics::_linkToNative)                           \
                                                                           \
   /********************************/                                      \
   /* Calling convention constants */                                      \
diff --git a/src/hotspot/share/utilities/growableArray.hpp b/src/hotspot/share/utilities/growableArray.hpp
index e4a0acf07550e..58893d35d0700 100644
--- a/src/hotspot/share/utilities/growableArray.hpp
+++ b/src/hotspot/share/utilities/growableArray.hpp
@@ -124,6 +124,21 @@ class GrowableArrayView : public GrowableArrayBase {
   ~GrowableArrayView() {}
 
 public:
+  bool operator==(const GrowableArrayView& rhs) const {
+    if (_len != rhs._len)
+      return false;
+    for (int i = 0; i < _len; i++) {
+      if (at(i) != rhs.at(i)) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  bool operator!=(const GrowableArrayView& rhs) const {
+    return !(*this == rhs);
+  }
+
   E& at(int i) {
     assert(0 <= i && i < _len, "illegal index");
     return _data[i];
diff --git a/src/java.base/share/classes/java/lang/System.java b/src/java.base/share/classes/java/lang/System.java
index 7581b07154f67..47ebb20b50a00 100644
--- a/src/java.base/share/classes/java/lang/System.java
+++ b/src/java.base/share/classes/java/lang/System.java
@@ -2051,7 +2051,6 @@ private static void initPhase1() {
      * @return JNI_OK for success, JNI_ERR for failure
      */
     private static int initPhase2(boolean printToStderr, boolean printStackTrace) {
-
         try {
             bootLayer = ModuleBootstrap.boot();
         } catch (Exception | Error e) {
@@ -2068,23 +2067,15 @@ private static int initPhase2(boolean printToStderr, boolean printStackTrace) {
 
     /*
      * Invoked by VM.  Phase 3 is the final system initialization:
-     * 1. eagerly initialize bootstrap method factories that might interact
-     *    negatively with custom security managers and custom class loaders
-     * 2. set security manager
-     * 3. set system class loader
-     * 4. set TCCL
+     * 1. set security manager
+     * 2. set system class loader
+     * 3. set TCCL
      *
      * This method must be called after the module system initialization.
      * The security manager and system class loader may be a custom class from
      * the application classpath or modulepath.
      */
     private static void initPhase3() {
-
-        // Initialize the StringConcatFactory eagerly to avoid potential
-        // bootstrap circularity issues that could be caused by a custom
-        // SecurityManager
-        Unsafe.getUnsafe().ensureClassInitialized(StringConcatFactory.class);
-
         String smProp = System.getProperty("java.security.manager");
         if (smProp != null) {
             switch (smProp) {
diff --git a/src/java.base/share/classes/java/lang/invoke/MethodHandle.java b/src/java.base/share/classes/java/lang/invoke/MethodHandle.java
index 383f3b8cab6ec..e9f8dc918e2ce 100644
--- a/src/java.base/share/classes/java/lang/invoke/MethodHandle.java
+++ b/src/java.base/share/classes/java/lang/invoke/MethodHandle.java
@@ -605,6 +605,10 @@ public MethodType type() {
     /*non-public*/
     static native @PolymorphicSignature Object linkToInterface(Object... args) throws Throwable;
 
+    /** TODO */
+    @IntrinsicCandidate
+    /*non-public*/ static native @PolymorphicSignature Object linkToNative(Object... args) throws Throwable;
+
     /**
      * Performs a variable arity invocation, passing the arguments in the given array
      * to the method handle, as if via an inexact {@link #invoke invoke} from a call site
diff --git a/src/java.base/share/classes/java/lang/invoke/MethodHandleImpl.java b/src/java.base/share/classes/java/lang/invoke/MethodHandleImpl.java
index ea5d80ad1e801..85b748ac0cca2 100644
--- a/src/java.base/share/classes/java/lang/invoke/MethodHandleImpl.java
+++ b/src/java.base/share/classes/java/lang/invoke/MethodHandleImpl.java
@@ -27,6 +27,7 @@
 
 import jdk.internal.access.JavaLangInvokeAccess;
 import jdk.internal.access.SharedSecrets;
+import jdk.internal.invoke.NativeEntryPoint;
 import jdk.internal.org.objectweb.asm.ClassWriter;
 import jdk.internal.org.objectweb.asm.MethodVisitor;
 import jdk.internal.reflect.CallerSensitive;
@@ -1768,6 +1769,11 @@ public Map generateHolderClasses(Stream traces) {
                 return GenerateJLIClassesHelper.generateHolderClasses(traces);
             }
 
+            @Override
+            public MethodHandle nativeMethodHandle(NativeEntryPoint nep, MethodHandle fallback) {
+                return NativeMethodHandle.make(nep, fallback);
+            }
+
             @Override
             public VarHandle memoryAccessVarHandle(Class carrier, boolean skipAlignmentMaskCheck, long alignmentMask,
                                                    ByteOrder order) {
diff --git a/src/java.base/share/classes/java/lang/invoke/MethodTypeForm.java b/src/java.base/share/classes/java/lang/invoke/MethodTypeForm.java
index 4f8b948bacf78..ece336136e4d8 100644
--- a/src/java.base/share/classes/java/lang/invoke/MethodTypeForm.java
+++ b/src/java.base/share/classes/java/lang/invoke/MethodTypeForm.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2008, 2019, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2008, 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -86,7 +86,8 @@ final class MethodTypeForm {
             LF_TF                      = 18,  // tryFinally
             LF_LOOP                    = 19,  // loop
             LF_INVSPECIAL_IFC          = 20,  // DMH invokeSpecial of (private) interface method
-            LF_LIMIT                   = 21;
+            LF_INVNATIVE               = 21,  // NMH invokeNative
+            LF_LIMIT                   = 22;
 
     /** Return the type corresponding uniquely (1-1) to this MT-form.
      *  It might have any primitive returns or arguments, but will have no references except Object.
diff --git a/src/java.base/share/classes/jdk/internal/access/JavaLangAccess.java b/src/java.base/share/classes/jdk/internal/access/JavaLangAccess.java
index edcc5ed5caf8d..630f5e0854374 100644
--- a/src/java.base/share/classes/jdk/internal/access/JavaLangAccess.java
+++ b/src/java.base/share/classes/jdk/internal/access/JavaLangAccess.java
@@ -43,6 +43,7 @@
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.stream.Stream;
 
+import jdk.internal.loader.NativeLibrary;
 import jdk.internal.module.ServicesCatalog;
 import jdk.internal.reflect.ConstantPool;
 import sun.reflect.annotation.AnnotationType;
diff --git a/src/java.base/share/classes/jdk/internal/access/JavaLangInvokeAccess.java b/src/java.base/share/classes/jdk/internal/access/JavaLangInvokeAccess.java
index 20090014264c9..767108cdb8e91 100644
--- a/src/java.base/share/classes/jdk/internal/access/JavaLangInvokeAccess.java
+++ b/src/java.base/share/classes/jdk/internal/access/JavaLangInvokeAccess.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, 2018, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2015, 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -25,6 +25,8 @@
 
 package jdk.internal.access;
 
+import jdk.internal.invoke.NativeEntryPoint;
+
 import java.lang.invoke.MethodHandle;
 import java.lang.invoke.MethodType;
 import java.lang.invoke.VarHandle;
@@ -119,4 +121,15 @@ VarHandle memoryAccessVarHandle(Class carrier, boolean skipAlignmentMaskCheck
      * Used by {@code jdk.incubator.foreign.MemoryHandles}.
      */
     VarHandle insertCoordinates(VarHandle target, int pos, Object... values);
+
+    /**
+     * Returns a native method handle with given arguments as fallback and steering info.
+     *
+     * Will allow JIT to intrinsify.
+     *
+     * @param nep the native entry point
+     * @param fallback the fallback handle
+     * @return the native method handle
+     */
+    MethodHandle nativeMethodHandle(NativeEntryPoint nep, MethodHandle fallback);
 }
diff --git a/src/java.base/share/classes/jdk/internal/loader/NativeLibraries.java b/src/java.base/share/classes/jdk/internal/loader/NativeLibraries.java
index b27c37dd05229..425d1ec1ea7c9 100644
--- a/src/java.base/share/classes/jdk/internal/loader/NativeLibraries.java
+++ b/src/java.base/share/classes/jdk/internal/loader/NativeLibraries.java
@@ -384,6 +384,20 @@ boolean open() {
         }
     }
 
+    public static NativeLibrary defaultLibrary = new NativeLibraryImpl(Object.class, "", true, true) {
+
+        @Override
+        boolean open() {
+            throw new UnsupportedOperationException("Cannot load default library");
+        }
+
+        @Override
+        public long find(String name) {
+            return NativeLibraries.findEntryInProcess(name);
+        }
+
+    };
+
     /*
      * The run() method will be invoked when this class loader becomes
      * phantom reachable to unload the native library.
@@ -464,4 +478,5 @@ private static Class getFromClass() {
     private static native void unload(String name, boolean isBuiltin, boolean isJNI, long handle);
     private static native String findBuiltinLib(String name);
     private static native long findEntry0(NativeLibraryImpl lib, String name);
+    private static native long findEntryInProcess(String name);
 }
diff --git a/src/java.base/share/classes/module-info.java b/src/java.base/share/classes/module-info.java
index d5cd74eb79025..0b0dac36ca4c2 100644
--- a/src/java.base/share/classes/module-info.java
+++ b/src/java.base/share/classes/module-info.java
@@ -163,7 +163,8 @@
     exports jdk.internal.loader to
         java.instrument,
         java.logging,
-        java.naming;
+        java.naming,
+        jdk.incubator.foreign;
     exports jdk.internal.jmod to
         jdk.compiler,
         jdk.jlink;
@@ -343,6 +344,8 @@
         java.prefs;
     exports sun.util.resources to
         jdk.localedata;
+    exports jdk.internal.invoke to
+        jdk.incubator.foreign;
 
 
     // the service types defined by the APIs in this module
diff --git a/src/java.base/share/native/libjava/NativeLibraries.c b/src/java.base/share/native/libjava/NativeLibraries.c
index 1d973c93a2442..291917d1edb2d 100644
--- a/src/java.base/share/native/libjava/NativeLibraries.c
+++ b/src/java.base/share/native/libjava/NativeLibraries.c
@@ -246,6 +246,29 @@ Java_jdk_internal_loader_NativeLibraries_findEntry0
     return res;
 }
 
+/*
+ * Class:     jdk_internal_loader_NativeLibraries
+ * Method:    findEntryInProcess
+ * Signature: (Ljava/lang/String;)J
+ */
+JNIEXPORT jlong JNICALL
+Java_jdk_internal_loader_NativeLibraries_findEntryInProcess
+  (JNIEnv *env, jclass cls, jstring name)
+{
+    const char *cname;
+    jlong res;
+
+    if (!initIDs(env))
+        return jlong_zero;
+
+    cname = (*env)->GetStringUTFChars(env, name, 0);
+    if (cname == 0)
+        return jlong_zero;
+    res = ptr_to_jlong(findEntryInProcess(cname));
+    (*env)->ReleaseStringUTFChars(env, name, cname);
+    return res;
+}
+
 /*
  * Class:     jdk_internal_loader_NativeLibraries
  * Method:    findBuiltinLib
diff --git a/src/java.base/share/native/libjava/jni_util.h b/src/java.base/share/native/libjava/jni_util.h
index c443fee5fa1aa..652a1864e7777 100644
--- a/src/java.base/share/native/libjava/jni_util.h
+++ b/src/java.base/share/native/libjava/jni_util.h
@@ -333,6 +333,8 @@ JNIEXPORT void InitializeEncoding(JNIEnv *env, const char *name);
 
 void* getProcessHandle();
 
+void* findEntryInProcess(const char* name);
+
 void buildJniFunctionName(const char *sym, const char *cname,
                           char *jniEntryName);
 
diff --git a/src/java.base/unix/native/libjava/jni_util_md.c b/src/java.base/unix/native/libjava/jni_util_md.c
index 87b43f2cebcee..7415e03f169d1 100644
--- a/src/java.base/unix/native/libjava/jni_util_md.c
+++ b/src/java.base/unix/native/libjava/jni_util_md.c
@@ -26,6 +26,7 @@
 #include 
 #include 
 
+#include "jvm.h"
 #include "jni.h"
 #include "jni_util.h"
 #include "dlfcn.h"
@@ -50,6 +51,10 @@ void* getProcessHandle() {
     return procHandle;
 }
 
+void* findEntryInProcess(const char* name) {
+    return JVM_FindLibraryEntry(RTLD_DEFAULT, name);
+}
+
 void buildJniFunctionName(const char *sym, const char *cname,
                           char *jniEntryName) {
     strcpy(jniEntryName, sym);
diff --git a/src/java.base/windows/native/libjava/jni_util_md.c b/src/java.base/windows/native/libjava/jni_util_md.c
index 9ed2d384aedf3..92619d9fdc67f 100644
--- a/src/java.base/windows/native/libjava/jni_util_md.c
+++ b/src/java.base/windows/native/libjava/jni_util_md.c
@@ -26,6 +26,7 @@
 #include 
 #include 
 #include 
+#include 
 #include 
 
 #include "jni.h"
@@ -35,6 +36,31 @@ void* getProcessHandle() {
     return (void*)GetModuleHandle(NULL);
 }
 
+/*
+ * Windows doesn't have an RTLD_DEFAULT equivalent, so in stead we have to
+ * iterate over all the modules loaded by the process to implement the
+ * default library behaviour.
+ */
+void* findEntryInProcess(const char* name) {
+    HANDLE hProcess = GetCurrentProcess();
+
+    HMODULE hMods[1024];
+    DWORD cbNeeded; // array size in bytes
+
+    // first come, first served
+    if(EnumProcessModules(hProcess, hMods, sizeof(hMods), &cbNeeded)) {
+        for (int i = 0; i < (cbNeeded / sizeof(HMODULE)); i++) {
+            HMODULE mod = hMods[i];
+            FARPROC proc = GetProcAddress(mod, name);
+            if(proc != NULL) {
+                return proc;
+            }
+        }
+    }
+
+    return NULL;
+}
+
 /*
  * Windows symbols can be simple like JNI_OnLoad or __stdcall format
  * like _JNI_OnLoad@8. We need to handle both.
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/AbstractLayout.java b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/AbstractLayout.java
index b5b0c97ec2987..ca8e1f18209c7 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/AbstractLayout.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/AbstractLayout.java
@@ -43,6 +43,7 @@
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
+import static java.lang.constant.ConstantDescs.BSM_GET_STATIC_FINAL;
 import static java.lang.constant.ConstantDescs.BSM_INVOKE;
 import static java.lang.constant.ConstantDescs.CD_String;
 import static java.lang.constant.ConstantDescs.CD_long;
@@ -192,10 +193,6 @@ public boolean equals(Object other) {
 
     /*** Helper constants for implementing Layout::describeConstable ***/
 
-    static final DirectMethodHandleDesc BSM_GET_STATIC_FINAL
-            = ConstantDescs.ofConstantBootstrap(ConstantDescs.CD_ConstantBootstraps, "getStaticFinal",
-            ConstantDescs.CD_Object, ConstantDescs.CD_Class);
-
     static final ClassDesc CD_MEMORY_LAYOUT = MemoryLayout.class.describeConstable().get();
 
     static final ClassDesc CD_VALUE_LAYOUT = ValueLayout.class.describeConstable().get();
@@ -206,6 +203,8 @@ public boolean equals(Object other) {
 
     static final ClassDesc CD_BYTEORDER = ByteOrder.class.describeConstable().get();
 
+    static final ClassDesc CD_FUNCTION_DESC = FunctionDescriptor.class.describeConstable().get();
+
     static final ClassDesc CD_Constable = Constable.class.describeConstable().get();
 
     static final ConstantDesc BIG_ENDIAN = DynamicConstantDesc.ofNamed(BSM_GET_STATIC_FINAL, "BIG_ENDIAN", CD_BYTEORDER, CD_BYTEORDER);
@@ -230,6 +229,12 @@ public boolean equals(Object other) {
     static final MethodHandleDesc MH_UNION = MethodHandleDesc.ofMethod(DirectMethodHandleDesc.Kind.INTERFACE_STATIC, CD_MEMORY_LAYOUT, "ofUnion",
                 MethodTypeDesc.of(CD_GROUP_LAYOUT, CD_MEMORY_LAYOUT.arrayType()));
 
+    static final MethodHandleDesc MH_VOID_FUNCTION = MethodHandleDesc.ofMethod(DirectMethodHandleDesc.Kind.STATIC, CD_FUNCTION_DESC, "ofVoid",
+                MethodTypeDesc.of(CD_FUNCTION_DESC, CD_MEMORY_LAYOUT.arrayType()));
+
+    static final MethodHandleDesc MH_FUNCTION = MethodHandleDesc.ofMethod(DirectMethodHandleDesc.Kind.STATIC, CD_FUNCTION_DESC, "of",
+                MethodTypeDesc.of(CD_FUNCTION_DESC, CD_MEMORY_LAYOUT, CD_MEMORY_LAYOUT.arrayType()));
+
     static final MethodHandleDesc MH_WITH_BIT_ALIGNMENT = MethodHandleDesc.ofMethod(DirectMethodHandleDesc.Kind.INTERFACE_VIRTUAL, CD_MEMORY_LAYOUT, "withBitAlignment",
                 MethodTypeDesc.of(CD_MEMORY_LAYOUT, CD_long));
 
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/Addressable.java b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/Addressable.java
index 15a62f5e02ee9..0f212e3674d5d 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/Addressable.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/Addressable.java
@@ -28,11 +28,12 @@
 /**
  * Represents a type which is addressable. An addressable type is one which can be projected down to
  * a memory address instance (see {@link #address()}). Examples of addressable types are {@link MemorySegment},
- * and {@link MemoryAddress}.
+ * {@link MemoryAddress}, {@link LibraryLookup.Symbol} and {@link CLinker.VaList}.
  *
  * @apiNote In the future, if the Java language permits, {@link Addressable}
  * may become a {@code sealed} interface, which would prohibit subclassing except by
- * explicitly permitted types, such as {@link MemorySegment} and {@link MemoryAddress}.
+ * explicitly permitted types, such as {@link MemorySegment}, {@link MemoryAddress}, {@link LibraryLookup.Symbol}
+ * and {@link CLinker.VaList}.
  *
  * @implSpec
  * Implementations of this interface value-based.
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/GroupLayout.java b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/GroupLayout.java
index fc1fbe6c2125f..a158a649d6802 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/GroupLayout.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/GroupLayout.java
@@ -31,6 +31,7 @@
 import java.lang.constant.DynamicConstantDesc;
 import java.lang.constant.MethodHandleDesc;
 import java.util.Collections;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MemorySegment.java b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MemorySegment.java
index a79ac33304653..2d089809cb408 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MemorySegment.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MemorySegment.java
@@ -425,6 +425,34 @@ default MemorySegment asSlice(MemoryAddress newBase) {
      */
     MemorySegment handoff(Thread thread);
 
+    /**
+     * Obtains a new confined memory segment backed by the same underlying memory region as this segment, but whose
+     * temporal bounds are controlled by the provided {@link NativeScope} instance.
+     * 

+     * This is a terminal operation;
+     * as a side-effect, this segment will be marked as not alive, and subsequent operations on this segment
+     * will fail with {@link IllegalStateException}.
+     * 

+     * The returned segment will feature only {@link MemorySegment#READ} and {@link MemorySegment#WRITE} access modes
+     * (assuming these were available in the original segment). As such the returned segment cannot be closed directly
+     * using {@link MemorySegment#close()} - but it will be closed indirectly when this native scope is closed. The
+     * returned segment will also be confined by the same thread as the provided native scope (see {@link NativeScope#ownerThread()}).
+     * 

+     * In case where the owner thread of the returned segment differs from that of this segment, write accesses to this
+     * segment's content happens-before
+     * hand-over from the current owner thread to the new owner thread, which in turn happens before read accesses
+     * to the returned segment's contents on the new owner thread.
+     *
+     * @param nativeScope the native scope.
+     * @return a new confined memory segment backed by the same underlying memory region as this segment, but whose life-cycle
+     * is tied to that of {@code nativeScope}.
+     * @throws IllegalStateException if this segment is not alive, or if access occurs from a thread other than the
+     * thread owning this segment.
+     * @throws UnsupportedOperationException if this segment does not support the {@link #HANDOFF} access mode.
+     * @throws NullPointerException if {@code nativeScope == null}.
+     */
+    MemorySegment handoff(NativeScope nativeScope);
+
     /**
      * Obtains a new shared memory segment backed by the same underlying memory region as this segment. The returned segment will
      * not be confined on any thread and can therefore be accessed concurrently from multiple threads; moreover, the
@@ -921,7 +949,7 @@ static MemorySegment ofNativeRestricted() {
 
     /**
      * Handoff access mode; this segment support serial thread-confinement via thread ownership changes
-     * (see {@link #handoff(Thread)}).
+     * (see {@link #handoff(NativeScope)} and {@link #handoff(Thread)}).
      * @see MemorySegment#accessModes()
      * @see MemorySegment#withAccessModes(int)
      */
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/package-info.java b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/package-info.java
index 5d4000e0aa230..322da7fcc0a7a 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/package-info.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/package-info.java
@@ -25,9 +25,12 @@
  */
 
 /**
- * 
 Classes to support low-level, safe and efficient memory access.
+ * 
 Classes to support low-level and efficient foreign memory/function access, directly from Java.
+ *
+ * 
Foreign memory access

+ *
  * 

- * The key abstractions introduced by this package are {@link jdk.incubator.foreign.MemorySegment} and {@link jdk.incubator.foreign.MemoryAddress}.
+ * The key abstractions introduced to support foreign memory access are {@link jdk.incubator.foreign.MemorySegment} and {@link jdk.incubator.foreign.MemoryAddress}.
  * The first models a contiguous memory region, which can reside either inside or outside the Java heap; the latter models an address - which also can
  * reside either inside or outside the Java heap (and can sometimes be expressed as an offset into a given segment).
  * A memory segment represents the main access coordinate of a memory access var handle, which can be obtained
@@ -60,7 +63,7 @@
  * {@code s[i]}, where {@code 0 <= i < 10}, where the size of each slot is exactly 4 bytes, the initialization logic above will set each slot
  * so that {@code s[i] = i}, again where {@code 0 <= i < 10}.
  *
- * 
Deterministic deallocation

+ * 
Deterministic deallocation

  *
  * When writing code that manipulates memory segments, especially if backed by memory which resides outside the Java heap, it is
  * crucial that the resources associated with a memory segment are released when the segment is no longer in use, by calling the {@link jdk.incubator.foreign.MemorySegment#close()}
@@ -74,7 +77,7 @@
  * models such as this can be very convenient - clients do not have to remember to close a direct buffer - such models can also make it
  * hard for clients to ensure that the memory associated with a direct buffer has indeed been released.
  *
- * 
Safety

+ * 
Safety

  *
  * This API provides strong safety guarantees when it comes to memory access. First, when dereferencing a memory segment,
  * the access coordinates are validated (upon access), to make sure that access does not occur at an address which resides
@@ -91,5 +94,142 @@
  * 

  * Together, spatial and temporal safety ensure that each memory access operation either succeeds - and accesses a valid
  * memory location - or fails.
+ *
+ * 
Foreign function access

+ * The key abstractions introduced to support foreign function access are {@link jdk.incubator.foreign.LibraryLookup} and {@link jdk.incubator.foreign.CLinker}.
+ * The former is used to load foreign libraries, as well as to lookup symbols inside said libraries; the latter
+ * provides linking capabilities which allow to model foreign functions as {@link java.lang.invoke.MethodHandle} instances,
+ * so that clients can perform foreign function calls directly in Java, without the need for intermediate layers of native
+ * code (as it's the case with the Java Native Interface (JNI)).
+ * 

+ * For example, to compute the length of a string using the C standard library function {@code strlen} on a Linux x64 platform,
+ * we can use the following code:
+ *
+ * 
{@code
+MethodHandle strlen = CLinker.getInstance().downcallHandle(
+        LibraryLookup.ofDefault().lookup("strlen").get(),
+        MethodType.methodType(long.class, MemoryAddress.class),
+        FunctionDescriptor.of(CLinker.C_LONG, CLinker.C_POINTER)
+);
+
+try (var cString = CLinker.toCString("Hello")) {
+    long len = strlen.invokeExact(cString.address()) // 5
+}
+ * }

+ *
+ * Here, we lookup the {@code strlen} symbol in the default library lookup (see {@link jdk.incubator.foreign.LibraryLookup#ofDefault()}).
+ * Then, we obtain a linker instance (see {@link jdk.incubator.foreign.CLinker#getInstance()}) and we use it to
+ * obtain a method handle which targets the {@code strlen} library symbol. To complete the linking successfully,
+ * we must provide (i) a {@link java.lang.invoke.MethodType} instance, describing the type of the resulting method handle
+ * and (ii) a {@link jdk.incubator.foreign.FunctionDescriptor} instance, describing the signature of the {@code strlen}
+ * function. From this information, the linker will uniquely determine the sequence of steps which will turn
+ * the method handle invocation (here performed using {@link java.lang.invoke.MethodHandle#invokeExact(java.lang.Object...)})
+ * into a foreign function call, according to the rules specified by the platform C ABI. The {@link jdk.incubator.foreign.CLinker}
+ * class also provides many useful methods for interacting with native code, such as converting Java strings into
+ * native strings and viceversa (see {@link jdk.incubator.foreign.CLinker#toCString(java.lang.String)} and
+ * {@link jdk.incubator.foreign.CLinker#toJavaString(jdk.incubator.foreign.MemorySegment)}, respectively), as
+ * demonstrated in the above example.
+ *
+ * 
Foreign addresses

+ *
+ * When a memory segment is created from Java code, the segment properties (spatial bounds, temporal bounds and confinement)
+ * are fully known at segment creation. But when interacting with native libraries, clients will often receive raw pointers;
+ * such pointers have no spatial bounds (example: does the C type {@code char*} refer to a single {@code char} value,
+ * or an array of {@code char} values, of given size?), no notion of temporal bounds, nor thread-confinement.
+ * 

+ * When clients receive a {@link jdk.incubator.foreign.MemoryAddress} instance from a foreign function call, it might be
+ * necessary to obtain a {@link jdk.incubator.foreign.MemorySegment} instance to dereference the memory pointed to by that address.
+ * To do that, clients can proceed in three different ways, described below.
+ * 

+ * First, if the memory address is known to belong to a segment the client already owns, a rebase operation can be performed;
+ * in other words, the client can ask the address what its offset relative to a given segment is, and, then, proceed to dereference
+ * the original segment accordingly, as follows:
+ *
+ * 
{@code
+MemorySegment segment = MemorySegment.allocateNative(100);
+...
+MemoryAddress addr = ... //obtain address from native code
+int x = MemoryAccess.getIntAtOffset(segment, addr.segmentOffset(segment));
+ * }

+ *
+ * Secondly, if the client does not have a segment which contains a given memory address, it can create one unsafely,
+ * using the {@link jdk.incubator.foreign.MemoryAddress#asSegmentRestricted(long)} factory. This allows the client to
+ * inject extra knowledge about spatial bounds which might, for instance, be available in the documentation of the foreign function
+ * which produced the native address. Here is how an unsafe segment can be created from a native address:
+ *
+ * 
{@code
+MemoryAddress addr = ... //obtain address from native code
+MemorySegment segment = addr.asSegmentRestricted(4); // segment is 4 bytes long
+int x = MemoryAccess.getInt(segment);
+ * }

+ *
+ * Alternatively, the client can fall back to use the so called everything segment - that is, a primordial segment
+ * which covers the entire native heap. This segment can be obtained by calling the {@link jdk.incubator.foreign.MemorySegment#ofNativeRestricted()}
+ * method, so that dereference can happen without the need of creating any additional segment instances:
+ *
+ * 
{@code
+MemoryAddress addr = ... //obtain address from native code
+int x = MemoryAccess.getIntAtOffset(MemorySegment.ofNativeRestricted(), addr.toRawLongValue());
+ * }

+ *
+ * 
Upcalls

+ * The {@link jdk.incubator.foreign.CLinker} interface also allows to turn an existing method handle (which might point
+ * to a Java method) into a native memory segment (see {@link jdk.incubator.foreign.MemorySegment}), so that Java code
+ * can effectively be passed to other foreign functions. For instance, we can write a method that compares two
+ * integer values, as follows:
+ *
+ * 
{@code
+class IntComparator {
+    static int intCompare(MemoryAddress addr1, MemoryAddress addr2) {
+        return MemoryAccess.getIntAtOffset(MemorySegment.ofNativeRestricted(), addr1.toRawLongValue()) -
+               MemoryAccess.getIntAtOffset(MemorySegment.ofNativeRestricted(), addr2.toRawLongValue());
+    }
+}
+ * }

+ *
+ * The above method dereferences two memory addresses containing an integer value, and performs a simple comparison
+ * by returning the difference between such values. We can then obtain a method handle which targets the above static
+ * method, as follows:
+ *
+ * 
{@code
+MethodHandle intCompareHandle = MethodHandles.lookup().findStatic(IntComparator.class,
+                                                   "intCompare",
+                                                   MethodType.methodType(int.class, MemoryAddress.class, MemoryAddress.class));
+ * }

+ *
+ * Now that we have a method handle instance, we can link it into a fresh native memory segment, using the {@link jdk.incubator.foreign.CLinker} interface, as follows:
+ *
+ * 
{@code
+MemorySegment comparFunc = CLinker.getInstance().upcallStub(
+     intCompareHandle,
+     FunctionDescriptor.of(C_INT, C_POINTER, C_POINTER)
+);
+ * }

+ *
+ * As before, we need to provide a {@link jdk.incubator.foreign.FunctionDescriptor} instance describing the signature
+ * of the function pointer we want to create; as before, this, coupled with the method handle type, uniquely determines the
+ * sequence of steps which will allow foreign code to call {@code intCompareHandle} according to the rules specified
+ * by the platform C ABI.
+ *
+ * 
Restricted methods

+ * Some methods in this package are considered restricted. Restricted methods are typically used to bind native
+ * foreign data and/or functions to first-class Java API elements which can then be used directly by client. For instance
+ * the restricted method {@link jdk.incubator.foreign.MemoryAddress#asSegmentRestricted(long)} can be used to create
+ * a fresh segment with given spatial bounds out of a native address.
+ * 

+ * Binding foreign data and/or functions is generally unsafe and, if done incorrectly, can result in VM crashes, or memory corruption when the bound Java API element is accessed.
+ * For instance, in the case of {@link jdk.incubator.foreign.MemoryAddress#asSegmentRestricted(long)}, if the provided
+ * spatial bounds are incorrect, a client of the segment returned by that method might crash the VM, or corrupt
+ * memory when attempting to dereference said segment. For these reasons, it is crucial for code that calls a restricted method
+ * to never pass arguments that might cause incorrect binding of foreign data and/or functions to a Java API.
+ * 

+ * Access to restricted methods is disabled by default; to enable restricted methods, the JDK property
+ * {@code foreign.restricted} must be set to a value other than {@code deny}. The possible values for this property are:
+ * 
    
+ * 
  • {@code deny}: issues a runtime exception on each restricted call. This is the default value;
    • 
+ * 
  • {@code permit}: allows restricted calls;
    • 
+ * 
  • {@code warn}: like permit, but also prints a one-line warning on each restricted call;
    • 
+ * 
  • {@code debug}: like permit, but also dumps the stack corresponding to any given restricted call.
    • 
+ * 

  */
 package jdk.incubator.foreign;
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/AbstractMemorySegmentImpl.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/AbstractMemorySegmentImpl.java
index 53278d6fbb5a5..c0ed80a06fb71 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/AbstractMemorySegmentImpl.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/AbstractMemorySegmentImpl.java
@@ -134,6 +134,16 @@ public void copyFrom(MemorySegment src) {
                 base(), min(), size);
     }
 
+    public void copyFromSwap(MemorySegment src, long elemSize) {
+        AbstractMemorySegmentImpl that = (AbstractMemorySegmentImpl)src;
+        long size = that.byteSize();
+        checkAccess(0, size, false);
+        that.checkAccess(0, size, true);
+        SCOPED_MEMORY_ACCESS.copySwapMemory(scope, that.scope,
+                        that.base(), that.min(),
+                        base(), min(), size, elemSize);
+    }
+
     @Override
     public long mismatch(MemorySegment other) {
         AbstractMemorySegmentImpl that = (AbstractMemorySegmentImpl)other;
@@ -293,6 +303,22 @@ public MemorySegment share() {
         }
     }
 
+   @Override
+    public MemorySegment handoff(NativeScope scope) {
+        Objects.requireNonNull(scope);
+        checkValidState();
+        if (!isSet(HANDOFF)) {
+            throw unsupportedAccessMode(HANDOFF);
+        }
+        if (!isSet(CLOSE)) {
+            throw unsupportedAccessMode(CLOSE);
+        }
+        MemorySegment dup = handoff(scope.ownerThread());
+        ((AbstractNativeScope)scope).register(dup);
+        return dup.withAccessModes(accessModes() & (READ | WRITE));
+    }
+
+
     @Override
     public MemorySegment registerCleaner(Cleaner cleaner) {
         Objects.requireNonNull(cleaner);
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/LayoutPath.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/LayoutPath.java
index a0b6b5ebce574..393a05e6ff225 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/LayoutPath.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/LayoutPath.java
@@ -148,15 +148,7 @@ public long offset() {
     }
 
     public VarHandle dereferenceHandle(Class carrier) {
-        if (!(layout instanceof ValueLayout)) {
-            throw badLayoutPath("layout path does not select a value layout");
-        }
-
-        if (!carrier.isPrimitive() || carrier == void.class || carrier == boolean.class // illegal carrier?
-                || Wrapper.forPrimitiveType(carrier).bitWidth() != layout.bitSize()) { // carrier has the right size?
-            throw new IllegalArgumentException("Invalid carrier: " + carrier + ", for layout " + layout);
-        }
-
+        Utils.checkPrimitiveCarrierCompat(carrier, layout);
         checkAlignment(this);
 
         List> expectedCoordinates = new ArrayList<>();
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/MemoryAddressImpl.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/MemoryAddressImpl.java
index dc76c0e87fa3c..f7d39bd79448c 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/MemoryAddressImpl.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/MemoryAddressImpl.java
@@ -100,4 +100,12 @@ public MemorySegment asSegmentRestricted(long bytesSize, Runnable cleanupAction,
         }
         return NativeMemorySegmentImpl.makeNativeSegmentUnchecked(this, bytesSize, cleanupAction, attachment);
     }
+
+    public static MemorySegment ofLongUnchecked(long value) {
+        return ofLongUnchecked(value, Long.MAX_VALUE);
+    }
+
+    public static MemorySegment ofLongUnchecked(long value, long byteSize) {
+        return MemoryAddress.ofLong(value).asSegmentRestricted(byteSize).share();
+    }
 }
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/Utils.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/Utils.java
index dd4d7b8bbfc91..577799215b7d1 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/Utils.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/Utils.java
@@ -26,10 +26,10 @@
 
 package jdk.internal.foreign;
 
-import jdk.incubator.foreign.MemoryHandles;
-import jdk.incubator.foreign.MemorySegment;
+import jdk.incubator.foreign.*;
 import jdk.internal.access.foreign.MemorySegmentProxy;
 import jdk.internal.misc.VM;
+import sun.invoke.util.Wrapper;
 
 import java.lang.invoke.MethodHandle;
 import java.lang.invoke.MethodHandles;
@@ -61,6 +61,16 @@ public static long alignUp(long n, long alignment) {
         return (n + alignment - 1) & -alignment;
     }
 
+    public static MemoryAddress alignUp(MemoryAddress ma, long alignment) {
+        long offset = ma.toRawLongValue();
+        return ma.addOffset(alignUp(offset, alignment) - offset);
+    }
+
+    public static MemorySegment alignUp(MemorySegment ms, long alignment) {
+        long offset = ms.address().toRawLongValue();
+        return ms.asSlice(alignUp(offset, alignment) - offset);
+    }
+
     public static long bitsToBytesOrThrow(long bits, Supplier exFactory) {
         if (bits % 8 == 0) {
             return bits / 8;
@@ -99,4 +109,28 @@ private static void throwIllegalAccessError(String value, String method) {
         throw new IllegalAccessError("Illegal access to restricted foreign method: " + method +
                 " ; system property 'foreign.restricted' is set to '" + value + "'");
     }
+
+    public static void checkPrimitiveCarrierCompat(Class carrier, MemoryLayout layout) {
+        checkLayoutType(layout, ValueLayout.class);
+        if (!isValidPrimitiveCarrier(carrier))
+            throw new IllegalArgumentException("Unsupported carrier: " + carrier);
+        if (Wrapper.forPrimitiveType(carrier).bitWidth() != layout.bitSize())
+            throw new IllegalArgumentException("Carrier size mismatch: " + carrier + " != " + layout);
+    }
+
+    public static boolean isValidPrimitiveCarrier(Class carrier) {
+        return carrier == byte.class
+            || carrier == short.class
+            || carrier == char.class
+            || carrier == int.class
+            || carrier == long.class
+            || carrier == float.class
+            || carrier == double.class;
+    }
+
+    public static void checkLayoutType(MemoryLayout layout, Class layoutType) {
+        if (!layoutType.isInstance(layout))
+            throw new IllegalArgumentException("Expected a " + layoutType.getSimpleName() + ": " + layout);
+    }
+
 }
diff --git a/test/jdk/java/foreign/TestAdaptVarHandles.java b/test/jdk/java/foreign/TestAdaptVarHandles.java
index 709aef3fc8836..ab2e86a49f3c5 100644
--- a/test/jdk/java/foreign/TestAdaptVarHandles.java
+++ b/test/jdk/java/foreign/TestAdaptVarHandles.java
@@ -24,7 +24,6 @@
 
 /*
  * @test
- * @modules jdk.incubator.foreign
  * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=true -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=false -Xverify:all TestAdaptVarHandles
  * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=true -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=true -Xverify:all TestAdaptVarHandles
  * @run testng/othervm -Djava.lang.invoke.VarHandle.VAR_HANDLE_GUARDS=false -Djava.lang.invoke.VarHandle.VAR_HANDLE_IDENTITY_ADAPT=false -Xverify:all TestAdaptVarHandles
diff --git a/test/jdk/java/foreign/TestLayoutConstants.java b/test/jdk/java/foreign/TestLayoutConstants.java
index e5b270c9708a4..2bd1e06727787 100644
--- a/test/jdk/java/foreign/TestLayoutConstants.java
+++ b/test/jdk/java/foreign/TestLayoutConstants.java
@@ -26,6 +26,7 @@
  * @run testng TestLayoutConstants
  */
 
+import jdk.incubator.foreign.FunctionDescriptor;
 import jdk.incubator.foreign.MemoryLayouts;
 import jdk.incubator.foreign.MemoryLayout;
 
@@ -47,6 +48,20 @@ public void testDescribeResolve(MemoryLayout expected) {
         }
     }
 
+    @Test(dataProvider = "functions")
+    public void testDescribeResolveFunction(MemoryLayout layout, boolean isVoid) {
+        FunctionDescriptor expected = isVoid ?
+                FunctionDescriptor.ofVoid(layout) :
+                FunctionDescriptor.of(layout, layout);
+        try {
+            FunctionDescriptor actual = expected.describeConstable().get()
+                    .resolveConstantDesc(MethodHandles.lookup());
+            assertEquals(actual, expected);
+        } catch (ReflectiveOperationException ex) {
+            throw new AssertionError(ex);
+        }
+    }
+
     @DataProvider(name = "layouts")
     public Object[][] createLayouts() {
         return new Object[][] {
@@ -96,4 +111,21 @@ public Object[][] createLayouts() {
                 { MemoryLayouts.BITS_32_LE.withAttribute("xyz", "abc") },
         };
     }
+
+    @DataProvider(name = "functions")
+    public Object[][] createFunctions() {
+        Object[][] layouts = createLayouts();
+        Object[][] functions = new Object[layouts.length * 2][];
+        boolean[] values = new boolean[] { true, false };
+        for (int i = 0 ; i < layouts.length ; i++) {
+            for (boolean isVoid : values) {
+                int offset = 0;
+                if (isVoid) {
+                    offset += 1;
+                }
+                functions[i * 2 + offset] = new Object[] { layouts[i][0], isVoid };
+            }
+        }
+        return functions;
+    }
 }
diff --git a/test/jdk/java/foreign/TestNative.java b/test/jdk/java/foreign/TestNative.java
index c922f4bf70391..01a7c0d597a00 100644
--- a/test/jdk/java/foreign/TestNative.java
+++ b/test/jdk/java/foreign/TestNative.java
@@ -28,6 +28,7 @@
  * @run testng/othervm -Dforeign.restricted=permit TestNative
  */
 
+import jdk.incubator.foreign.CLinker;
 import jdk.incubator.foreign.MemoryAccess;
 import jdk.incubator.foreign.MemoryAddress;
 import jdk.incubator.foreign.MemoryLayout;
@@ -141,8 +142,13 @@ static  void checkBytes(MemorySegment base, SequenceLayout lay
 
     public static native long getCapacity(Buffer buffer);
 
-    public static native long allocate(int size);
-    public static native void free(long address);
+    public static MemoryAddress allocate(int size) {
+        return CLinker.allocateMemoryRestricted(size);
+    }
+
+    public static void free(MemoryAddress addr) {
+        CLinker.freeMemoryRestricted(addr);
+    }
 
     @Test(dataProvider="nativeAccessOps")
     public void testNativeAccess(Consumer checker, Consumer initializer, SequenceLayout seq) {
@@ -166,8 +172,8 @@ public void testNativeCapacity(Function bufferFunction, int
 
     @Test
     public void testDefaultAccessModes() {
-        MemoryAddress addr = MemoryAddress.ofLong(allocate(12));
-        MemorySegment mallocSegment = addr.asSegmentRestricted(12, () -> free(addr.toRawLongValue()), null);
+        MemoryAddress addr = allocate(12);
+        MemorySegment mallocSegment = addr.asSegmentRestricted(12, () -> free(addr), null);
         try (MemorySegment segment = mallocSegment) {
             assertTrue(segment.hasAccessModes(ALL_ACCESS));
             assertEquals(segment.accessModes(), ALL_ACCESS);
@@ -183,8 +189,8 @@ public void testDefaultAccessModesEverthing() {
 
     @Test
     public void testMallocSegment() {
-        MemoryAddress addr = MemoryAddress.ofLong(allocate(12));
-        MemorySegment mallocSegment = addr.asSegmentRestricted(12, () -> free(addr.toRawLongValue()), null);
+        MemoryAddress addr = allocate(12);
+        MemorySegment mallocSegment = addr.asSegmentRestricted(12, () -> free(addr), null);
         assertEquals(mallocSegment.byteSize(), 12);
         mallocSegment.close(); //free here
         assertTrue(!mallocSegment.isAlive());
@@ -192,11 +198,11 @@ public void testMallocSegment() {
 
     @Test
     public void testEverythingSegment() {
-        MemoryAddress addr = MemoryAddress.ofLong(allocate(4));
+        MemoryAddress addr = allocate(4);
         MemorySegment everything = MemorySegment.ofNativeRestricted();
         MemoryAccess.setIntAtOffset(everything, addr.toRawLongValue(), 42);
         assertEquals(MemoryAccess.getIntAtOffset(everything, addr.toRawLongValue()), 42);
-        free(addr.toRawLongValue());
+        free(addr);
     }
 
     @Test(expectedExceptions = IllegalArgumentException.class)
diff --git a/test/jdk/java/foreign/TestNoForeignUnsafeOverride.java b/test/jdk/java/foreign/TestNoForeignUnsafeOverride.java
index 072506e42bf78..c39796ea21243 100644
--- a/test/jdk/java/foreign/TestNoForeignUnsafeOverride.java
+++ b/test/jdk/java/foreign/TestNoForeignUnsafeOverride.java
@@ -23,8 +23,6 @@
 
 /*
  * @test
- * @modules java.base/jdk.internal.misc
- *          jdk.incubator.foreign/jdk.internal.foreign
  * @run testng TestNoForeignUnsafeOverride
  */
 
diff --git a/test/jdk/java/foreign/TestRebase.java b/test/jdk/java/foreign/TestRebase.java
index c30bc3ec0689d..12ccaec7f5abb 100644
--- a/test/jdk/java/foreign/TestRebase.java
+++ b/test/jdk/java/foreign/TestRebase.java
@@ -39,9 +39,7 @@
 import java.util.List;
 import java.util.function.IntFunction;
 
-import static org.testng.Assert.assertEquals;
-import static org.testng.Assert.assertTrue;
-import static org.testng.Assert.fail;
+import static org.testng.Assert.*;
 
 public class TestRebase {
 
diff --git a/test/jdk/java/foreign/TestTypeAccess.java b/test/jdk/java/foreign/TestTypeAccess.java
index b555f0987acbc..8ac8e92026a22 100644
--- a/test/jdk/java/foreign/TestTypeAccess.java
+++ b/test/jdk/java/foreign/TestTypeAccess.java
@@ -27,17 +27,22 @@
  * @run testng TestTypeAccess
  */
 
+import jdk.incubator.foreign.MemoryAddress;
+import jdk.incubator.foreign.MemoryHandles;
 import jdk.incubator.foreign.MemorySegment;
 import jdk.incubator.foreign.MemoryLayouts;
 import org.testng.annotations.*;
 
 import java.lang.invoke.VarHandle;
 import java.lang.invoke.WrongMethodTypeException;
+import java.nio.ByteOrder;
 
 public class TestTypeAccess {
 
     static final VarHandle INT_HANDLE = MemoryLayouts.JAVA_INT.varHandle(int.class);
 
+    static final VarHandle ADDR_HANDLE = MemoryHandles.asAddressVarHandle(INT_HANDLE);
+
     @Test(expectedExceptions=ClassCastException.class)
     public void testMemoryAddressCoordinateAsString() {
         try (MemorySegment s = MemorySegment.allocateNative(8)) {
@@ -51,4 +56,33 @@ public void testMemoryCoordinatePrimitive() {
             int v = (int)INT_HANDLE.get(1);
         }
     }
+
+    @Test(expectedExceptions=ClassCastException.class)
+    public void testMemoryAddressValueGetAsString() {
+        try (MemorySegment s = MemorySegment.allocateNative(8)) {
+            String address = (String)ADDR_HANDLE.get(s.address());
+        }
+    }
+
+    @Test(expectedExceptions=ClassCastException.class)
+    public void testMemoryAddressValueSetAsString() {
+        try (MemorySegment s = MemorySegment.allocateNative(8)) {
+            ADDR_HANDLE.set(s.address(), "string");
+        }
+    }
+
+    @Test(expectedExceptions=WrongMethodTypeException.class)
+    public void testMemoryAddressValueGetAsPrimitive() {
+        try (MemorySegment s = MemorySegment.allocateNative(8)) {
+            int address = (int)ADDR_HANDLE.get(s.address());
+        }
+    }
+
+    @Test(expectedExceptions=WrongMethodTypeException.class)
+    public void testMemoryAddressValueSetAsPrimitive() {
+        try (MemorySegment s = MemorySegment.allocateNative(8)) {
+            ADDR_HANDLE.set(s.address(), 1);
+        }
+    }
+
 }
diff --git a/test/jdk/java/foreign/libNativeAccess.c b/test/jdk/java/foreign/libNativeAccess.c
index 6fafd6e0622d1..a502734842a4d 100644
--- a/test/jdk/java/foreign/libNativeAccess.c
+++ b/test/jdk/java/foreign/libNativeAccess.c
@@ -115,13 +115,3 @@ JNIEXPORT jlong JNICALL
 Java_TestNative_getCapacity(JNIEnv *env, jclass cls, jobject buf) {
     return (*env)->GetDirectBufferCapacity(env, buf);
 }
-
-JNIEXPORT jlong JNICALL
-Java_TestNative_allocate(JNIEnv *env, jclass cls, jint size) {
-    return (jlong)(uintptr_t)malloc(size);
-}
-
-JNIEXPORT void JNICALL
-Java_TestNative_free(JNIEnv *env, jclass cls, jlong ptr) {
-    free((void*)(uintptr_t)ptr);
-}
diff --git a/test/lib/sun/hotspot/WhiteBox.java b/test/lib/sun/hotspot/WhiteBox.java
index b34cf383a00f9..ecb0663340a23 100644
--- a/test/lib/sun/hotspot/WhiteBox.java
+++ b/test/lib/sun/hotspot/WhiteBox.java
@@ -619,6 +619,9 @@ public native int validateCgroup(String procCgroups,
   // libc name
   public native String getLibcName();
 
+  // Walk stack frames of current thread
+  public native void verifyFrames(boolean log);
+
   public native boolean isJVMTIIncluded();
 
   public native void waitUnsafe(int time_ms);
diff --git a/test/micro/org/openjdk/bench/jdk/incubator/foreign/BulkOps.java b/test/micro/org/openjdk/bench/jdk/incubator/foreign/BulkOps.java
index 69950eacbac6a..65a4257fa6109 100644
--- a/test/micro/org/openjdk/bench/jdk/incubator/foreign/BulkOps.java
+++ b/test/micro/org/openjdk/bench/jdk/incubator/foreign/BulkOps.java
@@ -45,7 +45,7 @@
 @Measurement(iterations = 10, time = 500, timeUnit = TimeUnit.MILLISECONDS)
 @State(org.openjdk.jmh.annotations.Scope.Thread)
 @OutputTimeUnit(TimeUnit.MILLISECONDS)
-@Fork(3)
+@Fork(value = 3, jvmArgsAppend = { "--add-modules=jdk.incubator.foreign" })
 public class BulkOps {
 
     static final Unsafe unsafe = Utils.unsafe;
diff --git a/test/micro/org/openjdk/bench/jdk/incubator/foreign/LoopOverConstant.java b/test/micro/org/openjdk/bench/jdk/incubator/foreign/LoopOverConstant.java
index f79b019b1a2cf..48be59077968f 100644
--- a/test/micro/org/openjdk/bench/jdk/incubator/foreign/LoopOverConstant.java
+++ b/test/micro/org/openjdk/bench/jdk/incubator/foreign/LoopOverConstant.java
@@ -51,7 +51,7 @@
 @Measurement(iterations = 10, time = 500, timeUnit = TimeUnit.MILLISECONDS)
 @State(org.openjdk.jmh.annotations.Scope.Thread)
 @OutputTimeUnit(TimeUnit.MILLISECONDS)
-@Fork(3)
+@Fork(value = 3, jvmArgsAppend = { "--add-modules=jdk.incubator.foreign" })
 public class LoopOverConstant {
 
     static final Unsafe unsafe = Utils.unsafe;
diff --git a/test/micro/org/openjdk/bench/jdk/incubator/foreign/LoopOverNew.java b/test/micro/org/openjdk/bench/jdk/incubator/foreign/LoopOverNew.java
index 101f3dde8e96f..c2a32beb13e03 100644
--- a/test/micro/org/openjdk/bench/jdk/incubator/foreign/LoopOverNew.java
+++ b/test/micro/org/openjdk/bench/jdk/incubator/foreign/LoopOverNew.java
@@ -49,7 +49,7 @@
 @Measurement(iterations = 10, time = 500, timeUnit = TimeUnit.MILLISECONDS)
 @State(org.openjdk.jmh.annotations.Scope.Thread)
 @OutputTimeUnit(TimeUnit.MILLISECONDS)
-@Fork(3)
+@Fork(value = 3, jvmArgsAppend = { "--add-modules=jdk.incubator.foreign" })
 public class LoopOverNew {
 
     static final Unsafe unsafe = Utils.unsafe;
diff --git a/test/micro/org/openjdk/bench/jdk/incubator/foreign/LoopOverNonConstant.java b/test/micro/org/openjdk/bench/jdk/incubator/foreign/LoopOverNonConstant.java
index 03cc9dab946de..690a0c5d5b7d1 100644
--- a/test/micro/org/openjdk/bench/jdk/incubator/foreign/LoopOverNonConstant.java
+++ b/test/micro/org/openjdk/bench/jdk/incubator/foreign/LoopOverNonConstant.java
@@ -51,7 +51,7 @@
 @Measurement(iterations = 10, time = 500, timeUnit = TimeUnit.MILLISECONDS)
 @State(org.openjdk.jmh.annotations.Scope.Thread)
 @OutputTimeUnit(TimeUnit.MILLISECONDS)
-@Fork(3)
+@Fork(value = 3, jvmArgsAppend = { "--add-modules=jdk.incubator.foreign" })
 public class LoopOverNonConstant {
 
     static final Unsafe unsafe = Utils.unsafe;
diff --git a/test/micro/org/openjdk/bench/jdk/incubator/foreign/LoopOverNonConstantHeap.java b/test/micro/org/openjdk/bench/jdk/incubator/foreign/LoopOverNonConstantHeap.java
index 61fd7cb132012..422a33fb8b684 100644
--- a/test/micro/org/openjdk/bench/jdk/incubator/foreign/LoopOverNonConstantHeap.java
+++ b/test/micro/org/openjdk/bench/jdk/incubator/foreign/LoopOverNonConstantHeap.java
@@ -51,7 +51,7 @@
 @Measurement(iterations = 10, time = 500, timeUnit = TimeUnit.MILLISECONDS)
 @State(org.openjdk.jmh.annotations.Scope.Thread)
 @OutputTimeUnit(TimeUnit.MILLISECONDS)
-@Fork(3)
+@Fork(value = 3, jvmArgsAppend = { "--add-modules=jdk.incubator.foreign" })
 public class LoopOverNonConstantHeap {
 
     static final Unsafe unsafe = Utils.unsafe;
diff --git a/test/micro/org/openjdk/bench/jdk/incubator/foreign/LoopOverNonConstantMapped.java b/test/micro/org/openjdk/bench/jdk/incubator/foreign/LoopOverNonConstantMapped.java
index 651e8c7390121..713d787d694b3 100644
--- a/test/micro/org/openjdk/bench/jdk/incubator/foreign/LoopOverNonConstantMapped.java
+++ b/test/micro/org/openjdk/bench/jdk/incubator/foreign/LoopOverNonConstantMapped.java
@@ -58,7 +58,7 @@
 @Measurement(iterations = 10, time = 500, timeUnit = TimeUnit.MILLISECONDS)
 @State(org.openjdk.jmh.annotations.Scope.Thread)
 @OutputTimeUnit(TimeUnit.MILLISECONDS)
-@Fork(3)
+@Fork(value = 3, jvmArgsAppend = { "--add-modules=jdk.incubator.foreign" })
 public class LoopOverNonConstantMapped {
 
     static final Unsafe unsafe = Utils.unsafe;
diff --git a/test/micro/org/openjdk/bench/jdk/incubator/foreign/ParallelSum.java b/test/micro/org/openjdk/bench/jdk/incubator/foreign/ParallelSum.java
index 4bebe01de09f7..b0f6d3080cdec 100644
--- a/test/micro/org/openjdk/bench/jdk/incubator/foreign/ParallelSum.java
+++ b/test/micro/org/openjdk/bench/jdk/incubator/foreign/ParallelSum.java
@@ -62,7 +62,7 @@
 @Measurement(iterations = 10, time = 500, timeUnit = TimeUnit.MILLISECONDS)
 @State(org.openjdk.jmh.annotations.Scope.Thread)
 @OutputTimeUnit(TimeUnit.MILLISECONDS)
-@Fork(3)
+@Fork(value = 3, jvmArgsAppend = { "--add-modules=jdk.incubator.foreign" })
 public class ParallelSum {
 
     final static int CARRIER_SIZE = 4;
diff --git a/test/micro/org/openjdk/bench/jdk/incubator/foreign/TestAdaptVarHandles.java b/test/micro/org/openjdk/bench/jdk/incubator/foreign/TestAdaptVarHandles.java
index 2a35b36955ea4..da44ad762a324 100644
--- a/test/micro/org/openjdk/bench/jdk/incubator/foreign/TestAdaptVarHandles.java
+++ b/test/micro/org/openjdk/bench/jdk/incubator/foreign/TestAdaptVarHandles.java
@@ -50,7 +50,7 @@
 @Measurement(iterations = 10, time = 500, timeUnit = TimeUnit.MILLISECONDS)
 @State(org.openjdk.jmh.annotations.Scope.Thread)
 @OutputTimeUnit(TimeUnit.MILLISECONDS)
-@Fork(3)
+@Fork(value = 3, jvmArgsAppend = { "--add-modules=jdk.incubator.foreign" })
 public class TestAdaptVarHandles {
 
     static class IntBox {
diff --git a/test/micro/org/openjdk/bench/jdk/incubator/foreign/points/PointsAccess.java b/test/micro/org/openjdk/bench/jdk/incubator/foreign/points/PointsAccess.java
index 3abeae0000cb4..beb0b5292ed37 100644
--- a/test/micro/org/openjdk/bench/jdk/incubator/foreign/points/PointsAccess.java
+++ b/test/micro/org/openjdk/bench/jdk/incubator/foreign/points/PointsAccess.java
@@ -43,7 +43,7 @@
 @Measurement(iterations = 10, time = 500, timeUnit = TimeUnit.MILLISECONDS)
 @State(org.openjdk.jmh.annotations.Scope.Thread)
 @OutputTimeUnit(TimeUnit.NANOSECONDS)
-@Fork(3)
+@Fork(value = 3, jvmArgsAppend = { "--add-modules=jdk.incubator.foreign", "-Dforeign.restricted=permit" })
 public class PointsAccess {
 
     BBPoint BBPoint;
diff --git a/test/micro/org/openjdk/bench/jdk/incubator/foreign/points/PointsAlloc.java b/test/micro/org/openjdk/bench/jdk/incubator/foreign/points/PointsAlloc.java
index d13f1951e808e..f13648b776ae2 100644
--- a/test/micro/org/openjdk/bench/jdk/incubator/foreign/points/PointsAlloc.java
+++ b/test/micro/org/openjdk/bench/jdk/incubator/foreign/points/PointsAlloc.java
@@ -41,7 +41,7 @@
 @Measurement(iterations = 10, time = 500, timeUnit = TimeUnit.MILLISECONDS)
 @State(org.openjdk.jmh.annotations.Scope.Thread)
 @OutputTimeUnit(TimeUnit.NANOSECONDS)
-@Fork(3)
+@Fork(value = 3, jvmArgsAppend = { "--add-modules=jdk.incubator.foreign", "-Dforeign.restricted=permit" })
 public class PointsAlloc {
 
     @Benchmark
diff --git a/test/micro/org/openjdk/bench/jdk/incubator/foreign/points/PointsFree.java b/test/micro/org/openjdk/bench/jdk/incubator/foreign/points/PointsFree.java
index e4a3d0eb2545f..dbf76e8b12b25 100644
--- a/test/micro/org/openjdk/bench/jdk/incubator/foreign/points/PointsFree.java
+++ b/test/micro/org/openjdk/bench/jdk/incubator/foreign/points/PointsFree.java
@@ -42,7 +42,7 @@
 @Measurement(iterations = 10, time = 500, timeUnit = TimeUnit.MILLISECONDS)
 @State(org.openjdk.jmh.annotations.Scope.Thread)
 @OutputTimeUnit(TimeUnit.NANOSECONDS)
-@Fork(3)
+@Fork(value = 3, jvmArgsAppend = { "--add-modules=jdk.incubator.foreign", "-Dforeign.restricted=permit" })
 public class PointsFree {
 
     JNIPoint jniPoint;
diff --git a/test/micro/org/openjdk/bench/jdk/incubator/foreign/points/support/BBPoint.java b/test/micro/org/openjdk/bench/jdk/incubator/foreign/points/support/BBPoint.java
index d0a4f2e8a34ca..0710c71a29b93 100644
--- a/test/micro/org/openjdk/bench/jdk/incubator/foreign/points/support/BBPoint.java
+++ b/test/micro/org/openjdk/bench/jdk/incubator/foreign/points/support/BBPoint.java
@@ -27,6 +27,10 @@
 
 public class BBPoint {
 
+    static {
+        System.loadLibrary("JNIPoint");
+    }
+
     private final ByteBuffer buff;
 
     public BBPoint(int x, int y) {
@@ -50,4 +54,10 @@ public int getY() {
     public void setY(int y) {
         buff.putInt(0, y);
     }
+
+    public double distanceTo(BBPoint other) {
+        return distance(buff, other.buff);
+    }
+
+    private static native double distance(ByteBuffer p1, ByteBuffer p2);
 }
diff --git a/test/micro/org/openjdk/bench/jdk/incubator/foreign/points/support/JNIPoint.java b/test/micro/org/openjdk/bench/jdk/incubator/foreign/points/support/JNIPoint.java
index f2372923b80de..ec76b8fdc9242 100644
--- a/test/micro/org/openjdk/bench/jdk/incubator/foreign/points/support/JNIPoint.java
+++ b/test/micro/org/openjdk/bench/jdk/incubator/foreign/points/support/JNIPoint.java
@@ -56,6 +56,10 @@ public void setY(int value) {
         setY(peer, value);
     }
 
+    public double distanceTo(JNIPoint other) {
+        return distance(peer, other.peer);
+    }
+
     private static native long allocate();
     private static native void free(long ptr);
 
@@ -65,6 +69,8 @@ public void setY(int value) {
     private static native int getY(long ptr);
     private static native void setY(long ptr, int y);
 
+    private static native double distance(long p1, long p2);
+
     @Override
     public void close() {
         free();
diff --git a/test/micro/org/openjdk/bench/jdk/incubator/foreign/points/support/PanamaPoint.java b/test/micro/org/openjdk/bench/jdk/incubator/foreign/points/support/PanamaPoint.java
index 0a3127bb50800..aea10f5853ffb 100644
--- a/test/micro/org/openjdk/bench/jdk/incubator/foreign/points/support/PanamaPoint.java
+++ b/test/micro/org/openjdk/bench/jdk/incubator/foreign/points/support/PanamaPoint.java
@@ -22,24 +22,46 @@
  */
 package org.openjdk.bench.jdk.incubator.foreign.points.support;
 
+import jdk.incubator.foreign.FunctionDescriptor;
+import jdk.incubator.foreign.LibraryLookup;
+import jdk.incubator.foreign.MemoryAddress;
 import jdk.incubator.foreign.MemoryLayout;
-import jdk.incubator.foreign.MemoryLayouts;
 import jdk.incubator.foreign.MemorySegment;
+import jdk.incubator.foreign.CLinker;
 
+import java.lang.invoke.MethodHandle;
 import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
 
+import static java.lang.invoke.MethodType.methodType;
 import static jdk.incubator.foreign.MemoryLayout.PathElement.groupElement;
+import static jdk.incubator.foreign.CLinker.*;
 
 public class PanamaPoint implements AutoCloseable {
 
     public static final MemoryLayout LAYOUT = MemoryLayout.ofStruct(
-        MemoryLayouts.JAVA_INT.withOrder(ByteOrder.nativeOrder()).withName("x"),
-        MemoryLayouts.JAVA_INT.withOrder(ByteOrder.nativeOrder()).withName("y")
+        C_INT.withName("x"),
+        C_INT.withName("y")
     );
 
     private static final VarHandle VH_x = LAYOUT.varHandle(int.class, groupElement("x"));
     private static final VarHandle VH_y = LAYOUT.varHandle(int.class, groupElement("y"));
+    private static final MethodHandle MH_distance;
+    private static final MethodHandle MH_distance_ptrs;
+
+    static {
+        CLinker abi = CLinker.getInstance();
+        LibraryLookup lookup = LibraryLookup.ofLibrary("Point");
+        MH_distance = abi.downcallHandle(
+            lookup.lookup("distance").get(),
+            methodType(double.class, MemorySegment.class, MemorySegment.class),
+            FunctionDescriptor.of(C_DOUBLE, LAYOUT, LAYOUT)
+        );
+        MH_distance_ptrs = abi.downcallHandle(
+            lookup.lookup("distance_ptrs").get(),
+            methodType(double.class, MemoryAddress.class, MemoryAddress.class),
+            FunctionDescriptor.of(C_DOUBLE, C_POINTER, C_POINTER)
+        );
+    }
 
     private final MemorySegment segment;
 
@@ -73,6 +95,22 @@ public int getY() {
         return (int) VH_y.get(segment);
     }
 
+    public double distanceTo(PanamaPoint other) {
+        try {
+            return (double) MH_distance.invokeExact(segment, other.segment);
+        } catch (Throwable throwable) {
+            throw new InternalError(throwable);
+        }
+    }
+
+    public double distanceToPtrs(PanamaPoint other) {
+        try {
+            return (double) MH_distance_ptrs.invokeExact(segment.address(), other.segment.address());
+        } catch (Throwable throwable) {
+            throw new InternalError(throwable);
+        }
+    }
+
     @Override
     public void close() {
         segment.close();
diff --git a/test/micro/org/openjdk/bench/jdk/incubator/foreign/points/support/libJNIPoint.c b/test/micro/org/openjdk/bench/jdk/incubator/foreign/points/support/libJNIPoint.c
index 569e0e3d25b98..26b70fc271862 100644
--- a/test/micro/org/openjdk/bench/jdk/incubator/foreign/points/support/libJNIPoint.c
+++ b/test/micro/org/openjdk/bench/jdk/incubator/foreign/points/support/libJNIPoint.c
@@ -22,9 +22,16 @@
  */
 #include 
 #include 
+#include 
 
 #include "points.h"
 
+double distance(Point p1, Point p2) {
+    int xDist = abs(p1.x - p2.x);
+    int yDist = abs(p1.y - p2.y);
+    return sqrt((xDist * xDist) + (yDist * yDist));
+}
+
 JNIEXPORT jlong JNICALL Java_org_openjdk_bench_jdk_incubator_foreign_points_support_JNIPoint_allocate
   (JNIEnv *env, jclass nativePointClass) {
     Point* p = malloc(sizeof *p);
@@ -59,3 +66,17 @@ JNIEXPORT void JNICALL Java_org_openjdk_bench_jdk_incubator_foreign_points_suppo
     Point* point = (Point*) thisPoint;
     point->y = value;
 }
+
+JNIEXPORT jdouble JNICALL Java_org_openjdk_bench_jdk_incubator_foreign_points_support_JNIPoint_distance
+  (JNIEnv *env, jclass cls, jlong thisPoint, jlong other) {
+    Point* p1 = (Point*) thisPoint;
+    Point* p2 = (Point*) other;
+    return distance(*p1, *p2);
+}
+
+JNIEXPORT jdouble JNICALL Java_org_openjdk_bench_jdk_incubator_foreign_points_support_BBPoint_distance
+  (JNIEnv *env, jclass ignored, jobject buffP1, jobject buffP2) {
+    Point* p1 = (Point*) (*env)->GetDirectBufferAddress(env, buffP1);
+    Point* p2 = (Point*) (*env)->GetDirectBufferAddress(env, buffP2);
+    return distance(*p1, *p2);
+}

From adcef6a7d17cb36528b24f58dbe5dd6a30c84ea6 Mon Sep 17 00:00:00 2001
From: Maurizio Cimadamore 
Date: Tue, 13 Oct 2020 11:34:34 +0100
Subject: [PATCH 12/70] Add new files

---
 .../cpu/aarch64/foreign_globals_aarch64.cpp   |   126 +
 .../cpu/aarch64/foreign_globals_aarch64.hpp   |    78 +
 .../universalNativeInvoker_aarch64.cpp        |   163 +
 .../universalUpcallHandler_aarch64.cpp        |   190 +
 src/hotspot/cpu/x86/foreign_globals_x86.cpp   |   120 +
 src/hotspot/cpu/x86/foreign_globals_x86.hpp   |    79 +
 .../cpu/x86/universalNativeInvoker_x86.cpp    |   201 +
 .../cpu/x86/universalUpcallHandler_x86.cpp    |   242 +
 src/hotspot/share/ci/ciNativeEntryPoint.cpp   |    93 +
 src/hotspot/share/ci/ciNativeEntryPoint.hpp   |    56 +
 src/hotspot/share/prims/nativeEntryPoint.cpp  |    51 +
 .../share/prims/universalNativeInvoker.cpp    |    77 +
 .../share/prims/universalNativeInvoker.hpp    |    51 +
 .../share/prims/universalUpcallHandler.cpp    |    59 +
 .../share/prims/universalUpcallHandler.hpp    |    40 +
 src/hotspot/share/prims/upcallStubs.cpp       |    67 +
 .../java/lang/invoke/NativeMethodHandle.java  |   170 +
 .../access/foreign/NativeLibraryProxy.java    |    31 +
 .../internal/invoke/ABIDescriptorProxy.java   |    29 +
 .../jdk/internal/invoke/NativeEntryPoint.java |    85 +
 .../jdk/internal/invoke/VMStorageProxy.java   |    30 +
 .../jdk/incubator/foreign/CLinker.java        |   794 +
 .../incubator/foreign/FunctionDescriptor.java |   228 +
 .../jdk/incubator/foreign/LibraryLookup.java  |   146 +
 .../jdk/incubator/foreign/NativeScope.java    |   430 +
 .../AbstractMemorySegmentImpl.java.rej        |    18 +
 .../internal/foreign/AbstractNativeScope.java |   134 +
 .../classes/jdk/internal/foreign/CABI.java    |    47 +
 .../jdk/internal/foreign/LibrariesHelper.java |   144 +
 .../jdk/internal/foreign/PlatformLayouts.java |   296 +
 .../jdk/internal/foreign/Utils.java.rej       |    14 +
 .../internal/foreign/abi/ABIDescriptor.java   |    52 +
 .../internal/foreign/abi/Architecture.java    |    29 +
 .../jdk/internal/foreign/abi/Binding.java     |  1027 ++
 .../foreign/abi/BindingInterpreter.java       |    55 +
 .../internal/foreign/abi/BufferLayout.java    |   141 +
 .../internal/foreign/abi/CallingSequence.java |   102 +
 .../foreign/abi/CallingSequenceBuilder.java   |   151 +
 .../foreign/abi/ProgrammableInvoker.java      |   385 +
 .../abi/ProgrammableUpcallHandler.java        |   140 +
 .../jdk/internal/foreign/abi/SharedUtils.java |   550 +
 .../internal/foreign/abi/UpcallHandler.java   |    28 +
 .../jdk/internal/foreign/abi/UpcallStubs.java |    57 +
 .../jdk/internal/foreign/abi/VMStorage.java   |    75 +
 .../abi/aarch64/AArch64Architecture.java      |   169 +
 .../foreign/abi/aarch64/AArch64Linker.java    |   103 +
 .../foreign/abi/aarch64/AArch64VaList.java    |   565 +
 .../foreign/abi/aarch64/CallArranger.java     |   462 +
 .../foreign/abi/aarch64/TypeClass.java        |   110 +
 .../foreign/abi/x64/X86_64Architecture.java   |   156 +
 .../abi/x64/sysv/ArgumentClassImpl.java       |    75 +
 .../foreign/abi/x64/sysv/CallArranger.java    |   357 +
 .../foreign/abi/x64/sysv/SysVVaList.java      |   482 +
 .../foreign/abi/x64/sysv/SysVx64Linker.java   |   107 +
 .../foreign/abi/x64/sysv/TypeClass.java       |   231 +
 .../foreign/abi/x64/windows/CallArranger.java |   309 +
 .../foreign/abi/x64/windows/TypeClass.java    |    89 +
 .../foreign/abi/x64/windows/WinVaList.java    |   269 +
 .../abi/x64/windows/Windowsx64Linker.java     |   108 +
 .../jdk/java/foreign/CallGeneratorHelper.java |   464 +
 test/jdk/java/foreign/NativeTestHelper.java   |    42 +
 test/jdk/java/foreign/StdLibTest.java         |   454 +
 test/jdk/java/foreign/TestCircularInit1.java  |    44 +
 test/jdk/java/foreign/TestCircularInit2.java  |    46 +
 test/jdk/java/foreign/TestCondy.java          |    86 +
 test/jdk/java/foreign/TestDowncall.java       |   110 +
 test/jdk/java/foreign/TestFree.java           |    53 +
 .../java/foreign/TestFunctionDescriptor.java  |   147 +
 test/jdk/java/foreign/TestIllegalLink.java    |   112 +
 test/jdk/java/foreign/TestIntrinsics.java     |   137 +
 test/jdk/java/foreign/TestLayoutEquality.java |    79 +
 test/jdk/java/foreign/TestLibraryLookup.java  |   167 +
 test/jdk/java/foreign/TestNativeScope.java    |   528 +
 test/jdk/java/foreign/TestUpcall.java         |   204 +
 .../jdk/java/foreign/TestUpcallHighArity.java |   159 +
 test/jdk/java/foreign/TestUpcallStubs.java    |    95 +
 test/jdk/java/foreign/TestVarArgs.java        |   152 +
 .../callarranger/CallArrangerTestBase.java    |    50 +
 .../callarranger/TestAarch64CallArranger.java |   347 +
 .../callarranger/TestSysVCallArranger.java    |   487 +
 .../callarranger/TestWindowsCallArranger.java |   373 +
 test/jdk/java/foreign/libIntrinsics.c         |    82 +
 test/jdk/java/foreign/libLookupTest.c         |    32 +
 test/jdk/java/foreign/libTestDowncall.c       | 12129 +++++++++++++++
 test/jdk/java/foreign/libTestDowncall.h       | 12210 ++++++++++++++++
 test/jdk/java/foreign/libTestUpcall.c         | 12129 +++++++++++++++
 test/jdk/java/foreign/libTestUpcall.h         | 12210 ++++++++++++++++
 .../jdk/java/foreign/libTestUpcallHighArity.c |    38 +
 test/jdk/java/foreign/libVarArgs.c            |    59 +
 .../java/foreign/stackwalk/TestStackWalk.java |   111 +
 .../jdk/java/foreign/stackwalk/libStackWalk.c |    33 +
 test/jdk/java/foreign/valist/VaListTest.java  |   807 +
 test/jdk/java/foreign/valist/libVaList.c      |   181 +
 .../jdk/incubator/foreign/CallOverhead.java   |   161 +
 .../bench/jdk/incubator/foreign/Upcalls.java  |   126 +
 .../bench/jdk/incubator/foreign/VaList.java   |    87 +
 .../jdk/incubator/foreign/libCallOverhead.c   |    51 +
 .../incubator/foreign/libCallOverheadJNI.c    |    39 +
 .../bench/jdk/incubator/foreign/libUpcalls.c  |    36 +
 .../jdk/incubator/foreign/libUpcallsJNI.c     |    83 +
 .../bench/jdk/incubator/foreign/libVaList.c   |    41 +
 .../foreign/points/PointsDistance.java        |    99 +
 .../foreign/points/support/libPoint.c         |    42 +
 103 files changed, 65795 insertions(+)
 create mode 100644 src/hotspot/cpu/aarch64/foreign_globals_aarch64.cpp
 create mode 100644 src/hotspot/cpu/aarch64/foreign_globals_aarch64.hpp
 create mode 100644 src/hotspot/cpu/aarch64/universalNativeInvoker_aarch64.cpp
 create mode 100644 src/hotspot/cpu/aarch64/universalUpcallHandler_aarch64.cpp
 create mode 100644 src/hotspot/cpu/x86/foreign_globals_x86.cpp
 create mode 100644 src/hotspot/cpu/x86/foreign_globals_x86.hpp
 create mode 100644 src/hotspot/cpu/x86/universalNativeInvoker_x86.cpp
 create mode 100644 src/hotspot/cpu/x86/universalUpcallHandler_x86.cpp
 create mode 100644 src/hotspot/share/ci/ciNativeEntryPoint.cpp
 create mode 100644 src/hotspot/share/ci/ciNativeEntryPoint.hpp
 create mode 100644 src/hotspot/share/prims/nativeEntryPoint.cpp
 create mode 100644 src/hotspot/share/prims/universalNativeInvoker.cpp
 create mode 100644 src/hotspot/share/prims/universalNativeInvoker.hpp
 create mode 100644 src/hotspot/share/prims/universalUpcallHandler.cpp
 create mode 100644 src/hotspot/share/prims/universalUpcallHandler.hpp
 create mode 100644 src/hotspot/share/prims/upcallStubs.cpp
 create mode 100644 src/java.base/share/classes/java/lang/invoke/NativeMethodHandle.java
 create mode 100644 src/java.base/share/classes/jdk/internal/access/foreign/NativeLibraryProxy.java
 create mode 100644 src/java.base/share/classes/jdk/internal/invoke/ABIDescriptorProxy.java
 create mode 100644 src/java.base/share/classes/jdk/internal/invoke/NativeEntryPoint.java
 create mode 100644 src/java.base/share/classes/jdk/internal/invoke/VMStorageProxy.java
 create mode 100644 src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/CLinker.java
 create mode 100644 src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/FunctionDescriptor.java
 create mode 100644 src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/LibraryLookup.java
 create mode 100644 src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/NativeScope.java
 create mode 100644 src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/AbstractMemorySegmentImpl.java.rej
 create mode 100644 src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/AbstractNativeScope.java
 create mode 100644 src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/CABI.java
 create mode 100644 src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/LibrariesHelper.java
 create mode 100644 src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/PlatformLayouts.java
 create mode 100644 src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/Utils.java.rej
 create mode 100644 src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/ABIDescriptor.java
 create mode 100644 src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/Architecture.java
 create mode 100644 src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/Binding.java
 create mode 100644 src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/BindingInterpreter.java
 create mode 100644 src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/BufferLayout.java
 create mode 100644 src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/CallingSequence.java
 create mode 100644 src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/CallingSequenceBuilder.java
 create mode 100644 src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/ProgrammableInvoker.java
 create mode 100644 src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/ProgrammableUpcallHandler.java
 create mode 100644 src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/SharedUtils.java
 create mode 100644 src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/UpcallHandler.java
 create mode 100644 src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/UpcallStubs.java
 create mode 100644 src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/VMStorage.java
 create mode 100644 src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/aarch64/AArch64Architecture.java
 create mode 100644 src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/aarch64/AArch64Linker.java
 create mode 100644 src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/aarch64/AArch64VaList.java
 create mode 100644 src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/aarch64/CallArranger.java
 create mode 100644 src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/aarch64/TypeClass.java
 create mode 100644 src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/X86_64Architecture.java
 create mode 100644 src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/sysv/ArgumentClassImpl.java
 create mode 100644 src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/sysv/CallArranger.java
 create mode 100644 src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/sysv/SysVVaList.java
 create mode 100644 src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/sysv/SysVx64Linker.java
 create mode 100644 src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/sysv/TypeClass.java
 create mode 100644 src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/windows/CallArranger.java
 create mode 100644 src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/windows/TypeClass.java
 create mode 100644 src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/windows/WinVaList.java
 create mode 100644 src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/windows/Windowsx64Linker.java
 create mode 100644 test/jdk/java/foreign/CallGeneratorHelper.java
 create mode 100644 test/jdk/java/foreign/NativeTestHelper.java
 create mode 100644 test/jdk/java/foreign/StdLibTest.java
 create mode 100644 test/jdk/java/foreign/TestCircularInit1.java
 create mode 100644 test/jdk/java/foreign/TestCircularInit2.java
 create mode 100644 test/jdk/java/foreign/TestCondy.java
 create mode 100644 test/jdk/java/foreign/TestDowncall.java
 create mode 100644 test/jdk/java/foreign/TestFree.java
 create mode 100644 test/jdk/java/foreign/TestFunctionDescriptor.java
 create mode 100644 test/jdk/java/foreign/TestIllegalLink.java
 create mode 100644 test/jdk/java/foreign/TestIntrinsics.java
 create mode 100644 test/jdk/java/foreign/TestLayoutEquality.java
 create mode 100644 test/jdk/java/foreign/TestLibraryLookup.java
 create mode 100644 test/jdk/java/foreign/TestNativeScope.java
 create mode 100644 test/jdk/java/foreign/TestUpcall.java
 create mode 100644 test/jdk/java/foreign/TestUpcallHighArity.java
 create mode 100644 test/jdk/java/foreign/TestUpcallStubs.java
 create mode 100644 test/jdk/java/foreign/TestVarArgs.java
 create mode 100644 test/jdk/java/foreign/callarranger/CallArrangerTestBase.java
 create mode 100644 test/jdk/java/foreign/callarranger/TestAarch64CallArranger.java
 create mode 100644 test/jdk/java/foreign/callarranger/TestSysVCallArranger.java
 create mode 100644 test/jdk/java/foreign/callarranger/TestWindowsCallArranger.java
 create mode 100644 test/jdk/java/foreign/libIntrinsics.c
 create mode 100644 test/jdk/java/foreign/libLookupTest.c
 create mode 100644 test/jdk/java/foreign/libTestDowncall.c
 create mode 100644 test/jdk/java/foreign/libTestDowncall.h
 create mode 100644 test/jdk/java/foreign/libTestUpcall.c
 create mode 100644 test/jdk/java/foreign/libTestUpcall.h
 create mode 100644 test/jdk/java/foreign/libTestUpcallHighArity.c
 create mode 100644 test/jdk/java/foreign/libVarArgs.c
 create mode 100644 test/jdk/java/foreign/stackwalk/TestStackWalk.java
 create mode 100644 test/jdk/java/foreign/stackwalk/libStackWalk.c
 create mode 100644 test/jdk/java/foreign/valist/VaListTest.java
 create mode 100644 test/jdk/java/foreign/valist/libVaList.c
 create mode 100644 test/micro/org/openjdk/bench/jdk/incubator/foreign/CallOverhead.java
 create mode 100644 test/micro/org/openjdk/bench/jdk/incubator/foreign/Upcalls.java
 create mode 100644 test/micro/org/openjdk/bench/jdk/incubator/foreign/VaList.java
 create mode 100644 test/micro/org/openjdk/bench/jdk/incubator/foreign/libCallOverhead.c
 create mode 100644 test/micro/org/openjdk/bench/jdk/incubator/foreign/libCallOverheadJNI.c
 create mode 100644 test/micro/org/openjdk/bench/jdk/incubator/foreign/libUpcalls.c
 create mode 100644 test/micro/org/openjdk/bench/jdk/incubator/foreign/libUpcallsJNI.c
 create mode 100644 test/micro/org/openjdk/bench/jdk/incubator/foreign/libVaList.c
 create mode 100644 test/micro/org/openjdk/bench/jdk/incubator/foreign/points/PointsDistance.java
 create mode 100644 test/micro/org/openjdk/bench/jdk/incubator/foreign/points/support/libPoint.c

diff --git a/src/hotspot/cpu/aarch64/foreign_globals_aarch64.cpp b/src/hotspot/cpu/aarch64/foreign_globals_aarch64.cpp
new file mode 100644
index 0000000000000..9a527f68f918c
--- /dev/null
+++ b/src/hotspot/cpu/aarch64/foreign_globals_aarch64.cpp
@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2019, Arm Limited. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+#include "precompiled.hpp"
+#include "asm/macroAssembler.hpp"
+#include CPU_HEADER(foreign_globals)
+
+bool ABIDescriptor::is_volatile_reg(Register reg) const {
+  return _integer_argument_registers.contains(reg)
+    || _integer_additional_volatile_registers.contains(reg);
+}
+
+bool ABIDescriptor::is_volatile_reg(FloatRegister reg) const {
+    return _vector_argument_registers.contains(reg)
+        || _vector_additional_volatile_registers.contains(reg);
+}
+
+#define FOREIGN_ABI "jdk/internal/foreign/abi/"
+
+#define INTEGER_TYPE 0
+#define VECTOR_TYPE 1
+#define X87_TYPE 2
+#define STACK_TYPE 3
+
+template
+void loadArray(JNIEnv* env, jfieldID indexField, jobjectArray jarray,
+               jint type_index, GrowableArray& array, Func converter) {
+  jobjectArray subarray = (jobjectArray) env->GetObjectArrayElement(jarray, type_index);
+  jint subarray_length = env->GetArrayLength(subarray);
+  for (jint i = 0; i < subarray_length; i++) {
+    jobject storage = env->GetObjectArrayElement(subarray, i);
+    jint index = env->GetIntField(storage, indexField);
+    array.push(converter(index));
+  }
+}
+
+const ABIDescriptor parseABIDescriptor(JNIEnv* env, jobject jabi) {
+  jclass jc_ABIDescriptor = env->FindClass(FOREIGN_ABI "ABIDescriptor");
+  jfieldID jfID_inputStorage = env->GetFieldID(jc_ABIDescriptor, "inputStorage", "[[L" FOREIGN_ABI "VMStorage;");
+  jfieldID jfID_outputStorage = env->GetFieldID(jc_ABIDescriptor, "outputStorage", "[[L" FOREIGN_ABI "VMStorage;");
+  jfieldID jfID_volatileStorage = env->GetFieldID(jc_ABIDescriptor, "volatileStorage", "[[L" FOREIGN_ABI "VMStorage;");
+  jfieldID jfID_stackAlignment = env->GetFieldID(jc_ABIDescriptor, "stackAlignment", "I");
+  jfieldID jfID_shadowSpace = env->GetFieldID(jc_ABIDescriptor, "shadowSpace", "I");
+
+  jclass jc_VMStorage = env->FindClass(FOREIGN_ABI "VMStorage");
+  jfieldID jfID_storageIndex = env->GetFieldID(jc_VMStorage, "index", "I");
+
+  ABIDescriptor abi;
+
+  jobjectArray inputStorage = (jobjectArray) env->GetObjectField(jabi, jfID_inputStorage);
+  loadArray(env, jfID_storageIndex, inputStorage, INTEGER_TYPE, abi._integer_argument_registers, as_Register);
+  loadArray(env, jfID_storageIndex, inputStorage, VECTOR_TYPE, abi._vector_argument_registers, as_FloatRegister);
+
+  jobjectArray outputStorage = (jobjectArray) env->GetObjectField(jabi, jfID_outputStorage);
+  loadArray(env, jfID_storageIndex, outputStorage, INTEGER_TYPE, abi._integer_return_registers, as_Register);
+  loadArray(env, jfID_storageIndex, outputStorage, VECTOR_TYPE, abi._vector_return_registers, as_FloatRegister);
+
+  jobjectArray volatileStorage = (jobjectArray) env->GetObjectField(jabi, jfID_volatileStorage);
+  loadArray(env, jfID_storageIndex, volatileStorage, INTEGER_TYPE, abi._integer_additional_volatile_registers, as_Register);
+  loadArray(env, jfID_storageIndex, volatileStorage, VECTOR_TYPE, abi._vector_additional_volatile_registers, as_FloatRegister);
+
+  abi._stack_alignment_bytes = env->GetIntField(jabi, jfID_stackAlignment);
+  abi._shadow_space_bytes = env->GetIntField(jabi, jfID_shadowSpace);
+
+  return abi;
+}
+
+const BufferLayout parseBufferLayout(JNIEnv* env, jobject jlayout) {
+  jclass jc_BufferLayout = env->FindClass(FOREIGN_ABI "BufferLayout");
+  jfieldID jfID_size = env->GetFieldID(jc_BufferLayout, "size", "J");
+  jfieldID jfID_arguments_next_pc =
+    env->GetFieldID(jc_BufferLayout, "arguments_next_pc", "J");
+  jfieldID jfID_stack_args_bytes =
+    env->GetFieldID(jc_BufferLayout, "stack_args_bytes", "J");
+  jfieldID jfID_stack_args =
+    env->GetFieldID(jc_BufferLayout, "stack_args", "J");
+  jfieldID jfID_input_type_offsets =
+    env->GetFieldID(jc_BufferLayout, "input_type_offsets", "[J");
+  jfieldID jfID_output_type_offsets =
+    env->GetFieldID(jc_BufferLayout, "output_type_offsets", "[J");
+
+  BufferLayout layout;
+
+  layout.stack_args_bytes = env->GetLongField(jlayout, jfID_stack_args_bytes);
+  layout.stack_args = env->GetLongField(jlayout, jfID_stack_args);
+  layout.arguments_next_pc = env->GetLongField(jlayout, jfID_arguments_next_pc);
+
+  jlongArray input_offsets =
+    (jlongArray)env->GetObjectField(jlayout, jfID_input_type_offsets);
+  jlong *input_offsets_prim = env->GetLongArrayElements(input_offsets, NULL);
+  layout.arguments_integer = (size_t)input_offsets_prim[INTEGER_TYPE];
+  layout.arguments_vector = (size_t)input_offsets_prim[VECTOR_TYPE];
+  env->ReleaseLongArrayElements(input_offsets, input_offsets_prim, JNI_ABORT);
+
+  jlongArray output_offsets =
+    (jlongArray)env->GetObjectField(jlayout, jfID_output_type_offsets);
+  jlong *output_offsets_prim = env->GetLongArrayElements(output_offsets, NULL);
+  layout.returns_integer = (size_t)output_offsets_prim[INTEGER_TYPE];
+  layout.returns_vector = (size_t)output_offsets_prim[VECTOR_TYPE];
+  env->ReleaseLongArrayElements(output_offsets, output_offsets_prim, JNI_ABORT);
+
+  layout.buffer_size = env->GetLongField(jlayout, jfID_size);
+
+  return layout;
+}
diff --git a/src/hotspot/cpu/aarch64/foreign_globals_aarch64.hpp b/src/hotspot/cpu/aarch64/foreign_globals_aarch64.hpp
new file mode 100644
index 0000000000000..0112558f5c51b
--- /dev/null
+++ b/src/hotspot/cpu/aarch64/foreign_globals_aarch64.hpp
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2019, Arm Limited. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+#include "asm/macroAssembler.hpp"
+#include "utilities/growableArray.hpp"
+
+#ifndef CPU_AARCH64_VM_FOREIGN_GLOBALS_AARCH64_HPP
+#define CPU_AARCH64_VM_FOREIGN_GLOBALS_AARCH64_HPP
+
+#define __ _masm->
+
+struct VectorRegister {
+  static const size_t VECTOR_MAX_WIDTH_BITS = 128;
+  static const size_t VECTOR_MAX_WIDTH_BYTES = VECTOR_MAX_WIDTH_BITS / 8;
+  static const size_t VECTOR_MAX_WIDTH_U64S = VECTOR_MAX_WIDTH_BITS / 64;
+  static const size_t VECTOR_MAX_WIDTH_FLOATS = VECTOR_MAX_WIDTH_BITS / 32;
+  static const size_t VECTOR_MAX_WIDTH_DOUBLES = VECTOR_MAX_WIDTH_BITS / 64;
+
+  union {
+    uint8_t bits[VECTOR_MAX_WIDTH_BYTES];
+    uint64_t u64[VECTOR_MAX_WIDTH_U64S];
+    float f[VECTOR_MAX_WIDTH_FLOATS];
+    double d[VECTOR_MAX_WIDTH_DOUBLES];
+  };
+};
+
+struct ABIDescriptor {
+  GrowableArray _integer_argument_registers;
+  GrowableArray _integer_return_registers;
+  GrowableArray _vector_argument_registers;
+  GrowableArray _vector_return_registers;
+
+  GrowableArray _integer_additional_volatile_registers;
+  GrowableArray _vector_additional_volatile_registers;
+
+  int32_t _stack_alignment_bytes;
+  int32_t _shadow_space_bytes;
+
+  bool is_volatile_reg(Register reg) const;
+  bool is_volatile_reg(FloatRegister reg) const;
+};
+
+struct BufferLayout {
+  size_t stack_args_bytes;
+  size_t stack_args;
+  size_t arguments_vector;
+  size_t arguments_integer;
+  size_t arguments_next_pc;
+  size_t returns_vector;
+  size_t returns_integer;
+  size_t buffer_size;
+};
+
+const ABIDescriptor parseABIDescriptor(JNIEnv* env, jobject jabi);
+const BufferLayout parseBufferLayout(JNIEnv* env, jobject jlayout);
+
+#endif // CPU_AARCH64_VM_FOREIGN_GLOBALS_AARCH64_HPP
diff --git a/src/hotspot/cpu/aarch64/universalNativeInvoker_aarch64.cpp b/src/hotspot/cpu/aarch64/universalNativeInvoker_aarch64.cpp
new file mode 100644
index 0000000000000..75b1e565bb3b3
--- /dev/null
+++ b/src/hotspot/cpu/aarch64/universalNativeInvoker_aarch64.cpp
@@ -0,0 +1,163 @@
+/*
+ * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2019, Arm Limited. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+#include "precompiled.hpp"
+#include "asm/macroAssembler.hpp"
+#include "include/jvm.h"
+#include "logging/log.hpp"
+#include "logging/logStream.hpp"
+#include "memory/resourceArea.hpp"
+#include "oops/arrayOop.inline.hpp"
+#include "prims/methodHandles.hpp"
+#include "prims/universalNativeInvoker.hpp"
+#include "runtime/interfaceSupport.inline.hpp"
+#include "runtime/javaCalls.hpp"
+
+static void generate_invoke_native(MacroAssembler* _masm,
+                                   const ABIDescriptor& abi,
+                                   const BufferLayout& layout) {
+  /**
+   * invoke_native_stub(struct ShuffleDowncallContext* ctxt) {
+   *   rbx = ctxt;
+   *
+   *   stack = alloca(ctxt->arguments.stack_args_bytes);
+   *
+   *   load_all_registers();
+   *   memcpy(stack, ctxt->arguments.stack_args, arguments.stack_args_bytes);
+   *
+   *   (*ctxt->arguments.next_pc)();
+   *
+   *   store_all_registers();
+   * }
+   */
+
+  __ enter();
+
+  // Name registers used in the stub code. These are all caller-save so
+  // may be clobbered by the call to the native function. Avoid using
+  // rscratch1 here as it's r8 which is the indirect result register in
+  // the standard ABI.
+  Register Rctx = r10, Rstack_size = r11;
+  Register Rwords = r12, Rtmp = r13;
+  Register Rsrc_ptr = r14, Rdst_ptr = r15;
+
+  assert_different_registers(Rctx, Rstack_size, rscratch1, rscratch2);
+
+  // TODO: if the callee is not using the standard C ABI then we need to
+  //       preserve more registers here.
+
+  __ block_comment("init_and_alloc_stack");
+
+  __ mov(Rctx, c_rarg0);
+  __ str(Rctx, Address(__ pre(sp, -2 * wordSize)));
+
+  assert(abi._stack_alignment_bytes % 16 == 0, "stack must be 16 byte aligned");
+
+  __ block_comment("allocate_stack");
+  __ ldr(Rstack_size, Address(Rctx, (int) layout.stack_args_bytes));
+  __ add(rscratch2, Rstack_size, abi._stack_alignment_bytes - 1);
+  __ andr(rscratch2, rscratch2, -abi._stack_alignment_bytes);
+  __ sub(sp, sp, rscratch2);
+
+  __ block_comment("load_arguments");
+
+  __ ldr(Rsrc_ptr, Address(Rctx, (int) layout.stack_args));
+  __ lsr(Rwords, Rstack_size, LogBytesPerWord);
+  __ mov(Rdst_ptr, sp);
+
+  Label Ldone, Lnext;
+  __ bind(Lnext);
+  __ cbz(Rwords, Ldone);
+  __ ldr(Rtmp, __ post(Rsrc_ptr, wordSize));
+  __ str(Rtmp, __ post(Rdst_ptr, wordSize));
+  __ sub(Rwords, Rwords, 1);
+  __ b(Lnext);
+  __ bind(Ldone);
+
+  for (int i = 0; i < abi._vector_argument_registers.length(); i++) {
+    ssize_t offs = layout.arguments_vector + i * sizeof(VectorRegister);
+    __ ldrq(abi._vector_argument_registers.at(i), Address(Rctx, offs));
+  }
+
+  for (int i = 0; i < abi._integer_argument_registers.length(); i++) {
+    ssize_t offs = layout.arguments_integer + i * sizeof(uintptr_t);
+    __ ldr(abi._integer_argument_registers.at(i), Address(Rctx, offs));
+  }
+
+  assert(abi._shadow_space_bytes == 0, "shadow space not supported on AArch64");
+
+  // call target function
+  __ block_comment("call target function");
+  __ ldr(rscratch2, Address(Rctx, (int) layout.arguments_next_pc));
+  __ blr(rscratch2);
+
+  __ ldr(Rctx, Address(rfp, -2 * wordSize));   // Might have clobbered Rctx
+
+  __ block_comment("store_registers");
+
+  for (int i = 0; i < abi._integer_return_registers.length(); i++) {
+    ssize_t offs = layout.returns_integer + i * sizeof(uintptr_t);
+    __ str(abi._integer_return_registers.at(i), Address(Rctx, offs));
+  }
+
+  for (int i = 0; i < abi._vector_return_registers.length(); i++) {
+    ssize_t offs = layout.returns_vector + i * sizeof(VectorRegister);
+    __ strq(abi._vector_return_registers.at(i), Address(Rctx, offs));
+  }
+
+  __ leave();
+  __ ret(lr);
+
+  __ flush();
+}
+
+class ProgrammableInvokerGenerator : public StubCodeGenerator {
+private:
+  const ABIDescriptor* _abi;
+  const BufferLayout* _layout;
+public:
+  ProgrammableInvokerGenerator(CodeBuffer* code, const ABIDescriptor* abi, const BufferLayout* layout)
+    : StubCodeGenerator(code, PrintMethodHandleStubs),
+      _abi(abi),
+      _layout(layout) {}
+
+  void generate() {
+    generate_invoke_native(_masm, *_abi, *_layout);
+  }
+};
+
+jlong ProgrammableInvoker::generate_adapter(JNIEnv* env, jobject jabi, jobject jlayout) {
+  ResourceMark rm;
+  const ABIDescriptor abi = parseABIDescriptor(env, jabi);
+  const BufferLayout layout = parseBufferLayout(env, jlayout);
+
+  BufferBlob* _invoke_native_blob = BufferBlob::create("invoke_native_blob", MethodHandles::adapter_code_size);
+
+  CodeBuffer code2(_invoke_native_blob);
+  ProgrammableInvokerGenerator g2(&code2, &abi, &layout);
+  g2.generate();
+  code2.log_section_sizes("InvokeNativeBlob");
+
+  return (jlong) _invoke_native_blob->code_begin();
+}
diff --git a/src/hotspot/cpu/aarch64/universalUpcallHandler_aarch64.cpp b/src/hotspot/cpu/aarch64/universalUpcallHandler_aarch64.cpp
new file mode 100644
index 0000000000000..4794d5251ed3d
--- /dev/null
+++ b/src/hotspot/cpu/aarch64/universalUpcallHandler_aarch64.cpp
@@ -0,0 +1,190 @@
+/*
+ * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2019, Arm Limited. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+#include "precompiled.hpp"
+#include "asm/macroAssembler.hpp"
+#include "classfile/javaClasses.inline.hpp"
+#include "classfile/symbolTable.hpp"
+#include "include/jvm.h"
+#include "jni.h"
+#include "logging/log.hpp"
+#include "logging/logStream.hpp"
+#include "memory/allocation.inline.hpp"
+#include "memory/resourceArea.hpp"
+#include "oops/arrayOop.inline.hpp"
+#include "prims/universalUpcallHandler.hpp"
+#include "runtime/interfaceSupport.inline.hpp"
+#include "runtime/javaCalls.hpp"
+#include "runtime/jniHandles.inline.hpp"
+
+extern struct JavaVM_ main_vm;
+
+static struct {
+  bool inited;
+  struct {
+    Klass* klass;
+    Symbol* name;
+    Symbol* sig;
+  } upcall_method;  // jdk.internal.foreign.abi.UniversalUpcallHandler::invoke
+} upcall_info;
+
+// FIXME: This should be initialized explicitly instead of lazily/racily
+static void upcall_init() {
+#if 0
+  fprintf(stderr, "upcall_init()\n");
+#endif
+
+  TRAPS = Thread::current();
+  ResourceMark rm;
+
+  const char* cname = "jdk/internal/foreign/abi/ProgrammableUpcallHandler";
+  const char* mname = "invoke";
+  const char* mdesc = "(Ljdk/internal/foreign/abi/ProgrammableUpcallHandler;J)V";
+  Symbol* cname_sym = SymbolTable::new_symbol(cname, (int)strlen(cname));
+  Symbol* mname_sym = SymbolTable::new_symbol(mname, (int)strlen(mname));
+  Symbol* mdesc_sym = SymbolTable::new_symbol(mdesc, (int)strlen(mdesc));
+
+#if 0
+  ::fprintf(stderr, "cname_sym: %p\n", cname_sym);
+  ::fprintf(stderr, "mname_sym: %p\n", mname_sym);
+  ::fprintf(stderr, "mdesc_sym: %p\n", mdesc_sym);
+#endif
+
+  Klass* k = SystemDictionary::resolve_or_null(cname_sym, THREAD);
+#if 0
+  ::fprintf(stderr, "Klass: %p\n", k);
+#endif
+
+  Method* method = k->lookup_method(mname_sym, mdesc_sym);
+#if 0
+  ::fprintf(stderr, "Method: %p\n", method);
+#endif
+
+  upcall_info.upcall_method.klass = k;
+  upcall_info.upcall_method.name = mname_sym;
+  upcall_info.upcall_method.sig = mdesc_sym;
+
+  upcall_info.inited = true;
+}
+
+static void upcall_helper(jobject rec, address buff) {
+  void *p_env = NULL;
+
+  Thread* thread = Thread::current_or_null();
+  if (thread == NULL) {
+    JavaVM_ *vm = (JavaVM *)(&main_vm);
+    vm -> functions -> AttachCurrentThreadAsDaemon(vm, &p_env, NULL);
+    thread = Thread::current();
+  }
+
+  assert(thread->is_Java_thread(), "really?");
+
+  ThreadInVMfromNative __tiv((JavaThread *)thread);
+
+  if (!upcall_info.inited) {
+    upcall_init();
+  }
+
+  ResourceMark rm;
+  JavaValue result(T_VOID);
+  JavaCallArguments args(2); // long = 2 slots
+
+  args.push_jobject(rec);
+  args.push_long((jlong) buff);
+
+  JavaCalls::call_static(&result, upcall_info.upcall_method.klass,
+                         upcall_info.upcall_method.name, upcall_info.upcall_method.sig,
+                         &args, thread);
+}
+
+static address generate_upcall_stub(jobject rec, const ABIDescriptor& abi,
+                                    const BufferLayout& layout) {
+  ResourceMark rm;
+  CodeBuffer buffer("upcall_stub", 1024, 1024);
+
+  MacroAssembler* _masm = new MacroAssembler(&buffer);
+
+  // stub code
+  __ enter();
+
+  // save pointer to JNI receiver handle into constant segment
+  Address rec_adr = InternalAddress(__ address_constant((address)rec));
+
+  assert(abi._stack_alignment_bytes % 16 == 0, "stack must be 16 byte aligned");
+
+  __ sub(sp, sp, (int) align_up(layout.buffer_size, abi._stack_alignment_bytes));
+
+  // TODO: This stub only uses registers which are caller-save in the
+  //       standard C ABI. If this is called from a different ABI then
+  //       we need to save registers here according to abi.is_volatile_reg.
+
+  for (int i = 0; i < abi._integer_argument_registers.length(); i++) {
+    Register reg = abi._integer_argument_registers.at(i);
+    ssize_t offset = layout.arguments_integer + i * sizeof(uintptr_t);
+    __ str(reg, Address(sp, offset));
+  }
+
+  for (int i = 0; i < abi._vector_argument_registers.length(); i++) {
+    FloatRegister reg = abi._vector_argument_registers.at(i);
+    ssize_t offset = layout.arguments_vector + i * sizeof(VectorRegister);
+    __ strq(reg, Address(sp, offset));
+  }
+
+  // Capture prev stack pointer (stack arguments base)
+  __ add(rscratch1, rfp, 16);   // Skip saved FP and LR
+  __ str(rscratch1, Address(sp, layout.stack_args));
+
+  // Call upcall helper
+  __ ldr(c_rarg0, rec_adr);
+  __ mov(c_rarg1, sp);
+  __ movptr(rscratch1, CAST_FROM_FN_PTR(uint64_t, upcall_helper));
+  __ blr(rscratch1);
+
+  for (int i = 0; i < abi._integer_return_registers.length(); i++) {
+    ssize_t offs = layout.returns_integer + i * sizeof(uintptr_t);
+    __ ldr(abi._integer_return_registers.at(i), Address(sp, offs));
+  }
+
+  for (int i = 0; i < abi._vector_return_registers.length(); i++) {
+    FloatRegister reg = abi._vector_return_registers.at(i);
+    ssize_t offs = layout.returns_vector + i * sizeof(VectorRegister);
+    __ ldrq(reg, Address(sp, offs));
+  }
+
+  __ leave();
+  __ ret(lr);
+
+  __ flush();
+
+  BufferBlob* blob = BufferBlob::create("upcall_stub", &buffer);
+
+  return blob->code_begin();
+}
+
+jlong ProgrammableUpcallHandler::generate_upcall_stub(JNIEnv *env, jobject rec, jobject jabi, jobject jlayout) {
+  const ABIDescriptor abi = parseABIDescriptor(env, jabi);
+  const BufferLayout layout = parseBufferLayout(env, jlayout);
+
+  return (jlong) ::generate_upcall_stub(rec, abi, layout);
+}
diff --git a/src/hotspot/cpu/x86/foreign_globals_x86.cpp b/src/hotspot/cpu/x86/foreign_globals_x86.cpp
new file mode 100644
index 0000000000000..71cf407302134
--- /dev/null
+++ b/src/hotspot/cpu/x86/foreign_globals_x86.cpp
@@ -0,0 +1,120 @@
+/*
+ * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+#include "precompiled.hpp"
+#include "asm/macroAssembler.hpp"
+#include CPU_HEADER(foreign_globals)
+
+bool ABIDescriptor::is_volatile_reg(Register reg) const {
+    return _integer_argument_registers.contains(reg)
+        || _integer_additional_volatile_registers.contains(reg);
+}
+
+bool ABIDescriptor::is_volatile_reg(XMMRegister reg) const {
+    return _vector_argument_registers.contains(reg)
+        || _vector_additional_volatile_registers.contains(reg);
+}
+
+#define FOREIGN_ABI "jdk/internal/foreign/abi/"
+
+#define INTEGER_TYPE 0
+#define VECTOR_TYPE 1
+#define X87_TYPE 2
+#define STACK_TYPE 3
+
+template
+void loadArray(JNIEnv* env, jfieldID indexField, jobjectArray jarray, jint type_index, GrowableArray& array, Func converter) {
+    jobjectArray subarray = (jobjectArray) env->GetObjectArrayElement(jarray, type_index);
+    jint subarray_length = env->GetArrayLength(subarray);
+    for (jint i = 0; i < subarray_length; i++) {
+        jobject storage = env->GetObjectArrayElement(subarray, i);
+        jint index = env->GetIntField(storage, indexField);
+        array.push(converter(index));
+    }
+}
+
+const ABIDescriptor parseABIDescriptor(JNIEnv* env, jobject jabi) {
+    jclass jc_ABIDescriptor = env->FindClass(FOREIGN_ABI "ABIDescriptor");
+    jfieldID jfID_inputStorage = env->GetFieldID(jc_ABIDescriptor, "inputStorage", "[[L" FOREIGN_ABI "VMStorage;");
+    jfieldID jfID_outputStorage = env->GetFieldID(jc_ABIDescriptor, "outputStorage", "[[L" FOREIGN_ABI "VMStorage;");
+    jfieldID jfID_volatileStorage = env->GetFieldID(jc_ABIDescriptor, "volatileStorage", "[[L" FOREIGN_ABI "VMStorage;");
+    jfieldID jfID_stackAlignment = env->GetFieldID(jc_ABIDescriptor, "stackAlignment", "I");
+    jfieldID jfID_shadowSpace = env->GetFieldID(jc_ABIDescriptor, "shadowSpace", "I");
+
+    jclass jc_VMStorage = env->FindClass(FOREIGN_ABI "VMStorage");
+    jfieldID jfID_storageIndex = env->GetFieldID(jc_VMStorage, "index", "I");
+
+    ABIDescriptor abi;
+
+    jobjectArray inputStorage = (jobjectArray) env->GetObjectField(jabi, jfID_inputStorage);
+    loadArray(env, jfID_storageIndex, inputStorage, INTEGER_TYPE, abi._integer_argument_registers, as_Register);
+    loadArray(env, jfID_storageIndex, inputStorage, VECTOR_TYPE, abi._vector_argument_registers, as_XMMRegister);
+
+    jobjectArray outputStorage = (jobjectArray) env->GetObjectField(jabi, jfID_outputStorage);
+    loadArray(env, jfID_storageIndex, outputStorage, INTEGER_TYPE, abi._integer_return_registers, as_Register);
+    loadArray(env, jfID_storageIndex, outputStorage, VECTOR_TYPE, abi._vector_return_registers, as_XMMRegister);
+    jobjectArray subarray = (jobjectArray) env->GetObjectArrayElement(outputStorage, X87_TYPE);
+    abi._X87_return_registers_noof = env->GetArrayLength(subarray);
+
+    jobjectArray volatileStorage = (jobjectArray) env->GetObjectField(jabi, jfID_volatileStorage);
+    loadArray(env, jfID_storageIndex, volatileStorage, INTEGER_TYPE, abi._integer_additional_volatile_registers, as_Register);
+    loadArray(env, jfID_storageIndex, volatileStorage, VECTOR_TYPE, abi._vector_additional_volatile_registers, as_XMMRegister);
+
+    abi._stack_alignment_bytes = env->GetIntField(jabi, jfID_stackAlignment);
+    abi._shadow_space_bytes = env->GetIntField(jabi, jfID_shadowSpace);
+
+    return abi;
+}
+
+const BufferLayout parseBufferLayout(JNIEnv* env, jobject jlayout) {
+    jclass jc_BufferLayout = env->FindClass(FOREIGN_ABI "BufferLayout");
+    jfieldID jfID_size = env->GetFieldID(jc_BufferLayout, "size", "J");
+    jfieldID jfID_arguments_next_pc = env->GetFieldID(jc_BufferLayout, "arguments_next_pc", "J");
+    jfieldID jfID_stack_args_bytes = env->GetFieldID(jc_BufferLayout, "stack_args_bytes", "J");
+    jfieldID jfID_stack_args = env->GetFieldID(jc_BufferLayout, "stack_args", "J");
+    jfieldID jfID_input_type_offsets = env->GetFieldID(jc_BufferLayout, "input_type_offsets", "[J");
+    jfieldID jfID_output_type_offsets = env->GetFieldID(jc_BufferLayout, "output_type_offsets", "[J");
+
+    BufferLayout layout;
+
+    layout.stack_args_bytes = env->GetLongField(jlayout, jfID_stack_args_bytes);
+    layout.stack_args = env->GetLongField(jlayout, jfID_stack_args);
+    layout.arguments_next_pc = env->GetLongField(jlayout, jfID_arguments_next_pc);
+
+    jlongArray input_offsets = (jlongArray) env->GetObjectField(jlayout, jfID_input_type_offsets);
+    jlong* input_offsets_prim = env->GetLongArrayElements(input_offsets, NULL);
+    layout.arguments_integer = (size_t) input_offsets_prim[INTEGER_TYPE];
+    layout.arguments_vector = (size_t) input_offsets_prim[VECTOR_TYPE];
+    env->ReleaseLongArrayElements(input_offsets, input_offsets_prim, JNI_ABORT);
+
+    jlongArray output_offsets = (jlongArray) env->GetObjectField(jlayout, jfID_output_type_offsets);
+    jlong* output_offsets_prim = env->GetLongArrayElements(output_offsets, NULL);
+    layout.returns_integer = (size_t) output_offsets_prim[INTEGER_TYPE];
+    layout.returns_vector = (size_t) output_offsets_prim[VECTOR_TYPE];
+    layout.returns_x87 = (size_t) output_offsets_prim[X87_TYPE];
+    env->ReleaseLongArrayElements(output_offsets, output_offsets_prim, JNI_ABORT);
+
+    layout.buffer_size = env->GetLongField(jlayout, jfID_size);
+
+    return layout;
+}
diff --git a/src/hotspot/cpu/x86/foreign_globals_x86.hpp b/src/hotspot/cpu/x86/foreign_globals_x86.hpp
new file mode 100644
index 0000000000000..ff813e01add75
--- /dev/null
+++ b/src/hotspot/cpu/x86/foreign_globals_x86.hpp
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+#include "asm/macroAssembler.hpp"
+#include "utilities/growableArray.hpp"
+
+#ifndef CPU_X86_VM_FOREIGN_GLOBALS_X86_HPP
+#define CPU_X86_VM_FOREIGN_GLOBALS_X86_HPP
+
+#define __ _masm->
+
+struct VectorRegister {
+  static const size_t VECTOR_MAX_WIDTH_BITS = 512; // AVX-512 (64-byte) vector types
+  static const size_t VECTOR_MAX_WIDTH_BYTES = VECTOR_MAX_WIDTH_BITS / 8;
+  static const size_t VECTOR_MAX_WIDTH_U64S = VECTOR_MAX_WIDTH_BITS / 64;
+  static const size_t VECTOR_MAX_WIDTH_FLOATS = VECTOR_MAX_WIDTH_BITS / 32;
+  static const size_t VECTOR_MAX_WIDTH_DOUBLES = VECTOR_MAX_WIDTH_BITS / 64;
+
+  union {
+    uint8_t bits[VECTOR_MAX_WIDTH_BYTES];
+    uint64_t u64[VECTOR_MAX_WIDTH_U64S];
+    float f[VECTOR_MAX_WIDTH_FLOATS];
+    double d[VECTOR_MAX_WIDTH_DOUBLES];
+  };
+};
+
+struct ABIDescriptor {
+    GrowableArray _integer_argument_registers;
+    GrowableArray _integer_return_registers;
+    GrowableArray _vector_argument_registers;
+    GrowableArray _vector_return_registers;
+    size_t _X87_return_registers_noof;
+
+    GrowableArray _integer_additional_volatile_registers;
+    GrowableArray _vector_additional_volatile_registers;
+
+    int32_t _stack_alignment_bytes;
+    int32_t _shadow_space_bytes;
+
+    bool is_volatile_reg(Register reg) const;
+    bool is_volatile_reg(XMMRegister reg) const;
+};
+
+struct BufferLayout {
+  size_t stack_args_bytes;
+  size_t stack_args;
+  size_t arguments_vector;
+  size_t arguments_integer;
+  size_t arguments_next_pc;
+  size_t returns_vector;
+  size_t returns_integer;
+  size_t returns_x87;
+  size_t buffer_size;
+};
+
+const ABIDescriptor parseABIDescriptor(JNIEnv* env, jobject jabi);
+const BufferLayout parseBufferLayout(JNIEnv* env, jobject jlayout);
+
+#endif // CPU_X86_VM_FOREIGN_GLOBALS_X86_HPP
diff --git a/src/hotspot/cpu/x86/universalNativeInvoker_x86.cpp b/src/hotspot/cpu/x86/universalNativeInvoker_x86.cpp
new file mode 100644
index 0000000000000..c555647b82493
--- /dev/null
+++ b/src/hotspot/cpu/x86/universalNativeInvoker_x86.cpp
@@ -0,0 +1,201 @@
+/*
+ * Copyright (c) 2018, 2019, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+#include "precompiled.hpp"
+#include "asm/macroAssembler.hpp"
+#include "classfile/javaClasses.inline.hpp"
+#include "interpreter/interpreter.hpp"
+#include "interpreter/interpreterRuntime.hpp"
+#include "memory/allocation.inline.hpp"
+#include "memory/resourceArea.hpp"
+#include "include/jvm.h"
+#include "prims/universalNativeInvoker.hpp"
+#include "runtime/javaCalls.hpp"
+#include "runtime/interfaceSupport.inline.hpp"
+#include "logging/log.hpp"
+#include "logging/logStream.hpp"
+#include "oops/arrayOop.inline.hpp"
+#include "runtime/jniHandles.inline.hpp"
+#include "prims/methodHandles.hpp"
+
+void generate_invoke_native(MacroAssembler* _masm, const ABIDescriptor& abi, const BufferLayout& layout) {
+
+#if 0
+  fprintf(stderr, "generate_invoke_native()\n");
+#endif
+
+  /**
+   * invoke_native_stub(struct ShuffleDowncallContext* ctxt) {
+   *   rbx = ctxt;
+   *
+   *   stack = alloca(ctxt->arguments.stack_args_bytes);
+   *
+   *   load_all_registers();
+   *   memcpy(stack, ctxt->arguments.stack_args, arguments.stack_args_bytes);
+   *
+   *   (*ctxt->arguments.next_pc)();
+   *
+   *   store_all_registers();
+   * }
+   */
+
+  __ enter();
+
+  // Put the context pointer in ebx/rbx - it's going to be heavily used below both before and after the call
+  Register ctxt_reg = rbx;
+  Register used_regs[] = { ctxt_reg, rcx, rsi, rdi };
+  GrowableArray preserved_regs;
+
+  for (size_t i = 0; i < sizeof(used_regs)/sizeof(Register); i++) {
+    Register used_reg = used_regs[i];
+    if (!abi.is_volatile_reg(used_reg)) {
+      preserved_regs.push(used_reg);
+    }
+  }
+
+  __ block_comment("init_and_alloc_stack");
+
+  for (int i = 0; i < preserved_regs.length(); i++) {
+    __ push(preserved_regs.at(i));
+  }
+
+  __ movptr(ctxt_reg, c_rarg0); // FIXME c args? or java?
+
+  __ block_comment("allocate_stack");
+  __ movptr(rcx, Address(ctxt_reg, (int) layout.stack_args_bytes));
+  __ subptr(rsp, rcx);
+  __ andptr(rsp, -abi._stack_alignment_bytes);
+
+  // Note: rcx is used below!
+
+
+  __ block_comment("load_arguments");
+
+  __ shrptr(rcx, LogBytesPerWord); // bytes -> words
+  __ movptr(rsi, Address(ctxt_reg, (int) layout.stack_args));
+  __ movptr(rdi, rsp);
+  __ rep_mov();
+
+
+  for (int i = 0; i < abi._vector_argument_registers.length(); i++) {
+    // [1] -> 64 bit -> xmm
+    // [2] -> 128 bit -> xmm
+    // [4] -> 256 bit -> ymm
+    // [8] -> 512 bit -> zmm
+
+    XMMRegister reg = abi._vector_argument_registers.at(i);
+    size_t offs = layout.arguments_vector + i * sizeof(VectorRegister);
+    if (UseAVX >= 3) {
+      __ evmovdqul(reg, Address(ctxt_reg, (int)offs), Assembler::AVX_512bit);
+    } else if (UseAVX >= 1) {
+      __ vmovdqu(reg, Address(ctxt_reg, (int)offs));
+    } else {
+      __ movdqu(reg, Address(ctxt_reg, (int)offs));
+    }
+  }
+
+  for (int i = 0; i < abi._integer_argument_registers.length(); i++) {
+    size_t offs = layout.arguments_integer + i * sizeof(uintptr_t);
+    __ movptr(abi._integer_argument_registers.at(i), Address(ctxt_reg, (int)offs));
+  }
+
+  if (abi._shadow_space_bytes != 0) {
+    __ block_comment("allocate shadow space for argument register spill");
+    __ subptr(rsp, abi._shadow_space_bytes);
+  }
+
+  // call target function
+  __ block_comment("call target function");
+  __ call(Address(ctxt_reg, (int) layout.arguments_next_pc));
+
+  if (abi._shadow_space_bytes != 0) {
+    __ block_comment("pop shadow space");
+    __ addptr(rsp, abi._shadow_space_bytes);
+  }
+
+  __ block_comment("store_registers");
+  for (int i = 0; i < abi._integer_return_registers.length(); i++) {
+    ssize_t offs = layout.returns_integer + i * sizeof(uintptr_t);
+    __ movptr(Address(ctxt_reg, offs), abi._integer_return_registers.at(i));
+  }
+
+  for (int i = 0; i < abi._vector_return_registers.length(); i++) {
+    // [1] -> 64 bit -> xmm
+    // [2] -> 128 bit -> xmm (SSE)
+    // [4] -> 256 bit -> ymm (AVX)
+    // [8] -> 512 bit -> zmm (AVX-512, aka AVX3)
+
+    XMMRegister reg = abi._vector_return_registers.at(i);
+    size_t offs = layout.returns_vector + i * sizeof(VectorRegister);
+    if (UseAVX >= 3) {
+      __ evmovdqul(Address(ctxt_reg, (int)offs), reg, Assembler::AVX_512bit);
+    } else if (UseAVX >= 1) {
+      __ vmovdqu(Address(ctxt_reg, (int)offs), reg);
+    } else {
+      __ movdqu(Address(ctxt_reg, (int)offs), reg);
+    }
+  }
+
+  for (size_t i = 0; i < abi._X87_return_registers_noof; i++) {
+    size_t offs = layout.returns_x87 + i * (sizeof(long double));
+    __ fstp_x(Address(ctxt_reg, (int)offs)); //pop ST(0)
+  }
+
+  // Restore backed up preserved register
+  for (int i = 0; i < preserved_regs.length(); i++) {
+    __ movptr(preserved_regs.at(i), Address(rbp, -(int)(sizeof(uintptr_t) * (i + 1))));
+  }
+
+  __ leave();
+  __ ret(0);
+
+  __ flush();
+}
+
+class ProgrammableInvokerGenerator : public StubCodeGenerator {
+private:
+  const ABIDescriptor* _abi;
+  const BufferLayout* _layout;
+public:
+  ProgrammableInvokerGenerator(CodeBuffer* code, const ABIDescriptor* abi, const BufferLayout* layout)
+   : StubCodeGenerator(code, PrintMethodHandleStubs), _abi(abi), _layout(layout) {}
+
+  void generate() {
+      generate_invoke_native(_masm, *_abi, *_layout);
+  }
+};
+
+jlong ProgrammableInvoker::generate_adapter(JNIEnv* env, jobject jabi, jobject jlayout) {
+    ResourceMark rm;
+    const ABIDescriptor abi = parseABIDescriptor(env, jabi);
+    const BufferLayout layout = parseBufferLayout(env, jlayout);
+
+    BufferBlob* _invoke_native_blob = BufferBlob::create("invoke_native_blob", MethodHandles::adapter_code_size);
+
+    CodeBuffer code2(_invoke_native_blob);
+    ProgrammableInvokerGenerator g2(&code2, &abi, &layout);
+    g2.generate();
+    code2.log_section_sizes("InvokeNativeBlob");
+
+    return (jlong) _invoke_native_blob->code_begin();
+}
diff --git a/src/hotspot/cpu/x86/universalUpcallHandler_x86.cpp b/src/hotspot/cpu/x86/universalUpcallHandler_x86.cpp
new file mode 100644
index 0000000000000..9426d5cdf612a
--- /dev/null
+++ b/src/hotspot/cpu/x86/universalUpcallHandler_x86.cpp
@@ -0,0 +1,242 @@
+/*
+ * Copyright (c) 2018, 2019, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+#include "precompiled.hpp"
+#include "asm/macroAssembler.hpp"
+#include "classfile/javaClasses.inline.hpp"
+#include "interpreter/interpreter.hpp"
+#include "interpreter/interpreterRuntime.hpp"
+#include "memory/allocation.inline.hpp"
+#include "memory/resourceArea.hpp"
+#include "include/jvm.h"
+#include "jni.h"
+#include "prims/universalUpcallHandler.hpp"
+#include "runtime/javaCalls.hpp"
+#include "runtime/interfaceSupport.inline.hpp"
+#include "logging/log.hpp"
+#include "logging/logStream.hpp"
+#include "oops/arrayOop.inline.hpp"
+#include "runtime/jniHandles.inline.hpp"
+#include "classfile/symbolTable.hpp"
+
+extern struct JavaVM_ main_vm;
+
+static struct {
+  bool inited;
+  struct {
+    Klass* klass;
+    Symbol* name;
+    Symbol* sig;
+  } upcall_method;  // jdk.internal.foreign.abi.UniversalUpcallHandler::invoke
+} upcall_info;
+
+// FIXME: This should be initialized explicitly instead of lazily/racily
+static void upcall_init() {
+#if 0
+  fprintf(stderr, "upcall_init()\n");
+#endif
+
+  TRAPS = Thread::current();
+  ResourceMark rm;
+
+  const char* cname = "jdk/internal/foreign/abi/ProgrammableUpcallHandler";
+  const char* mname = "invoke";
+  const char* mdesc = "(Ljdk/internal/foreign/abi/ProgrammableUpcallHandler;J)V";
+  Symbol* cname_sym = SymbolTable::new_symbol(cname, (int)strlen(cname));
+  Symbol* mname_sym = SymbolTable::new_symbol(mname, (int)strlen(mname));
+  Symbol* mdesc_sym = SymbolTable::new_symbol(mdesc, (int)strlen(mdesc));
+
+#if 0
+  ::fprintf(stderr, "cname_sym: %p\n", cname_sym);
+  ::fprintf(stderr, "mname_sym: %p\n", mname_sym);
+  ::fprintf(stderr, "mdesc_sym: %p\n", mdesc_sym);
+#endif
+
+  Klass* k = SystemDictionary::resolve_or_null(cname_sym, THREAD);
+#if 0
+  ::fprintf(stderr, "Klass: %p\n", k);
+#endif
+
+  Method* method = k->lookup_method(mname_sym, mdesc_sym);
+#if 0
+  ::fprintf(stderr, "Method: %p\n", method);
+#endif
+
+  upcall_info.upcall_method.klass = k;
+  upcall_info.upcall_method.name = mname_sym;
+  upcall_info.upcall_method.sig = mdesc_sym;
+
+  upcall_info.inited = true;
+}
+
+static void upcall_helper(jobject rec, address buff) {
+  void *p_env = NULL;
+
+  Thread* thread = Thread::current_or_null();
+  if (thread == NULL) {
+    JavaVM_ *vm = (JavaVM *)(&main_vm);
+    vm -> functions -> AttachCurrentThreadAsDaemon(vm, &p_env, NULL);
+    thread = Thread::current();
+  }
+
+  assert(thread->is_Java_thread(), "really?");
+
+  ThreadInVMfromNative __tiv((JavaThread *)thread);
+
+  if (!upcall_info.inited) {
+    upcall_init();
+  }
+
+  ResourceMark rm;
+  JavaValue result(T_VOID);
+  JavaCallArguments args(2); // long = 2 slots
+
+  args.push_jobject(rec);
+  args.push_long((jlong) buff);
+
+  JavaCalls::call_static(&result, upcall_info.upcall_method.klass, upcall_info.upcall_method.name, upcall_info.upcall_method.sig, &args, thread);
+}
+
+static address generate_upcall_stub(jobject rec, const ABIDescriptor& abi, const BufferLayout& layout) {
+  ResourceMark rm;
+  CodeBuffer buffer("upcall_stub", 1024, 1024);
+
+  MacroAssembler* _masm = new MacroAssembler(&buffer);
+  int stack_alignment_C = 16; // bytes
+  int register_size = sizeof(uintptr_t);
+  int buffer_alignment = sizeof(VectorRegister);
+
+  // stub code
+  __ enter();
+
+  // save pointer to JNI receiver handle into constant segment
+  Address rec_adr = __ as_Address(InternalAddress(__ address_constant((address)rec)));
+
+  __ subptr(rsp, (int) align_up(layout.buffer_size, buffer_alignment));
+
+  Register used[] = { c_rarg0, c_rarg1, rax, rbx, rdi, rsi, r12, r13, r14, r15 };
+  GrowableArray preserved;
+  // TODO need to preserve anything killed by the upcall that is non-volatile, needs XMM regs as well, probably
+  for (size_t i = 0; i < sizeof(used)/sizeof(Register); i++) {
+    Register reg = used[i];
+    if (!abi.is_volatile_reg(reg)) {
+      preserved.push(reg);
+    }
+  }
+
+  int preserved_size = align_up(preserved.length() * register_size, stack_alignment_C); // includes register alignment
+  int buffer_offset = preserved_size; // offset from rsp
+
+  __ subptr(rsp, preserved_size);
+  for (int i = 0; i < preserved.length(); i++) {
+    __ movptr(Address(rsp, i * register_size), preserved.at(i));
+  }
+
+  for (int i = 0; i < abi._integer_argument_registers.length(); i++) {
+    size_t offs = buffer_offset + layout.arguments_integer + i * sizeof(uintptr_t);
+    __ movptr(Address(rsp, (int)offs), abi._integer_argument_registers.at(i));
+  }
+
+  for (int i = 0; i < abi._vector_argument_registers.length(); i++) {
+    XMMRegister reg = abi._vector_argument_registers.at(i);
+    size_t offs = buffer_offset + layout.arguments_vector + i * sizeof(VectorRegister);
+    if (UseAVX >= 3) {
+      __ evmovdqul(Address(rsp, (int)offs), reg, Assembler::AVX_512bit);
+    } else if (UseAVX >= 1) {
+      __ vmovdqu(Address(rsp, (int)offs), reg);
+    } else {
+      __ movdqu(Address(rsp, (int)offs), reg);
+    }
+  }
+
+  // Capture prev stack pointer (stack arguments base)
+#ifndef _WIN64
+  __ lea(rax, Address(rbp, 16)); // skip frame+return address
+#else
+  __ lea(rax, Address(rbp, 16 + 32)); // also skip shadow space
+#endif
+  __ movptr(Address(rsp, buffer_offset + (int) layout.stack_args), rax);
+#ifndef PRODUCT
+  __ movptr(Address(rsp, buffer_offset + (int) layout.stack_args_bytes), -1); // unknown
+#endif
+
+  // Call upcall helper
+
+  __ movptr(c_rarg0, rec_adr);
+  __ lea(c_rarg1, Address(rsp, buffer_offset));
+
+#ifdef _WIN64
+  __ block_comment("allocate shadow space for argument register spill");
+  __ subptr(rsp, 32);
+#endif
+
+  __ call(RuntimeAddress(CAST_FROM_FN_PTR(address, upcall_helper)));
+
+#ifdef _WIN64
+  __ block_comment("pop shadow space");
+  __ addptr(rsp, 32);
+#endif
+
+  for (int i = 0; i < abi._integer_return_registers.length(); i++) {
+    size_t offs = buffer_offset + layout.returns_integer + i * sizeof(uintptr_t);
+    __ movptr(abi._integer_return_registers.at(i), Address(rsp, (int)offs));
+  }
+
+  for (int i = 0; i < abi._vector_return_registers.length(); i++) {
+    XMMRegister reg = abi._vector_return_registers.at(i);
+    size_t offs = buffer_offset + layout.returns_vector + i * sizeof(VectorRegister);
+    if (UseAVX >= 3) {
+      __ evmovdqul(reg, Address(rsp, (int)offs), Assembler::AVX_512bit);
+    } else if (UseAVX >= 1) {
+      __ vmovdqu(reg, Address(rsp, (int)offs));
+    } else {
+      __ movdqu(reg, Address(rsp, (int)offs));
+    }
+  }
+
+  for (size_t i = abi._X87_return_registers_noof; i > 0 ; i--) {
+      ssize_t offs = buffer_offset + layout.returns_x87 + (i - 1) * (sizeof(long double));
+      __ fld_x (Address(rsp, (int)offs));
+  }
+
+  // Restore preserved registers
+  for (int i = 0; i < preserved.length(); i++) {
+    __ movptr(preserved.at(i), Address(rsp, i * register_size));
+  }
+
+  __ leave();
+  __ ret(0);
+
+  _masm->flush();
+
+  BufferBlob* blob = BufferBlob::create("upcall_stub", &buffer);
+
+  return blob->code_begin();
+}
+
+jlong ProgrammableUpcallHandler::generate_upcall_stub(JNIEnv *env, jobject rec, jobject jabi, jobject jlayout) {
+  const ABIDescriptor abi = parseABIDescriptor(env, jabi);
+  const BufferLayout layout = parseBufferLayout(env, jlayout);
+
+  return (jlong) ::generate_upcall_stub(rec, abi, layout);
+}
diff --git a/src/hotspot/share/ci/ciNativeEntryPoint.cpp b/src/hotspot/share/ci/ciNativeEntryPoint.cpp
new file mode 100644
index 0000000000000..5d60fd3c543f2
--- /dev/null
+++ b/src/hotspot/share/ci/ciNativeEntryPoint.cpp
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ *
+ */
+
+#include "precompiled.hpp"
+#include "ci/ciClassList.hpp"
+#include "ci/ciNativeEntryPoint.hpp"
+#include "ci/ciUtilities.inline.hpp"
+#include "ci/ciArray.hpp"
+#include "classfile/javaClasses.hpp"
+#include "oops/oop.inline.hpp"
+#include "memory/allocation.hpp"
+
+VMReg* getVMRegArray(ciArray* array) {
+  assert(array->element_basic_type() == T_LONG, "Unexpected type");
+
+  VMReg* out = NEW_ARENA_ARRAY(CURRENT_ENV->arena(), VMReg, array->length());
+
+  for (int i = 0; i < array->length(); i++) {
+    ciConstant con = array->element_value(i);
+    VMReg reg = VMRegImpl::as_VMReg(con.as_long());
+    out[i] = reg;
+  }
+
+  return out;
+}
+
+ciNativeEntryPoint::ciNativeEntryPoint(instanceHandle h_i) : ciInstance(h_i), _name(NULL) {
+  // Copy name
+  oop name_str = jdk_internal_invoke_NativeEntryPoint::name(get_oop());
+  if (name_str != NULL) {
+    char* temp_name = java_lang_String::as_quoted_ascii(name_str);
+    size_t len = strlen(temp_name) + 1;
+    char* name = (char*)CURRENT_ENV->arena()->Amalloc(len);
+    strncpy(name, temp_name, len);
+    _name = name;
+  }
+
+  _arg_moves = getVMRegArray(CURRENT_ENV->get_object(jdk_internal_invoke_NativeEntryPoint::argMoves(get_oop()))->as_array());
+  _ret_moves = getVMRegArray(CURRENT_ENV->get_object(jdk_internal_invoke_NativeEntryPoint::returnMoves(get_oop()))->as_array());
+}
+
+address ciNativeEntryPoint::entry_point() const {
+  VM_ENTRY_MARK;
+  return jdk_internal_invoke_NativeEntryPoint::addr(get_oop());
+}
+
+jint ciNativeEntryPoint::shadow_space() const {
+  VM_ENTRY_MARK;
+  return jdk_internal_invoke_NativeEntryPoint::shadow_space(get_oop());
+}
+
+VMReg* ciNativeEntryPoint::argMoves() const {
+  return _arg_moves;
+}
+
+VMReg* ciNativeEntryPoint::returnMoves() const {
+  return _ret_moves;
+}
+
+jboolean ciNativeEntryPoint::need_transition() const {
+  VM_ENTRY_MARK;
+  return jdk_internal_invoke_NativeEntryPoint::need_transition(get_oop());
+}
+
+ciMethodType* ciNativeEntryPoint::method_type() const {
+  VM_ENTRY_MARK;
+  return CURRENT_ENV->get_object(jdk_internal_invoke_NativeEntryPoint::method_type(get_oop()))->as_method_type();
+}
+
+const char* ciNativeEntryPoint::name() {
+  return _name;
+}
diff --git a/src/hotspot/share/ci/ciNativeEntryPoint.hpp b/src/hotspot/share/ci/ciNativeEntryPoint.hpp
new file mode 100644
index 0000000000000..21d490b9614bc
--- /dev/null
+++ b/src/hotspot/share/ci/ciNativeEntryPoint.hpp
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ *
+ */
+
+#ifndef SHARE_VM_CI_CINATIVEENTRYPOINT_HPP
+#define SHARE_VM_CI_CINATIVEENTRYPOINT_HPP
+
+#include "ci/ciInstance.hpp"
+#include "ci/ciMethodType.hpp"
+
+#include "code/vmreg.hpp"
+
+// ciNativeEntryPoint
+//
+// The class represents a java.lang.invoke.NativeEntryPoint object.
+class ciNativeEntryPoint : public ciInstance {
+private:
+  const char* _name;
+  VMReg* _arg_moves;
+  VMReg* _ret_moves;
+public:
+  ciNativeEntryPoint(instanceHandle h_i);
+
+  // What kind of ciObject is this?
+  bool is_native_entry_point() const { return true; }
+
+  address        entry_point() const;
+  jint           shadow_space() const;
+  VMReg*         argMoves() const;
+  VMReg*        returnMoves() const;
+  jboolean       need_transition() const;
+  ciMethodType*  method_type() const;
+  const char*    name();
+};
+
+#endif // SHARE_VM_CI_CINATIVEENTRYPOINT_HPP
diff --git a/src/hotspot/share/prims/nativeEntryPoint.cpp b/src/hotspot/share/prims/nativeEntryPoint.cpp
new file mode 100644
index 0000000000000..5dad3be180b81
--- /dev/null
+++ b/src/hotspot/share/prims/nativeEntryPoint.cpp
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ *
+ */
+
+#include "precompiled.hpp"
+#include "runtime/interfaceSupport.inline.hpp"
+#include "code/vmreg.hpp"
+
+JVM_ENTRY(jlong, NEP_vmStorageToVMReg(JNIEnv* env, jclass _unused, jint type, jint index)) {
+  ThreadToNativeFromVM ttnfvm(thread);
+  return VMRegImpl::vmStorageToVMReg(type, index)->value();
+}
+JVM_END
+
+#define CC (char*)  /*cast a literal from (const char*)*/
+#define FN_PTR(f) CAST_FROM_FN_PTR(void*, &f)
+
+static JNINativeMethod NEP_methods[] = {
+  {CC "vmStorageToVMReg", CC "(II)J", FN_PTR(NEP_vmStorageToVMReg)},
+};
+
+JVM_ENTRY(void, JVM_RegisterNativeEntryPointMethods(JNIEnv *env, jclass NEP_class)) {
+  {
+    ThreadToNativeFromVM ttnfv(thread);
+
+    int status = env->RegisterNatives(NEP_class, NEP_methods, sizeof(NEP_methods)/sizeof(JNINativeMethod));
+    guarantee(status == JNI_OK && !env->ExceptionOccurred(),
+              "register jdk.internal.invoke.NativeEntryPoint natives");
+  }
+}
+JVM_END
\ No newline at end of file
diff --git a/src/hotspot/share/prims/universalNativeInvoker.cpp b/src/hotspot/share/prims/universalNativeInvoker.cpp
new file mode 100644
index 0000000000000..0373a9aac3f2e
--- /dev/null
+++ b/src/hotspot/share/prims/universalNativeInvoker.cpp
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+#include "precompiled.hpp"
+#include "code/codeBlob.hpp"
+#include "prims/universalNativeInvoker.hpp"
+#include "runtime/interfaceSupport.inline.hpp"
+#include "runtime/jniHandles.inline.hpp"
+#include "runtime/stubCodeGenerator.hpp"
+#include "prims/methodHandles.hpp"
+
+void ProgrammableInvoker::invoke_native(ProgrammableStub stub, address buff, JavaThread* thread) {
+  {
+    assert(thread->thread_state() == _thread_in_vm, "thread state is: %d", thread->thread_state());
+    ThreadToNativeFromVM ttnfvm(thread);
+    assert(thread->thread_state() == _thread_in_native, "thread state is: %d", thread->thread_state());
+    stub(buff);
+    assert(thread->thread_state() == _thread_in_native, "thread state is: %d", thread->thread_state());
+  }
+  assert(thread->thread_state() == _thread_in_vm, "thread state is: %d", thread->thread_state());
+}
+
+JVM_ENTRY(void, PI_invokeNative(JNIEnv* env, jclass _unused, jlong adapter_stub, jlong buff)) {
+  assert(thread->thread_state() == _thread_in_vm, "thread state is: %d", thread->thread_state());
+  ProgrammableStub stub = (ProgrammableStub) adapter_stub;
+  address c = (address) buff;
+  ProgrammableInvoker::invoke_native(stub, c, thread);
+}
+JVM_END
+
+JVM_ENTRY(jlong, PI_generateAdapter(JNIEnv* env, jclass _unused, jobject abi, jobject layout)) {
+  ThreadToNativeFromVM ttnfvm(thread);
+  return ProgrammableInvoker::generate_adapter(env, abi, layout);
+}
+JVM_END
+
+#define CC (char*)  /*cast a literal from (const char*)*/
+#define FN_PTR(f) CAST_FROM_FN_PTR(void*, &f)
+#define LANG "Ljava/lang/"
+
+#define FOREIGN_ABI "Ljdk/internal/foreign/abi"
+
+static JNINativeMethod PI_methods[] = {
+  {CC "invokeNative",          CC "(JJ)V",           FN_PTR(PI_invokeNative)},
+  {CC "generateAdapter",       CC "(" FOREIGN_ABI "/ABIDescriptor;" FOREIGN_ABI "/BufferLayout;" ")J",           FN_PTR(PI_generateAdapter)}
+};
+
+JVM_ENTRY(void, JVM_RegisterProgrammableInvokerMethods(JNIEnv *env, jclass PI_class)) {
+  {
+    ThreadToNativeFromVM ttnfv(thread);
+
+    int status = env->RegisterNatives(PI_class, PI_methods, sizeof(PI_methods)/sizeof(JNINativeMethod));
+    guarantee(status == JNI_OK && !env->ExceptionOccurred(),
+              "register jdk.internal.foreign.abi.programmable.ProgrammableInvoker natives");
+  }
+}
+JVM_END
diff --git a/src/hotspot/share/prims/universalNativeInvoker.hpp b/src/hotspot/share/prims/universalNativeInvoker.hpp
new file mode 100644
index 0000000000000..b1c9cfecb3657
--- /dev/null
+++ b/src/hotspot/share/prims/universalNativeInvoker.hpp
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2018, 2019, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+#ifndef SHARE_VM_PRIMS_UNIVERSALNATIVEINVOKER_HPP
+#define SHARE_VM_PRIMS_UNIVERSALNATIVEINVOKER_HPP
+
+#include "classfile/javaClasses.hpp"
+#include "classfile/vmSymbols.hpp"
+#include "include/jvm.h"
+#include "runtime/frame.inline.hpp"
+#include "runtime/globals.hpp"
+#include "utilities/macros.hpp"
+#include CPU_HEADER(foreign_globals)
+
+#ifdef ZERO
+# include "entry_zero.hpp"
+#endif
+
+class MacroAssembler;
+class Label;
+class ShuffleRecipe;
+
+typedef void (*ProgrammableStub)(address);
+
+class ProgrammableInvoker: AllStatic {
+public:  
+  static void invoke_native(ProgrammableStub stub, address buff, JavaThread* thread);
+  static jlong generate_adapter(JNIEnv* env, jobject abi, jobject layout);
+};
+
+#endif // SHARE_VM_PRIMS_UNIVERSALNATIVEINVOKER_HPP
diff --git a/src/hotspot/share/prims/universalUpcallHandler.cpp b/src/hotspot/share/prims/universalUpcallHandler.cpp
new file mode 100644
index 0000000000000..b80c57597d252
--- /dev/null
+++ b/src/hotspot/share/prims/universalUpcallHandler.cpp
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+#include "precompiled.hpp"
+#include "prims/universalUpcallHandler.hpp"
+#include "runtime/jniHandles.inline.hpp"
+#include "runtime/interfaceSupport.inline.hpp"
+
+JVM_ENTRY(jlong, PUH_AllocateUpcallStub(JNIEnv *env, jobject rec, jobject abi, jobject buffer_layout))
+  Handle receiver(THREAD, JNIHandles::resolve(rec));
+  jobject global_rec = JNIHandles::make_global(receiver);
+  ThreadToNativeFromVM ttnfvm(thread);
+
+  return ProgrammableUpcallHandler::generate_upcall_stub(env, global_rec, abi, buffer_layout);
+JVM_END
+
+#define CC (char*)  /*cast a literal from (const char*)*/
+#define FN_PTR(f) CAST_FROM_FN_PTR(void*, &f)
+#define LANG "Ljava/lang/"
+
+#define FOREIGN_ABI "Ljdk/internal/foreign/abi"
+
+static JNINativeMethod PUH_methods[] = {
+  {CC "allocateUpcallStub", CC "(" FOREIGN_ABI "/ABIDescriptor;" FOREIGN_ABI "/BufferLayout;" ")J", FN_PTR(PUH_AllocateUpcallStub)},
+};
+
+/**
+ * This one function is exported, used by NativeLookup.
+ */
+JVM_ENTRY(void, JVM_RegisterProgrammableUpcallHandlerMethods(JNIEnv *env, jclass PUH_class)) {
+  {
+    ThreadToNativeFromVM ttnfv(thread);
+
+    int status = env->RegisterNatives(PUH_class, PUH_methods, sizeof(PUH_methods)/sizeof(JNINativeMethod));
+    guarantee(status == JNI_OK && !env->ExceptionOccurred(),
+              "register jdk.internal.foreign.abi.ProgrammableUpcallHandler natives");
+  }
+}
+JVM_END
diff --git a/src/hotspot/share/prims/universalUpcallHandler.hpp b/src/hotspot/share/prims/universalUpcallHandler.hpp
new file mode 100644
index 0000000000000..43710f128fdac
--- /dev/null
+++ b/src/hotspot/share/prims/universalUpcallHandler.hpp
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+#ifndef SHARE_VM_PRIMS_UNIVERSALUPCALLHANDLER_HPP
+#define SHARE_VM_PRIMS_UNIVERSALUPCALLHANDLER_HPP
+
+#include "classfile/javaClasses.hpp"
+#include "classfile/vmSymbols.hpp"
+#include "include/jvm.h"
+#include "runtime/frame.inline.hpp"
+#include "runtime/globals.hpp"
+#include "utilities/macros.hpp"
+#include CPU_HEADER(foreign_globals)
+
+class ProgrammableUpcallHandler : AllStatic {
+public:
+  static jlong generate_upcall_stub(JNIEnv *env, jobject rec, jobject abi, jobject buffer_layout);
+};
+
+#endif // SHARE_VM_PRIMS_UNIVERSALUPCALLHANDLER_HPP
diff --git a/src/hotspot/share/prims/upcallStubs.cpp b/src/hotspot/share/prims/upcallStubs.cpp
new file mode 100644
index 0000000000000..d8ae5f2415d77
--- /dev/null
+++ b/src/hotspot/share/prims/upcallStubs.cpp
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+#include "precompiled.hpp"
+#include "runtime/jniHandles.inline.hpp"
+#include "runtime/interfaceSupport.inline.hpp"
+#include "code/codeCache.hpp"
+
+JVM_ENTRY(static jboolean, UH_FreeUpcallStub0(JNIEnv *env, jobject _unused, jlong addr))
+  //acquire code cache lock
+  MutexLocker mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
+  //find code blob
+  CodeBlob* cb = CodeCache::find_blob((char*)addr);
+  if (cb == NULL) {
+    return false;
+  }
+  //free global JNI handle
+  jobject* rec_ptr = (jobject*)(void*)cb -> content_begin();
+  JNIHandles::destroy_global(*rec_ptr);
+  //free code blob
+  CodeCache::free(cb);
+  return true;
+JVM_END
+
+#define CC (char*)  /*cast a literal from (const char*)*/
+#define FN_PTR(f) CAST_FROM_FN_PTR(void*, &f)
+#define LANG "Ljava/lang/"
+
+// These are the native methods on jdk.internal.foreign.NativeInvoker.
+static JNINativeMethod UH_methods[] = {
+  {CC "freeUpcallStub0",     CC "(J)Z",                FN_PTR(UH_FreeUpcallStub0)}
+};
+
+/**
+ * This one function is exported, used by NativeLookup.
+ */
+JVM_ENTRY(void, JVM_RegisterUpcallHandlerMethods(JNIEnv *env, jclass UH_class)) {
+  {
+    ThreadToNativeFromVM ttnfv(thread);
+
+    int status = env->RegisterNatives(UH_class, UH_methods, sizeof(UH_methods)/sizeof(JNINativeMethod));
+    guarantee(status == JNI_OK && !env->ExceptionOccurred(),
+              "register jdk.internal.foreign.abi.UpcallStubs natives");
+  }
+}
+JVM_END
+
diff --git a/src/java.base/share/classes/java/lang/invoke/NativeMethodHandle.java b/src/java.base/share/classes/java/lang/invoke/NativeMethodHandle.java
new file mode 100644
index 0000000000000..e130b5c3c9538
--- /dev/null
+++ b/src/java.base/share/classes/java/lang/invoke/NativeMethodHandle.java
@@ -0,0 +1,170 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang.invoke;
+
+import jdk.internal.vm.annotation.ForceInline;
+import jdk.internal.invoke.NativeEntryPoint;
+
+import static java.lang.invoke.LambdaForm.*;
+import static java.lang.invoke.MethodHandleNatives.Constants.LM_TRUSTED;
+import static java.lang.invoke.MethodHandleNatives.Constants.REF_invokeStatic;
+import static java.lang.invoke.MethodHandleStatics.newInternalError;
+
+/** TODO */
+/*non-public*/ class NativeMethodHandle extends MethodHandle {
+    final NativeEntryPoint nep;
+    final MethodHandle fallback;
+
+    /**
+     * TODO
+     */
+    private NativeMethodHandle(MethodType type, LambdaForm form, MethodHandle fallback, NativeEntryPoint nep) {
+        super(type, form);
+        this.fallback = fallback;
+        this.nep = nep;
+    }
+
+    /** TODO */
+    public static MethodHandle make(NativeEntryPoint nep, MethodHandle fallback) {
+        MethodType type = nep.type();
+        if (!allTypesPrimitive(type))
+            throw new IllegalArgumentException("Type must only contain primitives: " + type);
+
+        if (type != fallback.type())
+            throw new IllegalArgumentException("Type of fallback must match");
+
+        LambdaForm lform = preparedLambdaForm(type);
+        return new NativeMethodHandle(type, lform, fallback, nep);
+    }
+
+    private static boolean allTypesPrimitive(MethodType type) {
+        if (!type.returnType().isPrimitive())
+            return false;
+
+        for (Class pType : type.parameterArray()) {
+            if (!pType.isPrimitive())
+                return false;
+        }
+
+        return true;
+    }
+
+    private static final MemberName.Factory IMPL_NAMES = MemberName.getFactory();
+
+    private static LambdaForm preparedLambdaForm(MethodType mtype) {
+        int id = MethodTypeForm.LF_INVNATIVE;
+        mtype = mtype.basicType();
+        LambdaForm lform = mtype.form().cachedLambdaForm(id);
+        if (lform != null) return lform;
+        lform = makePreparedLambdaForm(mtype);
+        return mtype.form().setCachedLambdaForm(id, lform);
+    }
+
+    private static LambdaForm makePreparedLambdaForm(MethodType mtype) {
+        MethodType linkerType = mtype.insertParameterTypes(0, MethodHandle.class)
+                .appendParameterTypes(Object.class);
+        MemberName linker = new MemberName(MethodHandle.class, "linkToNative", linkerType, REF_invokeStatic);
+        try {
+            linker = IMPL_NAMES.resolveOrFail(REF_invokeStatic, linker, null, LM_TRUSTED, NoSuchMethodException.class);
+        } catch (ReflectiveOperationException ex) {
+            throw newInternalError(ex);
+        }
+        final int NMH_THIS = 0;
+        final int ARG_BASE = 1;
+        final int ARG_LIMIT = ARG_BASE + mtype.parameterCount();
+        int nameCursor = ARG_LIMIT;
+        final int GET_FALLBACK = nameCursor++;
+        final int GET_NEP = nameCursor++;
+        final int LINKER_CALL = nameCursor++;
+        LambdaForm.Name[] names = arguments(nameCursor - ARG_LIMIT, mtype.invokerType());
+        assert (names.length == nameCursor);
+        names[GET_FALLBACK] = new LambdaForm.Name(Lazy.NF_internalFallback, names[NMH_THIS]);
+        names[GET_NEP] = new LambdaForm.Name(Lazy.NF_internalNativeEntryPoint, names[NMH_THIS]);
+        Object[] outArgs = new Object[linkerType.parameterCount()];
+        // Need to pass fallback here so we can call it without destroying the receiver register!!
+        outArgs[0] = names[GET_FALLBACK];
+        System.arraycopy(names, ARG_BASE, outArgs, 1, mtype.parameterCount());
+        outArgs[outArgs.length - 1] = names[GET_NEP];
+        names[LINKER_CALL] = new LambdaForm.Name(linker, outArgs);
+        LambdaForm lform = new LambdaForm(ARG_LIMIT, names, LAST_RESULT);
+        // This is a tricky bit of code.  Don't send it through the LF interpreter.
+        lform.compileToBytecode();
+        return lform;
+    }
+
+    final
+    @Override
+    MethodHandle copyWith(MethodType mt, LambdaForm lf) {
+        assert (this.getClass() == NativeMethodHandle.class);  // must override in subclasses
+        return new NativeMethodHandle(mt, lf, fallback, nep);
+    }
+
+    @Override
+    BoundMethodHandle rebind() {
+        return BoundMethodHandle.makeReinvoker(this);
+    }
+
+    @ForceInline
+    static Object internalNativeEntryPoint(Object mh) {
+        return ((NativeMethodHandle)mh).nep;
+    }
+
+    @ForceInline
+    static MethodHandle internalFallback(Object mh) {
+        return ((NativeMethodHandle)mh).fallback;
+    }
+
+    /**
+     * Pre-initialized NamedFunctions for bootstrapping purposes.
+     * Factored in an inner class to delay initialization until first usage.
+     */
+    private static class Lazy {
+        static Class THIS_CLASS = NativeMethodHandle.class;
+
+        static final NamedFunction
+                NF_internalNativeEntryPoint;
+        static final NamedFunction
+                NF_internalFallback;
+
+        static {
+            try {
+                NamedFunction[] nfs = new NamedFunction[]{
+                        NF_internalNativeEntryPoint = new NamedFunction(
+                                THIS_CLASS.getDeclaredMethod("internalNativeEntryPoint", Object.class)),
+                        NF_internalFallback = new NamedFunction(
+                                THIS_CLASS.getDeclaredMethod("internalFallback", Object.class))
+                };
+                for (NamedFunction nf : nfs) {
+                    // Each nf must be statically invocable or we get tied up in our bootstraps.
+                    assert (InvokerBytecodeGenerator.isStaticallyInvocable(nf.member)) : nf;
+                    nf.resolve();
+                }
+            } catch (ReflectiveOperationException ex) {
+                throw newInternalError(ex);
+            }
+        }
+    }
+}
diff --git a/src/java.base/share/classes/jdk/internal/access/foreign/NativeLibraryProxy.java b/src/java.base/share/classes/jdk/internal/access/foreign/NativeLibraryProxy.java
new file mode 100644
index 0000000000000..dcd22833adb88
--- /dev/null
+++ b/src/java.base/share/classes/jdk/internal/access/foreign/NativeLibraryProxy.java
@@ -0,0 +1,31 @@
+/*
+ *  Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
+ *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ *  This code is free software; you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License version 2 only, as
+ *  published by the Free Software Foundation.  Oracle designates this
+ *  particular file as subject to the "Classpath" exception as provided
+ *  by Oracle in the LICENSE file that accompanied this code.
+ *
+ *  This code 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
+ *  version 2 for more details (a copy is included in the LICENSE file that
+ *  accompanied this code).
+ *
+ *  You should have received a copy of the GNU General Public License version
+ *  2 along with this work; if not, write to the Free Software Foundation,
+ *  Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ *   Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ *  or visit www.oracle.com if you need additional information or have any
+ *  questions.
+ *
+ */
+
+package jdk.internal.access.foreign;
+
+public interface NativeLibraryProxy {
+    long lookup(String name) throws NoSuchMethodException;
+}
diff --git a/src/java.base/share/classes/jdk/internal/invoke/ABIDescriptorProxy.java b/src/java.base/share/classes/jdk/internal/invoke/ABIDescriptorProxy.java
new file mode 100644
index 0000000000000..869b22dcd761a
--- /dev/null
+++ b/src/java.base/share/classes/jdk/internal/invoke/ABIDescriptorProxy.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package jdk.internal.invoke;
+
+public interface ABIDescriptorProxy {
+    int shadowSpaceBytes();
+}
diff --git a/src/java.base/share/classes/jdk/internal/invoke/NativeEntryPoint.java b/src/java.base/share/classes/jdk/internal/invoke/NativeEntryPoint.java
new file mode 100644
index 0000000000000..0cbab48bce5aa
--- /dev/null
+++ b/src/java.base/share/classes/jdk/internal/invoke/NativeEntryPoint.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package jdk.internal.invoke;
+
+import java.lang.invoke.MethodType;
+import java.util.Objects;
+
+/** TODO */
+public class NativeEntryPoint {
+    static {
+        registerNatives();
+    }
+
+    private final long addr;
+
+    private final int shadowSpace;
+
+    // encoded as VMRegImpl*
+    private final long[] argMoves;
+    private final long[] returnMoves;
+
+    private final boolean needTransition;
+    private final MethodType methodType; // C2 sees erased version (byte -> int), so need this explicitly
+    private final String name;
+
+    private NativeEntryPoint(long addr, int shadowSpace, long[] argMoves, long[] returnMoves,
+                     boolean needTransition, MethodType methodType, String name) {
+        this.addr = addr;
+        this.shadowSpace = shadowSpace;
+        this.argMoves = Objects.requireNonNull(argMoves);
+        this.returnMoves = Objects.requireNonNull(returnMoves);
+        this.needTransition = needTransition;
+        this.methodType = methodType;
+        this.name = name;
+    }
+
+    public static NativeEntryPoint make(long addr, String name, ABIDescriptorProxy abi, VMStorageProxy[] argMoves, VMStorageProxy[] returnMoves,
+                                        boolean needTransition, MethodType methodType) {
+        if (returnMoves.length > 1) {
+            throw new IllegalArgumentException("Multiple register return not supported");
+        }
+
+        return new NativeEntryPoint(
+            addr, abi.shadowSpaceBytes(), encodeVMStorages(argMoves), encodeVMStorages(returnMoves), needTransition, methodType, name);
+    }
+
+    private static long[] encodeVMStorages(VMStorageProxy[] moves) {
+        long[] out = new long[moves.length];
+        for (int i = 0; i < moves.length; i++) {
+            out[i] = vmStorageToVMReg(moves[i].type(), moves[i].index());
+        }
+        return out;
+    }
+
+    private static native long vmStorageToVMReg(int type, int index);
+
+    public MethodType type() {
+        return methodType;
+    }
+
+    private static native void registerNatives();
+}
diff --git a/src/java.base/share/classes/jdk/internal/invoke/VMStorageProxy.java b/src/java.base/share/classes/jdk/internal/invoke/VMStorageProxy.java
new file mode 100644
index 0000000000000..9f44356e41115
--- /dev/null
+++ b/src/java.base/share/classes/jdk/internal/invoke/VMStorageProxy.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package jdk.internal.invoke;
+
+public interface VMStorageProxy {
+    int type();
+    int index();
+}
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/CLinker.java b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/CLinker.java
new file mode 100644
index 0000000000000..b365616012bdb
--- /dev/null
+++ b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/CLinker.java
@@ -0,0 +1,794 @@
+/*
+ *  Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ *  This code is free software; you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License version 2 only, as
+ *  published by the Free Software Foundation.  Oracle designates this
+ *  particular file as subject to the "Classpath" exception as provided
+ *  by Oracle in the LICENSE file that accompanied this code.
+ *
+ *  This code 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
+ *  version 2 for more details (a copy is included in the LICENSE file that
+ *  accompanied this code).
+ *
+ *  You should have received a copy of the GNU General Public License version
+ *  2 along with this work; if not, write to the Free Software Foundation,
+ *  Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ *   Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ *  or visit www.oracle.com if you need additional information or have any
+ *  questions.
+ *
+ */
+package jdk.incubator.foreign;
+
+import jdk.internal.foreign.NativeMemorySegmentImpl;
+import jdk.internal.foreign.PlatformLayouts;
+import jdk.internal.foreign.Utils;
+import jdk.internal.foreign.abi.SharedUtils;
+
+import java.lang.constant.Constable;
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodType;
+import java.nio.charset.Charset;
+import java.util.Objects;
+import java.util.function.Consumer;
+
+import static jdk.internal.foreign.PlatformLayouts.*;
+
+/**
+ * A C linker implements the C Application Binary Interface (ABI) calling conventions.
+ * Instances of this interface can be used to link foreign functions in native libraries that
+ * follow the JVM's target platform C ABI.
+ * 

+ * Linking a foreign function is a process which requires two components: a method type, and
+ * a function descriptor. The method type, consists of a set of carrier types, which, together,
+ * specify the Java signature which clients must adhere to when calling the underlying foreign function.
+ * The function descriptor contains a set of memory layouts which, together, specify the foreign function
+ * signature and classification information (via a custom layout attributes, see {@link TypeKind}), so that linking can take place.
+ * 

+ * Clients of this API can build function descriptors using the predefined memory layout constants
+ * (based on a subset of the built-in types provided by the C language), found in this interface; alternatively,
+ * they can also decorate existing value layouts using the required {@link TypeKind} classification attribute
+ * (this can be done using the {@link MemoryLayout#withAttribute(String, Constable)} method). A failure to do so might
+ * result in linkage errors, given that linking requires additional classification information to determine, for instance,
+ * how arguments should be loaded into registers during a foreign function call.
+ * 

+ * Implementations of this interface support the following primitive carrier types:
+ * {@code byte}, {@code short}, {@code char}, {@code int}, {@code long}, {@code float},
+ * and {@code double}, as well as {@link MemoryAddress} for passing pointers, and
+ * {@link MemorySegment} for passing structs and unions. Finally, the {@link VaList}
+ * carrier type can be used to match the native {@code va_list} type.
+ * 

+ * For the linking process to be successful, some requirements must be satisfied; if {@code M} and {@code F} are
+ * the method type and the function descriptor, respectively, used during the linking process, then it must be that:
+ * 
    
+ *     
  • The arity of {@code M} is the same as that of {@code F};
    • 
+ *     
  • If the return type of {@code M} is {@code void}, then {@code F} should have no return layout
+ *     (see {@link FunctionDescriptor#ofVoid(MemoryLayout...)});
    • 
+ *     
  • for each pair of carrier type {@code C} and layout {@code L} in {@code M} and {@code F}, respectively,
+ *     where {@code C} and {@code L} refer to the same argument, or to the return value, the following conditions must hold:
+ *     
      
+ *       
    • If {@code C} is a primitve type, then {@code L} must be a {@code ValueLayout}, and the size of the layout must match
+ *       that of the carrier type (see {@link Integer#SIZE} and similar fields in other primitive wrapper classes);
      • 
+ *       
    • If {@code C} is {@code MemoryAddress.class}, then {@code L} must be a {@code ValueLayout}, and its size must match
+ *       the platform's address size (see {@link MemoryLayouts#ADDRESS}). For this purpose, the {@link CLinker#C_POINTER} layout
+ *       constant can  be used;
      • 
+ *       
    • If {@code C} is {@code MemorySegment.class}, then {@code L} must be a {@code GroupLayout}
      • 
+ *       
    • If {@code C} is {@code VaList.class}, then {@code L} must be {@link CLinker#C_VA_LIST}
      • 
+ *     
    
+ *     
    • 
+ * 

+ *
+ * 
Variadic functions, declared in C either with a trailing ellipses ({@code ...}) at the end of the formal parameter
+ * list or with an empty formal parameter list, are not supported directly. It is not possible to create a method handle
+ * that takes a variable number of arguments, and neither is it possible to create an upcall stub wrapping a method
+ * handle that accepts a variable number of arguments. However, for downcalls only, it is possible to link a native
+ * variadic function by using a specialized method type and function descriptor: for each argument that is to be
+ * passed as a variadic argument, an explicit, additional, carrier type and memory layout must be present in the method type and
+ * function descriptor objects passed to the linker. Furthermore, as memory layouts corresponding to variadic arguments in
+ * a function descriptor must contain additional classification information, it is required that
+ * {@link #asVarArg(MemoryLayout)} is used to create the memory layouts for each parameter corresponding to a variadic
+ * argument in a specialized function descriptor.
+ *
+ * @apiNote In the future, if the Java language permits, {@link CLinker}
+ * may become a {@code sealed} interface, which would prohibit subclassing except by
+ * explicitly permitted types.
+ *
+ * @implSpec
+ * Implementations of this interface are immutable, thread-safe and value-based.
+ */
+public interface CLinker {
+
+    /**
+     * Returns the C linker for the current platform.
+     * 

+     * This method is restricted. Restricted method are unsafe, and, if used incorrectly, their use might crash
+     * the JVM or, worse, silently result in memory corruption. Thus, clients should refrain from depending on
+     * restricted methods, and use safe and supported functionalities, where possible.
+     * @return a linker for this system.
+     * @throws IllegalAccessError if the runtime property {@code foreign.restricted} is not set to either
+     * {@code permit}, {@code warn} or {@code debug} (the default value is set to {@code deny}).
+     */
+    static CLinker getInstance() {
+        Utils.checkRestrictedAccess("CLinker.getInstance");
+        return SharedUtils.getSystemLinker();
+    }
+
+    /**
+     * Obtain a foreign method handle, with given type, which can be used to call a
+     * target foreign function at a given address and featuring a given function descriptor.
+     *
+     * @param symbol   downcall symbol.
+     * @param type     the method type.
+     * @param function the function descriptor.
+     * @return the downcall method handle.
+     * @throws IllegalArgumentException in the case of a carrier type and memory layout mismatch.
+     */
+    MethodHandle downcallHandle(Addressable symbol, MethodType type, FunctionDescriptor function);
+
+    /**
+     * Allocates a native segment whose base address (see {@link MemorySegment#address}) can be
+     * passed to other foreign functions (as a function pointer); calling such a function pointer
+     * from native code will result in the execution of the provided method handle.
+     *
+     * 
The returned segment is not thread-confined, and it only features
+     * the {@link MemorySegment#CLOSE} access mode. When the returned segment is closed,
+     * the corresponding native stub will be deallocated.

+     *
+     * @param target   the target method handle.
+     * @param function the function descriptor.
+     * @return the native stub segment.
+     * @throws IllegalArgumentException in the case of a carrier type and memory layout mismatch.
+     */
+    MemorySegment upcallStub(MethodHandle target, FunctionDescriptor function);
+
+    /**
+     * The layout for the {@code char} C type
+     */
+    ValueLayout C_CHAR = pick(SysV.C_CHAR, Win64.C_CHAR, AArch64.C_CHAR);
+    /**
+     * The layout for the {@code short} C type
+     */
+    ValueLayout C_SHORT = pick(SysV.C_SHORT, Win64.C_SHORT, AArch64.C_SHORT);
+    /**
+     * The layout for the {@code int} C type
+     */
+    ValueLayout C_INT = pick(SysV.C_INT, Win64.C_INT, AArch64.C_INT);
+    /**
+     * The layout for the {@code long} C type
+     */
+    ValueLayout C_LONG = pick(SysV.C_LONG, Win64.C_LONG, AArch64.C_LONG);
+    /**
+     * The {@code long long} native type.
+     */
+    ValueLayout C_LONGLONG = pick(SysV.C_LONGLONG, Win64.C_LONGLONG, AArch64.C_LONGLONG);
+    /**
+     * The layout for the {@code float} C type
+     */
+    ValueLayout C_FLOAT = pick(SysV.C_FLOAT, Win64.C_FLOAT, AArch64.C_FLOAT);
+    /**
+     * The layout for the {@code double} C type
+     */
+    ValueLayout C_DOUBLE = pick(SysV.C_DOUBLE, Win64.C_DOUBLE, AArch64.C_DOUBLE);
+    /**
+     * The {@code long double} native type.
+     */
+    ValueLayout C_LONGDOUBLE = pick(SysV.C_LONGDOUBLE, Win64.C_LONGDOUBLE, AArch64.C_LONGDOUBLE);
+    /**
+     * The {@code T*} native type.
+     */
+    ValueLayout C_POINTER = pick(SysV.C_POINTER, Win64.C_POINTER, AArch64.C_POINTER);
+    /**
+     * The layout for the {@code va_list} C type
+     */
+    MemoryLayout C_VA_LIST = pick(SysV.C_VA_LIST, Win64.C_VA_LIST, AArch64.C_VA_LIST);
+
+    /**
+     * Returns a memory layout that is suitable to use the layout for variadic arguments.
+     * @param  the memory layout type
+     * @param ml the layout the adapt
+     * @return a potentially newly created layout with the right attributes
+     */
+    @SuppressWarnings("unchecked")
+    static  T asVarArg(T ml) {
+        return (T) PlatformLayouts.asVarArg(ml);
+    }
+
+        /**
+     * Convert a Java string into a null-terminated C string, using the
+     * platform's default charset, storing the result into a new native memory segment.
+     * 

+     * This method always replaces malformed-input and unmappable-character
+     * sequences with this charset's default replacement byte array.  The
+     * {@link java.nio.charset.CharsetEncoder} class should be used when more
+     * control over the encoding process is required.
+     *
+     * @param str the Java string to be converted into a C string.
+     * @return a new native memory segment containing the converted C string.
+     * @throws NullPointerException if either {@code str == null}.
+     */
+    static MemorySegment toCString(String str) {
+        Objects.requireNonNull(str);
+        return toCString(str.getBytes());
+    }
+
+    /**
+     * Convert a Java string into a null-terminated C string, using the given {@linkplain java.nio.charset.Charset charset},
+     * storing the result into a new native memory segment.
+     * 

+     * This method always replaces malformed-input and unmappable-character
+     * sequences with this charset's default replacement byte array.  The
+     * {@link java.nio.charset.CharsetEncoder} class should be used when more
+     * control over the encoding process is required.
+     *
+     * @param str the Java string to be converted into a C string.
+     * @param charset The {@linkplain java.nio.charset.Charset} to be used to compute the contents of the C string.
+     * @return a new native memory segment containing the converted C string.
+     * @throws NullPointerException if either {@code str == null} or {@code charset == null}.
+     */
+    static MemorySegment toCString(String str, Charset charset) {
+        Objects.requireNonNull(str);
+        Objects.requireNonNull(charset);
+        return toCString(str.getBytes(charset));
+    }
+
+    /**
+     * Convert a Java string into a null-terminated C string, using the platform's default charset,
+     * storing the result into a native memory segment allocated using the provided scope.
+     * 

+     * This method always replaces malformed-input and unmappable-character
+     * sequences with this charset's default replacement byte array.  The
+     * {@link java.nio.charset.CharsetEncoder} class should be used when more
+     * control over the encoding process is required.
+     *
+     * @param str the Java string to be converted into a C string.
+     * @param scope the scope to be used for the native segment allocation.
+     * @return a new native memory segment containing the converted C string.
+     * @throws NullPointerException if either {@code str == null} or {@code scope == null}.
+     */
+    static MemorySegment toCString(String str, NativeScope scope) {
+        Objects.requireNonNull(str);
+        Objects.requireNonNull(scope);
+        return toCString(str.getBytes(), scope);
+    }
+
+    /**
+     * Convert a Java string into a null-terminated C string, using the given {@linkplain java.nio.charset.Charset charset},
+     * storing the result into a new native memory segment native memory segment allocated using the provided scope.
+     * 

+     * This method always replaces malformed-input and unmappable-character
+     * sequences with this charset's default replacement byte array.  The
+     * {@link java.nio.charset.CharsetEncoder} class should be used when more
+     * control over the encoding process is required.
+     *
+     * @param str the Java string to be converted into a C string.
+     * @param charset The {@linkplain java.nio.charset.Charset} to be used to compute the contents of the C string.
+     * @param scope the scope to be used for the native segment allocation.
+     * @return a new native memory segment containing the converted C string.
+     * @throws NullPointerException if either {@code str == null}, {@code charset == null} or {@code scope == null}.
+     */
+    static MemorySegment toCString(String str, Charset charset, NativeScope scope) {
+        Objects.requireNonNull(str);
+        Objects.requireNonNull(charset);
+        Objects.requireNonNull(scope);
+        return toCString(str.getBytes(charset), scope);
+    }
+
+    /**
+     * Convert a null-terminated C string stored at given address into a Java string, using the platform's default charset.
+     * 

+     * This method always replaces malformed-input and unmappable-character
+     * sequences with this charset's default replacement string.  The {@link
+     * java.nio.charset.CharsetDecoder} class should be used when more control
+     * over the decoding process is required.
+     * 

+     * This method is restricted. Restricted method are unsafe, and, if used incorrectly, their use might crash
+     * the JVM or, worse, silently result in memory corruption. Thus, clients should refrain from depending on
+     * restricted methods, and use safe and supported functionalities, where possible.
+     * @param addr the address at which the string is stored.
+     * @return a Java string with the contents of the null-terminated C string at given address.
+     * @throws NullPointerException if {@code addr == null}
+     * @throws IllegalArgumentException if the size of the native string is greater than {@code Integer.MAX_VALUE}.
+     */
+    static String toJavaStringRestricted(MemoryAddress addr) {
+        Utils.checkRestrictedAccess("CLinker.toJavaStringRestricted");
+        return SharedUtils.toJavaStringInternal(NativeMemorySegmentImpl.EVERYTHING, addr.toRawLongValue(), Charset.defaultCharset());
+    }
+
+    /**
+     * Convert a null-terminated C string stored at given address into a Java string, using the given {@linkplain java.nio.charset.Charset charset}.
+     * 

+     * This method always replaces malformed-input and unmappable-character
+     * sequences with this charset's default replacement string.  The {@link
+     * java.nio.charset.CharsetDecoder} class should be used when more control
+     * over the decoding process is required.
+     * 

+     * This method is restricted. Restricted method are unsafe, and, if used incorrectly, their use might crash
+     * the JVM or, worse, silently result in memory corruption. Thus, clients should refrain from depending on
+     * restricted methods, and use safe and supported functionalities, where possible.
+     * @param addr the address at which the string is stored.
+     * @param charset The {@linkplain java.nio.charset.Charset} to be used to compute the contents of the Java string.
+     * @return a Java string with the contents of the null-terminated C string at given address.
+     * @throws NullPointerException if {@code addr == null}
+     * @throws IllegalArgumentException if the size of the native string is greater than {@code Integer.MAX_VALUE}.
+     */
+    static String toJavaStringRestricted(MemoryAddress addr, Charset charset) {
+        Utils.checkRestrictedAccess("CLinker.toJavaStringRestricted");
+        return SharedUtils.toJavaStringInternal(NativeMemorySegmentImpl.EVERYTHING, addr.toRawLongValue(), charset);
+    }
+
+    /**
+     * Convert a null-terminated C string stored at given address into a Java string, using the platform's default charset.
+     * 

+     * This method always replaces malformed-input and unmappable-character
+     * sequences with this charset's default replacement string.  The {@link
+     * java.nio.charset.CharsetDecoder} class should be used when more control
+     * over the decoding process is required.
+     * @param addr the address at which the string is stored.
+     * @return a Java string with the contents of the null-terminated C string at given address.
+     * @throws NullPointerException if {@code addr == null}
+     * @throws IllegalArgumentException if the size of the native string is greater than {@code Integer.MAX_VALUE}.
+     * @throws IllegalStateException if the size of the native string is greater than the size of the segment
+     * associated with {@code addr}, or if {@code addr} is associated with a segment that is not alive.
+     */
+    static String toJavaString(MemorySegment addr) {
+        return SharedUtils.toJavaStringInternal(addr, 0L, Charset.defaultCharset());
+    }
+
+    /**
+     * Convert a null-terminated C string stored at given address into a Java string, using the given {@linkplain java.nio.charset.Charset charset}.
+     * 

+     * This method always replaces malformed-input and unmappable-character
+     * sequences with this charset's default replacement string.  The {@link
+     * java.nio.charset.CharsetDecoder} class should be used when more control
+     * over the decoding process is required.
+     * @param addr the address at which the string is stored.
+     * @param charset The {@linkplain java.nio.charset.Charset} to be used to compute the contents of the Java string.
+     * @return a Java string with the contents of the null-terminated C string at given address.
+     * @throws NullPointerException if {@code addr == null}
+     * @throws IllegalArgumentException if the size of the native string is greater than {@code Integer.MAX_VALUE}.
+     * @throws IllegalStateException if the size of the native string is greater than the size of the segment
+     * associated with {@code addr}, or if {@code addr} is associated with a segment that is not alive.
+     */
+    static String toJavaString(MemorySegment addr, Charset charset) {
+        return SharedUtils.toJavaStringInternal(addr, 0L, charset);
+    }
+
+    private static void copy(MemorySegment addr, byte[] bytes) {
+        var heapSegment = MemorySegment.ofArray(bytes);
+        addr.copyFrom(heapSegment);
+        MemoryAccess.setByteAtOffset(addr, bytes.length, (byte)0);
+    }
+
+    private static MemorySegment toCString(byte[] bytes) {
+        MemorySegment segment = MemorySegment.allocateNative(bytes.length + 1, 1L);
+        copy(segment, bytes);
+        return segment;
+    }
+
+    private static MemorySegment toCString(byte[] bytes, NativeScope scope) {
+        MemorySegment addr = scope.allocate(bytes.length + 1, 1L);
+        copy(addr, bytes);
+        return addr;
+    }
+
+    /**
+     * Allocate memory of given size using malloc.
+     * 

+     * This method is restricted. Restricted method are unsafe, and, if used incorrectly, their use might crash
+     * the JVM or, worse, silently result in memory corruption. Thus, clients should refrain from depending on
+     * restricted methods, and use safe and supported functionalities, where possible.
+     *
+     * @param size memory size to be allocated
+     * @return addr memory address of the allocated memory
+     */
+    static MemoryAddress allocateMemoryRestricted(long size) {
+        Utils.checkRestrictedAccess("CLinker.allocateMemoryRestricted");
+        return SharedUtils.allocateMemoryInternal(size);
+    }
+
+    /**
+     * Free the memory pointed by the given memory address.
+     * 

+     * This method is restricted. Restricted method are unsafe, and, if used incorrectly, their use might crash
+     * the JVM or, worse, silently result in memory corruption. Thus, clients should refrain from depending on
+     * restricted methods, and use safe and supported functionalities, where possible.
+     *
+     * @param addr memory address of the native memory to be freed
+     */
+    static void freeMemoryRestricted(MemoryAddress addr) {
+        Utils.checkRestrictedAccess("CLinker.freeMemoryRestricted");
+        SharedUtils.freeMemoryInternal(addr);
+    }
+
+    /**
+     * An interface that models a C {@code va_list}.
+     * 

+     * A va list is a stateful cursor used to iterate over a set of variadic arguments.
+     * 

+     * Per the C specification (see C standard 6.5.2.2 Function calls - item 6),
+     * arguments to variadic calls are erased by way of 'default argument promotions',
+     * which erases integral types by way of integer promotion (see C standard 6.3.1.1 - item 2),
+     * and which erases all {@code float} arguments to {@code double}.
+     * 

+     * As such, this interface only supports reading {@code int}, {@code double},
+     * and any other type that fits into a {@code long}.
+     *
+     * @apiNote In the future, if the Java language permits, {@link VaList}
+     * may become a {@code sealed} interface, which would prohibit subclassing except by
+     * explicitly permitted types.
+     *
+     */
+    interface VaList extends Addressable, AutoCloseable {
+
+        /**
+         * Reads the next value as an {@code int} and advances this va list's position.
+         *
+         * @param layout the layout of the value
+         * @return the value read as an {@code int}
+         * @throws IllegalStateException if the C {@code va_list} associated with this instance is no longer valid
+         * (see {@link #close()}).
+         * @throws IllegalArgumentException if the given memory layout is not compatible with {@code int}
+         */
+        int vargAsInt(MemoryLayout layout);
+
+        /**
+         * Reads the next value as a {@code long} and advances this va list's position.
+         *
+         * @param layout the layout of the value
+         * @return the value read as an {@code long}
+         * @throws IllegalStateException if the C {@code va_list} associated with this instance is no longer valid
+         * (see {@link #close()}).
+         * @throws IllegalArgumentException if the given memory layout is not compatible with {@code long}
+         */
+        long vargAsLong(MemoryLayout layout);
+
+        /**
+         * Reads the next value as a {@code double} and advances this va list's position.
+         *
+         * @param layout the layout of the value
+         * @return the value read as an {@code double}
+         * @throws IllegalStateException if the C {@code va_list} associated with this instance is no longer valid
+         * (see {@link #close()}).
+         * @throws IllegalArgumentException if the given memory layout is not compatible with {@code double}
+         */
+        double vargAsDouble(MemoryLayout layout);
+
+        /**
+         * Reads the next value as a {@code MemoryAddress} and advances this va list's position.
+         *
+         * @param layout the layout of the value
+         * @return the value read as an {@code MemoryAddress}
+         * @throws IllegalStateException if the C {@code va_list} associated with this instance is no longer valid
+         * (see {@link #close()}).
+         * @throws IllegalArgumentException if the given memory layout is not compatible with {@code MemoryAddress}
+         */
+        MemoryAddress vargAsAddress(MemoryLayout layout);
+
+        /**
+         * Reads the next value as a {@code MemorySegment}, and advances this va list's position.
+         * 

+         * The memory segment returned by this method will be allocated using
+         * {@link MemorySegment#allocateNative(long, long)}, and will have to be closed separately.
+         *
+         * @param layout the layout of the value
+         * @return the value read as an {@code MemorySegment}
+         * @throws IllegalStateException if the C {@code va_list} associated with this instance is no longer valid
+         * (see {@link #close()}).
+         * @throws IllegalArgumentException if the given memory layout is not compatible with {@code MemorySegment}
+         */
+        MemorySegment vargAsSegment(MemoryLayout layout);
+
+        /**
+         * Reads the next value as a {@code MemorySegment}, and advances this va list's position.
+         * 

+         * The memory segment returned by this method will be allocated using the given {@code NativeScope}.
+         *
+         * @param layout the layout of the value
+         * @param scope the scope to allocate the segment in
+         * @return the value read as an {@code MemorySegment}
+         * @throws IllegalStateException if the C {@code va_list} associated with this instance is no longer valid
+         * (see {@link #close()}).
+         * @throws IllegalArgumentException if the given memory layout is not compatible with {@code MemorySegment}
+         */
+        MemorySegment vargAsSegment(MemoryLayout layout, NativeScope scope);
+
+        /**
+         * Skips a number of elements with the given memory layouts, and advances this va list's position.
+         *
+         * @param layouts the layout of the value
+         * @throws IllegalStateException if the C {@code va_list} associated with this instance is no longer valid
+         * (see {@link #close()}).
+         */
+        void skip(MemoryLayout... layouts);
+
+        /**
+         * A predicate used to check if the memory associated with the C {@code va_list} modelled
+         * by this instance is still valid to use.
+         *
+         * @return true, if the memory associated with the C {@code va_list} modelled by this instance is still valid
+         * @see #close()
+         */
+        boolean isAlive();
+
+        /**
+         * Releases the underlying C {@code va_list} modelled by this instance, and any native memory that is attached
+         * to this va list that holds its elements (see {@link VaList#make(Consumer)}).
+         * 

+         * After calling this method, {@link #isAlive()} will return {@code false} and further attempts to read values
+         * from this va list will result in an exception.
+         *
+         * @see #isAlive()
+         */
+        void close();
+
+        /**
+         * Copies this C {@code va_list} at its current position. Copying is useful to traverse the va list's elements
+         * starting from the current position, without affecting the state of the original va list, essentially
+         * allowing the elements to be traversed multiple times.
+         * 

+         * If this method needs to allocate native memory for the copy, it will use
+         * {@link MemorySegment#allocateNative(long, long)} to do so. {@link #close()} will have to be called on the
+         * returned va list instance to release the allocated memory.
+         * 

+         * This method only copies the va list cursor itself and not the memory that may be attached to the
+         * va list which holds its elements. That means that if this va list was created with the
+         * {@link #make(Consumer)} method, closing this va list will also release the native memory that holds its
+         * elements, making the copy unusable.
+         *
+         * @return a copy of this C {@code va_list}.
+         * @throws IllegalStateException if the C {@code va_list} associated with this instance is no longer valid
+         * (see {@link #close()}).
+         */
+        VaList copy();
+
+        /**
+         * Copies this C {@code va_list} at its current position. Copying is useful to traverse the va list's elements
+         * starting from the current position, without affecting the state of the original va list, essentially
+         * allowing the elements to be traversed multiple times.
+         * 

+         * If this method needs to allocate native memory for the copy, it will use
+         * the given {@code NativeScope} to do so.
+         * 

+         * This method only copies the va list cursor itself and not the memory that may be attached to the
+         * va list which holds its elements. That means that if this va list was created with the
+         * {@link #make(Consumer)} method, closing this va list will also release the native memory that holds its
+         * elements, making the copy unusable.
+         *
+         * @param scope the scope to allocate the copy in
+         * @return a copy of this C {@code va_list}.
+         * @throws IllegalStateException if the C {@code va_list} associated with this instance is no longer valid
+         * (see {@link #close()}).
+         */
+        VaList copy(NativeScope scope);
+
+        /**
+         * Returns the memory address of the C {@code va_list} associated with this instance.
+         *
+         * @return the memory address of the C {@code va_list} associated with this instance.
+         */
+        @Override
+        MemoryAddress address();
+
+        /**
+         * Constructs a new {@code VaList} instance out of a memory address pointing to an existing C {@code va_list}.
+         * 

+         * This method is restricted. Restricted method are unsafe, and, if used incorrectly, their use might crash
+         * the JVM or, worse, silently result in memory corruption. Thus, clients should refrain from depending on
+         * restricted methods, and use safe and supported functionalities, where possible.
+         *
+         * @param address a memory address pointing to an existing C {@code va_list}.
+         * @return a new {@code VaList} instance backed by the C {@code va_list} at {@code address}.
+         */
+        static VaList ofAddressRestricted(MemoryAddress address) {
+            Utils.checkRestrictedAccess("VaList.ofAddressRestricted");
+            return SharedUtils.newVaListOfAddress(address);
+        }
+
+        /**
+         * Constructs a new {@code VaList} using a builder (see {@link Builder}).
+         * 

+         * If this method needs to allocate native memory for the va list, it will use
+         * {@link MemorySegment#allocateNative(long, long)} to do so.
+         * 

+         * This method will allocate native memory to hold the elements in the va list. This memory
+         * will be 'attached' to the returned va list instance, and will be released when {@link VaList#close()}
+         * is called.
+         * 

+         * Note that when there are no elements added to the created va list,
+         * this method will return the same as {@linkplain #empty()}.
+         *
+         * @param actions a consumer for a builder (see {@link Builder}) which can be used to specify the elements
+         *                of the underlying C {@code va_list}.
+         * @return a new {@code VaList} instance backed by a fresh C {@code va_list}.
+         */
+        static VaList make(Consumer actions) {
+            return SharedUtils.newVaList(actions, MemorySegment::allocateNative);
+        }
+
+        /**
+         * Constructs a new {@code VaList} using a builder (see {@link Builder}).
+         * 

+         * If this method needs to allocate native memory for the va list, it will use
+         * the given {@code NativeScope} to do so.
+         * 

+         * This method will allocate native memory to hold the elements in the va list. This memory
+         * will be managed by the given {@code NativeScope}, and will be released when the scope is closed.
+         * 

+         * Note that when there are no elements added to the created va list,
+         * this method will return the same as {@linkplain #empty()}.
+         *
+         * @param actions a consumer for a builder (see {@link Builder}) which can be used to specify the elements
+         *                of the underlying C {@code va_list}.
+         * @param scope the scope to be used for the valist allocation.
+         * @return a new {@code VaList} instance backed by a fresh C {@code va_list}.
+         */
+        static VaList make(Consumer actions, NativeScope scope) {
+            return SharedUtils.newVaList(actions, SharedUtils.Allocator.ofScope(scope));
+        }
+
+        /**
+         * Returns an empty C {@code va_list} constant.
+         * 

+         * The returned {@code VaList} can not be closed.
+         *
+         * @return a {@code VaList} modelling an empty C {@code va_list}.
+         */
+        static VaList empty() {
+            return SharedUtils.emptyVaList();
+        }
+
+        /**
+         * A builder interface used to construct a C {@code va_list}.
+         *
+         * @apiNote In the future, if the Java language permits, {@link Builder}
+         * may become a {@code sealed} interface, which would prohibit subclassing except by
+         * explicitly permitted types.
+         *
+         */
+        interface Builder {
+
+            /**
+             * Adds a native value represented as an {@code int} to the C {@code va_list} being constructed.
+             *
+             * @param layout the native layout of the value.
+             * @param value the value, represented as an {@code int}.
+             * @return this builder.
+             * @throws IllegalArgumentException if the given memory layout is not compatible with {@code int}
+             */
+            Builder vargFromInt(ValueLayout layout, int value);
+
+            /**
+             * Adds a native value represented as a {@code long} to the C {@code va_list} being constructed.
+             *
+             * @param layout the native layout of the value.
+             * @param value the value, represented as a {@code long}.
+             * @return this builder.
+             * @throws IllegalArgumentException if the given memory layout is not compatible with {@code long}
+             */
+            Builder vargFromLong(ValueLayout layout, long value);
+
+            /**
+             * Adds a native value represented as a {@code double} to the C {@code va_list} being constructed.
+             *
+             * @param layout the native layout of the value.
+             * @param value the value, represented as a {@code double}.
+             * @return this builder.
+             * @throws IllegalArgumentException if the given memory layout is not compatible with {@code double}
+             */
+            Builder vargFromDouble(ValueLayout layout, double value);
+
+            /**
+             * Adds a native value represented as a {@code MemoryAddress} to the C {@code va_list} being constructed.
+             *
+             * @param layout the native layout of the value.
+             * @param value the value, represented as a {@code Addressable}.
+             * @return this builder.
+             * @throws IllegalArgumentException if the given memory layout is not compatible with {@code MemoryAddress}
+             */
+            Builder vargFromAddress(ValueLayout layout, Addressable value);
+
+            /**
+             * Adds a native value represented as a {@code MemorySegment} to the C {@code va_list} being constructed.
+             *
+             * @param layout the native layout of the value.
+             * @param value the value, represented as a {@code MemorySegment}.
+             * @return this builder.
+             * @throws IllegalArgumentException if the given memory layout is not compatible with {@code MemorySegment}
+             */
+            Builder vargFromSegment(GroupLayout layout, MemorySegment value);
+        }
+    }
+
+    /**
+     * A C type kind. Each kind corresponds to a particular C language builtin type, and can be attached to
+     * {@link ValueLayout} instances using the {@link MemoryLayout#withAttribute(String, Constable)} in order
+     * to obtain a layout which can be classified accordingly by {@link CLinker#downcallHandle(Addressable, MethodType, FunctionDescriptor)}
+     * and {@link CLinker#upcallStub(MethodHandle, FunctionDescriptor)}.
+     */
+    enum TypeKind {
+        /**
+         * A kind corresponding to the C {@code char} type
+         */
+        CHAR(true),
+        /**
+         * A kind corresponding to the C {@code short} type
+         */
+        SHORT(true),
+        /**
+         * A kind corresponding to the C {@code int} type
+         */
+        INT(true),
+        /**
+         * A kind corresponding to the C {@code long} type
+         */
+        LONG(true),
+        /**
+         * A kind corresponding to the C {@code long long} type
+         */
+        LONGLONG(true),
+        /**
+         * A kind corresponding to the C {@code float} type
+         */
+        FLOAT(false),
+        /**
+         * A kind corresponding to the C {@code double} type
+         */
+        DOUBLE(false),
+        /**
+         * A kind corresponding to the C {@code long double} type
+         */
+        LONGDOUBLE(false),
+        /**
+         * A kind corresponding to the a C pointer type
+         */
+        POINTER(false);
+
+        private final boolean isIntegral;
+
+        TypeKind(boolean isIntegral) {
+            this.isIntegral = isIntegral;
+        }
+
+        /**
+         * Is this kind integral?
+         *
+         * @return true if this kind is integral
+         */
+        public boolean isIntegral() {
+            return isIntegral;
+        }
+
+        /**
+         * Is this kind a floating point type?
+         *
+         * @return true if this kind is a floating point type
+         */
+        public boolean isFloat() {
+            return !isIntegral() && !isPointer();
+        }
+
+        /**
+         * Is this kind a pointer kind?
+         *
+         * @return true if this kind is a pointer kind
+         */
+        public boolean isPointer() {
+            return this == POINTER;
+        }
+
+        /**
+         * The layout attribute name associated with this classification kind. Clients can retrieve the type kind
+         * of a layout using the following code:
+         * 
{@code
+        ValueLayout layout = ...
+        TypeKind = layout.attribute(TypeKind.ATTR_NAME).orElse(null);
+         * }

+         */
+        public final static String ATTR_NAME = "abi/kind";
+    }
+}
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/FunctionDescriptor.java b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/FunctionDescriptor.java
new file mode 100644
index 0000000000000..b5314b233a58c
--- /dev/null
+++ b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/FunctionDescriptor.java
@@ -0,0 +1,228 @@
+/*
+ *  Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
+ *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ *  This code is free software; you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License version 2 only, as
+ *  published by the Free Software Foundation.
+ *
+ *  This code 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
+ *  version 2 for more details (a copy is included in the LICENSE file that
+ *  accompanied this code).
+ *
+ *  You should have received a copy of the GNU General Public License version
+ *  2 along with this work; if not, write to the Free Software Foundation,
+ *  Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ *  Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ *  or visit www.oracle.com if you need additional information or have any
+ *  questions.
+ */
+package jdk.incubator.foreign;
+
+import java.lang.constant.Constable;
+import java.lang.constant.ConstantDesc;
+import java.lang.constant.ConstantDescs;
+import java.lang.constant.DynamicConstantDesc;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+/**
+ * A function descriptor is made up of zero or more argument layouts and zero or one return layout. A function descriptor
+ * is used to model the signature of foreign functions.
+ */
+public final class FunctionDescriptor implements Constable {
+
+    /**
+     * The name of the function descriptor attribute (see {@link #attributes()} used to mark trivial functions. The
+     * attribute value must be a boolean.
+     */
+    public static final String TRIVIAL_ATTRIBUTE_NAME = "abi/trivial";
+    
+    private final MemoryLayout resLayout;
+    private final MemoryLayout[] argLayouts;
+    private final Map attributes;
+
+    private FunctionDescriptor(MemoryLayout resLayout, Map attributes, MemoryLayout... argLayouts) {
+        this.resLayout = resLayout;
+        this.attributes = Collections.unmodifiableMap(attributes);
+        this.argLayouts = argLayouts;
+    }
+
+    /**
+     * Returns the attribute with the given name (if it exists).
+     *
+     * @param name the attribute name.
+     * @return the attribute with the given name (if it exists).
+     */
+    public Optional attribute(String name) {
+        return Optional.ofNullable(attributes.get(name));
+    }
+
+    /**
+     * Returns a stream of the attribute names associated with this function descriptor.
+     *
+     * @return a stream of the attribute names associated with this function descriptor.
+     */
+    public Stream attributes() {
+        return attributes.keySet().stream();
+    }
+
+    /**
+     * Returns a new function descriptor which features the same attributes as this descriptor, plus the newly specified attribute.
+     * If this descriptor already contains an attribute with the same name, the existing attribute value is overwritten in the returned
+     * descriptor.
+     *
+     * @param name the attribute name.
+     * @param value the attribute value.
+     * @return a new function descriptor which features the same attributes as this descriptor, plus the newly specified attribute.
+     */
+    public FunctionDescriptor withAttribute(String name, Constable value) {
+        Map newAttributes = new HashMap<>(attributes);
+        newAttributes.put(name, value);
+        return new FunctionDescriptor(resLayout, newAttributes, argLayouts);
+    }
+
+    /**
+     * Returns the return layout associated with this function.
+     * @return the return
+     */
+    public Optional returnLayout() {
+        return Optional.ofNullable(resLayout);
+    }
+
+    /**
+     * Returns the argument layouts associated with this function.
+     * @return the argument layouts.
+     */
+    public List argumentLayouts() {
+        return Arrays.asList(argLayouts);
+    }
+
+    /**
+     * Create a function descriptor with given return and argument layouts.
+     * @param resLayout the return
+     * @param argLayouts the argument layouts.
+     * @return the new function descriptor.
+     * @throws NullPointerException if any of the argument layouts, or the return layout is null.
+     */
+    public static FunctionDescriptor of(MemoryLayout resLayout, MemoryLayout... argLayouts) {
+        Objects.requireNonNull(resLayout);
+        Arrays.stream(argLayouts).forEach(Objects::requireNonNull);
+        return new FunctionDescriptor(resLayout, Map.of(), argLayouts);
+    }
+
+    /**
+     * Create a function descriptor with given argument layouts and no return layout.
+     * @param argLayouts the argument layouts.
+     * @return the new function descriptor.
+     * @throws NullPointerException if any of the argument layouts is null.
+     */
+    public static FunctionDescriptor ofVoid(MemoryLayout... argLayouts) {
+        Arrays.stream(argLayouts).forEach(Objects::requireNonNull);
+        return new FunctionDescriptor(null, Map.of(), argLayouts);
+    }
+
+    /**
+     * Create a new function descriptor with the given argument layouts appended to the argument layout array
+     * of this function descriptor.
+     * @param addedLayouts the argument layouts to append.
+     * @return the new function descriptor.
+     * @throws NullPointerException if any of the new argument layouts is null.
+     */
+    public FunctionDescriptor appendArgumentLayouts(MemoryLayout... addedLayouts) {
+        Arrays.stream(addedLayouts).forEach(Objects::requireNonNull);
+        MemoryLayout[] newLayouts = Arrays.copyOf(argLayouts, argLayouts.length + addedLayouts.length);
+        System.arraycopy(addedLayouts, 0, newLayouts, argLayouts.length, addedLayouts.length);
+        return new FunctionDescriptor(resLayout, attributes, newLayouts);
+    }
+
+    /**
+     * Create a new function descriptor with the given memory layout as the new return layout.
+     * @param newReturn the new return layout.
+     * @return the new function descriptor.
+     * @throws NullPointerException if the new return layout is null.
+     */
+    public FunctionDescriptor changeReturnLayout(MemoryLayout newReturn) {
+        Objects.requireNonNull(newReturn);
+        return new FunctionDescriptor(newReturn, attributes, argLayouts);
+    }
+
+    /**
+     * Create a new function descriptor with the return layout dropped.
+     * @return the new function descriptor.
+     */
+    public FunctionDescriptor dropReturnLayout() {
+        return new FunctionDescriptor(null, attributes, argLayouts);
+    }
+
+    /**
+     * Returns a string representation of this function descriptor.
+     * @return a string representation of this function descriptor.
+     */
+    @Override
+    public String toString() {
+        return String.format("(%s)%s",
+                Stream.of(argLayouts)
+                        .map(Object::toString)
+                        .collect(Collectors.joining()),
+                returnLayout().map(Object::toString).orElse("v"));
+    }
+
+    /**
+     * Compares the specified object with this function descriptor for equality. Returns {@code true} if and only if the specified
+     * object is also a function descriptor, and all of the following conditions are met:
+     * 
    
+     *     
  • the two function descriptors have equals return layouts (see {@link MemoryLayout#equals(Object)}), or both have no return layout
    • 
+     *     
  • the two function descriptors have argument layouts that are pair-wise equal (see {@link MemoryLayout#equals(Object)})
+     * 

+     *
+     * @param other the object to be compared for equality with this function descriptor.
+     * @return {@code true} if the specified object is equal to this function descriptor.
+     */
+    @Override
+    public boolean equals(Object other) {
+        if (this == other) {
+            return true;
+        }
+        if (!(other instanceof FunctionDescriptor)) {
+            return false;
+        }
+        FunctionDescriptor f = (FunctionDescriptor) other;
+        return Objects.equals(resLayout, f.resLayout) && Arrays.equals(argLayouts, f.argLayouts);
+    }
+
+    /**
+     * Returns the hash code value for this function descriptor.
+     * @return the hash code value for this function descriptor.
+     */
+    @Override
+    public int hashCode() {
+        int hashCode = Arrays.hashCode(argLayouts);
+        return resLayout == null ? hashCode : resLayout.hashCode() ^ hashCode;
+    }
+
+    @Override
+    public Optional> describeConstable() {
+        List constants = new ArrayList<>();
+        constants.add(resLayout == null ? AbstractLayout.MH_VOID_FUNCTION : AbstractLayout.MH_FUNCTION);
+        if (resLayout != null) {
+            constants.add(resLayout.describeConstable().get());
+        }
+        for (MemoryLayout argLayout : argLayouts) {
+            constants.add(argLayout.describeConstable().get());
+        }
+        return Optional.of(DynamicConstantDesc.ofNamed(
+                    ConstantDescs.BSM_INVOKE, "function", AbstractLayout.CD_FUNCTION_DESC, constants.toArray(new ConstantDesc[0])));
+    }
+}
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/LibraryLookup.java b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/LibraryLookup.java
new file mode 100644
index 0000000000000..c78d451f42cbe
--- /dev/null
+++ b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/LibraryLookup.java
@@ -0,0 +1,146 @@
+/*
+ *  Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
+ *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ *  This code is free software; you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License version 2 only, as
+ *  published by the Free Software Foundation.  Oracle designates this
+ *  particular file as subject to the "Classpath" exception as provided
+ *  by Oracle in the LICENSE file that accompanied this code.
+ *
+ *  This code 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
+ *  version 2 for more details (a copy is included in the LICENSE file that
+ *  accompanied this code).
+ *
+ *  You should have received a copy of the GNU General Public License version
+ *  2 along with this work; if not, write to the Free Software Foundation,
+ *  Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ *   Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ *  or visit www.oracle.com if you need additional information or have any
+ *  questions.
+ *
+ */
+package jdk.incubator.foreign;
+
+import jdk.internal.foreign.LibrariesHelper;
+
+import java.io.File;
+import java.lang.invoke.MethodType;
+import java.nio.file.Path;
+import java.util.Objects;
+import java.util.Optional;
+
+/**
+ * A native library lookup. Exposes lookup operation for searching symbols, see {@link LibraryLookup#lookup(String)}.
+ * A given native library remains loaded as long as there is at least one live library lookup instance referring
+ * to it.
+ * All symbol instances (see {@link LibraryLookup.Symbol}) generated by a given library lookup object contain a strong reference
+ * to said lookup object, therefore preventing library unloading; in turn method handle instances obtained from
+ * {@link CLinker#downcallHandle(Addressable, MethodType, FunctionDescriptor)}) also maintain a strong reference
+ * to the addressable parameter used for their construction. This means that there is always a strong reachability chain
+ * from a native method handle to a lookup object (the one that was used to lookup the native library symbol the method handle
+ * refers to); this is useful to prevent situations where a native library is unloaded in the middle of a native call.
+ * 

+ * In cases where a client wants to create a memory segment out of a lookup symbol, the client might want to attach the
+ * lookup symbol to the newly created segment, so that the symbol will be kept reachable as long as the memory segment
+ * is reachable; this can be achieved by creating the segment using the {@link MemoryAddress#asSegmentRestricted(long, Runnable, Object)}
+ * restricted segment factory, as follows:
+ * 
{@code
+LibraryLookup defaultLookup = LibraryLookup.defaultLookup();
+LibraryLookup.Symbol errno = defaultLookup.lookup("errno");
+MemorySegment errnoSegment = errno.address().asRestrictedSegment(4, errno);
+ * }

+ * 

+ * To allow for a library to be unloaded, a client will have to discard any strong references it
+ * maintains, directly, or indirectly to a lookup object associated with given library.
+ */
+public interface LibraryLookup {
+
+    /**
+     * A symbol retrieved during a library lookup. A lookup symbol has a name and can be projected
+     * into a memory address (see {@link #name()} and {@link #address()}, respectively).
+     *
+     * @apiNote In the future, if the Java language permits, {@link Symbol}
+     * may become a {@code sealed} interface, which would prohibit subclassing except by
+     * explicitly permitted types.
+     *
+     * @implSpec
+     * Implementations of this interface are immutable, thread-safe and value-based.
+     */
+    interface Symbol extends Addressable {
+        /**
+         * The name of this lookup symbol.
+         * @return the name of this lookup symbol.
+         */
+        String name();
+
+        /**
+         * The memory address of this lookup symbol. If the memory associated with this symbol needs to be dereferenced,
+         * clients can obtain a segment from this symbol's address using the {@link MemoryAddress#asSegmentRestricted(long, Runnable, Object)},
+         * and making sure that the created segment maintains a strong reference to this symbol, to prevent library unloading.
+         * @return the memory address of this lookup symbol.
+         */
+        @Override
+        MemoryAddress address();
+    }
+
+    /**
+     * Lookups a symbol with given name in this library. The returned symbol maintains a strong reference to this lookup object.
+     * @param name the symbol name.
+     * @return the library symbol (if any).
+     */
+    Optional lookup(String name);
+
+    /**
+     * Obtain a default library lookup object.
+     * @return the default library lookup object.
+     */
+    static LibraryLookup ofDefault() {
+        SecurityManager security = System.getSecurityManager();
+        if (security != null) {
+            security.checkPermission(new RuntimePermission("java.foreign.getDefaultLibrary"));
+        }
+        return LibrariesHelper.getDefaultLibrary();
+    }
+
+    /**
+     * Obtain a library lookup object corresponding to a library identified by given path.
+     * @param path the library absolute path.
+     * @return a library lookup object for given path.
+     * @throws IllegalArgumentException if the specified path does not correspond to an absolute path,
+     * e.g. if {@code !path.isAbsolute()}.
+     */
+    static LibraryLookup ofPath(Path path) {
+        Objects.requireNonNull(path);
+        if (!path.isAbsolute()) {
+            throw new IllegalArgumentException("Not an absolute path: " + path.toString());
+        }
+        String absolutePath = path.toString();
+        SecurityManager security = System.getSecurityManager();
+        if (security != null) {
+            security.checkLink(absolutePath);
+        }
+        return LibrariesHelper.load(absolutePath);
+    }
+
+    /**
+     * Obtain a library lookup object corresponding to a library identified by given library name.
+     * @param libName the library name.
+     * @return a library lookup object for given library name.
+     */
+    static LibraryLookup ofLibrary(String libName) {
+        Objects.requireNonNull(libName);
+        SecurityManager security = System.getSecurityManager();
+        if (security != null) {
+            security.checkLink(libName);
+        }
+        if (libName.indexOf(File.separatorChar) != -1) {
+            throw new UnsatisfiedLinkError(
+                    "Directory separator should not appear in library name: " + libName);
+        }
+        return LibrariesHelper.loadLibrary(libName);
+    }
+}
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/NativeScope.java b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/NativeScope.java
new file mode 100644
index 0000000000000..09286ac004aca
--- /dev/null
+++ b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/NativeScope.java
@@ -0,0 +1,430 @@
+/*
+ *  Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ *  This code is free software; you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License version 2 only, as
+ *  published by the Free Software Foundation.  Oracle designates this
+ *  particular file as subject to the "Classpath" exception as provided
+ *  by Oracle in the LICENSE file that accompanied this code.
+ *
+ *  This code 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
+ *  version 2 for more details (a copy is included in the LICENSE file that
+ *  accompanied this code).
+ *
+ *  You should have received a copy of the GNU General Public License version
+ *  2 along with this work; if not, write to the Free Software Foundation,
+ *  Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ *   Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ *  or visit www.oracle.com if you need additional information or have any
+ *  questions.
+ *
+ */
+
+package jdk.incubator.foreign;
+
+import jdk.internal.foreign.AbstractMemorySegmentImpl;
+import jdk.internal.foreign.AbstractNativeScope;
+import jdk.internal.foreign.Utils;
+
+import java.lang.invoke.VarHandle;
+import java.lang.reflect.Array;
+import java.nio.ByteOrder;
+import java.util.OptionalLong;
+import java.util.function.Function;
+import java.util.stream.Stream;
+
+/**
+ * This class provides a scope, within which several allocations can be performed. An native scope is backed
+ * by off-heap memory. Native scopes can be either bounded or unbounded, depending on whether the size
+ * of the native scope is known statically. If an application knows before-hand how much memory it needs to allocate,
+ * then using a bounded native scope will typically provide better performances than independently allocating the memory
+ * for each value (e.g. using {@link MemorySegment#allocateNative(long)}), or using an unbounded native scope.
+ * For this reason, using a bounded native scope is recommended in cases where programs might need to emulate native stack allocation.
+ * 

+ * Allocation scopes are thread-confined (see {@link #ownerThread()}; as such, the resulting {@link MemorySegment} instances
+ * returned by the native scope will be backed by memory segments confined by the same owner thread as the native scope's
+ * owner thread.
+ * 

+ * To allow for more usability, it is possible for a native scope to reclaim ownership of an existing memory segment
+ * (see {@link MemorySegment#handoff(NativeScope)}). This might be useful to allow one or more segments which were independently
+ * created to share the same life-cycle as a given native scope - which in turns enables client to group all memory
+ * allocation and usage under a single try-with-resources block.
+ */
+public interface NativeScope extends AutoCloseable {
+
+    /**
+     * If this native scope is bounded, returns the size, in bytes, of this native scope.
+     * @return the size, in bytes, of this native scope (if available).
+     */
+    OptionalLong byteSize();
+
+    /**
+     * The thread owning this native scope.
+     * @return the thread owning this native scope.
+     */
+    Thread ownerThread();
+
+    /**
+     * Returns the number of allocated bytes in this native scope.
+     * @return the number of allocated bytes in this native scope.
+     */
+    long allocatedBytes();
+
+    /**
+     * Allocate a block of memory in this native scope with given layout and initialize it with given byte value.
+     * The segment returned by this method is associated with a segment which cannot be closed. Moreover, the returned
+     * segment must conform to the layout alignment constraints.
+     * @param layout the layout of the block of memory to be allocated.
+     * @param value the value to be set on the newly allocated memory block.
+     * @return a segment for the newly allocated memory block.
+     * @throws OutOfMemoryError if there is not enough space left in this native scope, that is, if
+     * {@code limit() - size() < layout.byteSize()}.
+     * @throws IllegalArgumentException if {@code layout.byteSize()} does not conform to the size of a byte value.
+     */
+    default MemorySegment allocate(ValueLayout layout, byte value) {
+        VarHandle handle = layout.varHandle(byte.class);
+        MemorySegment addr = allocate(layout);
+        handle.set(addr, value);
+        return addr;
+    }
+
+    /**
+     * Allocate a block of memory in this native scope with given layout and initialize it with given short value.
+     * The segment returned by this method is associated with a segment which cannot be closed. Moreover, the returned
+     * segment must conform to the layout alignment constraints.
+     * @param layout the layout of the block of memory to be allocated.
+     * @param value the value to be set on the newly allocated memory block.
+     * @return a segment for the newly allocated memory block.
+     * @throws OutOfMemoryError if there is not enough space left in this native scope, that is, if
+     * {@code limit() - size() < layout.byteSize()}.
+     * @throws IllegalArgumentException if {@code layout.byteSize()} does not conform to the size of a short value.
+     */
+    default MemorySegment allocate(ValueLayout layout, short value) {
+        VarHandle handle = layout.varHandle(short.class);
+        MemorySegment addr = allocate(layout);
+        handle.set(addr, value);
+        return addr;
+    }
+
+    /**
+     * Allocate a block of memory in this native scope with given layout and initialize it with given int value.
+     * The segment returned by this method is associated with a segment which cannot be closed. Moreover, the returned
+     * segment must conform to the layout alignment constraints.
+     * @param layout the layout of the block of memory to be allocated.
+     * @param value the value to be set on the newly allocated memory block.
+     * @return a segment for the newly allocated memory block.
+     * @throws OutOfMemoryError if there is not enough space left in this native scope, that is, if
+     * {@code limit() - size() < layout.byteSize()}.
+     * @throws IllegalArgumentException if {@code layout.byteSize()} does not conform to the size of a int value.
+     */
+    default MemorySegment allocate(ValueLayout layout, int value) {
+        VarHandle handle = layout.varHandle(int.class);
+        MemorySegment addr = allocate(layout);
+        handle.set(addr, value);
+        return addr;
+    }
+
+    /**
+     * Allocate a block of memory in this native scope with given layout and initialize it with given float value.
+     * The segment returned by this method is associated with a segment which cannot be closed. Moreover, the returned
+     * segment must conform to the layout alignment constraints.
+     * @param layout the layout of the block of memory to be allocated.
+     * @param value the value to be set on the newly allocated memory block.
+     * @return a segment for the newly allocated memory block.
+     * @throws OutOfMemoryError if there is not enough space left in this native scope, that is, if
+     * {@code limit() - size() < layout.byteSize()}.
+     * @throws IllegalArgumentException if {@code layout.byteSize()} does not conform to the size of a float value.
+     */
+    default MemorySegment allocate(ValueLayout layout, float value) {
+        VarHandle handle = layout.varHandle(float.class);
+        MemorySegment addr = allocate(layout);
+        handle.set(addr, value);
+        return addr;
+    }
+
+    /**
+     * Allocate a block of memory in this native scope with given layout and initialize it with given long value.
+     * The segment returned by this method is associated with a segment which cannot be closed. Moreover, the returned
+     * segment must conform to the layout alignment constraints.
+     * @param layout the layout of the block of memory to be allocated.
+     * @param value the value to be set on the newly allocated memory block.
+     * @return a segment for the newly allocated memory block.
+     * @throws OutOfMemoryError if there is not enough space left in this native scope, that is, if
+     * {@code limit() - size() < layout.byteSize()}.
+     * @throws IllegalArgumentException if {@code layout.byteSize()} does not conform to the size of a long value.
+     */
+    default MemorySegment allocate(ValueLayout layout, long value) {
+        VarHandle handle = layout.varHandle(long.class);
+        MemorySegment addr = allocate(layout);
+        handle.set(addr, value);
+        return addr;
+    }
+
+    /**
+     * Allocate a block of memory in this native scope with given layout and initialize it with given double value.
+     * The segment returned by this method is associated with a segment which cannot be closed. Moreover, the returned
+     * segment must conform to the layout alignment constraints.
+     * @param layout the layout of the block of memory to be allocated.
+     * @param value the value to be set on the newly allocated memory block.
+     * @return a segment for the newly allocated memory block.
+     * @throws OutOfMemoryError if there is not enough space left in this native scope, that is, if
+     * {@code limit() - size() < layout.byteSize()}.
+     * @throws IllegalArgumentException if {@code layout.byteSize()} does not conform to the size of a double value.
+     */
+    default MemorySegment allocate(ValueLayout layout, double value) {
+        VarHandle handle = layout.varHandle(double.class);
+        MemorySegment addr = allocate(layout);
+        handle.set(addr, value);
+        return addr;
+    }
+
+    /**
+     * Allocate a block of memory in this native scope with given layout and initialize it with given address value
+     * (expressed as an {@link Addressable} instance).
+     * The address value might be narrowed according to the platform address size (see {@link MemoryLayouts#ADDRESS}).
+     * The segment returned by this method cannot be closed. Moreover, the returned
+     * segment must conform to the layout alignment constraints.
+     * @param layout the layout of the block of memory to be allocated.
+     * @param value the value to be set on the newly allocated memory block.
+     * @return a segment for the newly allocated memory block.
+     * @throws OutOfMemoryError if there is not enough space left in this native scope, that is, if
+     * {@code limit() - size() < layout.byteSize()}.
+     * @throws IllegalArgumentException if {@code layout.byteSize() != MemoryLayouts.ADDRESS.byteSize()}.
+     */
+    default MemorySegment allocate(ValueLayout layout, Addressable value) {
+        if (MemoryLayouts.ADDRESS.byteSize() != layout.byteSize()) {
+            throw new IllegalArgumentException("Layout size mismatch - " + layout.byteSize() + " != " + MemoryLayouts.ADDRESS.byteSize());
+        }
+        switch ((int)layout.byteSize()) {
+            case 4: return allocate(layout, (int)value.address().toRawLongValue());
+            case 8: return allocate(layout, value.address().toRawLongValue());
+            default: throw new UnsupportedOperationException("Unsupported pointer size"); // should not get here
+        }
+    }
+
+    /**
+     * Allocate a block of memory in this native scope with given layout and initialize it with given byte array.
+     * The segment returned by this method is associated with a segment which cannot be closed. Moreover, the returned
+     * segment must conform to the layout alignment constraints.
+     * @param elementLayout the element layout of the array to be allocated.
+     * @param array the array to be copied on the newly allocated memory block.
+     * @return a segment for the newly allocated memory block.
+     * @throws OutOfMemoryError if there is not enough space left in this native scope, that is, if
+     * {@code limit() - size() < (elementLayout.byteSize() * array.length)}.
+     * @throws IllegalArgumentException if {@code elementLayout.byteSize()} does not conform to the size of a byte value.
+     */
+    default MemorySegment allocateArray(ValueLayout elementLayout, byte[] array) {
+        return copyArrayWithSwapIfNeeded(array, elementLayout, MemorySegment::ofArray);
+    }
+
+    /**
+     * Allocate a block of memory in this native scope with given layout and initialize it with given short array.
+     * The segment returned by this method is associated with a segment which cannot be closed. Moreover, the returned
+     * segment must conform to the layout alignment constraints.
+     * @param elementLayout the element layout of the array to be allocated.
+     * @param array the array to be copied on the newly allocated memory block.
+     * @return a segment for the newly allocated memory block.
+     * @throws OutOfMemoryError if there is not enough space left in this native scope, that is, if
+     * {@code limit() - size() < (elementLayout.byteSize() * array.length)}.
+     * @throws IllegalArgumentException if {@code elementLayout.byteSize()} does not conform to the size of a short value.
+     */
+    default MemorySegment allocateArray(ValueLayout elementLayout, short[] array) {
+        return copyArrayWithSwapIfNeeded(array, elementLayout, MemorySegment::ofArray);
+    }
+
+    /**
+     * Allocate a block of memory in this native scope with given layout and initialize it with given char array.
+     * The segment returned by this method is associated with a segment which cannot be closed. Moreover, the returned
+     * segment must conform to the layout alignment constraints.
+     * @param elementLayout the element layout of the array to be allocated.
+     * @param array the array to be copied on the newly allocated memory block.
+     * @return a segment for the newly allocated memory block.
+     * @throws OutOfMemoryError if there is not enough space left in this native scope, that is, if
+     * {@code limit() - size() < (elementLayout.byteSize() * array.length)}.
+     * @throws IllegalArgumentException if {@code elementLayout.byteSize()} does not conform to the size of a char value.
+     */
+    default MemorySegment allocateArray(ValueLayout elementLayout, char[] array) {
+        return copyArrayWithSwapIfNeeded(array, elementLayout, MemorySegment::ofArray);
+    }
+
+    /**
+     * Allocate a block of memory in this native scope with given layout and initialize it with given int array.
+     * The segment returned by this method is associated with a segment which cannot be closed. Moreover, the returned
+     * segment must conform to the layout alignment constraints.
+     * @param elementLayout the element layout of the array to be allocated.
+     * @param array the array to be copied on the newly allocated memory block.
+     * @return a segment for the newly allocated memory block.
+     * @throws OutOfMemoryError if there is not enough space left in this native scope, that is, if
+     * {@code limit() - size() < (elementLayout.byteSize() * array.length)}.
+     * @throws IllegalArgumentException if {@code elementLayout.byteSize()} does not conform to the size of a int value.
+     */
+    default MemorySegment allocateArray(ValueLayout elementLayout, int[] array) {
+        return copyArrayWithSwapIfNeeded(array, elementLayout, MemorySegment::ofArray);
+    }
+
+    /**
+     * Allocate a block of memory in this native scope with given layout and initialize it with given float array.
+     * The segment returned by this method is associated with a segment which cannot be closed. Moreover, the returned
+     * segment must conform to the layout alignment constraints.
+     * @param elementLayout the element layout of the array to be allocated.
+     * @param array the array to be copied on the newly allocated memory block.
+     * @return a segment for the newly allocated memory block.
+     * @throws OutOfMemoryError if there is not enough space left in this native scope, that is, if
+     * {@code limit() - size() < (elementLayout.byteSize() * array.length)}.
+     * @throws IllegalArgumentException if {@code elementLayout.byteSize()} does not conform to the size of a float value.
+     */
+    default MemorySegment allocateArray(ValueLayout elementLayout, float[] array) {
+        return copyArrayWithSwapIfNeeded(array, elementLayout, MemorySegment::ofArray);
+    }
+
+    /**
+     * Allocate a block of memory in this native scope with given layout and initialize it with given long array.
+     * The segment returned by this method is associated with a segment which cannot be closed. Moreover, the returned
+     * segment must conform to the layout alignment constraints.
+     * @param elementLayout the element layout of the array to be allocated.
+     * @param array the array to be copied on the newly allocated memory block.
+     * @return a segment for the newly allocated memory block.
+     * @throws OutOfMemoryError if there is not enough space left in this native scope, that is, if
+     * {@code limit() - size() < (elementLayout.byteSize() * array.length)}.
+     * @throws IllegalArgumentException if {@code elementLayout.byteSize()} does not conform to the size of a long value.
+     */
+    default MemorySegment allocateArray(ValueLayout elementLayout, long[] array) {
+        return copyArrayWithSwapIfNeeded(array, elementLayout, MemorySegment::ofArray);
+    }
+
+    /**
+     * Allocate a block of memory in this native scope with given layout and initialize it with given double array.
+     * The segment returned by this method is associated with a segment which cannot be closed. Moreover, the returned
+     * segment must conform to the layout alignment constraints.
+     * @param elementLayout the element layout of the array to be allocated.
+     * @param array the array to be copied on the newly allocated memory block.
+     * @return a segment for the newly allocated memory block.
+     * @throws OutOfMemoryError if there is not enough space left in this native scope, that is, if
+     * {@code limit() - size() < (elementLayout.byteSize() * array.length)}.
+     * @throws IllegalArgumentException if {@code elementLayout.byteSize()} does not conform to the size of a double value.
+     */
+    default MemorySegment allocateArray(ValueLayout elementLayout, double[] array) {
+        return copyArrayWithSwapIfNeeded(array, elementLayout, MemorySegment::ofArray);
+    }
+
+    /**
+     * Allocate a block of memory in this native scope with given layout and initialize it with given address array.
+     * The address value of each array element might be narrowed according to the platform address size (see {@link MemoryLayouts#ADDRESS}).
+     * The segment returned by this method is associated with a segment which cannot be closed. Moreover, the returned
+     * segment must conform to the layout alignment constraints.
+     * @param elementLayout the element layout of the array to be allocated.
+     * @param array the array to be copied on the newly allocated memory block.
+     * @return a segment for the newly allocated memory block.
+     * @throws OutOfMemoryError if there is not enough space left in this native scope, that is, if
+     * {@code limit() - size() < (elementLayout.byteSize() * array.length)}.
+     * @throws IllegalArgumentException if {@code layout.byteSize() != MemoryLayouts.ADDRESS.byteSize()}.
+     */
+    default MemorySegment allocateArray(ValueLayout elementLayout, Addressable[] array) {
+        if (MemoryLayouts.ADDRESS.byteSize() != elementLayout.byteSize()) {
+            throw new IllegalArgumentException("Layout size mismatch - " + elementLayout.byteSize() + " != " + MemoryLayouts.ADDRESS.byteSize());
+        }
+        switch ((int)elementLayout.byteSize()) {
+            case 4: return copyArrayWithSwapIfNeeded(Stream.of(array)
+                            .mapToInt(a -> (int)a.address().toRawLongValue()).toArray(),
+                            elementLayout, MemorySegment::ofArray);
+            case 8: return copyArrayWithSwapIfNeeded(Stream.of(array)
+                            .mapToLong(a -> a.address().toRawLongValue()).toArray(),
+                            elementLayout, MemorySegment::ofArray);
+            default: throw new UnsupportedOperationException("Unsupported pointer size"); // should not get here
+        }
+    }
+
+    private  MemorySegment copyArrayWithSwapIfNeeded(Z array, ValueLayout elementLayout,
+                                                        Function heapSegmentFactory) {
+        Utils.checkPrimitiveCarrierCompat(array.getClass().componentType(), elementLayout);
+        MemorySegment addr = allocate(MemoryLayout.ofSequence(Array.getLength(array), elementLayout));
+        if (elementLayout.byteSize() == 1 || (elementLayout.order() == ByteOrder.nativeOrder())) {
+            addr.copyFrom(heapSegmentFactory.apply(array));
+        } else {
+            ((AbstractMemorySegmentImpl)addr).copyFromSwap(heapSegmentFactory.apply(array), elementLayout.byteSize());
+        }
+        return addr;
+    }
+
+    /**
+     * Allocate a block of memory in this native scope with given layout. The segment returned by this method is
+     * associated with a segment which cannot be closed. Moreover, the returned segment must conform to the layout alignment constraints.
+     * @param layout the layout of the block of memory to be allocated.
+     * @return a segment for the newly allocated memory block.
+     * @throws OutOfMemoryError if there is not enough space left in this native scope, that is, if
+     * {@code limit() - size() < layout.byteSize()}.
+     */
+    default MemorySegment allocate(MemoryLayout layout) {
+        return allocate(layout.byteSize(), layout.byteAlignment());
+    }
+
+    /**
+     * Allocate a block of memory corresponding to an array with given element layout and size.
+     * The segment returned by this method is associated with a segment which cannot be closed.
+     * Moreover, the returned segment must conform to the layout alignment constraints. This is equivalent to the
+     * following code:
+     * 
{@code
+    allocate(MemoryLayout.ofSequence(size, elementLayout));
+     * }

+     * @param elementLayout the array element layout.
+     * @param size the array element count.
+     * @return a segment for the newly allocated memory block.
+     * @throws OutOfMemoryError if there is not enough space left in this native scope, that is, if
+     * {@code limit() - size() < (elementLayout.byteSize() * size)}.
+     */
+    default MemorySegment allocateArray(MemoryLayout elementLayout, long size) {
+        return allocate(MemoryLayout.ofSequence(size, elementLayout));
+    }
+
+    /**
+     * Allocate a block of memory in this native scope with given size. The segment returned by this method is
+     * associated with a segment which cannot be closed. Moreover, the returned segment must be aligned to {@code size}.
+     * @param bytesSize the size (in bytes) of the block of memory to be allocated.
+     * @return a segment for the newly allocated memory block.
+     * @throws OutOfMemoryError if there is not enough space left in this native scope, that is, if
+     * {@code limit() - size() < bytesSize}.
+     */
+    default MemorySegment allocate(long bytesSize) {
+        return allocate(bytesSize, bytesSize);
+    }
+
+    /**
+     * Allocate a block of memory in this native scope with given size and alignment constraint.
+     * The segment returned by this method is associated with a segment which cannot be closed. Moreover,
+     * the returned segment must be aligned to {@code alignment}.
+     * @param bytesSize the size (in bytes) of the block of memory to be allocated.
+     * @param bytesAlignment the alignment (in bytes) of the block of memory to be allocated.
+     * @return a segment for the newly allocated memory block.
+     * @throws OutOfMemoryError if there is not enough space left in this native scope, that is, if
+     * {@code limit() - size() < bytesSize}.
+     */
+    MemorySegment allocate(long bytesSize, long bytesAlignment);
+
+    /**
+     * Close this native scope; calling this method will render any segment obtained through this native scope
+     * unusable and might release any backing memory resources associated with this native scope.
+     */
+    @Override
+    void close();
+
+    /**
+     * Creates a new bounded native scope, backed by off-heap memory.
+     * @param size the size of the native scope.
+     * @return a new bounded native scope, with given size (in bytes).
+     */
+    static NativeScope boundedScope(long size) {
+        return new AbstractNativeScope.BoundedNativeScope(size);
+    }
+
+    /**
+     * Creates a new unbounded native scope, backed by off-heap memory.
+     * @return a new unbounded native scope.
+     */
+    static NativeScope unboundedScope() {
+        return new AbstractNativeScope.UnboundedNativeScope();
+    }
+}
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/AbstractMemorySegmentImpl.java.rej b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/AbstractMemorySegmentImpl.java.rej
new file mode 100644
index 0000000000000..9c9e55966562a
--- /dev/null
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/AbstractMemorySegmentImpl.java.rej
@@ -0,0 +1,18 @@
+diff a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/AbstractMemorySegmentImpl.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/AbstractMemorySegmentImpl.java	(rejected hunks)
+@@ -136,6 +136,16 @@ public abstract class AbstractMemorySegmentImpl implements MemorySegment, Memory
+                 base(), min(), size);
+     }
+ 
++    public void copyFromSwap(MemorySegment src, long elemSize) {
++        AbstractMemorySegmentImpl that = (AbstractMemorySegmentImpl)src;
++        long size = that.byteSize();
++        checkAccess(0, size, false);
++        that.checkAccess(0, size, true);
++        SCOPED_MEMORY_ACCESS.copySwapMemory(scope, that.scope,
++                that.base(), that.min(),
++                base(), min(), size, elemSize);
++    }
++
+     private final static VarHandle BYTE_HANDLE = MemoryLayout.ofSequence(MemoryLayouts.JAVA_BYTE)
+             .varHandle(byte.class, MemoryLayout.PathElement.sequenceElement());
+ 
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/AbstractNativeScope.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/AbstractNativeScope.java
new file mode 100644
index 0000000000000..0f7e89b6b0b77
--- /dev/null
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/AbstractNativeScope.java
@@ -0,0 +1,134 @@
+package jdk.internal.foreign;
+
+import jdk.incubator.foreign.MemorySegment;
+import jdk.incubator.foreign.NativeScope;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.OptionalLong;
+
+public abstract class AbstractNativeScope implements NativeScope {
+
+    private final List segments = new ArrayList<>();
+    private final Thread ownerThread;
+
+    private static final int SCOPE_MASK = MemorySegment.READ | MemorySegment.WRITE; // no terminal operations allowed
+
+    AbstractNativeScope(Thread ownerThread) {
+        this.ownerThread = ownerThread;
+    }
+
+    @Override
+    public Thread ownerThread() {
+        return ownerThread;
+    }
+
+    @Override
+    public void close() {
+        segments.forEach(MemorySegment::close);
+    }
+
+    void checkOwnerThread() {
+        if (Thread.currentThread() != ownerThread()) {
+            throw new IllegalStateException("Attempt to access scope from different thread");
+        }
+    }
+
+    MemorySegment newSegment(long size, long align) {
+        MemorySegment segment = MemorySegment.allocateNative(size, align);
+        segments.add(segment);
+        return segment;
+    }
+
+    MemorySegment newSegment(long size) {
+        return newSegment(size, size);
+    }
+
+    public void register(MemorySegment segment) {
+        segments.add(segment);
+    }
+
+    public static class UnboundedNativeScope extends AbstractNativeScope {
+
+        private static final long BLOCK_SIZE = 4 * 1024;
+        private static final long MAX_ALLOC_SIZE = BLOCK_SIZE / 2;
+
+        private MemorySegment segment;
+        private long sp = 0L;
+        private long size = 0L;
+
+        @Override
+        public OptionalLong byteSize() {
+            return OptionalLong.empty();
+        }
+
+        @Override
+        public long allocatedBytes() {
+            return size;
+        }
+
+        public UnboundedNativeScope() {
+            super(Thread.currentThread());
+            this.segment = newSegment(BLOCK_SIZE);
+        }
+
+        @Override
+        public MemorySegment allocate(long bytesSize, long bytesAlignment) {
+            checkOwnerThread();
+            if (bytesSize > MAX_ALLOC_SIZE) {
+                MemorySegment segment = newSegment(bytesSize, bytesAlignment);
+                return segment.withAccessModes(SCOPE_MASK);
+            }
+            for (int i = 0; i < 2; i++) {
+                long min = segment.address().toRawLongValue();
+                long start = Utils.alignUp(min + sp, bytesAlignment) - min;
+                try {
+                    MemorySegment slice = segment.asSlice(start, bytesSize)
+                            .withAccessModes(SCOPE_MASK);
+                    sp = start + bytesSize;
+                    size += Utils.alignUp(bytesSize, bytesAlignment);
+                    return slice;
+                } catch (IndexOutOfBoundsException ex) {
+                    sp = 0L;
+                    segment = newSegment(BLOCK_SIZE, 1L);
+                }
+            }
+            throw new AssertionError("Cannot get here!");
+        }
+    }
+
+    public static class BoundedNativeScope extends AbstractNativeScope {
+        private final MemorySegment segment;
+        private long sp = 0L;
+
+        @Override
+        public OptionalLong byteSize() {
+            return OptionalLong.of(segment.byteSize());
+        }
+
+        @Override
+        public long allocatedBytes() {
+            return sp;
+        }
+
+        public BoundedNativeScope(long size) {
+            super(Thread.currentThread());
+            this.segment = newSegment(size, 1);
+        }
+
+        @Override
+        public MemorySegment allocate(long bytesSize, long bytesAlignment) {
+            checkOwnerThread();
+            long min = segment.address().toRawLongValue();
+            long start = Utils.alignUp(min + sp, bytesAlignment) - min;
+            try {
+                MemorySegment slice = segment.asSlice(start, bytesSize)
+                        .withAccessModes(SCOPE_MASK);
+                sp = start + bytesSize;
+                return slice;
+            } catch (IndexOutOfBoundsException ex) {
+                throw new OutOfMemoryError("Not enough space left to allocate");
+            }
+        }
+    }
+}
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/CABI.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/CABI.java
new file mode 100644
index 0000000000000..4c24e6d15f386
--- /dev/null
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/CABI.java
@@ -0,0 +1,47 @@
+/*
+ *  Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ *  This code is free software; you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License version 2 only, as
+ *  published by the Free Software Foundation.  Oracle designates this
+ *  particular file as subject to the "Classpath" exception as provided
+ *  by Oracle in the LICENSE file that accompanied this code.
+ *
+ *  This code 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
+ *  version 2 for more details (a copy is included in the LICENSE file that
+ *  accompanied this code).
+ *
+ *  You should have received a copy of the GNU General Public License version
+ *  2 along with this work; if not, write to the Free Software Foundation,
+ *  Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ *   Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ *  or visit www.oracle.com if you need additional information or have any
+ *  questions.
+ *
+ */
+package jdk.internal.foreign;
+
+public enum CABI {
+    SysV,
+    Win64,
+    AArch64;
+
+    public static CABI current() {
+        String arch = System.getProperty("os.arch");
+        String os = System.getProperty("os.name");
+        if (arch.equals("amd64") || arch.equals("x86_64")) {
+            if (os.startsWith("Windows")) {
+                return Win64;
+            } else {
+                return SysV;
+            }
+        } else if (arch.equals("aarch64")) {
+            return AArch64;
+        }
+        throw new UnsupportedOperationException("Unsupported os or arch: " + os + ", " + arch);
+    }
+}
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/LibrariesHelper.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/LibrariesHelper.java
new file mode 100644
index 0000000000000..3417dd0c86f59
--- /dev/null
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/LibrariesHelper.java
@@ -0,0 +1,144 @@
+/*
+ *  Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
+ *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ *  This code is free software; you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License version 2 only, as
+ *  published by the Free Software Foundation.  Oracle designates this
+ *  particular file as subject to the "Classpath" exception as provided
+ *  by Oracle in the LICENSE file that accompanied this code.
+ *
+ *  This code 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
+ *  version 2 for more details (a copy is included in the LICENSE file that
+ *  accompanied this code).
+ *
+ *  You should have received a copy of the GNU General Public License version
+ *  2 along with this work; if not, write to the Free Software Foundation,
+ *  Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ *   Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ *  or visit www.oracle.com if you need additional information or have any
+ *  questions.
+ *
+ */
+package jdk.internal.foreign;
+
+import jdk.incubator.foreign.MemoryAddress;
+
+import java.io.File;
+import jdk.incubator.foreign.LibraryLookup;
+import jdk.internal.loader.NativeLibraries;
+import jdk.internal.loader.NativeLibrary;
+import jdk.internal.ref.CleanerFactory;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Arrays;
+import java.util.IdentityHashMap;
+import java.util.Map;
+import java.util.Optional;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.Supplier;
+
+public final class LibrariesHelper {
+    private LibrariesHelper() {}
+
+    private final static NativeLibraries nativeLibraries =
+            NativeLibraries.rawNativeLibraries(LibrariesHelper.class, true);
+
+    private final static Map loadedLibraries = new IdentityHashMap<>();
+
+    /**
+     * Load the specified shared library.
+     *
+     * @param name Name of the shared library to load.
+     */
+    public static LibraryLookup loadLibrary(String name) {
+        return lookup(() -> nativeLibraries.loadLibrary(LibrariesHelper.class, name),
+                "Library not found: " + name);
+    }
+
+    /**
+     * Load the specified shared library.
+     *
+     * @param path Path of the shared library to load.
+     */
+    public static LibraryLookup load(String path) {
+        File file = new File(path);
+        if (!file.isAbsolute()) {
+            throw new UnsatisfiedLinkError(
+                    "Expecting an absolute path of the library: " + path);
+        }
+        return lookup(() -> nativeLibraries.loadLibrary(LibrariesHelper.class, file),
+                "Library not found: " + path);
+    }
+
+    // return the absolute path of the library of given name by searching
+    // in the given array of paths.
+    private static Optional findLibraryPath(Path[] paths, String libName) {
+         return Arrays.stream(paths).
+              map(p -> p.resolve(System.mapLibraryName(libName))).
+              filter(Files::isRegularFile).map(Path::toAbsolutePath).findFirst();
+    }
+
+    public static LibraryLookup getDefaultLibrary() {
+        return LibraryLookupImpl.DEFAULT_LOOKUP;
+    }
+
+    synchronized static LibraryLookupImpl lookup(Supplier librarySupplier, String notFoundMsg) {
+        NativeLibrary library = librarySupplier.get();
+        if (library == null) {
+            throw new IllegalArgumentException(notFoundMsg);
+        }
+        AtomicInteger refCount = loadedLibraries.computeIfAbsent(library, lib -> new AtomicInteger());
+        refCount.incrementAndGet();
+        LibraryLookupImpl lookup = new LibraryLookupImpl(library);
+        CleanerFactory.cleaner().register(lookup, () -> tryUnload(library));
+        return lookup;
+    }
+
+    synchronized static void tryUnload(NativeLibrary library) {
+        AtomicInteger refCount = loadedLibraries.get(library);
+        if (refCount.decrementAndGet() == 0) {
+            loadedLibraries.remove(library);
+            nativeLibraries.unload(library);
+        }
+    }
+
+    static class LibraryLookupImpl implements LibraryLookup {
+        final NativeLibrary library;
+
+        LibraryLookupImpl(NativeLibrary library) {
+            this.library = library;
+        }
+
+        @Override
+        public Optional lookup(String name) {
+            try {
+                MemoryAddress addr = MemoryAddress.ofLong(library.lookup(name));
+                return Optional.of(new Symbol() { // inner class - retains a link to enclosing lookup
+                    @Override
+                    public String name() {
+                        return name;
+                    }
+
+                    @Override
+                    public MemoryAddress address() {
+                        return addr;
+                    }
+                });
+            } catch (NoSuchMethodException ex) {
+                return Optional.empty();
+            }
+        }
+
+        static LibraryLookup DEFAULT_LOOKUP = new LibraryLookupImpl(NativeLibraries.defaultLibrary);
+    }
+
+    /* used for testing */
+    public static int numLoadedLibraries() {
+        return loadedLibraries.size();
+    }
+}
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/PlatformLayouts.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/PlatformLayouts.java
new file mode 100644
index 0000000000000..10fa96f64b30b
--- /dev/null
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/PlatformLayouts.java
@@ -0,0 +1,296 @@
+/*
+ *  Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ *  This code is free software; you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License version 2 only, as
+ *  published by the Free Software Foundation.  Oracle designates this
+ *  particular file as subject to the "Classpath" exception as provided
+ *  by Oracle in the LICENSE file that accompanied this code.
+ *
+ *  This code 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
+ *  version 2 for more details (a copy is included in the LICENSE file that
+ *  accompanied this code).
+ *
+ *  You should have received a copy of the GNU General Public License version
+ *  2 along with this work; if not, write to the Free Software Foundation,
+ *  Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ *   Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ *  or visit www.oracle.com if you need additional information or have any
+ *  questions.
+ *
+ */
+package jdk.internal.foreign;
+
+import jdk.incubator.foreign.CLinker;
+import jdk.incubator.foreign.MemoryLayout;
+import jdk.incubator.foreign.ValueLayout;
+
+import java.nio.ByteOrder;
+
+import static java.nio.ByteOrder.LITTLE_ENDIAN;
+import static jdk.incubator.foreign.MemoryLayouts.ADDRESS;
+
+public class PlatformLayouts {
+    public static  Z pick(Z sysv, Z win64, Z aarch64) {
+        return switch (CABI.current()) {
+            case SysV -> sysv;
+            case Win64 -> win64;
+            case AArch64 -> aarch64;
+        };
+    }
+
+    public static MemoryLayout asVarArg(MemoryLayout ml) {
+        if (CABI.current() == CABI.Win64) {
+            return Win64.asVarArg(ml);
+        }
+        return ml;
+    }
+
+    private static ValueLayout ofChar(ByteOrder order, long bitSize) {
+        return MemoryLayout.ofValueBits(bitSize, order)
+                .withAttribute(CLinker.TypeKind.ATTR_NAME, CLinker.TypeKind.CHAR);
+    }
+
+    private static ValueLayout ofShort(ByteOrder order, long bitSize) {
+        return MemoryLayout.ofValueBits(bitSize, order)
+                .withAttribute(CLinker.TypeKind.ATTR_NAME, CLinker.TypeKind.SHORT);
+    }
+
+    private static ValueLayout ofInt(ByteOrder order, long bitSize) {
+        return MemoryLayout.ofValueBits(bitSize, order)
+                .withAttribute(CLinker.TypeKind.ATTR_NAME, CLinker.TypeKind.INT);
+    }
+
+    private static ValueLayout ofLong(ByteOrder order, long bitSize) {
+        return MemoryLayout.ofValueBits(bitSize, order)
+                .withAttribute(CLinker.TypeKind.ATTR_NAME, CLinker.TypeKind.LONG);
+    }
+
+    private static ValueLayout ofLongLong(ByteOrder order, long bitSize) {
+        return MemoryLayout.ofValueBits(bitSize, order)
+                .withAttribute(CLinker.TypeKind.ATTR_NAME, CLinker.TypeKind.LONGLONG);
+    }
+
+    private static ValueLayout ofFloat(ByteOrder order, long bitSize) {
+        return MemoryLayout.ofValueBits(bitSize, order)
+                .withAttribute(CLinker.TypeKind.ATTR_NAME, CLinker.TypeKind.FLOAT);
+    }
+
+    private static ValueLayout ofDouble(ByteOrder order, long bitSize) {
+        return MemoryLayout.ofValueBits(bitSize, order)
+                .withAttribute(CLinker.TypeKind.ATTR_NAME, CLinker.TypeKind.DOUBLE);
+    }
+
+    private static ValueLayout ofLongDouble(ByteOrder order, long bitSize) {
+        return MemoryLayout.ofValueBits(bitSize, order)
+                .withAttribute(CLinker.TypeKind.ATTR_NAME, CLinker.TypeKind.LONGDOUBLE);
+    }
+
+    private static ValueLayout ofPointer(ByteOrder order, long bitSize) {
+        return MemoryLayout.ofValueBits(bitSize, order)
+                .withAttribute(CLinker.TypeKind.ATTR_NAME, CLinker.TypeKind.POINTER);
+    }
+
+    public static CLinker.TypeKind getKind(MemoryLayout layout) {
+        return (CLinker.TypeKind)layout.attribute(CLinker.TypeKind.ATTR_NAME).orElseThrow(
+            () -> new IllegalStateException("Unexpected value layout: could not determine ABI class"));
+    }
+
+    /**
+     * This class defines layout constants modelling standard primitive types supported by the x64 SystemV ABI.
+     */
+    public static final class SysV {
+        private SysV() {
+            //just the one
+        }
+
+        /**
+         * The {@code char} native type.
+         */
+        public static final ValueLayout C_CHAR = ofChar(LITTLE_ENDIAN, 8);
+
+        /**
+         * The {@code short} native type.
+         */
+        public static final ValueLayout C_SHORT = ofShort(LITTLE_ENDIAN, 16);
+
+        /**
+         * The {@code int} native type.
+         */
+        public static final ValueLayout C_INT = ofInt(LITTLE_ENDIAN, 32);
+
+        /**
+         * The {@code long} native type.
+         */
+        public static final ValueLayout C_LONG = ofLong(LITTLE_ENDIAN, 64);
+
+        /**
+         * The {@code long long} native type.
+         */
+        public static final ValueLayout C_LONGLONG = ofLongLong(LITTLE_ENDIAN, 64);
+
+        /**
+         * The {@code float} native type.
+         */
+        public static final ValueLayout C_FLOAT = ofFloat(LITTLE_ENDIAN, 32);
+
+        /**
+         * The {@code double} native type.
+         */
+        public static final ValueLayout C_DOUBLE = ofDouble(LITTLE_ENDIAN, 64);
+
+        /**
+         * The {@code long double} native type.
+         */
+        public static final ValueLayout C_LONGDOUBLE = ofLongDouble(LITTLE_ENDIAN, 128);
+
+        /**
+         * The {@code T*} native type.
+         */
+        public static final ValueLayout C_POINTER = ofPointer(LITTLE_ENDIAN, ADDRESS.bitSize());
+
+        /**
+         * The {@code va_list} native type, as it is passed to a function.
+         */
+        public static final MemoryLayout C_VA_LIST = SysV.C_POINTER;
+    }
+
+    /**
+     * This class defines layout constants modelling standard primitive types supported by the x64 Windows ABI.
+     */
+    public static final class Win64 {
+
+        private Win64() {
+            //just the one
+        }
+
+        /**
+         * The name of the layout attribute (see {@link MemoryLayout#attributes()} used to mark variadic parameters. The
+         * attribute value must be a boolean.
+         */
+        public final static String VARARGS_ATTRIBUTE_NAME = "abi/windows/varargs";
+
+        /**
+         * The {@code char} native type.
+         */
+        public static final ValueLayout C_CHAR = ofChar(LITTLE_ENDIAN, 8);
+
+        /**
+         * The {@code short} native type.
+         */
+        public static final ValueLayout C_SHORT = ofShort(LITTLE_ENDIAN, 16);
+
+        /**
+         * The {@code int} native type.
+         */
+        public static final ValueLayout C_INT = ofInt(LITTLE_ENDIAN, 32);
+        /**
+         * The {@code long} native type.
+         */
+        public static final ValueLayout C_LONG = ofLong(LITTLE_ENDIAN, 32);
+
+        /**
+         * The {@code long long} native type.
+         */
+        public static final ValueLayout C_LONGLONG = ofLongLong(LITTLE_ENDIAN, 64);
+
+        /**
+         * The {@code float} native type.
+         */
+        public static final ValueLayout C_FLOAT = ofFloat(LITTLE_ENDIAN, 32);
+
+        /**
+         * The {@code double} native type.
+         */
+        public static final ValueLayout C_DOUBLE = ofDouble(LITTLE_ENDIAN, 64);
+
+        /**
+         * The {@code long double} native type.
+         */
+        public static final ValueLayout C_LONGDOUBLE = ofLongDouble(LITTLE_ENDIAN, 64);
+
+        /**
+         * The {@code T*} native type.
+         */
+        public static final ValueLayout C_POINTER = ofPointer(LITTLE_ENDIAN, ADDRESS.bitSize());
+
+        /**
+         * The {@code va_list} native type, as it is passed to a function.
+         */
+        public static final MemoryLayout C_VA_LIST = Win64.C_POINTER;
+
+        /**
+         * Return a new memory layout which describes a variadic parameter to be passed to a function.
+         * @param layout the original parameter layout.
+         * @return a layout which is the same as {@code layout}, except for the extra attribute {@link #VARARGS_ATTRIBUTE_NAME},
+         * which is set to {@code true}.
+         */
+        public static MemoryLayout asVarArg(MemoryLayout layout) {
+            return layout.withAttribute(VARARGS_ATTRIBUTE_NAME, true);
+        }
+    }
+
+    /**
+     * This class defines layout constants modelling standard primitive types supported by the AArch64 ABI.
+     */
+    public static final class AArch64 {
+
+        private AArch64() {
+            //just the one
+        }
+
+        /**
+         * The {@code char} native type.
+         */
+        public static final ValueLayout C_CHAR = ofChar(LITTLE_ENDIAN, 8);
+
+        /**
+         * The {@code short} native type.
+         */
+        public static final ValueLayout C_SHORT = ofShort(LITTLE_ENDIAN, 16);
+
+        /**
+         * The {@code int} native type.
+         */
+        public static final ValueLayout C_INT = ofInt(LITTLE_ENDIAN, 32);
+
+        /**
+         * The {@code long} native type.
+         */
+        public static final ValueLayout C_LONG = ofLong(LITTLE_ENDIAN, 64);
+
+        /**
+         * The {@code long long} native type.
+         */
+        public static final ValueLayout C_LONGLONG = ofLongLong(LITTLE_ENDIAN, 64);
+
+        /**
+         * The {@code float} native type.
+         */
+        public static final ValueLayout C_FLOAT = ofFloat(LITTLE_ENDIAN, 32);
+
+        /**
+         * The {@code double} native type.
+         */
+        public static final ValueLayout C_DOUBLE = ofDouble(LITTLE_ENDIAN, 64);
+
+        /**
+         * The {@code long double} native type.
+         */
+        public static final ValueLayout C_LONGDOUBLE = ofLongDouble(LITTLE_ENDIAN, 128);
+
+        /**
+         * The {@code T*} native type.
+         */
+        public static final ValueLayout C_POINTER = ofPointer(LITTLE_ENDIAN, ADDRESS.bitSize());
+
+        /**
+         * The {@code va_list} native type, as it is passed to a function.
+         */
+        public static final MemoryLayout C_VA_LIST = AArch64.C_POINTER;
+    }
+}
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/Utils.java.rej b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/Utils.java.rej
new file mode 100644
index 0000000000000..5d51563157596
--- /dev/null
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/Utils.java.rej
@@ -0,0 +1,14 @@
+diff a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/Utils.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/Utils.java	(rejected hunks)
+@@ -28,9 +28,12 @@ package jdk.internal.foreign;
+ 
+ import jdk.incubator.foreign.MemoryAddress;
+ import jdk.incubator.foreign.MemoryHandles;
++import jdk.incubator.foreign.MemoryLayout;
+ import jdk.incubator.foreign.MemorySegment;
++import jdk.incubator.foreign.ValueLayout;
+ import jdk.internal.access.foreign.MemorySegmentProxy;
+ import jdk.internal.misc.VM;
++import sun.invoke.util.Wrapper;
+ 
+ import java.lang.invoke.MethodHandle;
+ import java.lang.invoke.MethodHandles;
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/ABIDescriptor.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/ABIDescriptor.java
new file mode 100644
index 0000000000000..25a00812bf26e
--- /dev/null
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/ABIDescriptor.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package jdk.internal.foreign.abi;
+
+import jdk.internal.invoke.ABIDescriptorProxy;
+
+public class ABIDescriptor implements ABIDescriptorProxy {
+    final Architecture arch;
+
+    public final VMStorage[][] inputStorage;
+    public final VMStorage[][] outputStorage;
+
+    final VMStorage[][] volatileStorage;
+
+    final int stackAlignment;
+    final int shadowSpace;
+
+    public ABIDescriptor(Architecture arch, VMStorage[][] inputStorage, VMStorage[][] outputStorage,
+                         VMStorage[][] volatileStorage, int stackAlignment, int shadowSpace) {
+        this.arch = arch;
+        this.inputStorage = inputStorage;
+        this.outputStorage = outputStorage;
+        this.volatileStorage = volatileStorage;
+        this.stackAlignment = stackAlignment;
+        this.shadowSpace = shadowSpace;
+    }
+
+    @Override
+    public int shadowSpaceBytes() {
+        return shadowSpace;
+    }
+}
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/Architecture.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/Architecture.java
new file mode 100644
index 0000000000000..4c73d069247ed
--- /dev/null
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/Architecture.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package jdk.internal.foreign.abi;
+
+public interface Architecture {
+    boolean isStackType(int cls);
+    int typeSize(int cls);
+    int stackType();
+}
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/Binding.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/Binding.java
new file mode 100644
index 0000000000000..0b7bae3997627
--- /dev/null
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/Binding.java
@@ -0,0 +1,1027 @@
+/*
+ * Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package jdk.internal.foreign.abi;
+
+import jdk.incubator.foreign.MemoryAddress;
+import jdk.incubator.foreign.MemoryHandles;
+import jdk.incubator.foreign.MemoryLayout;
+import jdk.incubator.foreign.MemorySegment;
+import jdk.internal.foreign.MemoryAddressImpl;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
+import java.util.ArrayList;
+import java.util.Deque;
+import java.util.List;
+import java.util.Objects;
+
+import java.lang.invoke.VarHandle;
+import java.nio.ByteOrder;
+
+import static java.lang.invoke.MethodHandles.collectArguments;
+import static java.lang.invoke.MethodHandles.filterArguments;
+import static java.lang.invoke.MethodHandles.insertArguments;
+import static java.lang.invoke.MethodHandles.permuteArguments;
+import static java.lang.invoke.MethodType.methodType;
+
+/**
+ * The binding operators defined in the Binding class can be combined into argument and return value processing 'recipes'.
+ *
+ * The binding operators are interpreted using a stack-base interpreter. Operators can either consume operands from the
+ * stack, or push them onto the stack.
+ *
+ * In the description of each binding we talk about 'boxing' and 'unboxing'.
+ *  - Unboxing is the process of taking a Java value and decomposing it, and storing components into machine
+ *    storage locations. As such, the binding interpreter stack starts with the Java value on it, and should end empty.
+ *  - Boxing is the process of re-composing a Java value by pulling components from machine storage locations.
+ *    If a MemorySegment is needed to store the result, one should be allocated using the ALLOCATE_BUFFER operator.
+ *    The binding interpreter stack starts off empty, and ends with the value to be returned as the only value on it.
+ * A binding operator can be interpreted differently based on whether we are boxing or unboxing a value. For example,
+ * the CONVERT_ADDRESS operator 'unboxes' a MemoryAddress to a long, but 'boxes' a long to a MemoryAddress.
+ *
+ * Here are some examples of binding recipes derived from C declarations, and according to the Windows ABI (recipes are
+ * ABI-specific). Note that each argument has it's own recipe, which is indicated by '[number]:' (though, the only
+ * example that has multiple arguments is the one using varargs).
+ *
+ * --------------------
+ *
+ * void f(int i);
+ *
+ * Argument bindings:
+ * 0: VM_STORE(rcx, int.class) // move an 'int' into the RCX register
+ *
+ * Return bindings:
+ * none
+ *
+ * --------------------
+ *
+ * void f(int* i);
+ *
+ * Argument bindings:
+ * 0: UNBOX_ADDRESS // the 'MemoryAddress' is converted into a 'long'
+ *    VM_STORE(rcx, long.class) // the 'long' is moved into the RCX register
+ *
+ * Return bindings:
+ * none
+ *
+ * --------------------
+ *
+ * int* f();
+ *
+ * Argument bindings:
+ * none
+ *
+ * Return bindings:
+ * 0: VM_LOAD(rax, long) // load a 'long' from the RAX register
+ *    BOX_ADDRESS // convert the 'long' into a 'MemoryAddress'
+ *
+ * --------------------
+ *
+ * typedef struct { // fits into single register
+ *   int x;
+ *   int y;
+ * } MyStruct;
+ *
+ * void f(MyStruct ms);
+ *
+ * Argument bindings:
+ * 0: BUFFER_LOAD(0, long.class) // From the struct's memory region, load a 'long' from offset '0'
+ *    VM_STORE(rcx, long.class) // and copy that into the RCX register
+ *
+ * Return bindings:
+ * none
+ *
+ * --------------------
+ *
+ * typedef struct { // does not fit into single register
+ *   long long x;
+ *   long long y;
+ * } MyStruct;
+ *
+ * void f(MyStruct ms);
+ *
+ * For the Windows ABI:
+ *
+ * Argument bindings:
+ * 0: COPY(16, 8) // copy the memory region containing the struct
+ *    BASE_ADDRESS // take the base address of the copy
+ *    UNBOX_ADDRESS // converts the base address to a 'long'
+ *    VM_STORE(rcx, long.class) // moves the 'long' into the RCX register
+ *
+ * Return bindings:
+ * none
+ *
+ * For the SysV ABI:
+ *
+ * Argument bindings:
+ * 0: DUP // duplicates the MemoryRegion operand
+ *    BUFFER_LOAD(0, long.class) // loads a 'long' from offset '0'
+ *    VM_STORE(rdx, long.class) // moves the long into the RDX register
+ *    BUFFER_LOAD(8, long.class) // loads a 'long' from offset '8'
+ *    VM_STORE(rcx, long.class) // moves the long into the RCX register
+ *
+ * Return bindings:
+ * none
+ *
+ * --------------------
+ *
+ * typedef struct { // fits into single register
+ *   int x;
+ *   int y;
+ * } MyStruct;
+ *
+ * MyStruct f();
+ *
+ * Argument bindings:
+ * none
+ *
+ * Return bindings:
+ * 0: ALLOCATE(GroupLayout(C_INT, C_INT)) // allocate a buffer with the memory layout of the struct
+ *    DUP // duplicate the allocated buffer
+ *    VM_LOAD(rax, long.class) // loads a 'long' from rax
+ *    BUFFER_STORE(0, long.class) // stores a 'long' at offset 0
+ *
+ * --------------------
+ *
+ * typedef struct { // does not fit into single register
+ *   long long x;
+ *   long long y;
+ * } MyStruct;
+ *
+ * MyStruct f();
+ *
+ * !! uses synthetic argument, which is a pointer to a pre-allocated buffer
+ *
+ * Argument bindings:
+ * 0: UNBOX_ADDRESS // unbox the MemoryAddress synthetic argument
+ *    VM_STORE(rcx, long.class) // moves the 'long' into the RCX register
+ *
+ * Return bindings:
+ * none
+ *
+ * --------------------
+ *
+ * void f(int dummy, ...); // varargs
+ *
+ * f(0, 10f); // passing a float
+ *
+ * Argument bindings:
+ * 0: VM_STORE(rcx, int.class) // moves the 'int dummy' into the RCX register
+ *
+ * 1: DUP // duplicates the '10f' argument
+ *    VM_STORE(rdx, float.class) // move one copy into the RDX register
+ *    VM_STORE(xmm1, float.class) // moves the other copy into the xmm2 register
+ *
+ * Return bindings:
+ * none
+ *
+ * --------------------
+ */
+public abstract class Binding {
+    private static final MethodHandle MH_UNBOX_ADDRESS;
+    private static final MethodHandle MH_BOX_ADDRESS;
+    private static final MethodHandle MH_BASE_ADDRESS;
+    private static final MethodHandle MH_COPY_BUFFER;
+    private static final MethodHandle MH_ALLOCATE_BUFFER;
+    private static final MethodHandle MH_TO_SEGMENT;
+
+    static {
+        try {
+            MethodHandles.Lookup lookup = MethodHandles.lookup();
+            MH_UNBOX_ADDRESS = lookup.findVirtual(MemoryAddress.class, "toRawLongValue",
+                    methodType(long.class));
+            MH_BOX_ADDRESS = lookup.findStatic(MemoryAddress.class, "ofLong",
+                    methodType(MemoryAddress.class, long.class));
+            MH_BASE_ADDRESS = lookup.findVirtual(MemorySegment.class, "address",
+                    methodType(MemoryAddress.class));
+            MH_COPY_BUFFER = lookup.findStatic(Binding.Copy.class, "copyBuffer",
+                    methodType(MemorySegment.class, MemorySegment.class, long.class, long.class, SharedUtils.Allocator.class));
+            MH_ALLOCATE_BUFFER = lookup.findStatic(Binding.Allocate.class, "allocateBuffer",
+                    methodType(MemorySegment.class, long.class, long.class, SharedUtils.Allocator.class));
+            MH_TO_SEGMENT = lookup.findStatic(Binding.ToSegment.class, "toSegment",
+                    methodType(MemorySegment.class, MemoryAddress.class, long.class));
+        } catch (ReflectiveOperationException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    enum Tag {
+        VM_STORE,
+        VM_LOAD,
+        BUFFER_STORE,
+        BUFFER_LOAD,
+        COPY_BUFFER,
+        ALLOC_BUFFER,
+        BOX_ADDRESS,
+        UNBOX_ADDRESS,
+        BASE_ADDRESS,
+        TO_SEGMENT,
+        DUP
+    }
+
+    private final Tag tag;
+
+    private Binding(Tag tag) {
+        this.tag = tag;
+    }
+
+    public Tag tag() {
+        return tag;
+    }
+
+    public abstract void verify(Deque> stack);
+
+    public abstract void interpret(Deque stack, BindingInterpreter.StoreFunc storeFunc,
+                                   BindingInterpreter.LoadFunc loadFunc, SharedUtils.Allocator allocator);
+
+    public abstract MethodHandle specialize(MethodHandle specializedHandle, int insertPos, int allocatorPos);
+
+    private static MethodHandle mergeArguments(MethodHandle mh, int sourceIndex, int destIndex) {
+        MethodType oldType = mh.type();
+        Class sourceType = oldType.parameterType(sourceIndex);
+        Class destType = oldType.parameterType(destIndex);
+        if (sourceType != destType) {
+            // TODO meet?
+            throw new IllegalArgumentException("Parameter types differ: " + sourceType + " != " + destType);
+        }
+        MethodType newType = oldType.dropParameterTypes(destIndex, destIndex + 1);
+        int[] reorder = new int[oldType.parameterCount()];
+        assert destIndex > sourceIndex;
+        for (int i = 0, index = 0; i < reorder.length; i++) {
+            if (i != destIndex) {
+                reorder[i] = index++;
+            } else {
+                reorder[i] = sourceIndex;
+            }
+        }
+        return permuteArguments(mh, newType, reorder);
+    }
+
+    private static void checkType(Class type) {
+        if (!type.isPrimitive() || type == void.class || type == boolean.class)
+            throw new IllegalArgumentException("Illegal type: " + type);
+    }
+
+    private static void checkOffset(long offset) {
+        if (offset < 0)
+            throw new IllegalArgumentException("Negative offset: " + offset);
+    }
+
+    public static VMStore vmStore(VMStorage storage, Class type) {
+        checkType(type);
+        return new VMStore(storage, type);
+    }
+
+    public static VMLoad vmLoad(VMStorage storage, Class type) {
+        checkType(type);
+        return new VMLoad(storage, type);
+    }
+
+    public static BufferStore bufferStore(long offset, Class type) {
+        checkType(type);
+        checkOffset(offset);
+        return new BufferStore(offset, type);
+    }
+
+    public static BufferLoad bufferLoad(long offset, Class type) {
+        checkType(type);
+        checkOffset(offset);
+        return new BufferLoad(offset, type);
+    }
+
+    public static Copy copy(MemoryLayout layout) {
+        return new Copy(layout.byteSize(), layout.byteAlignment());
+    }
+
+    public static Allocate allocate(MemoryLayout layout) {
+        return new Allocate(layout.byteSize(), layout.byteAlignment());
+    }
+
+    public static BoxAddress boxAddress() {
+        return BoxAddress.INSTANCE;
+    }
+
+    public static UnboxAddress unboxAddress() {
+        return UnboxAddress.INSTANCE;
+    }
+
+    public static BaseAddress baseAddress() {
+        return BaseAddress.INSTANCE;
+    }
+
+    public static ToSegment toSegment(MemoryLayout layout) {
+        return new ToSegment(layout.byteSize());
+    }
+
+    public static Dup dup() {
+        return Dup.INSTANCE;
+    }
+
+
+    public static Binding.Builder builder() {
+        return new Binding.Builder();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        Binding binding = (Binding) o;
+        return tag == binding.tag;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(tag);
+    }
+
+    /**
+     * A builder helper class for generating lists of Bindings
+     */
+    public static class Builder {
+        private final List bindings = new ArrayList<>();
+
+        public Binding.Builder vmStore(VMStorage storage, Class type) {
+            bindings.add(Binding.vmStore(storage, type));
+            return this;
+        }
+
+        public Binding.Builder vmLoad(VMStorage storage, Class type) {
+            bindings.add(Binding.vmLoad(storage, type));
+            return this;
+        }
+
+        public Binding.Builder bufferStore(long offset, Class type) {
+            bindings.add(Binding.bufferStore(offset, type));
+            return this;
+        }
+
+        public Binding.Builder bufferLoad(long offset, Class type) {
+            bindings.add(Binding.bufferLoad(offset, type));
+            return this;
+        }
+
+        public Binding.Builder copy(MemoryLayout layout) {
+            bindings.add(Binding.copy(layout));
+            return this;
+        }
+
+        public Binding.Builder allocate(MemoryLayout layout) {
+            bindings.add(Binding.allocate(layout));
+            return this;
+        }
+
+        public Binding.Builder boxAddress() {
+            bindings.add(Binding.boxAddress());
+            return this;
+        }
+
+        public Binding.Builder unboxAddress() {
+            bindings.add(Binding.unboxAddress());
+            return this;
+        }
+
+        public Binding.Builder baseAddress() {
+            bindings.add(Binding.baseAddress());
+            return this;
+        }
+
+        public Binding.Builder toSegment(MemoryLayout layout) {
+            bindings.add(Binding.toSegment(layout));
+            return this;
+        }
+
+        public Binding.Builder dup() {
+            bindings.add(Binding.dup());
+            return this;
+        }
+
+        public List build() {
+            return new ArrayList<>(bindings);
+        }
+    }
+
+    static abstract class Move extends Binding {
+        private final VMStorage storage;
+        private final Class type;
+
+        private Move(Tag tag, VMStorage storage, Class type) {
+            super(tag);
+            this.storage = storage;
+            this.type = type;
+        }
+
+        public VMStorage storage() {
+            return storage;
+        }
+
+        public Class type() {
+            return type;
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) return true;
+            if (o == null || getClass() != o.getClass()) return false;
+            if (!super.equals(o)) return false;
+            Move move = (Move) o;
+            return Objects.equals(storage, move.storage) &&
+                    Objects.equals(type, move.type);
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(super.hashCode(), storage, type);
+        }
+    }
+
+    /**
+     * VM_STORE([storage location], [type])
+     * Pops a [type] from the operand stack, and moves it to [storage location]
+     * The [type] must be one of byte, short, char, int, long, float, or double
+     */
+    public static class VMStore extends Move {
+        private VMStore(VMStorage storage, Class type) {
+            super(Tag.VM_STORE, storage, type);
+        }
+
+        @Override
+        public void verify(Deque> stack) {
+            Class actualType = stack.pop();
+            Class expectedType = type();
+            SharedUtils.checkType(actualType, expectedType);
+        }
+
+        @Override
+        public void interpret(Deque stack, BindingInterpreter.StoreFunc storeFunc,
+                              BindingInterpreter.LoadFunc loadFunc, SharedUtils.Allocator allocator) {
+            storeFunc.store(storage(), type(), stack.pop());
+        }
+
+        @Override
+        public MethodHandle specialize(MethodHandle specializedHandle, int insertPos, int allocatorPos) {
+            return specializedHandle; // no-op
+        }
+
+        @Override
+        public String toString() {
+            return "VMStore{" +
+                    "storage=" + storage() +
+                    ", type=" + type() +
+                    '}';
+        }
+    }
+
+    /**
+     * VM_LOAD([storage location], [type])
+     * Loads a [type] from [storage location], and pushes it onto the operand stack.
+     * The [type] must be one of byte, short, char, int, long, float, or double
+     */
+    public static class VMLoad extends Move {
+        private VMLoad(VMStorage storage, Class type) {
+            super(Tag.VM_LOAD, storage, type);
+        }
+
+        @Override
+        public void verify(Deque> stack) {
+            stack.push(type());
+        }
+
+        @Override
+        public void interpret(Deque stack, BindingInterpreter.StoreFunc storeFunc,
+                              BindingInterpreter.LoadFunc loadFunc, SharedUtils.Allocator allocator) {
+            stack.push(loadFunc.load(storage(), type()));
+        }
+
+        @Override
+        public MethodHandle specialize(MethodHandle specializedHandle, int insertPos, int allocatorPos) {
+            return specializedHandle; // no-op
+        }
+
+        @Override
+        public String toString() {
+            return "VMLoad{" +
+                    "storage=" + storage() +
+                    ", type=" + type() +
+                    '}';
+        }
+    }
+
+    private static abstract class Dereference extends Binding {
+        private final long offset;
+        private final Class type;
+
+        private Dereference(Tag tag, long offset, Class type) {
+            super(tag);
+            this.offset = offset;
+            this.type = type;
+        }
+
+        public long offset() {
+            return offset;
+        }
+
+        public Class type() {
+            return type;
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) return true;
+            if (o == null || getClass() != o.getClass()) return false;
+            if (!super.equals(o)) return false;
+            Dereference that = (Dereference) o;
+            return offset == that.offset &&
+                    Objects.equals(type, that.type);
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(super.hashCode(), offset, type);
+        }
+
+        public VarHandle varHandle() {
+            return MemoryHandles.insertCoordinates(MemoryHandles.varHandle(type, ByteOrder.nativeOrder()), 1, offset);
+        }
+    }
+
+    /**
+     * BUFFER_STORE([offset into memory region], [type])
+     * Pops a MemorySegment from the operand stack, loads a [type] from
+     * [offset into memory region] from it, and pushes it onto the operand stack.
+     * The [type] must be one of byte, short, char, int, long, float, or double
+     */
+    public static class BufferStore extends Dereference {
+        private BufferStore(long offset, Class type) {
+            super(Tag.BUFFER_STORE, offset, type);
+        }
+
+        @Override
+        public void verify(Deque> stack) {
+            Class storeType = stack.pop();
+            SharedUtils.checkType(storeType, type());
+            Class segmentType = stack.pop();
+            SharedUtils.checkType(segmentType, MemorySegment.class);
+        }
+
+        @Override
+        public void interpret(Deque stack, BindingInterpreter.StoreFunc storeFunc,
+                              BindingInterpreter.LoadFunc loadFunc, SharedUtils.Allocator allocator) {
+            Object value = stack.pop();
+            MemorySegment operand = (MemorySegment) stack.pop();
+            MemorySegment writeAddress = operand.asSlice(offset());
+            SharedUtils.write(writeAddress, type(), value);
+        }
+
+        @Override
+        public MethodHandle specialize(MethodHandle specializedHandle, int insertPos, int allocatorPos) {
+            MethodHandle setter = varHandle().toMethodHandle(VarHandle.AccessMode.SET);
+            setter = setter.asType(methodType(void.class, MemorySegment.class, type()));
+            return collectArguments(specializedHandle, insertPos + 1, setter);
+        }
+
+        @Override
+        public String toString() {
+            return "BufferStore{" +
+                    "offset=" + offset() +
+                    ", type=" + type() +
+                    '}';
+        }
+    }
+
+    /**
+     * BUFFER_LOAD([offset into memory region], [type])
+     * Pops a [type], and then a MemorySegment from the operand stack,
+     * and then stores [type] to [offset into memory region] of the MemorySegment.
+     * The [type] must be one of byte, short, char, int, long, float, or double
+     */
+    public static class BufferLoad extends Dereference {
+        private BufferLoad(long offset, Class type) {
+            super(Tag.BUFFER_LOAD, offset, type);
+        }
+
+        @Override
+        public void verify(Deque> stack) {
+            Class actualType = stack.pop();
+            SharedUtils.checkType(actualType, MemorySegment.class);
+            Class newType = type();
+            stack.push(newType);
+        }
+
+        @Override
+        public void interpret(Deque stack, BindingInterpreter.StoreFunc storeFunc,
+                              BindingInterpreter.LoadFunc loadFunc, SharedUtils.Allocator allocator) {
+            MemorySegment operand = (MemorySegment) stack.pop();
+            MemorySegment readAddress = operand.asSlice(offset());
+            stack.push(SharedUtils.read(readAddress, type()));
+        }
+
+        @Override
+        public MethodHandle specialize(MethodHandle specializedHandle, int insertPos, int allocatorPos) {
+            MethodHandle filter = varHandle()
+                    .toMethodHandle(VarHandle.AccessMode.GET)
+                    .asType(methodType(type(), MemorySegment.class));
+            return filterArguments(specializedHandle, insertPos, filter);
+        }
+
+        @Override
+        public String toString() {
+            return "BufferLoad{" +
+                    "offset=" + offset() +
+                    ", type=" + type() +
+                    '}';
+        }
+    }
+
+    /**
+     * COPY([size], [alignment])
+     *   Creates a new MemorySegment with the given [size] and [alignment],
+     *     and copies contents from a MemorySegment popped from the top of the operand stack into this new buffer,
+     *     and pushes the new buffer onto the operand stack
+     */
+    public static class Copy extends Binding {
+        private final long size;
+        private final long alignment;
+
+        private Copy(long size, long alignment) {
+            super(Tag.COPY_BUFFER);
+            this.size = size;
+            this.alignment = alignment;
+        }
+
+        private static MemorySegment copyBuffer(MemorySegment operand, long size, long alignment,
+                                                    SharedUtils.Allocator allocator) {
+            MemorySegment copy = allocator.allocate(size, alignment);
+            copy.copyFrom(operand.asSlice(0, size));
+            return copy;
+        }
+
+        public long size() {
+            return size;
+        }
+
+        public long alignment() {
+            return alignment;
+        }
+
+        @Override
+        public String toString() {
+            return "Copy{" +
+                    "tag=" + tag() +
+                    ", size=" + size +
+                    ", alignment=" + alignment +
+                    '}';
+        }
+
+        @Override
+        public void verify(Deque> stack) {
+            Class actualType = stack.pop();
+            SharedUtils.checkType(actualType, MemorySegment.class);
+            stack.push(MemorySegment.class);
+        }
+
+        @Override
+        public void interpret(Deque stack, BindingInterpreter.StoreFunc storeFunc,
+                              BindingInterpreter.LoadFunc loadFunc, SharedUtils.Allocator allocator) {
+            MemorySegment operand = (MemorySegment) stack.pop();
+            MemorySegment copy = copyBuffer(operand, size, alignment, allocator);
+            stack.push(copy);
+        }
+
+        @Override
+        public MethodHandle specialize(MethodHandle specializedHandle, int insertPos, int allocatorPos) {
+            MethodHandle filter = insertArguments(MH_COPY_BUFFER, 1, size, alignment);
+            specializedHandle = collectArguments(specializedHandle, insertPos, filter);
+            return mergeArguments(specializedHandle, allocatorPos, insertPos + 1);
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) return true;
+            if (o == null || getClass() != o.getClass()) return false;
+            if (!super.equals(o)) return false;
+            Copy copy = (Copy) o;
+            return size == copy.size &&
+                    alignment == copy.alignment;
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(super.hashCode(), size, alignment);
+        }
+    }
+
+    /**
+     * ALLOCATE([size], [alignment])
+     *   Creates a new MemorySegment with the give [size] and [alignment], and pushes it onto the operand stack.
+     */
+    public static class Allocate extends Binding {
+        private final long size;
+        private final long alignment;
+
+        private Allocate(long size, long alignment) {
+            super(Tag.ALLOC_BUFFER);
+            this.size = size;
+            this.alignment = alignment;
+        }
+
+        private static MemorySegment allocateBuffer(long size, long allignment, SharedUtils.Allocator allocator) {
+            return allocator.allocate(size, allignment);
+        }
+
+        public long size() {
+            return size;
+        }
+
+        public long alignment() {
+            return alignment;
+        }
+
+        @Override
+        public String toString() {
+            return "AllocateBuffer{" +
+                    "tag=" + tag() +
+                    "size=" + size +
+                    ", alignment=" + alignment +
+                    '}';
+        }
+
+        @Override
+        public void verify(Deque> stack) {
+            stack.push(MemorySegment.class);
+        }
+
+        @Override
+        public void interpret(Deque stack, BindingInterpreter.StoreFunc storeFunc,
+                              BindingInterpreter.LoadFunc loadFunc, SharedUtils.Allocator allocator) {
+            stack.push(allocateBuffer(size, alignment, allocator));
+        }
+
+        @Override
+        public MethodHandle specialize(MethodHandle specializedHandle, int insertPos, int allocatorPos) {
+            MethodHandle allocateBuffer = insertArguments(MH_ALLOCATE_BUFFER, 0, size, alignment);
+            specializedHandle = collectArguments(specializedHandle, insertPos, allocateBuffer);
+            return mergeArguments(specializedHandle, allocatorPos, insertPos);
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) return true;
+            if (o == null || getClass() != o.getClass()) return false;
+            if (!super.equals(o)) return false;
+            Allocate allocate = (Allocate) o;
+            return size == allocate.size &&
+                    alignment == allocate.alignment;
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(super.hashCode(), size, alignment);
+        }
+    }
+
+    /**
+     * UNBOX_ADDRESS()
+     * Pops a 'MemoryAddress' from the operand stack, converts it to a 'long',
+     *     and pushes that onto the operand stack.
+     */
+    public static class UnboxAddress extends Binding {
+        private static final UnboxAddress INSTANCE = new UnboxAddress();
+        private UnboxAddress() {
+            super(Tag.UNBOX_ADDRESS);
+        }
+
+        @Override
+        public void verify(Deque> stack) {
+            Class actualType = stack.pop();
+            SharedUtils.checkType(actualType, MemoryAddress.class);
+            stack.push(long.class);
+        }
+
+        @Override
+        public void interpret(Deque stack, BindingInterpreter.StoreFunc storeFunc,
+                              BindingInterpreter.LoadFunc loadFunc, SharedUtils.Allocator allocator) {
+            stack.push(((MemoryAddress)stack.pop()).toRawLongValue());
+        }
+
+        @Override
+        public MethodHandle specialize(MethodHandle specializedHandle, int insertPos, int allocatorPos) {
+            return filterArguments(specializedHandle, insertPos, MH_UNBOX_ADDRESS);
+        }
+
+        @Override
+        public String toString() {
+            return "UnboxAddress{}";
+        }
+    }
+
+    /**
+     * Box_ADDRESS()
+     * Pops a 'long' from the operand stack, converts it to a 'MemoryAddress',
+     *     and pushes that onto the operand stack.
+     */
+    public static class BoxAddress extends Binding {
+        private static final BoxAddress INSTANCE = new BoxAddress();
+        private BoxAddress() {
+            super(Tag.BOX_ADDRESS);
+        }
+
+        @Override
+        public void verify(Deque> stack) {
+            Class actualType = stack.pop();
+            SharedUtils.checkType(actualType, long.class);
+            stack.push(MemoryAddress.class);
+        }
+
+        @Override
+        public void interpret(Deque stack, BindingInterpreter.StoreFunc storeFunc,
+                              BindingInterpreter.LoadFunc loadFunc, SharedUtils.Allocator allocator) {
+            stack.push(MemoryAddress.ofLong((long) stack.pop()));
+        }
+
+        @Override
+        public MethodHandle specialize(MethodHandle specializedHandle, int insertPos, int allocatorPos) {
+            return filterArguments(specializedHandle, insertPos, MH_BOX_ADDRESS);
+        }
+
+        @Override
+        public String toString() {
+            return "BoxAddress{}";
+        }
+    }
+
+    /**
+     * BASE_ADDRESS()
+     *   Pops a MemorySegment from the operand stack, and takes the base address of the segment
+     *   (the MemoryAddress that points to the start), and pushes that onto the operand stack
+     */
+    public static class BaseAddress extends Binding {
+        private static final BaseAddress INSTANCE = new BaseAddress();
+        private BaseAddress() {
+            super(Tag.BASE_ADDRESS);
+        }
+
+        @Override
+        public void verify(Deque> stack) {
+            Class actualType = stack.pop();
+            SharedUtils.checkType(actualType, MemorySegment.class);
+            stack.push(MemoryAddress.class);
+        }
+
+        @Override
+        public void interpret(Deque stack, BindingInterpreter.StoreFunc storeFunc,
+                              BindingInterpreter.LoadFunc loadFunc, SharedUtils.Allocator allocator) {
+            stack.push(((MemorySegment) stack.pop()).address());
+        }
+
+        @Override
+        public MethodHandle specialize(MethodHandle specializedHandle, int insertPos, int allocatorPos) {
+            return filterArguments(specializedHandle, insertPos, MH_BASE_ADDRESS);
+        }
+
+        @Override
+        public String toString() {
+            return "BaseAddress{}";
+        }
+    }
+
+    /**
+     * BASE_ADDRESS([size])
+     *   Pops a MemoryAddress from the operand stack, and takes the converts it to a MemorySegment
+     *   with the given size, and pushes that onto the operand stack
+     */
+    public static class ToSegment extends Binding {
+        private final long size;
+        // FIXME alignment?
+
+        public ToSegment(long size) {
+            super(Tag.TO_SEGMENT);
+            this.size = size;
+        }
+
+        // FIXME should register with scope
+        private static MemorySegment toSegment(MemoryAddress operand, long size) {
+            return MemoryAddressImpl.ofLongUnchecked(operand.toRawLongValue(), size);
+        }
+
+        @Override
+        public void verify(Deque> stack) {
+            Class actualType = stack.pop();
+            SharedUtils.checkType(actualType, MemoryAddress.class);
+            stack.push(MemorySegment.class);
+        }
+
+        @Override
+        public void interpret(Deque stack, BindingInterpreter.StoreFunc storeFunc,
+                              BindingInterpreter.LoadFunc loadFunc, SharedUtils.Allocator allocator) {
+            MemoryAddress operand = (MemoryAddress) stack.pop();
+            MemorySegment segment = toSegment(operand, size);
+            stack.push(segment);
+        }
+
+        @Override
+        public MethodHandle specialize(MethodHandle specializedHandle, int insertPos, int allocatorPos) {
+            MethodHandle toSegmentHandle = insertArguments(MH_TO_SEGMENT, 1, size);
+            return filterArguments(specializedHandle, insertPos, toSegmentHandle);
+        }
+
+        @Override
+        public String toString() {
+            return "ToSegemnt{" +
+                    "size=" + size +
+                    '}';
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) return true;
+            if (o == null || getClass() != o.getClass()) return false;
+            if (!super.equals(o)) return false;
+            ToSegment toSegemnt = (ToSegment) o;
+            return size == toSegemnt.size;
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(super.hashCode(), size);
+        }
+    }
+
+    /**
+     * DUP()
+     *   Duplicates the value on the top of the operand stack (without popping it!),
+     *   and pushes the duplicate onto the operand stack
+     */
+    public static class Dup extends Binding {
+        private static final Dup INSTANCE = new Dup();
+        private Dup() {
+            super(Tag.DUP);
+        }
+
+        @Override
+        public void verify(Deque> stack) {
+            stack.push(stack.peekLast());
+        }
+
+        @Override
+        public void interpret(Deque stack, BindingInterpreter.StoreFunc storeFunc,
+                              BindingInterpreter.LoadFunc loadFunc, SharedUtils.Allocator allocator) {
+            stack.push(stack.peekLast());
+        }
+
+        /*
+         * Fixes up Y-shaped data graphs (produced by DEREFERENCE):
+         *
+         * 1. DUP()
+         * 2. BUFFER_LOAD(0, int.class)
+         * 3. VM_STORE  (ignored)
+         * 4. BUFFER_LOAD(4, int.class)
+         * 5. VM_STORE  (ignored)
+         *
+         * (specialized in reverse!)
+         *
+         * 5. (int, int) -> void                       insertPos = 1
+         * 4. (MemorySegment, int) -> void             insertPos = 1
+         * 3. (MemorySegment, int) -> void             insertPos = 0
+         * 2. (MemorySegment, MemorySegment) -> void   insertPos = 0
+         * 1. (MemorySegment) -> void                  insertPos = 0
+         *
+         */
+        @Override
+        public MethodHandle specialize(MethodHandle specializedHandle, int insertPos, int allocatorPos) {
+            return mergeArguments(specializedHandle, insertPos, insertPos + 1);
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) return true;
+            return o != null && getClass() == o.getClass();
+        }
+
+        @Override
+        public String toString() {
+            return "Dup{}";
+        }
+    }
+}
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/BindingInterpreter.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/BindingInterpreter.java
new file mode 100644
index 0000000000000..fc0d3f5a3ebe7
--- /dev/null
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/BindingInterpreter.java
@@ -0,0 +1,55 @@
+/*
+ *  Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
+ *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ *  This code is free software; you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License version 2 only, as
+ *  published by the Free Software Foundation.
+ *
+ *  This code 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
+ *  version 2 for more details (a copy is included in the LICENSE file that
+ *  accompanied this code).
+ *
+ *  You should have received a copy of the GNU General Public License version
+ *  2 along with this work; if not, write to the Free Software Foundation,
+ *  Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ *  Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ *  or visit www.oracle.com if you need additional information or have any
+ *  questions.
+ */
+package jdk.internal.foreign.abi;
+
+import java.util.ArrayDeque;
+import java.util.Deque;
+import java.util.List;
+
+public class BindingInterpreter {
+
+    static void unbox(Object arg, List bindings, StoreFunc storeFunc, SharedUtils.Allocator allocator) {
+        Deque stack = new ArrayDeque<>();
+
+        stack.push(arg);
+        for (Binding b : bindings) {
+            b.interpret(stack, storeFunc, null, allocator);
+        }
+    }
+
+    static Object box(List bindings, LoadFunc loadFunc, SharedUtils.Allocator allocator) {
+        Deque stack = new ArrayDeque<>();
+        for (Binding b : bindings) {
+            b.interpret(stack, null, loadFunc, allocator);
+        }
+       return stack.pop();
+    }
+
+    interface StoreFunc {
+        void store(VMStorage storage, Class type, Object o);
+    }
+
+    interface LoadFunc {
+        Object load(VMStorage storage, Class type);
+    }
+}
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/BufferLayout.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/BufferLayout.java
new file mode 100644
index 0000000000000..a34ce2d69e099
--- /dev/null
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/BufferLayout.java
@@ -0,0 +1,141 @@
+/*
+ *  Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
+ *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ *  This code is free software; you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License version 2 only, as
+ *  published by the Free Software Foundation.
+ *
+ *  This code 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
+ *  version 2 for more details (a copy is included in the LICENSE file that
+ *  accompanied this code).
+ *
+ *  You should have received a copy of the GNU General Public License version
+ *  2 along with this work; if not, write to the Free Software Foundation,
+ *  Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ *  Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ *  or visit www.oracle.com if you need additional information or have any
+ *  questions.
+ */
+package jdk.internal.foreign.abi;
+
+import jdk.incubator.foreign.MemoryLayouts;
+import jdk.incubator.foreign.MemorySegment;
+
+import java.io.PrintStream;
+import java.lang.invoke.VarHandle;
+import java.util.HashMap;
+import java.util.Map;
+
+class BufferLayout {
+    static final VarHandle VH_LONG = MemoryLayouts.JAVA_LONG.varHandle(long.class);
+
+    final long size;
+    final long arguments_next_pc;
+    final long stack_args_bytes;
+    final long stack_args;
+
+    // read by JNI
+    final long[] input_type_offsets;
+    final long[] output_type_offsets;
+
+    private final Map argOffsets;
+    private final Map retOffsets;
+
+    private BufferLayout(long size, long arguments_next_pc, long stack_args_bytes, long stack_args,
+                         long[] input_type_offsets, long[] output_type_offsets,
+                         Map argOffsets, Map retOffsets) {
+        this.size = size;
+        this.arguments_next_pc = arguments_next_pc;
+        this.stack_args_bytes = stack_args_bytes;
+        this.stack_args = stack_args;
+        this.input_type_offsets = input_type_offsets;
+        this.output_type_offsets = output_type_offsets;
+        this.argOffsets = argOffsets;
+        this.retOffsets = retOffsets;
+    }
+
+    static BufferLayout of(ABIDescriptor abi) {
+        long offset = 0;
+
+        offset = SharedUtils.alignUp(offset, 8);
+        long arguments_next_pc = offset;
+        offset += 8;
+
+        offset = SharedUtils.alignUp(offset, 8);
+        long stack_args_bytes = offset;
+        offset += 8;
+
+        offset = SharedUtils.alignUp(offset, 8);
+        long stack_args = offset;
+        offset += 8;
+
+        Map argOffsets = new HashMap<>();
+        long[] input_type_offsets = new long[abi.inputStorage.length];
+        for (int i = 0; i < abi.inputStorage.length; i++) {
+            long size = abi.arch.typeSize(i);
+            offset = SharedUtils.alignUp(offset, size);
+            input_type_offsets[i] = offset;
+            for (jdk.internal.foreign.abi.VMStorage store : abi.inputStorage[i]) {
+                argOffsets.put(store, offset);
+                offset += size;
+            }
+        }
+
+        Map retOffsets = new HashMap<>();
+        long[] output_type_offsets = new long[abi.outputStorage.length];
+        for (int i = 0; i < abi.outputStorage.length; i++) {
+            long size = abi.arch.typeSize(i);
+            offset = SharedUtils.alignUp(offset, size);
+            output_type_offsets[i] = offset;
+            for (jdk.internal.foreign.abi.VMStorage store : abi.outputStorage[i]) {
+                retOffsets.put(store, offset);
+                offset += size;
+            }
+        }
+
+        return new BufferLayout(offset, arguments_next_pc, stack_args_bytes, stack_args,
+                input_type_offsets, output_type_offsets, argOffsets, retOffsets);
+    }
+
+    long argOffset(jdk.internal.foreign.abi.VMStorage storage) {
+        return argOffsets.get(storage);
+    }
+
+    long retOffset(jdk.internal.foreign.abi.VMStorage storage) {
+        return retOffsets.get(storage);
+    }
+
+    private static String getLongString(MemorySegment buffer, long offset) {
+        return Long.toHexString((long) VH_LONG.get(buffer.asSlice(offset)));
+    }
+
+    private static void dumpValues(jdk.internal.foreign.abi.Architecture arch, MemorySegment buff, PrintStream stream,
+                                   Map offsets) {
+        for (var entry : offsets.entrySet()) {
+            VMStorage storage = entry.getKey();
+            stream.print(storage.name());
+            stream.print("={ ");
+            MemorySegment start = buff.asSlice(entry.getValue());
+            for (int i = 0; i < arch.typeSize(storage.type()) / 8; i += 8) {
+                stream.print(getLongString(start, i));
+                stream.print(" ");
+            }
+            stream.println("}");
+        }
+    }
+
+    void dump(Architecture arch, MemorySegment buff, PrintStream stream) {
+        stream.println("Next PC: " + getLongString(buff, arguments_next_pc));
+        stream.println("Stack args bytes: " + getLongString(buff, stack_args_bytes));
+        stream.println("Stack args ptr: " + getLongString(buff, stack_args));
+
+        stream.println("Arguments:");
+        dumpValues(arch, buff, stream, argOffsets);
+        stream.println("Returns:");
+        dumpValues(arch, buff, stream, retOffsets);
+    }
+}
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/CallingSequence.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/CallingSequence.java
new file mode 100644
index 0000000000000..4a8045283f47a
--- /dev/null
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/CallingSequence.java
@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package jdk.internal.foreign.abi;
+
+import jdk.incubator.foreign.FunctionDescriptor;
+
+import java.lang.invoke.MethodType;
+import java.util.List;
+import java.util.stream.IntStream;
+import java.util.stream.Stream;
+
+public class CallingSequence {
+    private final MethodType mt;
+    private final FunctionDescriptor desc;
+    private final boolean isTrivial;
+
+    private final List returnBindings;
+    private final List> argumentBindings;
+
+    public CallingSequence(MethodType mt, FunctionDescriptor desc,
+                           boolean isTrivial, List> argumentBindings, List returnBindings) {
+        this.mt = mt;
+        this.desc = desc;
+        this.isTrivial = isTrivial;
+        this.returnBindings = returnBindings;
+        this.argumentBindings = argumentBindings;
+    }
+
+    public Stream argBindings() {
+        return argumentBindings.stream().flatMap(List::stream);
+    }
+
+    public Stream retBindings() {
+        return returnBindings().stream();
+    }
+
+    public int argumentCount() {
+        return argumentBindings.size();
+    }
+
+    public List argumentBindings(int i) {
+        return argumentBindings.get(i);
+    }
+
+    public Stream argumentBindings() {
+        return argumentBindings.stream().flatMap(List::stream);
+    }
+
+    public List returnBindings() {
+        return returnBindings;
+    }
+
+    public String asString() {
+        StringBuilder sb = new StringBuilder();
+
+        sb.append("CallingSequence: {\n");
+        sb.append("  MethodType: ").append(mt);
+        sb.append("  FunctionDescriptor: ").append(desc);
+        sb.append("  Argument Bindings:\n");
+        for (int i = 0; i < mt.parameterCount(); i++) {
+            sb.append("    ").append(i).append(": ").append(argumentBindings.get(i)).append("\n");
+        }
+        if (mt.returnType() != void.class) {
+            sb.append("    ").append("Return: ").append(returnBindings).append("\n");
+        }
+        sb.append("}\n");
+
+        return sb.toString();
+    }
+
+    public MethodType methodType() {
+        return mt;
+    }
+
+    public FunctionDescriptor functionDesc() {
+        return desc;
+    }
+
+    public boolean isTrivial() {
+        return isTrivial;
+    }
+}
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/CallingSequenceBuilder.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/CallingSequenceBuilder.java
new file mode 100644
index 0000000000000..8b6ac2aa1ef63
--- /dev/null
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/CallingSequenceBuilder.java
@@ -0,0 +1,151 @@
+/*
+ *  Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
+ *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ *  This code is free software; you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License version 2 only, as
+ *  published by the Free Software Foundation.
+ *
+ *  This code 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
+ *  version 2 for more details (a copy is included in the LICENSE file that
+ *  accompanied this code).
+ *
+ *  You should have received a copy of the GNU General Public License version
+ *  2 along with this work; if not, write to the Free Software Foundation,
+ *  Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ *  Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ *  or visit www.oracle.com if you need additional information or have any
+ *  questions.
+ */
+package jdk.internal.foreign.abi;
+
+import jdk.incubator.foreign.FunctionDescriptor;
+import jdk.incubator.foreign.MemoryLayout;
+import sun.security.action.GetPropertyAction;
+
+import java.lang.invoke.MethodType;
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Deque;
+import java.util.EnumSet;
+import java.util.List;
+import java.util.Set;
+
+import static jdk.internal.foreign.abi.Binding.Tag.*;
+
+public class CallingSequenceBuilder {
+    private static final boolean VERIFY_BINDINGS = Boolean.parseBoolean(
+            GetPropertyAction.privilegedGetProperty("jdk.incubator.foreign.VERIFY_BINDINGS", "true"));
+
+    private boolean isTrivial;
+    private final boolean forUpcall;
+    private final List> inputBindings = new ArrayList<>();
+    private List outputBindings = List.of();
+
+    private MethodType mt = MethodType.methodType(void.class);
+    private FunctionDescriptor desc = FunctionDescriptor.ofVoid();
+
+    public CallingSequenceBuilder(boolean forUpcall) {
+        this.forUpcall = forUpcall;
+    }
+
+    public final CallingSequenceBuilder addArgumentBindings(Class carrier, MemoryLayout layout,
+                                                            List bindings) {
+        verifyBindings(true, carrier, bindings);
+        inputBindings.add(bindings);
+        mt = mt.appendParameterTypes(carrier);
+        desc = desc.appendArgumentLayouts(layout);
+        return this;
+    }
+
+    public CallingSequenceBuilder setReturnBindings(Class carrier, MemoryLayout layout,
+                                                    List bindings) {
+        verifyBindings(false, carrier, bindings);
+        this.outputBindings = bindings;
+        mt = mt.changeReturnType(carrier);
+        desc = desc.changeReturnLayout(layout);
+        return this;
+    }
+
+    public CallingSequenceBuilder setTrivial(boolean isTrivial) {
+        this.isTrivial = isTrivial;
+        return this;
+    }
+
+    public CallingSequence build() {
+        return new CallingSequence(mt, desc, isTrivial, inputBindings, outputBindings);
+    }
+
+    private void verifyBindings(boolean forArguments, Class carrier, List bindings) {
+        if (VERIFY_BINDINGS) {
+            if (forUpcall == forArguments) {
+                verifyBoxBindings(carrier, bindings);
+            } else {
+                verifyUnboxBindings(carrier, bindings);
+            }
+        }
+    }
+
+    private static final Set unboxTags = EnumSet.of(
+        VM_STORE,
+        //VM_LOAD,
+        //BUFFER_STORE,
+        BUFFER_LOAD,
+        COPY_BUFFER,
+        //ALLOC_BUFFER,
+        //BOX_ADDRESS,
+        UNBOX_ADDRESS,
+        BASE_ADDRESS,
+        //TO_SEGMENT,
+        DUP
+    );
+
+    private static void verifyUnboxBindings(Class inType, List bindings) {
+        Deque> stack = new ArrayDeque<>();
+        stack.push(inType);
+
+        for (Binding b : bindings) {
+            if (!unboxTags.contains(b.tag()))
+                throw new IllegalArgumentException("Unexpected operator: " + b);
+            b.verify(stack);
+        }
+
+        if (!stack.isEmpty()) {
+            throw new IllegalArgumentException("Stack must be empty after recipe");
+        }
+    }
+
+    private static final Set boxTags = EnumSet.of(
+        //VM_STORE,
+        VM_LOAD,
+        BUFFER_STORE,
+        //BUFFER_LOAD,
+        COPY_BUFFER,
+        ALLOC_BUFFER,
+        BOX_ADDRESS,
+        //UNBOX_ADDRESS,
+        //BASE_ADDRESS,
+        TO_SEGMENT,
+        DUP
+    );
+
+    private static void verifyBoxBindings(Class expectedOutType, List bindings) {
+        Deque> stack = new ArrayDeque<>();
+
+        for (Binding b : bindings) {
+            if (!boxTags.contains(b.tag()))
+                throw new IllegalArgumentException("Unexpected operator: " + b);
+            b.verify(stack);
+        }
+
+        if (stack.size() != 1) {
+            throw new IllegalArgumentException("Stack must contain exactly 1 value");
+        }
+
+        Class actualOutType = stack.pop();
+        SharedUtils.checkType(actualOutType, expectedOutType);
+    }
+}
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/ProgrammableInvoker.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/ProgrammableInvoker.java
new file mode 100644
index 0000000000000..88053db829c4a
--- /dev/null
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/ProgrammableInvoker.java
@@ -0,0 +1,385 @@
+/*
+ * Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package jdk.internal.foreign.abi;
+
+import jdk.incubator.foreign.Addressable;
+import jdk.incubator.foreign.MemoryLayouts;
+import jdk.incubator.foreign.MemorySegment;
+import jdk.incubator.foreign.NativeScope;
+import jdk.internal.access.JavaLangInvokeAccess;
+import jdk.internal.access.SharedSecrets;
+import jdk.internal.foreign.Utils;
+import jdk.internal.invoke.NativeEntryPoint;
+import jdk.internal.invoke.VMStorageProxy;
+import sun.security.action.GetPropertyAction;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
+import java.lang.invoke.VarHandle;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+import java.util.stream.Stream;
+
+import static java.lang.invoke.MethodHandles.collectArguments;
+import static java.lang.invoke.MethodHandles.dropArguments;
+import static java.lang.invoke.MethodHandles.empty;
+import static java.lang.invoke.MethodHandles.filterArguments;
+import static java.lang.invoke.MethodHandles.identity;
+import static java.lang.invoke.MethodHandles.insertArguments;
+import static java.lang.invoke.MethodHandles.tryFinally;
+import static java.lang.invoke.MethodType.methodType;
+import static jdk.internal.foreign.abi.SharedUtils.Allocator.THROWING_ALLOCATOR;
+import static jdk.internal.foreign.abi.SharedUtils.DEFAULT_ALLOCATOR;
+import static sun.security.action.GetBooleanAction.privilegedGetProperty;
+
+/**
+ * This class implements native call invocation through a so called 'universal adapter'. A universal adapter takes
+ * an array of longs together with a call 'recipe', which is used to move the arguments in the right places as
+ * expected by the system ABI.
+ */
+public class ProgrammableInvoker {
+    private static final boolean DEBUG =
+        privilegedGetProperty("jdk.internal.foreign.ProgrammableInvoker.DEBUG");
+    private static final boolean USE_SPEC = Boolean.parseBoolean(
+        GetPropertyAction.privilegedGetProperty("jdk.internal.foreign.ProgrammableInvoker.USE_SPEC", "true"));
+    private static final boolean USE_INTRINSICS = Boolean.parseBoolean(
+        GetPropertyAction.privilegedGetProperty("jdk.internal.foreign.ProgrammableInvoker.USE_INTRINSICS", "true"));
+
+    private static final JavaLangInvokeAccess JLIA = SharedSecrets.getJavaLangInvokeAccess();
+
+    private static final VarHandle VH_LONG = MemoryLayouts.JAVA_LONG.varHandle(long.class);
+
+    private static final MethodHandle MH_INVOKE_MOVES;
+    private static final MethodHandle MH_INVOKE_INTERP_BINDINGS;
+
+    private static final MethodHandle MH_MAKE_SCOPE;
+    private static final MethodHandle MH_CLOSE_SCOPE;
+    private static final MethodHandle MH_WRAP_SCOPE;
+
+    private static final Map adapterStubs = new ConcurrentHashMap<>();
+
+    static {
+        try {
+            MethodHandles.Lookup lookup = MethodHandles.lookup();
+            MH_INVOKE_MOVES = lookup.findVirtual(ProgrammableInvoker.class, "invokeMoves",
+                    methodType(Object.class, Object[].class, Binding.VMStore[].class, Binding.VMLoad[].class));
+            MH_INVOKE_INTERP_BINDINGS = lookup.findVirtual(ProgrammableInvoker.class, "invokeInterpBindings",
+                    methodType(Object.class, Object[].class, MethodHandle.class, Map.class, Map.class));
+            MH_MAKE_SCOPE = lookup.findStatic(NativeScope.class, "boundedScope",
+                    methodType(NativeScope.class, long.class));
+            MH_CLOSE_SCOPE = lookup.findVirtual(NativeScope.class, "close",
+                    methodType(void.class));
+            MH_WRAP_SCOPE = lookup.findStatic(SharedUtils.Allocator.class, "ofScope",
+                    methodType(SharedUtils.Allocator.class, NativeScope.class));
+        } catch (ReflectiveOperationException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    private final ABIDescriptor abi;
+    private final BufferLayout layout;
+    private final long stackArgsBytes;
+
+    private final CallingSequence callingSequence;
+
+    private final Addressable addr;
+    private final long stubAddress;
+
+    private final long bufferCopySize;
+
+    public ProgrammableInvoker(ABIDescriptor abi, Addressable addr, CallingSequence callingSequence) {
+        this.abi = abi;
+        this.layout = BufferLayout.of(abi);
+        this.stubAddress = adapterStubs.computeIfAbsent(abi, key -> generateAdapter(key, layout));
+
+        this.addr = addr;
+        this.callingSequence = callingSequence;
+
+        this.stackArgsBytes = argMoveBindingsStream(callingSequence)
+                .map(Binding.VMStore::storage)
+                .filter(s -> abi.arch.isStackType(s.type()))
+                .count()
+                * abi.arch.typeSize(abi.arch.stackType());
+
+        this.bufferCopySize = bufferCopySize(callingSequence);
+    }
+
+    private static long bufferCopySize(CallingSequence callingSequence) {
+        // FIXME: > 16 bytes alignment might need extra space since the
+        // starting address of the allocator might be un-aligned.
+        long size = 0;
+        for (int i = 0; i < callingSequence.argumentCount(); i++) {
+            List bindings = callingSequence.argumentBindings(i);
+            for (Binding b : bindings) {
+                if (b instanceof Binding.Copy) {
+                    Binding.Copy c = (Binding.Copy) b;
+                    size = Utils.alignUp(size, c.alignment());
+                    size += c.size();
+                }
+            }
+        }
+        return size;
+    }
+
+    public MethodHandle getBoundMethodHandle() {
+        Binding.VMStore[] argMoves = argMoveBindingsStream(callingSequence).toArray(Binding.VMStore[]::new);
+        Class[] argMoveTypes = Arrays.stream(argMoves).map(Binding.VMStore::type).toArray(Class[]::new);
+
+        Binding.VMLoad[] retMoves = retMoveBindings(callingSequence);
+        Class returnType = retMoves.length == 0
+                ? void.class
+                : retMoves.length == 1
+                    ? retMoves[0].type()
+                    : Object[].class;
+
+        MethodType leafType = methodType(returnType, argMoveTypes);
+
+        MethodHandle handle = insertArguments(MH_INVOKE_MOVES.bindTo(this), 1, argMoves, retMoves)
+                                            .asCollector(Object[].class, leafType.parameterCount())
+                                            .asType(leafType);
+
+        boolean isSimple = !(retMoves.length > 1);
+        boolean usesStackArgs = stackArgsBytes != 0;
+        if (USE_INTRINSICS && isSimple && !usesStackArgs) {
+            NativeEntryPoint nep = NativeEntryPoint.make(
+                addr.address().toRawLongValue(),
+                "native_call",
+                abi,
+                toStorageArray(argMoves),
+                toStorageArray(retMoves),
+                !callingSequence.isTrivial(),
+                leafType
+            );
+
+            handle = JLIA.nativeMethodHandle(nep, handle);
+        }
+
+        if (USE_SPEC && isSimple) {
+            handle = specialize(handle);
+         } else {
+            Map argIndexMap = indexMap(argMoves);
+            Map retIndexMap = indexMap(retMoves);
+
+            handle = insertArguments(MH_INVOKE_INTERP_BINDINGS.bindTo(this), 1, handle, argIndexMap, retIndexMap);
+            handle = handle.asCollector(Object[].class, callingSequence.methodType().parameterCount())
+                                             .asType(callingSequence.methodType());
+         }
+
+        return handle;
+    }
+
+    private Stream argMoveBindingsStream(CallingSequence callingSequence) {
+        return callingSequence.argBindings()
+                .filter(Binding.VMStore.class::isInstance)
+                .map(Binding.VMStore.class::cast);
+    }
+
+    private Binding.VMLoad[] retMoveBindings(CallingSequence callingSequence) {
+        return callingSequence.retBindings()
+                .filter(Binding.VMLoad.class::isInstance)
+                .map(Binding.VMLoad.class::cast)
+                .toArray(Binding.VMLoad[]::new);
+    }
+
+
+    private VMStorageProxy[] toStorageArray(Binding.Move[] moves) {
+        return Arrays.stream(moves).map(Binding.Move::storage).toArray(VMStorage[]::new);
+    }
+
+    private MethodHandle specialize(MethodHandle leafHandle) {
+        MethodType highLevelType = callingSequence.methodType();
+        MethodType leafType = leafHandle.type();
+
+        MethodHandle specializedHandle = leafHandle; // initial
+
+        int argInsertPos = -1;
+        int argAllocatorPos = -1;
+        if (bufferCopySize > 0) {
+            argAllocatorPos = 0;
+            specializedHandle = dropArguments(specializedHandle, argAllocatorPos, SharedUtils.Allocator.class);
+            argInsertPos++;
+        }
+        for (int i = 0; i < highLevelType.parameterCount(); i++) {
+            List bindings = callingSequence.argumentBindings(i);
+            argInsertPos += bindings.stream().filter(Binding.VMStore.class::isInstance).count() + 1;
+            // We interpret the bindings in reverse since we have to construct a MethodHandle from the bottom up
+            for (int j = bindings.size() - 1; j >= 0; j--) {
+                Binding binding = bindings.get(j);
+                if (binding.tag() == Binding.Tag.VM_STORE) {
+                    argInsertPos--;
+                } else {
+                    specializedHandle = binding.specialize(specializedHandle, argInsertPos, argAllocatorPos);
+                }
+            }
+        }
+
+        if (highLevelType.returnType() != void.class) {
+            MethodHandle returnFilter = identity(highLevelType.returnType());
+            int retAllocatorPos = 0;
+            int retInsertPos = 1;
+            returnFilter = dropArguments(returnFilter, retAllocatorPos, SharedUtils.Allocator.class);
+            List bindings = callingSequence.returnBindings();
+            for (int j = bindings.size() - 1; j >= 0; j--) {
+                Binding binding = bindings.get(j);
+                returnFilter = binding.specialize(returnFilter, retInsertPos, retAllocatorPos);
+            }
+            returnFilter = insertArguments(returnFilter, retAllocatorPos, DEFAULT_ALLOCATOR);
+            specializedHandle = MethodHandles.filterReturnValue(specializedHandle, returnFilter);
+        }
+
+        if (bufferCopySize > 0) {
+            // insert try-finally to close the NativeScope used for Binding.Copy
+            MethodHandle closer = leafType.returnType() == void.class
+                  // (Throwable, NativeScope) -> void
+                ? collectArguments(empty(methodType(void.class, Throwable.class)), 1, MH_CLOSE_SCOPE)
+                  // (Throwable, V, NativeScope) -> V
+                : collectArguments(dropArguments(identity(specializedHandle.type().returnType()), 0, Throwable.class),
+                                   2, MH_CLOSE_SCOPE);
+            // Handle takes a SharedUtils.Allocator, so need to wrap our NativeScope
+            specializedHandle = filterArguments(specializedHandle, argAllocatorPos, MH_WRAP_SCOPE);
+            specializedHandle = tryFinally(specializedHandle, closer);
+            MethodHandle makeScopeHandle = insertArguments(MH_MAKE_SCOPE, 0, bufferCopySize);
+            specializedHandle = collectArguments(specializedHandle, argAllocatorPos, makeScopeHandle);
+        }
+        return specializedHandle;
+    }
+
+    private static Map indexMap(Binding.Move[] moves) {
+        return IntStream.range(0, moves.length)
+                        .boxed()
+                        .collect(Collectors.toMap(i -> moves[i].storage(), i -> i));
+    }
+
+    /**
+     * Does a native invocation by moving primitive values from the arg array into an intermediate buffer
+     * and calling the assembly stub that forwards arguments from the buffer to the target function
+     *
+     * @param args an array of primitive values to be copied in to the buffer
+     * @param argBindings Binding.Move values describing how arguments should be copied
+     * @param returnBindings Binding.Move values describing how return values should be copied
+     * @return null, a single primitive value, or an Object[] of primitive values
+     */
+    Object invokeMoves(Object[] args, Binding.VMStore[] argBindings, Binding.VMLoad[] returnBindings) {
+        MemorySegment stackArgsSeg = null;
+        try (MemorySegment argBuffer = MemorySegment.allocateNative(layout.size, 64)) {
+            if (stackArgsBytes > 0) {
+                stackArgsSeg = MemorySegment.allocateNative(stackArgsBytes, 8);
+            }
+
+            VH_LONG.set(argBuffer.asSlice(layout.arguments_next_pc), addr.address().toRawLongValue());
+            VH_LONG.set(argBuffer.asSlice(layout.stack_args_bytes), stackArgsBytes);
+            VH_LONG.set(argBuffer.asSlice(layout.stack_args), stackArgsSeg == null ? 0L : stackArgsSeg.address().toRawLongValue());
+
+            for (int i = 0; i < argBindings.length; i++) {
+                Binding.VMStore binding = argBindings[i];
+                VMStorage storage = binding.storage();
+                MemorySegment ptr = abi.arch.isStackType(storage.type())
+                    ? stackArgsSeg.asSlice(storage.index() * abi.arch.typeSize(abi.arch.stackType()))
+                    : argBuffer.asSlice(layout.argOffset(storage));
+                SharedUtils.writeOverSized(ptr, binding.type(), args[i]);
+            }
+
+            if (DEBUG) {
+                System.err.println("Buffer state before:");
+                layout.dump(abi.arch, argBuffer, System.err);
+            }
+
+            invokeNative(stubAddress, argBuffer.address().toRawLongValue());
+
+            if (DEBUG) {
+                System.err.println("Buffer state after:");
+                layout.dump(abi.arch, argBuffer, System.err);
+            }
+
+            if (returnBindings.length == 0) {
+                return null;
+            } else if (returnBindings.length == 1) {
+                Binding.VMLoad move = returnBindings[0];
+                VMStorage storage = move.storage();
+                return SharedUtils.read(argBuffer.asSlice(layout.retOffset(storage)), move.type());
+            } else { // length > 1
+                Object[] returns = new Object[returnBindings.length];
+                for (int i = 0; i < returnBindings.length; i++) {
+                    Binding.VMLoad move = returnBindings[i];
+                    VMStorage storage = move.storage();
+                    returns[i] = SharedUtils.read(argBuffer.asSlice(layout.retOffset(storage)), move.type());
+                }
+                return returns;
+            }
+        } finally {
+            if (stackArgsSeg != null) {
+                stackArgsSeg.close();
+            }
+        }
+    }
+
+    Object invokeInterpBindings(Object[] args, MethodHandle leaf,
+                                Map argIndexMap,
+                                Map retIndexMap) throws Throwable {
+        SharedUtils.Allocator unboxAllocator = bufferCopySize != 0
+                ? SharedUtils.Allocator.ofScope(NativeScope.boundedScope(bufferCopySize))
+                : THROWING_ALLOCATOR;
+        try (unboxAllocator) {
+            // do argument processing, get Object[] as result
+            Object[] moves = new Object[leaf.type().parameterCount()];
+            for (int i = 0; i < args.length; i++) {
+                Object arg = args[i];
+                BindingInterpreter.unbox(arg, callingSequence.argumentBindings(i),
+                        (storage, type, value) -> {
+                            moves[argIndexMap.get(storage)] = value;
+                        }, unboxAllocator);
+            }
+
+            // call leaf
+            Object o = leaf.invokeWithArguments(moves);
+
+            // return value processing
+            if (o == null) {
+                return null;
+            } else if (o instanceof Object[]) {
+                Object[] oArr = (Object[]) o;
+                return BindingInterpreter.box(callingSequence.returnBindings(),
+                        (storage, type) -> oArr[retIndexMap.get(storage)], DEFAULT_ALLOCATOR);
+            } else {
+                return BindingInterpreter.box(callingSequence.returnBindings(), (storage, type) -> o,
+                        DEFAULT_ALLOCATOR);
+            }
+        }
+    }
+
+    //natives
+
+    static native void invokeNative(long adapterStub, long buff);
+    static native long generateAdapter(ABIDescriptor abi, BufferLayout layout);
+
+    private static native void registerNatives();
+    static {
+        registerNatives();
+    }
+}
+
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/ProgrammableUpcallHandler.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/ProgrammableUpcallHandler.java
new file mode 100644
index 0000000000000..fcc3bbf011337
--- /dev/null
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/ProgrammableUpcallHandler.java
@@ -0,0 +1,140 @@
+/*
+ * Copyright (c) 2018, 2019, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package jdk.internal.foreign.abi;
+
+import jdk.incubator.foreign.MemoryAddress;
+import jdk.incubator.foreign.MemoryHandles;
+import jdk.incubator.foreign.MemoryLayouts;
+import jdk.incubator.foreign.MemorySegment;
+import jdk.internal.foreign.MemoryAddressImpl;
+import jdk.internal.foreign.Utils;
+import jdk.internal.vm.annotation.Stable;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodType;
+import java.lang.invoke.VarHandle;
+import java.nio.ByteOrder;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Objects;
+
+import static jdk.internal.foreign.abi.SharedUtils.DEFAULT_ALLOCATOR;
+import static sun.security.action.GetBooleanAction.privilegedGetProperty;
+
+/**
+ * This class implements upcall invocation from native code through a so called 'universal adapter'. A universal upcall adapter
+ * takes an array of storage pointers, which describes the state of the CPU at the time of the upcall. This can be used
+ * by the Java code to fetch the upcall arguments and to store the results to the desired location, as per system ABI.
+ */
+public class ProgrammableUpcallHandler implements UpcallHandler {
+
+    private static final boolean DEBUG =
+        privilegedGetProperty("jdk.internal.foreign.ProgrammableUpcallHandler.DEBUG");
+
+    private static final VarHandle VH_LONG = MemoryLayouts.JAVA_LONG.varHandle(long.class);
+
+    @Stable
+    private final MethodHandle mh;
+    private final MethodType type;
+    private final CallingSequence callingSequence;
+    private final long entryPoint;
+
+    private final ABIDescriptor abi;
+    private final BufferLayout layout;
+
+    public ProgrammableUpcallHandler(ABIDescriptor abi, MethodHandle target, CallingSequence callingSequence) {
+        this.abi = abi;
+        this.layout = BufferLayout.of(abi);
+        this.type = callingSequence.methodType();
+        this.callingSequence = callingSequence;
+        this.mh = target.asSpreader(Object[].class, callingSequence.methodType().parameterCount());
+        this.entryPoint = allocateUpcallStub(abi, layout);
+    }
+
+    @Override
+    public long entryPoint() {
+        return entryPoint;
+    }
+
+    public static void invoke(ProgrammableUpcallHandler handler, long address) {
+        handler.invoke(MemoryAddress.ofLong(address));
+    }
+
+    private void invoke(MemoryAddress buffer) {
+        try {
+            MemorySegment bufferBase = MemoryAddressImpl.ofLongUnchecked(buffer.toRawLongValue(), layout.size);
+
+            if (DEBUG) {
+                System.err.println("Buffer state before:");
+                layout.dump(abi.arch, bufferBase, System.err);
+            }
+
+            MemorySegment stackArgsBase = MemoryAddressImpl.ofLongUnchecked((long)VH_LONG.get(bufferBase.asSlice(layout.stack_args)));
+            Object[] args = new Object[type.parameterCount()];
+            for (int i = 0 ; i < type.parameterCount() ; i++) {
+                args[i] = BindingInterpreter.box(callingSequence.argumentBindings(i),
+                        (storage, type) -> {
+                            MemorySegment ptr = abi.arch.isStackType(storage.type())
+                                ? stackArgsBase.asSlice(storage.index() * abi.arch.typeSize(abi.arch.stackType()))
+                                : bufferBase.asSlice(layout.argOffset(storage));
+                            return SharedUtils.read(ptr, type);
+                        }, DEFAULT_ALLOCATOR);
+            }
+
+            if (DEBUG) {
+                System.err.println("Java arguments:");
+                System.err.println(Arrays.toString(args).indent(2));
+            }
+
+            Object o = mh.invoke(args);
+
+            if (DEBUG) {
+                System.err.println("Java return:");
+                System.err.println(Objects.toString(o).indent(2));
+            }
+
+            if (mh.type().returnType() != void.class) {
+                BindingInterpreter.unbox(o, callingSequence.returnBindings(),
+                        (storage, type, value) -> {
+                            MemorySegment ptr = bufferBase.asSlice(layout.retOffset(storage));
+                            SharedUtils.writeOverSized(ptr, type, value);
+                        }, null);
+            }
+
+            if (DEBUG) {
+                System.err.println("Buffer state after:");
+                layout.dump(abi.arch, bufferBase, System.err);
+            }
+        } catch (Throwable t) {
+            throw new IllegalStateException(t);
+        }
+    }
+
+    public native long allocateUpcallStub(ABIDescriptor abi, BufferLayout layout);
+
+    private static native void registerNatives();
+    static {
+        registerNatives();
+    }
+}
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/SharedUtils.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/SharedUtils.java
new file mode 100644
index 0000000000000..1f402d1bfa0ac
--- /dev/null
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/SharedUtils.java
@@ -0,0 +1,550 @@
+/*
+ * Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package jdk.internal.foreign.abi;
+
+import jdk.incubator.foreign.FunctionDescriptor;
+import jdk.incubator.foreign.GroupLayout;
+import jdk.incubator.foreign.MemoryAccess;
+import jdk.incubator.foreign.MemoryAddress;
+import jdk.incubator.foreign.MemoryHandles;
+import jdk.incubator.foreign.MemoryLayout;
+import jdk.incubator.foreign.MemorySegment;
+import jdk.incubator.foreign.LibraryLookup;
+import jdk.incubator.foreign.NativeScope;
+import jdk.incubator.foreign.SequenceLayout;
+import jdk.incubator.foreign.CLinker;
+import jdk.incubator.foreign.ValueLayout;
+import jdk.internal.foreign.CABI;
+import jdk.internal.foreign.MemoryAddressImpl;
+import jdk.internal.foreign.Utils;
+import jdk.internal.foreign.abi.aarch64.AArch64Linker;
+import jdk.internal.foreign.abi.x64.sysv.SysVx64Linker;
+import jdk.internal.foreign.abi.x64.windows.Windowsx64Linker;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
+import java.lang.invoke.VarHandle;
+import java.nio.charset.Charset;
+import java.util.List;
+import java.util.function.Consumer;
+import java.util.stream.IntStream;
+
+import static java.lang.invoke.MethodHandles.collectArguments;
+import static java.lang.invoke.MethodHandles.identity;
+import static java.lang.invoke.MethodHandles.insertArguments;
+import static java.lang.invoke.MethodHandles.permuteArguments;
+import static java.lang.invoke.MethodType.methodType;
+import static jdk.incubator.foreign.CLinker.*;
+
+public class SharedUtils {
+
+    private static final MethodHandle MH_ALLOC_BUFFER;
+    private static final MethodHandle MH_BASEADDRESS;
+    private static final MethodHandle MH_BUFFER_COPY;
+
+    static final Allocator DEFAULT_ALLOCATOR = MemorySegment::allocateNative;
+
+    static {
+        try {
+            var lookup = MethodHandles.lookup();
+            MH_ALLOC_BUFFER = lookup.findStatic(SharedUtils.class, "allocateNative",
+                    methodType(MemorySegment.class, MemoryLayout.class));
+            MH_BASEADDRESS = lookup.findVirtual(MemorySegment.class, "address",
+                    methodType(MemoryAddress.class));
+            MH_BUFFER_COPY = lookup.findStatic(SharedUtils.class, "bufferCopy",
+                    methodType(MemoryAddress.class, MemoryAddress.class, MemorySegment.class));
+        } catch (ReflectiveOperationException e) {
+            throw new BootstrapMethodError(e);
+        }
+    }
+
+    // workaround for https://bugs.openjdk.java.net/browse/JDK-8239083
+    private static MemorySegment allocateNative(MemoryLayout layout) {
+        return MemorySegment.allocateNative(layout);
+    }
+
+    /**
+     * Align the specified type from a given address
+     * @return The address the data should be at based on alignment requirement
+     */
+    public static long align(MemoryLayout t, boolean isVar, long addr) {
+        return alignUp(addr, alignment(t, isVar));
+    }
+
+    public static long alignUp(long addr, long alignment) {
+        return ((addr - 1) | (alignment - 1)) + 1;
+    }
+
+    /**
+     * The alignment requirement for a given type
+     * @param isVar indicate if the type is a standalone variable. This change how
+     * array is aligned. for example.
+     */
+    public static long alignment(MemoryLayout t, boolean isVar) {
+        if (t instanceof ValueLayout) {
+            return alignmentOfScalar((ValueLayout) t);
+        } else if (t instanceof SequenceLayout) {
+            // when array is used alone
+            return alignmentOfArray((SequenceLayout) t, isVar);
+        } else if (t instanceof GroupLayout) {
+            return alignmentOfContainer((GroupLayout) t);
+        } else if (t.isPadding()) {
+            return 1;
+        } else {
+            throw new IllegalArgumentException("Invalid type: " + t);
+        }
+    }
+
+    private static long alignmentOfScalar(ValueLayout st) {
+        return st.byteSize();
+    }
+
+    private static long alignmentOfArray(SequenceLayout ar, boolean isVar) {
+        if (ar.elementCount().orElseThrow() == 0) {
+            // VLA or incomplete
+            return 16;
+        } else if ((ar.byteSize()) >= 16 && isVar) {
+            return 16;
+        } else {
+            // align as element type
+            MemoryLayout elementType = ar.elementLayout();
+            return alignment(elementType, false);
+        }
+    }
+
+    private static long alignmentOfContainer(GroupLayout ct) {
+        // Most strict member
+        return ct.memberLayouts().stream().mapToLong(t -> alignment(t, false)).max().orElse(1);
+    }
+
+    /**
+     * Takes a MethodHandle that takes an input buffer as a first argument (a MemoryAddress), and returns nothing,
+     * and adapts it to return a MemorySegment, by allocating a MemorySegment for the input
+     * buffer, calling the target MethodHandle, and then returning the allocated MemorySegment.
+     *
+     * This allows viewing a MethodHandle that makes use of in memory return (IMR) as a MethodHandle that just returns
+     * a MemorySegment without requiring a pre-allocated buffer as an explicit input.
+     *
+     * @param handle the target handle to adapt
+     * @param cDesc the function descriptor of the native function (with actual return layout)
+     * @return the adapted handle
+     */
+    public static MethodHandle adaptDowncallForIMR(MethodHandle handle, FunctionDescriptor cDesc) {
+        if (handle.type().returnType() != void.class)
+            throw new IllegalArgumentException("return expected to be void for in memory returns");
+        if (handle.type().parameterType(0) != MemoryAddress.class)
+            throw new IllegalArgumentException("MemoryAddress expected as first param");
+        if (cDesc.returnLayout().isEmpty())
+            throw new IllegalArgumentException("Return layout needed: " + cDesc);
+
+        MethodHandle ret = identity(MemorySegment.class); // (MemorySegment) MemorySegment
+        handle = collectArguments(ret, 1, handle); // (MemorySegment, MemoryAddress ...) MemorySegment
+        handle = collectArguments(handle, 1, MH_BASEADDRESS); // (MemorySegment, MemorySegment ...) MemorySegment
+        MethodType oldType = handle.type(); // (MemorySegment, MemorySegment, ...) MemorySegment
+        MethodType newType = oldType.dropParameterTypes(0, 1); // (MemorySegment, ...) MemorySegment
+        int[] reorder = IntStream.range(-1, newType.parameterCount()).toArray();
+        reorder[0] = 0; // [0, 0, 1, 2, 3, ...]
+        handle = permuteArguments(handle, newType, reorder); // (MemorySegment, ...) MemoryAddress
+        handle = collectArguments(handle, 0, insertArguments(MH_ALLOC_BUFFER, 0, cDesc.returnLayout().get())); // (...) MemoryAddress
+
+        return handle;
+    }
+
+    /**
+     * Takes a MethodHandle that returns a MemorySegment, and adapts it to take an input buffer as a first argument
+     * (a MemoryAddress), and upon invocation, copies the contents of the returned MemorySegment into the input buffer
+     * passed as the first argument.
+     *
+     * @param target the target handle to adapt
+     * @return the adapted handle
+     */
+    public static MethodHandle adaptUpcallForIMR(MethodHandle target) {
+        if (target.type().returnType() != MemorySegment.class)
+            throw new IllegalArgumentException("Must return MemorySegment for IMR");
+
+        target = collectArguments(MH_BUFFER_COPY, 1, target); // (MemoryAddress, ...) MemoryAddress
+
+        return target;
+    }
+
+    private static MemoryAddress bufferCopy(MemoryAddress dest, MemorySegment buffer) {
+        MemoryAddressImpl.ofLongUnchecked(dest.toRawLongValue(), buffer.byteSize()).copyFrom(buffer);
+        return dest;
+    }
+
+    public static void checkCompatibleType(Class carrier, MemoryLayout layout, long addressSize) {
+        if (carrier.isPrimitive()) {
+            Utils.checkPrimitiveCarrierCompat(carrier, layout);
+        } else if (carrier == MemoryAddress.class) {
+            Utils.checkLayoutType(layout, ValueLayout.class);
+            if (layout.bitSize() != addressSize)
+                throw new IllegalArgumentException("Address size mismatch: " + addressSize + " != " + layout.bitSize());
+        } else if (carrier == MemorySegment.class) {
+            Utils.checkLayoutType(layout, GroupLayout.class);
+        } else {
+            throw new IllegalArgumentException("Unsupported carrier: " + carrier);
+        }
+    }
+
+    public static void checkFunctionTypes(MethodType mt, FunctionDescriptor cDesc, long addressSize) {
+        if (mt.returnType() == void.class != cDesc.returnLayout().isEmpty())
+            throw new IllegalArgumentException("Return type mismatch: " + mt + " != " + cDesc);
+        List argLayouts = cDesc.argumentLayouts();
+        if (mt.parameterCount() != argLayouts.size())
+            throw new IllegalArgumentException("Arity mismatch: " + mt + " != " + cDesc);
+
+        int paramCount = mt.parameterCount();
+        for (int i = 0; i < paramCount; i++) {
+            checkCompatibleType(mt.parameterType(i), argLayouts.get(i), addressSize);
+        }
+        cDesc.returnLayout().ifPresent(rl -> checkCompatibleType(mt.returnType(), rl, addressSize));
+    }
+
+    public static Class primitiveCarrierForSize(long size) {
+        if (size == 1) {
+            return byte.class;
+        } else if(size == 2) {
+            return short.class;
+        } else if (size <= 4) {
+            return int.class;
+        } else if (size <= 8) {
+            return long.class;
+        }
+
+        throw new IllegalArgumentException("Size too large: " + size);
+    }
+
+    public static CLinker getSystemLinker() {
+        return switch (CABI.current()) {
+            case Win64 -> Windowsx64Linker.getInstance();
+            case SysV -> SysVx64Linker.getInstance();
+            case AArch64 -> AArch64Linker.getInstance();
+        };
+    }
+
+    public static String toJavaStringInternal(MemorySegment segment, long start, Charset charset) {
+        int len = strlen(segment, start);
+        byte[] bytes = new byte[len];
+        MemorySegment.ofArray(bytes)
+                .copyFrom(segment.asSlice(start, len));
+        return new String(bytes, charset);
+    }
+
+    private static int strlen(MemorySegment segment, long start) {
+        // iterate until overflow (String can only hold a byte[], whose length can be expressed as an int)
+        for (int offset = 0; offset >= 0; offset++) {
+            byte curr = MemoryAccess.getByteAtOffset(segment, start + offset);
+            if (curr == 0) {
+                return offset;
+            }
+        }
+        throw new IllegalArgumentException("String too large");
+    }
+
+    // lazy init MH_ALLOC and MH_FREE handles
+    private static class AllocHolder {
+
+        final static LibraryLookup LOOKUP = LibraryLookup.ofDefault();
+
+        final static MethodHandle MH_MALLOC = getSystemLinker().downcallHandle(LOOKUP.lookup("malloc").get(),
+                        MethodType.methodType(MemoryAddress.class, long.class),
+                FunctionDescriptor.of(C_POINTER, C_LONGLONG));
+
+        final static MethodHandle MH_FREE = getSystemLinker().downcallHandle(LOOKUP.lookup("free").get(),
+                        MethodType.methodType(void.class, MemoryAddress.class),
+                FunctionDescriptor.ofVoid(C_POINTER));
+    }
+
+    public static MemoryAddress allocateMemoryInternal(long size) {
+        try {
+            return (MemoryAddress) AllocHolder.MH_MALLOC.invokeExact(size);
+        } catch (Throwable th) {
+            throw new RuntimeException(th);
+        }
+    }
+
+    public static void freeMemoryInternal(MemoryAddress addr) {
+        try {
+            AllocHolder.MH_FREE.invokeExact(addr);
+        } catch (Throwable th) {
+            throw new RuntimeException(th);
+        }
+    }
+
+    public static VaList newVaList(Consumer actions, Allocator allocator) {
+        return switch (CABI.current()) {
+            case Win64 -> Windowsx64Linker.newVaList(actions, allocator);
+            case SysV -> SysVx64Linker.newVaList(actions, allocator);
+            case AArch64 -> AArch64Linker.newVaList(actions, allocator);
+        };
+    }
+
+    public static VarHandle vhPrimitiveOrAddress(Class carrier, MemoryLayout layout) {
+        return carrier == MemoryAddress.class
+            ? MemoryHandles.asAddressVarHandle(layout.varHandle(primitiveCarrierForSize(layout.byteSize())))
+            : layout.varHandle(carrier);
+    }
+
+    public static VaList newVaListOfAddress(MemoryAddress ma) {
+        return switch (CABI.current()) {
+            case Win64 -> Windowsx64Linker.newVaListOfAddress(ma);
+            case SysV -> SysVx64Linker.newVaListOfAddress(ma);
+            case AArch64 -> AArch64Linker.newVaListOfAddress(ma);
+        };
+    }
+
+    public static VaList emptyVaList() {
+        return switch (CABI.current()) {
+            case Win64 -> Windowsx64Linker.emptyVaList();
+            case SysV -> SysVx64Linker.emptyVaList();
+            case AArch64 -> AArch64Linker.emptyVaList();
+        };
+    }
+
+    public static MethodType convertVaListCarriers(MethodType mt, Class carrier) {
+        Class[] params = new Class[mt.parameterCount()];
+        for (int i = 0; i < params.length; i++) {
+            Class pType = mt.parameterType(i);
+            params[i] = ((pType == VaList.class) ? carrier : pType);
+        }
+        return methodType(mt.returnType(), params);
+    }
+
+    public static MethodHandle unboxVaLists(MethodType type, MethodHandle handle, MethodHandle unboxer) {
+        for (int i = 0; i < type.parameterCount(); i++) {
+            if (type.parameterType(i) == VaList.class) {
+               handle = MethodHandles.filterArguments(handle, i, unboxer);
+            }
+        }
+        return handle;
+    }
+
+    public static MethodHandle boxVaLists(MethodHandle handle, MethodHandle boxer) {
+        MethodType type = handle.type();
+        for (int i = 0; i < type.parameterCount(); i++) {
+            if (type.parameterType(i) == VaList.class) {
+               handle = MethodHandles.filterArguments(handle, i, boxer);
+            }
+        }
+        return handle;
+    }
+
+    static void checkType(Class actualType, Class expectedType) {
+        if (expectedType != actualType) {
+            throw new IllegalArgumentException(
+                    String.format("Invalid operand type: %s. %s expected", actualType, expectedType));
+        }
+    }
+
+    public static boolean isTrivial(FunctionDescriptor cDesc) {
+        return cDesc.attribute(FunctionDescriptor.TRIVIAL_ATTRIBUTE_NAME)
+                .map(Boolean.class::cast)
+                .orElse(false);
+    }
+
+    public interface Allocator extends AutoCloseable {
+        Allocator THROWING_ALLOCATOR = (size, align) -> { throw new UnsupportedOperationException("Null allocator"); };
+
+        default MemorySegment allocate(MemoryLayout layout) {
+            return allocate(layout.byteSize(), layout.byteAlignment());
+        }
+
+        default MemorySegment allocate(long size) {
+            return allocate(size, 1);
+        }
+
+        @Override
+        default void close() {}
+
+        MemorySegment allocate(long size, long align);
+
+        static Allocator ofScope(NativeScope scope) {
+            return new Allocator() {
+                @Override
+                public MemorySegment allocate(long size, long align) {
+                    return scope.allocate(size, align);
+                }
+
+                @Override
+                public void close() {
+                    scope.close();
+                }
+            };
+        }
+    }
+
+    public static class SimpleVaArg {
+        public final Class carrier;
+        public final MemoryLayout layout;
+        public final Object value;
+
+        public SimpleVaArg(Class carrier, MemoryLayout layout, Object value) {
+            this.carrier = carrier;
+            this.layout = layout;
+            this.value = value;
+        }
+
+        public VarHandle varHandle() {
+            return carrier == MemoryAddress.class
+                ? MemoryHandles.asAddressVarHandle(layout.varHandle(primitiveCarrierForSize(layout.byteSize())))
+                : layout.varHandle(carrier);
+        }
+    }
+
+    public static class EmptyVaList implements VaList {
+
+        private final MemoryAddress address;
+
+        public EmptyVaList(MemoryAddress address) {
+            this.address = address;
+        }
+
+        private static UnsupportedOperationException uoe() {
+            return new UnsupportedOperationException("Empty VaList");
+        }
+
+        @Override
+        public int vargAsInt(MemoryLayout layout) {
+            throw uoe();
+        }
+
+        @Override
+        public long vargAsLong(MemoryLayout layout) {
+            throw uoe();
+        }
+
+        @Override
+        public double vargAsDouble(MemoryLayout layout) {
+            throw uoe();
+        }
+
+        @Override
+        public MemoryAddress vargAsAddress(MemoryLayout layout) {
+            throw uoe();
+        }
+
+        @Override
+        public MemorySegment vargAsSegment(MemoryLayout layout) {
+            throw uoe();
+        }
+
+        @Override
+        public MemorySegment vargAsSegment(MemoryLayout layout, NativeScope scope) {
+            throw uoe();
+        }
+
+        @Override
+        public void skip(MemoryLayout... layouts) {
+            throw uoe();
+        }
+
+        @Override
+        public boolean isAlive() {
+            return true;
+        }
+
+        @Override
+        public void close() {
+            throw uoe();
+        }
+
+        @Override
+        public VaList copy() {
+            return this;
+        }
+
+        @Override
+        public VaList copy(NativeScope scope) {
+            throw uoe();
+        }
+
+        @Override
+        public MemoryAddress address() {
+            return address;
+        }
+    }
+
+    static void writeOverSized(MemorySegment ptr, Class type, Object o) {
+        // use VH_LONG for integers to zero out the whole register in the process
+        if (type == long.class) {
+            MemoryAccess.setLong(ptr, (long) o);
+        } else if (type == int.class) {
+            MemoryAccess.setLong(ptr, (int) o);
+        } else if (type == short.class) {
+            MemoryAccess.setLong(ptr, (short) o);
+        } else if (type == char.class) {
+            MemoryAccess.setLong(ptr, (char) o);
+        } else if (type == byte.class) {
+            MemoryAccess.setLong(ptr, (byte) o);
+        } else if (type == float.class) {
+            MemoryAccess.setFloat(ptr, (float) o);
+        } else if (type == double.class) {
+            MemoryAccess.setDouble(ptr, (double) o);
+        } else {
+            throw new IllegalArgumentException("Unsupported carrier: " + type);
+        }
+    }
+
+    static void write(MemorySegment ptr, Class type, Object o) {
+        if (type == long.class) {
+            MemoryAccess.setLong(ptr, (long) o);
+        } else if (type == int.class) {
+            MemoryAccess.setInt(ptr, (int) o);
+        } else if (type == short.class) {
+            MemoryAccess.setShort(ptr, (short) o);
+        } else if (type == char.class) {
+            MemoryAccess.setChar(ptr, (char) o);
+        } else if (type == byte.class) {
+            MemoryAccess.setByte(ptr, (byte) o);
+        } else if (type == float.class) {
+            MemoryAccess.setFloat(ptr, (float) o);
+        } else if (type == double.class) {
+            MemoryAccess.setDouble(ptr, (double) o);
+        } else {
+            throw new IllegalArgumentException("Unsupported carrier: " + type);
+        }
+    }
+
+    static Object read(MemorySegment ptr, Class type) {
+        if (type == long.class) {
+            return MemoryAccess.getLong(ptr);
+        } else if (type == int.class) {
+            return MemoryAccess.getInt(ptr);
+        } else if (type == short.class) {
+            return MemoryAccess.getShort(ptr);
+        } else if (type == char.class) {
+            return MemoryAccess.getChar(ptr);
+        } else if (type == byte.class) {
+            return MemoryAccess.getByte(ptr);
+        } else if (type == float.class) {
+            return MemoryAccess.getFloat(ptr);
+        } else if (type == double.class) {
+            return MemoryAccess.getDouble(ptr);
+        } else {
+            throw new IllegalArgumentException("Unsupported carrier: " + type);
+        }
+    }
+}
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/UpcallHandler.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/UpcallHandler.java
new file mode 100644
index 0000000000000..913dc1d17e018
--- /dev/null
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/UpcallHandler.java
@@ -0,0 +1,28 @@
+/*
+ *  Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
+ *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ *  This code is free software; you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License version 2 only, as
+ *  published by the Free Software Foundation.
+ *
+ *  This code 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
+ *  version 2 for more details (a copy is included in the LICENSE file that
+ *  accompanied this code).
+ *
+ *  You should have received a copy of the GNU General Public License version
+ *  2 along with this work; if not, write to the Free Software Foundation,
+ *  Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ *  Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ *  or visit www.oracle.com if you need additional information or have any
+ *  questions.
+ */
+
+package jdk.internal.foreign.abi;
+
+public interface UpcallHandler {
+    long entryPoint();
+}
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/UpcallStubs.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/UpcallStubs.java
new file mode 100644
index 0000000000000..4db7d77d0334e
--- /dev/null
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/UpcallStubs.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package jdk.internal.foreign.abi;
+
+import jdk.incubator.foreign.MemoryAddress;
+import jdk.incubator.foreign.MemorySegment;
+import jdk.internal.foreign.MemoryAddressImpl;
+import jdk.internal.foreign.NativeMemorySegmentImpl;
+
+public class UpcallStubs {
+
+    public static MemorySegment upcallAddress(UpcallHandler handler) {
+        long stubAddress = handler.entryPoint();
+        return NativeMemorySegmentImpl.makeNativeSegmentUnchecked(
+                MemoryAddress.ofLong(stubAddress), 0, () -> freeUpcallStub(stubAddress), null)
+                .share()
+                .withAccessModes(MemorySegment.CLOSE | MemorySegment.HANDOFF | MemorySegment.SHARE);
+    };
+
+    private static void freeUpcallStub(long stubAddress) {
+        if (!freeUpcallStub0(stubAddress)) {
+            throw new IllegalStateException("Not a stub address: " + stubAddress);
+        }
+    }
+
+    // natives
+
+    // returns true if the stub was found (and freed)
+    private static native boolean freeUpcallStub0(long addr);
+
+    private static native void registerNatives();
+    static {
+        registerNatives();
+    }
+}
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/VMStorage.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/VMStorage.java
new file mode 100644
index 0000000000000..23f3bc3fba70e
--- /dev/null
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/VMStorage.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package jdk.internal.foreign.abi;
+
+import jdk.internal.invoke.VMStorageProxy;
+
+import java.util.Objects;
+
+public class VMStorage implements VMStorageProxy {
+    private final int type;
+    private final int index;
+
+    private final String debugName;
+
+    public VMStorage(int type, int index, String debugName) {
+        this.type = type;
+        this.index = index;
+        this.debugName = debugName;
+    }
+
+    public int type() {
+        return type;
+    }
+
+    public int index() {
+        return index;
+    }
+
+    public String name() {
+        return debugName;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        VMStorage vmStorage = (VMStorage) o;
+        return type == vmStorage.type &&
+                index == vmStorage.index;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(type, index);
+    }
+
+    @Override
+    public String toString() {
+        return "VMStorage{" +
+                "type=" + type +
+                ", index=" + index +
+                ", debugName='" + debugName + '\'' +
+                '}';
+    }
+}
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/aarch64/AArch64Architecture.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/aarch64/AArch64Architecture.java
new file mode 100644
index 0000000000000..31fc75fc4367a
--- /dev/null
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/aarch64/AArch64Architecture.java
@@ -0,0 +1,169 @@
+/*
+ * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2019, Arm Limited. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package jdk.internal.foreign.abi.aarch64;
+
+import jdk.internal.foreign.abi.ABIDescriptor;
+import jdk.internal.foreign.abi.Architecture;
+import jdk.internal.foreign.abi.VMStorage;
+
+public class AArch64Architecture implements Architecture {
+    public static final Architecture INSTANCE = new AArch64Architecture();
+
+    private static final int INTEGER_REG_SIZE = 8;
+    private static final int VECTOR_REG_SIZE = 16;
+    private static final int STACK_SLOT_SIZE = 8;
+
+    @Override
+    public boolean isStackType(int cls) {
+        return cls == StorageClasses.STACK;
+    }
+
+    @Override
+    public int typeSize(int cls) {
+        switch (cls) {
+            case StorageClasses.INTEGER: return INTEGER_REG_SIZE;
+            case StorageClasses.VECTOR: return VECTOR_REG_SIZE;
+            case StorageClasses.STACK: return STACK_SLOT_SIZE;
+        }
+
+        throw new IllegalArgumentException("Invalid Storage Class: " + cls);
+    }
+
+    @Override
+    public int stackType() {
+        return StorageClasses.STACK;
+    }
+
+    public interface StorageClasses {
+        int INTEGER = 0;
+        int VECTOR = 1;
+        int STACK = 3;
+    }
+
+    public static final VMStorage r0  = integerRegister(0);
+    public static final VMStorage r1  = integerRegister(1);
+    public static final VMStorage r2  = integerRegister(2);
+    public static final VMStorage r3  = integerRegister(3);
+    public static final VMStorage r4  = integerRegister(4);
+    public static final VMStorage r5  = integerRegister(5);
+    public static final VMStorage r6  = integerRegister(6);
+    public static final VMStorage r7  = integerRegister(7);
+    public static final VMStorage r8  = integerRegister(8);
+    public static final VMStorage r9  = integerRegister(9);
+    public static final VMStorage r10 = integerRegister(10);
+    public static final VMStorage r11 = integerRegister(11);
+    public static final VMStorage r12 = integerRegister(12);
+    public static final VMStorage r13 = integerRegister(13);
+    public static final VMStorage r14 = integerRegister(14);
+    public static final VMStorage r15 = integerRegister(15);
+    public static final VMStorage r16 = integerRegister(16);
+    public static final VMStorage r17 = integerRegister(17);
+    public static final VMStorage r18 = integerRegister(18);
+    public static final VMStorage r19 = integerRegister(19);
+    public static final VMStorage r20 = integerRegister(20);
+    public static final VMStorage r21 = integerRegister(21);
+    public static final VMStorage r22 = integerRegister(22);
+    public static final VMStorage r23 = integerRegister(23);
+    public static final VMStorage r24 = integerRegister(24);
+    public static final VMStorage r25 = integerRegister(25);
+    public static final VMStorage r26 = integerRegister(26);
+    public static final VMStorage r27 = integerRegister(27);
+    public static final VMStorage r28 = integerRegister(28);
+    public static final VMStorage r29 = integerRegister(29);
+    public static final VMStorage r30 = integerRegister(30);
+    public static final VMStorage r31 = integerRegister(31);
+
+    public static final VMStorage v0  = vectorRegister(0);
+    public static final VMStorage v1  = vectorRegister(1);
+    public static final VMStorage v2  = vectorRegister(2);
+    public static final VMStorage v3  = vectorRegister(3);
+    public static final VMStorage v4  = vectorRegister(4);
+    public static final VMStorage v5  = vectorRegister(5);
+    public static final VMStorage v6  = vectorRegister(6);
+    public static final VMStorage v7  = vectorRegister(7);
+    public static final VMStorage v8  = vectorRegister(8);
+    public static final VMStorage v9  = vectorRegister(9);
+    public static final VMStorage v10 = vectorRegister(10);
+    public static final VMStorage v11 = vectorRegister(11);
+    public static final VMStorage v12 = vectorRegister(12);
+    public static final VMStorage v13 = vectorRegister(13);
+    public static final VMStorage v14 = vectorRegister(14);
+    public static final VMStorage v15 = vectorRegister(15);
+    public static final VMStorage v16 = vectorRegister(16);
+    public static final VMStorage v17 = vectorRegister(17);
+    public static final VMStorage v18 = vectorRegister(18);
+    public static final VMStorage v19 = vectorRegister(19);
+    public static final VMStorage v20 = vectorRegister(20);
+    public static final VMStorage v21 = vectorRegister(21);
+    public static final VMStorage v22 = vectorRegister(22);
+    public static final VMStorage v23 = vectorRegister(23);
+    public static final VMStorage v24 = vectorRegister(24);
+    public static final VMStorage v25 = vectorRegister(25);
+    public static final VMStorage v26 = vectorRegister(26);
+    public static final VMStorage v27 = vectorRegister(27);
+    public static final VMStorage v28 = vectorRegister(28);
+    public static final VMStorage v29 = vectorRegister(29);
+    public static final VMStorage v30 = vectorRegister(30);
+    public static final VMStorage v31 = vectorRegister(31);
+
+    private static VMStorage integerRegister(int index) {
+        return new VMStorage(StorageClasses.INTEGER, index, "r" + index);
+    }
+
+    private static VMStorage vectorRegister(int index) {
+        return new VMStorage(StorageClasses.VECTOR, index, "v" + index);
+    }
+
+    public static VMStorage stackStorage(int index) {
+        return new VMStorage(StorageClasses.STACK, index, "Stack@" + index);
+    }
+
+    public static ABIDescriptor abiFor(VMStorage[] inputIntRegs,
+                                       VMStorage[] inputVectorRegs,
+                                       VMStorage[] outputIntRegs,
+                                       VMStorage[] outputVectorRegs,
+                                       VMStorage[] volatileIntRegs,
+                                       VMStorage[] volatileVectorRegs,
+                                       int stackAlignment,
+                                       int shadowSpace) {
+        return new ABIDescriptor(
+            INSTANCE,
+            new VMStorage[][] {
+                inputIntRegs,
+                inputVectorRegs,
+            },
+            new VMStorage[][] {
+                outputIntRegs,
+                outputVectorRegs,
+            },
+            new VMStorage[][] {
+                volatileIntRegs,
+                volatileVectorRegs,
+            },
+            stackAlignment,
+            shadowSpace
+        );
+    }
+
+}
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/aarch64/AArch64Linker.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/aarch64/AArch64Linker.java
new file mode 100644
index 0000000000000..fcfbf300b68f9
--- /dev/null
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/aarch64/AArch64Linker.java
@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2019, 2020, Arm Limited. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package jdk.internal.foreign.abi.aarch64;
+
+import jdk.incubator.foreign.Addressable;
+import jdk.incubator.foreign.FunctionDescriptor;
+import jdk.incubator.foreign.MemoryAddress;
+import jdk.incubator.foreign.MemoryLayout;
+import jdk.incubator.foreign.MemorySegment;
+import jdk.incubator.foreign.CLinker;
+import jdk.internal.foreign.abi.SharedUtils;
+import jdk.internal.foreign.abi.UpcallStubs;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
+import java.util.function.Consumer;
+
+import static jdk.internal.foreign.PlatformLayouts.*;
+
+/**
+ * ABI implementation based on ARM document "Procedure Call Standard for
+ * the ARM 64-bit Architecture".
+ */
+public class AArch64Linker implements CLinker {
+    private static AArch64Linker instance;
+
+    static final long ADDRESS_SIZE = 64; // bits
+
+    private static final MethodHandle MH_unboxVaList;
+    private static final MethodHandle MH_boxVaList;
+
+    static {
+        try {
+            MethodHandles.Lookup lookup = MethodHandles.lookup();
+            MH_unboxVaList = lookup.findVirtual(VaList.class, "address",
+                MethodType.methodType(MemoryAddress.class));
+            MH_boxVaList = lookup.findStatic(AArch64Linker.class, "newVaListOfAddress",
+                MethodType.methodType(VaList.class, MemoryAddress.class));
+        } catch (ReflectiveOperationException e) {
+            throw new ExceptionInInitializerError(e);
+        }
+    }
+
+    public static AArch64Linker getInstance() {
+        if (instance == null) {
+            instance = new AArch64Linker();
+        }
+        return instance;
+    }
+
+    @Override
+    public MethodHandle downcallHandle(Addressable symbol, MethodType type, FunctionDescriptor function) {
+        MethodType llMt = SharedUtils.convertVaListCarriers(type, AArch64VaList.CARRIER);
+        MethodHandle handle = CallArranger.arrangeDowncall(symbol, llMt, function);
+        handle = SharedUtils.unboxVaLists(type, handle, MH_unboxVaList);
+        return handle;
+    }
+
+    @Override
+    public MemorySegment upcallStub(MethodHandle target, FunctionDescriptor function) {
+        target = SharedUtils.boxVaLists(target, MH_boxVaList);
+        return UpcallStubs.upcallAddress(CallArranger.arrangeUpcall(target, target.type(), function));
+    }
+
+    public static VaList newVaList(Consumer actions, SharedUtils.Allocator allocator) {
+        AArch64VaList.Builder builder = AArch64VaList.builder(allocator);
+        actions.accept(builder);
+        return builder.build();
+    }
+
+    public static VaList newVaListOfAddress(MemoryAddress ma) {
+        return AArch64VaList.ofAddress(ma);
+    }
+
+    public static VaList emptyVaList() {
+        return AArch64VaList.empty();
+    }
+
+}
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/aarch64/AArch64VaList.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/aarch64/AArch64VaList.java
new file mode 100644
index 0000000000000..3d7147fcfea5e
--- /dev/null
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/aarch64/AArch64VaList.java
@@ -0,0 +1,565 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020, Arm Limited. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package jdk.internal.foreign.abi.aarch64;
+
+import jdk.incubator.foreign.*;
+import jdk.internal.foreign.NativeMemorySegmentImpl;
+import jdk.internal.foreign.Utils;
+import jdk.internal.foreign.abi.SharedUtils;
+import jdk.internal.misc.Unsafe;
+
+import java.lang.invoke.VarHandle;
+import java.lang.ref.Cleaner;
+import java.nio.ByteOrder;
+import java.util.ArrayList;
+import java.util.List;
+
+import static jdk.internal.foreign.PlatformLayouts.AArch64;
+import static jdk.incubator.foreign.CLinker.VaList;
+import static jdk.incubator.foreign.MemoryLayout.PathElement.groupElement;
+import static jdk.internal.foreign.abi.SharedUtils.SimpleVaArg;
+import static jdk.internal.foreign.abi.SharedUtils.checkCompatibleType;
+import static jdk.internal.foreign.abi.SharedUtils.vhPrimitiveOrAddress;
+import static jdk.internal.foreign.abi.aarch64.CallArranger.MAX_REGISTER_ARGUMENTS;
+
+public class AArch64VaList implements VaList {
+    private static final Unsafe U = Unsafe.getUnsafe();
+
+    static final Class CARRIER = MemoryAddress.class;
+
+    // See AAPCS Appendix B "Variable Argument Lists" for definition of
+    // va_list on AArch64.
+    //
+    // typedef struct __va_list {
+    //     void *__stack;   // next stack param
+    //     void *__gr_top;  // end of GP arg reg save area
+    //     void *__vr_top;  // end of FP/SIMD arg reg save area
+    //     int __gr_offs;   // offset from __gr_top to next GP register arg
+    //     int __vr_offs;   // offset from __vr_top to next FP/SIMD register arg
+    // } va_list;
+
+    static final GroupLayout LAYOUT = MemoryLayout.ofStruct(
+        AArch64.C_POINTER.withName("__stack"),
+        AArch64.C_POINTER.withName("__gr_top"),
+        AArch64.C_POINTER.withName("__vr_top"),
+        AArch64.C_INT.withName("__gr_offs"),
+        AArch64.C_INT.withName("__vr_offs")
+    ).withName("__va_list");
+
+    private static final MemoryLayout GP_REG
+        = MemoryLayout.ofValueBits(64, ByteOrder.nativeOrder());
+    private static final MemoryLayout FP_REG
+        = MemoryLayout.ofValueBits(128, ByteOrder.nativeOrder());
+
+    private static final MemoryLayout LAYOUT_GP_REGS
+        = MemoryLayout.ofSequence(MAX_REGISTER_ARGUMENTS, GP_REG);
+    private static final MemoryLayout LAYOUT_FP_REGS
+        = MemoryLayout.ofSequence(MAX_REGISTER_ARGUMENTS, FP_REG);
+
+    private static final int GP_SLOT_SIZE = (int) GP_REG.byteSize();
+    private static final int FP_SLOT_SIZE = (int) FP_REG.byteSize();
+
+    private static final int MAX_GP_OFFSET = (int) LAYOUT_GP_REGS.byteSize();
+    private static final int MAX_FP_OFFSET = (int) LAYOUT_FP_REGS.byteSize();
+
+    private static final VarHandle VH_stack
+        = MemoryHandles.asAddressVarHandle(LAYOUT.varHandle(long.class, groupElement("__stack")));
+    private static final VarHandle VH_gr_top
+        = MemoryHandles.asAddressVarHandle(LAYOUT.varHandle(long.class, groupElement("__gr_top")));
+    private static final VarHandle VH_vr_top
+        = MemoryHandles.asAddressVarHandle(LAYOUT.varHandle(long.class, groupElement("__vr_top")));
+    private static final VarHandle VH_gr_offs
+        = LAYOUT.varHandle(int.class, groupElement("__gr_offs"));
+    private static final VarHandle VH_vr_offs
+        = LAYOUT.varHandle(int.class, groupElement("__vr_offs"));
+
+    private static final Cleaner cleaner = Cleaner.create();
+    private static final VaList EMPTY
+        = new SharedUtils.EmptyVaList(emptyListAddress());
+
+    private final MemorySegment segment;
+    private final MemorySegment gpRegsArea;
+    private final MemorySegment fpRegsArea;
+    private final List attachedSegments;
+
+    private AArch64VaList(MemorySegment segment, MemorySegment gpRegsArea, MemorySegment fpRegsArea,
+                          List attachedSegments) {
+        this.segment = segment;
+        this.gpRegsArea = gpRegsArea;
+        this.fpRegsArea = fpRegsArea;
+        this.attachedSegments = attachedSegments;
+    }
+
+    private static AArch64VaList readFromSegment(MemorySegment segment) {
+        MemorySegment gpRegsArea = handoffIfNeeded(grTop(segment).addOffset(-MAX_GP_OFFSET)
+                .asSegmentRestricted(MAX_GP_OFFSET), segment.ownerThread());
+
+        MemorySegment fpRegsArea = handoffIfNeeded(vrTop(segment).addOffset(-MAX_FP_OFFSET)
+                .asSegmentRestricted(MAX_FP_OFFSET), segment.ownerThread());
+        return new AArch64VaList(segment, gpRegsArea, fpRegsArea, List.of(gpRegsArea, fpRegsArea));
+    }
+
+    private static MemoryAddress emptyListAddress() {
+        long ptr = U.allocateMemory(LAYOUT.byteSize());
+        MemorySegment ms = MemoryAddress.ofLong(ptr)
+                .asSegmentRestricted(LAYOUT.byteSize(), () -> U.freeMemory(ptr), null)
+                .share();
+        cleaner.register(AArch64VaList.class, ms::close);
+        VH_stack.set(ms, MemoryAddress.NULL);
+        VH_gr_top.set(ms, MemoryAddress.NULL);
+        VH_vr_top.set(ms, MemoryAddress.NULL);
+        VH_gr_offs.set(ms, 0);
+        VH_vr_offs.set(ms, 0);
+        return ms.address();
+    }
+
+    public static VaList empty() {
+        return EMPTY;
+    }
+
+    private MemoryAddress grTop() {
+        return grTop(segment);
+    }
+
+    private static MemoryAddress grTop(MemorySegment segment) {
+        return (MemoryAddress) VH_gr_top.get(segment);
+    }
+
+    private MemoryAddress vrTop() {
+        return vrTop(segment);
+    }
+
+    private static MemoryAddress vrTop(MemorySegment segment) {
+        return (MemoryAddress) VH_vr_top.get(segment);
+    }
+
+    private int grOffs() {
+        final int offs = (int) VH_gr_offs.get(segment);
+        assert offs <= 0;
+        return offs;
+    }
+
+    private int vrOffs() {
+        final int offs = (int) VH_vr_offs.get(segment);
+        assert offs <= 0;
+        return offs;
+    }
+
+    private MemoryAddress stackPtr() {
+        return (MemoryAddress) VH_stack.get(segment);
+    }
+
+    private void stackPtr(MemoryAddress ptr) {
+        VH_stack.set(segment, ptr);
+    }
+
+    private void consumeGPSlots(int num) {
+        final int old = (int) VH_gr_offs.get(segment);
+        VH_gr_offs.set(segment, old + num * GP_SLOT_SIZE);
+    }
+
+    private void consumeFPSlots(int num) {
+        final int old = (int) VH_vr_offs.get(segment);
+        VH_vr_offs.set(segment, old + num * FP_SLOT_SIZE);
+    }
+
+    private long currentGPOffset() {
+        // Offset from start of GP register segment. __gr_top points to the top
+        // (highest address) of the GP registers area. __gr_offs is the negative
+        // offset of next saved register from the top.
+
+        return gpRegsArea.byteSize() + grOffs();
+    }
+
+    private long currentFPOffset() {
+        // Offset from start of FP register segment. __vr_top points to the top
+        // (highest address) of the FP registers area. __vr_offs is the negative
+        // offset of next saved register from the top.
+
+        return fpRegsArea.byteSize() + vrOffs();
+    }
+
+    private void preAlignStack(MemoryLayout layout) {
+        if (layout.byteAlignment() > 8) {
+            stackPtr(Utils.alignUp(stackPtr(), 16));
+        }
+    }
+
+    private void postAlignStack(MemoryLayout layout) {
+        stackPtr(Utils.alignUp(stackPtr().addOffset(layout.byteSize()), 8));
+    }
+
+    @Override
+    public int vargAsInt(MemoryLayout layout) {
+        return (int) read(int.class, layout);
+    }
+
+    @Override
+    public long vargAsLong(MemoryLayout layout) {
+        return (long) read(long.class, layout);
+    }
+
+    @Override
+    public double vargAsDouble(MemoryLayout layout) {
+        return (double) read(double.class, layout);
+    }
+
+    @Override
+    public MemoryAddress vargAsAddress(MemoryLayout layout) {
+        return (MemoryAddress) read(MemoryAddress.class, layout);
+    }
+
+    @Override
+    public MemorySegment vargAsSegment(MemoryLayout layout) {
+        return (MemorySegment) read(MemorySegment.class, layout);
+    }
+
+    @Override
+    public MemorySegment vargAsSegment(MemoryLayout layout, NativeScope scope) {
+        return (MemorySegment) read(MemorySegment.class, layout, SharedUtils.Allocator.ofScope(scope));
+    }
+
+    private Object read(Class carrier, MemoryLayout layout) {
+        return read(carrier, layout, MemorySegment::allocateNative);
+    }
+
+    private Object read(Class carrier, MemoryLayout layout, SharedUtils.Allocator allocator) {
+        checkCompatibleType(carrier, layout, AArch64Linker.ADDRESS_SIZE);
+
+        TypeClass typeClass = TypeClass.classifyLayout(layout);
+        if (isRegOverflow(currentGPOffset(), currentFPOffset(), typeClass, layout)) {
+            preAlignStack(layout);
+            return switch (typeClass) {
+                case STRUCT_REGISTER, STRUCT_HFA, STRUCT_REFERENCE -> {
+                    try (MemorySegment slice = handoffIfNeeded(stackPtr()
+                            .asSegmentRestricted(layout.byteSize()), segment.ownerThread())) {
+                        MemorySegment seg = allocator.allocate(layout);
+                        seg.copyFrom(slice);
+                        postAlignStack(layout);
+                        yield seg;
+                    }
+                }
+                case POINTER, INTEGER, FLOAT -> {
+                    VarHandle reader = vhPrimitiveOrAddress(carrier, layout);
+                    try (MemorySegment slice = handoffIfNeeded(stackPtr()
+                            .asSegmentRestricted(layout.byteSize()), segment.ownerThread())) {
+                        Object res = reader.get(slice);
+                        postAlignStack(layout);
+                        yield res;
+                    }
+                }
+            };
+        } else {
+            return switch (typeClass) {
+                case STRUCT_REGISTER -> {
+                    // Struct is passed packed in integer registers.
+                    MemorySegment value = allocator.allocate(layout);
+                    long offset = 0;
+                    while (offset < layout.byteSize()) {
+                        final long copy = Math.min(layout.byteSize() - offset, 8);
+                        MemorySegment slice = value.asSlice(offset, copy);
+                        slice.copyFrom(gpRegsArea.asSlice(currentGPOffset(), copy));
+                        consumeGPSlots(1);
+                        offset += copy;
+                    }
+                    yield value;
+                }
+                case STRUCT_HFA -> {
+                    // Struct is passed with each element in a separate floating
+                    // point register.
+                    MemorySegment value = allocator.allocate(layout);
+                    GroupLayout group = (GroupLayout)layout;
+                    long offset = 0;
+                    for (MemoryLayout elem : group.memberLayouts()) {
+                        assert elem.byteSize() <= 8;
+                        final long copy = elem.byteSize();
+                        MemorySegment slice = value.asSlice(offset, copy);
+                        slice.copyFrom(fpRegsArea.asSlice(currentFPOffset(), copy));
+                        consumeFPSlots(1);
+                        offset += copy;
+                    }
+                    yield value;
+                }
+                case STRUCT_REFERENCE -> {
+                    // Struct is passed indirectly via a pointer in an integer register.
+                    VarHandle ptrReader
+                        = SharedUtils.vhPrimitiveOrAddress(MemoryAddress.class, AArch64.C_POINTER);
+                    MemoryAddress ptr = (MemoryAddress) ptrReader.get(
+                        gpRegsArea.asSlice(currentGPOffset()));
+                    consumeGPSlots(1);
+
+                    try (MemorySegment slice = handoffIfNeeded(ptr
+                            .asSegmentRestricted(layout.byteSize()), segment.ownerThread())) {
+                        MemorySegment seg = allocator.allocate(layout);
+                        seg.copyFrom(slice);
+                        yield seg;
+                    }
+                }
+                case POINTER, INTEGER -> {
+                    VarHandle reader = SharedUtils.vhPrimitiveOrAddress(carrier, layout);
+                    Object res = reader.get(gpRegsArea.asSlice(currentGPOffset()));
+                    consumeGPSlots(1);
+                    yield res;
+                }
+                case FLOAT -> {
+                    VarHandle reader = layout.varHandle(carrier);
+                    Object res = reader.get(fpRegsArea.asSlice(currentFPOffset()));
+                    consumeFPSlots(1);
+                    yield res;
+                }
+            };
+        }
+    }
+
+    @Override
+    public void skip(MemoryLayout... layouts) {
+        for (MemoryLayout layout : layouts) {
+            TypeClass typeClass = TypeClass.classifyLayout(layout);
+            if (isRegOverflow(currentGPOffset(), currentFPOffset(), typeClass, layout)) {
+                preAlignStack(layout);
+                postAlignStack(layout);
+            } else if (typeClass == TypeClass.FLOAT || typeClass == TypeClass.STRUCT_HFA) {
+                consumeFPSlots(numSlots(layout));
+            } else if (typeClass == TypeClass.STRUCT_REFERENCE) {
+                consumeGPSlots(1);
+            } else {
+                consumeGPSlots(numSlots(layout));
+            }
+        }
+    }
+
+    static AArch64VaList.Builder builder(SharedUtils.Allocator allocator) {
+        return new AArch64VaList.Builder(allocator);
+    }
+
+    public static VaList ofAddress(MemoryAddress ma) {
+        return readFromSegment(ma.asSegmentRestricted(LAYOUT.byteSize()));
+    }
+
+    @Override
+    public boolean isAlive() {
+        return segment.isAlive();
+    }
+
+    @Override
+    public void close() {
+        segment.close();
+        attachedSegments.forEach(MemorySegment::close);
+    }
+
+    @Override
+    public VaList copy() {
+        return copy(MemorySegment::allocateNative);
+    }
+
+    @Override
+    public VaList copy(NativeScope scope) {
+        return copy(SharedUtils.Allocator.ofScope(scope));
+    }
+
+    private VaList copy(SharedUtils.Allocator allocator) {
+        MemorySegment copy = allocator.allocate(LAYOUT);
+        copy.copyFrom(segment);
+        return new AArch64VaList(copy, gpRegsArea, fpRegsArea, List.of());
+    }
+
+    @Override
+    public MemoryAddress address() {
+        return segment.address();
+    }
+
+    private static int numSlots(MemoryLayout layout) {
+        return (int) Utils.alignUp(layout.byteSize(), 8) / 8;
+    }
+
+    private static boolean isRegOverflow(long currentGPOffset, long currentFPOffset,
+                                         TypeClass typeClass, MemoryLayout layout) {
+        if (typeClass == TypeClass.FLOAT || typeClass == TypeClass.STRUCT_HFA) {
+            return currentFPOffset > MAX_FP_OFFSET - numSlots(layout) * FP_SLOT_SIZE;
+        } else if (typeClass == TypeClass.STRUCT_REFERENCE) {
+            return currentGPOffset > MAX_GP_OFFSET - GP_SLOT_SIZE;
+        } else {
+            return currentGPOffset > MAX_GP_OFFSET - numSlots(layout) * GP_SLOT_SIZE;
+        }
+    }
+
+    @Override
+    public String toString() {
+        return "AArch64VaList{"
+            + "__stack=" + stackPtr()
+            + ", __gr_top=" + grTop()
+            + ", __vr_top=" + vrTop()
+            + ", __gr_offs=" + grOffs()
+            + ", __vr_offs=" + vrOffs()
+            + '}';
+    }
+
+    static class Builder implements VaList.Builder {
+        private final SharedUtils.Allocator allocator;
+        private final MemorySegment gpRegs;
+        private final MemorySegment fpRegs;
+
+        private long currentGPOffset = 0;
+        private long currentFPOffset = 0;
+        private final List stackArgs = new ArrayList<>();
+
+        Builder(SharedUtils.Allocator allocator) {
+            this.allocator = allocator;
+            this.gpRegs = allocator.allocate(LAYOUT_GP_REGS);
+            this.fpRegs = allocator.allocate(LAYOUT_FP_REGS);
+        }
+
+        @Override
+        public Builder vargFromInt(ValueLayout layout, int value) {
+            return arg(int.class, layout, value);
+        }
+
+        @Override
+        public Builder vargFromLong(ValueLayout layout, long value) {
+            return arg(long.class, layout, value);
+        }
+
+        @Override
+        public Builder vargFromDouble(ValueLayout layout, double value) {
+            return arg(double.class, layout, value);
+        }
+
+        @Override
+        public Builder vargFromAddress(ValueLayout layout, Addressable value) {
+            return arg(MemoryAddress.class, layout, value.address());
+        }
+
+        @Override
+        public Builder vargFromSegment(GroupLayout layout, MemorySegment value) {
+            return arg(MemorySegment.class, layout, value);
+        }
+
+        private Builder arg(Class carrier, MemoryLayout layout, Object value) {
+            checkCompatibleType(carrier, layout, AArch64Linker.ADDRESS_SIZE);
+
+            TypeClass typeClass = TypeClass.classifyLayout(layout);
+            if (isRegOverflow(currentGPOffset, currentFPOffset, typeClass, layout)) {
+                stackArgs.add(new SimpleVaArg(carrier, layout, value));
+            } else {
+                switch (typeClass) {
+                    case STRUCT_REGISTER -> {
+                        // Struct is passed packed in integer registers.
+                        MemorySegment valueSegment = (MemorySegment) value;
+                        long offset = 0;
+                        while (offset < layout.byteSize()) {
+                            final long copy = Math.min(layout.byteSize() - offset, 8);
+                            MemorySegment slice = valueSegment.asSlice(offset, copy);
+                            gpRegs.asSlice(currentGPOffset, copy).copyFrom(slice);
+                            currentGPOffset += GP_SLOT_SIZE;
+                            offset += copy;
+                        }
+                    }
+                    case STRUCT_HFA -> {
+                        // Struct is passed with each element in a separate floating
+                        // point register.
+                        MemorySegment valueSegment = (MemorySegment) value;
+                        GroupLayout group = (GroupLayout)layout;
+                        long offset = 0;
+                        for (MemoryLayout elem : group.memberLayouts()) {
+                            assert elem.byteSize() <= 8;
+                            final long copy = elem.byteSize();
+                            MemorySegment slice = valueSegment.asSlice(offset, copy);
+                            fpRegs.asSlice(currentFPOffset, copy).copyFrom(slice);
+                            currentFPOffset += FP_SLOT_SIZE;
+                            offset += copy;
+                        }
+                    }
+                    case STRUCT_REFERENCE -> {
+                        // Struct is passed indirectly via a pointer in an integer register.
+                        MemorySegment valueSegment = (MemorySegment) value;
+                        VarHandle writer
+                            = SharedUtils.vhPrimitiveOrAddress(MemoryAddress.class,
+                                                               AArch64.C_POINTER);
+                        writer.set(gpRegs.asSlice(currentGPOffset),
+                                   valueSegment.address());
+                        currentGPOffset += GP_SLOT_SIZE;
+                    }
+                    case POINTER, INTEGER -> {
+                        VarHandle writer = SharedUtils.vhPrimitiveOrAddress(carrier, layout);
+                        writer.set(gpRegs.asSlice(currentGPOffset), value);
+                        currentGPOffset += GP_SLOT_SIZE;
+                    }
+                    case FLOAT -> {
+                        VarHandle writer = layout.varHandle(carrier);
+                        writer.set(fpRegs.asSlice(currentFPOffset), value);
+                        currentFPOffset += FP_SLOT_SIZE;
+                    }
+                }
+            }
+            return this;
+        }
+
+        private boolean isEmpty() {
+            return currentGPOffset == 0 && currentFPOffset == 0 && stackArgs.isEmpty();
+        }
+
+        public VaList build() {
+            if (isEmpty()) {
+                return EMPTY;
+            }
+
+            MemorySegment vaListSegment = allocator.allocate(LAYOUT);
+            List attachedSegments = new ArrayList<>();
+            MemoryAddress stackArgsPtr = MemoryAddress.NULL;
+            if (!stackArgs.isEmpty()) {
+                long stackArgsSize = stackArgs.stream()
+                    .reduce(0L, (acc, e) -> acc + Utils.alignUp(e.layout.byteSize(), 8), Long::sum);
+                MemorySegment stackArgsSegment = allocator.allocate(stackArgsSize, 16);
+                stackArgsPtr = stackArgsSegment.address();
+                for (SimpleVaArg arg : stackArgs) {
+                    final long alignedSize = Utils.alignUp(arg.layout.byteSize(), 8);
+                    stackArgsSegment = Utils.alignUp(stackArgsSegment, alignedSize);
+                    VarHandle writer = arg.varHandle();
+                    writer.set(stackArgsSegment, arg.value);
+                    stackArgsSegment = stackArgsSegment.asSlice(alignedSize);
+                }
+                attachedSegments.add(stackArgsSegment);
+            }
+
+            VH_gr_top.set(vaListSegment, gpRegs.asSlice(gpRegs.byteSize()).address());
+            VH_vr_top.set(vaListSegment, fpRegs.asSlice(fpRegs.byteSize()).address());
+            VH_stack.set(vaListSegment, stackArgsPtr);
+            VH_gr_offs.set(vaListSegment, -MAX_GP_OFFSET);
+            VH_vr_offs.set(vaListSegment, -MAX_FP_OFFSET);
+
+            attachedSegments.add(gpRegs);
+            attachedSegments.add(fpRegs);
+            assert gpRegs.ownerThread() == vaListSegment.ownerThread();
+            assert fpRegs.ownerThread() == vaListSegment.ownerThread();
+            return new AArch64VaList(vaListSegment, gpRegs, fpRegs, attachedSegments);
+        }
+    }
+
+    private static MemorySegment handoffIfNeeded(MemorySegment segment, Thread thread) {
+        return segment.ownerThread() == thread ?
+                segment : segment.handoff(thread);
+    }
+}
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/aarch64/CallArranger.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/aarch64/CallArranger.java
new file mode 100644
index 0000000000000..3f07cc920da6d
--- /dev/null
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/aarch64/CallArranger.java
@@ -0,0 +1,462 @@
+/*
+ * Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2019, 2020, Arm Limited. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package jdk.internal.foreign.abi.aarch64;
+
+import jdk.incubator.foreign.Addressable;
+import jdk.incubator.foreign.FunctionDescriptor;
+import jdk.incubator.foreign.GroupLayout;
+import jdk.incubator.foreign.MemoryAddress;
+import jdk.incubator.foreign.MemoryLayout;
+import jdk.incubator.foreign.MemorySegment;
+import jdk.internal.foreign.PlatformLayouts;
+import jdk.internal.foreign.Utils;
+import jdk.internal.foreign.abi.CallingSequenceBuilder;
+import jdk.internal.foreign.abi.UpcallHandler;
+import jdk.internal.foreign.abi.ABIDescriptor;
+import jdk.internal.foreign.abi.Binding;
+import jdk.internal.foreign.abi.CallingSequence;
+import jdk.internal.foreign.abi.ProgrammableInvoker;
+import jdk.internal.foreign.abi.ProgrammableUpcallHandler;
+import jdk.internal.foreign.abi.VMStorage;
+import jdk.internal.foreign.abi.SharedUtils;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodType;
+import java.util.List;
+import java.util.Optional;
+
+import static jdk.internal.foreign.PlatformLayouts.*;
+import static jdk.internal.foreign.abi.aarch64.AArch64Architecture.*;
+
+/**
+ * For the AArch64 C ABI specifically, this class uses the ProgrammableInvoker API, namely CallingSequenceBuilder2
+ * to translate a C FunctionDescriptor into a CallingSequence2, which can then be turned into a MethodHandle.
+ *
+ * This includes taking care of synthetic arguments like pointers to return buffers for 'in-memory' returns.
+ */
+public class CallArranger {
+    private static final int STACK_SLOT_SIZE = 8;
+    public static final int MAX_REGISTER_ARGUMENTS = 8;
+
+    private static final VMStorage INDIRECT_RESULT = r8;
+
+    // This is derived from the AAPCS64 spec, restricted to what's
+    // possible when calling to/from C code.
+    //
+    // The indirect result register, r8, is used to return a large
+    // struct by value. It's treated as an input here as the caller is
+    // responsible for allocating storage and passing this into the
+    // function.
+    //
+    // Although the AAPCS64 says r0-7 and v0-7 are all valid return
+    // registers, it's not possible to generate a C function that uses
+    // r2-7 and v4-7 so they are omitted here.
+    private static final ABIDescriptor C = AArch64Architecture.abiFor(
+        new VMStorage[] { r0, r1, r2, r3, r4, r5, r6, r7, INDIRECT_RESULT},
+        new VMStorage[] { v0, v1, v2, v3, v4, v5, v6, v7 },
+        new VMStorage[] { r0, r1 },
+        new VMStorage[] { v0, v1, v2, v3 },
+        new VMStorage[] { r9, r10, r11, r12, r13, r14, r15 },
+        new VMStorage[] { v16, v17, v18, v19, v20, v21, v22, v23, v25,
+                          v26, v27, v28, v29, v30, v31 },
+        16,  // Stack is always 16 byte aligned on AArch64
+        0    // No shadow space
+    );
+
+    // record
+    public static class Bindings {
+        public final CallingSequence callingSequence;
+        public final boolean isInMemoryReturn;
+
+        Bindings(CallingSequence callingSequence, boolean isInMemoryReturn) {
+            this.callingSequence = callingSequence;
+            this.isInMemoryReturn = isInMemoryReturn;
+        }
+    }
+
+    public static Bindings getBindings(MethodType mt, FunctionDescriptor cDesc, boolean forUpcall) {
+        SharedUtils.checkFunctionTypes(mt, cDesc, AArch64Linker.ADDRESS_SIZE);
+
+        CallingSequenceBuilder csb = new CallingSequenceBuilder(forUpcall);
+
+        BindingCalculator argCalc = forUpcall ? new BoxBindingCalculator(true) : new UnboxBindingCalculator(true);
+        BindingCalculator retCalc = forUpcall ? new UnboxBindingCalculator(false) : new BoxBindingCalculator(false);
+
+        boolean returnInMemory = isInMemoryReturn(cDesc.returnLayout());
+        if (returnInMemory) {
+            csb.addArgumentBindings(MemoryAddress.class, AArch64.C_POINTER,
+                    argCalc.getIndirectBindings());
+        } else if (cDesc.returnLayout().isPresent()) {
+            Class carrier = mt.returnType();
+            MemoryLayout layout = cDesc.returnLayout().get();
+            csb.setReturnBindings(carrier, layout, retCalc.getBindings(carrier, layout));
+        }
+
+        for (int i = 0; i < mt.parameterCount(); i++) {
+            Class carrier = mt.parameterType(i);
+            MemoryLayout layout = cDesc.argumentLayouts().get(i);
+            csb.addArgumentBindings(carrier, layout, argCalc.getBindings(carrier, layout));
+        }
+
+        csb.setTrivial(SharedUtils.isTrivial(cDesc));
+
+        return new Bindings(csb.build(), returnInMemory);
+    }
+
+    public static MethodHandle arrangeDowncall(Addressable addr, MethodType mt, FunctionDescriptor cDesc) {
+        Bindings bindings = getBindings(mt, cDesc, false);
+
+        MethodHandle handle = new ProgrammableInvoker(C, addr, bindings.callingSequence).getBoundMethodHandle();
+
+        if (bindings.isInMemoryReturn) {
+            handle = SharedUtils.adaptDowncallForIMR(handle, cDesc);
+        }
+
+        return handle;
+    }
+
+    public static UpcallHandler arrangeUpcall(MethodHandle target, MethodType mt, FunctionDescriptor cDesc) {
+        Bindings bindings = getBindings(mt, cDesc, true);
+
+        if (bindings.isInMemoryReturn) {
+            target = SharedUtils.adaptUpcallForIMR(target);
+        }
+
+        return new ProgrammableUpcallHandler(C, target, bindings.callingSequence);
+    }
+
+    private static boolean isInMemoryReturn(Optional returnLayout) {
+        return returnLayout
+            .filter(GroupLayout.class::isInstance)
+            .filter(g -> TypeClass.classifyLayout(g) == TypeClass.STRUCT_REFERENCE)
+            .isPresent();
+    }
+
+    static class StorageCalculator {
+        private final boolean forArguments;
+
+        private final int[] nRegs = new int[] { 0, 0 };
+        private long stackOffset = 0;
+
+        public StorageCalculator(boolean forArguments) {
+            this.forArguments = forArguments;
+        }
+
+        VMStorage stackAlloc(long size, long alignment) {
+            assert forArguments : "no stack returns";
+            alignment = Math.max(alignment, STACK_SLOT_SIZE);
+            stackOffset = Utils.alignUp(stackOffset, alignment);
+
+            VMStorage storage =
+                AArch64Architecture.stackStorage((int)(stackOffset / STACK_SLOT_SIZE));
+            stackOffset += size;
+            return storage;
+        }
+
+        VMStorage stackAlloc(MemoryLayout layout) {
+            return stackAlloc(layout.byteSize(), SharedUtils.alignment(layout, true));
+        }
+
+        VMStorage[] regAlloc(int type, int count) {
+            if (nRegs[type] + count <= MAX_REGISTER_ARGUMENTS) {
+                VMStorage[] source =
+                    (forArguments ? C.inputStorage : C.outputStorage)[type];
+                VMStorage[] result = new VMStorage[count];
+                for (int i = 0; i < count; i++) {
+                    result[i] = source[nRegs[type]++];
+                }
+                return result;
+            } else {
+                // Any further allocations for this register type must
+                // be from the stack.
+                nRegs[type] = MAX_REGISTER_ARGUMENTS;
+                return null;
+            }
+        }
+
+        VMStorage[] regAlloc(int type, MemoryLayout layout) {
+            return regAlloc(type, (int)Utils.alignUp(layout.byteSize(), 8) / 8);
+        }
+
+        VMStorage nextStorage(int type, MemoryLayout layout) {
+            VMStorage[] storage = regAlloc(type, 1);
+            if (storage == null) {
+                return stackAlloc(layout);
+            }
+
+            return storage[0];
+        }
+    }
+
+    static abstract class BindingCalculator {
+        protected final StorageCalculator storageCalculator;
+
+        protected BindingCalculator(boolean forArguments) {
+            this.storageCalculator = new StorageCalculator(forArguments);
+        }
+
+        protected void spillStructUnbox(Binding.Builder bindings, MemoryLayout layout) {
+            // If a struct has been assigned register or HFA class but
+            // there are not enough free registers to hold the entire
+            // struct, it must be passed on the stack. I.e. not split
+            // between registers and stack.
+
+            long offset = 0;
+            while (offset < layout.byteSize()) {
+                long copy = Math.min(layout.byteSize() - offset, STACK_SLOT_SIZE);
+                VMStorage storage =
+                    storageCalculator.stackAlloc(copy, STACK_SLOT_SIZE);
+                if (offset + STACK_SLOT_SIZE < layout.byteSize()) {
+                    bindings.dup();
+                }
+                Class type = SharedUtils.primitiveCarrierForSize(copy);
+                bindings.bufferLoad(offset, type)
+                        .vmStore(storage, type);
+                offset += STACK_SLOT_SIZE;
+            }
+        }
+
+        protected void spillStructBox(Binding.Builder bindings, MemoryLayout layout) {
+            // If a struct has been assigned register or HFA class but
+            // there are not enough free registers to hold the entire
+            // struct, it must be passed on the stack. I.e. not split
+            // between registers and stack.
+
+            long offset = 0;
+            while (offset < layout.byteSize()) {
+                long copy = Math.min(layout.byteSize() - offset, STACK_SLOT_SIZE);
+                VMStorage storage =
+                    storageCalculator.stackAlloc(copy, STACK_SLOT_SIZE);
+                Class type = SharedUtils.primitiveCarrierForSize(copy);
+                bindings.dup()
+                        .vmLoad(storage, type)
+                        .bufferStore(offset, type);
+                offset += STACK_SLOT_SIZE;
+            }
+        }
+
+        abstract List getBindings(Class carrier, MemoryLayout layout);
+
+        abstract List getIndirectBindings();
+    }
+
+    static class UnboxBindingCalculator extends BindingCalculator {
+        UnboxBindingCalculator(boolean forArguments) {
+            super(forArguments);
+        }
+
+        @Override
+        List getIndirectBindings() {
+            return Binding.builder()
+                .unboxAddress()
+                .vmStore(INDIRECT_RESULT, long.class)
+                .build();
+        }
+
+        @Override
+        List getBindings(Class carrier, MemoryLayout layout) {
+            TypeClass argumentClass = TypeClass.classifyLayout(layout);
+            Binding.Builder bindings = Binding.builder();
+            switch (argumentClass) {
+                case STRUCT_REGISTER: {
+                    assert carrier == MemorySegment.class;
+                    VMStorage[] regs = storageCalculator.regAlloc(
+                        StorageClasses.INTEGER, layout);
+                    if (regs != null) {
+                        int regIndex = 0;
+                        long offset = 0;
+                        while (offset < layout.byteSize()) {
+                            final long copy = Math.min(layout.byteSize() - offset, 8);
+                            VMStorage storage = regs[regIndex++];
+                            Class type = SharedUtils.primitiveCarrierForSize(copy);
+                            if (offset + copy < layout.byteSize()) {
+                                bindings.dup();
+                            }
+                            bindings.bufferLoad(offset, type)
+                                    .vmStore(storage, type);
+                            offset += copy;
+                        }
+                    } else {
+                        spillStructUnbox(bindings, layout);
+                    }
+                    break;
+                }
+                case STRUCT_REFERENCE: {
+                    assert carrier == MemorySegment.class;
+                    bindings.copy(layout)
+                            .baseAddress()
+                            .unboxAddress();
+                    VMStorage storage = storageCalculator.nextStorage(
+                        StorageClasses.INTEGER, layout);
+                    bindings.vmStore(storage, long.class);
+                    break;
+                }
+                case STRUCT_HFA: {
+                    assert carrier == MemorySegment.class;
+                    GroupLayout group = (GroupLayout)layout;
+                    VMStorage[] regs = storageCalculator.regAlloc(
+                        StorageClasses.VECTOR, group.memberLayouts().size());
+                    if (regs != null) {
+                        long offset = 0;
+                        for (int i = 0; i < group.memberLayouts().size(); i++) {
+                            VMStorage storage = regs[i];
+                            final long size = group.memberLayouts().get(i).byteSize();
+                            Class type = SharedUtils.primitiveCarrierForSize(size);
+                            if (i + 1 < group.memberLayouts().size()) {
+                                bindings.dup();
+                            }
+                            bindings.bufferLoad(offset, type)
+                                    .vmStore(storage, type);
+                            offset += size;
+                        }
+                    } else {
+                        spillStructUnbox(bindings, layout);
+                    }
+                    break;
+                }
+                case POINTER: {
+                    bindings.unboxAddress();
+                    VMStorage storage =
+                        storageCalculator.nextStorage(StorageClasses.INTEGER, layout);
+                    bindings.vmStore(storage, long.class);
+                    break;
+                }
+                case INTEGER: {
+                    VMStorage storage =
+                        storageCalculator.nextStorage(StorageClasses.INTEGER, layout);
+                    bindings.vmStore(storage, carrier);
+                    break;
+                }
+                case FLOAT: {
+                    VMStorage storage =
+                        storageCalculator.nextStorage(StorageClasses.VECTOR, layout);
+                    bindings.vmStore(storage, carrier);
+                    break;
+                }
+                default:
+                    throw new UnsupportedOperationException("Unhandled class " + argumentClass);
+            }
+            return bindings.build();
+        }
+    }
+
+    static class BoxBindingCalculator extends BindingCalculator{
+        BoxBindingCalculator(boolean forArguments) {
+            super(forArguments);
+        }
+
+        @Override
+        List getIndirectBindings() {
+            return Binding.builder()
+                .vmLoad(INDIRECT_RESULT, long.class)
+                .boxAddress()
+                .build();
+        }
+
+        @Override
+        List getBindings(Class carrier, MemoryLayout layout) {
+            TypeClass argumentClass = TypeClass.classifyLayout(layout);
+            Binding.Builder bindings = Binding.builder();
+            switch (argumentClass) {
+                case STRUCT_REGISTER: {
+                    assert carrier == MemorySegment.class;
+                    bindings.allocate(layout);
+                    VMStorage[] regs = storageCalculator.regAlloc(
+                        StorageClasses.INTEGER, layout);
+                    if (regs != null) {
+                        int regIndex = 0;
+                        long offset = 0;
+                        while (offset < layout.byteSize()) {
+                            final long copy = Math.min(layout.byteSize() - offset, 8);
+                            VMStorage storage = regs[regIndex++];
+                            bindings.dup();
+                            Class type = SharedUtils.primitiveCarrierForSize(copy);
+                            bindings.vmLoad(storage, type)
+                                    .bufferStore(offset, type);
+                            offset += copy;
+                        }
+                    } else {
+                        spillStructBox(bindings, layout);
+                    }
+                    break;
+                }
+                case STRUCT_REFERENCE: {
+                    assert carrier == MemorySegment.class;
+                    VMStorage storage = storageCalculator.nextStorage(StorageClasses.INTEGER, layout);
+                    bindings.vmLoad(storage, long.class)
+                            .boxAddress()
+                            .toSegment(layout);
+                    // ASSERT SCOPE OF BOXED ADDRESS HERE
+                    // caveat. buffer should instead go out of scope after call
+                    bindings.copy(layout);
+                    break;
+                }
+                case STRUCT_HFA: {
+                    assert carrier == MemorySegment.class;
+                    bindings.allocate(layout);
+                    GroupLayout group = (GroupLayout)layout;
+                    VMStorage[] regs = storageCalculator.regAlloc(
+                        StorageClasses.VECTOR, group.memberLayouts().size());
+                    if (regs != null) {
+                        long offset = 0;
+                        for (int i = 0; i < group.memberLayouts().size(); i++) {
+                            VMStorage storage = regs[i];
+                            final long size = group.memberLayouts().get(i).byteSize();
+                            Class type = SharedUtils.primitiveCarrierForSize(size);
+                            bindings.dup()
+                                    .vmLoad(storage, type)
+                                    .bufferStore(offset, type);
+                            offset += size;
+                        }
+                    } else {
+                        spillStructBox(bindings, layout);
+                    }
+                    break;
+                }
+                case POINTER: {
+                    VMStorage storage =
+                        storageCalculator.nextStorage(StorageClasses.INTEGER, layout);
+                    bindings.vmLoad(storage, long.class)
+                            .boxAddress();
+                    break;
+                }
+                case INTEGER: {
+                    VMStorage storage =
+                        storageCalculator.nextStorage(StorageClasses.INTEGER, layout);
+                    bindings.vmLoad(storage, carrier);
+                    break;
+                }
+                case FLOAT: {
+                    VMStorage storage =
+                        storageCalculator.nextStorage(StorageClasses.VECTOR, layout);
+                    bindings.vmLoad(storage, carrier);
+                    break;
+                }
+                default:
+                    throw new UnsupportedOperationException("Unhandled class " + argumentClass);
+            }
+            return bindings.build();
+        }
+    }
+}
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/aarch64/TypeClass.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/aarch64/TypeClass.java
new file mode 100644
index 0000000000000..5d33e282eb1e9
--- /dev/null
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/aarch64/TypeClass.java
@@ -0,0 +1,110 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020, Arm Limited. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package jdk.internal.foreign.abi.aarch64;
+
+import jdk.incubator.foreign.GroupLayout;
+import jdk.incubator.foreign.MemoryLayout;
+import jdk.incubator.foreign.SequenceLayout;
+import jdk.incubator.foreign.ValueLayout;
+import jdk.internal.foreign.PlatformLayouts;
+
+enum TypeClass {
+    STRUCT_REGISTER,
+    STRUCT_REFERENCE,
+    STRUCT_HFA,
+    POINTER,
+    INTEGER,
+    FLOAT;
+
+    private static final int MAX_AGGREGATE_REGS_SIZE = 2;
+
+    private static TypeClass classifyValueType(ValueLayout type) {
+        return switch (PlatformLayouts.getKind(type)) {
+            case CHAR, SHORT, INT, LONG, LONGLONG -> INTEGER;
+            case POINTER -> POINTER;
+            case FLOAT, DOUBLE, LONGDOUBLE -> FLOAT;
+        };
+    }
+
+    static boolean isRegisterAggregate(MemoryLayout type) {
+        return type.bitSize() <= MAX_AGGREGATE_REGS_SIZE * 64;
+    }
+
+    static boolean isHomogeneousFloatAggregate(MemoryLayout type) {
+        if (!(type instanceof GroupLayout))
+            return false;
+
+        GroupLayout groupLayout = (GroupLayout)type;
+
+        final int numElements = groupLayout.memberLayouts().size();
+        if (numElements > 4 || numElements == 0)
+            return false;
+
+        MemoryLayout baseType = groupLayout.memberLayouts().get(0);
+
+        if (!(baseType instanceof ValueLayout))
+            return false;
+
+        TypeClass baseArgClass = classifyValueType((ValueLayout) baseType);
+        if (baseArgClass != FLOAT)
+           return false;
+
+        for (MemoryLayout elem : groupLayout.memberLayouts()) {
+            if (!(elem instanceof ValueLayout))
+                return false;
+
+            TypeClass argClass = classifyValueType((ValueLayout) elem);
+            if (elem.bitSize() != baseType.bitSize() ||
+                    elem.bitAlignment() != baseType.bitAlignment() ||
+                    baseArgClass != argClass) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    private static TypeClass classifyStructType(MemoryLayout layout) {
+        if (isHomogeneousFloatAggregate(layout)) {
+            return TypeClass.STRUCT_HFA;
+        } else if (isRegisterAggregate(layout)) {
+            return TypeClass.STRUCT_REGISTER;
+        }
+        return TypeClass.STRUCT_REFERENCE;
+    }
+
+    public static TypeClass classifyLayout(MemoryLayout type) {
+        if (type instanceof ValueLayout) {
+            return classifyValueType((ValueLayout) type);
+        } else if (type instanceof GroupLayout) {
+            return classifyStructType(type);
+        } else if (type instanceof SequenceLayout) {
+            return TypeClass.INTEGER;
+        } else {
+            throw new IllegalArgumentException("Unhandled type " + type);
+        }
+    }
+}
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/X86_64Architecture.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/X86_64Architecture.java
new file mode 100644
index 0000000000000..eace0ef25ea6a
--- /dev/null
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/X86_64Architecture.java
@@ -0,0 +1,156 @@
+/*
+ * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package jdk.internal.foreign.abi.x64;
+
+import jdk.internal.foreign.abi.ABIDescriptor;
+import jdk.internal.foreign.abi.Architecture;
+import jdk.internal.foreign.abi.VMStorage;
+
+import java.util.stream.IntStream;
+
+public class X86_64Architecture implements Architecture {
+    public static final Architecture INSTANCE = new X86_64Architecture();
+    private static final int INTEGER_REG_SIZE = 8; // bytes
+    private static final int VECTOR_REG_SIZE = 64; // sizeof(VectorRegister)
+    private static final int X87_REG_SIZE = 16;
+    private static final int STACK_SLOT_SIZE = 8;
+
+    @Override
+    public boolean isStackType(int cls) {
+        return cls == StorageClasses.STACK;
+    }
+
+    @Override
+    public int typeSize(int cls) {
+        switch (cls) {
+            case StorageClasses.INTEGER: return INTEGER_REG_SIZE;
+            case StorageClasses.VECTOR: return VECTOR_REG_SIZE;
+            case StorageClasses.X87: return X87_REG_SIZE;
+            case StorageClasses.STACK: return STACK_SLOT_SIZE;
+        }
+
+        throw new IllegalArgumentException("Invalid Storage Class: " +cls);
+    }
+
+    @Override
+    public int stackType() {
+        return StorageClasses.STACK;
+    }
+
+    public interface StorageClasses {
+        int INTEGER = 0;
+        int VECTOR = 1;
+        int X87 = 2;
+        int STACK = 3;
+    }
+
+    public static final VMStorage rax = integerRegister(0, "rax");
+    public static final VMStorage rcx = integerRegister(1, "rcx");
+    public static final VMStorage rdx = integerRegister(2, "rdx");
+    public static final VMStorage rbx = integerRegister(3, "rbx");
+    public static final VMStorage rsp = integerRegister(4, "rsp");
+    public static final VMStorage rbp = integerRegister(5, "rbp");
+    public static final VMStorage rsi = integerRegister(6, "rsi");
+    public static final VMStorage rdi = integerRegister(7, "rdi");
+    public static final VMStorage r8 =  integerRegister(8, "r8");
+    public static final VMStorage r9 =  integerRegister(9, "r9");
+    public static final VMStorage r10 = integerRegister(10, "r10");
+    public static final VMStorage r11 = integerRegister(11, "r11");
+    public static final VMStorage r12 = integerRegister(12, "r12");
+    public static final VMStorage r13 = integerRegister(13, "r13");
+    public static final VMStorage r14 = integerRegister(14, "r14");
+    public static final VMStorage r15 = integerRegister(15, "r15");
+
+    public static final VMStorage xmm0 =  vectorRegister(0, "xmm0");
+    public static final VMStorage xmm1 =  vectorRegister(1, "xmm1");
+    public static final VMStorage xmm2 =  vectorRegister(2, "xmm2");
+    public static final VMStorage xmm3 =  vectorRegister(3, "xmm3");
+    public static final VMStorage xmm4 =  vectorRegister(4, "xmm4");
+    public static final VMStorage xmm5 =  vectorRegister(5, "xmm5");
+    public static final VMStorage xmm6 =  vectorRegister(6, "xmm6");
+    public static final VMStorage xmm7 =  vectorRegister(7, "xmm7");
+    public static final VMStorage xmm8 =  vectorRegister(8, "xmm8");
+    public static final VMStorage xmm9 =  vectorRegister(9, "xmm9");
+    public static final VMStorage xmm10 = vectorRegister(10, "xmm10");
+    public static final VMStorage xmm11 = vectorRegister(11, "xmm11");
+    public static final VMStorage xmm12 = vectorRegister(12, "xmm12");
+    public static final VMStorage xmm13 = vectorRegister(13, "xmm13");
+    public static final VMStorage xmm14 = vectorRegister(14, "xmm14");
+    public static final VMStorage xmm15 = vectorRegister(15, "xmm15");
+    public static final VMStorage xmm16 = vectorRegister(16, "xmm16");
+    public static final VMStorage xmm17 = vectorRegister(17, "xmm17");
+    public static final VMStorage xmm18 = vectorRegister(18, "xmm18");
+    public static final VMStorage xmm19 = vectorRegister(19, "xmm19");
+    public static final VMStorage xmm20 = vectorRegister(20, "xmm20");
+    public static final VMStorage xmm21 = vectorRegister(21, "xmm21");
+    public static final VMStorage xmm22 = vectorRegister(22, "xmm22");
+    public static final VMStorage xmm23 = vectorRegister(23, "xmm23");
+    public static final VMStorage xmm24 = vectorRegister(24, "xmm24");
+    public static final VMStorage xmm25 = vectorRegister(25, "xmm25");
+    public static final VMStorage xmm26 = vectorRegister(26, "xmm26");
+    public static final VMStorage xmm27 = vectorRegister(27, "xmm27");
+    public static final VMStorage xmm28 = vectorRegister(28, "xmm28");
+    public static final VMStorage xmm29 = vectorRegister(29, "xmm29");
+    public static final VMStorage xmm30 = vectorRegister(30, "xmm30");
+    public static final VMStorage xmm31 = vectorRegister(31, "xmm31");
+
+    private static VMStorage integerRegister(int index, String debugName) {
+        return new VMStorage(StorageClasses.INTEGER, index, debugName);
+    }
+
+    private static VMStorage vectorRegister(int index, String debugName) {
+        return new VMStorage(StorageClasses.VECTOR, index, debugName);
+    }
+
+    public static VMStorage stackStorage(int index) {
+        return new VMStorage(StorageClasses.STACK, index, "Stack@" + index);
+    }
+
+    public static VMStorage x87Storage(int index) {
+        return new VMStorage(StorageClasses.X87, index, "X87(" + index + ")");
+    }
+
+    public static ABIDescriptor abiFor(VMStorage[] inputIntRegs, VMStorage[] inputVectorRegs, VMStorage[] outputIntRegs,
+                                       VMStorage[] outputVectorRegs, int numX87Outputs, VMStorage[] volatileIntRegs,
+                                       VMStorage[] volatileVectorRegs, int stackAlignment, int shadowSpace) {
+        return new ABIDescriptor(
+            INSTANCE,
+            new VMStorage[][] {
+                inputIntRegs,
+                inputVectorRegs,
+            },
+            new VMStorage[][] {
+                outputIntRegs,
+                outputVectorRegs,
+                IntStream.range(0, numX87Outputs).mapToObj(X86_64Architecture::x87Storage).toArray(VMStorage[]::new)
+            },
+            new VMStorage[][] {
+                volatileIntRegs,
+                volatileVectorRegs,
+            },
+            stackAlignment,
+            shadowSpace
+        );
+    }
+
+}
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/sysv/ArgumentClassImpl.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/sysv/ArgumentClassImpl.java
new file mode 100644
index 0000000000000..7bd9dc61786f5
--- /dev/null
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/sysv/ArgumentClassImpl.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package jdk.internal.foreign.abi.x64.sysv;
+
+public enum ArgumentClassImpl {
+    POINTER, INTEGER, SSE, SSEUP, X87, X87UP, COMPLEX_X87, NO_CLASS, MEMORY;
+
+    public ArgumentClassImpl merge(ArgumentClassImpl other) {
+        if (this == other) {
+            return this;
+        }
+
+        if (other == NO_CLASS) {
+            return this;
+        }
+        if (this == NO_CLASS) {
+            return other;
+        }
+
+        if (this == MEMORY || other == MEMORY) {
+            return MEMORY;
+        }
+
+        if (this == POINTER || other == POINTER) {
+            return POINTER;
+        }
+
+        if (this == INTEGER || other == INTEGER) {
+            return INTEGER;
+        }
+
+        if (this == X87 || this == X87UP || this == COMPLEX_X87) {
+            return MEMORY;
+        }
+        if (other == X87 || other == X87UP || other == COMPLEX_X87) {
+            return MEMORY;
+        }
+
+        return SSE;
+    }
+
+    public boolean isIntegral() {
+        return this == INTEGER || this == POINTER;
+    }
+
+    public boolean isPointer() {
+        return this == POINTER;
+    }
+
+    public boolean isIndirect() {
+        return this == MEMORY;
+    }
+}
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/sysv/CallArranger.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/sysv/CallArranger.java
new file mode 100644
index 0000000000000..638c12660c552
--- /dev/null
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/sysv/CallArranger.java
@@ -0,0 +1,357 @@
+/*
+ *  Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
+ *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ *  This code is free software; you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License version 2 only, as
+ *  published by the Free Software Foundation.  Oracle designates this
+ *  particular file as subject to the "Classpath" exception as provided
+ *  by Oracle in the LICENSE file that accompanied this code.
+ *
+ *  This code 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
+ *  version 2 for more details (a copy is included in the LICENSE file that
+ *  accompanied this code).
+ *
+ *  You should have received a copy of the GNU General Public License version
+ *  2 along with this work; if not, write to the Free Software Foundation,
+ *  Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ *   Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ *  or visit www.oracle.com if you need additional information or have any
+ *  questions.
+ *
+ */
+package jdk.internal.foreign.abi.x64.sysv;
+
+import jdk.incubator.foreign.Addressable;
+import jdk.incubator.foreign.FunctionDescriptor;
+import jdk.incubator.foreign.GroupLayout;
+import jdk.incubator.foreign.MemoryAddress;
+import jdk.incubator.foreign.MemoryLayout;
+import jdk.incubator.foreign.MemorySegment;
+import jdk.internal.foreign.PlatformLayouts;
+import jdk.internal.foreign.abi.CallingSequenceBuilder;
+import jdk.internal.foreign.abi.UpcallHandler;
+import jdk.internal.foreign.abi.ABIDescriptor;
+import jdk.internal.foreign.abi.Binding;
+import jdk.internal.foreign.abi.CallingSequence;
+import jdk.internal.foreign.abi.ProgrammableInvoker;
+import jdk.internal.foreign.abi.ProgrammableUpcallHandler;
+import jdk.internal.foreign.abi.VMStorage;
+import jdk.internal.foreign.abi.x64.X86_64Architecture;
+import jdk.internal.foreign.abi.SharedUtils;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
+import java.util.List;
+import java.util.Optional;
+
+import static jdk.internal.foreign.PlatformLayouts.*;
+import static jdk.internal.foreign.abi.Binding.*;
+import static jdk.internal.foreign.abi.x64.X86_64Architecture.*;
+import static jdk.internal.foreign.abi.x64.sysv.SysVx64Linker.MAX_INTEGER_ARGUMENT_REGISTERS;
+import static jdk.internal.foreign.abi.x64.sysv.SysVx64Linker.MAX_VECTOR_ARGUMENT_REGISTERS;
+
+/**
+ * For the SysV x64 C ABI specifically, this class uses the ProgrammableInvoker API, namely CallingSequenceBuilder2
+ * to translate a C FunctionDescriptor into a CallingSequence, which can then be turned into a MethodHandle.
+ *
+ * This includes taking care of synthetic arguments like pointers to return buffers for 'in-memory' returns.
+ */
+public class CallArranger {
+    private static final ABIDescriptor CSysV = X86_64Architecture.abiFor(
+        new VMStorage[] { rdi, rsi, rdx, rcx, r8, r9, rax },
+        new VMStorage[] { xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7 },
+        new VMStorage[] { rax, rdx },
+        new VMStorage[] { xmm0, xmm1 },
+        2,
+        new VMStorage[] { r10, r11 },
+        new VMStorage[] { xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15 },
+        16,
+        0 //no shadow space
+    );
+
+    // record
+    public static class Bindings {
+        public final CallingSequence callingSequence;
+        public final boolean isInMemoryReturn;
+        public final int nVectorArgs;
+
+        Bindings(CallingSequence callingSequence, boolean isInMemoryReturn, int nVectorArgs) {
+            this.callingSequence = callingSequence;
+            this.isInMemoryReturn = isInMemoryReturn;
+            this.nVectorArgs = nVectorArgs;
+        }
+    }
+
+    public static Bindings getBindings(MethodType mt, FunctionDescriptor cDesc, boolean forUpcall) {
+        SharedUtils.checkFunctionTypes(mt, cDesc, SysVx64Linker.ADDRESS_SIZE);
+
+        CallingSequenceBuilder csb = new CallingSequenceBuilder(forUpcall);
+
+        BindingCalculator argCalc = forUpcall ? new BoxBindingCalculator(true) : new UnboxBindingCalculator(true);
+        BindingCalculator retCalc = forUpcall ? new UnboxBindingCalculator(false) : new BoxBindingCalculator(false);
+
+        boolean returnInMemory = isInMemoryReturn(cDesc.returnLayout());
+        if (returnInMemory) {
+            Class carrier = MemoryAddress.class;
+            MemoryLayout layout = SysV.C_POINTER;
+            csb.addArgumentBindings(carrier, layout, argCalc.getBindings(carrier, layout));
+        } else if (cDesc.returnLayout().isPresent()) {
+            Class carrier = mt.returnType();
+            MemoryLayout layout = cDesc.returnLayout().get();
+            csb.setReturnBindings(carrier, layout, retCalc.getBindings(carrier, layout));
+        }
+
+        for (int i = 0; i < mt.parameterCount(); i++) {
+            Class carrier = mt.parameterType(i);
+            MemoryLayout layout = cDesc.argumentLayouts().get(i);
+            csb.addArgumentBindings(carrier, layout, argCalc.getBindings(carrier, layout));
+        }
+
+        if (!forUpcall) {
+            //add extra binding for number of used vector registers (used for variadic calls)
+            csb.addArgumentBindings(long.class, SysV.C_LONG,
+                    List.of(vmStore(rax, long.class)));
+        }
+
+        csb.setTrivial(SharedUtils.isTrivial(cDesc));
+
+        return new Bindings(csb.build(), returnInMemory, argCalc.storageCalculator.nVectorReg);
+    }
+
+    public static MethodHandle arrangeDowncall(Addressable addr, MethodType mt, FunctionDescriptor cDesc) {
+        Bindings bindings = getBindings(mt, cDesc, false);
+
+        MethodHandle handle = new ProgrammableInvoker(CSysV, addr, bindings.callingSequence).getBoundMethodHandle();
+        handle = MethodHandles.insertArguments(handle, handle.type().parameterCount() - 1, bindings.nVectorArgs);
+
+        if (bindings.isInMemoryReturn) {
+            handle = SharedUtils.adaptDowncallForIMR(handle, cDesc);
+        }
+
+        return handle;
+    }
+
+    public static UpcallHandler arrangeUpcall(MethodHandle target, MethodType mt, FunctionDescriptor cDesc) {
+        Bindings bindings = getBindings(mt, cDesc, true);
+
+        if (bindings.isInMemoryReturn) {
+            target = SharedUtils.adaptUpcallForIMR(target);
+        }
+
+        return new ProgrammableUpcallHandler(CSysV, target, bindings.callingSequence);
+    }
+
+    private static boolean isInMemoryReturn(Optional returnLayout) {
+        return returnLayout
+                .filter(GroupLayout.class::isInstance)
+                .filter(g -> TypeClass.classifyLayout(g).inMemory())
+                .isPresent();
+    }
+
+    static class StorageCalculator {
+        private final boolean forArguments;
+
+        private int nVectorReg = 0;
+        private int nIntegerReg = 0;
+        private long stackOffset = 0;
+
+        public StorageCalculator(boolean forArguments) {
+            this.forArguments = forArguments;
+        }
+
+        private int maxRegisterArguments(int type) {
+            return type == StorageClasses.INTEGER ?
+                    MAX_INTEGER_ARGUMENT_REGISTERS :
+                    SysVx64Linker.MAX_VECTOR_ARGUMENT_REGISTERS;
+        }
+
+        VMStorage stackAlloc() {
+            assert forArguments : "no stack returns";
+            VMStorage storage = X86_64Architecture.stackStorage((int)stackOffset);
+            stackOffset++;
+            return storage;
+        }
+
+        VMStorage nextStorage(int type) {
+            int registerCount = registerCount(type);
+            if (registerCount < maxRegisterArguments(type)) {
+                VMStorage[] source =
+                    (forArguments ? CSysV.inputStorage : CSysV.outputStorage)[type];
+                incrementRegisterCount(type);
+                return source[registerCount];
+            } else {
+                return stackAlloc();
+            }
+        }
+
+        VMStorage[] structStorages(TypeClass typeClass) {
+            if (typeClass.inMemory()) {
+                return typeClass.classes.stream().map(c -> stackAlloc()).toArray(VMStorage[]::new);
+            }
+            long nIntegerReg = typeClass.nIntegerRegs();
+
+            if (this.nIntegerReg + nIntegerReg > MAX_INTEGER_ARGUMENT_REGISTERS) {
+                //not enough registers - pass on stack
+                return typeClass.classes.stream().map(c -> stackAlloc()).toArray(VMStorage[]::new);
+            }
+
+            long nVectorReg = typeClass.nVectorRegs();
+
+            if (this.nVectorReg + nVectorReg > MAX_VECTOR_ARGUMENT_REGISTERS) {
+                //not enough registers - pass on stack
+                return typeClass.classes.stream().map(c -> stackAlloc()).toArray(VMStorage[]::new);
+            }
+
+            //ok, let's pass pass on registers
+            VMStorage[] storage = new VMStorage[(int)(nIntegerReg + nVectorReg)];
+            for (int i = 0 ; i < typeClass.classes.size() ; i++) {
+                boolean sse = typeClass.classes.get(i) == ArgumentClassImpl.SSE;
+                storage[i] = nextStorage(sse ? StorageClasses.VECTOR : StorageClasses.INTEGER);
+            }
+            return storage;
+        }
+
+        int registerCount(int type) {
+            switch (type) {
+                case StorageClasses.INTEGER:
+                    return nIntegerReg;
+                case StorageClasses.VECTOR:
+                    return nVectorReg;
+                default:
+                    throw new IllegalStateException();
+            }
+        }
+
+        void incrementRegisterCount(int type) {
+            switch (type) {
+                case StorageClasses.INTEGER:
+                    nIntegerReg++;
+                    break;
+                case StorageClasses.VECTOR:
+                    nVectorReg++;
+                    break;
+                default:
+                    throw new IllegalStateException();
+            }
+        }
+    }
+
+    static abstract class BindingCalculator {
+        protected final StorageCalculator storageCalculator;
+
+        protected BindingCalculator(boolean forArguments) {
+            this.storageCalculator = new StorageCalculator(forArguments);
+        }
+
+        abstract List getBindings(Class carrier, MemoryLayout layout);
+    }
+
+    static class UnboxBindingCalculator extends BindingCalculator {
+
+        UnboxBindingCalculator(boolean forArguments) {
+            super(forArguments);
+        }
+
+        @Override
+        List getBindings(Class carrier, MemoryLayout layout) {
+            TypeClass argumentClass = TypeClass.classifyLayout(layout);
+            Binding.Builder bindings = Binding.builder();
+            switch (argumentClass.kind()) {
+                case STRUCT: {
+                    assert carrier == MemorySegment.class;
+                    VMStorage[] regs = storageCalculator.structStorages(argumentClass);
+                    int regIndex = 0;
+                    long offset = 0;
+                    while (offset < layout.byteSize()) {
+                        final long copy = Math.min(layout.byteSize() - offset, 8);
+                        VMStorage storage = regs[regIndex++];
+                        Class type = SharedUtils.primitiveCarrierForSize(copy);
+                        if (offset + copy < layout.byteSize()) {
+                            bindings.dup();
+                        }
+                        bindings.bufferLoad(offset, type)
+                                .vmStore(storage, type);
+                        offset += copy;
+                    }
+                    break;
+                }
+                case POINTER: {
+                    bindings.unboxAddress();
+                    VMStorage storage = storageCalculator.nextStorage(StorageClasses.INTEGER);
+                    bindings.vmStore(storage, long.class);
+                    break;
+                }
+                case INTEGER: {
+                    VMStorage storage = storageCalculator.nextStorage(StorageClasses.INTEGER);
+                    bindings.vmStore(storage, carrier);
+                    break;
+                }
+                case FLOAT: {
+                    VMStorage storage = storageCalculator.nextStorage(StorageClasses.VECTOR);
+                    bindings.vmStore(storage, carrier);
+                    break;
+                }
+                default:
+                    throw new UnsupportedOperationException("Unhandled class " + argumentClass);
+            }
+            return bindings.build();
+        }
+    }
+
+    static class BoxBindingCalculator extends BindingCalculator {
+
+        BoxBindingCalculator(boolean forArguments) {
+            super(forArguments);
+        }
+
+        @Override
+        List getBindings(Class carrier, MemoryLayout layout) {
+            TypeClass argumentClass = TypeClass.classifyLayout(layout);
+            Binding.Builder bindings = Binding.builder();
+            switch (argumentClass.kind()) {
+                case STRUCT: {
+                    assert carrier == MemorySegment.class;
+                    bindings.allocate(layout);
+                    VMStorage[] regs = storageCalculator.structStorages(argumentClass);
+                    int regIndex = 0;
+                    long offset = 0;
+                    while (offset < layout.byteSize()) {
+                        final long copy = Math.min(layout.byteSize() - offset, 8);
+                        VMStorage storage = regs[regIndex++];
+                        bindings.dup();
+                        Class type = SharedUtils.primitiveCarrierForSize(copy);
+                        bindings.vmLoad(storage, type)
+                                .bufferStore(offset, type);
+                        offset += copy;
+                    }
+                    break;
+                }
+                case POINTER: {
+                    VMStorage storage = storageCalculator.nextStorage(StorageClasses.INTEGER);
+                    bindings.vmLoad(storage, long.class)
+                            .boxAddress();
+                    break;
+                }
+                case INTEGER: {
+                    VMStorage storage = storageCalculator.nextStorage(StorageClasses.INTEGER);
+                    bindings.vmLoad(storage, carrier);
+                    break;
+                }
+                case FLOAT: {
+                    VMStorage storage = storageCalculator.nextStorage(StorageClasses.VECTOR);
+                    bindings.vmLoad(storage, carrier);
+                    break;
+                }
+                default:
+                    throw new UnsupportedOperationException("Unhandled class " + argumentClass);
+            }
+            return bindings.build();
+        }
+    }
+
+}
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/sysv/SysVVaList.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/sysv/SysVVaList.java
new file mode 100644
index 0000000000000..4f10483b24338
--- /dev/null
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/sysv/SysVVaList.java
@@ -0,0 +1,482 @@
+/*
+ *  Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ *  This code is free software; you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License version 2 only, as
+ *  published by the Free Software Foundation.  Oracle designates this
+ *  particular file as subject to the "Classpath" exception as provided
+ *  by Oracle in the LICENSE file that accompanied this code.
+ *
+ *  This code 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
+ *  version 2 for more details (a copy is included in the LICENSE file that
+ *  accompanied this code).
+ *
+ *  You should have received a copy of the GNU General Public License version
+ *  2 along with this work; if not, write to the Free Software Foundation,
+ *  Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ *   Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ *  or visit www.oracle.com if you need additional information or have any
+ *  questions.
+ *
+ */
+package jdk.internal.foreign.abi.x64.sysv;
+
+import jdk.incubator.foreign.*;
+import jdk.internal.foreign.NativeMemorySegmentImpl;
+import jdk.internal.foreign.Utils;
+import jdk.internal.foreign.abi.SharedUtils;
+import jdk.internal.misc.Unsafe;
+
+import java.lang.invoke.VarHandle;
+import java.lang.ref.Cleaner;
+import java.nio.ByteOrder;
+import java.util.ArrayList;
+import java.util.List;
+
+import static jdk.internal.foreign.PlatformLayouts.SysV;
+import static jdk.incubator.foreign.CLinker.VaList;
+import static jdk.incubator.foreign.MemoryLayout.PathElement.groupElement;
+import static jdk.internal.foreign.abi.SharedUtils.SimpleVaArg;
+import static jdk.internal.foreign.abi.SharedUtils.checkCompatibleType;
+import static jdk.internal.foreign.abi.SharedUtils.vhPrimitiveOrAddress;
+
+// See https://software.intel.com/sites/default/files/article/402129/mpx-linux64-abi.pdf "3.5.7 Variable Argument Lists"
+public class SysVVaList implements VaList {
+    private static final Unsafe U = Unsafe.getUnsafe();
+
+    static final Class CARRIER = MemoryAddress.class;
+
+//    struct typedef __va_list_tag __va_list_tag {
+//        unsigned int               gp_offset;            /*     0     4 */
+//        unsigned int               fp_offset;            /*     4     4 */
+//        void *                     overflow_arg_area;    /*     8     8 */
+//        void *                     reg_save_area;        /*    16     8 */
+//
+//        /* size: 24, cachelines: 1, members: 4 */
+//        /* last cacheline: 24 bytes */
+//    };
+    static final GroupLayout LAYOUT = MemoryLayout.ofStruct(
+        SysV.C_INT.withName("gp_offset"),
+        SysV.C_INT.withName("fp_offset"),
+        SysV.C_POINTER.withName("overflow_arg_area"),
+        SysV.C_POINTER.withName("reg_save_area")
+    ).withName("__va_list_tag");
+
+    private static final MemoryLayout GP_REG = MemoryLayout.ofValueBits(64, ByteOrder.nativeOrder());
+    private static final MemoryLayout FP_REG = MemoryLayout.ofValueBits(128, ByteOrder.nativeOrder());
+
+    private static final GroupLayout LAYOUT_REG_SAVE_AREA = MemoryLayout.ofStruct(
+        GP_REG.withName("%rdi"),
+        GP_REG.withName("%rsi"),
+        GP_REG.withName("%rdx"),
+        GP_REG.withName("%rcx"),
+        GP_REG.withName("%r8"),
+        GP_REG.withName("%r9"),
+        FP_REG.withName("%xmm0"),
+        FP_REG.withName("%xmm1"),
+        FP_REG.withName("%xmm2"),
+        FP_REG.withName("%xmm3"),
+        FP_REG.withName("%xmm4"),
+        FP_REG.withName("%xmm5"),
+        FP_REG.withName("%xmm6"),
+        FP_REG.withName("%xmm7")
+// specification and implementation differ as to whether the following are part of a reg save area
+// Let's go with the implementation, since then it actually works :)
+//        FP_REG.withName("%xmm8"),
+//        FP_REG.withName("%xmm9"),
+//        FP_REG.withName("%xmm10"),
+//        FP_REG.withName("%xmm11"),
+//        FP_REG.withName("%xmm12"),
+//        FP_REG.withName("%xmm13"),
+//        FP_REG.withName("%xmm14"),
+//        FP_REG.withName("%xmm15")
+    );
+
+    private static final long FP_OFFSET = LAYOUT_REG_SAVE_AREA.byteOffset(groupElement("%xmm0"));
+
+    private static final int GP_SLOT_SIZE = (int) GP_REG.byteSize();
+    private static final int FP_SLOT_SIZE = (int) FP_REG.byteSize();
+
+    private static final int MAX_GP_OFFSET = (int) FP_OFFSET; // 6 regs used
+    private static final int MAX_FP_OFFSET = (int) LAYOUT_REG_SAVE_AREA.byteSize(); // 8 16 byte regs
+
+    private static final VarHandle VH_fp_offset = LAYOUT.varHandle(int.class, groupElement("fp_offset"));
+    private static final VarHandle VH_gp_offset = LAYOUT.varHandle(int.class, groupElement("gp_offset"));
+    private static final VarHandle VH_overflow_arg_area
+        = MemoryHandles.asAddressVarHandle(LAYOUT.varHandle(long.class, groupElement("overflow_arg_area")));
+    private static final VarHandle VH_reg_save_area
+        = MemoryHandles.asAddressVarHandle(LAYOUT.varHandle(long.class, groupElement("reg_save_area")));
+
+    private static final Cleaner cleaner = Cleaner.create();
+    private static final VaList EMPTY = new SharedUtils.EmptyVaList(emptyListAddress());
+
+    private final MemorySegment segment;
+    private final MemorySegment regSaveArea;
+    private final List attachedSegments;
+
+    private SysVVaList(MemorySegment segment, MemorySegment regSaveArea, List attachedSegments) {
+        this.segment = segment;
+        this.regSaveArea = regSaveArea;
+        this.attachedSegments = attachedSegments;
+    }
+
+    private static SysVVaList readFromSegment(MemorySegment segment) {
+        MemorySegment regSaveArea = getRegSaveArea(segment);
+        return new SysVVaList(segment, regSaveArea, List.of(regSaveArea));
+    }
+
+    private static MemoryAddress emptyListAddress() {
+        long ptr = U.allocateMemory(LAYOUT.byteSize());
+        MemorySegment base = MemoryAddress.ofLong(ptr)
+                .asSegmentRestricted(LAYOUT.byteSize(), () -> U.freeMemory(ptr), null)
+                .share();
+        cleaner.register(SysVVaList.class, base::close);
+        VH_gp_offset.set(base, MAX_GP_OFFSET);
+        VH_fp_offset.set(base, MAX_FP_OFFSET);
+        VH_overflow_arg_area.set(base, MemoryAddress.NULL);
+        VH_reg_save_area.set(base, MemoryAddress.NULL);
+        return base.withAccessModes(0).address();
+    }
+
+    public static VaList empty() {
+        return EMPTY;
+    }
+
+    private int currentGPOffset() {
+        return (int) VH_gp_offset.get(segment);
+    }
+
+    private void currentGPOffset(int i) {
+        VH_gp_offset.set(segment, i);
+    }
+
+    private int currentFPOffset() {
+        return (int) VH_fp_offset.get(segment);
+    }
+
+    private void currentFPOffset(int i) {
+        VH_fp_offset.set(segment, i);
+    }
+
+    private MemoryAddress stackPtr() {
+        return (MemoryAddress) VH_overflow_arg_area.get(segment);
+    }
+
+    private void stackPtr(MemoryAddress ptr) {
+        VH_overflow_arg_area.set(segment, ptr);
+    }
+
+    private MemorySegment regSaveArea() {
+        return getRegSaveArea(segment);
+    }
+
+    private static MemorySegment getRegSaveArea(MemorySegment segment) {
+        return handoffIfNeeded(((MemoryAddress)VH_reg_save_area.get(segment))
+                .asSegmentRestricted(LAYOUT_REG_SAVE_AREA.byteSize()), segment.ownerThread());
+    }
+
+    private void preAlignStack(MemoryLayout layout) {
+        if (layout.byteAlignment() > 8) {
+            stackPtr(Utils.alignUp(stackPtr(), 16));
+        }
+    }
+
+    private void postAlignStack(MemoryLayout layout) {
+        stackPtr(Utils.alignUp(stackPtr().addOffset(layout.byteSize()), 8));
+    }
+
+    @Override
+    public int vargAsInt(MemoryLayout layout) {
+        return (int) read(int.class, layout);
+    }
+
+    @Override
+    public long vargAsLong(MemoryLayout layout) {
+        return (long) read(long.class, layout);
+    }
+
+    @Override
+    public double vargAsDouble(MemoryLayout layout) {
+        return (double) read(double.class, layout);
+    }
+
+    @Override
+    public MemoryAddress vargAsAddress(MemoryLayout layout) {
+        return (MemoryAddress) read(MemoryAddress.class, layout);
+    }
+
+    @Override
+    public MemorySegment vargAsSegment(MemoryLayout layout) {
+        return (MemorySegment) read(MemorySegment.class, layout);
+    }
+
+    @Override
+    public MemorySegment vargAsSegment(MemoryLayout layout, NativeScope scope) {
+        return (MemorySegment) read(MemorySegment.class, layout, SharedUtils.Allocator.ofScope(scope));
+    }
+
+    private Object read(Class carrier, MemoryLayout layout) {
+        return read(carrier, layout, MemorySegment::allocateNative);
+    }
+
+    private Object read(Class carrier, MemoryLayout layout, SharedUtils.Allocator allocator) {
+        checkCompatibleType(carrier, layout, SysVx64Linker.ADDRESS_SIZE);
+        TypeClass typeClass = TypeClass.classifyLayout(layout);
+        if (isRegOverflow(currentGPOffset(), currentFPOffset(), typeClass)
+                || typeClass.inMemory()) {
+            preAlignStack(layout);
+            return switch (typeClass.kind()) {
+                case STRUCT -> {
+                    try (MemorySegment slice = handoffIfNeeded(stackPtr()
+                            .asSegmentRestricted(layout.byteSize()), segment.ownerThread())) {
+                        MemorySegment seg = allocator.allocate(layout);
+                        seg.copyFrom(slice);
+                        postAlignStack(layout);
+                        yield seg;
+                    }
+                }
+                case POINTER, INTEGER, FLOAT -> {
+                    VarHandle reader = vhPrimitiveOrAddress(carrier, layout);
+                    try (MemorySegment slice = handoffIfNeeded(stackPtr()
+                            .asSegmentRestricted(layout.byteSize()), segment.ownerThread())) {
+                        Object res = reader.get(slice);
+                        postAlignStack(layout);
+                        yield res;
+                    }
+                }
+            };
+        } else {
+            return switch (typeClass.kind()) {
+                case STRUCT -> {
+                    MemorySegment value = allocator.allocate(layout);
+                    int classIdx = 0;
+                    long offset = 0;
+                    while (offset < layout.byteSize()) {
+                        final long copy = Math.min(layout.byteSize() - offset, 8);
+                        boolean isSSE = typeClass.classes.get(classIdx++) == ArgumentClassImpl.SSE;
+                        MemorySegment slice = value.asSlice(offset, copy);
+                        if (isSSE) {
+                            slice.copyFrom(regSaveArea.asSlice(currentFPOffset(), copy));
+                            currentFPOffset(currentFPOffset() + FP_SLOT_SIZE);
+                        } else {
+                            slice.copyFrom(regSaveArea.asSlice(currentGPOffset(), copy));
+                            currentGPOffset(currentGPOffset() + GP_SLOT_SIZE);
+                        }
+                        offset += copy;
+                    }
+                    yield value;
+                }
+                case POINTER, INTEGER -> {
+                    VarHandle reader = SharedUtils.vhPrimitiveOrAddress(carrier, layout);
+                    Object res = reader.get(regSaveArea.asSlice(currentGPOffset()));
+                    currentGPOffset(currentGPOffset() + GP_SLOT_SIZE);
+                    yield res;
+                }
+                case FLOAT -> {
+                    VarHandle reader = layout.varHandle(carrier);
+                    Object res = reader.get(regSaveArea.asSlice(currentFPOffset()));
+                    currentFPOffset(currentFPOffset() + FP_SLOT_SIZE);
+                    yield res;
+                }
+            };
+        }
+    }
+
+    @Override
+    public void skip(MemoryLayout... layouts) {
+        for (MemoryLayout layout : layouts) {
+            TypeClass typeClass = TypeClass.classifyLayout(layout);
+            if (isRegOverflow(currentGPOffset(), currentFPOffset(), typeClass)) {
+                preAlignStack(layout);
+                postAlignStack(layout);
+            } else {
+                currentGPOffset(currentGPOffset() + (((int) typeClass.nIntegerRegs()) * GP_SLOT_SIZE));
+                currentFPOffset(currentFPOffset() + (((int) typeClass.nVectorRegs()) * FP_SLOT_SIZE));
+            }
+        }
+    }
+
+    static SysVVaList.Builder builder(SharedUtils.Allocator allocator) {
+        return new SysVVaList.Builder(allocator);
+    }
+
+    public static VaList ofAddress(MemoryAddress ma) {
+        return readFromSegment(ma.asSegmentRestricted(LAYOUT.byteSize()));
+    }
+
+    @Override
+    public boolean isAlive() {
+        return segment.isAlive();
+    }
+
+    @Override
+    public void close() {
+        segment.close();
+        attachedSegments.forEach(MemorySegment::close);
+    }
+
+    @Override
+    public VaList copy() {
+        return copy(MemorySegment::allocateNative);
+    }
+
+    @Override
+    public VaList copy(NativeScope scope) {
+        return copy(SharedUtils.Allocator.ofScope(scope));
+    }
+
+    private VaList copy(SharedUtils.Allocator allocator) {
+        MemorySegment copy = allocator.allocate(LAYOUT);
+        copy.copyFrom(segment);
+        return new SysVVaList(copy, regSaveArea, List.of());
+    }
+
+    @Override
+    public MemoryAddress address() {
+        return segment.address();
+    }
+
+    private static boolean isRegOverflow(long currentGPOffset, long currentFPOffset, TypeClass typeClass) {
+        return currentGPOffset > MAX_GP_OFFSET - typeClass.nIntegerRegs() * GP_SLOT_SIZE
+                || currentFPOffset > MAX_FP_OFFSET - typeClass.nVectorRegs() * FP_SLOT_SIZE;
+    }
+
+    @Override
+    public String toString() {
+        return "SysVVaList{"
+               + "gp_offset=" + currentGPOffset()
+               + ", fp_offset=" + currentFPOffset()
+               + ", overflow_arg_area=" + stackPtr()
+               + ", reg_save_area=" + regSaveArea()
+               + '}';
+    }
+
+    static class Builder implements VaList.Builder {
+        private final SharedUtils.Allocator allocator;
+        private final MemorySegment reg_save_area;
+        private long currentGPOffset = 0;
+        private long currentFPOffset = FP_OFFSET;
+        private final List stackArgs = new ArrayList<>();
+
+        public Builder(SharedUtils.Allocator allocator) {
+            this.allocator = allocator;
+            this.reg_save_area = allocator.allocate(LAYOUT_REG_SAVE_AREA);
+        }
+
+        @Override
+        public Builder vargFromInt(ValueLayout layout, int value) {
+            return arg(int.class, layout, value);
+        }
+
+        @Override
+        public Builder vargFromLong(ValueLayout layout, long value) {
+            return arg(long.class, layout, value);
+        }
+
+        @Override
+        public Builder vargFromDouble(ValueLayout layout, double value) {
+            return arg(double.class, layout, value);
+        }
+
+        @Override
+        public Builder vargFromAddress(ValueLayout layout, Addressable value) {
+            return arg(MemoryAddress.class, layout, value.address());
+        }
+
+        @Override
+        public Builder vargFromSegment(GroupLayout layout, MemorySegment value) {
+            return arg(MemorySegment.class, layout, value);
+        }
+
+        private Builder arg(Class carrier, MemoryLayout layout, Object value) {
+            checkCompatibleType(carrier, layout, SysVx64Linker.ADDRESS_SIZE);
+            TypeClass typeClass = TypeClass.classifyLayout(layout);
+            if (isRegOverflow(currentGPOffset, currentFPOffset, typeClass)
+                    || typeClass.inMemory()) {
+                // stack it!
+                stackArgs.add(new SimpleVaArg(carrier, layout, value));
+            } else {
+                switch (typeClass.kind()) {
+                    case STRUCT -> {
+                        MemorySegment valueSegment = (MemorySegment) value;
+                        int classIdx = 0;
+                        long offset = 0;
+                        while (offset < layout.byteSize()) {
+                            final long copy = Math.min(layout.byteSize() - offset, 8);
+                            boolean isSSE = typeClass.classes.get(classIdx++) == ArgumentClassImpl.SSE;
+                            MemorySegment slice = valueSegment.asSlice(offset, copy);
+                            if (isSSE) {
+                                reg_save_area.asSlice(currentFPOffset, copy).copyFrom(slice);
+                                currentFPOffset += FP_SLOT_SIZE;
+                            } else {
+                                reg_save_area.asSlice(currentGPOffset, copy).copyFrom(slice);
+                                currentGPOffset += GP_SLOT_SIZE;
+                            }
+                            offset += copy;
+                        }
+                    }
+                    case POINTER, INTEGER -> {
+                        VarHandle writer = SharedUtils.vhPrimitiveOrAddress(carrier, layout);
+                        writer.set(reg_save_area.asSlice(currentGPOffset), value);
+                        currentGPOffset += GP_SLOT_SIZE;
+                    }
+                    case FLOAT -> {
+                        VarHandle writer = layout.varHandle(carrier);
+                        writer.set(reg_save_area.asSlice(currentFPOffset), value);
+                        currentFPOffset += FP_SLOT_SIZE;
+                    }
+                }
+            }
+            return this;
+        }
+
+        private boolean isEmpty() {
+            return currentGPOffset == 0 && currentFPOffset == FP_OFFSET && stackArgs.isEmpty();
+        }
+
+        public VaList build() {
+            if (isEmpty()) {
+                return EMPTY;
+            }
+
+            MemorySegment vaListSegment = allocator.allocate(LAYOUT);
+            List attachedSegments = new ArrayList<>();
+            MemoryAddress stackArgsPtr = MemoryAddress.NULL;
+            if (!stackArgs.isEmpty()) {
+                long stackArgsSize = stackArgs.stream().reduce(0L, (acc, e) -> acc + e.layout.byteSize(), Long::sum);
+                MemorySegment stackArgsSegment = allocator.allocate(stackArgsSize, 16);
+                MemorySegment maOverflowArgArea = stackArgsSegment;
+                for (SimpleVaArg arg : stackArgs) {
+                    if (arg.layout.byteSize() > 8) {
+                        maOverflowArgArea = Utils.alignUp(maOverflowArgArea, Math.min(16, arg.layout.byteSize()));
+                    }
+                    if (arg.value instanceof MemorySegment) {
+                        maOverflowArgArea.copyFrom((MemorySegment) arg.value);
+                    } else {
+                        VarHandle writer = arg.varHandle();
+                        writer.set(maOverflowArgArea, arg.value);
+                    }
+                    maOverflowArgArea = maOverflowArgArea.asSlice(arg.layout.byteSize());
+                }
+                stackArgsPtr = stackArgsSegment.address();
+                attachedSegments.add(stackArgsSegment);
+            }
+
+            VH_fp_offset.set(vaListSegment, (int) FP_OFFSET);
+            VH_overflow_arg_area.set(vaListSegment, stackArgsPtr);
+            VH_reg_save_area.set(vaListSegment, reg_save_area.address());
+            attachedSegments.add(reg_save_area);
+            assert reg_save_area.ownerThread() == vaListSegment.ownerThread();
+            return new SysVVaList(vaListSegment, reg_save_area, attachedSegments);
+        }
+    }
+
+    private static MemorySegment handoffIfNeeded(MemorySegment segment, Thread thread) {
+        return segment.ownerThread() == thread ?
+            segment : segment.handoff(thread);
+    }
+}
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/sysv/SysVx64Linker.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/sysv/SysVx64Linker.java
new file mode 100644
index 0000000000000..58f20b7d20053
--- /dev/null
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/sysv/SysVx64Linker.java
@@ -0,0 +1,107 @@
+/*
+ * Copyright (c) 2016, 2020, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package jdk.internal.foreign.abi.x64.sysv;
+
+import jdk.incubator.foreign.Addressable;
+import jdk.incubator.foreign.FunctionDescriptor;
+import jdk.incubator.foreign.MemoryAddress;
+import jdk.incubator.foreign.MemoryLayout;
+import jdk.incubator.foreign.MemorySegment;
+import jdk.incubator.foreign.CLinker;
+import jdk.internal.foreign.abi.SharedUtils;
+import jdk.internal.foreign.abi.UpcallStubs;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
+import java.util.Optional;
+import java.util.function.Consumer;
+
+import static jdk.internal.foreign.PlatformLayouts.*;
+
+/**
+ * ABI implementation based on System V ABI AMD64 supplement v.0.99.6
+ */
+public class SysVx64Linker implements CLinker {
+    public static final int MAX_INTEGER_ARGUMENT_REGISTERS = 6;
+    public static final int MAX_INTEGER_RETURN_REGISTERS = 2;
+    public static final int MAX_VECTOR_ARGUMENT_REGISTERS = 8;
+    public static final int MAX_VECTOR_RETURN_REGISTERS = 2;
+    public static final int MAX_X87_RETURN_REGISTERS = 2;
+
+    private static SysVx64Linker instance;
+
+    static final long ADDRESS_SIZE = 64; // bits
+
+    private static final MethodHandle MH_unboxVaList;
+    private static final MethodHandle MH_boxVaList;
+
+    static {
+        try {
+            MethodHandles.Lookup lookup = MethodHandles.lookup();
+            MH_unboxVaList = lookup.findVirtual(VaList.class, "address",
+                MethodType.methodType(MemoryAddress.class));
+            MH_boxVaList = lookup.findStatic(SysVx64Linker.class, "newVaListOfAddress",
+                MethodType.methodType(VaList.class, MemoryAddress.class));
+        } catch (ReflectiveOperationException e) {
+            throw new ExceptionInInitializerError(e);
+        }
+    }
+
+    public static SysVx64Linker getInstance() {
+        if (instance == null) {
+            instance = new SysVx64Linker();
+        }
+        return instance;
+    }
+
+    public static VaList newVaList(Consumer actions, SharedUtils.Allocator allocator) {
+        SysVVaList.Builder builder = SysVVaList.builder(allocator);
+        actions.accept(builder);
+        return builder.build();
+    }
+
+    @Override
+    public MethodHandle downcallHandle(Addressable symbol, MethodType type, FunctionDescriptor function) {
+        MethodType llMt = SharedUtils.convertVaListCarriers(type, SysVVaList.CARRIER);
+        MethodHandle handle = CallArranger.arrangeDowncall(symbol, llMt, function);
+        handle = SharedUtils.unboxVaLists(type, handle, MH_unboxVaList);
+        return handle;
+    }
+
+    @Override
+    public MemorySegment upcallStub(MethodHandle target, FunctionDescriptor function) {
+        target = SharedUtils.boxVaLists(target, MH_boxVaList);
+        return UpcallStubs.upcallAddress(CallArranger.arrangeUpcall(target, target.type(), function));
+    }
+
+    public static VaList newVaListOfAddress(MemoryAddress ma) {
+        return SysVVaList.ofAddress(ma);
+    }
+
+    public static VaList emptyVaList() {
+        return SysVVaList.empty();
+    }
+}
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/sysv/TypeClass.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/sysv/TypeClass.java
new file mode 100644
index 0000000000000..59d737bd2234e
--- /dev/null
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/sysv/TypeClass.java
@@ -0,0 +1,231 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package jdk.internal.foreign.abi.x64.sysv;
+
+import jdk.incubator.foreign.GroupLayout;
+import jdk.incubator.foreign.MemoryLayout;
+import jdk.incubator.foreign.SequenceLayout;
+import jdk.incubator.foreign.ValueLayout;
+import jdk.internal.foreign.PlatformLayouts;
+import jdk.internal.foreign.Utils;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+class TypeClass {
+    enum Kind {
+        STRUCT,
+        POINTER,
+        INTEGER,
+        FLOAT
+    }
+
+    private final Kind kind;
+    final List classes;
+
+    private TypeClass(Kind kind, List classes) {
+        this.kind = kind;
+        this.classes = classes;
+    }
+
+    public static TypeClass ofValue(ValueLayout layout) {
+        final Kind kind;
+        ArgumentClassImpl argClass = argumentClassFor(layout);
+        kind = switch (argClass) {
+            case POINTER -> Kind.POINTER;
+            case INTEGER -> Kind.INTEGER;
+            case SSE -> Kind.FLOAT;
+            default -> throw new IllegalStateException("Unexpected argument class: " + argClass);
+        };
+        return new TypeClass(kind, List.of(argClass));
+    }
+
+    public static TypeClass ofStruct(GroupLayout layout) {
+        return new TypeClass(Kind.STRUCT, classifyStructType(layout));
+    }
+
+    boolean inMemory() {
+        return classes.stream().anyMatch(c -> c == ArgumentClassImpl.MEMORY);
+    }
+
+    private long numClasses(ArgumentClassImpl clazz) {
+        return classes.stream().filter(c -> c == clazz).count();
+    }
+
+    public long nIntegerRegs() {
+        return numClasses(ArgumentClassImpl.INTEGER) + numClasses(ArgumentClassImpl.POINTER);
+    }
+
+    public long nVectorRegs() {
+        return numClasses(ArgumentClassImpl.SSE);
+    }
+
+    public Kind kind() {
+        return kind;
+    }
+
+    // layout classification
+
+    // The AVX 512 enlightened ABI says "eight eightbytes"
+    // Although AMD64 0.99.6 states 4 eightbytes
+    private static final int MAX_AGGREGATE_REGS_SIZE = 8;
+    static final List COMPLEX_X87_CLASSES = List.of(
+         ArgumentClassImpl.X87,
+         ArgumentClassImpl.X87UP,
+         ArgumentClassImpl.X87,
+         ArgumentClassImpl.X87UP
+    );
+
+    private static List createMemoryClassArray(long size) {
+        return IntStream.range(0, (int)size)
+                .mapToObj(i -> ArgumentClassImpl.MEMORY)
+                .collect(Collectors.toCollection(ArrayList::new));
+    }
+
+    private static ArgumentClassImpl argumentClassFor(MemoryLayout layout) {
+        return switch (PlatformLayouts.getKind(layout)) {
+            case CHAR, SHORT, INT, LONG, LONGLONG -> ArgumentClassImpl.INTEGER;
+            case FLOAT, DOUBLE -> ArgumentClassImpl.SSE;
+            case LONGDOUBLE -> ArgumentClassImpl.X87;
+            case POINTER -> ArgumentClassImpl.POINTER;
+        };
+    }
+
+    // TODO: handle zero length arrays
+    private static List classifyStructType(GroupLayout type) {
+        List[] eightbytes = groupByEightBytes(type);
+        long nWords = eightbytes.length;
+        if (nWords > MAX_AGGREGATE_REGS_SIZE) {
+            return createMemoryClassArray(nWords);
+        }
+
+        ArrayList classes = new ArrayList<>();
+
+        for (int idx = 0; idx < nWords; idx++) {
+            List subclasses = eightbytes[idx];
+            ArgumentClassImpl result = subclasses.stream()
+                    .reduce(ArgumentClassImpl.NO_CLASS, ArgumentClassImpl::merge);
+            classes.add(result);
+        }
+
+        for (int i = 0; i < classes.size(); i++) {
+            ArgumentClassImpl c = classes.get(i);
+
+            if (c == ArgumentClassImpl.MEMORY) {
+                // if any of the eightbytes was passed in memory, pass the whole thing in memory
+                return createMemoryClassArray(classes.size());
+            }
+
+            if (c == ArgumentClassImpl.X87UP) {
+                if (i == 0) {
+                    throw new IllegalArgumentException("Unexpected leading X87UP class");
+                }
+
+                if (classes.get(i - 1) != ArgumentClassImpl.X87) {
+                    return createMemoryClassArray(classes.size());
+                }
+            }
+        }
+
+        if (classes.size() > 2) {
+            if (classes.get(0) != ArgumentClassImpl.SSE) {
+                return createMemoryClassArray(classes.size());
+            }
+
+            for (int i = 1; i < classes.size(); i++) {
+                if (classes.get(i) != ArgumentClassImpl.SSEUP) {
+                    return createMemoryClassArray(classes.size());
+                }
+            }
+        }
+
+        return classes;
+    }
+
+    static TypeClass classifyLayout(MemoryLayout type) {
+        try {
+            if (type instanceof ValueLayout) {
+                return ofValue((ValueLayout)type);
+            } else if (type instanceof GroupLayout) {
+                return ofStruct((GroupLayout)type);
+            } else {
+                throw new IllegalArgumentException("Unhandled type " + type);
+            }
+        } catch (UnsupportedOperationException e) {
+            System.err.println("Failed to classify layout: " + type);
+            throw e;
+        }
+    }
+
+    private static List[] groupByEightBytes(GroupLayout group) {
+        long offset = 0L;
+        int nEightbytes = (int) Utils.alignUp(group.byteSize(), 8) / 8;
+        @SuppressWarnings({"unchecked", "rawtypes"})
+        List[] groups = new List[nEightbytes];
+        for (MemoryLayout l : group.memberLayouts()) {
+            groupByEightBytes(l, offset, groups);
+            if (group.isStruct()) {
+                offset += l.byteSize();
+            }
+        }
+        return groups;
+    }
+
+    private static void groupByEightBytes(MemoryLayout l, long offset, List[] groups) {
+        if (l instanceof GroupLayout) {
+            GroupLayout group = (GroupLayout)l;
+            for (MemoryLayout m : group.memberLayouts()) {
+                groupByEightBytes(m, offset, groups);
+                if (group.isStruct()) {
+                    offset += m.byteSize();
+                }
+            }
+        } else if (l.isPadding()) {
+            return;
+        } else if (l instanceof SequenceLayout) {
+            SequenceLayout seq = (SequenceLayout)l;
+            MemoryLayout elem = seq.elementLayout();
+            for (long i = 0 ; i < seq.elementCount().getAsLong() ; i++) {
+                groupByEightBytes(elem, offset, groups);
+                offset += elem.byteSize();
+            }
+        } else if (l instanceof ValueLayout) {
+            List layouts = groups[(int)offset / 8];
+            if (layouts == null) {
+                layouts = new ArrayList<>();
+                groups[(int)offset / 8] = layouts;
+            }
+            // if the aggregate contains unaligned fields, it has class MEMORY
+            ArgumentClassImpl argumentClass = (offset % l.byteAlignment()) == 0 ?
+                    argumentClassFor(l) :
+                    ArgumentClassImpl.MEMORY;
+            layouts.add(argumentClass);
+        } else {
+            throw new IllegalStateException("Unexpected layout: " + l);
+        }
+    }
+}
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/windows/CallArranger.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/windows/CallArranger.java
new file mode 100644
index 0000000000000..256c835b2de77
--- /dev/null
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/windows/CallArranger.java
@@ -0,0 +1,309 @@
+/*
+ * Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package jdk.internal.foreign.abi.x64.windows;
+
+import jdk.incubator.foreign.Addressable;
+import jdk.incubator.foreign.FunctionDescriptor;
+import jdk.incubator.foreign.GroupLayout;
+import jdk.incubator.foreign.MemoryAddress;
+import jdk.incubator.foreign.MemoryLayout;
+import jdk.incubator.foreign.MemorySegment;
+import jdk.internal.foreign.PlatformLayouts;
+import jdk.internal.foreign.Utils;
+import jdk.internal.foreign.abi.CallingSequenceBuilder;
+import jdk.internal.foreign.abi.UpcallHandler;
+import jdk.internal.foreign.abi.ABIDescriptor;
+import jdk.internal.foreign.abi.Binding;
+import jdk.internal.foreign.abi.CallingSequence;
+import jdk.internal.foreign.abi.ProgrammableInvoker;
+import jdk.internal.foreign.abi.ProgrammableUpcallHandler;
+import jdk.internal.foreign.abi.VMStorage;
+import jdk.internal.foreign.abi.x64.X86_64Architecture;
+import jdk.internal.foreign.abi.SharedUtils;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodType;
+import java.util.List;
+import java.util.Optional;
+
+import static jdk.internal.foreign.PlatformLayouts.*;
+import static jdk.internal.foreign.abi.x64.X86_64Architecture.*;
+
+/**
+ * For the Windowx x64 C ABI specifically, this class uses the ProgrammableInvoker API, namely CallingSequenceBuilder2
+ * to translate a C FunctionDescriptor into a CallingSequence2, which can then be turned into a MethodHandle.
+ *
+ * This includes taking care of synthetic arguments like pointers to return buffers for 'in-memory' returns.
+ */
+public class CallArranger {
+    private static final int STACK_SLOT_SIZE = 8;
+
+    private static final ABIDescriptor CWindows = X86_64Architecture.abiFor(
+        new VMStorage[] { rcx, rdx, r8, r9 },
+        new VMStorage[] { xmm0, xmm1, xmm2, xmm3 },
+        new VMStorage[] { rax },
+        new VMStorage[] { xmm0 },
+        0,
+        new VMStorage[] { rax, r10, r11 },
+        new VMStorage[] { xmm4, xmm5 },
+        16,
+        32
+    );
+
+    // record
+    public static class Bindings {
+        public final CallingSequence callingSequence;
+        public final boolean isInMemoryReturn;
+
+        Bindings(CallingSequence callingSequence, boolean isInMemoryReturn) {
+            this.callingSequence = callingSequence;
+            this.isInMemoryReturn = isInMemoryReturn;
+        }
+    }
+
+    public static Bindings getBindings(MethodType mt, FunctionDescriptor cDesc, boolean forUpcall) {
+        SharedUtils.checkFunctionTypes(mt, cDesc, Windowsx64Linker.ADDRESS_SIZE);
+
+        class CallingSequenceBuilderHelper {
+            final CallingSequenceBuilder csb = new CallingSequenceBuilder(forUpcall);
+            final BindingCalculator argCalc =
+                forUpcall ? new BoxBindingCalculator(true) : new UnboxBindingCalculator(true);
+            final BindingCalculator retCalc =
+                forUpcall ? new UnboxBindingCalculator(false) : new BoxBindingCalculator(false);
+
+            void addArgumentBindings(Class carrier, MemoryLayout layout) {
+                csb.addArgumentBindings(carrier, layout, argCalc.getBindings(carrier, layout));
+            }
+
+            void setReturnBindings(Class carrier, MemoryLayout layout) {
+                csb.setReturnBindings(carrier, layout, retCalc.getBindings(carrier, layout));
+            }
+        }
+        var csb = new CallingSequenceBuilderHelper();
+
+        boolean returnInMemory = isInMemoryReturn(cDesc.returnLayout());
+        if (returnInMemory) {
+            Class carrier = MemoryAddress.class;
+            MemoryLayout layout = Win64.C_POINTER;
+            csb.addArgumentBindings(carrier, layout);
+            if (forUpcall) {
+                csb.setReturnBindings(carrier, layout);
+            }
+        } else if (cDesc.returnLayout().isPresent()) {
+            csb.setReturnBindings(mt.returnType(), cDesc.returnLayout().get());
+        }
+
+        for (int i = 0; i < mt.parameterCount(); i++) {
+            csb.addArgumentBindings(mt.parameterType(i), cDesc.argumentLayouts().get(i));
+        }
+
+        csb.csb.setTrivial(SharedUtils.isTrivial(cDesc));
+
+        return new Bindings(csb.csb.build(), returnInMemory);
+    }
+
+    public static MethodHandle arrangeDowncall(Addressable addr, MethodType mt, FunctionDescriptor cDesc) {
+        Bindings bindings = getBindings(mt, cDesc, false);
+
+        MethodHandle handle = new ProgrammableInvoker(CWindows, addr, bindings.callingSequence).getBoundMethodHandle();
+
+        if (bindings.isInMemoryReturn) {
+            handle = SharedUtils.adaptDowncallForIMR(handle, cDesc);
+        }
+
+        return handle;
+    }
+
+    public static UpcallHandler arrangeUpcall(MethodHandle target, MethodType mt, FunctionDescriptor cDesc) {
+        Bindings bindings = getBindings(mt, cDesc, true);
+
+        if (bindings.isInMemoryReturn) {
+            target = SharedUtils.adaptUpcallForIMR(target);
+        }
+
+        return new ProgrammableUpcallHandler(CWindows, target, bindings.callingSequence);
+    }
+
+    private static boolean isInMemoryReturn(Optional returnLayout) {
+        return returnLayout
+                .filter(GroupLayout.class::isInstance)
+                .filter(g -> !TypeClass.isRegisterAggregate(g))
+                .isPresent();
+    }
+
+    static class StorageCalculator {
+        private final boolean forArguments;
+
+        private int nRegs = 0;
+        private long stackOffset = 0;
+
+        public StorageCalculator(boolean forArguments) {
+            this.forArguments = forArguments;
+        }
+
+        VMStorage nextStorage(int type, MemoryLayout layout) {
+            if (nRegs >= Windowsx64Linker.MAX_REGISTER_ARGUMENTS) {
+                assert forArguments : "no stack returns";
+                // stack
+                long alignment = Math.max(SharedUtils.alignment(layout, true), STACK_SLOT_SIZE);
+                stackOffset = Utils.alignUp(stackOffset, alignment);
+
+                VMStorage storage = X86_64Architecture.stackStorage((int) (stackOffset / STACK_SLOT_SIZE));
+                stackOffset += STACK_SLOT_SIZE;
+                return storage;
+            }
+            return (forArguments
+                    ? CWindows.inputStorage
+                    : CWindows.outputStorage)
+                 [type][nRegs++];
+        }
+
+        public VMStorage extraVarargsStorage() {
+            assert forArguments;
+            return CWindows.inputStorage[StorageClasses.INTEGER][nRegs - 1];
+        }
+    }
+
+    private interface BindingCalculator {
+        List getBindings(Class carrier, MemoryLayout layout);
+    }
+
+    static class UnboxBindingCalculator implements BindingCalculator {
+        private final StorageCalculator storageCalculator;
+
+        UnboxBindingCalculator(boolean forArguments) {
+            this.storageCalculator = new StorageCalculator(forArguments);
+        }
+
+        @Override
+        public List getBindings(Class carrier, MemoryLayout layout) {
+            TypeClass argumentClass = TypeClass.typeClassFor(layout);
+            Binding.Builder bindings = Binding.builder();
+            switch (argumentClass) {
+                case STRUCT_REGISTER: {
+                    assert carrier == MemorySegment.class;
+                    VMStorage storage = storageCalculator.nextStorage(StorageClasses.INTEGER, layout);
+                    Class type = SharedUtils.primitiveCarrierForSize(layout.byteSize());
+                    bindings.bufferLoad(0, type)
+                            .vmStore(storage, type);
+                    break;
+                }
+                case STRUCT_REFERENCE: {
+                    assert carrier == MemorySegment.class;
+                    bindings.copy(layout)
+                            .baseAddress()
+                            .unboxAddress();
+                    VMStorage storage = storageCalculator.nextStorage(StorageClasses.INTEGER, layout);
+                    bindings.vmStore(storage, long.class);
+                    break;
+                }
+                case POINTER: {
+                    bindings.unboxAddress();
+                    VMStorage storage = storageCalculator.nextStorage(StorageClasses.INTEGER, layout);
+                    bindings.vmStore(storage, long.class);
+                    break;
+                }
+                case INTEGER: {
+                    VMStorage storage = storageCalculator.nextStorage(StorageClasses.INTEGER, layout);
+                    bindings.vmStore(storage, carrier);
+                    break;
+                }
+                case FLOAT: {
+                    VMStorage storage = storageCalculator.nextStorage(StorageClasses.VECTOR, layout);
+                    bindings.vmStore(storage, carrier);
+                    break;
+                }
+                case VARARG_FLOAT: {
+                    VMStorage storage = storageCalculator.nextStorage(StorageClasses.VECTOR, layout);
+                    if (!INSTANCE.isStackType(storage.type())) { // need extra for register arg
+                        VMStorage extraStorage = storageCalculator.extraVarargsStorage();
+                        bindings.dup()
+                                .vmStore(extraStorage, carrier);
+                    }
+
+                    bindings.vmStore(storage, carrier);
+                    break;
+                }
+                default:
+                    throw new UnsupportedOperationException("Unhandled class " + argumentClass);
+            }
+            return bindings.build();
+        }
+    }
+
+    static class BoxBindingCalculator implements BindingCalculator {
+        private final StorageCalculator storageCalculator;
+
+        BoxBindingCalculator(boolean forArguments) {
+            this.storageCalculator = new StorageCalculator(forArguments);
+        }
+
+        @Override
+        public List getBindings(Class carrier, MemoryLayout layout) {
+            TypeClass argumentClass = TypeClass.typeClassFor(layout);
+            Binding.Builder bindings = Binding.builder();
+            switch (argumentClass) {
+                case STRUCT_REGISTER: {
+                    assert carrier == MemorySegment.class;
+                    bindings.allocate(layout)
+                            .dup();
+                    VMStorage storage = storageCalculator.nextStorage(StorageClasses.INTEGER, layout);
+                    Class type = SharedUtils.primitiveCarrierForSize(layout.byteSize());
+                    bindings.vmLoad(storage, type)
+                            .bufferStore(0, type);
+                    break;
+                }
+                case STRUCT_REFERENCE: {
+                    assert carrier == MemorySegment.class;
+                    VMStorage storage = storageCalculator.nextStorage(StorageClasses.INTEGER, layout);
+                    bindings.vmLoad(storage, long.class)
+                            .boxAddress()
+                            .toSegment(layout);
+                    // ASSERT SCOPE OF BOXED ADDRESS HERE
+                    // caveat. buffer should instead go out of scope after call
+                    bindings.copy(layout);
+                    break;
+                }
+                case POINTER: {
+                    VMStorage storage = storageCalculator.nextStorage(StorageClasses.INTEGER, layout);
+                    bindings.vmLoad(storage, long.class)
+                            .boxAddress();
+                    break;
+                }
+                case INTEGER: {
+                    VMStorage storage = storageCalculator.nextStorage(StorageClasses.INTEGER, layout);
+                    bindings.vmLoad(storage, carrier);
+                    break;
+                }
+                case FLOAT: {
+                    VMStorage storage = storageCalculator.nextStorage(StorageClasses.VECTOR, layout);
+                    bindings.vmLoad(storage, carrier);
+                    break;
+                }
+                default:
+                    throw new UnsupportedOperationException("Unhandled class " + argumentClass);
+            }
+            return bindings.build();
+        }
+    }
+}
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/windows/TypeClass.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/windows/TypeClass.java
new file mode 100644
index 0000000000000..d1b78f44f28e6
--- /dev/null
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/windows/TypeClass.java
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package jdk.internal.foreign.abi.x64.windows;
+
+import jdk.incubator.foreign.GroupLayout;
+import jdk.incubator.foreign.MemoryLayout;
+import jdk.incubator.foreign.ValueLayout;
+import jdk.internal.foreign.PlatformLayouts;
+
+import static jdk.internal.foreign.PlatformLayouts.Win64.VARARGS_ATTRIBUTE_NAME;
+
+enum TypeClass {
+    STRUCT_REGISTER,
+    STRUCT_REFERENCE,
+    POINTER,
+    INTEGER,
+    FLOAT,
+    VARARG_FLOAT;
+
+    private static TypeClass classifyValueType(ValueLayout type) {
+        // No 128 bit integers in the Windows C ABI. There are __m128(i|d) intrinsic types but they act just
+        // like a struct when passing as an argument (passed by pointer).
+        // https://docs.microsoft.com/en-us/cpp/cpp/m128?view=vs-2019
+
+        // x87 is ignored on Windows:
+        // "The x87 register stack is unused, and may be used by the callee,
+        // but must be considered volatile across function calls."
+        // https://docs.microsoft.com/en-us/cpp/build/x64-calling-convention?view=vs-2019
+
+        return switch (PlatformLayouts.getKind(type)) {
+            case CHAR, SHORT, INT, LONG, LONGLONG -> INTEGER;
+            case POINTER -> POINTER;
+            case FLOAT, DOUBLE, LONGDOUBLE -> {
+                 if (type.attribute(VARARGS_ATTRIBUTE_NAME)
+                        .map(Boolean.class::cast).orElse(false)) {
+                    yield VARARG_FLOAT;
+                }
+                yield FLOAT;
+            }
+        };
+    }
+
+    static boolean isRegisterAggregate(MemoryLayout type) {
+        long size = type.byteSize();
+        return size == 1
+            || size == 2
+            || size == 4
+            || size == 8;
+    }
+
+    private static TypeClass classifyStructType(MemoryLayout layout) {
+        if (isRegisterAggregate(layout)) {
+            return STRUCT_REGISTER;
+        }
+        return STRUCT_REFERENCE;
+    }
+
+    static TypeClass typeClassFor(MemoryLayout type) {
+        if (type instanceof ValueLayout) {
+            return classifyValueType((ValueLayout) type);
+        } else if (type instanceof GroupLayout) {
+            return classifyStructType(type);
+        } else {
+            throw new IllegalArgumentException("Unhandled type " + type);
+        }
+    }
+}
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/windows/WinVaList.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/windows/WinVaList.java
new file mode 100644
index 0000000000000..9e63c2eae8de7
--- /dev/null
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/windows/WinVaList.java
@@ -0,0 +1,269 @@
+/*
+ *  Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ *  This code is free software; you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License version 2 only, as
+ *  published by the Free Software Foundation.  Oracle designates this
+ *  particular file as subject to the "Classpath" exception as provided
+ *  by Oracle in the LICENSE file that accompanied this code.
+ *
+ *  This code 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
+ *  version 2 for more details (a copy is included in the LICENSE file that
+ *  accompanied this code).
+ *
+ *  You should have received a copy of the GNU General Public License version
+ *  2 along with this work; if not, write to the Free Software Foundation,
+ *  Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ *   Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ *  or visit www.oracle.com if you need additional information or have any
+ *  questions.
+ *
+ */
+package jdk.internal.foreign.abi.x64.windows;
+
+import jdk.incubator.foreign.*;
+import jdk.incubator.foreign.CLinker.VaList;
+import jdk.internal.foreign.abi.SharedUtils;
+import jdk.internal.foreign.abi.SharedUtils.SimpleVaArg;
+
+import java.lang.invoke.VarHandle;
+import java.util.ArrayList;
+import java.util.List;
+
+import static jdk.internal.foreign.PlatformLayouts.Win64.C_POINTER;
+
+// see vadefs.h (VC header)
+//
+// in short
+// -> va_list is just a pointer to a buffer with 64 bit entries.
+// -> non-power-of-two-sized, or larger than 64 bit types passed by reference.
+// -> other types passed in 64 bit slots by normal function calling convention.
+//
+// X64 va_arg impl:
+//
+//    typedef char* va_list;
+//
+//    #define __crt_va_arg(ap, t)                                               \
+//        ((sizeof(t) > sizeof(__int64) || (sizeof(t) & (sizeof(t) - 1)) != 0) \
+//            ? **(t**)((ap += sizeof(__int64)) - sizeof(__int64))             \
+//            :  *(t* )((ap += sizeof(__int64)) - sizeof(__int64)))
+//
+class WinVaList implements VaList {
+    public static final Class CARRIER = MemoryAddress.class;
+    private static final long VA_SLOT_SIZE_BYTES = 8;
+    private static final VarHandle VH_address = MemoryHandles.asAddressVarHandle(C_POINTER.varHandle(long.class));
+
+    private static final VaList EMPTY = new SharedUtils.EmptyVaList(MemoryAddress.NULL);
+
+    private MemorySegment segment;
+    private final List attachedSegments;
+    private final MemorySegment livenessCheck;
+
+    private WinVaList(MemorySegment segment, List attachedSegments, MemorySegment livenessCheck) {
+        this.segment = segment;
+        this.attachedSegments = attachedSegments;
+        this.livenessCheck = livenessCheck;
+    }
+
+    public static final VaList empty() {
+        return EMPTY;
+    }
+
+    @Override
+    public int vargAsInt(MemoryLayout layout) {
+        return (int) read(int.class, layout);
+    }
+
+    @Override
+    public long vargAsLong(MemoryLayout layout) {
+        return (long) read(long.class, layout);
+    }
+
+    @Override
+    public double vargAsDouble(MemoryLayout layout) {
+        return (double) read(double.class, layout);
+    }
+
+    @Override
+    public MemoryAddress vargAsAddress(MemoryLayout layout) {
+        return (MemoryAddress) read(MemoryAddress.class, layout);
+    }
+
+    @Override
+    public MemorySegment vargAsSegment(MemoryLayout layout) {
+        return (MemorySegment) read(MemorySegment.class, layout);
+    }
+
+    @Override
+    public MemorySegment vargAsSegment(MemoryLayout layout, NativeScope scope) {
+        return (MemorySegment) read(MemorySegment.class, layout, SharedUtils.Allocator.ofScope(scope));
+    }
+
+    private Object read(Class carrier, MemoryLayout layout) {
+        return read(carrier, layout, MemorySegment::allocateNative);
+    }
+
+    private Object read(Class carrier, MemoryLayout layout, SharedUtils.Allocator allocator) {
+        SharedUtils.checkCompatibleType(carrier, layout, Windowsx64Linker.ADDRESS_SIZE);
+        Object res;
+        if (carrier == MemorySegment.class) {
+            TypeClass typeClass = TypeClass.typeClassFor(layout);
+            res = switch (typeClass) {
+                case STRUCT_REFERENCE -> {
+                    MemoryAddress structAddr = (MemoryAddress) VH_address.get(segment);
+                    try (MemorySegment struct = handoffIfNeeded(structAddr.asSegmentRestricted(layout.byteSize()),
+                         segment.ownerThread())) {
+                        MemorySegment seg = allocator.allocate(layout.byteSize());
+                        seg.copyFrom(struct);
+                        yield seg;
+                    }
+                }
+                case STRUCT_REGISTER -> {
+                    MemorySegment struct = allocator.allocate(layout);
+                    struct.copyFrom(segment.asSlice(0L, layout.byteSize()));
+                    yield struct;
+                }
+                default -> throw new IllegalStateException("Unexpected TypeClass: " + typeClass);
+            };
+        } else {
+            VarHandle reader = SharedUtils.vhPrimitiveOrAddress(carrier, layout);
+            res = reader.get(segment);
+        }
+        segment = segment.asSlice(VA_SLOT_SIZE_BYTES);
+        return res;
+    }
+
+    @Override
+    public void skip(MemoryLayout... layouts) {
+        segment = segment.asSlice(layouts.length * VA_SLOT_SIZE_BYTES);
+    }
+
+    static WinVaList ofAddress(MemoryAddress addr) {
+        MemorySegment segment = addr.asSegmentRestricted(Long.MAX_VALUE);
+        return new WinVaList(segment, List.of(segment), null);
+    }
+
+    static Builder builder(SharedUtils.Allocator allocator) {
+        return new Builder(allocator);
+    }
+
+    @Override
+    public void close() {
+        if (livenessCheck != null)
+            livenessCheck.close();
+        attachedSegments.forEach(MemorySegment::close);
+    }
+
+    @Override
+    public VaList copy() {
+        MemorySegment liveness = handoffIfNeeded(MemoryAddress.NULL.asSegmentRestricted(1),
+                segment.ownerThread());
+        return new WinVaList(segment, List.of(), liveness);
+    }
+
+    @Override
+    public VaList copy(NativeScope scope) {
+        MemorySegment liveness = handoffIfNeeded(MemoryAddress.NULL.asSegmentRestricted(1),
+                segment.ownerThread());
+        liveness = liveness.handoff(scope);
+        return new WinVaList(segment, List.of(), liveness);
+    }
+
+    @Override
+    public MemoryAddress address() {
+        return segment.address();
+    }
+
+    @Override
+    public boolean isAlive() {
+        if (livenessCheck != null)
+            return livenessCheck.isAlive();
+        return segment.isAlive();
+    }
+
+    static class Builder implements VaList.Builder {
+
+        private final SharedUtils.Allocator allocator;
+        private final List args = new ArrayList<>();
+
+        public Builder(SharedUtils.Allocator allocator) {
+            this.allocator = allocator;
+        }
+
+        private Builder arg(Class carrier, MemoryLayout layout, Object value) {
+            SharedUtils.checkCompatibleType(carrier, layout, Windowsx64Linker.ADDRESS_SIZE);
+            args.add(new SimpleVaArg(carrier, layout, value));
+            return this;
+        }
+
+        @Override
+        public Builder vargFromInt(ValueLayout layout, int value) {
+            return arg(int.class, layout, value);
+        }
+
+        @Override
+        public Builder vargFromLong(ValueLayout layout, long value) {
+            return arg(long.class, layout, value);
+        }
+
+        @Override
+        public Builder vargFromDouble(ValueLayout layout, double value) {
+            return arg(double.class, layout, value);
+        }
+
+        @Override
+        public Builder vargFromAddress(ValueLayout layout, Addressable value) {
+            return arg(MemoryAddress.class, layout, value.address());
+        }
+
+        @Override
+        public Builder vargFromSegment(GroupLayout layout, MemorySegment value) {
+            return arg(MemorySegment.class, layout, value);
+        }
+
+        public VaList build() {
+            if (args.isEmpty()) {
+                return EMPTY;
+            }
+            MemorySegment segment = allocator.allocate(VA_SLOT_SIZE_BYTES * args.size());
+            List attachedSegments = new ArrayList<>();
+            attachedSegments.add(segment);
+            MemorySegment cursor = segment;
+
+            for (SimpleVaArg arg : args) {
+                if (arg.carrier == MemorySegment.class) {
+                    MemorySegment msArg = ((MemorySegment) arg.value);
+                    TypeClass typeClass = TypeClass.typeClassFor(arg.layout);
+                    switch (typeClass) {
+                        case STRUCT_REFERENCE -> {
+                            MemorySegment copy = allocator.allocate(arg.layout);
+                            copy.copyFrom(msArg); // by-value
+                            attachedSegments.add(copy);
+                            VH_address.set(cursor, copy.address());
+                        }
+                        case STRUCT_REGISTER -> {
+                            MemorySegment slice = cursor.asSlice(0, VA_SLOT_SIZE_BYTES);
+                            slice.copyFrom(msArg);
+                        }
+                        default -> throw new IllegalStateException("Unexpected TypeClass: " + typeClass);
+                    }
+                } else {
+                    VarHandle writer = arg.varHandle();
+                    writer.set(cursor, arg.value);
+                }
+                cursor = cursor.asSlice(VA_SLOT_SIZE_BYTES);
+            }
+
+            return new WinVaList(segment, attachedSegments, null);
+        }
+    }
+
+    private static MemorySegment handoffIfNeeded(MemorySegment segment, Thread thread) {
+        return segment.ownerThread() == thread ?
+                segment : segment.handoff(thread);
+    }
+}
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/windows/Windowsx64Linker.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/windows/Windowsx64Linker.java
new file mode 100644
index 0000000000000..a695ddc4138da
--- /dev/null
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/windows/Windowsx64Linker.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package jdk.internal.foreign.abi.x64.windows;
+
+import jdk.incubator.foreign.Addressable;
+import jdk.incubator.foreign.FunctionDescriptor;
+import jdk.incubator.foreign.MemoryAddress;
+import jdk.incubator.foreign.MemoryLayout;
+import jdk.incubator.foreign.MemorySegment;
+import jdk.incubator.foreign.CLinker;
+import jdk.internal.foreign.abi.SharedUtils;
+import jdk.internal.foreign.abi.UpcallStubs;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
+import java.util.function.Consumer;
+
+import static jdk.internal.foreign.PlatformLayouts.*;
+
+/**
+ * ABI implementation based on Windows ABI AMD64 supplement v.0.99.6
+ */
+public class Windowsx64Linker implements CLinker {
+
+    public static final int MAX_INTEGER_ARGUMENT_REGISTERS = 4;
+    public static final int MAX_INTEGER_RETURN_REGISTERS = 1;
+    public static final int MAX_VECTOR_ARGUMENT_REGISTERS = 4;
+    public static final int MAX_VECTOR_RETURN_REGISTERS = 1;
+    public static final int MAX_REGISTER_ARGUMENTS = 4;
+    public static final int MAX_REGISTER_RETURNS = 1;
+
+    private static Windowsx64Linker instance;
+
+    static final long ADDRESS_SIZE = 64; // bits
+
+    private static final MethodHandle MH_unboxVaList;
+    private static final MethodHandle MH_boxVaList;
+
+    static {
+        try {
+            MethodHandles.Lookup lookup = MethodHandles.lookup();
+            MH_unboxVaList = lookup.findVirtual(VaList.class, "address",
+                MethodType.methodType(MemoryAddress.class));
+            MH_boxVaList = lookup.findStatic(Windowsx64Linker.class, "newVaListOfAddress",
+                MethodType.methodType(VaList.class, MemoryAddress.class));
+        } catch (ReflectiveOperationException e) {
+            throw new ExceptionInInitializerError(e);
+        }
+    }
+
+    public static Windowsx64Linker getInstance() {
+        if (instance == null) {
+            instance = new Windowsx64Linker();
+        }
+        return instance;
+    }
+
+    public static VaList newVaList(Consumer actions, SharedUtils.Allocator allocator) {
+        WinVaList.Builder builder = WinVaList.builder(allocator);
+        actions.accept(builder);
+        return builder.build();
+    }
+
+    @Override
+    public MethodHandle downcallHandle(Addressable symbol, MethodType type, FunctionDescriptor function) {
+        MethodType llMt = SharedUtils.convertVaListCarriers(type, WinVaList.CARRIER);
+        MethodHandle handle = CallArranger.arrangeDowncall(symbol, llMt, function);
+        handle = SharedUtils.unboxVaLists(type, handle, MH_unboxVaList);
+        return handle;
+    }
+
+    @Override
+    public MemorySegment upcallStub(MethodHandle target, FunctionDescriptor function) {
+        target = SharedUtils.boxVaLists(target, MH_boxVaList);
+        return UpcallStubs.upcallAddress(CallArranger.arrangeUpcall(target, target.type(), function));
+    }
+
+    public static VaList newVaListOfAddress(MemoryAddress ma) {
+        return WinVaList.ofAddress(ma);
+    }
+
+    public static VaList emptyVaList() {
+        return WinVaList.empty();
+    }
+}
diff --git a/test/jdk/java/foreign/CallGeneratorHelper.java b/test/jdk/java/foreign/CallGeneratorHelper.java
new file mode 100644
index 0000000000000..bc9cc7a181fca
--- /dev/null
+++ b/test/jdk/java/foreign/CallGeneratorHelper.java
@@ -0,0 +1,464 @@
+/*
+ * Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
+ *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ *  This code is free software; you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License version 2 only, as
+ *  published by the Free Software Foundation.
+ *
+ *  This code 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
+ *  version 2 for more details (a copy is included in the LICENSE file that
+ *  accompanied this code).
+ *
+ *  You should have received a copy of the GNU General Public License version
+ *  2 along with this work; if not, write to the Free Software Foundation,
+ *  Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ *   Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ *  or visit www.oracle.com if you need additional information or have any
+ *  questions.
+ *
+ */
+
+import jdk.incubator.foreign.GroupLayout;
+import jdk.incubator.foreign.MemoryAddress;
+import jdk.incubator.foreign.MemoryLayout;
+import jdk.incubator.foreign.MemorySegment;
+import jdk.incubator.foreign.ValueLayout;
+
+import java.lang.invoke.VarHandle;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Stack;
+import java.util.function.Consumer;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+import org.testng.annotations.*;
+
+import static jdk.incubator.foreign.CLinker.*;
+import static org.testng.Assert.*;
+
+public class CallGeneratorHelper extends NativeTestHelper {
+
+    static final int MAX_FIELDS = 3;
+    static final int MAX_PARAMS = 3;
+    static final int CHUNK_SIZE = 600;
+
+    static int functions = 0;
+
+    public static void assertStructEquals(MemorySegment actual, MemorySegment expected, MemoryLayout layout) {
+        assertEquals(actual.byteSize(), expected.byteSize());
+        GroupLayout g = (GroupLayout) layout;
+        for (MemoryLayout field : g.memberLayouts()) {
+            if (field instanceof ValueLayout) {
+                VarHandle vh = g.varHandle(vhCarrier(field), MemoryLayout.PathElement.groupElement(field.name().orElseThrow()));
+                assertEquals(vh.get(actual), vh.get(expected));
+            }
+        }
+    }
+
+    private static Class vhCarrier(MemoryLayout layout) {
+        if (layout instanceof ValueLayout) {
+            if (isIntegral(layout)) {
+                if (layout.bitSize() == 64) {
+                    return long.class;
+                }
+                return int.class;
+            } else if (layout.bitSize() == 32) {
+                return float.class;
+            }
+            return double.class;
+        } else {
+            throw new IllegalStateException("Unexpected layout: " + layout);
+        }
+    }
+
+    enum Ret {
+        VOID,
+        NON_VOID
+    }
+
+    enum StructFieldType {
+        INT("int", C_INT),
+        FLOAT("float", C_FLOAT),
+        DOUBLE("double", C_DOUBLE),
+        POINTER("void*", C_POINTER);
+
+        final String typeStr;
+        final MemoryLayout layout;
+
+        StructFieldType(String typeStr, MemoryLayout layout) {
+            this.typeStr = typeStr;
+            this.layout = layout;
+        }
+
+        MemoryLayout layout() {
+            return layout;
+        }
+
+        @SuppressWarnings("unchecked")
+        static List>[] perms = new List[10];
+
+        static List> perms(int i) {
+            if (perms[i] == null) {
+                perms[i] = generateTest(i, values());
+            }
+            return perms[i];
+        }
+    }
+
+    enum ParamType {
+        INT("int", C_INT),
+        FLOAT("float", C_FLOAT),
+        DOUBLE("double", C_DOUBLE),
+        POINTER("void*", C_POINTER),
+        STRUCT("struct S", null);
+
+        private final String typeStr;
+        private final MemoryLayout layout;
+
+        ParamType(String typeStr, MemoryLayout layout) {
+            this.typeStr = typeStr;
+            this.layout = layout;
+        }
+
+        String type(List fields) {
+            return this == STRUCT ?
+                    typeStr + "_" + sigCode(fields) :
+                    typeStr;
+        }
+
+        MemoryLayout layout(List fields) {
+            if (this == STRUCT) {
+                long offset = 0L;
+                List layouts = new ArrayList<>();
+                for (StructFieldType field : fields) {
+                    MemoryLayout l = field.layout();
+                    long padding = offset % l.bitSize();
+                    if (padding != 0) {
+                        layouts.add(MemoryLayout.ofPaddingBits(padding));
+                        offset += padding;
+                    }
+                    layouts.add(l.withName("field" + offset));
+                    offset += l.bitSize();
+                }
+                return MemoryLayout.ofStruct(layouts.toArray(new MemoryLayout[0]));
+            } else {
+                return layout;
+            }
+        }
+
+        @SuppressWarnings("unchecked")
+        static List>[] perms = new List[10];
+
+        static List> perms(int i) {
+            if (perms[i] == null) {
+                perms[i] = generateTest(i, values());
+            }
+            return perms[i];
+        }
+    }
+
+    static  List> generateTest(int i, Z[] elems) {
+        List> res = new ArrayList<>();
+        generateTest(i, new Stack<>(), elems, res);
+        return res;
+    }
+
+    static  void generateTest(int i, Stack combo, Z[] elems, List> results) {
+        if (i == 0) {
+            results.add(new ArrayList<>(combo));
+        } else {
+            for (Z z : elems) {
+                combo.push(z);
+                generateTest(i - 1, combo, elems, results);
+                combo.pop();
+            }
+        }
+    }
+
+    @DataProvider(name = "functions")
+    public static Object[][] functions() {
+        List downcalls = new ArrayList<>();
+        for (Ret r : Ret.values()) {
+            for (int i = 0; i <= MAX_PARAMS; i++) {
+                if (r != Ret.VOID && i == 0) continue;
+                for (List ptypes : ParamType.perms(i)) {
+                    String retCode = r == Ret.VOID ? "V" : ptypes.get(0).name().charAt(0) + "";
+                    String sigCode = sigCode(ptypes);
+                    if (ptypes.contains(ParamType.STRUCT)) {
+                        for (int j = 1; j <= MAX_FIELDS; j++) {
+                            for (List fields : StructFieldType.perms(j)) {
+                                String structCode = sigCode(fields);
+                                int fCode = functions++ / CHUNK_SIZE;
+                                String fName = String.format("f%d_%s_%s_%s", fCode, retCode, sigCode, structCode);
+                                downcalls.add(new Object[] { fName, r, ptypes, fields });
+                            }
+                        }
+                    } else {
+                        String structCode = sigCode(List.of());
+                        int fCode = functions++ / CHUNK_SIZE;
+                        String fName = String.format("f%d_%s_%s_%s", fCode, retCode, sigCode, structCode);
+                        downcalls.add(new Object[] { fName, r, ptypes, List.of() });
+                    }
+                }
+            }
+        }
+        return downcalls.toArray(new Object[0][]);
+    }
+
+    static > String sigCode(List elems) {
+        return elems.stream().map(p -> p.name().charAt(0) + "").collect(Collectors.joining());
+    }
+
+    static void generateStructDecl(List fields) {
+        String structCode = sigCode(fields);
+        List fieldDecls = new ArrayList<>();
+        for (int i = 0 ; i < fields.size() ; i++) {
+            fieldDecls.add(String.format("%s p%d;", fields.get(i).typeStr, i));
+        }
+        String res = String.format("struct S_%s { %s };", structCode,
+                fieldDecls.stream().collect(Collectors.joining(" ")));
+        System.out.println(res);
+    }
+
+    /* this can be used to generate the test header/implementation */
+    public static void main(String[] args) {
+        boolean header = args.length > 0 && args[0].equals("header");
+        boolean upcall = args.length > 1 && args[1].equals("upcall");
+        if (upcall) {
+            generateUpcalls(header);
+        } else {
+            generateDowncalls(header);
+        }
+    }
+
+    static void generateDowncalls(boolean header) {
+        if (header) {
+            System.out.println(
+                "#ifdef _WIN64\n" +
+                "#define EXPORT __declspec(dllexport)\n" +
+                "#else\n" +
+                "#define EXPORT\n" +
+                "#endif\n"
+            );
+
+            for (int j = 1; j <= MAX_FIELDS; j++) {
+                for (List fields : StructFieldType.perms(j)) {
+                    generateStructDecl(fields);
+                }
+            }
+        } else {
+            System.out.println(
+                "#include \"libh\"\n" +
+                "#ifdef __clang__\n" +
+                "#pragma clang optimize off\n" +
+                "#elif defined __GNUC__\n" +
+                "#pragma GCC optimize (\"O0\")\n" +
+                "#elif defined _MSC_BUILD\n" +
+                "#pragma optimize( \"\", off )\n" +
+                "#endif\n"
+            );
+        }
+
+        for (Object[] downcall : functions()) {
+            String fName = (String)downcall[0];
+            Ret r = (Ret)downcall[1];
+            @SuppressWarnings("unchecked")
+            List ptypes = (List)downcall[2];
+            @SuppressWarnings("unchecked")
+            List fields = (List)downcall[3];
+            generateDowncallFunction(fName, r, ptypes, fields, header);
+        }
+    }
+
+    static void generateDowncallFunction(String fName, Ret ret, List params, List fields, boolean declOnly) {
+        String retType = ret == Ret.VOID ? "void" : params.get(0).type(fields);
+        List paramDecls = new ArrayList<>();
+        for (int i = 0 ; i < params.size() ; i++) {
+            paramDecls.add(String.format("%s p%d", params.get(i).type(fields), i));
+        }
+        String sig = paramDecls.isEmpty() ?
+                "void" :
+                paramDecls.stream().collect(Collectors.joining(", "));
+        String body = ret == Ret.VOID ? "{ }" : "{ return p0; }";
+        String res = String.format("EXPORT %s f%s(%s) %s", retType, fName,
+                sig, declOnly ? ";" : body);
+        System.out.println(res);
+    }
+
+    static void generateUpcalls(boolean header) {
+        if (header) {
+            System.out.println(
+                "#ifdef _WIN64\n" +
+                "#define EXPORT __declspec(dllexport)\n" +
+                "#else\n" +
+                "#define EXPORT\n" +
+                "#endif\n"
+            );
+
+            for (int j = 1; j <= MAX_FIELDS; j++) {
+                for (List fields : StructFieldType.perms(j)) {
+                    generateStructDecl(fields);
+                }
+            }
+        } else {
+            System.out.println(
+                "#include \"libh\"\n" +
+                "#ifdef __clang__\n" +
+                "#pragma clang optimize off\n" +
+                "#elif defined __GNUC__\n" +
+                "#pragma GCC optimize (\"O0\")\n" +
+                "#elif defined _MSC_BUILD\n" +
+                "#pragma optimize( \"\", off )\n" +
+                "#endif\n"
+            );
+        }
+
+        for (Object[] downcall : functions()) {
+            String fName = (String)downcall[0];
+            Ret r = (Ret)downcall[1];
+            @SuppressWarnings("unchecked")
+            List ptypes = (List)downcall[2];
+            @SuppressWarnings("unchecked")
+            List fields = (List)downcall[3];
+            generateUpcallFunction(fName, r, ptypes, fields, header);
+        }
+    }
+
+    static void generateUpcallFunction(String fName, Ret ret, List params, List fields, boolean declOnly) {
+        String retType = ret == Ret.VOID ? "void" : params.get(0).type(fields);
+        List paramDecls = new ArrayList<>();
+        for (int i = 0 ; i < params.size() ; i++) {
+            paramDecls.add(String.format("%s p%d", params.get(i).type(fields), i));
+        }
+        String paramNames = IntStream.range(0, params.size())
+                .mapToObj(i -> "p" + i)
+                .collect(Collectors.joining(","));
+        String sig = paramDecls.isEmpty() ?
+                "" :
+                paramDecls.stream().collect(Collectors.joining(", ")) + ", ";
+        String body = String.format(ret == Ret.VOID ? "{ cb(%s); }" : "{ return cb(%s); }", paramNames);
+        List paramTypes = params.stream().map(p -> p.type(fields)).collect(Collectors.toList());
+        String cbSig = paramTypes.isEmpty() ?
+                "void" :
+                paramTypes.stream().collect(Collectors.joining(", "));
+        String cbParam = String.format("%s (*cb)(%s)",
+                retType, cbSig);
+
+        String res = String.format("EXPORT %s %s(%s %s) %s", retType, fName,
+                sig, cbParam, declOnly ? ";" : body);
+        System.out.println(res);
+    }
+
+    //helper methods
+
+    @SuppressWarnings("unchecked")
+    static Object makeArg(MemoryLayout layout, List> checks, boolean check, List segments) throws ReflectiveOperationException {
+        if (layout instanceof GroupLayout) {
+            MemorySegment segment = MemorySegment.allocateNative(layout);
+            initStruct(segment, (GroupLayout)layout, checks, check, segments);
+            segments.add(segment);
+            return segment;
+        } else if (isPointer(layout)) {
+            MemorySegment segment = MemorySegment.allocateNative(1);
+            segments.add(segment);
+            if (check) {
+                checks.add(o -> {
+                    try {
+                        assertEquals((MemoryAddress)o, segment.address());
+                    } catch (Throwable ex) {
+                        throw new IllegalStateException(ex);
+                    }
+                });
+            }
+            return segment.address();
+        } else if (layout instanceof ValueLayout) {
+            if (isIntegral(layout)) {
+                if (check) {
+                    checks.add(o -> assertEquals(o, 42));
+                }
+                return 42;
+            } else if (layout.bitSize() == 32) {
+                if (check) {
+                    checks.add(o -> assertEquals(o, 12f));
+                }
+                return 12f;
+            } else {
+                if (check) {
+                    checks.add(o -> assertEquals(o, 24d));
+                }
+                return 24d;
+            }
+        } else {
+            throw new IllegalStateException("Unexpected layout: " + layout);
+        }
+    }
+
+    static void initStruct(MemorySegment str, GroupLayout g, List> checks, boolean check, List segments) throws ReflectiveOperationException {
+        for (MemoryLayout l : g.memberLayouts()) {
+            if (l.isPadding()) continue;
+            VarHandle accessor = g.varHandle(structFieldCarrier(l), MemoryLayout.PathElement.groupElement(l.name().get()));
+            List> fieldsCheck = new ArrayList<>();
+            Object value = makeArg(l, fieldsCheck, check, segments);
+            if (isPointer(l)) {
+                value = ((MemoryAddress)value).toRawLongValue();
+            }
+            //set value
+            accessor.set(str, value);
+            //add check
+            if (check) {
+                assertTrue(fieldsCheck.size() == 1);
+                checks.add(o -> {
+                    MemorySegment actual = (MemorySegment)o;
+                    try {
+                        if (isPointer(l)) {
+                            fieldsCheck.get(0).accept(MemoryAddress.ofLong((long)accessor.get(actual)));
+                        } else {
+                            fieldsCheck.get(0).accept(accessor.get(actual));
+                        }
+                    } catch (Throwable ex) {
+                        throw new IllegalStateException(ex);
+                    }
+                });
+            }
+        }
+    }
+
+    static Class structFieldCarrier(MemoryLayout layout) {
+        if (isPointer(layout)) {
+            return long.class;
+        } else if (layout instanceof ValueLayout) {
+            if (isIntegral(layout)) {
+                return int.class;
+            } else if (layout.bitSize() == 32) {
+                return float.class;
+            } else {
+                return double.class;
+            }
+        } else {
+            throw new IllegalStateException("Unexpected layout: " + layout);
+        }
+    }
+
+    static Class paramCarrier(MemoryLayout layout) {
+        if (layout instanceof GroupLayout) {
+            return MemorySegment.class;
+        } if (isPointer(layout)) {
+            return MemoryAddress.class;
+        } else if (layout instanceof ValueLayout) {
+            if (isIntegral(layout)) {
+                return int.class;
+            } else if (layout.bitSize() == 32) {
+                return float.class;
+            } else {
+                return double.class;
+            }
+        } else {
+            throw new IllegalStateException("Unexpected layout: " + layout);
+        }
+    }
+}
diff --git a/test/jdk/java/foreign/NativeTestHelper.java b/test/jdk/java/foreign/NativeTestHelper.java
new file mode 100644
index 0000000000000..71f580329283f
--- /dev/null
+++ b/test/jdk/java/foreign/NativeTestHelper.java
@@ -0,0 +1,42 @@
+/*
+ *  Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
+ *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ *  This code is free software; you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License version 2 only, as
+ *  published by the Free Software Foundation.
+ *
+ *  This code 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
+ *  version 2 for more details (a copy is included in the LICENSE file that
+ *  accompanied this code).
+ *
+ *  You should have received a copy of the GNU General Public License version
+ *  2 along with this work; if not, write to the Free Software Foundation,
+ *  Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ *  Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ *  or visit www.oracle.com if you need additional information or have any
+ *  questions.
+ *
+ */
+
+import jdk.incubator.foreign.CLinker;
+import jdk.incubator.foreign.MemoryLayout;
+
+public class NativeTestHelper {
+
+    static CLinker.TypeKind kind(MemoryLayout layout) {
+        return (CLinker.TypeKind)layout.attribute(CLinker.TypeKind.ATTR_NAME).orElseThrow(
+                () -> new IllegalStateException("Unexpected value layout: could not determine ABI class"));
+    }
+
+    public static boolean isIntegral(MemoryLayout layout) {
+        return kind(layout).isIntegral();
+    }
+
+    public static boolean isPointer(MemoryLayout layout) {
+        return kind(layout).isPointer();
+    }
+}
diff --git a/test/jdk/java/foreign/StdLibTest.java b/test/jdk/java/foreign/StdLibTest.java
new file mode 100644
index 0000000000000..35713b8e6742b
--- /dev/null
+++ b/test/jdk/java/foreign/StdLibTest.java
@@ -0,0 +1,454 @@
+/*
+ * Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test
+ * @run testng/othervm -Dforeign.restricted=permit StdLibTest
+ */
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
+import java.time.Instant;
+import java.time.LocalDateTime;
+import java.time.ZoneOffset;
+import java.time.ZonedDateTime;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.function.Consumer;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import jdk.incubator.foreign.*;
+
+import static jdk.incubator.foreign.MemoryAccess.*;
+
+import org.testng.annotations.*;
+
+import static jdk.incubator.foreign.CLinker.*;
+import static org.testng.Assert.*;
+
+@Test
+public class StdLibTest {
+
+    final static CLinker abi = CLinker.getInstance();
+
+    private StdLibHelper stdLibHelper = new StdLibHelper();
+
+    @Test(dataProvider = "stringPairs")
+    void test_strcat(String s1, String s2) throws Throwable {
+        assertEquals(stdLibHelper.strcat(s1, s2), s1 + s2);
+    }
+
+    @Test(dataProvider = "stringPairs")
+    void test_strcmp(String s1, String s2) throws Throwable {
+        assertEquals(Math.signum(stdLibHelper.strcmp(s1, s2)), Math.signum(s1.compareTo(s2)));
+    }
+
+    @Test(dataProvider = "strings")
+    void test_puts(String s) throws Throwable {
+        assertTrue(stdLibHelper.puts(s) >= 0);
+    }
+
+    @Test(dataProvider = "strings")
+    void test_strlen(String s) throws Throwable {
+        assertEquals(stdLibHelper.strlen(s), s.length());
+    }
+
+    @Test(dataProvider = "instants")
+    void test_time(Instant instant) throws Throwable {
+        StdLibHelper.Tm tm = stdLibHelper.gmtime(instant.getEpochSecond());
+        LocalDateTime localTime = LocalDateTime.ofInstant(instant, ZoneOffset.UTC);
+        assertEquals(tm.sec(), localTime.getSecond());
+        assertEquals(tm.min(), localTime.getMinute());
+        assertEquals(tm.hour(), localTime.getHour());
+        //day pf year in Java has 1-offset
+        assertEquals(tm.yday(), localTime.getDayOfYear() - 1);
+        assertEquals(tm.mday(), localTime.getDayOfMonth());
+        //days of week starts from Sunday in C, but on Monday in Java, also account for 1-offset
+        assertEquals((tm.wday() + 6) % 7, localTime.getDayOfWeek().getValue() - 1);
+        //month in Java has 1-offset
+        assertEquals(tm.mon(), localTime.getMonth().getValue() - 1);
+        assertEquals(tm.isdst(), ZoneOffset.UTC.getRules()
+                .isDaylightSavings(Instant.ofEpochMilli(instant.getEpochSecond() * 1000)));
+    }
+
+    @Test(dataProvider = "ints")
+    void test_qsort(List ints) throws Throwable {
+        if (ints.size() > 0) {
+            int[] input = ints.stream().mapToInt(i -> i).toArray();
+            int[] sorted = stdLibHelper.qsort(input);
+            Arrays.sort(input);
+            assertEquals(sorted, input);
+        }
+    }
+
+    @Test
+    void test_rand() throws Throwable {
+        int val = stdLibHelper.rand();
+        for (int i = 0 ; i < 100 ; i++) {
+            int newVal = stdLibHelper.rand();
+            if (newVal != val) {
+                return; //ok
+            }
+            val = newVal;
+        }
+        fail("All values are the same! " + val);
+    }
+
+    @Test(dataProvider = "printfArgs")
+    void test_printf(List args) throws Throwable {
+        String formatArgs = args.stream()
+                .map(a -> a.format)
+                .collect(Collectors.joining(","));
+
+        String formatString = "hello(" + formatArgs + ")\n";
+
+        String expected = String.format(formatString, args.stream()
+                .map(a -> a.javaValue).toArray());
+
+        int found = stdLibHelper.printf(formatString, args);
+        assertEquals(found, expected.length());
+    }
+
+    @Test(dataProvider = "printfArgs")
+    void test_vprintf(List args) throws Throwable {
+        String formatArgs = args.stream()
+                .map(a -> a.format)
+                .collect(Collectors.joining(","));
+
+        String formatString = "hello(" + formatArgs + ")\n";
+
+        String expected = String.format(formatString, args.stream()
+                .map(a -> a.javaValue).toArray());
+
+        int found = stdLibHelper.vprintf(formatString, args);
+        assertEquals(found, expected.length());
+    }
+
+    static class StdLibHelper {
+
+        static final LibraryLookup lookup = LibraryLookup.ofDefault();
+
+        final static MethodHandle strcat = abi.downcallHandle(lookup.lookup("strcat").get(),
+                MethodType.methodType(MemoryAddress.class, MemoryAddress.class, MemoryAddress.class),
+                FunctionDescriptor.of(C_POINTER, C_POINTER, C_POINTER));
+
+        final static MethodHandle strcmp = abi.downcallHandle(lookup.lookup("strcmp").get(),
+                MethodType.methodType(int.class, MemoryAddress.class, MemoryAddress.class),
+                FunctionDescriptor.of(C_INT, C_POINTER, C_POINTER));
+
+        final static MethodHandle puts = abi.downcallHandle(lookup.lookup("puts").get(),
+                MethodType.methodType(int.class, MemoryAddress.class),
+                FunctionDescriptor.of(C_INT, C_POINTER));
+
+        final static MethodHandle strlen = abi.downcallHandle(lookup.lookup("strlen").get(),
+                MethodType.methodType(int.class, MemoryAddress.class),
+                FunctionDescriptor.of(C_INT, C_POINTER));
+
+        final static MethodHandle gmtime = abi.downcallHandle(lookup.lookup("gmtime").get(),
+                MethodType.methodType(MemoryAddress.class, MemoryAddress.class),
+                FunctionDescriptor.of(C_POINTER, C_POINTER));
+
+        final static MethodHandle qsort = abi.downcallHandle(lookup.lookup("qsort").get(),
+                MethodType.methodType(void.class, MemoryAddress.class, long.class, long.class, MemoryAddress.class),
+                FunctionDescriptor.ofVoid(C_POINTER, C_LONGLONG, C_LONGLONG, C_POINTER));
+
+        final static FunctionDescriptor qsortComparFunction = FunctionDescriptor.of(C_INT, C_POINTER, C_POINTER);
+
+        final static MethodHandle qsortCompar;
+
+        final static MethodHandle rand = abi.downcallHandle(lookup.lookup("rand").get(),
+                MethodType.methodType(int.class),
+                FunctionDescriptor.of(C_INT));
+
+        final static MethodHandle vprintf = abi.downcallHandle(lookup.lookup("vprintf").get(),
+                MethodType.methodType(int.class, MemoryAddress.class, VaList.class),
+                FunctionDescriptor.of(C_INT, C_POINTER, C_VA_LIST));
+
+        final static LibraryLookup.Symbol printfAddr = lookup.lookup("printf").get();
+
+        final static FunctionDescriptor printfBase = FunctionDescriptor.of(C_INT, C_POINTER);
+
+        static {
+            try {
+                //qsort upcall handle
+                qsortCompar = MethodHandles.lookup().findStatic(StdLibTest.StdLibHelper.class, "qsortCompare",
+                        MethodType.methodType(int.class, MemorySegment.class, MemoryAddress.class, MemoryAddress.class));
+            } catch (ReflectiveOperationException ex) {
+                throw new IllegalStateException(ex);
+            }
+        }
+
+        String strcat(String s1, String s2) throws Throwable {
+            try (MemorySegment buf = MemorySegment.allocateNative(s1.length() + s2.length() + 1) ;
+                 MemorySegment other = toCString(s2)) {
+                char[] chars = s1.toCharArray();
+                for (long i = 0 ; i < chars.length ; i++) {
+                    setByteAtOffset(buf, i, (byte)chars[(int)i]);
+                }
+                setByteAtOffset(buf, chars.length, (byte)'\0');
+                return toJavaStringRestricted(((MemoryAddress)strcat.invokeExact(buf.address(), other.address())));
+            }
+        }
+
+        int strcmp(String s1, String s2) throws Throwable {
+            try (MemorySegment ns1 = toCString(s1) ;
+                 MemorySegment ns2 = toCString(s2)) {
+                return (int)strcmp.invokeExact(ns1.address(), ns2.address());
+            }
+        }
+
+        int puts(String msg) throws Throwable {
+            try (MemorySegment s = toCString(msg)) {
+                return (int)puts.invokeExact(s.address());
+            }
+        }
+
+        int strlen(String msg) throws Throwable {
+            try (MemorySegment s = toCString(msg)) {
+                return (int)strlen.invokeExact(s.address());
+            }
+        }
+
+        Tm gmtime(long arg) throws Throwable {
+            try (MemorySegment time = MemorySegment.allocateNative(8)) {
+                setLong(time, arg);
+                return new Tm((MemoryAddress)gmtime.invokeExact(time.address()));
+            }
+        }
+
+        static class Tm {
+
+            //Tm pointer should never be freed directly, as it points to shared memory
+            private final MemorySegment base;
+
+            static final long SIZE = 56;
+
+            Tm(MemoryAddress addr) {
+                this.base = addr.asSegmentRestricted(SIZE);
+            }
+
+            int sec() {
+                return getIntAtOffset(base, 0);
+            }
+            int min() {
+                return getIntAtOffset(base, 4);
+            }
+            int hour() {
+                return getIntAtOffset(base, 8);
+            }
+            int mday() {
+                return getIntAtOffset(base, 12);
+            }
+            int mon() {
+                return getIntAtOffset(base, 16);
+            }
+            int year() {
+                return getIntAtOffset(base, 20);
+            }
+            int wday() {
+                return getIntAtOffset(base, 24);
+            }
+            int yday() {
+                return getIntAtOffset(base, 28);
+            }
+            boolean isdst() {
+                byte b = getByteAtOffset(base, 32);
+                return b != 0;
+            }
+        }
+
+        int[] qsort(int[] arr) throws Throwable {
+            //init native array
+            try (NativeScope scope = NativeScope.unboundedScope()) {
+
+                MemorySegment nativeArr = scope.allocateArray(C_INT, arr);
+
+                //call qsort
+                MemorySegment qsortUpcallStub = abi.upcallStub(qsortCompar.bindTo(nativeArr), qsortComparFunction);
+                qsortUpcallStub = qsortUpcallStub.handoff(scope);
+
+                qsort.invokeExact(nativeArr.address(), (long)arr.length, C_INT.byteSize(), qsortUpcallStub.address());
+
+                //convert back to Java array
+                return nativeArr.toIntArray();
+            }
+        }
+
+        static int qsortCompare(MemorySegment base, MemoryAddress addr1, MemoryAddress addr2) {
+            return getIntAtOffset(base, addr1.segmentOffset(base)) -
+                   getIntAtOffset(base, addr2.segmentOffset(base));
+        }
+
+        int rand() throws Throwable {
+            return (int)rand.invokeExact();
+        }
+
+        int printf(String format, List args) throws Throwable {
+            try (MemorySegment formatStr = toCString(format)) {
+                return (int)specializedPrintf(args).invokeExact(formatStr.address(),
+                        args.stream().map(a -> a.nativeValue).toArray());
+            }
+        }
+
+        int vprintf(String format, List args) throws Throwable {
+            try (MemorySegment formatStr = toCString(format)) {
+                VaList vaList = VaList.make(b -> args.forEach(a -> a.accept(b)));
+                int result = (int)vprintf.invokeExact(formatStr.address(), vaList);
+                try {
+                    vaList.close();
+                }
+                catch (UnsupportedOperationException e) {
+                    assertEquals(e.getMessage(), "Empty VaList");
+                }
+                return result;
+            }
+        }
+
+        private MethodHandle specializedPrintf(List args) {
+            //method type
+            MethodType mt = MethodType.methodType(int.class, MemoryAddress.class);
+            FunctionDescriptor fd = printfBase;
+            for (PrintfArg arg : args) {
+                mt = mt.appendParameterTypes(arg.carrier);
+                fd = fd.appendArgumentLayouts(arg.layout);
+            }
+            MethodHandle mh = abi.downcallHandle(printfAddr, mt, fd);
+            return mh.asSpreader(1, Object[].class, args.size());
+        }
+    }
+
+    /*** data providers ***/
+
+    @DataProvider
+    public static Object[][] ints() {
+        return perms(0, new Integer[] { 0, 1, 2, 3, 4 }).stream()
+                .map(l -> new Object[] { l })
+                .toArray(Object[][]::new);
+    }
+
+    @DataProvider
+    public static Object[][] strings() {
+        return perms(0, new String[] { "a", "b", "c" }).stream()
+                .map(l -> new Object[] { String.join("", l) })
+                .toArray(Object[][]::new);
+    }
+
+    @DataProvider
+    public static Object[][] stringPairs() {
+        Object[][] strings = strings();
+        Object[][] stringPairs = new Object[strings.length * strings.length][];
+        int pos = 0;
+        for (Object[] s1 : strings) {
+            for (Object[] s2 : strings) {
+                stringPairs[pos++] = new Object[] { s1[0], s2[0] };
+            }
+        }
+        return stringPairs;
+    }
+
+    @DataProvider
+    public static Object[][] instants() {
+        Instant start = ZonedDateTime.of(LocalDateTime.parse("2017-01-01T00:00:00"), ZoneOffset.UTC).toInstant();
+        Instant end = ZonedDateTime.of(LocalDateTime.parse("2017-12-31T00:00:00"), ZoneOffset.UTC).toInstant();
+        Object[][] instants = new Object[100][];
+        for (int i = 0 ; i < instants.length ; i++) {
+            Instant instant = start.plusSeconds((long)(Math.random() * (end.getEpochSecond() - start.getEpochSecond())));
+            instants[i] = new Object[] { instant };
+        }
+        return instants;
+    }
+
+    @DataProvider
+    public static Object[][] printfArgs() {
+        ArrayList> res = new ArrayList<>();
+        List> perms = new ArrayList<>(perms(0, PrintfArg.values()));
+        for (int i = 0 ; i < 100 ; i++) {
+            Collections.shuffle(perms);
+            res.addAll(perms);
+        }
+        return res.stream()
+                .map(l -> new Object[] { l })
+                .toArray(Object[][]::new);
+    }
+
+    enum PrintfArg implements Consumer {
+
+        INTEGRAL(int.class, asVarArg(C_INT), "%d", 42, 42, VaList.Builder::vargFromInt),
+        STRING(MemoryAddress.class, asVarArg(C_POINTER), "%s", toCString("str").address(), "str", VaList.Builder::vargFromAddress),
+        CHAR(byte.class, asVarArg(C_CHAR), "%c", (byte) 'h', 'h', (builder, layout, value) -> builder.vargFromInt(C_INT, (int)value)),
+        DOUBLE(double.class, asVarArg(C_DOUBLE), "%.4f", 1.2345d, 1.2345d, VaList.Builder::vargFromDouble);
+
+        final Class carrier;
+        final ValueLayout layout;
+        final String format;
+        final Object nativeValue;
+        final Object javaValue;
+        @SuppressWarnings("rawtypes")
+        final VaListBuilderCall builderCall;
+
+         PrintfArg(Class carrier, ValueLayout layout, String format, Z nativeValue, Object javaValue, VaListBuilderCall builderCall) {
+            this.carrier = carrier;
+            this.layout = layout;
+            this.format = format;
+            this.nativeValue = nativeValue;
+            this.javaValue = javaValue;
+            this.builderCall = builderCall;
+        }
+
+        @Override
+        @SuppressWarnings("unchecked")
+        public void accept(VaList.Builder builder) {
+            builderCall.build(builder, layout, nativeValue);
+        }
+
+        interface VaListBuilderCall {
+            void build(VaList.Builder builder, ValueLayout layout, V value);
+        }
+    }
+
+    static  Set> perms(int count, Z[] arr) {
+        if (count == arr.length) {
+            return Set.of(List.of());
+        } else {
+            return Arrays.stream(arr)
+                    .flatMap(num -> {
+                        Set> perms = perms(count + 1, arr);
+                        return Stream.concat(
+                                //take n
+                                perms.stream().map(l -> {
+                                    List li = new ArrayList<>(l);
+                                    li.add(num);
+                                    return li;
+                                }),
+                                //drop n
+                                perms.stream());
+                    }).collect(Collectors.toCollection(LinkedHashSet::new));
+        }
+    }
+}
diff --git a/test/jdk/java/foreign/TestCircularInit1.java b/test/jdk/java/foreign/TestCircularInit1.java
new file mode 100644
index 0000000000000..2b07178ec8c8f
--- /dev/null
+++ b/test/jdk/java/foreign/TestCircularInit1.java
@@ -0,0 +1,44 @@
+/*
+ *  Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ *  This code is free software; you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License version 2 only, as
+ *  published by the Free Software Foundation.
+ *
+ *  This code 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
+ *  version 2 for more details (a copy is included in the LICENSE file that
+ *  accompanied this code).
+ *
+ *  You should have received a copy of the GNU General Public License version
+ *  2 along with this work; if not, write to the Free Software Foundation,
+ *  Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ *  Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ *  or visit www.oracle.com if you need additional information or have any
+ *  questions.
+ */
+
+/*
+ * @test
+ * @modules jdk.incubator.foreign/jdk.internal.foreign
+ * @run testng/othervm TestCircularInit1
+ */
+
+import jdk.incubator.foreign.CLinker;
+import jdk.internal.foreign.PlatformLayouts;
+import org.testng.annotations.Test;
+
+import static org.testng.Assert.assertNotNull;
+
+public class TestCircularInit1 {
+
+    @Test
+    public void testCircularInit() {
+        System.out.println(PlatformLayouts.Win64.C_CHAR); // trigger clinit
+        assertNotNull(CLinker.C_CHAR); // should not be null
+    }
+
+}
diff --git a/test/jdk/java/foreign/TestCircularInit2.java b/test/jdk/java/foreign/TestCircularInit2.java
new file mode 100644
index 0000000000000..84cdf0b1eb07f
--- /dev/null
+++ b/test/jdk/java/foreign/TestCircularInit2.java
@@ -0,0 +1,46 @@
+/*
+ *  Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ *  This code is free software; you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License version 2 only, as
+ *  published by the Free Software Foundation.
+ *
+ *  This code 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
+ *  version 2 for more details (a copy is included in the LICENSE file that
+ *  accompanied this code).
+ *
+ *  You should have received a copy of the GNU General Public License version
+ *  2 along with this work; if not, write to the Free Software Foundation,
+ *  Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ *  Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ *  or visit www.oracle.com if you need additional information or have any
+ *  questions.
+ */
+
+/*
+ * @test
+ * @modules jdk.incubator.foreign/jdk.internal.foreign
+ * @run testng/othervm TestCircularInit2
+ */
+
+import jdk.incubator.foreign.CLinker;
+import jdk.internal.foreign.PlatformLayouts;
+import org.testng.annotations.Test;
+
+import static org.testng.Assert.assertNotNull;
+
+public class TestCircularInit2 {
+
+    @Test
+    public void testCircularInit() {
+        System.out.println(CLinker.C_CHAR); // trigger clinit
+        assertNotNull(PlatformLayouts.Win64.C_CHAR);
+        assertNotNull(PlatformLayouts.SysV.C_CHAR);
+        assertNotNull(PlatformLayouts.AArch64.C_CHAR);
+    }
+
+}
diff --git a/test/jdk/java/foreign/TestCondy.java b/test/jdk/java/foreign/TestCondy.java
new file mode 100644
index 0000000000000..f802f94161f06
--- /dev/null
+++ b/test/jdk/java/foreign/TestCondy.java
@@ -0,0 +1,86 @@
+/*
+ *  Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ *  This code is free software; you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License version 2 only, as
+ *  published by the Free Software Foundation.
+ *
+ *  This code 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
+ *  version 2 for more details (a copy is included in the LICENSE file that
+ *  accompanied this code).
+ *
+ *  You should have received a copy of the GNU General Public License version
+ *  2 along with this work; if not, write to the Free Software Foundation,
+ *  Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ *  Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ *  or visit www.oracle.com if you need additional information or have any
+ *  questions.
+ */
+
+/*
+ * @test
+ *
+ * @run testng TestCondy
+ */
+
+import jdk.incubator.foreign.FunctionDescriptor;
+import jdk.incubator.foreign.MemoryLayout;
+import org.testng.annotations.DataProvider;
+import org.testng.annotations.Test;
+
+import java.lang.constant.Constable;
+import java.lang.constant.ConstantDesc;
+import java.lang.invoke.MethodHandles;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import static jdk.incubator.foreign.CLinker.*;
+import static org.testng.Assert.assertEquals;
+
+public class TestCondy {
+
+    @Test(dataProvider = "constables")
+    public void testPublicResolve(Constable constable) throws ReflectiveOperationException {
+        ConstantDesc desc = constable.describeConstable().orElseThrow();
+        Object result = desc.resolveConstantDesc(MethodHandles.publicLookup());
+        assertEquals(result, constable);
+    }
+
+
+    private static final MemoryLayout[] constants = {
+        C_CHAR,
+        C_SHORT,
+        C_INT,
+        C_LONG,
+        C_LONGLONG,
+        C_FLOAT,
+        C_DOUBLE,
+        C_LONGDOUBLE,
+        C_POINTER
+    };
+
+    @DataProvider
+    public static Object[][] constables() {
+        List testValues = new ArrayList<>();
+
+        testValues.addAll(Arrays.asList(constants));
+
+        testValues.add(MemoryLayout.ofStruct(constants));
+        testValues.add(MemoryLayout.ofUnion(constants));
+
+        for (MemoryLayout ml : constants) {
+            testValues.add(MemoryLayout.ofSequence(ml));
+            testValues.add(MemoryLayout.ofSequence(10, ml));
+        }
+
+        testValues.add(FunctionDescriptor.ofVoid(constants));
+        testValues.add(FunctionDescriptor.of(C_CHAR, constants));
+
+        return testValues.stream().map(e -> new Object[] { e }).toArray(Object[][]::new);
+    }
+}
diff --git a/test/jdk/java/foreign/TestDowncall.java b/test/jdk/java/foreign/TestDowncall.java
new file mode 100644
index 0000000000000..956d46a0ea693
--- /dev/null
+++ b/test/jdk/java/foreign/TestDowncall.java
@@ -0,0 +1,110 @@
+/*
+ *  Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
+ *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ *  This code is free software; you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License version 2 only, as
+ *  published by the Free Software Foundation.
+ *
+ *  This code 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
+ *  version 2 for more details (a copy is included in the LICENSE file that
+ *  accompanied this code).
+ *
+ *  You should have received a copy of the GNU General Public License version
+ *  2 along with this work; if not, write to the Free Software Foundation,
+ *  Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ *   Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ *  or visit www.oracle.com if you need additional information or have any
+ *  questions.
+ *
+ */
+
+/*
+ * @test
+ * @modules jdk.incubator.foreign/jdk.internal.foreign
+ * @build NativeTestHelper CallGeneratorHelper TestDowncall
+ *
+ * @run testng/othervm
+ *   -Dforeign.restricted=permit
+ *   -Djdk.internal.foreign.ProgrammableInvoker.USE_SPEC=false
+ *   -Djdk.internal.foreign.ProgrammableInvoker.USE_INTRINSICS=false
+ *   TestDowncall
+ * @run testng/othervm
+ *   -Dforeign.restricted=permit
+ *   -Djdk.internal.foreign.ProgrammableInvoker.USE_SPEC=true
+ *   -Djdk.internal.foreign.ProgrammableInvoker.USE_INTRINSICS=false
+ *   TestDowncall
+ * @run testng/othervm
+ *   -Dforeign.restricted=permit
+ *   -Djdk.internal.foreign.ProgrammableInvoker.USE_SPEC=false
+ *   -Djdk.internal.foreign.ProgrammableInvoker.USE_INTRINSICS=true
+ *   TestDowncall
+ * @run testng/othervm
+ *   -Dforeign.restricted=permit
+ *   -Djdk.internal.foreign.ProgrammableInvoker.USE_SPEC=true
+ *   -Djdk.internal.foreign.ProgrammableInvoker.USE_INTRINSICS=true
+ *   TestDowncall
+ */
+
+import jdk.incubator.foreign.CLinker;
+import jdk.incubator.foreign.FunctionDescriptor;
+import jdk.incubator.foreign.LibraryLookup;
+import jdk.incubator.foreign.MemoryLayout;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodType;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Consumer;
+
+import jdk.incubator.foreign.MemorySegment;
+import org.testng.annotations.*;
+
+public class TestDowncall extends CallGeneratorHelper {
+
+    static LibraryLookup lib = LibraryLookup.ofLibrary("TestDowncall");
+    static CLinker abi = CLinker.getInstance();
+
+
+    @Test(dataProvider="functions", dataProviderClass=CallGeneratorHelper.class)
+    public void testDowncall(String fName, Ret ret, List paramTypes, List fields) throws Throwable {
+        List> checks = new ArrayList<>();
+        List segments = new ArrayList<>();
+        LibraryLookup.Symbol addr = lib.lookup(fName).get();
+        MethodHandle mh = abi.downcallHandle(addr, methodType(ret, paramTypes, fields), function(ret, paramTypes, fields));
+        Object[] args = makeArgs(paramTypes, fields, checks, segments);
+        mh = mh.asSpreader(Object[].class, paramTypes.size());
+        Object res = mh.invoke(args);
+        if (ret == Ret.NON_VOID) {
+            checks.forEach(c -> c.accept(res));
+        }
+        segments.forEach(MemorySegment::close);
+    }
+
+    static MethodType methodType(Ret ret, List params, List fields) {
+        MethodType mt = ret == Ret.VOID ?
+                MethodType.methodType(void.class) : MethodType.methodType(paramCarrier(params.get(0).layout(fields)));
+        for (ParamType p : params) {
+            mt = mt.appendParameterTypes(paramCarrier(p.layout(fields)));
+        }
+        return mt;
+    }
+
+    static FunctionDescriptor function(Ret ret, List params, List fields) {
+        MemoryLayout[] paramLayouts = params.stream().map(p -> p.layout(fields)).toArray(MemoryLayout[]::new);
+        return ret == Ret.VOID ?
+                FunctionDescriptor.ofVoid(paramLayouts) :
+                FunctionDescriptor.of(paramLayouts[0], paramLayouts);
+    }
+
+    static Object[] makeArgs(List params, List fields, List> checks, List segments) throws ReflectiveOperationException {
+        Object[] args = new Object[params.size()];
+        for (int i = 0 ; i < params.size() ; i++) {
+            args[i] = makeArg(params.get(i).layout(fields), checks, i == 0, segments);
+        }
+        return args;
+    }
+}
diff --git a/test/jdk/java/foreign/TestFree.java b/test/jdk/java/foreign/TestFree.java
new file mode 100644
index 0000000000000..a8a32c5096278
--- /dev/null
+++ b/test/jdk/java/foreign/TestFree.java
@@ -0,0 +1,53 @@
+/*
+ *  Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ *  This code is free software; you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License version 2 only, as
+ *  published by the Free Software Foundation.
+ *
+ *  This code 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
+ *  version 2 for more details (a copy is included in the LICENSE file that
+ *  accompanied this code).
+ *
+ *  You should have received a copy of the GNU General Public License version
+ *  2 along with this work; if not, write to the Free Software Foundation,
+ *  Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ *   Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ *  or visit www.oracle.com if you need additional information or have any
+ *  questions.
+ *
+ */
+
+/*
+ * @test
+ * @bug 8248421
+ * @summary SystemCLinker should have a way to free memory allocated outside Java
+ * @run testng/othervm -Dforeign.restricted=permit TestFree
+ */
+
+import jdk.incubator.foreign.MemoryAccess;
+import jdk.incubator.foreign.MemoryAddress;
+import jdk.incubator.foreign.MemoryLayout;
+import jdk.incubator.foreign.MemorySegment;
+import static jdk.incubator.foreign.CLinker.*;
+import static org.testng.Assert.assertEquals;
+
+public class TestFree {
+    private static MemorySegment asArrayRestricted(MemoryAddress addr, MemoryLayout layout, int numElements) {
+        return addr.asSegmentRestricted(numElements * layout.byteSize());
+    }
+
+    public void test() throws Throwable {
+        String str = "hello world";
+        MemoryAddress addr = allocateMemoryRestricted(str.length() + 1);
+        MemorySegment seg = asArrayRestricted(addr, C_CHAR, str.length() + 1);
+        seg.copyFrom(MemorySegment.ofArray(str.getBytes()));
+        MemoryAccess.setByteAtOffset(seg, str.length(), (byte)0);
+        assertEquals(str, toJavaString(seg));
+        freeMemoryRestricted(addr);
+    }
+}
diff --git a/test/jdk/java/foreign/TestFunctionDescriptor.java b/test/jdk/java/foreign/TestFunctionDescriptor.java
new file mode 100644
index 0000000000000..44e21e5cdaf90
--- /dev/null
+++ b/test/jdk/java/foreign/TestFunctionDescriptor.java
@@ -0,0 +1,147 @@
+/*
+ *  Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ *  This code is free software; you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License version 2 only, as
+ *  published by the Free Software Foundation.
+ *
+ *  This code 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
+ *  version 2 for more details (a copy is included in the LICENSE file that
+ *  accompanied this code).
+ *
+ *  You should have received a copy of the GNU General Public License version
+ *  2 along with this work; if not, write to the Free Software Foundation,
+ *  Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ *   Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ *  or visit www.oracle.com if you need additional information or have any
+ *  questions.
+ *
+ */
+
+/*
+ * @test
+ * @run testng TestFunctionDescriptor
+ */
+
+import jdk.incubator.foreign.FunctionDescriptor;
+import jdk.incubator.foreign.MemoryLayout;
+import org.testng.annotations.Test;
+
+import java.lang.constant.Constable;
+import java.lang.constant.ConstantDesc;
+import java.lang.invoke.MethodHandles;
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+import static jdk.incubator.foreign.CLinker.C_DOUBLE;
+import static jdk.incubator.foreign.CLinker.C_INT;
+import static jdk.incubator.foreign.CLinker.C_LONGLONG;
+import static jdk.incubator.foreign.CLinker.C_POINTER;
+import static org.testng.Assert.assertEquals;
+import static org.testng.Assert.assertFalse;
+import static org.testng.Assert.assertTrue;
+
+public class TestFunctionDescriptor {
+
+    static final String DUMMY_ATTR = "dummy";
+
+    @Test
+    public void testOf() {
+        FunctionDescriptor fd = FunctionDescriptor.of(C_INT, C_DOUBLE, C_LONGLONG);
+
+        assertEquals(fd.argumentLayouts(), List.of(C_DOUBLE, C_LONGLONG));
+        Optional returnLayoutOp = fd.returnLayout();
+        assertTrue(returnLayoutOp.isPresent());
+        assertEquals(returnLayoutOp.get(), C_INT);
+    }
+
+    @Test
+    public void testOfVoid() {
+        FunctionDescriptor fd = FunctionDescriptor.ofVoid(C_DOUBLE, C_LONGLONG);
+
+        assertEquals(fd.argumentLayouts(), List.of(C_DOUBLE, C_LONGLONG));
+        Optional returnLayoutOp = fd.returnLayout();
+        assertFalse(returnLayoutOp.isPresent());
+    }
+
+    @Test
+    public void testAttribute() {
+        FunctionDescriptor fd = FunctionDescriptor.of(C_INT, C_DOUBLE, C_LONGLONG);
+        fd = fd.withAttribute(DUMMY_ATTR, true);
+
+        assertEquals(fd.argumentLayouts(), List.of(C_DOUBLE, C_LONGLONG));
+        Optional returnLayoutOp = fd.returnLayout();
+        assertTrue(returnLayoutOp.isPresent());
+        assertEquals(returnLayoutOp.get(), C_INT);
+        assertEquals(fd.attributes().collect(Collectors.toList()), List.of(DUMMY_ATTR));
+        Optional attr = fd.attribute(DUMMY_ATTR);
+        assertTrue(attr.isPresent());
+        assertEquals(attr.get(), true);
+    }
+
+    @Test
+    public void testAppendArgumentLayouts() {
+        FunctionDescriptor fd = FunctionDescriptor.of(C_INT, C_DOUBLE, C_LONGLONG)
+                                                  .withAttribute(DUMMY_ATTR, true);
+        fd = fd.appendArgumentLayouts(C_POINTER);
+
+        assertEquals(fd.argumentLayouts(), List.of(C_DOUBLE, C_LONGLONG, C_POINTER));
+        Optional returnLayoutOp = fd.returnLayout();
+        assertTrue(returnLayoutOp.isPresent());
+        assertEquals(returnLayoutOp.get(), C_INT);
+        assertEquals(fd.attributes().collect(Collectors.toList()), List.of(DUMMY_ATTR));
+    }
+
+    @Test
+    public void testChangeReturnLayout() {
+        FunctionDescriptor fd = FunctionDescriptor.of(C_INT, C_DOUBLE, C_LONGLONG)
+                                                  .withAttribute(DUMMY_ATTR, true);
+        fd = fd.changeReturnLayout(C_INT);
+
+        assertEquals(fd.argumentLayouts(), List.of(C_DOUBLE, C_LONGLONG));
+        Optional returnLayoutOp = fd.returnLayout();
+        assertTrue(returnLayoutOp.isPresent());
+        assertEquals(returnLayoutOp.get(), C_INT);
+        assertEquals(fd.attributes().collect(Collectors.toList()), List.of(DUMMY_ATTR));
+    }
+
+    @Test
+    public void testDropReturnLayout() {
+        FunctionDescriptor fd = FunctionDescriptor.of(C_INT, C_DOUBLE, C_LONGLONG)
+                                                  .withAttribute(DUMMY_ATTR, true);
+        fd = fd.dropReturnLayout();
+
+        assertEquals(fd.argumentLayouts(), List.of(C_DOUBLE, C_LONGLONG));
+        Optional returnLayoutOp = fd.returnLayout();
+        assertFalse(returnLayoutOp.isPresent());
+        assertEquals(fd.attributes().collect(Collectors.toList()), List.of(DUMMY_ATTR));
+    }
+
+    @Test(expectedExceptions = NullPointerException.class)
+    public void testNullArgumentLayout() {
+        FunctionDescriptor.ofVoid(C_INT, null, C_LONGLONG);
+    }
+
+    @Test(expectedExceptions = NullPointerException.class)
+    public void testNullReturnLayout() {
+        FunctionDescriptor.of(null, C_INT, C_LONGLONG);
+    }
+
+    @Test(expectedExceptions = NullPointerException.class)
+    public void testNullArgumentLayoutsAppend() {
+        FunctionDescriptor fd = FunctionDescriptor.ofVoid(C_INT, C_LONGLONG);
+        fd.appendArgumentLayouts(C_DOUBLE, null); // should throw
+    }
+
+    @Test(expectedExceptions = NullPointerException.class)
+    public void testNullReturnLayoutChange() {
+        FunctionDescriptor fd = FunctionDescriptor.ofVoid(C_INT, C_LONGLONG);
+        fd.changeReturnLayout(null); // should throw
+    }
+
+}
diff --git a/test/jdk/java/foreign/TestIllegalLink.java b/test/jdk/java/foreign/TestIllegalLink.java
new file mode 100644
index 0000000000000..0164794bf98d7
--- /dev/null
+++ b/test/jdk/java/foreign/TestIllegalLink.java
@@ -0,0 +1,112 @@
+/*
+ *  Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
+ *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ *  This code is free software; you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License version 2 only, as
+ *  published by the Free Software Foundation.
+ *
+ *  This code 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
+ *  version 2 for more details (a copy is included in the LICENSE file that
+ *  accompanied this code).
+ *
+ *  You should have received a copy of the GNU General Public License version
+ *  2 along with this work; if not, write to the Free Software Foundation,
+ *  Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ *   Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ *  or visit www.oracle.com if you need additional information or have any
+ *  questions.
+ *
+ */
+
+/*
+ * @test
+ *
+ * @run testng/othervm -Dforeign.restricted=permit TestIllegalLink
+ */
+
+import jdk.incubator.foreign.CLinker;
+import jdk.incubator.foreign.FunctionDescriptor;
+import jdk.incubator.foreign.MemoryAddress;
+import jdk.incubator.foreign.MemoryLayout;
+import jdk.incubator.foreign.MemoryLayouts;
+import jdk.incubator.foreign.MemorySegment;
+import org.testng.annotations.DataProvider;
+import org.testng.annotations.Test;
+
+import java.lang.invoke.MethodType;
+
+import static jdk.incubator.foreign.CLinker.C_INT;
+import static org.testng.Assert.assertTrue;
+import static org.testng.Assert.fail;
+
+public class TestIllegalLink {
+
+    private static final MemoryAddress dummyTarget = MemoryAddress.NULL;
+    private static final CLinker ABI = CLinker.getInstance();
+
+    @Test(dataProvider = "types")
+    public void testTypeMismatch(MethodType mt, FunctionDescriptor desc, String expectedExceptionMessage) {
+        try {
+            ABI.downcallHandle(dummyTarget, mt, desc);
+            fail("Expected IllegalArgumentException was not thrown");
+        } catch (IllegalArgumentException e) {
+            assertTrue(e.getMessage().contains(expectedExceptionMessage));
+        }
+    }
+
+    @DataProvider
+    public static Object[][] types() {
+        return new Object[][]{
+            {
+                MethodType.methodType(void.class),
+                FunctionDescriptor.of(C_INT),
+                "Return type mismatch"
+            },
+            {
+                MethodType.methodType(void.class),
+                FunctionDescriptor.ofVoid(C_INT),
+                "Arity mismatch"
+            },
+            {
+                MethodType.methodType(void.class, int.class),
+                FunctionDescriptor.ofVoid(MemoryLayout.ofPaddingBits(32)),
+                "Expected a ValueLayout"
+            },
+            {
+                MethodType.methodType(void.class, boolean.class),
+                FunctionDescriptor.ofVoid(MemoryLayouts.BITS_8_LE),
+                "Unsupported carrier"
+            },
+            {
+                MethodType.methodType(void.class, int.class),
+                FunctionDescriptor.ofVoid(MemoryLayouts.BITS_64_LE),
+                "Carrier size mismatch"
+            },
+            {
+                MethodType.methodType(void.class, MemoryAddress.class),
+                FunctionDescriptor.ofVoid(MemoryLayout.ofPaddingBits(64)),
+                "Expected a ValueLayout"
+            },
+            {
+                MethodType.methodType(void.class, MemoryAddress.class),
+                FunctionDescriptor.ofVoid(MemoryLayouts.BITS_16_LE),
+                "Address size mismatch"
+            },
+            {
+                MethodType.methodType(void.class, MemorySegment.class),
+                FunctionDescriptor.ofVoid(MemoryLayouts.BITS_64_LE),
+                "Expected a GroupLayout"
+            },
+            {
+                MethodType.methodType(void.class, String.class),
+                FunctionDescriptor.ofVoid(MemoryLayouts.BITS_64_LE),
+                "Unsupported carrier"
+            },
+        };
+    }
+
+}
diff --git a/test/jdk/java/foreign/TestIntrinsics.java b/test/jdk/java/foreign/TestIntrinsics.java
new file mode 100644
index 0000000000000..3bb5dbb8011df
--- /dev/null
+++ b/test/jdk/java/foreign/TestIntrinsics.java
@@ -0,0 +1,137 @@
+/*
+ *  Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ *  This code is free software; you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License version 2 only, as
+ *  published by the Free Software Foundation.
+ *
+ *  This code 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
+ *  version 2 for more details (a copy is included in the LICENSE file that
+ *  accompanied this code).
+ *
+ *  You should have received a copy of the GNU General Public License version
+ *  2 along with this work; if not, write to the Free Software Foundation,
+ *  Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ *  Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ *  or visit www.oracle.com if you need additional information or have any
+ *  questions.
+ */
+
+/*
+ * @test
+ * @run testng/othervm
+ *   -Djdk.internal.foreign.ProgrammableInvoker.USE_SPEC=true
+ *   -Djdk.internal.foreign.ProgrammableInvoker.USE_INTRINSICS=true
+ *   -Dforeign.restricted=permit
+ *   -Xbatch
+ *   TestIntrinsics
+ */
+
+import jdk.incubator.foreign.CLinker;
+import jdk.incubator.foreign.FunctionDescriptor;
+import jdk.incubator.foreign.LibraryLookup;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodType;
+import java.util.ArrayList;
+import java.util.List;
+
+import jdk.incubator.foreign.MemoryLayout;
+import org.testng.annotations.*;
+
+import static java.lang.invoke.MethodType.methodType;
+import static jdk.incubator.foreign.CLinker.*;
+import static jdk.incubator.foreign.FunctionDescriptor.TRIVIAL_ATTRIBUTE_NAME;
+import static org.testng.Assert.assertEquals;
+
+public class TestIntrinsics {
+
+    static final CLinker abi = CLinker.getInstance();
+    static final LibraryLookup lookup = LibraryLookup.ofLibrary("Intrinsics");
+
+    private static MethodHandle linkIndentity(String name, Class carrier, MemoryLayout layout, boolean trivial) {
+        LibraryLookup.Symbol ma = lookup.lookup(name).orElseThrow();
+        MethodType mt = methodType(carrier, carrier);
+        FunctionDescriptor fd = FunctionDescriptor.of(layout, layout);
+        if (trivial) {
+            fd = fd.withAttribute(TRIVIAL_ATTRIBUTE_NAME, true);
+        }
+        return abi.downcallHandle(ma, mt, fd);
+    }
+
+    @Test(dataProvider = "tests")
+    public void testIntrinsics(RunnableX test) throws Throwable {
+        for (int i = 0; i < 20_000; i++) {
+            test.run();
+        }
+    }
+
+    private interface RunnableX {
+        void run() throws Throwable;
+    }
+
+    private interface AddTest {
+        void add(MethodHandle target, Object expectedResult, Object... args);
+    }
+
+    @DataProvider
+    public Object[][] tests() {
+        List testsList = new ArrayList<>();
+        AddTest tests = (mh, expectedResult, args) -> testsList.add(() -> {
+            Object actual = mh.invokeWithArguments(args);
+            assertEquals(actual, expectedResult);
+        });
+
+        { // empty
+            LibraryLookup.Symbol ma = lookup.lookup("empty").orElseThrow();
+            MethodType mt = methodType(void.class);
+            FunctionDescriptor fd = FunctionDescriptor.ofVoid();
+            tests.add(abi.downcallHandle(ma, mt, fd), null);
+            tests.add(abi.downcallHandle(ma, mt, fd.withAttribute(TRIVIAL_ATTRIBUTE_NAME, true)), null);
+        }
+
+        tests.add(linkIndentity("identity_char", byte.class, C_CHAR, false), (byte) 10, (byte) 10);
+        tests.add(linkIndentity("identity_char", byte.class, C_CHAR, true), (byte) 10, (byte) 10);
+        tests.add(linkIndentity("identity_short", short.class, C_SHORT, false), (short) 10, (short) 10);
+        tests.add(linkIndentity("identity_short", short.class, C_SHORT, true), (short) 10, (short) 10);
+        tests.add(linkIndentity("identity_int", int.class, C_INT, false), 10, 10);
+        tests.add(linkIndentity("identity_int", int.class, C_INT, true), 10, 10);
+        tests.add(linkIndentity("identity_long", long.class, C_LONGLONG, false), 10L, 10L);
+        tests.add(linkIndentity("identity_long", long.class, C_LONGLONG, true), 10L, 10L);
+        tests.add(linkIndentity("identity_float", float.class, C_FLOAT, false), 10F, 10F);
+        tests.add(linkIndentity("identity_float", float.class, C_FLOAT, true), 10F, 10F);
+        tests.add(linkIndentity("identity_double", double.class, C_DOUBLE, false), 10D, 10D);
+        tests.add(linkIndentity("identity_double", double.class, C_DOUBLE, true), 10D, 10D);
+
+        { // identity_va
+            LibraryLookup.Symbol ma = lookup.lookup("identity_va").orElseThrow();
+            MethodType mt = methodType(int.class, int.class, double.class, int.class, float.class, long.class);
+            FunctionDescriptor fd = FunctionDescriptor.of(C_INT, C_INT, asVarArg(C_DOUBLE),
+                    asVarArg(C_INT), asVarArg(C_FLOAT), asVarArg(C_LONGLONG));
+            tests.add(abi.downcallHandle(ma, mt, fd), 1, 1, 10D, 2, 3F, 4L);
+            tests.add(abi.downcallHandle(ma, mt, fd.withAttribute(TRIVIAL_ATTRIBUTE_NAME, true)), 1, 1, 10D, 2, 3F, 4L);
+        }
+
+        { // high_arity
+            MethodType baseMT = methodType(void.class, int.class, double.class, long.class, float.class, byte.class,
+                    short.class, char.class);
+            FunctionDescriptor baseFD = FunctionDescriptor.ofVoid(C_INT, C_DOUBLE, C_LONGLONG, C_FLOAT, C_CHAR,
+                    C_SHORT, C_SHORT);
+            Object[] args = {1, 10D, 2L, 3F, (byte) 0, (short) 13, 'a'};
+            for (int i = 0; i < args.length; i++) {
+                LibraryLookup.Symbol ma = lookup.lookup("invoke_high_arity" + i).orElseThrow();
+                MethodType mt = baseMT.changeReturnType(baseMT.parameterType(i));
+                FunctionDescriptor fd = baseFD.changeReturnLayout(baseFD.argumentLayouts().get(i));
+                Object expected = args[i];
+                tests.add(abi.downcallHandle(ma, mt, fd), expected, args);
+                tests.add(abi.downcallHandle(ma, mt, fd.withAttribute(TRIVIAL_ATTRIBUTE_NAME, true)), expected, args);
+            }
+        }
+
+        return testsList.stream().map(rx -> new Object[]{ rx }).toArray(Object[][]::new);
+    }
+}
diff --git a/test/jdk/java/foreign/TestLayoutEquality.java b/test/jdk/java/foreign/TestLayoutEquality.java
new file mode 100644
index 0000000000000..3549d91c33f17
--- /dev/null
+++ b/test/jdk/java/foreign/TestLayoutEquality.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ *
+ */
+
+/*
+ * @test
+ * @modules jdk.incubator.foreign/jdk.internal.foreign
+ *
+ * @run testng TestLayoutEquality
+ */
+
+import jdk.incubator.foreign.MemoryLayout;
+import jdk.incubator.foreign.ValueLayout;
+import jdk.internal.foreign.PlatformLayouts;
+import org.testng.annotations.DataProvider;
+import org.testng.annotations.Test;
+
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.testng.Assert.*;
+
+public class TestLayoutEquality {
+
+    @Test(dataProvider = "layoutConstants")
+    public void testReconstructedEquality(ValueLayout layout) {
+        ValueLayout newLayout = MemoryLayout.ofValueBits(layout.bitSize(), layout.order());
+
+        // properties should be equal
+        assertEquals(newLayout.bitSize(), layout.bitSize());
+        assertEquals(newLayout.bitAlignment(), layout.bitAlignment());
+        assertEquals(newLayout.name(), layout.name());
+        assertEquals(newLayout.attributes().toArray().length, 0);
+        assertEquals(layout.attributes().toArray().length, 1);
+
+        // but equals should return false, because one is a ValueLayout with a CLinker kind
+        assertNotEquals(newLayout, layout);
+    }
+
+    @DataProvider
+    public static Object[][] layoutConstants() throws ReflectiveOperationException {
+        List testValues = new ArrayList<>();
+
+        addLayoutConstants(testValues, PlatformLayouts.SysV.class);
+        addLayoutConstants(testValues, PlatformLayouts.Win64.class);
+        addLayoutConstants(testValues, PlatformLayouts.AArch64.class);
+
+        return testValues.stream().map(e -> new Object[]{ e }).toArray(Object[][]::new);
+    }
+
+    private static void addLayoutConstants(List testValues, Class cls) throws ReflectiveOperationException {
+        for (Field f : cls.getFields()) {
+            if (f.getName().startsWith("C_"))
+                testValues.add((ValueLayout) f.get(null));
+        }
+    }
+
+}
diff --git a/test/jdk/java/foreign/TestLibraryLookup.java b/test/jdk/java/foreign/TestLibraryLookup.java
new file mode 100644
index 0000000000000..2c581434bfabf
--- /dev/null
+++ b/test/jdk/java/foreign/TestLibraryLookup.java
@@ -0,0 +1,167 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test
+ * @modules jdk.incubator.foreign/jdk.internal.foreign
+ * @run testng/othervm -Dforeign.restricted=permit TestLibraryLookup
+ */
+
+import jdk.incubator.foreign.LibraryLookup;
+import jdk.incubator.foreign.MemoryAddress;
+import jdk.internal.foreign.LibrariesHelper;
+import org.testng.annotations.Test;
+
+import java.lang.reflect.Field;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.testng.Assert.*;
+
+public class TestLibraryLookup {
+
+    @Test(expectedExceptions = IllegalArgumentException.class, expectedExceptionsMessageRegExp = "Library not found.*")
+    public void testInvalidLookupName() {
+        LibraryLookup.ofLibrary("NonExistent");
+    }
+
+    @Test(expectedExceptions = IllegalArgumentException.class, expectedExceptionsMessageRegExp = "Not an absolute path.*")
+    public void testNoAbsoluteLookupPath() {
+        LibraryLookup.ofPath(Path.of("NonExistent"));
+    }
+
+    @Test(expectedExceptions = IllegalArgumentException.class, expectedExceptionsMessageRegExp = "Library not found.*")
+    public void testInvalidLookupPath() {
+        LibraryLookup.ofPath(Path.of("NonExistent").toAbsolutePath());
+    }
+
+    @Test
+    public void testSimpleLookup() throws Throwable {
+        LibraryLookup.Symbol symbol = null;
+        LibraryLookup lookup = LibraryLookup.ofLibrary("LookupTest");
+        symbol = lookup.lookup("f").get();
+        assertEquals(symbol.name(), "f");
+        assertEquals(LibrariesHelper.numLoadedLibraries(), 1);
+        lookup = null;
+        symbol = null;
+        waitUnload();
+    }
+
+    @Test
+    public void testInvalidSymbolLookup() throws Throwable {
+        LibraryLookup.Symbol symbol = null;
+        LibraryLookup lookup = LibraryLookup.ofLibrary("LookupTest");
+        assertTrue(lookup.lookup("nonExistent").isEmpty());
+        assertEquals(LibrariesHelper.numLoadedLibraries(), 1);
+        lookup = null;
+        symbol = null;
+        waitUnload();
+    }
+
+    @Test
+    public void testMultiLookupSameLoader() throws Throwable {
+        List symbols = new ArrayList<>();
+        List lookups = new ArrayList<>();
+        for (int i = 0 ; i < 5 ; i++) {
+            LibraryLookup lookup = LibraryLookup.ofLibrary("LookupTest");
+            LibraryLookup.Symbol symbol = lookup.lookup("f").get();
+            lookups.add(lookup);
+            symbols.add(symbol);
+            assertEquals(LibrariesHelper.numLoadedLibraries(), 1);
+        }
+        lookups = null;
+        symbols = null;
+        waitUnload();
+    }
+
+    @Test
+    public void testMultiLookupDifferentLoaders() throws Throwable {
+        List loaders = new ArrayList<>();
+        for (int i = 0 ; i < 5 ; i++) {
+            URLClassLoader loader = new LocalLoader();
+            Class clazz = loader.loadClass("TestLibraryLookup$Holder");
+            Field field = clazz.getField("lookup");
+            field.setAccessible(true);
+            field.get(null); //make sure  is run
+            loaders.add(loader);
+        }
+        loaders.forEach(loader -> {
+            try {
+                loader.close();
+            } catch (Throwable ex) {
+                throw new AssertionError(ex);
+            }
+        });
+        loaders = null;
+        waitUnload();
+    }
+
+    static class LocalLoader extends URLClassLoader {
+        public LocalLoader() throws Exception {
+            super(new URL[] { Path.of(System.getProperty("test.classes")).toUri().toURL() });
+        }
+
+        @Override
+        public Class loadClass(String name) throws ClassNotFoundException {
+            Class clazz = findLoadedClass(name);
+            if (clazz == null) {
+                //try local first
+                try {
+                    clazz = findClass(name);
+                } catch (ClassNotFoundException e) {
+                    // Swallow exception - does not exist locally
+                }
+                //then try parent loader
+                if (clazz == null) {
+                    clazz = super.loadClass(name);
+                }
+            }
+            return clazz;
+        }
+    }
+
+    static class Holder {
+        public static LibraryLookup lookup;
+        public static LibraryLookup.Symbol symbol;
+
+        static {
+            try {
+                lookup = LibraryLookup.ofLibrary("LookupTest");
+                symbol = lookup.lookup("f").get();
+            } catch (Throwable ex) {
+                throw new ExceptionInInitializerError();
+            }
+        }
+    }
+
+    private static void waitUnload() throws InterruptedException {
+        while (LibrariesHelper.numLoadedLibraries() != 0) {
+            System.gc();
+            Object o = new Object[1000];
+            Thread.sleep(1);
+        }
+    }
+}
diff --git a/test/jdk/java/foreign/TestNativeScope.java b/test/jdk/java/foreign/TestNativeScope.java
new file mode 100644
index 0000000000000..fc0ebc1bb46f2
--- /dev/null
+++ b/test/jdk/java/foreign/TestNativeScope.java
@@ -0,0 +1,528 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ *  This code is free software; you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License version 2 only, as
+ *  published by the Free Software Foundation.
+ *
+ *  This code 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
+ *  version 2 for more details (a copy is included in the LICENSE file that
+ *  accompanied this code).
+ *
+ *  You should have received a copy of the GNU General Public License version
+ *  2 along with this work; if not, write to the Free Software Foundation,
+ *  Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ *   Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ *  or visit www.oracle.com if you need additional information or have any
+ *  questions.
+ *
+ */
+
+/*
+ * @test
+ * @run testng/othervm TestNativeScope
+ */
+
+import jdk.incubator.foreign.MemorySegment;
+import jdk.incubator.foreign.NativeScope;
+import jdk.incubator.foreign.MemoryHandles;
+import jdk.incubator.foreign.MemoryLayouts;
+import jdk.incubator.foreign.MemoryLayout;
+import jdk.incubator.foreign.MemoryAddress;
+
+import jdk.incubator.foreign.ValueLayout;
+import org.testng.annotations.*;
+
+import java.lang.invoke.VarHandle;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.DoubleBuffer;
+import java.nio.FloatBuffer;
+import java.nio.IntBuffer;
+import java.nio.LongBuffer;
+import java.nio.ShortBuffer;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.function.Function;
+import java.util.stream.IntStream;
+import java.util.stream.LongStream;
+
+import static jdk.incubator.foreign.MemorySegment.CLOSE;
+import static jdk.incubator.foreign.MemorySegment.HANDOFF;
+import static org.testng.Assert.*;
+
+public class TestNativeScope {
+
+    final static int ELEMS = 128;
+
+    @Test(dataProvider = "nativeScopes")
+    public  void testAllocation(Z value, ScopeFactory scopeFactory, ValueLayout layout, AllocationFunction allocationFunction, Function handleFactory) {
+        ValueLayout[] layouts = {
+                layout,
+                layout.withBitAlignment(layout.bitAlignment() * 2),
+                layout.withBitAlignment(layout.bitAlignment() * 4),
+                layout.withBitAlignment(layout.bitAlignment() * 8)
+        };
+        for (ValueLayout alignedLayout : layouts) {
+            List addressList = new ArrayList<>();
+            int elems = ELEMS / ((int)alignedLayout.byteAlignment() / (int)layout.byteAlignment());
+            try (NativeScope scope = scopeFactory.make((int)alignedLayout.byteSize() * ELEMS)) {
+                for (int i = 0 ; i < elems ; i++) {
+                    MemorySegment address = allocationFunction.allocate(scope, alignedLayout, value);
+                    assertEquals(address.byteSize(), alignedLayout.byteSize());
+                    addressList.add(address);
+                    VarHandle handle = handleFactory.apply(alignedLayout);
+                    assertEquals(value, handle.get(address));
+                    try {
+                        address.close();
+                        fail();
+                    } catch (UnsupportedOperationException uoe) {
+                        //failure is expected
+                        assertTrue(true);
+                    }
+                }
+                boolean isBound = scope.byteSize().isPresent();
+                try {
+                    allocationFunction.allocate(scope, alignedLayout, value); //too much, should fail if bound
+                    assertFalse(isBound);
+                } catch (OutOfMemoryError ex) {
+                    //failure is expected if bound
+                    assertTrue(isBound);
+                }
+            }
+            // addresses should be invalid now
+            for (MemorySegment address : addressList) {
+                assertFalse(address.isAlive());
+            }
+        }
+    }
+
+    static final int SIZE_256M = 1024 * 1024 * 256;
+
+    @Test
+    public void testBigAllocationInUnboundedScope() {
+        try (NativeScope scope = NativeScope.unboundedScope()) {
+            for (int i = 8 ; i < SIZE_256M ; i *= 8) {
+                MemorySegment address = scope.allocate(i);
+                //check size
+                assertEquals(address.byteSize(), i);
+                //check alignment
+                assertTrue(address.address().toRawLongValue() % i == 0);
+            }
+        }
+    }
+
+    @Test
+    public void testAttachClose() {
+        MemorySegment s1 = MemorySegment.ofArray(new byte[1]);
+        MemorySegment s2 = MemorySegment.ofArray(new byte[1]);
+        MemorySegment s3 = MemorySegment.ofArray(new byte[1]);
+        assertTrue(s1.isAlive());
+        assertTrue(s2.isAlive());
+        assertTrue(s3.isAlive());
+        try (NativeScope scope = NativeScope.boundedScope(10)) {
+            MemorySegment ss1 = s1.handoff(scope);
+            assertFalse(s1.isAlive());
+            assertTrue(ss1.isAlive());
+            s1 = ss1;
+            MemorySegment ss2 = s2.handoff(scope);
+            assertFalse(s2.isAlive());
+            assertTrue(ss2.isAlive());
+            s2 = ss2;
+            MemorySegment ss3 = s3.handoff(scope);
+            assertFalse(s3.isAlive());
+            assertTrue(ss3.isAlive());
+            s3 = ss3;
+        }
+        assertFalse(s1.isAlive());
+        assertFalse(s2.isAlive());
+        assertFalse(s3.isAlive());
+    }
+
+    @Test
+    public void testNoTerminalOps() {
+        try (NativeScope scope = NativeScope.boundedScope(10)) {
+            MemorySegment s1 = MemorySegment.ofArray(new byte[1]);
+            MemorySegment attached = s1.handoff(scope);
+            int[] terminalOps = {CLOSE, HANDOFF};
+            for (int mode : terminalOps) {
+                if (attached.hasAccessModes(mode)) {
+                    fail();
+                }
+            }
+        }
+    }
+
+    @Test(expectedExceptions = UnsupportedOperationException.class)
+    public void testNoReattach() {
+        MemorySegment s1 = MemorySegment.ofArray(new byte[1]);
+        NativeScope scope1 = NativeScope.boundedScope(10);
+        NativeScope scope2 = NativeScope.boundedScope(10);
+        s1.handoff(scope1).handoff(scope2);
+    }
+
+    @Test(expectedExceptions = NullPointerException.class)
+    public void testNullClaim() {
+        MemorySegment.ofArray(new byte[5]).handoff((NativeScope)null);
+    }
+
+    @Test(expectedExceptions = IllegalStateException.class)
+    public void testNotAliveClaim() {
+        MemorySegment segment = MemorySegment.ofArray(new byte[1]);
+        segment.close();
+        segment.handoff(NativeScope.boundedScope(10));
+    }
+
+    @Test
+    public void testRegisterFromUnconfined() {
+        MemorySegment unconfined = MemorySegment.allocateNative(10).share();
+        NativeScope scope = NativeScope.boundedScope(10);
+        MemorySegment registered = unconfined.handoff(scope);
+        assertFalse(unconfined.isAlive());
+        assertEquals(registered.ownerThread(), scope.ownerThread());
+        scope.close();
+        assertFalse(registered.isAlive());
+    }
+
+    @Test(dataProvider = "arrayScopes")
+    public  void testArray(ScopeFactory scopeFactory, ValueLayout layout, AllocationFunction allocationFunction, ToArrayHelper arrayHelper) {
+        Z arr = arrayHelper.array();
+        try (NativeScope scope = scopeFactory.make(100)) {
+            MemorySegment address = allocationFunction.allocate(scope, layout, arr);
+            Z found = arrayHelper.toArray(address, layout);
+            assertEquals(found, arr);
+        }
+    }
+
+    @DataProvider(name = "nativeScopes")
+    static Object[][] nativeScopes() {
+        return new Object[][] {
+                { (byte)42, (ScopeFactory) NativeScope::boundedScope, MemoryLayouts.BITS_8_BE,
+                        (AllocationFunction) NativeScope::allocate,
+                        (Function)l -> l.varHandle(byte.class) },
+                { (short)42, (ScopeFactory) NativeScope::boundedScope, MemoryLayouts.BITS_16_BE,
+                        (AllocationFunction) NativeScope::allocate,
+                        (Function)l -> l.varHandle(short.class) },
+                { 42, (ScopeFactory) NativeScope::boundedScope,
+                        MemoryLayouts.BITS_32_BE,
+                        (AllocationFunction) NativeScope::allocate,
+                        (Function)l -> l.varHandle(int.class) },
+                { 42f, (ScopeFactory) NativeScope::boundedScope, MemoryLayouts.BITS_32_BE,
+                        (AllocationFunction) NativeScope::allocate,
+                        (Function)l -> l.varHandle(float.class) },
+                { 42L, (ScopeFactory) NativeScope::boundedScope, MemoryLayouts.BITS_64_BE,
+                        (AllocationFunction) NativeScope::allocate,
+                        (Function)l -> l.varHandle(long.class) },
+                { 42d, (ScopeFactory) NativeScope::boundedScope, MemoryLayouts.BITS_64_BE,
+                        (AllocationFunction) NativeScope::allocate,
+                        (Function)l -> l.varHandle(double.class) },
+                { MemoryAddress.ofLong(42), (ScopeFactory) NativeScope::boundedScope, MemoryLayouts.ADDRESS.withOrder(ByteOrder.BIG_ENDIAN),
+                        (AllocationFunction) NativeScope::allocate,
+                        (Function)l -> MemoryHandles.asAddressVarHandle(l.varHandle(long.class)) },
+
+                { (byte)42, (ScopeFactory) NativeScope::boundedScope, MemoryLayouts.BITS_8_LE,
+                        (AllocationFunction) NativeScope::allocate,
+                        (Function)l -> l.varHandle(byte.class) },
+                { (short)42, (ScopeFactory) NativeScope::boundedScope, MemoryLayouts.BITS_16_LE,
+                        (AllocationFunction) NativeScope::allocate,
+                        (Function)l -> l.varHandle(short.class) },
+                { 42, (ScopeFactory) NativeScope::boundedScope,
+                        MemoryLayouts.BITS_32_LE,
+                        (AllocationFunction) NativeScope::allocate,
+                        (Function)l -> l.varHandle(int.class) },
+                { 42f, (ScopeFactory) NativeScope::boundedScope, MemoryLayouts.BITS_32_LE,
+                        (AllocationFunction) NativeScope::allocate,
+                        (Function)l -> l.varHandle(float.class) },
+                { 42L, (ScopeFactory) NativeScope::boundedScope, MemoryLayouts.BITS_64_LE,
+                        (AllocationFunction) NativeScope::allocate,
+                        (Function)l -> l.varHandle(long.class) },
+                { 42d, (ScopeFactory) NativeScope::boundedScope, MemoryLayouts.BITS_64_LE,
+                        (AllocationFunction) NativeScope::allocate,
+                        (Function)l -> l.varHandle(double.class) },
+                { MemoryAddress.ofLong(42), (ScopeFactory) NativeScope::boundedScope, MemoryLayouts.ADDRESS.withOrder(ByteOrder.LITTLE_ENDIAN),
+                        (AllocationFunction) NativeScope::allocate,
+                        (Function)l -> MemoryHandles.asAddressVarHandle(l.varHandle(long.class)) },
+
+                { (byte)42, (ScopeFactory)size -> NativeScope.unboundedScope(), MemoryLayouts.BITS_8_BE,
+                        (AllocationFunction) NativeScope::allocate,
+                        (Function)l -> l.varHandle(byte.class) },
+                { (short)42, (ScopeFactory)size -> NativeScope.unboundedScope(), MemoryLayouts.BITS_16_BE,
+                        (AllocationFunction) NativeScope::allocate,
+                        (Function)l -> l.varHandle(short.class) },
+                { 42, (ScopeFactory)size -> NativeScope.unboundedScope(),
+                        MemoryLayouts.BITS_32_BE,
+                        (AllocationFunction) NativeScope::allocate,
+                        (Function)l -> l.varHandle(int.class) },
+                { 42f, (ScopeFactory)size -> NativeScope.unboundedScope(), MemoryLayouts.BITS_32_BE,
+                        (AllocationFunction) NativeScope::allocate,
+                        (Function)l -> l.varHandle(float.class) },
+                { 42L, (ScopeFactory)size -> NativeScope.unboundedScope(), MemoryLayouts.BITS_64_BE,
+                        (AllocationFunction) NativeScope::allocate,
+                        (Function)l -> l.varHandle(long.class) },
+                { 42d, (ScopeFactory)size -> NativeScope.unboundedScope(), MemoryLayouts.BITS_64_BE,
+                        (AllocationFunction) NativeScope::allocate,
+                        (Function)l -> l.varHandle(double.class) },
+                { MemoryAddress.ofLong(42), (ScopeFactory)size -> NativeScope.unboundedScope(), MemoryLayouts.ADDRESS.withOrder(ByteOrder.BIG_ENDIAN),
+                        (AllocationFunction) NativeScope::allocate,
+                        (Function)l -> MemoryHandles.asAddressVarHandle(l.varHandle(long.class)) },
+
+                { (byte)42, (ScopeFactory)size -> NativeScope.unboundedScope(), MemoryLayouts.BITS_8_LE,
+                        (AllocationFunction) NativeScope::allocate,
+                        (Function)l -> l.varHandle(byte.class) },
+                { (short)42, (ScopeFactory)size -> NativeScope.unboundedScope(), MemoryLayouts.BITS_16_LE,
+                        (AllocationFunction) NativeScope::allocate,
+                        (Function)l -> l.varHandle(short.class) },
+                { 42, (ScopeFactory)size -> NativeScope.unboundedScope(),
+                        MemoryLayouts.BITS_32_LE,
+                        (AllocationFunction) NativeScope::allocate,
+                        (Function)l -> l.varHandle(int.class) },
+                { 42f, (ScopeFactory)size -> NativeScope.unboundedScope(), MemoryLayouts.BITS_32_LE,
+                        (AllocationFunction) NativeScope::allocate,
+                        (Function)l -> l.varHandle(float.class) },
+                { 42L, (ScopeFactory)size -> NativeScope.unboundedScope(), MemoryLayouts.BITS_64_LE,
+                        (AllocationFunction) NativeScope::allocate,
+                        (Function)l -> l.varHandle(long.class) },
+                { 42d, (ScopeFactory)size -> NativeScope.unboundedScope(), MemoryLayouts.BITS_64_LE,
+                        (AllocationFunction) NativeScope::allocate,
+                        (Function)l -> l.varHandle(double.class) },
+                { MemoryAddress.ofLong(42), (ScopeFactory)size -> NativeScope.unboundedScope(), MemoryLayouts.ADDRESS.withOrder(ByteOrder.LITTLE_ENDIAN),
+                        (AllocationFunction) NativeScope::allocate,
+                        (Function)l -> MemoryHandles.asAddressVarHandle(l.varHandle(long.class)) },
+        };
+    }
+
+    @DataProvider(name = "arrayScopes")
+    static Object[][] arrayScopes() {
+        return new Object[][] {
+                { (ScopeFactory) NativeScope::boundedScope, MemoryLayouts.BITS_8_LE,
+                        (AllocationFunction) NativeScope::allocateArray,
+                        ToArrayHelper.toByteArray },
+                { (ScopeFactory) NativeScope::boundedScope, MemoryLayouts.BITS_16_LE,
+                        (AllocationFunction) NativeScope::allocateArray,
+                        ToArrayHelper.toShortArray },
+                { (ScopeFactory) NativeScope::boundedScope,
+                        MemoryLayouts.BITS_32_LE,
+                        (AllocationFunction) NativeScope::allocateArray,
+                        ToArrayHelper.toIntArray },
+                { (ScopeFactory) NativeScope::boundedScope, MemoryLayouts.BITS_32_LE,
+                        (AllocationFunction) NativeScope::allocateArray,
+                        ToArrayHelper.toFloatArray },
+                { (ScopeFactory) NativeScope::boundedScope, MemoryLayouts.BITS_64_LE,
+                        (AllocationFunction) NativeScope::allocateArray,
+                        ToArrayHelper.toLongArray },
+                { (ScopeFactory) NativeScope::boundedScope, MemoryLayouts.BITS_64_LE,
+                        (AllocationFunction) NativeScope::allocateArray,
+                        ToArrayHelper.toDoubleArray },
+                { (ScopeFactory) NativeScope::boundedScope, MemoryLayouts.ADDRESS.withOrder(ByteOrder.LITTLE_ENDIAN),
+                        (AllocationFunction) NativeScope::allocateArray,
+                        ToArrayHelper.toAddressArray },
+
+
+                { (ScopeFactory) NativeScope::boundedScope, MemoryLayouts.BITS_8_BE,
+                        (AllocationFunction) NativeScope::allocateArray,
+                        ToArrayHelper.toByteArray },
+                { (ScopeFactory) NativeScope::boundedScope, MemoryLayouts.BITS_16_BE,
+                        (AllocationFunction) NativeScope::allocateArray,
+                        ToArrayHelper.toShortArray },
+                { (ScopeFactory) NativeScope::boundedScope,
+                        MemoryLayouts.BITS_32_BE,
+                        (AllocationFunction) NativeScope::allocateArray,
+                        ToArrayHelper.toIntArray },
+                { (ScopeFactory) NativeScope::boundedScope, MemoryLayouts.BITS_32_BE,
+                        (AllocationFunction) NativeScope::allocateArray,
+                        ToArrayHelper.toFloatArray },
+                { (ScopeFactory) NativeScope::boundedScope, MemoryLayouts.BITS_64_BE,
+                        (AllocationFunction) NativeScope::allocateArray,
+                        ToArrayHelper.toLongArray },
+                { (ScopeFactory) NativeScope::boundedScope, MemoryLayouts.BITS_64_BE,
+                        (AllocationFunction) NativeScope::allocateArray,
+                        ToArrayHelper.toDoubleArray },
+                { (ScopeFactory) NativeScope::boundedScope, MemoryLayouts.ADDRESS.withOrder(ByteOrder.BIG_ENDIAN),
+                        (AllocationFunction) NativeScope::allocateArray,
+                        ToArrayHelper.toAddressArray },
+
+                { (ScopeFactory) size -> NativeScope.unboundedScope(), MemoryLayouts.BITS_8_LE,
+                        (AllocationFunction) NativeScope::allocateArray,
+                        ToArrayHelper.toByteArray },
+                { (ScopeFactory) size -> NativeScope.unboundedScope(), MemoryLayouts.BITS_16_LE,
+                        (AllocationFunction) NativeScope::allocateArray,
+                        ToArrayHelper.toShortArray },
+                { (ScopeFactory) size -> NativeScope.unboundedScope(),
+                        MemoryLayouts.BITS_32_LE,
+                        (AllocationFunction) NativeScope::allocateArray,
+                        ToArrayHelper.toIntArray },
+                { (ScopeFactory) size -> NativeScope.unboundedScope(), MemoryLayouts.BITS_32_LE,
+                        (AllocationFunction) NativeScope::allocateArray,
+                        ToArrayHelper.toFloatArray },
+                { (ScopeFactory) size -> NativeScope.unboundedScope(), MemoryLayouts.BITS_64_LE,
+                        (AllocationFunction) NativeScope::allocateArray,
+                        ToArrayHelper.toLongArray },
+                { (ScopeFactory) size -> NativeScope.unboundedScope(), MemoryLayouts.BITS_64_LE,
+                        (AllocationFunction) NativeScope::allocateArray,
+                        ToArrayHelper.toDoubleArray },
+                { (ScopeFactory)size -> NativeScope.unboundedScope(), MemoryLayouts.ADDRESS.withOrder(ByteOrder.LITTLE_ENDIAN),
+                        (AllocationFunction) NativeScope::allocateArray,
+                        ToArrayHelper.toAddressArray },
+
+
+                { (ScopeFactory) size -> NativeScope.unboundedScope(), MemoryLayouts.BITS_8_BE,
+                        (AllocationFunction) NativeScope::allocateArray,
+                        ToArrayHelper.toByteArray },
+                { (ScopeFactory) size -> NativeScope.unboundedScope(), MemoryLayouts.BITS_16_BE,
+                        (AllocationFunction) NativeScope::allocateArray,
+                        ToArrayHelper.toShortArray },
+                { (ScopeFactory) size -> NativeScope.unboundedScope(),
+                        MemoryLayouts.BITS_32_BE,
+                        (AllocationFunction) NativeScope::allocateArray,
+                        ToArrayHelper.toIntArray },
+                { (ScopeFactory) size -> NativeScope.unboundedScope(), MemoryLayouts.BITS_32_BE,
+                        (AllocationFunction) NativeScope::allocateArray,
+                        ToArrayHelper.toFloatArray },
+                { (ScopeFactory) size -> NativeScope.unboundedScope(), MemoryLayouts.BITS_64_BE,
+                        (AllocationFunction) NativeScope::allocateArray,
+                        ToArrayHelper.toLongArray },
+                { (ScopeFactory) size -> NativeScope.unboundedScope(), MemoryLayouts.BITS_64_BE,
+                        (AllocationFunction) NativeScope::allocateArray,
+                        ToArrayHelper.toDoubleArray },
+                { (ScopeFactory)size -> NativeScope.unboundedScope(), MemoryLayouts.ADDRESS.withOrder(ByteOrder.BIG_ENDIAN),
+                        (AllocationFunction) NativeScope::allocateArray,
+                        ToArrayHelper.toAddressArray },
+        };
+    }
+
+    interface AllocationFunction {
+        MemorySegment allocate(NativeScope scope, ValueLayout layout, X value);
+    }
+
+    interface ScopeFactory {
+        NativeScope make(int size);
+    }
+
+    interface ToArrayHelper {
+        T array();
+        T toArray(MemorySegment segment, ValueLayout layout);
+
+        ToArrayHelper toByteArray = new ToArrayHelper<>() {
+            @Override
+            public byte[] array() {
+                return new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
+            }
+
+            @Override
+            public byte[] toArray(MemorySegment segment, ValueLayout layout) {
+                ByteBuffer buffer = segment.asByteBuffer().order(layout.order());
+                byte[] found = new byte[buffer.limit()];
+                buffer.get(found);
+                return found;
+            }
+        };
+
+        ToArrayHelper toShortArray = new ToArrayHelper<>() {
+            @Override
+            public short[] array() {
+                return new short[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
+            }
+
+            @Override
+            public short[] toArray(MemorySegment segment, ValueLayout layout) {
+                ShortBuffer buffer = segment.asByteBuffer().order(layout.order()).asShortBuffer();
+                short[] found = new short[buffer.limit()];
+                buffer.get(found);
+                return found;
+            }
+        };
+
+        ToArrayHelper toIntArray = new ToArrayHelper<>() {
+            @Override
+            public int[] array() {
+                return new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
+            }
+
+            @Override
+            public int[] toArray(MemorySegment segment, ValueLayout layout) {
+                IntBuffer buffer = segment.asByteBuffer().order(layout.order()).asIntBuffer();
+                int[] found = new int[buffer.limit()];
+                buffer.get(found);
+                return found;
+            }
+        };
+
+        ToArrayHelper toFloatArray = new ToArrayHelper<>() {
+            @Override
+            public float[] array() {
+                return new float[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
+            }
+
+            @Override
+            public float[] toArray(MemorySegment segment, ValueLayout layout) {
+                FloatBuffer buffer = segment.asByteBuffer().order(layout.order()).asFloatBuffer();
+                float[] found = new float[buffer.limit()];
+                buffer.get(found);
+                return found;
+            }
+        };
+
+        ToArrayHelper toLongArray = new ToArrayHelper<>() {
+            @Override
+            public long[] array() {
+                return new long[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
+            }
+
+            @Override
+            public long[] toArray(MemorySegment segment, ValueLayout layout) {
+                LongBuffer buffer = segment.asByteBuffer().order(layout.order()).asLongBuffer();
+                long[] found = new long[buffer.limit()];
+                buffer.get(found);
+                return found;
+            }
+        };
+
+        ToArrayHelper toDoubleArray = new ToArrayHelper<>() {
+            @Override
+            public double[] array() {
+                return new double[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
+            }
+
+            @Override
+            public double[] toArray(MemorySegment segment, ValueLayout layout) {
+                DoubleBuffer buffer = segment.asByteBuffer().order(layout.order()).asDoubleBuffer();
+                double[] found = new double[buffer.limit()];
+                buffer.get(found);
+                return found;
+            }
+        };
+
+        ToArrayHelper toAddressArray = new ToArrayHelper<>() {
+            @Override
+            public MemoryAddress[] array() {
+                return switch ((int)MemoryLayouts.ADDRESS.byteSize()) {
+                    case 4 -> wrap(toIntArray.array());
+                    case 8 -> wrap(toLongArray.array());
+                    default -> throw new IllegalStateException("Cannot get here");
+                };
+            }
+
+            @Override
+            public MemoryAddress[] toArray(MemorySegment segment, ValueLayout layout) {
+                return switch ((int)layout.byteSize()) {
+                    case 4 -> wrap(toIntArray.toArray(segment, layout));
+                    case 8 -> wrap(toLongArray.toArray(segment, layout));
+                    default -> throw new IllegalStateException("Cannot get here");
+                };
+            }
+
+            private MemoryAddress[] wrap(int[] ints) {
+                return IntStream.of(ints).mapToObj(MemoryAddress::ofLong).toArray(MemoryAddress[]::new);
+            }
+
+            private MemoryAddress[] wrap(long[] ints) {
+                return LongStream.of(ints).mapToObj(MemoryAddress::ofLong).toArray(MemoryAddress[]::new);
+            }
+        };
+    }
+}
diff --git a/test/jdk/java/foreign/TestUpcall.java b/test/jdk/java/foreign/TestUpcall.java
new file mode 100644
index 0000000000000..04fa3f96ec8b7
--- /dev/null
+++ b/test/jdk/java/foreign/TestUpcall.java
@@ -0,0 +1,204 @@
+/*
+ * Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
+ *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ *  This code is free software; you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License version 2 only, as
+ *  published by the Free Software Foundation.
+ *
+ *  This code 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
+ *  version 2 for more details (a copy is included in the LICENSE file that
+ *  accompanied this code).
+ *
+ *  You should have received a copy of the GNU General Public License version
+ *  2 along with this work; if not, write to the Free Software Foundation,
+ *  Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ *   Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ *  or visit www.oracle.com if you need additional information or have any
+ *  questions.
+ *
+ */
+
+/*
+ * @test
+ * @modules jdk.incubator.foreign/jdk.internal.foreign
+ * @build NativeTestHelper CallGeneratorHelper TestUpcall
+ *
+ * @run testng/othervm
+ *   -Dforeign.restricted=permit
+ *   -Djdk.internal.foreign.ProgrammableInvoker.USE_SPEC=false
+ *   -Djdk.internal.foreign.ProgrammableInvoker.USE_INTRINSICS=false
+ *   TestUpcall
+ * @run testng/othervm
+ *   -Dforeign.restricted=permit
+ *   -Djdk.internal.foreign.ProgrammableInvoker.USE_SPEC=true
+ *   -Djdk.internal.foreign.ProgrammableInvoker.USE_INTRINSICS=false
+ *   TestUpcall
+ * @run testng/othervm
+ *   -Dforeign.restricted=permit
+ *   -Djdk.internal.foreign.ProgrammableInvoker.USE_SPEC=false
+ *   -Djdk.internal.foreign.ProgrammableInvoker.USE_INTRINSICS=true
+ *   TestUpcall
+ * @run testng/othervm
+ *   -Dforeign.restricted=permit
+ *   -Djdk.internal.foreign.ProgrammableInvoker.USE_SPEC=true
+ *   -Djdk.internal.foreign.ProgrammableInvoker.USE_INTRINSICS=true
+ *   TestUpcall
+ */
+
+import jdk.incubator.foreign.CLinker;
+import jdk.incubator.foreign.FunctionDescriptor;
+import jdk.incubator.foreign.LibraryLookup;
+import jdk.incubator.foreign.MemoryAddress;
+import jdk.incubator.foreign.MemoryLayout;
+import jdk.incubator.foreign.MemorySegment;
+import jdk.incubator.foreign.ValueLayout;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.Consumer;
+import java.util.stream.Collectors;
+
+import static java.lang.invoke.MethodHandles.insertArguments;
+import static jdk.incubator.foreign.CLinker.C_POINTER;
+import static org.testng.Assert.assertEquals;
+
+
+public class TestUpcall extends CallGeneratorHelper {
+
+    static LibraryLookup lib = LibraryLookup.ofLibrary("TestUpcall");
+    static CLinker abi = CLinker.getInstance();
+
+    static MethodHandle DUMMY;
+    static MethodHandle PASS_AND_SAVE;
+
+    static {
+        try {
+            DUMMY = MethodHandles.lookup().findStatic(TestUpcall.class, "dummy", MethodType.methodType(void.class));
+            PASS_AND_SAVE = MethodHandles.lookup().findStatic(TestUpcall.class, "passAndSave", MethodType.methodType(Object.class, Object[].class, AtomicReference.class));
+        } catch (Throwable ex) {
+            throw new IllegalStateException(ex);
+        }
+    }
+
+    static MemorySegment dummyStub;
+
+    @BeforeClass
+    void setup() {
+        dummyStub = abi.upcallStub(DUMMY, FunctionDescriptor.ofVoid());
+    }
+
+    @AfterClass
+    void teardown() {
+        dummyStub.close();
+    }
+
+    @Test(dataProvider="functions", dataProviderClass=CallGeneratorHelper.class)
+    public void testUpcalls(String fName, Ret ret, List paramTypes, List fields) throws Throwable {
+        List segments = new ArrayList<>();
+        List> returnChecks = new ArrayList<>();
+        List> argChecks = new ArrayList<>();
+        LibraryLookup.Symbol addr = lib.lookup(fName).get();
+        MethodHandle mh = abi.downcallHandle(addr, methodType(ret, paramTypes, fields), function(ret, paramTypes, fields));
+        Object[] args = makeArgs(ret, paramTypes, fields, returnChecks, argChecks, segments);
+        mh = mh.asSpreader(Object[].class, paramTypes.size() + 1);
+        Object res = mh.invoke(args);
+        argChecks.forEach(c -> c.accept(args));
+        if (ret == Ret.NON_VOID) {
+            returnChecks.forEach(c -> c.accept(res));
+        }
+        segments.forEach(MemorySegment::close);
+    }
+
+    static MethodType methodType(Ret ret, List params, List fields) {
+        MethodType mt = ret == Ret.VOID ?
+                MethodType.methodType(void.class) : MethodType.methodType(paramCarrier(params.get(0).layout(fields)));
+        for (ParamType p : params) {
+            mt = mt.appendParameterTypes(paramCarrier(p.layout(fields)));
+        }
+        mt = mt.appendParameterTypes(MemoryAddress.class); //the callback
+        return mt;
+    }
+
+    static FunctionDescriptor function(Ret ret, List params, List fields) {
+        List paramLayouts = params.stream().map(p -> p.layout(fields)).collect(Collectors.toList());
+        paramLayouts.add(C_POINTER); // the callback
+        MemoryLayout[] layouts = paramLayouts.toArray(new MemoryLayout[0]);
+        return ret == Ret.VOID ?
+                FunctionDescriptor.ofVoid(layouts) :
+                FunctionDescriptor.of(layouts[0], layouts);
+    }
+
+    static Object[] makeArgs(Ret ret, List params, List fields, List> checks, List> argChecks, List segments) throws ReflectiveOperationException {
+        Object[] args = new Object[params.size() + 1];
+        for (int i = 0 ; i < params.size() ; i++) {
+            args[i] = makeArg(params.get(i).layout(fields), checks, i == 0, segments);
+        }
+        args[params.size()] = makeCallback(ret, params, fields, checks, argChecks, segments);
+        return args;
+    }
+
+    @SuppressWarnings("unchecked")
+    static MemoryAddress makeCallback(Ret ret, List params, List fields, List> checks, List> argChecks, List segments) {
+        if (params.isEmpty()) {
+            return dummyStub.address();
+        }
+
+        AtomicReference box = new AtomicReference<>();
+        MethodHandle mh = insertArguments(PASS_AND_SAVE, 1, box);
+        mh = mh.asCollector(Object[].class, params.size());
+
+        for (int i = 0; i < params.size(); i++) {
+            ParamType pt = params.get(i);
+            MemoryLayout layout = pt.layout(fields);
+            Class carrier = paramCarrier(layout);
+            mh = mh.asType(mh.type().changeParameterType(i, carrier));
+
+            final int finalI = i;
+            if (carrier == MemorySegment.class) {
+                argChecks.add(o -> assertStructEquals((MemorySegment) box.get()[finalI], (MemorySegment) o[finalI], layout));
+            } else {
+                argChecks.add(o -> assertEquals(box.get()[finalI], o[finalI]));
+            }
+        }
+
+        ParamType firstParam = params.get(0);
+        MemoryLayout firstlayout = firstParam.layout(fields);
+        Class firstCarrier = paramCarrier(firstlayout);
+
+        if (firstCarrier == MemorySegment.class) {
+            checks.add(o -> assertStructEquals((MemorySegment) box.get()[0], (MemorySegment) o, firstlayout));
+        } else {
+            checks.add(o -> assertEquals(o, box.get()[0]));
+        }
+
+        mh = mh.asType(mh.type().changeReturnType(ret == Ret.VOID ? void.class : firstCarrier));
+
+        MemoryLayout[] paramLayouts = params.stream().map(p -> p.layout(fields)).toArray(MemoryLayout[]::new);
+        FunctionDescriptor func = ret != Ret.VOID
+                ? FunctionDescriptor.of(firstlayout, paramLayouts)
+                : FunctionDescriptor.ofVoid(paramLayouts);
+        MemorySegment stub = abi.upcallStub(mh, func);
+        segments.add(stub);
+        return stub.address();
+    }
+
+    static Object passAndSave(Object[] o, AtomicReference ref) {
+        ref.set(o);
+        return o[0];
+    }
+
+    static void dummy() {
+        //do nothing
+    }
+}
diff --git a/test/jdk/java/foreign/TestUpcallHighArity.java b/test/jdk/java/foreign/TestUpcallHighArity.java
new file mode 100644
index 0000000000000..97a2f7e063275
--- /dev/null
+++ b/test/jdk/java/foreign/TestUpcallHighArity.java
@@ -0,0 +1,159 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ *  This code is free software; you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License version 2 only, as
+ *  published by the Free Software Foundation.
+ *
+ *  This code 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
+ *  version 2 for more details (a copy is included in the LICENSE file that
+ *  accompanied this code).
+ *
+ *  You should have received a copy of the GNU General Public License version
+ *  2 along with this work; if not, write to the Free Software Foundation,
+ *  Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ *  Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ *  or visit www.oracle.com if you need additional information or have any
+ *  questions.
+ *
+ */
+
+/*
+ * @test
+ * @modules jdk.incubator.foreign/jdk.internal.foreign
+ * @build NativeTestHelper CallGeneratorHelper TestUpcallHighArity
+ *
+ * @run testng/othervm/native
+ *   -Dforeign.restricted=permit
+ *   -Djdk.internal.foreign.ProgrammableInvoker.USE_SPEC=false
+ *   -Djdk.internal.foreign.ProgrammableInvoker.USE_INTRINSICS=false
+ *   TestUpcallHighArity
+ * @run testng/othervm/native
+ *   -Dforeign.restricted=permit
+ *   -Djdk.internal.foreign.ProgrammableInvoker.USE_SPEC=true
+ *   -Djdk.internal.foreign.ProgrammableInvoker.USE_INTRINSICS=false
+ *   TestUpcallHighArity
+ * @run testng/othervm/native
+ *   -Dforeign.restricted=permit
+ *   -Djdk.internal.foreign.ProgrammableInvoker.USE_SPEC=false
+ *   -Djdk.internal.foreign.ProgrammableInvoker.USE_INTRINSICS=true
+ *   TestUpcallHighArity
+ * @run testng/othervm/native
+ *   -Dforeign.restricted=permit
+ *   -Djdk.internal.foreign.ProgrammableInvoker.USE_SPEC=true
+ *   -Djdk.internal.foreign.ProgrammableInvoker.USE_INTRINSICS=true
+ *   TestUpcallHighArity
+ */
+
+import jdk.incubator.foreign.CLinker;
+import jdk.incubator.foreign.FunctionDescriptor;
+import jdk.incubator.foreign.LibraryLookup;
+import jdk.incubator.foreign.MemoryAddress;
+import jdk.incubator.foreign.MemoryLayout;
+import jdk.incubator.foreign.MemorySegment;
+import org.testng.annotations.DataProvider;
+import org.testng.annotations.Test;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.Consumer;
+
+import static jdk.incubator.foreign.CLinker.*;
+import static org.testng.Assert.assertEquals;
+
+public class TestUpcallHighArity extends CallGeneratorHelper {
+    static final MethodHandle MH_do_upcall;
+    static final MethodHandle MH_passAndSave;
+    static final CLinker LINKER = CLinker.getInstance();
+
+    // struct S_PDI { void* p0; double p1; int p2; };
+    static final MemoryLayout S_PDI_LAYOUT = MemoryLayout.ofStruct(
+        C_POINTER.withName("p0"),
+        C_DOUBLE.withName("p1"),
+        C_INT.withName("p2")
+    );
+
+    static {
+        try {
+            LibraryLookup lookup = LibraryLookup.ofLibrary("TestUpcallHighArity");
+            MH_do_upcall = LINKER.downcallHandle(
+                lookup.lookup("do_upcall").get(),
+                MethodType.methodType(void.class, MemoryAddress.class,
+                    MemorySegment.class, int.class, double.class, MemoryAddress.class,
+                    MemorySegment.class, int.class, double.class, MemoryAddress.class,
+                    MemorySegment.class, int.class, double.class, MemoryAddress.class,
+                    MemorySegment.class, int.class, double.class, MemoryAddress.class),
+                FunctionDescriptor.ofVoid(C_POINTER,
+                    S_PDI_LAYOUT, C_INT, C_DOUBLE, C_POINTER,
+                    S_PDI_LAYOUT, C_INT, C_DOUBLE, C_POINTER,
+                    S_PDI_LAYOUT, C_INT, C_DOUBLE, C_POINTER,
+                    S_PDI_LAYOUT, C_INT, C_DOUBLE, C_POINTER)
+            );
+            MH_passAndSave = MethodHandles.lookup().findStatic(TestUpcallHighArity.class, "passAndSave",
+                    MethodType.methodType(void.class, Object[].class, AtomicReference.class));
+        } catch (ReflectiveOperationException e) {
+            throw new InternalError(e);
+        }
+    }
+
+    static void passAndSave(Object[] o, AtomicReference ref) {
+        ref.set(o);
+    }
+
+    @Test(dataProvider = "args")
+    public void testUpcall(MethodHandle downcall, MethodType upcallType,
+                           FunctionDescriptor upcallDescriptor) throws Throwable {
+        AtomicReference capturedArgs = new AtomicReference<>();
+        MethodHandle target = MethodHandles.insertArguments(MH_passAndSave, 1, capturedArgs)
+                                         .asCollector(Object[].class, upcallType.parameterCount())
+                                         .asType(upcallType);
+        try (MemorySegment upcallStub = LINKER.upcallStub(target, upcallDescriptor)) {
+            List segments = new ArrayList<>();
+            Object[] args = new Object[upcallType.parameterCount() + 1];
+            args[0] = upcallStub.address();
+            List argLayouts = upcallDescriptor.argumentLayouts();
+            for (int i = 1; i < args.length; i++) {
+                args[i] = makeArg(argLayouts.get(i - 1), null, false, segments);
+            }
+
+            downcall.invokeWithArguments(args);
+
+            Object[] capturedArgsArr = capturedArgs.get();
+            for (int i = 0; i < capturedArgsArr.length; i++) {
+                if (upcallType.parameterType(i) == MemorySegment.class) {
+                    assertStructEquals((MemorySegment) capturedArgsArr[i], (MemorySegment) args[i + 1], argLayouts.get(i));
+                } else {
+                    assertEquals(capturedArgsArr[i], args[i + 1]);
+                }
+            }
+            segments.forEach(MemorySegment::close);
+        }
+    }
+
+    @DataProvider
+    public static Object[][] args() {
+        return new Object[][]{
+            { MH_do_upcall,
+                MethodType.methodType(void.class,
+                    MemorySegment.class, int.class, double.class, MemoryAddress.class,
+                    MemorySegment.class, int.class, double.class, MemoryAddress.class,
+                    MemorySegment.class, int.class, double.class, MemoryAddress.class,
+                    MemorySegment.class, int.class, double.class, MemoryAddress.class),
+                FunctionDescriptor.ofVoid(
+                    S_PDI_LAYOUT, C_INT, C_DOUBLE, C_POINTER,
+                    S_PDI_LAYOUT, C_INT, C_DOUBLE, C_POINTER,
+                    S_PDI_LAYOUT, C_INT, C_DOUBLE, C_POINTER,
+                    S_PDI_LAYOUT, C_INT, C_DOUBLE, C_POINTER)
+            }
+        };
+    }
+
+}
diff --git a/test/jdk/java/foreign/TestUpcallStubs.java b/test/jdk/java/foreign/TestUpcallStubs.java
new file mode 100644
index 0000000000000..f519423d725f7
--- /dev/null
+++ b/test/jdk/java/foreign/TestUpcallStubs.java
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ *  This code is free software; you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License version 2 only, as
+ *  published by the Free Software Foundation.
+ *
+ *  This code 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
+ *  version 2 for more details (a copy is included in the LICENSE file that
+ *  accompanied this code).
+ *
+ *  You should have received a copy of the GNU General Public License version
+ *  2 along with this work; if not, write to the Free Software Foundation,
+ *  Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ *   Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ *  or visit www.oracle.com if you need additional information or have any
+ *  questions.
+ *
+ */
+
+/*
+ * @test
+ * @run testng/othervm -Dforeign.restricted=permit TestUpcallStubs
+ */
+
+import jdk.incubator.foreign.CLinker;
+import jdk.incubator.foreign.FunctionDescriptor;
+import jdk.incubator.foreign.MemoryAddress;
+import jdk.incubator.foreign.MemorySegment;
+import org.testng.annotations.*;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
+import java.lang.invoke.VarHandle;
+
+import static jdk.incubator.foreign.MemoryLayouts.JAVA_INT;
+import static org.testng.Assert.assertFalse;
+
+public class TestUpcallStubs {
+
+    static final CLinker abi = CLinker.getInstance();
+    static final MethodHandle MH_dummy;
+
+    static {
+        try {
+            MH_dummy = MethodHandles.lookup()
+                .findStatic(TestUpcallStubs.class, "dummy", MethodType.methodType(void.class));
+        } catch (NoSuchMethodException | IllegalAccessException e) {
+            throw new BootstrapMethodError(e);
+        }
+    }
+
+    private static MemorySegment getStub() {
+        return abi.upcallStub(MH_dummy, FunctionDescriptor.ofVoid());
+    }
+
+    @Test(expectedExceptions = UnsupportedOperationException.class)
+    public void testNoAccess() {
+        try (MemorySegment stub = getStub()) {
+            VarHandle vh = JAVA_INT.varHandle(int.class);
+            vh.set(stub, 10);
+        }
+    }
+
+    @Test
+    public void testFree() {
+        MemorySegment stub = getStub();
+        stub.close();
+        assertFalse(stub.isAlive());
+    }
+
+    @Test(expectedExceptions = IllegalStateException.class)
+    public void testAlreadyFreed() {
+        MemorySegment stub = getStub();
+        stub.close();
+        stub.close(); // should fail
+    }
+
+    @DataProvider
+    public static Object[][] badAddresses() {
+        return new Object[][]{
+            { MemoryAddress.ofLong(42) /* random address */ },
+            { MemorySegment.ofArray(new int []{ 1, 2, 3 }).address() /* heap address */ }
+        };
+    }
+
+    // where
+    public static void dummy() {}
+
+}
diff --git a/test/jdk/java/foreign/TestVarArgs.java b/test/jdk/java/foreign/TestVarArgs.java
new file mode 100644
index 0000000000000..87032561d3cb9
--- /dev/null
+++ b/test/jdk/java/foreign/TestVarArgs.java
@@ -0,0 +1,152 @@
+/*
+ * Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
+ *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ *  This code is free software; you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License version 2 only, as
+ *  published by the Free Software Foundation.
+ *
+ *  This code 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
+ *  version 2 for more details (a copy is included in the LICENSE file that
+ *  accompanied this code).
+ *
+ *  You should have received a copy of the GNU General Public License version
+ *  2 along with this work; if not, write to the Free Software Foundation,
+ *  Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ *   Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ *  or visit www.oracle.com if you need additional information or have any
+ *  questions.
+ *
+ */
+
+/*
+ * @test
+ * @run testng/othervm -Dforeign.restricted=permit TestVarArgs
+ */
+
+import jdk.incubator.foreign.CLinker;
+import jdk.incubator.foreign.FunctionDescriptor;
+import jdk.incubator.foreign.LibraryLookup;
+import jdk.incubator.foreign.MemoryAddress;
+import jdk.incubator.foreign.MemoryLayout;
+import jdk.incubator.foreign.MemorySegment;
+import jdk.incubator.foreign.ValueLayout;
+import org.testng.annotations.DataProvider;
+import org.testng.annotations.Test;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodType;
+import java.lang.invoke.VarHandle;
+import java.util.ArrayList;
+import java.util.List;
+
+import static jdk.incubator.foreign.CLinker.*;
+import static jdk.incubator.foreign.MemoryLayout.PathElement.*;
+import static org.testng.Assert.assertEquals;
+
+public class TestVarArgs {
+
+    static final MemoryLayout ML_CallInfo = MemoryLayout.ofStruct(
+            C_POINTER.withName("writeback"), // writeback
+            C_POINTER.withName("argIDs")); // arg ids
+
+    static final VarHandle VH_CallInfo_writeback = ML_CallInfo.varHandle(long.class, groupElement("writeback"));
+    static final VarHandle VH_CallInfo_argIDs = ML_CallInfo.varHandle(long.class, groupElement("argIDs"));
+
+    static final VarHandle VH_IntArray = MemoryLayout.ofSequence(C_INT).varHandle(int.class, sequenceElement());
+
+    static final CLinker abi = CLinker.getInstance();
+    static final LibraryLookup.Symbol varargsAddr = LibraryLookup.ofLibrary("VarArgs")
+            .lookup("varargs").get();
+
+    static final int WRITEBACK_BYTES_PER_ARG = 8;
+
+    @Test(dataProvider = "args")
+    public void testVarArgs(List args) throws Throwable {
+        try (MemorySegment writeBack = MemorySegment.allocateNative(args.size() * WRITEBACK_BYTES_PER_ARG);
+            MemorySegment callInfo = MemorySegment.allocateNative(ML_CallInfo);
+            MemorySegment argIDs = MemorySegment.allocateNative(MemoryLayout.ofSequence(args.size(), C_INT))) {
+
+            MemoryAddress callInfoPtr = callInfo.address();
+
+            VH_CallInfo_writeback.set(callInfo, writeBack.address().toRawLongValue());
+            VH_CallInfo_argIDs.set(callInfo, argIDs.address().toRawLongValue());
+
+            for (int i = 0; i < args.size(); i++) {
+                VH_IntArray.set(argIDs, (long) i, args.get(i).id.ordinal());
+            }
+
+            List argLayouts = new ArrayList<>();
+            argLayouts.add(C_POINTER); // call info
+            argLayouts.add(C_INT); // size
+            args.forEach(a -> argLayouts.add(asVarArg(a.layout)));
+
+            FunctionDescriptor desc = FunctionDescriptor.ofVoid(argLayouts.toArray(MemoryLayout[]::new));
+
+            List> carriers = new ArrayList<>();
+            carriers.add(MemoryAddress.class); // call info
+            carriers.add(int.class); // size
+            args.forEach(a -> carriers.add(a.carrier));
+
+            MethodType mt = MethodType.methodType(void.class, carriers);
+
+            MethodHandle downcallHandle = abi.downcallHandle(varargsAddr, mt, desc);
+
+            List argValues = new ArrayList<>();
+            argValues.add(callInfoPtr); // call info
+            argValues.add(args.size());  // size
+            args.forEach(a -> argValues.add(a.value));
+
+            downcallHandle.invokeWithArguments(argValues);
+
+            for (int i = 0; i < args.size(); i++) {
+                VarArg a = args.get(i);
+                MemorySegment writtenPtr = writeBack.asSlice(i * WRITEBACK_BYTES_PER_ARG);
+                Object written = a.vh.get(writtenPtr);
+                assertEquals(written, a.value);
+            }
+        }
+    }
+
+    @DataProvider
+    public static Object[][] args() {
+        return new Object[][] {
+            new Object[] { List.of(VarArg.intArg(5), VarArg.intArg(10), VarArg.intArg(15)) },
+            new Object[] { List.of(VarArg.doubleArg(5), VarArg.doubleArg(10), VarArg.doubleArg(15)) },
+            new Object[] { List.of(VarArg.intArg(5), VarArg.doubleArg(10), VarArg.intArg(15)) },
+        };
+    }
+
+    private static final class VarArg {
+        final NativeType id;
+        final Object value;
+        final ValueLayout layout;
+        final Class carrier;
+        final VarHandle vh;
+
+        private VarArg(NativeType id, ValueLayout layout, Class carrier, Object value) {
+            this.id = id;
+            this.value = value;
+            this.layout = layout;
+            this.carrier = carrier;
+            this.vh = layout.varHandle(carrier);
+        }
+
+        static VarArg intArg(int value) {
+            return new VarArg(VarArg.NativeType.INT, C_INT, int.class, value);
+        }
+
+        static VarArg doubleArg(double value) {
+            return new VarArg(VarArg.NativeType.DOUBLE, C_DOUBLE, double.class, value);
+        }
+
+        enum NativeType {
+            INT,
+            DOUBLE
+        }
+    }
+
+}
diff --git a/test/jdk/java/foreign/callarranger/CallArrangerTestBase.java b/test/jdk/java/foreign/callarranger/CallArrangerTestBase.java
new file mode 100644
index 0000000000000..76ee315fcf1fa
--- /dev/null
+++ b/test/jdk/java/foreign/callarranger/CallArrangerTestBase.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+import jdk.incubator.foreign.FunctionDescriptor;
+import jdk.incubator.foreign.MemoryLayout;
+import jdk.internal.foreign.abi.Binding;
+import jdk.internal.foreign.abi.CallingSequence;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import static org.testng.Assert.assertEquals;
+
+public class CallArrangerTestBase {
+
+    public static void checkArgumentBindings(CallingSequence callingSequence, Binding[][] argumentBindings) {
+        assertEquals(callingSequence.argumentCount(), argumentBindings.length);
+
+        for (int i = 0; i < callingSequence.argumentCount(); i++) {
+            List actual = callingSequence.argumentBindings(i);
+            Binding[] expected = argumentBindings[i];
+            assertEquals(actual, Arrays.asList(expected));
+        }
+    }
+
+    public static void checkReturnBindings(CallingSequence callingSequence, Binding[] returnBindings) {
+        assertEquals(callingSequence.returnBindings(), Arrays.asList(returnBindings));
+    }
+}
diff --git a/test/jdk/java/foreign/callarranger/TestAarch64CallArranger.java b/test/jdk/java/foreign/callarranger/TestAarch64CallArranger.java
new file mode 100644
index 0000000000000..8b5288b1d6fc0
--- /dev/null
+++ b/test/jdk/java/foreign/callarranger/TestAarch64CallArranger.java
@@ -0,0 +1,347 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ *  This code is free software; you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License version 2 only, as
+ *  published by the Free Software Foundation.
+ *
+ *  This code 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
+ *  version 2 for more details (a copy is included in the LICENSE file that
+ *  accompanied this code).
+ *
+ *  You should have received a copy of the GNU General Public License version
+ *  2 along with this work; if not, write to the Free Software Foundation,
+ *  Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ *   Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ *  or visit www.oracle.com if you need additional information or have any
+ *  questions.
+ *
+ */
+
+/*
+ * @test
+ * @modules jdk.incubator.foreign/jdk.internal.foreign
+ *          jdk.incubator.foreign/jdk.internal.foreign.abi
+ *          jdk.incubator.foreign/jdk.internal.foreign.abi.aarch64
+ * @build CallArrangerTestBase
+ * @run testng TestAarch64CallArranger
+ */
+
+import jdk.incubator.foreign.FunctionDescriptor;
+import jdk.incubator.foreign.MemoryAddress;
+import jdk.incubator.foreign.MemoryLayout;
+import jdk.incubator.foreign.MemorySegment;
+import jdk.internal.foreign.abi.Binding;
+import jdk.internal.foreign.abi.CallingSequence;
+import jdk.internal.foreign.abi.aarch64.CallArranger;
+import org.testng.annotations.DataProvider;
+import org.testng.annotations.Test;
+
+import java.lang.invoke.MethodType;
+
+import static jdk.internal.foreign.PlatformLayouts.AArch64.*;
+import static jdk.internal.foreign.abi.Binding.*;
+import static jdk.internal.foreign.abi.aarch64.AArch64Architecture.*;
+import static org.testng.Assert.assertEquals;
+import static org.testng.Assert.assertFalse;
+import static org.testng.Assert.assertTrue;
+
+public class TestAarch64CallArranger extends CallArrangerTestBase {
+
+    @Test
+    public void testEmpty() {
+        MethodType mt = MethodType.methodType(void.class);
+        FunctionDescriptor fd = FunctionDescriptor.ofVoid();
+        CallArranger.Bindings bindings = CallArranger.getBindings(mt, fd, false);
+
+        assertFalse(bindings.isInMemoryReturn);
+        CallingSequence callingSequence = bindings.callingSequence;
+        assertEquals(callingSequence.methodType(), mt);
+        assertEquals(callingSequence.functionDesc(), fd);
+
+        checkArgumentBindings(callingSequence, new Binding[][]{});
+
+        checkReturnBindings(callingSequence, new Binding[]{});
+    }
+
+    @Test
+    public void testInteger() {
+        MethodType mt = MethodType.methodType(void.class,
+                int.class, int.class, int.class, int.class,
+                int.class, int.class, int.class, int.class,
+                int.class, int.class);
+        FunctionDescriptor fd = FunctionDescriptor.ofVoid(
+                C_INT, C_INT, C_INT, C_INT,
+                C_INT, C_INT, C_INT, C_INT,
+                C_INT, C_INT);
+        CallArranger.Bindings bindings = CallArranger.getBindings(mt, fd, false);
+
+        assertFalse(bindings.isInMemoryReturn);
+        CallingSequence callingSequence = bindings.callingSequence;
+        assertEquals(callingSequence.methodType(), mt);
+        assertEquals(callingSequence.functionDesc(), fd);
+
+        checkArgumentBindings(callingSequence, new Binding[][]{
+            { vmStore(r0, int.class) },
+            { vmStore(r1, int.class) },
+            { vmStore(r2, int.class) },
+            { vmStore(r3, int.class) },
+            { vmStore(r4, int.class) },
+            { vmStore(r5, int.class) },
+            { vmStore(r6, int.class) },
+            { vmStore(r7, int.class) },
+            { vmStore(stackStorage(0), int.class) },
+            { vmStore(stackStorage(1), int.class) },
+        });
+
+        checkReturnBindings(callingSequence, new Binding[]{});
+    }
+
+    @Test
+    public void testTwoIntTwoFloat() {
+      MethodType mt = MethodType.methodType(void.class,
+                int.class, int.class, float.class, float.class);
+        FunctionDescriptor fd = FunctionDescriptor.ofVoid(
+                C_INT, C_INT, C_FLOAT, C_FLOAT);
+        CallArranger.Bindings bindings = CallArranger.getBindings(mt, fd, false);
+
+        assertFalse(bindings.isInMemoryReturn);
+        CallingSequence callingSequence = bindings.callingSequence;
+        assertEquals(callingSequence.methodType(), mt);
+        assertEquals(callingSequence.functionDesc(), fd);
+
+        checkArgumentBindings(callingSequence, new Binding[][]{
+            { vmStore(r0, int.class) },
+            { vmStore(r1, int.class) },
+            { vmStore(v0, float.class) },
+            { vmStore(v1, float.class) },
+        });
+
+        checkReturnBindings(callingSequence, new Binding[]{});
+    }
+
+    @Test(dataProvider = "structs")
+    public void testStruct(MemoryLayout struct, Binding[] expectedBindings) {
+        MethodType mt = MethodType.methodType(void.class, MemorySegment.class);
+        FunctionDescriptor fd = FunctionDescriptor.ofVoid(struct);
+        CallArranger.Bindings bindings = CallArranger.getBindings(mt, fd, false);
+
+        assertFalse(bindings.isInMemoryReturn);
+        CallingSequence callingSequence = bindings.callingSequence;
+        assertEquals(callingSequence.methodType(), mt);
+        assertEquals(callingSequence.functionDesc(), fd);
+
+        checkArgumentBindings(callingSequence, new Binding[][]{
+            expectedBindings
+        });
+
+        checkReturnBindings(callingSequence, new Binding[]{});
+    }
+
+    @DataProvider
+    public static Object[][] structs() {
+        MemoryLayout struct2 = MemoryLayout.ofStruct(C_INT, C_INT, C_DOUBLE, C_INT);
+        return new Object[][]{
+            // struct s { int32_t a, b; double c; };
+            { MemoryLayout.ofStruct(C_INT, C_INT, C_DOUBLE), new Binding[] {
+                dup(),
+                    // s.a & s.b
+                    bufferLoad(0, long.class), vmStore(r0, long.class),
+                    // s.c --> note AArch64 passes this in an *integer* register
+                    bufferLoad(8, long.class), vmStore(r1, long.class),
+            }},
+            // struct s { int32_t a, b; double c; int32_t d };
+            { struct2, new Binding[] {
+                copy(struct2),
+                baseAddress(),
+                unboxAddress(),
+                vmStore(r0, long.class)
+            }},
+            // struct s { int32_t a[2]; float b[2] };
+            { MemoryLayout.ofStruct(C_INT, C_INT, C_FLOAT, C_FLOAT), new Binding[] {
+                dup(),
+                    // s.a[0] & s.a[1]
+                    bufferLoad(0, long.class), vmStore(r0, long.class),
+                    // s.b[0] & s.b[1]
+                    bufferLoad(8, long.class), vmStore(r1, long.class),
+            }},
+            // struct s { float a; /* padding */ double b };
+            { MemoryLayout.ofStruct(C_FLOAT, MemoryLayout.ofPaddingBits(32), C_DOUBLE),
+              new Binding[] {
+                dup(),
+                // s.a
+                bufferLoad(0, long.class), vmStore(r0, long.class),
+                // s.b
+                bufferLoad(8, long.class), vmStore(r1, long.class),
+            }},
+        };
+    }
+
+    @Test
+    public void testMultipleStructs() {
+        MemoryLayout struct1 = MemoryLayout.ofStruct(C_INT, C_INT, C_DOUBLE, C_INT);
+        MemoryLayout struct2 = MemoryLayout.ofStruct(C_LONG, C_LONG, C_LONG);
+
+        MethodType mt = MethodType.methodType(void.class, MemorySegment.class, MemorySegment.class, int.class);
+        FunctionDescriptor fd = FunctionDescriptor.ofVoid(struct1, struct2, C_INT);
+        CallArranger.Bindings bindings = CallArranger.getBindings(mt, fd, false);
+
+        assertFalse(bindings.isInMemoryReturn);
+        CallingSequence callingSequence = bindings.callingSequence;
+        assertEquals(callingSequence.methodType(), mt);
+        assertEquals(callingSequence.functionDesc(), fd);
+
+        checkArgumentBindings(callingSequence, new Binding[][]{
+            {
+                copy(struct1),
+                baseAddress(),
+                unboxAddress(),
+                vmStore(r0, long.class)
+            },
+            {
+                copy(struct2),
+                baseAddress(),
+                unboxAddress(),
+                vmStore(r1, long.class)
+            },
+            { vmStore(r2, int.class) }
+        });
+
+        checkReturnBindings(callingSequence, new Binding[]{});
+    }
+
+    @Test
+    public void testReturnStruct1() {
+        MemoryLayout struct = MemoryLayout.ofStruct(C_LONG, C_LONG, C_FLOAT);
+
+        MethodType mt = MethodType.methodType(MemorySegment.class);
+        FunctionDescriptor fd = FunctionDescriptor.of(struct);
+        CallArranger.Bindings bindings = CallArranger.getBindings(mt, fd, false);
+
+        assertTrue(bindings.isInMemoryReturn);
+        CallingSequence callingSequence = bindings.callingSequence;
+        assertEquals(callingSequence.methodType(), MethodType.methodType(void.class, MemoryAddress.class));
+        assertEquals(callingSequence.functionDesc(), FunctionDescriptor.ofVoid(C_POINTER));
+
+        checkArgumentBindings(callingSequence, new Binding[][]{
+            {
+                unboxAddress(),
+                vmStore(r8, long.class)
+            }
+        });
+
+        checkReturnBindings(callingSequence, new Binding[]{});
+    }
+
+    @Test
+    public void testReturnStruct2() {
+        MemoryLayout struct = MemoryLayout.ofStruct(C_LONG, C_LONG);
+
+        MethodType mt = MethodType.methodType(MemorySegment.class);
+        FunctionDescriptor fd = FunctionDescriptor.of(struct);
+        CallArranger.Bindings bindings = CallArranger.getBindings(mt, fd, false);
+
+        assertFalse(bindings.isInMemoryReturn);
+        CallingSequence callingSequence = bindings.callingSequence;
+        assertEquals(callingSequence.methodType(), mt);
+        assertEquals(callingSequence.functionDesc(), fd);
+
+        checkArgumentBindings(callingSequence, new Binding[][]{});
+
+        checkReturnBindings(callingSequence, new Binding[]{
+            allocate(struct),
+            dup(),
+            vmLoad(r0, long.class),
+            bufferStore(0, long.class),
+            dup(),
+            vmLoad(r1, long.class),
+            bufferStore(8, long.class),
+        });
+    }
+
+    @Test
+    public void testStructHFA1() {
+        MemoryLayout hfa = MemoryLayout.ofStruct(C_FLOAT, C_FLOAT);
+
+        MethodType mt = MethodType.methodType(MemorySegment.class, float.class, int.class, MemorySegment.class);
+        FunctionDescriptor fd = FunctionDescriptor.of(hfa, C_FLOAT, C_INT, hfa);
+        CallArranger.Bindings bindings = CallArranger.getBindings(mt, fd, false);
+
+        assertFalse(bindings.isInMemoryReturn);
+        CallingSequence callingSequence = bindings.callingSequence;
+        assertEquals(callingSequence.methodType(), mt);
+        assertEquals(callingSequence.functionDesc(), fd);
+
+        checkArgumentBindings(callingSequence, new Binding[][]{
+            { vmStore(v0, float.class) },
+            { vmStore(r0, int.class) },
+            {
+                dup(),
+                bufferLoad(0, int.class),
+                vmStore(v1, int.class),
+                bufferLoad(4, int.class),
+                vmStore(v2, int.class)
+            }
+        });
+
+        checkReturnBindings(callingSequence, new Binding[]{
+            allocate(hfa),
+            dup(),
+            vmLoad(v0, int.class),
+            bufferStore(0, int.class),
+            dup(),
+            vmLoad(v1, int.class),
+            bufferStore(4, int.class),
+        });
+    }
+
+    @Test
+    public void testStructHFA3() {
+        MemoryLayout struct = MemoryLayout.ofStruct(C_FLOAT, C_FLOAT, C_FLOAT);
+
+        MethodType mt = MethodType.methodType(void.class, MemorySegment.class, MemorySegment.class, MemorySegment.class);
+        FunctionDescriptor fd = FunctionDescriptor.ofVoid(struct, struct, struct);
+        CallArranger.Bindings bindings = CallArranger.getBindings(mt, fd, false);
+
+        assertFalse(bindings.isInMemoryReturn);
+        CallingSequence callingSequence = bindings.callingSequence;
+        assertEquals(callingSequence.methodType(), mt);
+        assertEquals(callingSequence.functionDesc(), fd);
+
+        checkArgumentBindings(callingSequence, new Binding[][]{
+            {
+                dup(),
+                bufferLoad(0, int.class),
+                vmStore(v0, int.class),
+                dup(),
+                bufferLoad(4, int.class),
+                vmStore(v1, int.class),
+                bufferLoad(8, int.class),
+                vmStore(v2, int.class)
+            },
+            {
+                dup(),
+                bufferLoad(0, int.class),
+                vmStore(v3, int.class),
+                dup(),
+                bufferLoad(4, int.class),
+                vmStore(v4, int.class),
+                bufferLoad(8, int.class),
+                vmStore(v5, int.class)
+            },
+            {
+                dup(),
+                bufferLoad(0, long.class),
+                vmStore(stackStorage(0), long.class),
+                bufferLoad(8, int.class),
+                vmStore(stackStorage(1), int.class),
+            }
+        });
+
+        checkReturnBindings(callingSequence, new Binding[]{});
+    }
+}
diff --git a/test/jdk/java/foreign/callarranger/TestSysVCallArranger.java b/test/jdk/java/foreign/callarranger/TestSysVCallArranger.java
new file mode 100644
index 0000000000000..88d9bebd57a20
--- /dev/null
+++ b/test/jdk/java/foreign/callarranger/TestSysVCallArranger.java
@@ -0,0 +1,487 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ *  This code is free software; you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License version 2 only, as
+ *  published by the Free Software Foundation.
+ *
+ *  This code 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
+ *  version 2 for more details (a copy is included in the LICENSE file that
+ *  accompanied this code).
+ *
+ *  You should have received a copy of the GNU General Public License version
+ *  2 along with this work; if not, write to the Free Software Foundation,
+ *  Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ *   Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ *  or visit www.oracle.com if you need additional information or have any
+ *  questions.
+ *
+ */
+
+/*
+ * @test
+ * @modules jdk.incubator.foreign/jdk.internal.foreign
+ *          jdk.incubator.foreign/jdk.internal.foreign.abi
+ *          jdk.incubator.foreign/jdk.internal.foreign.abi.x64
+ *          jdk.incubator.foreign/jdk.internal.foreign.abi.x64.sysv
+ * @build CallArrangerTestBase
+ * @run testng TestSysVCallArranger
+ */
+
+import jdk.incubator.foreign.FunctionDescriptor;
+import jdk.incubator.foreign.MemoryAddress;
+import jdk.incubator.foreign.MemoryLayout;
+import jdk.incubator.foreign.MemorySegment;
+import jdk.internal.foreign.abi.Binding;
+import jdk.internal.foreign.abi.CallingSequence;
+import jdk.internal.foreign.abi.x64.sysv.CallArranger;
+import org.testng.annotations.DataProvider;
+import org.testng.annotations.Test;
+
+import java.lang.invoke.MethodType;
+
+import static jdk.internal.foreign.PlatformLayouts.SysV.*;
+import static jdk.internal.foreign.abi.Binding.*;
+import static jdk.internal.foreign.abi.x64.X86_64Architecture.*;
+import static org.testng.Assert.assertEquals;
+import static org.testng.Assert.assertFalse;
+import static org.testng.Assert.assertTrue;
+
+public class TestSysVCallArranger extends CallArrangerTestBase {
+
+    @Test
+    public void testEmpty() {
+        MethodType mt = MethodType.methodType(void.class);
+        FunctionDescriptor fd = FunctionDescriptor.ofVoid();
+        CallArranger.Bindings bindings = CallArranger.getBindings(mt, fd, false);
+
+        assertFalse(bindings.isInMemoryReturn);
+        CallingSequence callingSequence = bindings.callingSequence;
+        assertEquals(callingSequence.methodType(), mt.appendParameterTypes(long.class));
+        assertEquals(callingSequence.functionDesc(), fd.appendArgumentLayouts(C_LONG));
+
+        checkArgumentBindings(callingSequence, new Binding[][]{
+            { vmStore(rax, long.class) }
+        });
+
+        checkReturnBindings(callingSequence, new Binding[]{});
+
+        assertEquals(bindings.nVectorArgs, 0);
+    }
+
+    @Test
+    public void testNestedStructs() {
+        MemoryLayout POINT = MemoryLayout.ofStruct(
+                C_INT,
+                MemoryLayout.ofStruct(
+                        C_INT,
+                        C_INT
+                )
+        );
+        MethodType mt = MethodType.methodType(void.class, MemorySegment.class);
+        FunctionDescriptor fd = FunctionDescriptor.ofVoid(POINT);
+        CallArranger.Bindings bindings = CallArranger.getBindings(mt, fd, false);
+
+        assertFalse(bindings.isInMemoryReturn);
+        CallingSequence callingSequence = bindings.callingSequence;
+        assertEquals(callingSequence.methodType(), mt.appendParameterTypes(long.class));
+        assertEquals(callingSequence.functionDesc(), fd.appendArgumentLayouts(C_LONG));
+
+        checkArgumentBindings(callingSequence, new Binding[][]{
+                { dup(), bufferLoad(0, long.class), vmStore(rdi, long.class),
+                  bufferLoad(8, int.class), vmStore(rsi, int.class)},
+                { vmStore(rax, long.class) },
+        });
+
+        checkReturnBindings(callingSequence, new Binding[]{});
+
+        assertEquals(bindings.nVectorArgs, 0);
+    }
+
+    @Test
+    public void testNestedUnion() {
+        MemoryLayout POINT = MemoryLayout.ofStruct(
+                C_INT,
+                MemoryLayout.ofPaddingBits(32),
+                MemoryLayout.ofUnion(
+                        MemoryLayout.ofStruct(C_INT, C_INT),
+                        C_LONG
+                )
+        );
+        MethodType mt = MethodType.methodType(void.class, MemorySegment.class);
+        FunctionDescriptor fd = FunctionDescriptor.ofVoid(POINT);
+        CallArranger.Bindings bindings = CallArranger.getBindings(mt, fd, false);
+
+        assertFalse(bindings.isInMemoryReturn);
+        CallingSequence callingSequence = bindings.callingSequence;
+        assertEquals(callingSequence.methodType(), mt.appendParameterTypes(long.class));
+        assertEquals(callingSequence.functionDesc(), fd.appendArgumentLayouts(C_LONG));
+
+        checkArgumentBindings(callingSequence, new Binding[][]{
+                { dup(), bufferLoad(0, long.class), vmStore(rdi, long.class),
+                        bufferLoad(8, long.class), vmStore(rsi, long.class)},
+                { vmStore(rax, long.class) },
+        });
+
+        checkReturnBindings(callingSequence, new Binding[]{});
+
+        assertEquals(bindings.nVectorArgs, 0);
+    }
+
+    @Test
+    public void testNestedStructsUnaligned() {
+        MemoryLayout POINT = MemoryLayout.ofStruct(
+                C_INT,
+                MemoryLayout.ofStruct(
+                        C_LONG,
+                        C_INT
+                )
+        );
+        MethodType mt = MethodType.methodType(void.class, MemorySegment.class);
+        FunctionDescriptor fd = FunctionDescriptor.ofVoid(POINT);
+        CallArranger.Bindings bindings = CallArranger.getBindings(mt, fd, false);
+
+        assertFalse(bindings.isInMemoryReturn);
+        CallingSequence callingSequence = bindings.callingSequence;
+        assertEquals(callingSequence.methodType(), mt.appendParameterTypes(long.class));
+        assertEquals(callingSequence.functionDesc(), fd.appendArgumentLayouts(C_LONG));
+
+        checkArgumentBindings(callingSequence, new Binding[][]{
+                { dup(), bufferLoad(0, long.class), vmStore(stackStorage(0), long.class),
+                        bufferLoad(8, long.class), vmStore(stackStorage(1), long.class)},
+                { vmStore(rax, long.class) },
+        });
+
+        checkReturnBindings(callingSequence, new Binding[]{});
+
+        assertEquals(bindings.nVectorArgs, 0);
+    }
+
+    @Test
+    public void testNestedUnionUnaligned() {
+        MemoryLayout POINT = MemoryLayout.ofStruct(
+                C_INT,
+                MemoryLayout.ofUnion(
+                        MemoryLayout.ofStruct(C_INT, C_INT),
+                        C_LONG
+                )
+        );
+        MethodType mt = MethodType.methodType(void.class, MemorySegment.class);
+        FunctionDescriptor fd = FunctionDescriptor.ofVoid(POINT);
+        CallArranger.Bindings bindings = CallArranger.getBindings(mt, fd, false);
+
+        assertFalse(bindings.isInMemoryReturn);
+        CallingSequence callingSequence = bindings.callingSequence;
+        assertEquals(callingSequence.methodType(), mt.appendParameterTypes(long.class));
+        assertEquals(callingSequence.functionDesc(), fd.appendArgumentLayouts(C_LONG));
+
+        checkArgumentBindings(callingSequence, new Binding[][]{
+                { dup(), bufferLoad(0, long.class), vmStore(stackStorage(0), long.class),
+                        bufferLoad(8, int.class), vmStore(stackStorage(1), int.class)},
+                { vmStore(rax, long.class) },
+        });
+
+        checkReturnBindings(callingSequence, new Binding[]{});
+
+        assertEquals(bindings.nVectorArgs, 0);
+    }
+
+    @Test
+    public void testIntegerRegs() {
+        MethodType mt = MethodType.methodType(void.class,
+                int.class, int.class, int.class, int.class, int.class, int.class);
+        FunctionDescriptor fd = FunctionDescriptor.ofVoid(
+                C_INT, C_INT, C_INT, C_INT, C_INT, C_INT);
+        CallArranger.Bindings bindings = CallArranger.getBindings(mt, fd, false);
+
+        assertFalse(bindings.isInMemoryReturn);
+        CallingSequence callingSequence = bindings.callingSequence;
+        assertEquals(callingSequence.methodType(), mt.appendParameterTypes(long.class));
+        assertEquals(callingSequence.functionDesc(), fd.appendArgumentLayouts(C_LONG));
+
+        checkArgumentBindings(callingSequence, new Binding[][]{
+            { vmStore(rdi, int.class) },
+            { vmStore(rsi, int.class) },
+            { vmStore(rdx, int.class) },
+            { vmStore(rcx, int.class) },
+            { vmStore(r8, int.class) },
+            { vmStore(r9, int.class) },
+            { vmStore(rax, long.class) },
+        });
+
+        checkReturnBindings(callingSequence, new Binding[]{});
+
+        assertEquals(bindings.nVectorArgs, 0);
+    }
+
+    @Test
+    public void testDoubleRegs() {
+        MethodType mt = MethodType.methodType(void.class,
+                double.class, double.class, double.class, double.class,
+                double.class, double.class, double.class, double.class);
+        FunctionDescriptor fd = FunctionDescriptor.ofVoid(
+                C_DOUBLE, C_DOUBLE, C_DOUBLE, C_DOUBLE,
+                C_DOUBLE, C_DOUBLE, C_DOUBLE, C_DOUBLE);
+        CallArranger.Bindings bindings = CallArranger.getBindings(mt, fd, false);
+
+        assertFalse(bindings.isInMemoryReturn);
+        CallingSequence callingSequence = bindings.callingSequence;
+        assertEquals(callingSequence.methodType(), mt.appendParameterTypes(long.class));
+        assertEquals(callingSequence.functionDesc(), fd.appendArgumentLayouts(C_LONG));
+
+        checkArgumentBindings(callingSequence, new Binding[][]{
+            { vmStore(xmm0, double.class) },
+            { vmStore(xmm1, double.class) },
+            { vmStore(xmm2, double.class) },
+            { vmStore(xmm3, double.class) },
+            { vmStore(xmm4, double.class) },
+            { vmStore(xmm5, double.class) },
+            { vmStore(xmm6, double.class) },
+            { vmStore(xmm7, double.class) },
+            { vmStore(rax, long.class) },
+        });
+
+        checkReturnBindings(callingSequence, new Binding[]{});
+
+        assertEquals(bindings.nVectorArgs, 8);
+    }
+
+    @Test
+    public void testMixed() {
+        MethodType mt = MethodType.methodType(void.class,
+                long.class, long.class, long.class, long.class, long.class, long.class, long.class, long.class,
+                float.class, float.class, float.class, float.class,
+                float.class, float.class, float.class, float.class, float.class, float.class);
+        FunctionDescriptor fd = FunctionDescriptor.ofVoid(
+                C_LONG, C_LONG, C_LONG, C_LONG, C_LONG, C_LONG, C_LONG, C_LONG,
+                C_FLOAT, C_FLOAT, C_FLOAT, C_FLOAT,
+                C_FLOAT, C_FLOAT, C_FLOAT, C_FLOAT, C_FLOAT, C_FLOAT);
+        CallArranger.Bindings bindings = CallArranger.getBindings(mt, fd, false);
+
+        assertFalse(bindings.isInMemoryReturn);
+        CallingSequence callingSequence = bindings.callingSequence;
+        assertEquals(callingSequence.methodType(), mt.appendParameterTypes(long.class));
+        assertEquals(callingSequence.functionDesc(), fd.appendArgumentLayouts(C_LONG));
+
+        checkArgumentBindings(callingSequence, new Binding[][]{
+            { vmStore(rdi, long.class) },
+            { vmStore(rsi, long.class) },
+            { vmStore(rdx, long.class) },
+            { vmStore(rcx, long.class) },
+            { vmStore(r8, long.class) },
+            { vmStore(r9, long.class) },
+            { vmStore(stackStorage(0), long.class) },
+            { vmStore(stackStorage(1), long.class) },
+            { vmStore(xmm0, float.class) },
+            { vmStore(xmm1, float.class) },
+            { vmStore(xmm2, float.class) },
+            { vmStore(xmm3, float.class) },
+            { vmStore(xmm4, float.class) },
+            { vmStore(xmm5, float.class) },
+            { vmStore(xmm6, float.class) },
+            { vmStore(xmm7, float.class) },
+            { vmStore(stackStorage(2), float.class) },
+            { vmStore(stackStorage(3), float.class) },
+            { vmStore(rax, long.class) },
+        });
+
+        checkReturnBindings(callingSequence, new Binding[]{});
+
+        assertEquals(bindings.nVectorArgs, 8);
+    }
+
+    /**
+     * This is the example from the System V ABI AMD64 document
+     *
+     * struct structparm {
+     *   int32_t a, int32_t b, double d;
+     * } s;
+     * int32_t e, f, g, h, i, j, k;
+     * double m, n;
+     *
+     * void m(e, f, s, g, h, m, n, i, j, k);
+     *
+     * m(s);
+     */
+    @Test
+    public void testAbiExample() {
+        MemoryLayout struct = MemoryLayout.ofStruct(C_INT, C_INT, C_DOUBLE);
+
+        MethodType mt = MethodType.methodType(void.class,
+                int.class, int.class, MemorySegment.class, int.class, int.class,
+                double.class, double.class, int.class, int.class, int.class);
+        FunctionDescriptor fd = FunctionDescriptor.ofVoid(
+                C_INT, C_INT, struct, C_INT, C_INT, C_DOUBLE, C_DOUBLE, C_INT, C_INT, C_INT);
+        CallArranger.Bindings bindings = CallArranger.getBindings(mt, fd, false);
+
+        assertFalse(bindings.isInMemoryReturn);
+        CallingSequence callingSequence = bindings.callingSequence;
+        assertEquals(callingSequence.methodType(), mt.appendParameterTypes(long.class));
+        assertEquals(callingSequence.functionDesc(), fd.appendArgumentLayouts(C_LONG));
+
+        checkArgumentBindings(callingSequence, new Binding[][]{
+            { vmStore(rdi, int.class) },
+            { vmStore(rsi, int.class) },
+            {
+                dup(),
+                bufferLoad(0, long.class), vmStore(rdx, long.class),
+                bufferLoad(8, long.class), vmStore(xmm0, long.class)
+            },
+            { vmStore(rcx, int.class) },
+            { vmStore(r8, int.class) },
+            { vmStore(xmm1, double.class) },
+            { vmStore(xmm2, double.class) },
+            { vmStore(r9, int.class) },
+            { vmStore(stackStorage(0), int.class) },
+            { vmStore(stackStorage(1), int.class) },
+            { vmStore(rax, long.class) },
+        });
+
+        checkReturnBindings(callingSequence, new Binding[]{});
+
+        assertEquals(bindings.nVectorArgs, 3);
+    }
+
+    /**
+     * typedef void (*f)(void);
+     *
+     * void m(f f);
+     * void f_impl(void);
+     *
+     * m(f_impl);
+     */
+    @Test
+    public void testMemoryAddress() {
+        MethodType mt = MethodType.methodType(void.class, MemoryAddress.class);
+        FunctionDescriptor fd = FunctionDescriptor.ofVoid( C_POINTER);
+        CallArranger.Bindings bindings = CallArranger.getBindings(mt, fd, false);
+
+        assertFalse(bindings.isInMemoryReturn);
+        CallingSequence callingSequence = bindings.callingSequence;
+        assertEquals(callingSequence.methodType(), mt.appendParameterTypes(long.class));
+        assertEquals(callingSequence.functionDesc(), fd.appendArgumentLayouts(C_LONG));
+
+        checkArgumentBindings(callingSequence, new Binding[][]{
+            { unboxAddress(), vmStore(rdi, long.class) },
+            { vmStore(rax, long.class) },
+        });
+
+        checkReturnBindings(callingSequence, new Binding[]{});
+
+        assertEquals(bindings.nVectorArgs, 0);
+    }
+
+    @Test(dataProvider = "structs")
+    public void testStruct(MemoryLayout struct, Binding[] expectedBindings) {
+        MethodType mt = MethodType.methodType(void.class, MemorySegment.class);
+        FunctionDescriptor fd = FunctionDescriptor.ofVoid(struct);
+        CallArranger.Bindings bindings = CallArranger.getBindings(mt, fd, false);
+
+        assertFalse(bindings.isInMemoryReturn);
+        CallingSequence callingSequence = bindings.callingSequence;
+        assertEquals(callingSequence.methodType(), mt.appendParameterTypes(long.class));
+        assertEquals(callingSequence.functionDesc(), fd.appendArgumentLayouts(C_LONG));
+
+        checkArgumentBindings(callingSequence, new Binding[][]{
+            expectedBindings,
+            { vmStore(rax, long.class) },
+        });
+
+        checkReturnBindings(callingSequence, new Binding[]{});
+
+        assertEquals(bindings.nVectorArgs, 0);
+    }
+
+
+    @DataProvider
+    public static Object[][] structs() {
+        return new Object[][]{
+            { MemoryLayout.ofStruct(C_LONG), new Binding[]{
+                    bufferLoad(0, long.class), vmStore(rdi, long.class)
+                }
+            },
+            { MemoryLayout.ofStruct(C_LONG, C_LONG), new Binding[]{
+                    dup(),
+                    bufferLoad(0, long.class), vmStore(rdi, long.class),
+                    bufferLoad(8, long.class), vmStore(rsi, long.class)
+                }
+            },
+            { MemoryLayout.ofStruct(C_LONG, C_LONG, C_LONG), new Binding[]{
+                    dup(),
+                    bufferLoad(0, long.class), vmStore(stackStorage(0), long.class),
+                    dup(),
+                    bufferLoad(8, long.class), vmStore(stackStorage(1), long.class),
+                    bufferLoad(16, long.class), vmStore(stackStorage(2), long.class)
+                }
+            },
+            { MemoryLayout.ofStruct(C_LONG, C_LONG, C_LONG, C_LONG), new Binding[]{
+                    dup(),
+                    bufferLoad(0, long.class), vmStore(stackStorage(0), long.class),
+                    dup(),
+                    bufferLoad(8, long.class), vmStore(stackStorage(1), long.class),
+                    dup(),
+                    bufferLoad(16, long.class), vmStore(stackStorage(2), long.class),
+                    bufferLoad(24, long.class), vmStore(stackStorage(3), long.class)
+                }
+            },
+        };
+    }
+
+    @Test
+    public void testReturnRegisterStruct() {
+        MemoryLayout struct = MemoryLayout.ofStruct(C_LONG, C_LONG);
+
+        MethodType mt = MethodType.methodType(MemorySegment.class);
+        FunctionDescriptor fd = FunctionDescriptor.of(struct);
+        CallArranger.Bindings bindings = CallArranger.getBindings(mt, fd, false);
+
+        assertFalse(bindings.isInMemoryReturn);
+        CallingSequence callingSequence = bindings.callingSequence;
+        assertEquals(callingSequence.methodType(), mt.appendParameterTypes(long.class));
+        assertEquals(callingSequence.functionDesc(), fd.appendArgumentLayouts(C_LONG));
+
+        checkArgumentBindings(callingSequence, new Binding[][]{
+            { vmStore(rax, long.class) }
+        });
+
+        checkReturnBindings(callingSequence, new Binding[] {
+            allocate(struct),
+            dup(),
+            vmLoad(rax, long.class),
+            bufferStore(0, long.class),
+            dup(),
+            vmLoad(rdx, long.class),
+            bufferStore(8, long.class)
+        });
+
+        assertEquals(bindings.nVectorArgs, 0);
+    }
+
+    @Test
+    public void testIMR() {
+        MemoryLayout struct = MemoryLayout.ofStruct(C_LONG, C_LONG, C_LONG);
+
+        MethodType mt = MethodType.methodType(MemorySegment.class);
+        FunctionDescriptor fd = FunctionDescriptor.of(struct);
+        CallArranger.Bindings bindings = CallArranger.getBindings(mt, fd, false);
+
+        assertTrue(bindings.isInMemoryReturn);
+        CallingSequence callingSequence = bindings.callingSequence;
+        assertEquals(callingSequence.methodType(), MethodType.methodType(void.class, MemoryAddress.class, long.class));
+        assertEquals(callingSequence.functionDesc(), FunctionDescriptor.ofVoid(C_POINTER, C_LONG));
+
+        checkArgumentBindings(callingSequence, new Binding[][]{
+            { unboxAddress(), vmStore(rdi, long.class) },
+            { vmStore(rax, long.class) }
+        });
+
+        checkReturnBindings(callingSequence, new Binding[] {});
+
+        assertEquals(bindings.nVectorArgs, 0);
+    }
+
+}
diff --git a/test/jdk/java/foreign/callarranger/TestWindowsCallArranger.java b/test/jdk/java/foreign/callarranger/TestWindowsCallArranger.java
new file mode 100644
index 0000000000000..f5e68e5c56897
--- /dev/null
+++ b/test/jdk/java/foreign/callarranger/TestWindowsCallArranger.java
@@ -0,0 +1,373 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ *  This code is free software; you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License version 2 only, as
+ *  published by the Free Software Foundation.
+ *
+ *  This code 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
+ *  version 2 for more details (a copy is included in the LICENSE file that
+ *  accompanied this code).
+ *
+ *  You should have received a copy of the GNU General Public License version
+ *  2 along with this work; if not, write to the Free Software Foundation,
+ *  Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ *   Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ *  or visit www.oracle.com if you need additional information or have any
+ *  questions.
+ *
+ */
+
+/*
+ * @test
+ * @modules jdk.incubator.foreign/jdk.internal.foreign
+ *          jdk.incubator.foreign/jdk.internal.foreign.abi
+ *          jdk.incubator.foreign/jdk.internal.foreign.abi.x64
+ *          jdk.incubator.foreign/jdk.internal.foreign.abi.x64.windows
+ * @build CallArrangerTestBase
+ * @run testng TestWindowsCallArranger
+ */
+
+import jdk.incubator.foreign.FunctionDescriptor;
+import jdk.incubator.foreign.MemoryAddress;
+import jdk.incubator.foreign.MemoryLayout;
+import jdk.incubator.foreign.MemorySegment;
+import jdk.internal.foreign.abi.Binding;
+import jdk.internal.foreign.abi.CallingSequence;
+import jdk.internal.foreign.abi.x64.windows.CallArranger;
+import org.testng.annotations.Test;
+
+import java.lang.invoke.MethodType;
+
+import static jdk.internal.foreign.PlatformLayouts.Win64.*;
+import static jdk.internal.foreign.abi.Binding.*;
+import static jdk.internal.foreign.abi.Binding.copy;
+import static jdk.internal.foreign.abi.x64.X86_64Architecture.*;
+import static org.testng.Assert.*;
+
+public class TestWindowsCallArranger extends CallArrangerTestBase {
+
+    @Test
+    public void testEmpty() {
+        MethodType mt = MethodType.methodType(void.class);
+        FunctionDescriptor fd = FunctionDescriptor.ofVoid();
+        CallArranger.Bindings bindings = CallArranger.getBindings(mt, fd, false);
+
+        assertFalse(bindings.isInMemoryReturn);
+        CallingSequence callingSequence = bindings.callingSequence;
+        assertEquals(callingSequence.methodType(), mt);
+        assertEquals(callingSequence.functionDesc(), fd);
+
+        checkArgumentBindings(callingSequence, new Binding[][]{});
+        checkReturnBindings(callingSequence, new Binding[]{});
+    }
+
+    @Test
+    public void testIntegerRegs() {
+        MethodType mt = MethodType.methodType(void.class, int.class, int.class, int.class, int.class);
+        FunctionDescriptor fd = FunctionDescriptor.ofVoid(C_INT, C_INT, C_INT, C_INT);
+        CallArranger.Bindings bindings = CallArranger.getBindings(mt, fd, false);
+
+        assertFalse(bindings.isInMemoryReturn);
+        CallingSequence callingSequence = bindings.callingSequence;
+        assertEquals(callingSequence.methodType(), mt);
+        assertEquals(callingSequence.functionDesc(), fd);
+
+        checkArgumentBindings(callingSequence, new Binding[][]{
+            { vmStore(rcx, int.class) },
+            { vmStore(rdx, int.class) },
+            { vmStore(r8, int.class) },
+            { vmStore(r9, int.class) }
+        });
+
+        checkReturnBindings(callingSequence, new Binding[]{});
+    }
+
+    @Test
+    public void testDoubleRegs() {
+        MethodType mt = MethodType.methodType(void.class, double.class, double.class, double.class, double.class);
+        FunctionDescriptor fd = FunctionDescriptor.ofVoid(C_DOUBLE, C_DOUBLE, C_DOUBLE, C_DOUBLE);
+        CallArranger.Bindings bindings = CallArranger.getBindings(mt, fd, false);
+
+        assertFalse(bindings.isInMemoryReturn);
+        CallingSequence callingSequence = bindings.callingSequence;
+        assertEquals(callingSequence.methodType(), mt);
+        assertEquals(callingSequence.functionDesc(), fd);
+
+        checkArgumentBindings(callingSequence, new Binding[][]{
+            { vmStore(xmm0, double.class) },
+            { vmStore(xmm1, double.class) },
+            { vmStore(xmm2, double.class) },
+            { vmStore(xmm3, double.class) }
+        });
+
+        checkReturnBindings(callingSequence, new Binding[]{});
+    }
+
+    @Test
+    public void testMixed() {
+        MethodType mt = MethodType.methodType(void.class,
+                long.class, long.class, float.class, float.class, long.class, long.class, float.class, float.class);
+        FunctionDescriptor fd = FunctionDescriptor.ofVoid(
+                C_LONGLONG, C_LONGLONG, C_FLOAT, C_FLOAT, C_LONGLONG, C_LONGLONG, C_FLOAT, C_FLOAT);
+        CallArranger.Bindings bindings = CallArranger.getBindings(mt, fd, false);
+
+        assertFalse(bindings.isInMemoryReturn);
+        CallingSequence callingSequence = bindings.callingSequence;
+        assertEquals(callingSequence.methodType(), mt);
+        assertEquals(callingSequence.functionDesc(), fd);
+
+        checkArgumentBindings(callingSequence, new Binding[][]{
+            { vmStore(rcx, long.class) },
+            { vmStore(rdx, long.class) },
+            { vmStore(xmm2, float.class) },
+            { vmStore(xmm3, float.class) },
+            { vmStore(stackStorage(0), long.class) },
+            { vmStore(stackStorage(1), long.class) },
+            { vmStore(stackStorage(2), float.class) },
+            { vmStore(stackStorage(3), float.class) }
+        });
+
+        checkReturnBindings(callingSequence, new Binding[]{});
+    }
+
+    @Test
+    public void testAbiExample() {
+        MemoryLayout structLayout = MemoryLayout.ofStruct(C_INT, C_INT, C_DOUBLE);
+        MethodType mt = MethodType.methodType(void.class,
+                int.class, int.class, MemorySegment.class, int.class, int.class,
+                double.class, double.class, double.class, int.class, int.class, int.class);
+        FunctionDescriptor fd = FunctionDescriptor.ofVoid(
+                C_INT, C_INT, structLayout, C_INT, C_INT,
+                C_DOUBLE, C_DOUBLE, C_DOUBLE, C_INT, C_INT, C_INT);
+        CallArranger.Bindings bindings = CallArranger.getBindings(mt, fd, false);
+
+        assertFalse(bindings.isInMemoryReturn);
+        CallingSequence callingSequence = bindings.callingSequence;
+        assertEquals(callingSequence.methodType(), mt);
+        assertEquals(callingSequence.functionDesc(), fd);
+
+        checkArgumentBindings(callingSequence, new Binding[][]{
+            { vmStore(rcx, int.class) },
+            { vmStore(rdx, int.class) },
+            {
+                copy(structLayout),
+                baseAddress(),
+                unboxAddress(),
+                vmStore(r8, long.class)
+            },
+            { vmStore(r9, int.class) },
+            { vmStore(stackStorage(0), int.class) },
+            { vmStore(stackStorage(1), double.class) },
+            { vmStore(stackStorage(2), double.class) },
+            { vmStore(stackStorage(3), double.class) },
+            { vmStore(stackStorage(4), int.class) },
+            { vmStore(stackStorage(5), int.class) },
+            { vmStore(stackStorage(6), int.class) }
+        });
+
+        checkReturnBindings(callingSequence, new Binding[]{});
+    }
+
+    @Test
+    public void testAbiExampleVarargs() {
+        MethodType mt = MethodType.methodType(void.class,
+                int.class, double.class, int.class, double.class, double.class);
+        FunctionDescriptor fd = FunctionDescriptor.ofVoid(
+                C_INT, C_DOUBLE, asVarArg(C_INT), asVarArg(C_DOUBLE), asVarArg(C_DOUBLE));
+        CallArranger.Bindings bindings = CallArranger.getBindings(mt, fd, false);
+
+        assertFalse(bindings.isInMemoryReturn);
+        CallingSequence callingSequence = bindings.callingSequence;
+        assertEquals(callingSequence.methodType(), mt);
+        assertEquals(callingSequence.functionDesc(), fd);
+
+        checkArgumentBindings(callingSequence, new Binding[][]{
+            { vmStore(rcx, int.class) },
+            { vmStore(xmm1, double.class) },
+            { vmStore(r8, int.class) },
+            { dup(), vmStore(r9, double.class), vmStore(xmm3, double.class) },
+            { vmStore(stackStorage(0), double.class) },
+        });
+
+        checkReturnBindings(callingSequence, new Binding[]{});
+    }
+
+    /**
+     * struct s {
+     *   uint64_t u0;
+     * } s;
+     *
+     * void m(struct s s);
+     *
+     * m(s);
+     */
+    @Test
+    public void testStructRegister() {
+        MemoryLayout struct = MemoryLayout.ofStruct(C_LONGLONG);
+
+        MethodType mt = MethodType.methodType(void.class, MemorySegment.class);
+        FunctionDescriptor fd = FunctionDescriptor.ofVoid(struct);
+        CallArranger.Bindings bindings = CallArranger.getBindings(mt, fd, false);
+
+        assertFalse(bindings.isInMemoryReturn);
+        CallingSequence callingSequence = bindings.callingSequence;
+        assertEquals(callingSequence.methodType(), mt);
+        assertEquals(callingSequence.functionDesc(), fd);
+
+        checkArgumentBindings(callingSequence, new Binding[][]{
+            { bufferLoad(0, long.class), vmStore(rcx, long.class) }
+        });
+
+        checkReturnBindings(callingSequence, new Binding[]{});
+    }
+
+    /**
+     * struct s {
+     *   uint64_t u0, u1;
+     * } s;
+     *
+     * void m(struct s s);
+     *
+     * m(s);
+     */
+    @Test
+    public void testStructReference() {
+        MemoryLayout struct = MemoryLayout.ofStruct(C_LONGLONG, C_LONGLONG);
+
+        MethodType mt = MethodType.methodType(void.class, MemorySegment.class);
+        FunctionDescriptor fd = FunctionDescriptor.ofVoid(struct);
+        CallArranger.Bindings bindings = CallArranger.getBindings(mt, fd, false);
+
+        assertFalse(bindings.isInMemoryReturn);
+        CallingSequence callingSequence = bindings.callingSequence;
+        assertEquals(callingSequence.methodType(), mt);
+        assertEquals(callingSequence.functionDesc(), fd);
+
+        checkArgumentBindings(callingSequence, new Binding[][]{
+            {
+                copy(struct),
+                baseAddress(),
+                unboxAddress(),
+                vmStore(rcx, long.class)
+            }
+        });
+
+        checkReturnBindings(callingSequence, new Binding[]{});
+    }
+
+    /**
+     * typedef void (*f)(void);
+     *
+     * void m(f f);
+     * void f_impl(void);
+     *
+     * m(f_impl);
+     */
+    @Test
+    public void testMemoryAddress() {
+        MethodType mt = MethodType.methodType(void.class, MemoryAddress.class);
+        FunctionDescriptor fd = FunctionDescriptor.ofVoid(C_POINTER);
+        CallArranger.Bindings bindings = CallArranger.getBindings(mt, fd, false);
+
+        assertFalse(bindings.isInMemoryReturn);
+        CallingSequence callingSequence = bindings.callingSequence;
+        assertEquals(callingSequence.methodType(), mt);
+        assertEquals(callingSequence.functionDesc(), fd);
+
+        checkArgumentBindings(callingSequence, new Binding[][]{
+            { unboxAddress(), vmStore(rcx, long.class) }
+        });
+
+        checkReturnBindings(callingSequence, new Binding[]{});
+    }
+
+    @Test
+    public void testReturnRegisterStruct() {
+        MemoryLayout struct = MemoryLayout.ofStruct(C_LONGLONG);
+
+        MethodType mt = MethodType.methodType(MemorySegment.class);
+        FunctionDescriptor fd = FunctionDescriptor.of(struct);
+        CallArranger.Bindings bindings = CallArranger.getBindings(mt, fd, false);
+
+        assertFalse(bindings.isInMemoryReturn);
+        CallingSequence callingSequence = bindings.callingSequence;
+        assertEquals(callingSequence.methodType(), mt);
+        assertEquals(callingSequence.functionDesc(), fd);
+
+        checkArgumentBindings(callingSequence, new Binding[][]{});
+
+        checkReturnBindings(callingSequence,
+            new Binding[]{ allocate(struct),
+                dup(),
+                vmLoad(rax, long.class),
+                bufferStore(0, long.class) });
+    }
+
+    @Test
+    public void testIMR() {
+        MemoryLayout struct = MemoryLayout.ofStruct(C_LONGLONG, C_LONGLONG);
+
+        MethodType mt = MethodType.methodType(MemorySegment.class);
+        FunctionDescriptor fd = FunctionDescriptor.of(struct);
+        CallArranger.Bindings bindings = CallArranger.getBindings(mt, fd, false);
+
+        assertTrue(bindings.isInMemoryReturn);
+        CallingSequence callingSequence = bindings.callingSequence;
+        assertEquals(callingSequence.methodType(), MethodType.methodType(void.class, MemoryAddress.class));
+        assertEquals(callingSequence.functionDesc(), FunctionDescriptor.ofVoid(C_POINTER));
+
+        checkArgumentBindings(callingSequence, new Binding[][]{
+            { unboxAddress(), vmStore(rcx, long.class) }
+        });
+
+        checkReturnBindings(callingSequence, new Binding[]{});
+    }
+
+    @Test
+    public void testStackStruct() {
+        MemoryLayout struct = MemoryLayout.ofStruct(C_POINTER, C_DOUBLE, C_INT);
+
+        MethodType mt = MethodType.methodType(void.class,
+            MemorySegment.class, int.class, double.class, MemoryAddress.class,
+            MemorySegment.class, int.class, double.class, MemoryAddress.class,
+            MemorySegment.class, int.class, double.class, MemoryAddress.class,
+            MemorySegment.class, int.class, double.class, MemoryAddress.class);
+        FunctionDescriptor fd = FunctionDescriptor.ofVoid(
+            struct, C_INT, C_DOUBLE, C_POINTER,
+            struct, C_INT, C_DOUBLE, C_POINTER,
+            struct, C_INT, C_DOUBLE, C_POINTER,
+            struct, C_INT, C_DOUBLE, C_POINTER);
+        CallArranger.Bindings bindings = CallArranger.getBindings(mt, fd, false);
+
+        assertFalse(bindings.isInMemoryReturn);
+        CallingSequence callingSequence = bindings.callingSequence;
+        assertEquals(callingSequence.methodType(), mt);
+        assertEquals(callingSequence.functionDesc(), fd);
+
+        checkArgumentBindings(callingSequence, new Binding[][]{
+            { copy(struct), baseAddress(), unboxAddress(), vmStore(rcx, long.class) },
+            { vmStore(rdx, int.class) },
+            { vmStore(xmm2, double.class) },
+            { unboxAddress(), vmStore(r9, long.class) },
+            { copy(struct), baseAddress(), unboxAddress(), vmStore(stackStorage(0), long.class) },
+            { vmStore(stackStorage(1), int.class) },
+            { vmStore(stackStorage(2), double.class) },
+            { unboxAddress(), vmStore(stackStorage(3), long.class) },
+            { copy(struct), baseAddress(), unboxAddress(), vmStore(stackStorage(4), long.class) },
+            { vmStore(stackStorage(5), int.class) },
+            { vmStore(stackStorage(6), double.class) },
+            { unboxAddress(), vmStore(stackStorage(7), long.class) },
+            { copy(struct), baseAddress(), unboxAddress(), vmStore(stackStorage(8), long.class) },
+            { vmStore(stackStorage(9), int.class) },
+            { vmStore(stackStorage(10), double.class) },
+            { unboxAddress(), vmStore(stackStorage(11), long.class) },
+        });
+
+        checkReturnBindings(callingSequence, new Binding[]{});
+    }
+}
diff --git a/test/jdk/java/foreign/libIntrinsics.c b/test/jdk/java/foreign/libIntrinsics.c
new file mode 100644
index 0000000000000..5b6923cbbd780
--- /dev/null
+++ b/test/jdk/java/foreign/libIntrinsics.c
@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ *  This code is free software; you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License version 2 only, as
+ *  published by the Free Software Foundation.
+ *
+ *  This code 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
+ *  version 2 for more details (a copy is included in the LICENSE file that
+ *  accompanied this code).
+ *
+ *  You should have received a copy of the GNU General Public License version
+ *  2 along with this work; if not, write to the Free Software Foundation,
+ *  Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ *   Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ *  or visit www.oracle.com if you need additional information or have any
+ *  questions.
+ *
+ */
+
+#ifdef _WIN64
+#define EXPORT __declspec(dllexport)
+#else
+#define EXPORT
+#endif
+
+EXPORT void empty() {
+}
+
+EXPORT char identity_char(char x) {
+    return x;
+}
+
+EXPORT short identity_short(short x) {
+    return x;
+}
+
+EXPORT int identity_int(int x) {
+    return x;
+}
+
+EXPORT long long identity_long(long long x) {
+    return x;
+}
+
+EXPORT float identity_float(float x) {
+    return x;
+}
+
+EXPORT double identity_double(double x) {
+    return x;
+}
+
+EXPORT int identity_va(int x, ...) {
+    return x;
+}
+
+EXPORT int invoke_high_arity0(int x, double d, long long l, float f, char c, short s1, short s2) {
+    return x;
+}
+EXPORT double invoke_high_arity1(int x, double d, long long l, float f, char c, short s1, short s2) {
+    return d;
+}
+EXPORT long long invoke_high_arity2(int x, double d, long long l, float f, char c, short s1, short s2) {
+    return l;
+}
+EXPORT float invoke_high_arity3(int x, double d, long long l, float f, char c, short s1, short s2) {
+    return f;
+}
+EXPORT char invoke_high_arity4(int x, double d, long long l, float f, char c, short s1, short s2) {
+    return c;
+}
+EXPORT short invoke_high_arity5(int x, double d, long long l, float f, char c, short s1, short s2) {
+    return s1;
+}
+EXPORT short invoke_high_arity6(int x, double d, long long l, float f, char c, short s1, short s2) {
+    return s2;
+}
\ No newline at end of file
diff --git a/test/jdk/java/foreign/libLookupTest.c b/test/jdk/java/foreign/libLookupTest.c
new file mode 100644
index 0000000000000..31451d74ce4ca
--- /dev/null
+++ b/test/jdk/java/foreign/libLookupTest.c
@@ -0,0 +1,32 @@
+/*
+ *  Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
+ *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ *  This code is free software; you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License version 2 only, as
+ *  published by the Free Software Foundation.
+ *
+ *  This code 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
+ *  version 2 for more details (a copy is included in the LICENSE file that
+ *  accompanied this code).
+ *
+ *  You should have received a copy of the GNU General Public License version
+ *  2 along with this work; if not, write to the Free Software Foundation,
+ *  Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ *  Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ *  or visit www.oracle.com if you need additional information or have any
+ *  questions.
+ *
+ */
+
+ #ifdef _WIN64
+ #define EXPORT __declspec(dllexport)
+ #else
+ #define EXPORT
+ #endif
+
+ EXPORT void f() { }
+
diff --git a/test/jdk/java/foreign/libTestDowncall.c b/test/jdk/java/foreign/libTestDowncall.c
new file mode 100644
index 0000000000000..f4ef3aafbf0aa
--- /dev/null
+++ b/test/jdk/java/foreign/libTestDowncall.c
@@ -0,0 +1,12129 @@
+/*
+ * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+#include "libTestDowncall.h"
+#ifdef __clang__
+#pragma clang optimize off
+#elif defined __GNUC__
+#pragma GCC optimize ("O0")
+#elif defined _MSC_BUILD
+#pragma optimize( "", off )
+#endif
+
+EXPORT void f0_V__(void) { }
+EXPORT void f0_V_I_(int p0) { }
+EXPORT void f0_V_F_(float p0) { }
+EXPORT void f0_V_D_(double p0) { }
+EXPORT void f0_V_P_(void* p0) { }
+EXPORT void f0_V_S_I(struct S_I p0) { }
+EXPORT void f0_V_S_F(struct S_F p0) { }
+EXPORT void f0_V_S_D(struct S_D p0) { }
+EXPORT void f0_V_S_P(struct S_P p0) { }
+EXPORT void f0_V_S_II(struct S_II p0) { }
+EXPORT void f0_V_S_IF(struct S_IF p0) { }
+EXPORT void f0_V_S_ID(struct S_ID p0) { }
+EXPORT void f0_V_S_IP(struct S_IP p0) { }
+EXPORT void f0_V_S_FI(struct S_FI p0) { }
+EXPORT void f0_V_S_FF(struct S_FF p0) { }
+EXPORT void f0_V_S_FD(struct S_FD p0) { }
+EXPORT void f0_V_S_FP(struct S_FP p0) { }
+EXPORT void f0_V_S_DI(struct S_DI p0) { }
+EXPORT void f0_V_S_DF(struct S_DF p0) { }
+EXPORT void f0_V_S_DD(struct S_DD p0) { }
+EXPORT void f0_V_S_DP(struct S_DP p0) { }
+EXPORT void f0_V_S_PI(struct S_PI p0) { }
+EXPORT void f0_V_S_PF(struct S_PF p0) { }
+EXPORT void f0_V_S_PD(struct S_PD p0) { }
+EXPORT void f0_V_S_PP(struct S_PP p0) { }
+EXPORT void f0_V_S_III(struct S_III p0) { }
+EXPORT void f0_V_S_IIF(struct S_IIF p0) { }
+EXPORT void f0_V_S_IID(struct S_IID p0) { }
+EXPORT void f0_V_S_IIP(struct S_IIP p0) { }
+EXPORT void f0_V_S_IFI(struct S_IFI p0) { }
+EXPORT void f0_V_S_IFF(struct S_IFF p0) { }
+EXPORT void f0_V_S_IFD(struct S_IFD p0) { }
+EXPORT void f0_V_S_IFP(struct S_IFP p0) { }
+EXPORT void f0_V_S_IDI(struct S_IDI p0) { }
+EXPORT void f0_V_S_IDF(struct S_IDF p0) { }
+EXPORT void f0_V_S_IDD(struct S_IDD p0) { }
+EXPORT void f0_V_S_IDP(struct S_IDP p0) { }
+EXPORT void f0_V_S_IPI(struct S_IPI p0) { }
+EXPORT void f0_V_S_IPF(struct S_IPF p0) { }
+EXPORT void f0_V_S_IPD(struct S_IPD p0) { }
+EXPORT void f0_V_S_IPP(struct S_IPP p0) { }
+EXPORT void f0_V_S_FII(struct S_FII p0) { }
+EXPORT void f0_V_S_FIF(struct S_FIF p0) { }
+EXPORT void f0_V_S_FID(struct S_FID p0) { }
+EXPORT void f0_V_S_FIP(struct S_FIP p0) { }
+EXPORT void f0_V_S_FFI(struct S_FFI p0) { }
+EXPORT void f0_V_S_FFF(struct S_FFF p0) { }
+EXPORT void f0_V_S_FFD(struct S_FFD p0) { }
+EXPORT void f0_V_S_FFP(struct S_FFP p0) { }
+EXPORT void f0_V_S_FDI(struct S_FDI p0) { }
+EXPORT void f0_V_S_FDF(struct S_FDF p0) { }
+EXPORT void f0_V_S_FDD(struct S_FDD p0) { }
+EXPORT void f0_V_S_FDP(struct S_FDP p0) { }
+EXPORT void f0_V_S_FPI(struct S_FPI p0) { }
+EXPORT void f0_V_S_FPF(struct S_FPF p0) { }
+EXPORT void f0_V_S_FPD(struct S_FPD p0) { }
+EXPORT void f0_V_S_FPP(struct S_FPP p0) { }
+EXPORT void f0_V_S_DII(struct S_DII p0) { }
+EXPORT void f0_V_S_DIF(struct S_DIF p0) { }
+EXPORT void f0_V_S_DID(struct S_DID p0) { }
+EXPORT void f0_V_S_DIP(struct S_DIP p0) { }
+EXPORT void f0_V_S_DFI(struct S_DFI p0) { }
+EXPORT void f0_V_S_DFF(struct S_DFF p0) { }
+EXPORT void f0_V_S_DFD(struct S_DFD p0) { }
+EXPORT void f0_V_S_DFP(struct S_DFP p0) { }
+EXPORT void f0_V_S_DDI(struct S_DDI p0) { }
+EXPORT void f0_V_S_DDF(struct S_DDF p0) { }
+EXPORT void f0_V_S_DDD(struct S_DDD p0) { }
+EXPORT void f0_V_S_DDP(struct S_DDP p0) { }
+EXPORT void f0_V_S_DPI(struct S_DPI p0) { }
+EXPORT void f0_V_S_DPF(struct S_DPF p0) { }
+EXPORT void f0_V_S_DPD(struct S_DPD p0) { }
+EXPORT void f0_V_S_DPP(struct S_DPP p0) { }
+EXPORT void f0_V_S_PII(struct S_PII p0) { }
+EXPORT void f0_V_S_PIF(struct S_PIF p0) { }
+EXPORT void f0_V_S_PID(struct S_PID p0) { }
+EXPORT void f0_V_S_PIP(struct S_PIP p0) { }
+EXPORT void f0_V_S_PFI(struct S_PFI p0) { }
+EXPORT void f0_V_S_PFF(struct S_PFF p0) { }
+EXPORT void f0_V_S_PFD(struct S_PFD p0) { }
+EXPORT void f0_V_S_PFP(struct S_PFP p0) { }
+EXPORT void f0_V_S_PDI(struct S_PDI p0) { }
+EXPORT void f0_V_S_PDF(struct S_PDF p0) { }
+EXPORT void f0_V_S_PDD(struct S_PDD p0) { }
+EXPORT void f0_V_S_PDP(struct S_PDP p0) { }
+EXPORT void f0_V_S_PPI(struct S_PPI p0) { }
+EXPORT void f0_V_S_PPF(struct S_PPF p0) { }
+EXPORT void f0_V_S_PPD(struct S_PPD p0) { }
+EXPORT void f0_V_S_PPP(struct S_PPP p0) { }
+EXPORT void f0_V_II_(int p0, int p1) { }
+EXPORT void f0_V_IF_(int p0, float p1) { }
+EXPORT void f0_V_ID_(int p0, double p1) { }
+EXPORT void f0_V_IP_(int p0, void* p1) { }
+EXPORT void f0_V_IS_I(int p0, struct S_I p1) { }
+EXPORT void f0_V_IS_F(int p0, struct S_F p1) { }
+EXPORT void f0_V_IS_D(int p0, struct S_D p1) { }
+EXPORT void f0_V_IS_P(int p0, struct S_P p1) { }
+EXPORT void f0_V_IS_II(int p0, struct S_II p1) { }
+EXPORT void f0_V_IS_IF(int p0, struct S_IF p1) { }
+EXPORT void f0_V_IS_ID(int p0, struct S_ID p1) { }
+EXPORT void f0_V_IS_IP(int p0, struct S_IP p1) { }
+EXPORT void f0_V_IS_FI(int p0, struct S_FI p1) { }
+EXPORT void f0_V_IS_FF(int p0, struct S_FF p1) { }
+EXPORT void f0_V_IS_FD(int p0, struct S_FD p1) { }
+EXPORT void f0_V_IS_FP(int p0, struct S_FP p1) { }
+EXPORT void f0_V_IS_DI(int p0, struct S_DI p1) { }
+EXPORT void f0_V_IS_DF(int p0, struct S_DF p1) { }
+EXPORT void f0_V_IS_DD(int p0, struct S_DD p1) { }
+EXPORT void f0_V_IS_DP(int p0, struct S_DP p1) { }
+EXPORT void f0_V_IS_PI(int p0, struct S_PI p1) { }
+EXPORT void f0_V_IS_PF(int p0, struct S_PF p1) { }
+EXPORT void f0_V_IS_PD(int p0, struct S_PD p1) { }
+EXPORT void f0_V_IS_PP(int p0, struct S_PP p1) { }
+EXPORT void f0_V_IS_III(int p0, struct S_III p1) { }
+EXPORT void f0_V_IS_IIF(int p0, struct S_IIF p1) { }
+EXPORT void f0_V_IS_IID(int p0, struct S_IID p1) { }
+EXPORT void f0_V_IS_IIP(int p0, struct S_IIP p1) { }
+EXPORT void f0_V_IS_IFI(int p0, struct S_IFI p1) { }
+EXPORT void f0_V_IS_IFF(int p0, struct S_IFF p1) { }
+EXPORT void f0_V_IS_IFD(int p0, struct S_IFD p1) { }
+EXPORT void f0_V_IS_IFP(int p0, struct S_IFP p1) { }
+EXPORT void f0_V_IS_IDI(int p0, struct S_IDI p1) { }
+EXPORT void f0_V_IS_IDF(int p0, struct S_IDF p1) { }
+EXPORT void f0_V_IS_IDD(int p0, struct S_IDD p1) { }
+EXPORT void f0_V_IS_IDP(int p0, struct S_IDP p1) { }
+EXPORT void f0_V_IS_IPI(int p0, struct S_IPI p1) { }
+EXPORT void f0_V_IS_IPF(int p0, struct S_IPF p1) { }
+EXPORT void f0_V_IS_IPD(int p0, struct S_IPD p1) { }
+EXPORT void f0_V_IS_IPP(int p0, struct S_IPP p1) { }
+EXPORT void f0_V_IS_FII(int p0, struct S_FII p1) { }
+EXPORT void f0_V_IS_FIF(int p0, struct S_FIF p1) { }
+EXPORT void f0_V_IS_FID(int p0, struct S_FID p1) { }
+EXPORT void f0_V_IS_FIP(int p0, struct S_FIP p1) { }
+EXPORT void f0_V_IS_FFI(int p0, struct S_FFI p1) { }
+EXPORT void f0_V_IS_FFF(int p0, struct S_FFF p1) { }
+EXPORT void f0_V_IS_FFD(int p0, struct S_FFD p1) { }
+EXPORT void f0_V_IS_FFP(int p0, struct S_FFP p1) { }
+EXPORT void f0_V_IS_FDI(int p0, struct S_FDI p1) { }
+EXPORT void f0_V_IS_FDF(int p0, struct S_FDF p1) { }
+EXPORT void f0_V_IS_FDD(int p0, struct S_FDD p1) { }
+EXPORT void f0_V_IS_FDP(int p0, struct S_FDP p1) { }
+EXPORT void f0_V_IS_FPI(int p0, struct S_FPI p1) { }
+EXPORT void f0_V_IS_FPF(int p0, struct S_FPF p1) { }
+EXPORT void f0_V_IS_FPD(int p0, struct S_FPD p1) { }
+EXPORT void f0_V_IS_FPP(int p0, struct S_FPP p1) { }
+EXPORT void f0_V_IS_DII(int p0, struct S_DII p1) { }
+EXPORT void f0_V_IS_DIF(int p0, struct S_DIF p1) { }
+EXPORT void f0_V_IS_DID(int p0, struct S_DID p1) { }
+EXPORT void f0_V_IS_DIP(int p0, struct S_DIP p1) { }
+EXPORT void f0_V_IS_DFI(int p0, struct S_DFI p1) { }
+EXPORT void f0_V_IS_DFF(int p0, struct S_DFF p1) { }
+EXPORT void f0_V_IS_DFD(int p0, struct S_DFD p1) { }
+EXPORT void f0_V_IS_DFP(int p0, struct S_DFP p1) { }
+EXPORT void f0_V_IS_DDI(int p0, struct S_DDI p1) { }
+EXPORT void f0_V_IS_DDF(int p0, struct S_DDF p1) { }
+EXPORT void f0_V_IS_DDD(int p0, struct S_DDD p1) { }
+EXPORT void f0_V_IS_DDP(int p0, struct S_DDP p1) { }
+EXPORT void f0_V_IS_DPI(int p0, struct S_DPI p1) { }
+EXPORT void f0_V_IS_DPF(int p0, struct S_DPF p1) { }
+EXPORT void f0_V_IS_DPD(int p0, struct S_DPD p1) { }
+EXPORT void f0_V_IS_DPP(int p0, struct S_DPP p1) { }
+EXPORT void f0_V_IS_PII(int p0, struct S_PII p1) { }
+EXPORT void f0_V_IS_PIF(int p0, struct S_PIF p1) { }
+EXPORT void f0_V_IS_PID(int p0, struct S_PID p1) { }
+EXPORT void f0_V_IS_PIP(int p0, struct S_PIP p1) { }
+EXPORT void f0_V_IS_PFI(int p0, struct S_PFI p1) { }
+EXPORT void f0_V_IS_PFF(int p0, struct S_PFF p1) { }
+EXPORT void f0_V_IS_PFD(int p0, struct S_PFD p1) { }
+EXPORT void f0_V_IS_PFP(int p0, struct S_PFP p1) { }
+EXPORT void f0_V_IS_PDI(int p0, struct S_PDI p1) { }
+EXPORT void f0_V_IS_PDF(int p0, struct S_PDF p1) { }
+EXPORT void f0_V_IS_PDD(int p0, struct S_PDD p1) { }
+EXPORT void f0_V_IS_PDP(int p0, struct S_PDP p1) { }
+EXPORT void f0_V_IS_PPI(int p0, struct S_PPI p1) { }
+EXPORT void f0_V_IS_PPF(int p0, struct S_PPF p1) { }
+EXPORT void f0_V_IS_PPD(int p0, struct S_PPD p1) { }
+EXPORT void f0_V_IS_PPP(int p0, struct S_PPP p1) { }
+EXPORT void f0_V_FI_(float p0, int p1) { }
+EXPORT void f0_V_FF_(float p0, float p1) { }
+EXPORT void f0_V_FD_(float p0, double p1) { }
+EXPORT void f0_V_FP_(float p0, void* p1) { }
+EXPORT void f0_V_FS_I(float p0, struct S_I p1) { }
+EXPORT void f0_V_FS_F(float p0, struct S_F p1) { }
+EXPORT void f0_V_FS_D(float p0, struct S_D p1) { }
+EXPORT void f0_V_FS_P(float p0, struct S_P p1) { }
+EXPORT void f0_V_FS_II(float p0, struct S_II p1) { }
+EXPORT void f0_V_FS_IF(float p0, struct S_IF p1) { }
+EXPORT void f0_V_FS_ID(float p0, struct S_ID p1) { }
+EXPORT void f0_V_FS_IP(float p0, struct S_IP p1) { }
+EXPORT void f0_V_FS_FI(float p0, struct S_FI p1) { }
+EXPORT void f0_V_FS_FF(float p0, struct S_FF p1) { }
+EXPORT void f0_V_FS_FD(float p0, struct S_FD p1) { }
+EXPORT void f0_V_FS_FP(float p0, struct S_FP p1) { }
+EXPORT void f0_V_FS_DI(float p0, struct S_DI p1) { }
+EXPORT void f0_V_FS_DF(float p0, struct S_DF p1) { }
+EXPORT void f0_V_FS_DD(float p0, struct S_DD p1) { }
+EXPORT void f0_V_FS_DP(float p0, struct S_DP p1) { }
+EXPORT void f0_V_FS_PI(float p0, struct S_PI p1) { }
+EXPORT void f0_V_FS_PF(float p0, struct S_PF p1) { }
+EXPORT void f0_V_FS_PD(float p0, struct S_PD p1) { }
+EXPORT void f0_V_FS_PP(float p0, struct S_PP p1) { }
+EXPORT void f0_V_FS_III(float p0, struct S_III p1) { }
+EXPORT void f0_V_FS_IIF(float p0, struct S_IIF p1) { }
+EXPORT void f0_V_FS_IID(float p0, struct S_IID p1) { }
+EXPORT void f0_V_FS_IIP(float p0, struct S_IIP p1) { }
+EXPORT void f0_V_FS_IFI(float p0, struct S_IFI p1) { }
+EXPORT void f0_V_FS_IFF(float p0, struct S_IFF p1) { }
+EXPORT void f0_V_FS_IFD(float p0, struct S_IFD p1) { }
+EXPORT void f0_V_FS_IFP(float p0, struct S_IFP p1) { }
+EXPORT void f0_V_FS_IDI(float p0, struct S_IDI p1) { }
+EXPORT void f0_V_FS_IDF(float p0, struct S_IDF p1) { }
+EXPORT void f0_V_FS_IDD(float p0, struct S_IDD p1) { }
+EXPORT void f0_V_FS_IDP(float p0, struct S_IDP p1) { }
+EXPORT void f0_V_FS_IPI(float p0, struct S_IPI p1) { }
+EXPORT void f0_V_FS_IPF(float p0, struct S_IPF p1) { }
+EXPORT void f0_V_FS_IPD(float p0, struct S_IPD p1) { }
+EXPORT void f0_V_FS_IPP(float p0, struct S_IPP p1) { }
+EXPORT void f0_V_FS_FII(float p0, struct S_FII p1) { }
+EXPORT void f0_V_FS_FIF(float p0, struct S_FIF p1) { }
+EXPORT void f0_V_FS_FID(float p0, struct S_FID p1) { }
+EXPORT void f0_V_FS_FIP(float p0, struct S_FIP p1) { }
+EXPORT void f0_V_FS_FFI(float p0, struct S_FFI p1) { }
+EXPORT void f0_V_FS_FFF(float p0, struct S_FFF p1) { }
+EXPORT void f0_V_FS_FFD(float p0, struct S_FFD p1) { }
+EXPORT void f0_V_FS_FFP(float p0, struct S_FFP p1) { }
+EXPORT void f0_V_FS_FDI(float p0, struct S_FDI p1) { }
+EXPORT void f0_V_FS_FDF(float p0, struct S_FDF p1) { }
+EXPORT void f0_V_FS_FDD(float p0, struct S_FDD p1) { }
+EXPORT void f0_V_FS_FDP(float p0, struct S_FDP p1) { }
+EXPORT void f0_V_FS_FPI(float p0, struct S_FPI p1) { }
+EXPORT void f0_V_FS_FPF(float p0, struct S_FPF p1) { }
+EXPORT void f0_V_FS_FPD(float p0, struct S_FPD p1) { }
+EXPORT void f0_V_FS_FPP(float p0, struct S_FPP p1) { }
+EXPORT void f0_V_FS_DII(float p0, struct S_DII p1) { }
+EXPORT void f0_V_FS_DIF(float p0, struct S_DIF p1) { }
+EXPORT void f0_V_FS_DID(float p0, struct S_DID p1) { }
+EXPORT void f0_V_FS_DIP(float p0, struct S_DIP p1) { }
+EXPORT void f0_V_FS_DFI(float p0, struct S_DFI p1) { }
+EXPORT void f0_V_FS_DFF(float p0, struct S_DFF p1) { }
+EXPORT void f0_V_FS_DFD(float p0, struct S_DFD p1) { }
+EXPORT void f0_V_FS_DFP(float p0, struct S_DFP p1) { }
+EXPORT void f0_V_FS_DDI(float p0, struct S_DDI p1) { }
+EXPORT void f0_V_FS_DDF(float p0, struct S_DDF p1) { }
+EXPORT void f0_V_FS_DDD(float p0, struct S_DDD p1) { }
+EXPORT void f0_V_FS_DDP(float p0, struct S_DDP p1) { }
+EXPORT void f0_V_FS_DPI(float p0, struct S_DPI p1) { }
+EXPORT void f0_V_FS_DPF(float p0, struct S_DPF p1) { }
+EXPORT void f0_V_FS_DPD(float p0, struct S_DPD p1) { }
+EXPORT void f0_V_FS_DPP(float p0, struct S_DPP p1) { }
+EXPORT void f0_V_FS_PII(float p0, struct S_PII p1) { }
+EXPORT void f0_V_FS_PIF(float p0, struct S_PIF p1) { }
+EXPORT void f0_V_FS_PID(float p0, struct S_PID p1) { }
+EXPORT void f0_V_FS_PIP(float p0, struct S_PIP p1) { }
+EXPORT void f0_V_FS_PFI(float p0, struct S_PFI p1) { }
+EXPORT void f0_V_FS_PFF(float p0, struct S_PFF p1) { }
+EXPORT void f0_V_FS_PFD(float p0, struct S_PFD p1) { }
+EXPORT void f0_V_FS_PFP(float p0, struct S_PFP p1) { }
+EXPORT void f0_V_FS_PDI(float p0, struct S_PDI p1) { }
+EXPORT void f0_V_FS_PDF(float p0, struct S_PDF p1) { }
+EXPORT void f0_V_FS_PDD(float p0, struct S_PDD p1) { }
+EXPORT void f0_V_FS_PDP(float p0, struct S_PDP p1) { }
+EXPORT void f0_V_FS_PPI(float p0, struct S_PPI p1) { }
+EXPORT void f0_V_FS_PPF(float p0, struct S_PPF p1) { }
+EXPORT void f0_V_FS_PPD(float p0, struct S_PPD p1) { }
+EXPORT void f0_V_FS_PPP(float p0, struct S_PPP p1) { }
+EXPORT void f0_V_DI_(double p0, int p1) { }
+EXPORT void f0_V_DF_(double p0, float p1) { }
+EXPORT void f0_V_DD_(double p0, double p1) { }
+EXPORT void f0_V_DP_(double p0, void* p1) { }
+EXPORT void f0_V_DS_I(double p0, struct S_I p1) { }
+EXPORT void f0_V_DS_F(double p0, struct S_F p1) { }
+EXPORT void f0_V_DS_D(double p0, struct S_D p1) { }
+EXPORT void f0_V_DS_P(double p0, struct S_P p1) { }
+EXPORT void f0_V_DS_II(double p0, struct S_II p1) { }
+EXPORT void f0_V_DS_IF(double p0, struct S_IF p1) { }
+EXPORT void f0_V_DS_ID(double p0, struct S_ID p1) { }
+EXPORT void f0_V_DS_IP(double p0, struct S_IP p1) { }
+EXPORT void f0_V_DS_FI(double p0, struct S_FI p1) { }
+EXPORT void f0_V_DS_FF(double p0, struct S_FF p1) { }
+EXPORT void f0_V_DS_FD(double p0, struct S_FD p1) { }
+EXPORT void f0_V_DS_FP(double p0, struct S_FP p1) { }
+EXPORT void f0_V_DS_DI(double p0, struct S_DI p1) { }
+EXPORT void f0_V_DS_DF(double p0, struct S_DF p1) { }
+EXPORT void f0_V_DS_DD(double p0, struct S_DD p1) { }
+EXPORT void f0_V_DS_DP(double p0, struct S_DP p1) { }
+EXPORT void f0_V_DS_PI(double p0, struct S_PI p1) { }
+EXPORT void f0_V_DS_PF(double p0, struct S_PF p1) { }
+EXPORT void f0_V_DS_PD(double p0, struct S_PD p1) { }
+EXPORT void f0_V_DS_PP(double p0, struct S_PP p1) { }
+EXPORT void f0_V_DS_III(double p0, struct S_III p1) { }
+EXPORT void f0_V_DS_IIF(double p0, struct S_IIF p1) { }
+EXPORT void f0_V_DS_IID(double p0, struct S_IID p1) { }
+EXPORT void f0_V_DS_IIP(double p0, struct S_IIP p1) { }
+EXPORT void f0_V_DS_IFI(double p0, struct S_IFI p1) { }
+EXPORT void f0_V_DS_IFF(double p0, struct S_IFF p1) { }
+EXPORT void f0_V_DS_IFD(double p0, struct S_IFD p1) { }
+EXPORT void f0_V_DS_IFP(double p0, struct S_IFP p1) { }
+EXPORT void f0_V_DS_IDI(double p0, struct S_IDI p1) { }
+EXPORT void f0_V_DS_IDF(double p0, struct S_IDF p1) { }
+EXPORT void f0_V_DS_IDD(double p0, struct S_IDD p1) { }
+EXPORT void f0_V_DS_IDP(double p0, struct S_IDP p1) { }
+EXPORT void f0_V_DS_IPI(double p0, struct S_IPI p1) { }
+EXPORT void f0_V_DS_IPF(double p0, struct S_IPF p1) { }
+EXPORT void f0_V_DS_IPD(double p0, struct S_IPD p1) { }
+EXPORT void f0_V_DS_IPP(double p0, struct S_IPP p1) { }
+EXPORT void f0_V_DS_FII(double p0, struct S_FII p1) { }
+EXPORT void f0_V_DS_FIF(double p0, struct S_FIF p1) { }
+EXPORT void f0_V_DS_FID(double p0, struct S_FID p1) { }
+EXPORT void f0_V_DS_FIP(double p0, struct S_FIP p1) { }
+EXPORT void f0_V_DS_FFI(double p0, struct S_FFI p1) { }
+EXPORT void f0_V_DS_FFF(double p0, struct S_FFF p1) { }
+EXPORT void f0_V_DS_FFD(double p0, struct S_FFD p1) { }
+EXPORT void f0_V_DS_FFP(double p0, struct S_FFP p1) { }
+EXPORT void f0_V_DS_FDI(double p0, struct S_FDI p1) { }
+EXPORT void f0_V_DS_FDF(double p0, struct S_FDF p1) { }
+EXPORT void f0_V_DS_FDD(double p0, struct S_FDD p1) { }
+EXPORT void f0_V_DS_FDP(double p0, struct S_FDP p1) { }
+EXPORT void f0_V_DS_FPI(double p0, struct S_FPI p1) { }
+EXPORT void f0_V_DS_FPF(double p0, struct S_FPF p1) { }
+EXPORT void f0_V_DS_FPD(double p0, struct S_FPD p1) { }
+EXPORT void f0_V_DS_FPP(double p0, struct S_FPP p1) { }
+EXPORT void f0_V_DS_DII(double p0, struct S_DII p1) { }
+EXPORT void f0_V_DS_DIF(double p0, struct S_DIF p1) { }
+EXPORT void f0_V_DS_DID(double p0, struct S_DID p1) { }
+EXPORT void f0_V_DS_DIP(double p0, struct S_DIP p1) { }
+EXPORT void f0_V_DS_DFI(double p0, struct S_DFI p1) { }
+EXPORT void f0_V_DS_DFF(double p0, struct S_DFF p1) { }
+EXPORT void f0_V_DS_DFD(double p0, struct S_DFD p1) { }
+EXPORT void f0_V_DS_DFP(double p0, struct S_DFP p1) { }
+EXPORT void f0_V_DS_DDI(double p0, struct S_DDI p1) { }
+EXPORT void f0_V_DS_DDF(double p0, struct S_DDF p1) { }
+EXPORT void f0_V_DS_DDD(double p0, struct S_DDD p1) { }
+EXPORT void f0_V_DS_DDP(double p0, struct S_DDP p1) { }
+EXPORT void f0_V_DS_DPI(double p0, struct S_DPI p1) { }
+EXPORT void f0_V_DS_DPF(double p0, struct S_DPF p1) { }
+EXPORT void f0_V_DS_DPD(double p0, struct S_DPD p1) { }
+EXPORT void f0_V_DS_DPP(double p0, struct S_DPP p1) { }
+EXPORT void f0_V_DS_PII(double p0, struct S_PII p1) { }
+EXPORT void f0_V_DS_PIF(double p0, struct S_PIF p1) { }
+EXPORT void f0_V_DS_PID(double p0, struct S_PID p1) { }
+EXPORT void f0_V_DS_PIP(double p0, struct S_PIP p1) { }
+EXPORT void f0_V_DS_PFI(double p0, struct S_PFI p1) { }
+EXPORT void f0_V_DS_PFF(double p0, struct S_PFF p1) { }
+EXPORT void f0_V_DS_PFD(double p0, struct S_PFD p1) { }
+EXPORT void f0_V_DS_PFP(double p0, struct S_PFP p1) { }
+EXPORT void f0_V_DS_PDI(double p0, struct S_PDI p1) { }
+EXPORT void f0_V_DS_PDF(double p0, struct S_PDF p1) { }
+EXPORT void f0_V_DS_PDD(double p0, struct S_PDD p1) { }
+EXPORT void f0_V_DS_PDP(double p0, struct S_PDP p1) { }
+EXPORT void f0_V_DS_PPI(double p0, struct S_PPI p1) { }
+EXPORT void f0_V_DS_PPF(double p0, struct S_PPF p1) { }
+EXPORT void f0_V_DS_PPD(double p0, struct S_PPD p1) { }
+EXPORT void f0_V_DS_PPP(double p0, struct S_PPP p1) { }
+EXPORT void f0_V_PI_(void* p0, int p1) { }
+EXPORT void f0_V_PF_(void* p0, float p1) { }
+EXPORT void f0_V_PD_(void* p0, double p1) { }
+EXPORT void f0_V_PP_(void* p0, void* p1) { }
+EXPORT void f0_V_PS_I(void* p0, struct S_I p1) { }
+EXPORT void f0_V_PS_F(void* p0, struct S_F p1) { }
+EXPORT void f0_V_PS_D(void* p0, struct S_D p1) { }
+EXPORT void f0_V_PS_P(void* p0, struct S_P p1) { }
+EXPORT void f0_V_PS_II(void* p0, struct S_II p1) { }
+EXPORT void f0_V_PS_IF(void* p0, struct S_IF p1) { }
+EXPORT void f0_V_PS_ID(void* p0, struct S_ID p1) { }
+EXPORT void f0_V_PS_IP(void* p0, struct S_IP p1) { }
+EXPORT void f0_V_PS_FI(void* p0, struct S_FI p1) { }
+EXPORT void f0_V_PS_FF(void* p0, struct S_FF p1) { }
+EXPORT void f0_V_PS_FD(void* p0, struct S_FD p1) { }
+EXPORT void f0_V_PS_FP(void* p0, struct S_FP p1) { }
+EXPORT void f0_V_PS_DI(void* p0, struct S_DI p1) { }
+EXPORT void f0_V_PS_DF(void* p0, struct S_DF p1) { }
+EXPORT void f0_V_PS_DD(void* p0, struct S_DD p1) { }
+EXPORT void f0_V_PS_DP(void* p0, struct S_DP p1) { }
+EXPORT void f0_V_PS_PI(void* p0, struct S_PI p1) { }
+EXPORT void f0_V_PS_PF(void* p0, struct S_PF p1) { }
+EXPORT void f0_V_PS_PD(void* p0, struct S_PD p1) { }
+EXPORT void f0_V_PS_PP(void* p0, struct S_PP p1) { }
+EXPORT void f0_V_PS_III(void* p0, struct S_III p1) { }
+EXPORT void f0_V_PS_IIF(void* p0, struct S_IIF p1) { }
+EXPORT void f0_V_PS_IID(void* p0, struct S_IID p1) { }
+EXPORT void f0_V_PS_IIP(void* p0, struct S_IIP p1) { }
+EXPORT void f0_V_PS_IFI(void* p0, struct S_IFI p1) { }
+EXPORT void f0_V_PS_IFF(void* p0, struct S_IFF p1) { }
+EXPORT void f0_V_PS_IFD(void* p0, struct S_IFD p1) { }
+EXPORT void f0_V_PS_IFP(void* p0, struct S_IFP p1) { }
+EXPORT void f0_V_PS_IDI(void* p0, struct S_IDI p1) { }
+EXPORT void f0_V_PS_IDF(void* p0, struct S_IDF p1) { }
+EXPORT void f0_V_PS_IDD(void* p0, struct S_IDD p1) { }
+EXPORT void f0_V_PS_IDP(void* p0, struct S_IDP p1) { }
+EXPORT void f0_V_PS_IPI(void* p0, struct S_IPI p1) { }
+EXPORT void f0_V_PS_IPF(void* p0, struct S_IPF p1) { }
+EXPORT void f0_V_PS_IPD(void* p0, struct S_IPD p1) { }
+EXPORT void f0_V_PS_IPP(void* p0, struct S_IPP p1) { }
+EXPORT void f0_V_PS_FII(void* p0, struct S_FII p1) { }
+EXPORT void f0_V_PS_FIF(void* p0, struct S_FIF p1) { }
+EXPORT void f0_V_PS_FID(void* p0, struct S_FID p1) { }
+EXPORT void f0_V_PS_FIP(void* p0, struct S_FIP p1) { }
+EXPORT void f0_V_PS_FFI(void* p0, struct S_FFI p1) { }
+EXPORT void f0_V_PS_FFF(void* p0, struct S_FFF p1) { }
+EXPORT void f0_V_PS_FFD(void* p0, struct S_FFD p1) { }
+EXPORT void f0_V_PS_FFP(void* p0, struct S_FFP p1) { }
+EXPORT void f0_V_PS_FDI(void* p0, struct S_FDI p1) { }
+EXPORT void f0_V_PS_FDF(void* p0, struct S_FDF p1) { }
+EXPORT void f0_V_PS_FDD(void* p0, struct S_FDD p1) { }
+EXPORT void f0_V_PS_FDP(void* p0, struct S_FDP p1) { }
+EXPORT void f0_V_PS_FPI(void* p0, struct S_FPI p1) { }
+EXPORT void f0_V_PS_FPF(void* p0, struct S_FPF p1) { }
+EXPORT void f0_V_PS_FPD(void* p0, struct S_FPD p1) { }
+EXPORT void f0_V_PS_FPP(void* p0, struct S_FPP p1) { }
+EXPORT void f0_V_PS_DII(void* p0, struct S_DII p1) { }
+EXPORT void f0_V_PS_DIF(void* p0, struct S_DIF p1) { }
+EXPORT void f0_V_PS_DID(void* p0, struct S_DID p1) { }
+EXPORT void f0_V_PS_DIP(void* p0, struct S_DIP p1) { }
+EXPORT void f0_V_PS_DFI(void* p0, struct S_DFI p1) { }
+EXPORT void f0_V_PS_DFF(void* p0, struct S_DFF p1) { }
+EXPORT void f0_V_PS_DFD(void* p0, struct S_DFD p1) { }
+EXPORT void f0_V_PS_DFP(void* p0, struct S_DFP p1) { }
+EXPORT void f0_V_PS_DDI(void* p0, struct S_DDI p1) { }
+EXPORT void f0_V_PS_DDF(void* p0, struct S_DDF p1) { }
+EXPORT void f0_V_PS_DDD(void* p0, struct S_DDD p1) { }
+EXPORT void f0_V_PS_DDP(void* p0, struct S_DDP p1) { }
+EXPORT void f0_V_PS_DPI(void* p0, struct S_DPI p1) { }
+EXPORT void f0_V_PS_DPF(void* p0, struct S_DPF p1) { }
+EXPORT void f0_V_PS_DPD(void* p0, struct S_DPD p1) { }
+EXPORT void f0_V_PS_DPP(void* p0, struct S_DPP p1) { }
+EXPORT void f0_V_PS_PII(void* p0, struct S_PII p1) { }
+EXPORT void f0_V_PS_PIF(void* p0, struct S_PIF p1) { }
+EXPORT void f0_V_PS_PID(void* p0, struct S_PID p1) { }
+EXPORT void f0_V_PS_PIP(void* p0, struct S_PIP p1) { }
+EXPORT void f0_V_PS_PFI(void* p0, struct S_PFI p1) { }
+EXPORT void f0_V_PS_PFF(void* p0, struct S_PFF p1) { }
+EXPORT void f0_V_PS_PFD(void* p0, struct S_PFD p1) { }
+EXPORT void f0_V_PS_PFP(void* p0, struct S_PFP p1) { }
+EXPORT void f0_V_PS_PDI(void* p0, struct S_PDI p1) { }
+EXPORT void f0_V_PS_PDF(void* p0, struct S_PDF p1) { }
+EXPORT void f0_V_PS_PDD(void* p0, struct S_PDD p1) { }
+EXPORT void f0_V_PS_PDP(void* p0, struct S_PDP p1) { }
+EXPORT void f0_V_PS_PPI(void* p0, struct S_PPI p1) { }
+EXPORT void f0_V_PS_PPF(void* p0, struct S_PPF p1) { }
+EXPORT void f0_V_PS_PPD(void* p0, struct S_PPD p1) { }
+EXPORT void f0_V_PS_PPP(void* p0, struct S_PPP p1) { }
+EXPORT void f0_V_SI_I(struct S_I p0, int p1) { }
+EXPORT void f0_V_SI_F(struct S_F p0, int p1) { }
+EXPORT void f0_V_SI_D(struct S_D p0, int p1) { }
+EXPORT void f0_V_SI_P(struct S_P p0, int p1) { }
+EXPORT void f0_V_SI_II(struct S_II p0, int p1) { }
+EXPORT void f0_V_SI_IF(struct S_IF p0, int p1) { }
+EXPORT void f0_V_SI_ID(struct S_ID p0, int p1) { }
+EXPORT void f0_V_SI_IP(struct S_IP p0, int p1) { }
+EXPORT void f0_V_SI_FI(struct S_FI p0, int p1) { }
+EXPORT void f0_V_SI_FF(struct S_FF p0, int p1) { }
+EXPORT void f0_V_SI_FD(struct S_FD p0, int p1) { }
+EXPORT void f0_V_SI_FP(struct S_FP p0, int p1) { }
+EXPORT void f0_V_SI_DI(struct S_DI p0, int p1) { }
+EXPORT void f0_V_SI_DF(struct S_DF p0, int p1) { }
+EXPORT void f0_V_SI_DD(struct S_DD p0, int p1) { }
+EXPORT void f0_V_SI_DP(struct S_DP p0, int p1) { }
+EXPORT void f0_V_SI_PI(struct S_PI p0, int p1) { }
+EXPORT void f0_V_SI_PF(struct S_PF p0, int p1) { }
+EXPORT void f0_V_SI_PD(struct S_PD p0, int p1) { }
+EXPORT void f0_V_SI_PP(struct S_PP p0, int p1) { }
+EXPORT void f0_V_SI_III(struct S_III p0, int p1) { }
+EXPORT void f0_V_SI_IIF(struct S_IIF p0, int p1) { }
+EXPORT void f0_V_SI_IID(struct S_IID p0, int p1) { }
+EXPORT void f0_V_SI_IIP(struct S_IIP p0, int p1) { }
+EXPORT void f0_V_SI_IFI(struct S_IFI p0, int p1) { }
+EXPORT void f0_V_SI_IFF(struct S_IFF p0, int p1) { }
+EXPORT void f0_V_SI_IFD(struct S_IFD p0, int p1) { }
+EXPORT void f0_V_SI_IFP(struct S_IFP p0, int p1) { }
+EXPORT void f0_V_SI_IDI(struct S_IDI p0, int p1) { }
+EXPORT void f0_V_SI_IDF(struct S_IDF p0, int p1) { }
+EXPORT void f0_V_SI_IDD(struct S_IDD p0, int p1) { }
+EXPORT void f0_V_SI_IDP(struct S_IDP p0, int p1) { }
+EXPORT void f0_V_SI_IPI(struct S_IPI p0, int p1) { }
+EXPORT void f0_V_SI_IPF(struct S_IPF p0, int p1) { }
+EXPORT void f0_V_SI_IPD(struct S_IPD p0, int p1) { }
+EXPORT void f0_V_SI_IPP(struct S_IPP p0, int p1) { }
+EXPORT void f0_V_SI_FII(struct S_FII p0, int p1) { }
+EXPORT void f0_V_SI_FIF(struct S_FIF p0, int p1) { }
+EXPORT void f0_V_SI_FID(struct S_FID p0, int p1) { }
+EXPORT void f0_V_SI_FIP(struct S_FIP p0, int p1) { }
+EXPORT void f0_V_SI_FFI(struct S_FFI p0, int p1) { }
+EXPORT void f0_V_SI_FFF(struct S_FFF p0, int p1) { }
+EXPORT void f0_V_SI_FFD(struct S_FFD p0, int p1) { }
+EXPORT void f0_V_SI_FFP(struct S_FFP p0, int p1) { }
+EXPORT void f0_V_SI_FDI(struct S_FDI p0, int p1) { }
+EXPORT void f0_V_SI_FDF(struct S_FDF p0, int p1) { }
+EXPORT void f0_V_SI_FDD(struct S_FDD p0, int p1) { }
+EXPORT void f0_V_SI_FDP(struct S_FDP p0, int p1) { }
+EXPORT void f0_V_SI_FPI(struct S_FPI p0, int p1) { }
+EXPORT void f0_V_SI_FPF(struct S_FPF p0, int p1) { }
+EXPORT void f0_V_SI_FPD(struct S_FPD p0, int p1) { }
+EXPORT void f0_V_SI_FPP(struct S_FPP p0, int p1) { }
+EXPORT void f0_V_SI_DII(struct S_DII p0, int p1) { }
+EXPORT void f0_V_SI_DIF(struct S_DIF p0, int p1) { }
+EXPORT void f0_V_SI_DID(struct S_DID p0, int p1) { }
+EXPORT void f0_V_SI_DIP(struct S_DIP p0, int p1) { }
+EXPORT void f0_V_SI_DFI(struct S_DFI p0, int p1) { }
+EXPORT void f0_V_SI_DFF(struct S_DFF p0, int p1) { }
+EXPORT void f0_V_SI_DFD(struct S_DFD p0, int p1) { }
+EXPORT void f0_V_SI_DFP(struct S_DFP p0, int p1) { }
+EXPORT void f0_V_SI_DDI(struct S_DDI p0, int p1) { }
+EXPORT void f0_V_SI_DDF(struct S_DDF p0, int p1) { }
+EXPORT void f0_V_SI_DDD(struct S_DDD p0, int p1) { }
+EXPORT void f0_V_SI_DDP(struct S_DDP p0, int p1) { }
+EXPORT void f0_V_SI_DPI(struct S_DPI p0, int p1) { }
+EXPORT void f0_V_SI_DPF(struct S_DPF p0, int p1) { }
+EXPORT void f0_V_SI_DPD(struct S_DPD p0, int p1) { }
+EXPORT void f0_V_SI_DPP(struct S_DPP p0, int p1) { }
+EXPORT void f0_V_SI_PII(struct S_PII p0, int p1) { }
+EXPORT void f0_V_SI_PIF(struct S_PIF p0, int p1) { }
+EXPORT void f0_V_SI_PID(struct S_PID p0, int p1) { }
+EXPORT void f0_V_SI_PIP(struct S_PIP p0, int p1) { }
+EXPORT void f0_V_SI_PFI(struct S_PFI p0, int p1) { }
+EXPORT void f0_V_SI_PFF(struct S_PFF p0, int p1) { }
+EXPORT void f0_V_SI_PFD(struct S_PFD p0, int p1) { }
+EXPORT void f0_V_SI_PFP(struct S_PFP p0, int p1) { }
+EXPORT void f0_V_SI_PDI(struct S_PDI p0, int p1) { }
+EXPORT void f0_V_SI_PDF(struct S_PDF p0, int p1) { }
+EXPORT void f0_V_SI_PDD(struct S_PDD p0, int p1) { }
+EXPORT void f0_V_SI_PDP(struct S_PDP p0, int p1) { }
+EXPORT void f0_V_SI_PPI(struct S_PPI p0, int p1) { }
+EXPORT void f0_V_SI_PPF(struct S_PPF p0, int p1) { }
+EXPORT void f0_V_SI_PPD(struct S_PPD p0, int p1) { }
+EXPORT void f0_V_SI_PPP(struct S_PPP p0, int p1) { }
+EXPORT void f0_V_SF_I(struct S_I p0, float p1) { }
+EXPORT void f0_V_SF_F(struct S_F p0, float p1) { }
+EXPORT void f0_V_SF_D(struct S_D p0, float p1) { }
+EXPORT void f0_V_SF_P(struct S_P p0, float p1) { }
+EXPORT void f0_V_SF_II(struct S_II p0, float p1) { }
+EXPORT void f0_V_SF_IF(struct S_IF p0, float p1) { }
+EXPORT void f0_V_SF_ID(struct S_ID p0, float p1) { }
+EXPORT void f0_V_SF_IP(struct S_IP p0, float p1) { }
+EXPORT void f0_V_SF_FI(struct S_FI p0, float p1) { }
+EXPORT void f0_V_SF_FF(struct S_FF p0, float p1) { }
+EXPORT void f0_V_SF_FD(struct S_FD p0, float p1) { }
+EXPORT void f0_V_SF_FP(struct S_FP p0, float p1) { }
+EXPORT void f0_V_SF_DI(struct S_DI p0, float p1) { }
+EXPORT void f0_V_SF_DF(struct S_DF p0, float p1) { }
+EXPORT void f0_V_SF_DD(struct S_DD p0, float p1) { }
+EXPORT void f0_V_SF_DP(struct S_DP p0, float p1) { }
+EXPORT void f0_V_SF_PI(struct S_PI p0, float p1) { }
+EXPORT void f0_V_SF_PF(struct S_PF p0, float p1) { }
+EXPORT void f0_V_SF_PD(struct S_PD p0, float p1) { }
+EXPORT void f0_V_SF_PP(struct S_PP p0, float p1) { }
+EXPORT void f0_V_SF_III(struct S_III p0, float p1) { }
+EXPORT void f0_V_SF_IIF(struct S_IIF p0, float p1) { }
+EXPORT void f0_V_SF_IID(struct S_IID p0, float p1) { }
+EXPORT void f0_V_SF_IIP(struct S_IIP p0, float p1) { }
+EXPORT void f0_V_SF_IFI(struct S_IFI p0, float p1) { }
+EXPORT void f0_V_SF_IFF(struct S_IFF p0, float p1) { }
+EXPORT void f0_V_SF_IFD(struct S_IFD p0, float p1) { }
+EXPORT void f0_V_SF_IFP(struct S_IFP p0, float p1) { }
+EXPORT void f0_V_SF_IDI(struct S_IDI p0, float p1) { }
+EXPORT void f0_V_SF_IDF(struct S_IDF p0, float p1) { }
+EXPORT void f0_V_SF_IDD(struct S_IDD p0, float p1) { }
+EXPORT void f0_V_SF_IDP(struct S_IDP p0, float p1) { }
+EXPORT void f0_V_SF_IPI(struct S_IPI p0, float p1) { }
+EXPORT void f0_V_SF_IPF(struct S_IPF p0, float p1) { }
+EXPORT void f0_V_SF_IPD(struct S_IPD p0, float p1) { }
+EXPORT void f0_V_SF_IPP(struct S_IPP p0, float p1) { }
+EXPORT void f0_V_SF_FII(struct S_FII p0, float p1) { }
+EXPORT void f0_V_SF_FIF(struct S_FIF p0, float p1) { }
+EXPORT void f0_V_SF_FID(struct S_FID p0, float p1) { }
+EXPORT void f0_V_SF_FIP(struct S_FIP p0, float p1) { }
+EXPORT void f0_V_SF_FFI(struct S_FFI p0, float p1) { }
+EXPORT void f0_V_SF_FFF(struct S_FFF p0, float p1) { }
+EXPORT void f0_V_SF_FFD(struct S_FFD p0, float p1) { }
+EXPORT void f0_V_SF_FFP(struct S_FFP p0, float p1) { }
+EXPORT void f0_V_SF_FDI(struct S_FDI p0, float p1) { }
+EXPORT void f0_V_SF_FDF(struct S_FDF p0, float p1) { }
+EXPORT void f0_V_SF_FDD(struct S_FDD p0, float p1) { }
+EXPORT void f0_V_SF_FDP(struct S_FDP p0, float p1) { }
+EXPORT void f0_V_SF_FPI(struct S_FPI p0, float p1) { }
+EXPORT void f0_V_SF_FPF(struct S_FPF p0, float p1) { }
+EXPORT void f0_V_SF_FPD(struct S_FPD p0, float p1) { }
+EXPORT void f0_V_SF_FPP(struct S_FPP p0, float p1) { }
+EXPORT void f0_V_SF_DII(struct S_DII p0, float p1) { }
+EXPORT void f0_V_SF_DIF(struct S_DIF p0, float p1) { }
+EXPORT void f0_V_SF_DID(struct S_DID p0, float p1) { }
+EXPORT void f0_V_SF_DIP(struct S_DIP p0, float p1) { }
+EXPORT void f0_V_SF_DFI(struct S_DFI p0, float p1) { }
+EXPORT void f0_V_SF_DFF(struct S_DFF p0, float p1) { }
+EXPORT void f0_V_SF_DFD(struct S_DFD p0, float p1) { }
+EXPORT void f0_V_SF_DFP(struct S_DFP p0, float p1) { }
+EXPORT void f0_V_SF_DDI(struct S_DDI p0, float p1) { }
+EXPORT void f0_V_SF_DDF(struct S_DDF p0, float p1) { }
+EXPORT void f0_V_SF_DDD(struct S_DDD p0, float p1) { }
+EXPORT void f0_V_SF_DDP(struct S_DDP p0, float p1) { }
+EXPORT void f0_V_SF_DPI(struct S_DPI p0, float p1) { }
+EXPORT void f0_V_SF_DPF(struct S_DPF p0, float p1) { }
+EXPORT void f0_V_SF_DPD(struct S_DPD p0, float p1) { }
+EXPORT void f0_V_SF_DPP(struct S_DPP p0, float p1) { }
+EXPORT void f0_V_SF_PII(struct S_PII p0, float p1) { }
+EXPORT void f0_V_SF_PIF(struct S_PIF p0, float p1) { }
+EXPORT void f0_V_SF_PID(struct S_PID p0, float p1) { }
+EXPORT void f0_V_SF_PIP(struct S_PIP p0, float p1) { }
+EXPORT void f0_V_SF_PFI(struct S_PFI p0, float p1) { }
+EXPORT void f0_V_SF_PFF(struct S_PFF p0, float p1) { }
+EXPORT void f0_V_SF_PFD(struct S_PFD p0, float p1) { }
+EXPORT void f1_V_SF_PFP(struct S_PFP p0, float p1) { }
+EXPORT void f1_V_SF_PDI(struct S_PDI p0, float p1) { }
+EXPORT void f1_V_SF_PDF(struct S_PDF p0, float p1) { }
+EXPORT void f1_V_SF_PDD(struct S_PDD p0, float p1) { }
+EXPORT void f1_V_SF_PDP(struct S_PDP p0, float p1) { }
+EXPORT void f1_V_SF_PPI(struct S_PPI p0, float p1) { }
+EXPORT void f1_V_SF_PPF(struct S_PPF p0, float p1) { }
+EXPORT void f1_V_SF_PPD(struct S_PPD p0, float p1) { }
+EXPORT void f1_V_SF_PPP(struct S_PPP p0, float p1) { }
+EXPORT void f1_V_SD_I(struct S_I p0, double p1) { }
+EXPORT void f1_V_SD_F(struct S_F p0, double p1) { }
+EXPORT void f1_V_SD_D(struct S_D p0, double p1) { }
+EXPORT void f1_V_SD_P(struct S_P p0, double p1) { }
+EXPORT void f1_V_SD_II(struct S_II p0, double p1) { }
+EXPORT void f1_V_SD_IF(struct S_IF p0, double p1) { }
+EXPORT void f1_V_SD_ID(struct S_ID p0, double p1) { }
+EXPORT void f1_V_SD_IP(struct S_IP p0, double p1) { }
+EXPORT void f1_V_SD_FI(struct S_FI p0, double p1) { }
+EXPORT void f1_V_SD_FF(struct S_FF p0, double p1) { }
+EXPORT void f1_V_SD_FD(struct S_FD p0, double p1) { }
+EXPORT void f1_V_SD_FP(struct S_FP p0, double p1) { }
+EXPORT void f1_V_SD_DI(struct S_DI p0, double p1) { }
+EXPORT void f1_V_SD_DF(struct S_DF p0, double p1) { }
+EXPORT void f1_V_SD_DD(struct S_DD p0, double p1) { }
+EXPORT void f1_V_SD_DP(struct S_DP p0, double p1) { }
+EXPORT void f1_V_SD_PI(struct S_PI p0, double p1) { }
+EXPORT void f1_V_SD_PF(struct S_PF p0, double p1) { }
+EXPORT void f1_V_SD_PD(struct S_PD p0, double p1) { }
+EXPORT void f1_V_SD_PP(struct S_PP p0, double p1) { }
+EXPORT void f1_V_SD_III(struct S_III p0, double p1) { }
+EXPORT void f1_V_SD_IIF(struct S_IIF p0, double p1) { }
+EXPORT void f1_V_SD_IID(struct S_IID p0, double p1) { }
+EXPORT void f1_V_SD_IIP(struct S_IIP p0, double p1) { }
+EXPORT void f1_V_SD_IFI(struct S_IFI p0, double p1) { }
+EXPORT void f1_V_SD_IFF(struct S_IFF p0, double p1) { }
+EXPORT void f1_V_SD_IFD(struct S_IFD p0, double p1) { }
+EXPORT void f1_V_SD_IFP(struct S_IFP p0, double p1) { }
+EXPORT void f1_V_SD_IDI(struct S_IDI p0, double p1) { }
+EXPORT void f1_V_SD_IDF(struct S_IDF p0, double p1) { }
+EXPORT void f1_V_SD_IDD(struct S_IDD p0, double p1) { }
+EXPORT void f1_V_SD_IDP(struct S_IDP p0, double p1) { }
+EXPORT void f1_V_SD_IPI(struct S_IPI p0, double p1) { }
+EXPORT void f1_V_SD_IPF(struct S_IPF p0, double p1) { }
+EXPORT void f1_V_SD_IPD(struct S_IPD p0, double p1) { }
+EXPORT void f1_V_SD_IPP(struct S_IPP p0, double p1) { }
+EXPORT void f1_V_SD_FII(struct S_FII p0, double p1) { }
+EXPORT void f1_V_SD_FIF(struct S_FIF p0, double p1) { }
+EXPORT void f1_V_SD_FID(struct S_FID p0, double p1) { }
+EXPORT void f1_V_SD_FIP(struct S_FIP p0, double p1) { }
+EXPORT void f1_V_SD_FFI(struct S_FFI p0, double p1) { }
+EXPORT void f1_V_SD_FFF(struct S_FFF p0, double p1) { }
+EXPORT void f1_V_SD_FFD(struct S_FFD p0, double p1) { }
+EXPORT void f1_V_SD_FFP(struct S_FFP p0, double p1) { }
+EXPORT void f1_V_SD_FDI(struct S_FDI p0, double p1) { }
+EXPORT void f1_V_SD_FDF(struct S_FDF p0, double p1) { }
+EXPORT void f1_V_SD_FDD(struct S_FDD p0, double p1) { }
+EXPORT void f1_V_SD_FDP(struct S_FDP p0, double p1) { }
+EXPORT void f1_V_SD_FPI(struct S_FPI p0, double p1) { }
+EXPORT void f1_V_SD_FPF(struct S_FPF p0, double p1) { }
+EXPORT void f1_V_SD_FPD(struct S_FPD p0, double p1) { }
+EXPORT void f1_V_SD_FPP(struct S_FPP p0, double p1) { }
+EXPORT void f1_V_SD_DII(struct S_DII p0, double p1) { }
+EXPORT void f1_V_SD_DIF(struct S_DIF p0, double p1) { }
+EXPORT void f1_V_SD_DID(struct S_DID p0, double p1) { }
+EXPORT void f1_V_SD_DIP(struct S_DIP p0, double p1) { }
+EXPORT void f1_V_SD_DFI(struct S_DFI p0, double p1) { }
+EXPORT void f1_V_SD_DFF(struct S_DFF p0, double p1) { }
+EXPORT void f1_V_SD_DFD(struct S_DFD p0, double p1) { }
+EXPORT void f1_V_SD_DFP(struct S_DFP p0, double p1) { }
+EXPORT void f1_V_SD_DDI(struct S_DDI p0, double p1) { }
+EXPORT void f1_V_SD_DDF(struct S_DDF p0, double p1) { }
+EXPORT void f1_V_SD_DDD(struct S_DDD p0, double p1) { }
+EXPORT void f1_V_SD_DDP(struct S_DDP p0, double p1) { }
+EXPORT void f1_V_SD_DPI(struct S_DPI p0, double p1) { }
+EXPORT void f1_V_SD_DPF(struct S_DPF p0, double p1) { }
+EXPORT void f1_V_SD_DPD(struct S_DPD p0, double p1) { }
+EXPORT void f1_V_SD_DPP(struct S_DPP p0, double p1) { }
+EXPORT void f1_V_SD_PII(struct S_PII p0, double p1) { }
+EXPORT void f1_V_SD_PIF(struct S_PIF p0, double p1) { }
+EXPORT void f1_V_SD_PID(struct S_PID p0, double p1) { }
+EXPORT void f1_V_SD_PIP(struct S_PIP p0, double p1) { }
+EXPORT void f1_V_SD_PFI(struct S_PFI p0, double p1) { }
+EXPORT void f1_V_SD_PFF(struct S_PFF p0, double p1) { }
+EXPORT void f1_V_SD_PFD(struct S_PFD p0, double p1) { }
+EXPORT void f1_V_SD_PFP(struct S_PFP p0, double p1) { }
+EXPORT void f1_V_SD_PDI(struct S_PDI p0, double p1) { }
+EXPORT void f1_V_SD_PDF(struct S_PDF p0, double p1) { }
+EXPORT void f1_V_SD_PDD(struct S_PDD p0, double p1) { }
+EXPORT void f1_V_SD_PDP(struct S_PDP p0, double p1) { }
+EXPORT void f1_V_SD_PPI(struct S_PPI p0, double p1) { }
+EXPORT void f1_V_SD_PPF(struct S_PPF p0, double p1) { }
+EXPORT void f1_V_SD_PPD(struct S_PPD p0, double p1) { }
+EXPORT void f1_V_SD_PPP(struct S_PPP p0, double p1) { }
+EXPORT void f1_V_SP_I(struct S_I p0, void* p1) { }
+EXPORT void f1_V_SP_F(struct S_F p0, void* p1) { }
+EXPORT void f1_V_SP_D(struct S_D p0, void* p1) { }
+EXPORT void f1_V_SP_P(struct S_P p0, void* p1) { }
+EXPORT void f1_V_SP_II(struct S_II p0, void* p1) { }
+EXPORT void f1_V_SP_IF(struct S_IF p0, void* p1) { }
+EXPORT void f1_V_SP_ID(struct S_ID p0, void* p1) { }
+EXPORT void f1_V_SP_IP(struct S_IP p0, void* p1) { }
+EXPORT void f1_V_SP_FI(struct S_FI p0, void* p1) { }
+EXPORT void f1_V_SP_FF(struct S_FF p0, void* p1) { }
+EXPORT void f1_V_SP_FD(struct S_FD p0, void* p1) { }
+EXPORT void f1_V_SP_FP(struct S_FP p0, void* p1) { }
+EXPORT void f1_V_SP_DI(struct S_DI p0, void* p1) { }
+EXPORT void f1_V_SP_DF(struct S_DF p0, void* p1) { }
+EXPORT void f1_V_SP_DD(struct S_DD p0, void* p1) { }
+EXPORT void f1_V_SP_DP(struct S_DP p0, void* p1) { }
+EXPORT void f1_V_SP_PI(struct S_PI p0, void* p1) { }
+EXPORT void f1_V_SP_PF(struct S_PF p0, void* p1) { }
+EXPORT void f1_V_SP_PD(struct S_PD p0, void* p1) { }
+EXPORT void f1_V_SP_PP(struct S_PP p0, void* p1) { }
+EXPORT void f1_V_SP_III(struct S_III p0, void* p1) { }
+EXPORT void f1_V_SP_IIF(struct S_IIF p0, void* p1) { }
+EXPORT void f1_V_SP_IID(struct S_IID p0, void* p1) { }
+EXPORT void f1_V_SP_IIP(struct S_IIP p0, void* p1) { }
+EXPORT void f1_V_SP_IFI(struct S_IFI p0, void* p1) { }
+EXPORT void f1_V_SP_IFF(struct S_IFF p0, void* p1) { }
+EXPORT void f1_V_SP_IFD(struct S_IFD p0, void* p1) { }
+EXPORT void f1_V_SP_IFP(struct S_IFP p0, void* p1) { }
+EXPORT void f1_V_SP_IDI(struct S_IDI p0, void* p1) { }
+EXPORT void f1_V_SP_IDF(struct S_IDF p0, void* p1) { }
+EXPORT void f1_V_SP_IDD(struct S_IDD p0, void* p1) { }
+EXPORT void f1_V_SP_IDP(struct S_IDP p0, void* p1) { }
+EXPORT void f1_V_SP_IPI(struct S_IPI p0, void* p1) { }
+EXPORT void f1_V_SP_IPF(struct S_IPF p0, void* p1) { }
+EXPORT void f1_V_SP_IPD(struct S_IPD p0, void* p1) { }
+EXPORT void f1_V_SP_IPP(struct S_IPP p0, void* p1) { }
+EXPORT void f1_V_SP_FII(struct S_FII p0, void* p1) { }
+EXPORT void f1_V_SP_FIF(struct S_FIF p0, void* p1) { }
+EXPORT void f1_V_SP_FID(struct S_FID p0, void* p1) { }
+EXPORT void f1_V_SP_FIP(struct S_FIP p0, void* p1) { }
+EXPORT void f1_V_SP_FFI(struct S_FFI p0, void* p1) { }
+EXPORT void f1_V_SP_FFF(struct S_FFF p0, void* p1) { }
+EXPORT void f1_V_SP_FFD(struct S_FFD p0, void* p1) { }
+EXPORT void f1_V_SP_FFP(struct S_FFP p0, void* p1) { }
+EXPORT void f1_V_SP_FDI(struct S_FDI p0, void* p1) { }
+EXPORT void f1_V_SP_FDF(struct S_FDF p0, void* p1) { }
+EXPORT void f1_V_SP_FDD(struct S_FDD p0, void* p1) { }
+EXPORT void f1_V_SP_FDP(struct S_FDP p0, void* p1) { }
+EXPORT void f1_V_SP_FPI(struct S_FPI p0, void* p1) { }
+EXPORT void f1_V_SP_FPF(struct S_FPF p0, void* p1) { }
+EXPORT void f1_V_SP_FPD(struct S_FPD p0, void* p1) { }
+EXPORT void f1_V_SP_FPP(struct S_FPP p0, void* p1) { }
+EXPORT void f1_V_SP_DII(struct S_DII p0, void* p1) { }
+EXPORT void f1_V_SP_DIF(struct S_DIF p0, void* p1) { }
+EXPORT void f1_V_SP_DID(struct S_DID p0, void* p1) { }
+EXPORT void f1_V_SP_DIP(struct S_DIP p0, void* p1) { }
+EXPORT void f1_V_SP_DFI(struct S_DFI p0, void* p1) { }
+EXPORT void f1_V_SP_DFF(struct S_DFF p0, void* p1) { }
+EXPORT void f1_V_SP_DFD(struct S_DFD p0, void* p1) { }
+EXPORT void f1_V_SP_DFP(struct S_DFP p0, void* p1) { }
+EXPORT void f1_V_SP_DDI(struct S_DDI p0, void* p1) { }
+EXPORT void f1_V_SP_DDF(struct S_DDF p0, void* p1) { }
+EXPORT void f1_V_SP_DDD(struct S_DDD p0, void* p1) { }
+EXPORT void f1_V_SP_DDP(struct S_DDP p0, void* p1) { }
+EXPORT void f1_V_SP_DPI(struct S_DPI p0, void* p1) { }
+EXPORT void f1_V_SP_DPF(struct S_DPF p0, void* p1) { }
+EXPORT void f1_V_SP_DPD(struct S_DPD p0, void* p1) { }
+EXPORT void f1_V_SP_DPP(struct S_DPP p0, void* p1) { }
+EXPORT void f1_V_SP_PII(struct S_PII p0, void* p1) { }
+EXPORT void f1_V_SP_PIF(struct S_PIF p0, void* p1) { }
+EXPORT void f1_V_SP_PID(struct S_PID p0, void* p1) { }
+EXPORT void f1_V_SP_PIP(struct S_PIP p0, void* p1) { }
+EXPORT void f1_V_SP_PFI(struct S_PFI p0, void* p1) { }
+EXPORT void f1_V_SP_PFF(struct S_PFF p0, void* p1) { }
+EXPORT void f1_V_SP_PFD(struct S_PFD p0, void* p1) { }
+EXPORT void f1_V_SP_PFP(struct S_PFP p0, void* p1) { }
+EXPORT void f1_V_SP_PDI(struct S_PDI p0, void* p1) { }
+EXPORT void f1_V_SP_PDF(struct S_PDF p0, void* p1) { }
+EXPORT void f1_V_SP_PDD(struct S_PDD p0, void* p1) { }
+EXPORT void f1_V_SP_PDP(struct S_PDP p0, void* p1) { }
+EXPORT void f1_V_SP_PPI(struct S_PPI p0, void* p1) { }
+EXPORT void f1_V_SP_PPF(struct S_PPF p0, void* p1) { }
+EXPORT void f1_V_SP_PPD(struct S_PPD p0, void* p1) { }
+EXPORT void f1_V_SP_PPP(struct S_PPP p0, void* p1) { }
+EXPORT void f1_V_SS_I(struct S_I p0, struct S_I p1) { }
+EXPORT void f1_V_SS_F(struct S_F p0, struct S_F p1) { }
+EXPORT void f1_V_SS_D(struct S_D p0, struct S_D p1) { }
+EXPORT void f1_V_SS_P(struct S_P p0, struct S_P p1) { }
+EXPORT void f1_V_SS_II(struct S_II p0, struct S_II p1) { }
+EXPORT void f1_V_SS_IF(struct S_IF p0, struct S_IF p1) { }
+EXPORT void f1_V_SS_ID(struct S_ID p0, struct S_ID p1) { }
+EXPORT void f1_V_SS_IP(struct S_IP p0, struct S_IP p1) { }
+EXPORT void f1_V_SS_FI(struct S_FI p0, struct S_FI p1) { }
+EXPORT void f1_V_SS_FF(struct S_FF p0, struct S_FF p1) { }
+EXPORT void f1_V_SS_FD(struct S_FD p0, struct S_FD p1) { }
+EXPORT void f1_V_SS_FP(struct S_FP p0, struct S_FP p1) { }
+EXPORT void f1_V_SS_DI(struct S_DI p0, struct S_DI p1) { }
+EXPORT void f1_V_SS_DF(struct S_DF p0, struct S_DF p1) { }
+EXPORT void f1_V_SS_DD(struct S_DD p0, struct S_DD p1) { }
+EXPORT void f1_V_SS_DP(struct S_DP p0, struct S_DP p1) { }
+EXPORT void f1_V_SS_PI(struct S_PI p0, struct S_PI p1) { }
+EXPORT void f1_V_SS_PF(struct S_PF p0, struct S_PF p1) { }
+EXPORT void f1_V_SS_PD(struct S_PD p0, struct S_PD p1) { }
+EXPORT void f1_V_SS_PP(struct S_PP p0, struct S_PP p1) { }
+EXPORT void f1_V_SS_III(struct S_III p0, struct S_III p1) { }
+EXPORT void f1_V_SS_IIF(struct S_IIF p0, struct S_IIF p1) { }
+EXPORT void f1_V_SS_IID(struct S_IID p0, struct S_IID p1) { }
+EXPORT void f1_V_SS_IIP(struct S_IIP p0, struct S_IIP p1) { }
+EXPORT void f1_V_SS_IFI(struct S_IFI p0, struct S_IFI p1) { }
+EXPORT void f1_V_SS_IFF(struct S_IFF p0, struct S_IFF p1) { }
+EXPORT void f1_V_SS_IFD(struct S_IFD p0, struct S_IFD p1) { }
+EXPORT void f1_V_SS_IFP(struct S_IFP p0, struct S_IFP p1) { }
+EXPORT void f1_V_SS_IDI(struct S_IDI p0, struct S_IDI p1) { }
+EXPORT void f1_V_SS_IDF(struct S_IDF p0, struct S_IDF p1) { }
+EXPORT void f1_V_SS_IDD(struct S_IDD p0, struct S_IDD p1) { }
+EXPORT void f1_V_SS_IDP(struct S_IDP p0, struct S_IDP p1) { }
+EXPORT void f1_V_SS_IPI(struct S_IPI p0, struct S_IPI p1) { }
+EXPORT void f1_V_SS_IPF(struct S_IPF p0, struct S_IPF p1) { }
+EXPORT void f1_V_SS_IPD(struct S_IPD p0, struct S_IPD p1) { }
+EXPORT void f1_V_SS_IPP(struct S_IPP p0, struct S_IPP p1) { }
+EXPORT void f1_V_SS_FII(struct S_FII p0, struct S_FII p1) { }
+EXPORT void f1_V_SS_FIF(struct S_FIF p0, struct S_FIF p1) { }
+EXPORT void f1_V_SS_FID(struct S_FID p0, struct S_FID p1) { }
+EXPORT void f1_V_SS_FIP(struct S_FIP p0, struct S_FIP p1) { }
+EXPORT void f1_V_SS_FFI(struct S_FFI p0, struct S_FFI p1) { }
+EXPORT void f1_V_SS_FFF(struct S_FFF p0, struct S_FFF p1) { }
+EXPORT void f1_V_SS_FFD(struct S_FFD p0, struct S_FFD p1) { }
+EXPORT void f1_V_SS_FFP(struct S_FFP p0, struct S_FFP p1) { }
+EXPORT void f1_V_SS_FDI(struct S_FDI p0, struct S_FDI p1) { }
+EXPORT void f1_V_SS_FDF(struct S_FDF p0, struct S_FDF p1) { }
+EXPORT void f1_V_SS_FDD(struct S_FDD p0, struct S_FDD p1) { }
+EXPORT void f1_V_SS_FDP(struct S_FDP p0, struct S_FDP p1) { }
+EXPORT void f1_V_SS_FPI(struct S_FPI p0, struct S_FPI p1) { }
+EXPORT void f1_V_SS_FPF(struct S_FPF p0, struct S_FPF p1) { }
+EXPORT void f1_V_SS_FPD(struct S_FPD p0, struct S_FPD p1) { }
+EXPORT void f1_V_SS_FPP(struct S_FPP p0, struct S_FPP p1) { }
+EXPORT void f1_V_SS_DII(struct S_DII p0, struct S_DII p1) { }
+EXPORT void f1_V_SS_DIF(struct S_DIF p0, struct S_DIF p1) { }
+EXPORT void f1_V_SS_DID(struct S_DID p0, struct S_DID p1) { }
+EXPORT void f1_V_SS_DIP(struct S_DIP p0, struct S_DIP p1) { }
+EXPORT void f1_V_SS_DFI(struct S_DFI p0, struct S_DFI p1) { }
+EXPORT void f1_V_SS_DFF(struct S_DFF p0, struct S_DFF p1) { }
+EXPORT void f1_V_SS_DFD(struct S_DFD p0, struct S_DFD p1) { }
+EXPORT void f1_V_SS_DFP(struct S_DFP p0, struct S_DFP p1) { }
+EXPORT void f1_V_SS_DDI(struct S_DDI p0, struct S_DDI p1) { }
+EXPORT void f1_V_SS_DDF(struct S_DDF p0, struct S_DDF p1) { }
+EXPORT void f1_V_SS_DDD(struct S_DDD p0, struct S_DDD p1) { }
+EXPORT void f1_V_SS_DDP(struct S_DDP p0, struct S_DDP p1) { }
+EXPORT void f1_V_SS_DPI(struct S_DPI p0, struct S_DPI p1) { }
+EXPORT void f1_V_SS_DPF(struct S_DPF p0, struct S_DPF p1) { }
+EXPORT void f1_V_SS_DPD(struct S_DPD p0, struct S_DPD p1) { }
+EXPORT void f1_V_SS_DPP(struct S_DPP p0, struct S_DPP p1) { }
+EXPORT void f1_V_SS_PII(struct S_PII p0, struct S_PII p1) { }
+EXPORT void f1_V_SS_PIF(struct S_PIF p0, struct S_PIF p1) { }
+EXPORT void f1_V_SS_PID(struct S_PID p0, struct S_PID p1) { }
+EXPORT void f1_V_SS_PIP(struct S_PIP p0, struct S_PIP p1) { }
+EXPORT void f1_V_SS_PFI(struct S_PFI p0, struct S_PFI p1) { }
+EXPORT void f1_V_SS_PFF(struct S_PFF p0, struct S_PFF p1) { }
+EXPORT void f1_V_SS_PFD(struct S_PFD p0, struct S_PFD p1) { }
+EXPORT void f1_V_SS_PFP(struct S_PFP p0, struct S_PFP p1) { }
+EXPORT void f1_V_SS_PDI(struct S_PDI p0, struct S_PDI p1) { }
+EXPORT void f1_V_SS_PDF(struct S_PDF p0, struct S_PDF p1) { }
+EXPORT void f1_V_SS_PDD(struct S_PDD p0, struct S_PDD p1) { }
+EXPORT void f1_V_SS_PDP(struct S_PDP p0, struct S_PDP p1) { }
+EXPORT void f1_V_SS_PPI(struct S_PPI p0, struct S_PPI p1) { }
+EXPORT void f1_V_SS_PPF(struct S_PPF p0, struct S_PPF p1) { }
+EXPORT void f1_V_SS_PPD(struct S_PPD p0, struct S_PPD p1) { }
+EXPORT void f1_V_SS_PPP(struct S_PPP p0, struct S_PPP p1) { }
+EXPORT void f1_V_III_(int p0, int p1, int p2) { }
+EXPORT void f1_V_IIF_(int p0, int p1, float p2) { }
+EXPORT void f1_V_IID_(int p0, int p1, double p2) { }
+EXPORT void f1_V_IIP_(int p0, int p1, void* p2) { }
+EXPORT void f1_V_IIS_I(int p0, int p1, struct S_I p2) { }
+EXPORT void f1_V_IIS_F(int p0, int p1, struct S_F p2) { }
+EXPORT void f1_V_IIS_D(int p0, int p1, struct S_D p2) { }
+EXPORT void f1_V_IIS_P(int p0, int p1, struct S_P p2) { }
+EXPORT void f1_V_IIS_II(int p0, int p1, struct S_II p2) { }
+EXPORT void f1_V_IIS_IF(int p0, int p1, struct S_IF p2) { }
+EXPORT void f1_V_IIS_ID(int p0, int p1, struct S_ID p2) { }
+EXPORT void f1_V_IIS_IP(int p0, int p1, struct S_IP p2) { }
+EXPORT void f1_V_IIS_FI(int p0, int p1, struct S_FI p2) { }
+EXPORT void f1_V_IIS_FF(int p0, int p1, struct S_FF p2) { }
+EXPORT void f1_V_IIS_FD(int p0, int p1, struct S_FD p2) { }
+EXPORT void f1_V_IIS_FP(int p0, int p1, struct S_FP p2) { }
+EXPORT void f1_V_IIS_DI(int p0, int p1, struct S_DI p2) { }
+EXPORT void f1_V_IIS_DF(int p0, int p1, struct S_DF p2) { }
+EXPORT void f1_V_IIS_DD(int p0, int p1, struct S_DD p2) { }
+EXPORT void f1_V_IIS_DP(int p0, int p1, struct S_DP p2) { }
+EXPORT void f1_V_IIS_PI(int p0, int p1, struct S_PI p2) { }
+EXPORT void f1_V_IIS_PF(int p0, int p1, struct S_PF p2) { }
+EXPORT void f1_V_IIS_PD(int p0, int p1, struct S_PD p2) { }
+EXPORT void f1_V_IIS_PP(int p0, int p1, struct S_PP p2) { }
+EXPORT void f1_V_IIS_III(int p0, int p1, struct S_III p2) { }
+EXPORT void f1_V_IIS_IIF(int p0, int p1, struct S_IIF p2) { }
+EXPORT void f1_V_IIS_IID(int p0, int p1, struct S_IID p2) { }
+EXPORT void f1_V_IIS_IIP(int p0, int p1, struct S_IIP p2) { }
+EXPORT void f1_V_IIS_IFI(int p0, int p1, struct S_IFI p2) { }
+EXPORT void f1_V_IIS_IFF(int p0, int p1, struct S_IFF p2) { }
+EXPORT void f1_V_IIS_IFD(int p0, int p1, struct S_IFD p2) { }
+EXPORT void f1_V_IIS_IFP(int p0, int p1, struct S_IFP p2) { }
+EXPORT void f1_V_IIS_IDI(int p0, int p1, struct S_IDI p2) { }
+EXPORT void f1_V_IIS_IDF(int p0, int p1, struct S_IDF p2) { }
+EXPORT void f1_V_IIS_IDD(int p0, int p1, struct S_IDD p2) { }
+EXPORT void f1_V_IIS_IDP(int p0, int p1, struct S_IDP p2) { }
+EXPORT void f1_V_IIS_IPI(int p0, int p1, struct S_IPI p2) { }
+EXPORT void f1_V_IIS_IPF(int p0, int p1, struct S_IPF p2) { }
+EXPORT void f1_V_IIS_IPD(int p0, int p1, struct S_IPD p2) { }
+EXPORT void f1_V_IIS_IPP(int p0, int p1, struct S_IPP p2) { }
+EXPORT void f1_V_IIS_FII(int p0, int p1, struct S_FII p2) { }
+EXPORT void f1_V_IIS_FIF(int p0, int p1, struct S_FIF p2) { }
+EXPORT void f1_V_IIS_FID(int p0, int p1, struct S_FID p2) { }
+EXPORT void f1_V_IIS_FIP(int p0, int p1, struct S_FIP p2) { }
+EXPORT void f1_V_IIS_FFI(int p0, int p1, struct S_FFI p2) { }
+EXPORT void f1_V_IIS_FFF(int p0, int p1, struct S_FFF p2) { }
+EXPORT void f1_V_IIS_FFD(int p0, int p1, struct S_FFD p2) { }
+EXPORT void f1_V_IIS_FFP(int p0, int p1, struct S_FFP p2) { }
+EXPORT void f1_V_IIS_FDI(int p0, int p1, struct S_FDI p2) { }
+EXPORT void f1_V_IIS_FDF(int p0, int p1, struct S_FDF p2) { }
+EXPORT void f1_V_IIS_FDD(int p0, int p1, struct S_FDD p2) { }
+EXPORT void f1_V_IIS_FDP(int p0, int p1, struct S_FDP p2) { }
+EXPORT void f1_V_IIS_FPI(int p0, int p1, struct S_FPI p2) { }
+EXPORT void f1_V_IIS_FPF(int p0, int p1, struct S_FPF p2) { }
+EXPORT void f1_V_IIS_FPD(int p0, int p1, struct S_FPD p2) { }
+EXPORT void f1_V_IIS_FPP(int p0, int p1, struct S_FPP p2) { }
+EXPORT void f1_V_IIS_DII(int p0, int p1, struct S_DII p2) { }
+EXPORT void f1_V_IIS_DIF(int p0, int p1, struct S_DIF p2) { }
+EXPORT void f1_V_IIS_DID(int p0, int p1, struct S_DID p2) { }
+EXPORT void f1_V_IIS_DIP(int p0, int p1, struct S_DIP p2) { }
+EXPORT void f1_V_IIS_DFI(int p0, int p1, struct S_DFI p2) { }
+EXPORT void f1_V_IIS_DFF(int p0, int p1, struct S_DFF p2) { }
+EXPORT void f1_V_IIS_DFD(int p0, int p1, struct S_DFD p2) { }
+EXPORT void f1_V_IIS_DFP(int p0, int p1, struct S_DFP p2) { }
+EXPORT void f1_V_IIS_DDI(int p0, int p1, struct S_DDI p2) { }
+EXPORT void f1_V_IIS_DDF(int p0, int p1, struct S_DDF p2) { }
+EXPORT void f1_V_IIS_DDD(int p0, int p1, struct S_DDD p2) { }
+EXPORT void f1_V_IIS_DDP(int p0, int p1, struct S_DDP p2) { }
+EXPORT void f1_V_IIS_DPI(int p0, int p1, struct S_DPI p2) { }
+EXPORT void f1_V_IIS_DPF(int p0, int p1, struct S_DPF p2) { }
+EXPORT void f1_V_IIS_DPD(int p0, int p1, struct S_DPD p2) { }
+EXPORT void f1_V_IIS_DPP(int p0, int p1, struct S_DPP p2) { }
+EXPORT void f1_V_IIS_PII(int p0, int p1, struct S_PII p2) { }
+EXPORT void f1_V_IIS_PIF(int p0, int p1, struct S_PIF p2) { }
+EXPORT void f1_V_IIS_PID(int p0, int p1, struct S_PID p2) { }
+EXPORT void f1_V_IIS_PIP(int p0, int p1, struct S_PIP p2) { }
+EXPORT void f1_V_IIS_PFI(int p0, int p1, struct S_PFI p2) { }
+EXPORT void f1_V_IIS_PFF(int p0, int p1, struct S_PFF p2) { }
+EXPORT void f1_V_IIS_PFD(int p0, int p1, struct S_PFD p2) { }
+EXPORT void f1_V_IIS_PFP(int p0, int p1, struct S_PFP p2) { }
+EXPORT void f1_V_IIS_PDI(int p0, int p1, struct S_PDI p2) { }
+EXPORT void f1_V_IIS_PDF(int p0, int p1, struct S_PDF p2) { }
+EXPORT void f1_V_IIS_PDD(int p0, int p1, struct S_PDD p2) { }
+EXPORT void f1_V_IIS_PDP(int p0, int p1, struct S_PDP p2) { }
+EXPORT void f1_V_IIS_PPI(int p0, int p1, struct S_PPI p2) { }
+EXPORT void f1_V_IIS_PPF(int p0, int p1, struct S_PPF p2) { }
+EXPORT void f1_V_IIS_PPD(int p0, int p1, struct S_PPD p2) { }
+EXPORT void f1_V_IIS_PPP(int p0, int p1, struct S_PPP p2) { }
+EXPORT void f1_V_IFI_(int p0, float p1, int p2) { }
+EXPORT void f1_V_IFF_(int p0, float p1, float p2) { }
+EXPORT void f1_V_IFD_(int p0, float p1, double p2) { }
+EXPORT void f1_V_IFP_(int p0, float p1, void* p2) { }
+EXPORT void f1_V_IFS_I(int p0, float p1, struct S_I p2) { }
+EXPORT void f1_V_IFS_F(int p0, float p1, struct S_F p2) { }
+EXPORT void f1_V_IFS_D(int p0, float p1, struct S_D p2) { }
+EXPORT void f1_V_IFS_P(int p0, float p1, struct S_P p2) { }
+EXPORT void f1_V_IFS_II(int p0, float p1, struct S_II p2) { }
+EXPORT void f1_V_IFS_IF(int p0, float p1, struct S_IF p2) { }
+EXPORT void f1_V_IFS_ID(int p0, float p1, struct S_ID p2) { }
+EXPORT void f1_V_IFS_IP(int p0, float p1, struct S_IP p2) { }
+EXPORT void f1_V_IFS_FI(int p0, float p1, struct S_FI p2) { }
+EXPORT void f1_V_IFS_FF(int p0, float p1, struct S_FF p2) { }
+EXPORT void f1_V_IFS_FD(int p0, float p1, struct S_FD p2) { }
+EXPORT void f1_V_IFS_FP(int p0, float p1, struct S_FP p2) { }
+EXPORT void f1_V_IFS_DI(int p0, float p1, struct S_DI p2) { }
+EXPORT void f1_V_IFS_DF(int p0, float p1, struct S_DF p2) { }
+EXPORT void f1_V_IFS_DD(int p0, float p1, struct S_DD p2) { }
+EXPORT void f1_V_IFS_DP(int p0, float p1, struct S_DP p2) { }
+EXPORT void f1_V_IFS_PI(int p0, float p1, struct S_PI p2) { }
+EXPORT void f1_V_IFS_PF(int p0, float p1, struct S_PF p2) { }
+EXPORT void f1_V_IFS_PD(int p0, float p1, struct S_PD p2) { }
+EXPORT void f1_V_IFS_PP(int p0, float p1, struct S_PP p2) { }
+EXPORT void f1_V_IFS_III(int p0, float p1, struct S_III p2) { }
+EXPORT void f1_V_IFS_IIF(int p0, float p1, struct S_IIF p2) { }
+EXPORT void f1_V_IFS_IID(int p0, float p1, struct S_IID p2) { }
+EXPORT void f1_V_IFS_IIP(int p0, float p1, struct S_IIP p2) { }
+EXPORT void f1_V_IFS_IFI(int p0, float p1, struct S_IFI p2) { }
+EXPORT void f1_V_IFS_IFF(int p0, float p1, struct S_IFF p2) { }
+EXPORT void f1_V_IFS_IFD(int p0, float p1, struct S_IFD p2) { }
+EXPORT void f1_V_IFS_IFP(int p0, float p1, struct S_IFP p2) { }
+EXPORT void f1_V_IFS_IDI(int p0, float p1, struct S_IDI p2) { }
+EXPORT void f1_V_IFS_IDF(int p0, float p1, struct S_IDF p2) { }
+EXPORT void f1_V_IFS_IDD(int p0, float p1, struct S_IDD p2) { }
+EXPORT void f1_V_IFS_IDP(int p0, float p1, struct S_IDP p2) { }
+EXPORT void f1_V_IFS_IPI(int p0, float p1, struct S_IPI p2) { }
+EXPORT void f1_V_IFS_IPF(int p0, float p1, struct S_IPF p2) { }
+EXPORT void f1_V_IFS_IPD(int p0, float p1, struct S_IPD p2) { }
+EXPORT void f1_V_IFS_IPP(int p0, float p1, struct S_IPP p2) { }
+EXPORT void f1_V_IFS_FII(int p0, float p1, struct S_FII p2) { }
+EXPORT void f1_V_IFS_FIF(int p0, float p1, struct S_FIF p2) { }
+EXPORT void f1_V_IFS_FID(int p0, float p1, struct S_FID p2) { }
+EXPORT void f1_V_IFS_FIP(int p0, float p1, struct S_FIP p2) { }
+EXPORT void f1_V_IFS_FFI(int p0, float p1, struct S_FFI p2) { }
+EXPORT void f1_V_IFS_FFF(int p0, float p1, struct S_FFF p2) { }
+EXPORT void f1_V_IFS_FFD(int p0, float p1, struct S_FFD p2) { }
+EXPORT void f1_V_IFS_FFP(int p0, float p1, struct S_FFP p2) { }
+EXPORT void f1_V_IFS_FDI(int p0, float p1, struct S_FDI p2) { }
+EXPORT void f1_V_IFS_FDF(int p0, float p1, struct S_FDF p2) { }
+EXPORT void f1_V_IFS_FDD(int p0, float p1, struct S_FDD p2) { }
+EXPORT void f1_V_IFS_FDP(int p0, float p1, struct S_FDP p2) { }
+EXPORT void f1_V_IFS_FPI(int p0, float p1, struct S_FPI p2) { }
+EXPORT void f1_V_IFS_FPF(int p0, float p1, struct S_FPF p2) { }
+EXPORT void f1_V_IFS_FPD(int p0, float p1, struct S_FPD p2) { }
+EXPORT void f1_V_IFS_FPP(int p0, float p1, struct S_FPP p2) { }
+EXPORT void f1_V_IFS_DII(int p0, float p1, struct S_DII p2) { }
+EXPORT void f1_V_IFS_DIF(int p0, float p1, struct S_DIF p2) { }
+EXPORT void f1_V_IFS_DID(int p0, float p1, struct S_DID p2) { }
+EXPORT void f1_V_IFS_DIP(int p0, float p1, struct S_DIP p2) { }
+EXPORT void f1_V_IFS_DFI(int p0, float p1, struct S_DFI p2) { }
+EXPORT void f1_V_IFS_DFF(int p0, float p1, struct S_DFF p2) { }
+EXPORT void f1_V_IFS_DFD(int p0, float p1, struct S_DFD p2) { }
+EXPORT void f1_V_IFS_DFP(int p0, float p1, struct S_DFP p2) { }
+EXPORT void f1_V_IFS_DDI(int p0, float p1, struct S_DDI p2) { }
+EXPORT void f1_V_IFS_DDF(int p0, float p1, struct S_DDF p2) { }
+EXPORT void f1_V_IFS_DDD(int p0, float p1, struct S_DDD p2) { }
+EXPORT void f1_V_IFS_DDP(int p0, float p1, struct S_DDP p2) { }
+EXPORT void f1_V_IFS_DPI(int p0, float p1, struct S_DPI p2) { }
+EXPORT void f1_V_IFS_DPF(int p0, float p1, struct S_DPF p2) { }
+EXPORT void f1_V_IFS_DPD(int p0, float p1, struct S_DPD p2) { }
+EXPORT void f1_V_IFS_DPP(int p0, float p1, struct S_DPP p2) { }
+EXPORT void f1_V_IFS_PII(int p0, float p1, struct S_PII p2) { }
+EXPORT void f1_V_IFS_PIF(int p0, float p1, struct S_PIF p2) { }
+EXPORT void f1_V_IFS_PID(int p0, float p1, struct S_PID p2) { }
+EXPORT void f1_V_IFS_PIP(int p0, float p1, struct S_PIP p2) { }
+EXPORT void f1_V_IFS_PFI(int p0, float p1, struct S_PFI p2) { }
+EXPORT void f1_V_IFS_PFF(int p0, float p1, struct S_PFF p2) { }
+EXPORT void f1_V_IFS_PFD(int p0, float p1, struct S_PFD p2) { }
+EXPORT void f1_V_IFS_PFP(int p0, float p1, struct S_PFP p2) { }
+EXPORT void f1_V_IFS_PDI(int p0, float p1, struct S_PDI p2) { }
+EXPORT void f1_V_IFS_PDF(int p0, float p1, struct S_PDF p2) { }
+EXPORT void f1_V_IFS_PDD(int p0, float p1, struct S_PDD p2) { }
+EXPORT void f1_V_IFS_PDP(int p0, float p1, struct S_PDP p2) { }
+EXPORT void f1_V_IFS_PPI(int p0, float p1, struct S_PPI p2) { }
+EXPORT void f1_V_IFS_PPF(int p0, float p1, struct S_PPF p2) { }
+EXPORT void f1_V_IFS_PPD(int p0, float p1, struct S_PPD p2) { }
+EXPORT void f1_V_IFS_PPP(int p0, float p1, struct S_PPP p2) { }
+EXPORT void f1_V_IDI_(int p0, double p1, int p2) { }
+EXPORT void f1_V_IDF_(int p0, double p1, float p2) { }
+EXPORT void f1_V_IDD_(int p0, double p1, double p2) { }
+EXPORT void f1_V_IDP_(int p0, double p1, void* p2) { }
+EXPORT void f1_V_IDS_I(int p0, double p1, struct S_I p2) { }
+EXPORT void f1_V_IDS_F(int p0, double p1, struct S_F p2) { }
+EXPORT void f1_V_IDS_D(int p0, double p1, struct S_D p2) { }
+EXPORT void f1_V_IDS_P(int p0, double p1, struct S_P p2) { }
+EXPORT void f1_V_IDS_II(int p0, double p1, struct S_II p2) { }
+EXPORT void f1_V_IDS_IF(int p0, double p1, struct S_IF p2) { }
+EXPORT void f1_V_IDS_ID(int p0, double p1, struct S_ID p2) { }
+EXPORT void f1_V_IDS_IP(int p0, double p1, struct S_IP p2) { }
+EXPORT void f1_V_IDS_FI(int p0, double p1, struct S_FI p2) { }
+EXPORT void f1_V_IDS_FF(int p0, double p1, struct S_FF p2) { }
+EXPORT void f1_V_IDS_FD(int p0, double p1, struct S_FD p2) { }
+EXPORT void f1_V_IDS_FP(int p0, double p1, struct S_FP p2) { }
+EXPORT void f1_V_IDS_DI(int p0, double p1, struct S_DI p2) { }
+EXPORT void f1_V_IDS_DF(int p0, double p1, struct S_DF p2) { }
+EXPORT void f1_V_IDS_DD(int p0, double p1, struct S_DD p2) { }
+EXPORT void f1_V_IDS_DP(int p0, double p1, struct S_DP p2) { }
+EXPORT void f1_V_IDS_PI(int p0, double p1, struct S_PI p2) { }
+EXPORT void f1_V_IDS_PF(int p0, double p1, struct S_PF p2) { }
+EXPORT void f1_V_IDS_PD(int p0, double p1, struct S_PD p2) { }
+EXPORT void f1_V_IDS_PP(int p0, double p1, struct S_PP p2) { }
+EXPORT void f1_V_IDS_III(int p0, double p1, struct S_III p2) { }
+EXPORT void f1_V_IDS_IIF(int p0, double p1, struct S_IIF p2) { }
+EXPORT void f1_V_IDS_IID(int p0, double p1, struct S_IID p2) { }
+EXPORT void f1_V_IDS_IIP(int p0, double p1, struct S_IIP p2) { }
+EXPORT void f1_V_IDS_IFI(int p0, double p1, struct S_IFI p2) { }
+EXPORT void f1_V_IDS_IFF(int p0, double p1, struct S_IFF p2) { }
+EXPORT void f1_V_IDS_IFD(int p0, double p1, struct S_IFD p2) { }
+EXPORT void f1_V_IDS_IFP(int p0, double p1, struct S_IFP p2) { }
+EXPORT void f1_V_IDS_IDI(int p0, double p1, struct S_IDI p2) { }
+EXPORT void f1_V_IDS_IDF(int p0, double p1, struct S_IDF p2) { }
+EXPORT void f1_V_IDS_IDD(int p0, double p1, struct S_IDD p2) { }
+EXPORT void f1_V_IDS_IDP(int p0, double p1, struct S_IDP p2) { }
+EXPORT void f1_V_IDS_IPI(int p0, double p1, struct S_IPI p2) { }
+EXPORT void f1_V_IDS_IPF(int p0, double p1, struct S_IPF p2) { }
+EXPORT void f1_V_IDS_IPD(int p0, double p1, struct S_IPD p2) { }
+EXPORT void f1_V_IDS_IPP(int p0, double p1, struct S_IPP p2) { }
+EXPORT void f1_V_IDS_FII(int p0, double p1, struct S_FII p2) { }
+EXPORT void f1_V_IDS_FIF(int p0, double p1, struct S_FIF p2) { }
+EXPORT void f1_V_IDS_FID(int p0, double p1, struct S_FID p2) { }
+EXPORT void f1_V_IDS_FIP(int p0, double p1, struct S_FIP p2) { }
+EXPORT void f1_V_IDS_FFI(int p0, double p1, struct S_FFI p2) { }
+EXPORT void f1_V_IDS_FFF(int p0, double p1, struct S_FFF p2) { }
+EXPORT void f1_V_IDS_FFD(int p0, double p1, struct S_FFD p2) { }
+EXPORT void f1_V_IDS_FFP(int p0, double p1, struct S_FFP p2) { }
+EXPORT void f1_V_IDS_FDI(int p0, double p1, struct S_FDI p2) { }
+EXPORT void f1_V_IDS_FDF(int p0, double p1, struct S_FDF p2) { }
+EXPORT void f1_V_IDS_FDD(int p0, double p1, struct S_FDD p2) { }
+EXPORT void f1_V_IDS_FDP(int p0, double p1, struct S_FDP p2) { }
+EXPORT void f1_V_IDS_FPI(int p0, double p1, struct S_FPI p2) { }
+EXPORT void f1_V_IDS_FPF(int p0, double p1, struct S_FPF p2) { }
+EXPORT void f1_V_IDS_FPD(int p0, double p1, struct S_FPD p2) { }
+EXPORT void f1_V_IDS_FPP(int p0, double p1, struct S_FPP p2) { }
+EXPORT void f1_V_IDS_DII(int p0, double p1, struct S_DII p2) { }
+EXPORT void f1_V_IDS_DIF(int p0, double p1, struct S_DIF p2) { }
+EXPORT void f1_V_IDS_DID(int p0, double p1, struct S_DID p2) { }
+EXPORT void f1_V_IDS_DIP(int p0, double p1, struct S_DIP p2) { }
+EXPORT void f1_V_IDS_DFI(int p0, double p1, struct S_DFI p2) { }
+EXPORT void f1_V_IDS_DFF(int p0, double p1, struct S_DFF p2) { }
+EXPORT void f1_V_IDS_DFD(int p0, double p1, struct S_DFD p2) { }
+EXPORT void f1_V_IDS_DFP(int p0, double p1, struct S_DFP p2) { }
+EXPORT void f1_V_IDS_DDI(int p0, double p1, struct S_DDI p2) { }
+EXPORT void f1_V_IDS_DDF(int p0, double p1, struct S_DDF p2) { }
+EXPORT void f1_V_IDS_DDD(int p0, double p1, struct S_DDD p2) { }
+EXPORT void f1_V_IDS_DDP(int p0, double p1, struct S_DDP p2) { }
+EXPORT void f1_V_IDS_DPI(int p0, double p1, struct S_DPI p2) { }
+EXPORT void f1_V_IDS_DPF(int p0, double p1, struct S_DPF p2) { }
+EXPORT void f1_V_IDS_DPD(int p0, double p1, struct S_DPD p2) { }
+EXPORT void f1_V_IDS_DPP(int p0, double p1, struct S_DPP p2) { }
+EXPORT void f1_V_IDS_PII(int p0, double p1, struct S_PII p2) { }
+EXPORT void f1_V_IDS_PIF(int p0, double p1, struct S_PIF p2) { }
+EXPORT void f1_V_IDS_PID(int p0, double p1, struct S_PID p2) { }
+EXPORT void f1_V_IDS_PIP(int p0, double p1, struct S_PIP p2) { }
+EXPORT void f1_V_IDS_PFI(int p0, double p1, struct S_PFI p2) { }
+EXPORT void f1_V_IDS_PFF(int p0, double p1, struct S_PFF p2) { }
+EXPORT void f1_V_IDS_PFD(int p0, double p1, struct S_PFD p2) { }
+EXPORT void f1_V_IDS_PFP(int p0, double p1, struct S_PFP p2) { }
+EXPORT void f1_V_IDS_PDI(int p0, double p1, struct S_PDI p2) { }
+EXPORT void f1_V_IDS_PDF(int p0, double p1, struct S_PDF p2) { }
+EXPORT void f1_V_IDS_PDD(int p0, double p1, struct S_PDD p2) { }
+EXPORT void f1_V_IDS_PDP(int p0, double p1, struct S_PDP p2) { }
+EXPORT void f1_V_IDS_PPI(int p0, double p1, struct S_PPI p2) { }
+EXPORT void f1_V_IDS_PPF(int p0, double p1, struct S_PPF p2) { }
+EXPORT void f1_V_IDS_PPD(int p0, double p1, struct S_PPD p2) { }
+EXPORT void f1_V_IDS_PPP(int p0, double p1, struct S_PPP p2) { }
+EXPORT void f1_V_IPI_(int p0, void* p1, int p2) { }
+EXPORT void f1_V_IPF_(int p0, void* p1, float p2) { }
+EXPORT void f1_V_IPD_(int p0, void* p1, double p2) { }
+EXPORT void f1_V_IPP_(int p0, void* p1, void* p2) { }
+EXPORT void f1_V_IPS_I(int p0, void* p1, struct S_I p2) { }
+EXPORT void f1_V_IPS_F(int p0, void* p1, struct S_F p2) { }
+EXPORT void f1_V_IPS_D(int p0, void* p1, struct S_D p2) { }
+EXPORT void f1_V_IPS_P(int p0, void* p1, struct S_P p2) { }
+EXPORT void f1_V_IPS_II(int p0, void* p1, struct S_II p2) { }
+EXPORT void f1_V_IPS_IF(int p0, void* p1, struct S_IF p2) { }
+EXPORT void f1_V_IPS_ID(int p0, void* p1, struct S_ID p2) { }
+EXPORT void f1_V_IPS_IP(int p0, void* p1, struct S_IP p2) { }
+EXPORT void f1_V_IPS_FI(int p0, void* p1, struct S_FI p2) { }
+EXPORT void f1_V_IPS_FF(int p0, void* p1, struct S_FF p2) { }
+EXPORT void f1_V_IPS_FD(int p0, void* p1, struct S_FD p2) { }
+EXPORT void f1_V_IPS_FP(int p0, void* p1, struct S_FP p2) { }
+EXPORT void f1_V_IPS_DI(int p0, void* p1, struct S_DI p2) { }
+EXPORT void f1_V_IPS_DF(int p0, void* p1, struct S_DF p2) { }
+EXPORT void f1_V_IPS_DD(int p0, void* p1, struct S_DD p2) { }
+EXPORT void f1_V_IPS_DP(int p0, void* p1, struct S_DP p2) { }
+EXPORT void f1_V_IPS_PI(int p0, void* p1, struct S_PI p2) { }
+EXPORT void f1_V_IPS_PF(int p0, void* p1, struct S_PF p2) { }
+EXPORT void f1_V_IPS_PD(int p0, void* p1, struct S_PD p2) { }
+EXPORT void f1_V_IPS_PP(int p0, void* p1, struct S_PP p2) { }
+EXPORT void f1_V_IPS_III(int p0, void* p1, struct S_III p2) { }
+EXPORT void f1_V_IPS_IIF(int p0, void* p1, struct S_IIF p2) { }
+EXPORT void f1_V_IPS_IID(int p0, void* p1, struct S_IID p2) { }
+EXPORT void f1_V_IPS_IIP(int p0, void* p1, struct S_IIP p2) { }
+EXPORT void f1_V_IPS_IFI(int p0, void* p1, struct S_IFI p2) { }
+EXPORT void f1_V_IPS_IFF(int p0, void* p1, struct S_IFF p2) { }
+EXPORT void f1_V_IPS_IFD(int p0, void* p1, struct S_IFD p2) { }
+EXPORT void f1_V_IPS_IFP(int p0, void* p1, struct S_IFP p2) { }
+EXPORT void f1_V_IPS_IDI(int p0, void* p1, struct S_IDI p2) { }
+EXPORT void f1_V_IPS_IDF(int p0, void* p1, struct S_IDF p2) { }
+EXPORT void f1_V_IPS_IDD(int p0, void* p1, struct S_IDD p2) { }
+EXPORT void f1_V_IPS_IDP(int p0, void* p1, struct S_IDP p2) { }
+EXPORT void f1_V_IPS_IPI(int p0, void* p1, struct S_IPI p2) { }
+EXPORT void f1_V_IPS_IPF(int p0, void* p1, struct S_IPF p2) { }
+EXPORT void f1_V_IPS_IPD(int p0, void* p1, struct S_IPD p2) { }
+EXPORT void f1_V_IPS_IPP(int p0, void* p1, struct S_IPP p2) { }
+EXPORT void f1_V_IPS_FII(int p0, void* p1, struct S_FII p2) { }
+EXPORT void f1_V_IPS_FIF(int p0, void* p1, struct S_FIF p2) { }
+EXPORT void f1_V_IPS_FID(int p0, void* p1, struct S_FID p2) { }
+EXPORT void f1_V_IPS_FIP(int p0, void* p1, struct S_FIP p2) { }
+EXPORT void f1_V_IPS_FFI(int p0, void* p1, struct S_FFI p2) { }
+EXPORT void f1_V_IPS_FFF(int p0, void* p1, struct S_FFF p2) { }
+EXPORT void f1_V_IPS_FFD(int p0, void* p1, struct S_FFD p2) { }
+EXPORT void f1_V_IPS_FFP(int p0, void* p1, struct S_FFP p2) { }
+EXPORT void f1_V_IPS_FDI(int p0, void* p1, struct S_FDI p2) { }
+EXPORT void f1_V_IPS_FDF(int p0, void* p1, struct S_FDF p2) { }
+EXPORT void f1_V_IPS_FDD(int p0, void* p1, struct S_FDD p2) { }
+EXPORT void f1_V_IPS_FDP(int p0, void* p1, struct S_FDP p2) { }
+EXPORT void f1_V_IPS_FPI(int p0, void* p1, struct S_FPI p2) { }
+EXPORT void f1_V_IPS_FPF(int p0, void* p1, struct S_FPF p2) { }
+EXPORT void f1_V_IPS_FPD(int p0, void* p1, struct S_FPD p2) { }
+EXPORT void f1_V_IPS_FPP(int p0, void* p1, struct S_FPP p2) { }
+EXPORT void f1_V_IPS_DII(int p0, void* p1, struct S_DII p2) { }
+EXPORT void f1_V_IPS_DIF(int p0, void* p1, struct S_DIF p2) { }
+EXPORT void f1_V_IPS_DID(int p0, void* p1, struct S_DID p2) { }
+EXPORT void f1_V_IPS_DIP(int p0, void* p1, struct S_DIP p2) { }
+EXPORT void f1_V_IPS_DFI(int p0, void* p1, struct S_DFI p2) { }
+EXPORT void f1_V_IPS_DFF(int p0, void* p1, struct S_DFF p2) { }
+EXPORT void f1_V_IPS_DFD(int p0, void* p1, struct S_DFD p2) { }
+EXPORT void f1_V_IPS_DFP(int p0, void* p1, struct S_DFP p2) { }
+EXPORT void f1_V_IPS_DDI(int p0, void* p1, struct S_DDI p2) { }
+EXPORT void f1_V_IPS_DDF(int p0, void* p1, struct S_DDF p2) { }
+EXPORT void f1_V_IPS_DDD(int p0, void* p1, struct S_DDD p2) { }
+EXPORT void f1_V_IPS_DDP(int p0, void* p1, struct S_DDP p2) { }
+EXPORT void f1_V_IPS_DPI(int p0, void* p1, struct S_DPI p2) { }
+EXPORT void f1_V_IPS_DPF(int p0, void* p1, struct S_DPF p2) { }
+EXPORT void f1_V_IPS_DPD(int p0, void* p1, struct S_DPD p2) { }
+EXPORT void f1_V_IPS_DPP(int p0, void* p1, struct S_DPP p2) { }
+EXPORT void f1_V_IPS_PII(int p0, void* p1, struct S_PII p2) { }
+EXPORT void f1_V_IPS_PIF(int p0, void* p1, struct S_PIF p2) { }
+EXPORT void f1_V_IPS_PID(int p0, void* p1, struct S_PID p2) { }
+EXPORT void f2_V_IPS_PIP(int p0, void* p1, struct S_PIP p2) { }
+EXPORT void f2_V_IPS_PFI(int p0, void* p1, struct S_PFI p2) { }
+EXPORT void f2_V_IPS_PFF(int p0, void* p1, struct S_PFF p2) { }
+EXPORT void f2_V_IPS_PFD(int p0, void* p1, struct S_PFD p2) { }
+EXPORT void f2_V_IPS_PFP(int p0, void* p1, struct S_PFP p2) { }
+EXPORT void f2_V_IPS_PDI(int p0, void* p1, struct S_PDI p2) { }
+EXPORT void f2_V_IPS_PDF(int p0, void* p1, struct S_PDF p2) { }
+EXPORT void f2_V_IPS_PDD(int p0, void* p1, struct S_PDD p2) { }
+EXPORT void f2_V_IPS_PDP(int p0, void* p1, struct S_PDP p2) { }
+EXPORT void f2_V_IPS_PPI(int p0, void* p1, struct S_PPI p2) { }
+EXPORT void f2_V_IPS_PPF(int p0, void* p1, struct S_PPF p2) { }
+EXPORT void f2_V_IPS_PPD(int p0, void* p1, struct S_PPD p2) { }
+EXPORT void f2_V_IPS_PPP(int p0, void* p1, struct S_PPP p2) { }
+EXPORT void f2_V_ISI_I(int p0, struct S_I p1, int p2) { }
+EXPORT void f2_V_ISI_F(int p0, struct S_F p1, int p2) { }
+EXPORT void f2_V_ISI_D(int p0, struct S_D p1, int p2) { }
+EXPORT void f2_V_ISI_P(int p0, struct S_P p1, int p2) { }
+EXPORT void f2_V_ISI_II(int p0, struct S_II p1, int p2) { }
+EXPORT void f2_V_ISI_IF(int p0, struct S_IF p1, int p2) { }
+EXPORT void f2_V_ISI_ID(int p0, struct S_ID p1, int p2) { }
+EXPORT void f2_V_ISI_IP(int p0, struct S_IP p1, int p2) { }
+EXPORT void f2_V_ISI_FI(int p0, struct S_FI p1, int p2) { }
+EXPORT void f2_V_ISI_FF(int p0, struct S_FF p1, int p2) { }
+EXPORT void f2_V_ISI_FD(int p0, struct S_FD p1, int p2) { }
+EXPORT void f2_V_ISI_FP(int p0, struct S_FP p1, int p2) { }
+EXPORT void f2_V_ISI_DI(int p0, struct S_DI p1, int p2) { }
+EXPORT void f2_V_ISI_DF(int p0, struct S_DF p1, int p2) { }
+EXPORT void f2_V_ISI_DD(int p0, struct S_DD p1, int p2) { }
+EXPORT void f2_V_ISI_DP(int p0, struct S_DP p1, int p2) { }
+EXPORT void f2_V_ISI_PI(int p0, struct S_PI p1, int p2) { }
+EXPORT void f2_V_ISI_PF(int p0, struct S_PF p1, int p2) { }
+EXPORT void f2_V_ISI_PD(int p0, struct S_PD p1, int p2) { }
+EXPORT void f2_V_ISI_PP(int p0, struct S_PP p1, int p2) { }
+EXPORT void f2_V_ISI_III(int p0, struct S_III p1, int p2) { }
+EXPORT void f2_V_ISI_IIF(int p0, struct S_IIF p1, int p2) { }
+EXPORT void f2_V_ISI_IID(int p0, struct S_IID p1, int p2) { }
+EXPORT void f2_V_ISI_IIP(int p0, struct S_IIP p1, int p2) { }
+EXPORT void f2_V_ISI_IFI(int p0, struct S_IFI p1, int p2) { }
+EXPORT void f2_V_ISI_IFF(int p0, struct S_IFF p1, int p2) { }
+EXPORT void f2_V_ISI_IFD(int p0, struct S_IFD p1, int p2) { }
+EXPORT void f2_V_ISI_IFP(int p0, struct S_IFP p1, int p2) { }
+EXPORT void f2_V_ISI_IDI(int p0, struct S_IDI p1, int p2) { }
+EXPORT void f2_V_ISI_IDF(int p0, struct S_IDF p1, int p2) { }
+EXPORT void f2_V_ISI_IDD(int p0, struct S_IDD p1, int p2) { }
+EXPORT void f2_V_ISI_IDP(int p0, struct S_IDP p1, int p2) { }
+EXPORT void f2_V_ISI_IPI(int p0, struct S_IPI p1, int p2) { }
+EXPORT void f2_V_ISI_IPF(int p0, struct S_IPF p1, int p2) { }
+EXPORT void f2_V_ISI_IPD(int p0, struct S_IPD p1, int p2) { }
+EXPORT void f2_V_ISI_IPP(int p0, struct S_IPP p1, int p2) { }
+EXPORT void f2_V_ISI_FII(int p0, struct S_FII p1, int p2) { }
+EXPORT void f2_V_ISI_FIF(int p0, struct S_FIF p1, int p2) { }
+EXPORT void f2_V_ISI_FID(int p0, struct S_FID p1, int p2) { }
+EXPORT void f2_V_ISI_FIP(int p0, struct S_FIP p1, int p2) { }
+EXPORT void f2_V_ISI_FFI(int p0, struct S_FFI p1, int p2) { }
+EXPORT void f2_V_ISI_FFF(int p0, struct S_FFF p1, int p2) { }
+EXPORT void f2_V_ISI_FFD(int p0, struct S_FFD p1, int p2) { }
+EXPORT void f2_V_ISI_FFP(int p0, struct S_FFP p1, int p2) { }
+EXPORT void f2_V_ISI_FDI(int p0, struct S_FDI p1, int p2) { }
+EXPORT void f2_V_ISI_FDF(int p0, struct S_FDF p1, int p2) { }
+EXPORT void f2_V_ISI_FDD(int p0, struct S_FDD p1, int p2) { }
+EXPORT void f2_V_ISI_FDP(int p0, struct S_FDP p1, int p2) { }
+EXPORT void f2_V_ISI_FPI(int p0, struct S_FPI p1, int p2) { }
+EXPORT void f2_V_ISI_FPF(int p0, struct S_FPF p1, int p2) { }
+EXPORT void f2_V_ISI_FPD(int p0, struct S_FPD p1, int p2) { }
+EXPORT void f2_V_ISI_FPP(int p0, struct S_FPP p1, int p2) { }
+EXPORT void f2_V_ISI_DII(int p0, struct S_DII p1, int p2) { }
+EXPORT void f2_V_ISI_DIF(int p0, struct S_DIF p1, int p2) { }
+EXPORT void f2_V_ISI_DID(int p0, struct S_DID p1, int p2) { }
+EXPORT void f2_V_ISI_DIP(int p0, struct S_DIP p1, int p2) { }
+EXPORT void f2_V_ISI_DFI(int p0, struct S_DFI p1, int p2) { }
+EXPORT void f2_V_ISI_DFF(int p0, struct S_DFF p1, int p2) { }
+EXPORT void f2_V_ISI_DFD(int p0, struct S_DFD p1, int p2) { }
+EXPORT void f2_V_ISI_DFP(int p0, struct S_DFP p1, int p2) { }
+EXPORT void f2_V_ISI_DDI(int p0, struct S_DDI p1, int p2) { }
+EXPORT void f2_V_ISI_DDF(int p0, struct S_DDF p1, int p2) { }
+EXPORT void f2_V_ISI_DDD(int p0, struct S_DDD p1, int p2) { }
+EXPORT void f2_V_ISI_DDP(int p0, struct S_DDP p1, int p2) { }
+EXPORT void f2_V_ISI_DPI(int p0, struct S_DPI p1, int p2) { }
+EXPORT void f2_V_ISI_DPF(int p0, struct S_DPF p1, int p2) { }
+EXPORT void f2_V_ISI_DPD(int p0, struct S_DPD p1, int p2) { }
+EXPORT void f2_V_ISI_DPP(int p0, struct S_DPP p1, int p2) { }
+EXPORT void f2_V_ISI_PII(int p0, struct S_PII p1, int p2) { }
+EXPORT void f2_V_ISI_PIF(int p0, struct S_PIF p1, int p2) { }
+EXPORT void f2_V_ISI_PID(int p0, struct S_PID p1, int p2) { }
+EXPORT void f2_V_ISI_PIP(int p0, struct S_PIP p1, int p2) { }
+EXPORT void f2_V_ISI_PFI(int p0, struct S_PFI p1, int p2) { }
+EXPORT void f2_V_ISI_PFF(int p0, struct S_PFF p1, int p2) { }
+EXPORT void f2_V_ISI_PFD(int p0, struct S_PFD p1, int p2) { }
+EXPORT void f2_V_ISI_PFP(int p0, struct S_PFP p1, int p2) { }
+EXPORT void f2_V_ISI_PDI(int p0, struct S_PDI p1, int p2) { }
+EXPORT void f2_V_ISI_PDF(int p0, struct S_PDF p1, int p2) { }
+EXPORT void f2_V_ISI_PDD(int p0, struct S_PDD p1, int p2) { }
+EXPORT void f2_V_ISI_PDP(int p0, struct S_PDP p1, int p2) { }
+EXPORT void f2_V_ISI_PPI(int p0, struct S_PPI p1, int p2) { }
+EXPORT void f2_V_ISI_PPF(int p0, struct S_PPF p1, int p2) { }
+EXPORT void f2_V_ISI_PPD(int p0, struct S_PPD p1, int p2) { }
+EXPORT void f2_V_ISI_PPP(int p0, struct S_PPP p1, int p2) { }
+EXPORT void f2_V_ISF_I(int p0, struct S_I p1, float p2) { }
+EXPORT void f2_V_ISF_F(int p0, struct S_F p1, float p2) { }
+EXPORT void f2_V_ISF_D(int p0, struct S_D p1, float p2) { }
+EXPORT void f2_V_ISF_P(int p0, struct S_P p1, float p2) { }
+EXPORT void f2_V_ISF_II(int p0, struct S_II p1, float p2) { }
+EXPORT void f2_V_ISF_IF(int p0, struct S_IF p1, float p2) { }
+EXPORT void f2_V_ISF_ID(int p0, struct S_ID p1, float p2) { }
+EXPORT void f2_V_ISF_IP(int p0, struct S_IP p1, float p2) { }
+EXPORT void f2_V_ISF_FI(int p0, struct S_FI p1, float p2) { }
+EXPORT void f2_V_ISF_FF(int p0, struct S_FF p1, float p2) { }
+EXPORT void f2_V_ISF_FD(int p0, struct S_FD p1, float p2) { }
+EXPORT void f2_V_ISF_FP(int p0, struct S_FP p1, float p2) { }
+EXPORT void f2_V_ISF_DI(int p0, struct S_DI p1, float p2) { }
+EXPORT void f2_V_ISF_DF(int p0, struct S_DF p1, float p2) { }
+EXPORT void f2_V_ISF_DD(int p0, struct S_DD p1, float p2) { }
+EXPORT void f2_V_ISF_DP(int p0, struct S_DP p1, float p2) { }
+EXPORT void f2_V_ISF_PI(int p0, struct S_PI p1, float p2) { }
+EXPORT void f2_V_ISF_PF(int p0, struct S_PF p1, float p2) { }
+EXPORT void f2_V_ISF_PD(int p0, struct S_PD p1, float p2) { }
+EXPORT void f2_V_ISF_PP(int p0, struct S_PP p1, float p2) { }
+EXPORT void f2_V_ISF_III(int p0, struct S_III p1, float p2) { }
+EXPORT void f2_V_ISF_IIF(int p0, struct S_IIF p1, float p2) { }
+EXPORT void f2_V_ISF_IID(int p0, struct S_IID p1, float p2) { }
+EXPORT void f2_V_ISF_IIP(int p0, struct S_IIP p1, float p2) { }
+EXPORT void f2_V_ISF_IFI(int p0, struct S_IFI p1, float p2) { }
+EXPORT void f2_V_ISF_IFF(int p0, struct S_IFF p1, float p2) { }
+EXPORT void f2_V_ISF_IFD(int p0, struct S_IFD p1, float p2) { }
+EXPORT void f2_V_ISF_IFP(int p0, struct S_IFP p1, float p2) { }
+EXPORT void f2_V_ISF_IDI(int p0, struct S_IDI p1, float p2) { }
+EXPORT void f2_V_ISF_IDF(int p0, struct S_IDF p1, float p2) { }
+EXPORT void f2_V_ISF_IDD(int p0, struct S_IDD p1, float p2) { }
+EXPORT void f2_V_ISF_IDP(int p0, struct S_IDP p1, float p2) { }
+EXPORT void f2_V_ISF_IPI(int p0, struct S_IPI p1, float p2) { }
+EXPORT void f2_V_ISF_IPF(int p0, struct S_IPF p1, float p2) { }
+EXPORT void f2_V_ISF_IPD(int p0, struct S_IPD p1, float p2) { }
+EXPORT void f2_V_ISF_IPP(int p0, struct S_IPP p1, float p2) { }
+EXPORT void f2_V_ISF_FII(int p0, struct S_FII p1, float p2) { }
+EXPORT void f2_V_ISF_FIF(int p0, struct S_FIF p1, float p2) { }
+EXPORT void f2_V_ISF_FID(int p0, struct S_FID p1, float p2) { }
+EXPORT void f2_V_ISF_FIP(int p0, struct S_FIP p1, float p2) { }
+EXPORT void f2_V_ISF_FFI(int p0, struct S_FFI p1, float p2) { }
+EXPORT void f2_V_ISF_FFF(int p0, struct S_FFF p1, float p2) { }
+EXPORT void f2_V_ISF_FFD(int p0, struct S_FFD p1, float p2) { }
+EXPORT void f2_V_ISF_FFP(int p0, struct S_FFP p1, float p2) { }
+EXPORT void f2_V_ISF_FDI(int p0, struct S_FDI p1, float p2) { }
+EXPORT void f2_V_ISF_FDF(int p0, struct S_FDF p1, float p2) { }
+EXPORT void f2_V_ISF_FDD(int p0, struct S_FDD p1, float p2) { }
+EXPORT void f2_V_ISF_FDP(int p0, struct S_FDP p1, float p2) { }
+EXPORT void f2_V_ISF_FPI(int p0, struct S_FPI p1, float p2) { }
+EXPORT void f2_V_ISF_FPF(int p0, struct S_FPF p1, float p2) { }
+EXPORT void f2_V_ISF_FPD(int p0, struct S_FPD p1, float p2) { }
+EXPORT void f2_V_ISF_FPP(int p0, struct S_FPP p1, float p2) { }
+EXPORT void f2_V_ISF_DII(int p0, struct S_DII p1, float p2) { }
+EXPORT void f2_V_ISF_DIF(int p0, struct S_DIF p1, float p2) { }
+EXPORT void f2_V_ISF_DID(int p0, struct S_DID p1, float p2) { }
+EXPORT void f2_V_ISF_DIP(int p0, struct S_DIP p1, float p2) { }
+EXPORT void f2_V_ISF_DFI(int p0, struct S_DFI p1, float p2) { }
+EXPORT void f2_V_ISF_DFF(int p0, struct S_DFF p1, float p2) { }
+EXPORT void f2_V_ISF_DFD(int p0, struct S_DFD p1, float p2) { }
+EXPORT void f2_V_ISF_DFP(int p0, struct S_DFP p1, float p2) { }
+EXPORT void f2_V_ISF_DDI(int p0, struct S_DDI p1, float p2) { }
+EXPORT void f2_V_ISF_DDF(int p0, struct S_DDF p1, float p2) { }
+EXPORT void f2_V_ISF_DDD(int p0, struct S_DDD p1, float p2) { }
+EXPORT void f2_V_ISF_DDP(int p0, struct S_DDP p1, float p2) { }
+EXPORT void f2_V_ISF_DPI(int p0, struct S_DPI p1, float p2) { }
+EXPORT void f2_V_ISF_DPF(int p0, struct S_DPF p1, float p2) { }
+EXPORT void f2_V_ISF_DPD(int p0, struct S_DPD p1, float p2) { }
+EXPORT void f2_V_ISF_DPP(int p0, struct S_DPP p1, float p2) { }
+EXPORT void f2_V_ISF_PII(int p0, struct S_PII p1, float p2) { }
+EXPORT void f2_V_ISF_PIF(int p0, struct S_PIF p1, float p2) { }
+EXPORT void f2_V_ISF_PID(int p0, struct S_PID p1, float p2) { }
+EXPORT void f2_V_ISF_PIP(int p0, struct S_PIP p1, float p2) { }
+EXPORT void f2_V_ISF_PFI(int p0, struct S_PFI p1, float p2) { }
+EXPORT void f2_V_ISF_PFF(int p0, struct S_PFF p1, float p2) { }
+EXPORT void f2_V_ISF_PFD(int p0, struct S_PFD p1, float p2) { }
+EXPORT void f2_V_ISF_PFP(int p0, struct S_PFP p1, float p2) { }
+EXPORT void f2_V_ISF_PDI(int p0, struct S_PDI p1, float p2) { }
+EXPORT void f2_V_ISF_PDF(int p0, struct S_PDF p1, float p2) { }
+EXPORT void f2_V_ISF_PDD(int p0, struct S_PDD p1, float p2) { }
+EXPORT void f2_V_ISF_PDP(int p0, struct S_PDP p1, float p2) { }
+EXPORT void f2_V_ISF_PPI(int p0, struct S_PPI p1, float p2) { }
+EXPORT void f2_V_ISF_PPF(int p0, struct S_PPF p1, float p2) { }
+EXPORT void f2_V_ISF_PPD(int p0, struct S_PPD p1, float p2) { }
+EXPORT void f2_V_ISF_PPP(int p0, struct S_PPP p1, float p2) { }
+EXPORT void f2_V_ISD_I(int p0, struct S_I p1, double p2) { }
+EXPORT void f2_V_ISD_F(int p0, struct S_F p1, double p2) { }
+EXPORT void f2_V_ISD_D(int p0, struct S_D p1, double p2) { }
+EXPORT void f2_V_ISD_P(int p0, struct S_P p1, double p2) { }
+EXPORT void f2_V_ISD_II(int p0, struct S_II p1, double p2) { }
+EXPORT void f2_V_ISD_IF(int p0, struct S_IF p1, double p2) { }
+EXPORT void f2_V_ISD_ID(int p0, struct S_ID p1, double p2) { }
+EXPORT void f2_V_ISD_IP(int p0, struct S_IP p1, double p2) { }
+EXPORT void f2_V_ISD_FI(int p0, struct S_FI p1, double p2) { }
+EXPORT void f2_V_ISD_FF(int p0, struct S_FF p1, double p2) { }
+EXPORT void f2_V_ISD_FD(int p0, struct S_FD p1, double p2) { }
+EXPORT void f2_V_ISD_FP(int p0, struct S_FP p1, double p2) { }
+EXPORT void f2_V_ISD_DI(int p0, struct S_DI p1, double p2) { }
+EXPORT void f2_V_ISD_DF(int p0, struct S_DF p1, double p2) { }
+EXPORT void f2_V_ISD_DD(int p0, struct S_DD p1, double p2) { }
+EXPORT void f2_V_ISD_DP(int p0, struct S_DP p1, double p2) { }
+EXPORT void f2_V_ISD_PI(int p0, struct S_PI p1, double p2) { }
+EXPORT void f2_V_ISD_PF(int p0, struct S_PF p1, double p2) { }
+EXPORT void f2_V_ISD_PD(int p0, struct S_PD p1, double p2) { }
+EXPORT void f2_V_ISD_PP(int p0, struct S_PP p1, double p2) { }
+EXPORT void f2_V_ISD_III(int p0, struct S_III p1, double p2) { }
+EXPORT void f2_V_ISD_IIF(int p0, struct S_IIF p1, double p2) { }
+EXPORT void f2_V_ISD_IID(int p0, struct S_IID p1, double p2) { }
+EXPORT void f2_V_ISD_IIP(int p0, struct S_IIP p1, double p2) { }
+EXPORT void f2_V_ISD_IFI(int p0, struct S_IFI p1, double p2) { }
+EXPORT void f2_V_ISD_IFF(int p0, struct S_IFF p1, double p2) { }
+EXPORT void f2_V_ISD_IFD(int p0, struct S_IFD p1, double p2) { }
+EXPORT void f2_V_ISD_IFP(int p0, struct S_IFP p1, double p2) { }
+EXPORT void f2_V_ISD_IDI(int p0, struct S_IDI p1, double p2) { }
+EXPORT void f2_V_ISD_IDF(int p0, struct S_IDF p1, double p2) { }
+EXPORT void f2_V_ISD_IDD(int p0, struct S_IDD p1, double p2) { }
+EXPORT void f2_V_ISD_IDP(int p0, struct S_IDP p1, double p2) { }
+EXPORT void f2_V_ISD_IPI(int p0, struct S_IPI p1, double p2) { }
+EXPORT void f2_V_ISD_IPF(int p0, struct S_IPF p1, double p2) { }
+EXPORT void f2_V_ISD_IPD(int p0, struct S_IPD p1, double p2) { }
+EXPORT void f2_V_ISD_IPP(int p0, struct S_IPP p1, double p2) { }
+EXPORT void f2_V_ISD_FII(int p0, struct S_FII p1, double p2) { }
+EXPORT void f2_V_ISD_FIF(int p0, struct S_FIF p1, double p2) { }
+EXPORT void f2_V_ISD_FID(int p0, struct S_FID p1, double p2) { }
+EXPORT void f2_V_ISD_FIP(int p0, struct S_FIP p1, double p2) { }
+EXPORT void f2_V_ISD_FFI(int p0, struct S_FFI p1, double p2) { }
+EXPORT void f2_V_ISD_FFF(int p0, struct S_FFF p1, double p2) { }
+EXPORT void f2_V_ISD_FFD(int p0, struct S_FFD p1, double p2) { }
+EXPORT void f2_V_ISD_FFP(int p0, struct S_FFP p1, double p2) { }
+EXPORT void f2_V_ISD_FDI(int p0, struct S_FDI p1, double p2) { }
+EXPORT void f2_V_ISD_FDF(int p0, struct S_FDF p1, double p2) { }
+EXPORT void f2_V_ISD_FDD(int p0, struct S_FDD p1, double p2) { }
+EXPORT void f2_V_ISD_FDP(int p0, struct S_FDP p1, double p2) { }
+EXPORT void f2_V_ISD_FPI(int p0, struct S_FPI p1, double p2) { }
+EXPORT void f2_V_ISD_FPF(int p0, struct S_FPF p1, double p2) { }
+EXPORT void f2_V_ISD_FPD(int p0, struct S_FPD p1, double p2) { }
+EXPORT void f2_V_ISD_FPP(int p0, struct S_FPP p1, double p2) { }
+EXPORT void f2_V_ISD_DII(int p0, struct S_DII p1, double p2) { }
+EXPORT void f2_V_ISD_DIF(int p0, struct S_DIF p1, double p2) { }
+EXPORT void f2_V_ISD_DID(int p0, struct S_DID p1, double p2) { }
+EXPORT void f2_V_ISD_DIP(int p0, struct S_DIP p1, double p2) { }
+EXPORT void f2_V_ISD_DFI(int p0, struct S_DFI p1, double p2) { }
+EXPORT void f2_V_ISD_DFF(int p0, struct S_DFF p1, double p2) { }
+EXPORT void f2_V_ISD_DFD(int p0, struct S_DFD p1, double p2) { }
+EXPORT void f2_V_ISD_DFP(int p0, struct S_DFP p1, double p2) { }
+EXPORT void f2_V_ISD_DDI(int p0, struct S_DDI p1, double p2) { }
+EXPORT void f2_V_ISD_DDF(int p0, struct S_DDF p1, double p2) { }
+EXPORT void f2_V_ISD_DDD(int p0, struct S_DDD p1, double p2) { }
+EXPORT void f2_V_ISD_DDP(int p0, struct S_DDP p1, double p2) { }
+EXPORT void f2_V_ISD_DPI(int p0, struct S_DPI p1, double p2) { }
+EXPORT void f2_V_ISD_DPF(int p0, struct S_DPF p1, double p2) { }
+EXPORT void f2_V_ISD_DPD(int p0, struct S_DPD p1, double p2) { }
+EXPORT void f2_V_ISD_DPP(int p0, struct S_DPP p1, double p2) { }
+EXPORT void f2_V_ISD_PII(int p0, struct S_PII p1, double p2) { }
+EXPORT void f2_V_ISD_PIF(int p0, struct S_PIF p1, double p2) { }
+EXPORT void f2_V_ISD_PID(int p0, struct S_PID p1, double p2) { }
+EXPORT void f2_V_ISD_PIP(int p0, struct S_PIP p1, double p2) { }
+EXPORT void f2_V_ISD_PFI(int p0, struct S_PFI p1, double p2) { }
+EXPORT void f2_V_ISD_PFF(int p0, struct S_PFF p1, double p2) { }
+EXPORT void f2_V_ISD_PFD(int p0, struct S_PFD p1, double p2) { }
+EXPORT void f2_V_ISD_PFP(int p0, struct S_PFP p1, double p2) { }
+EXPORT void f2_V_ISD_PDI(int p0, struct S_PDI p1, double p2) { }
+EXPORT void f2_V_ISD_PDF(int p0, struct S_PDF p1, double p2) { }
+EXPORT void f2_V_ISD_PDD(int p0, struct S_PDD p1, double p2) { }
+EXPORT void f2_V_ISD_PDP(int p0, struct S_PDP p1, double p2) { }
+EXPORT void f2_V_ISD_PPI(int p0, struct S_PPI p1, double p2) { }
+EXPORT void f2_V_ISD_PPF(int p0, struct S_PPF p1, double p2) { }
+EXPORT void f2_V_ISD_PPD(int p0, struct S_PPD p1, double p2) { }
+EXPORT void f2_V_ISD_PPP(int p0, struct S_PPP p1, double p2) { }
+EXPORT void f2_V_ISP_I(int p0, struct S_I p1, void* p2) { }
+EXPORT void f2_V_ISP_F(int p0, struct S_F p1, void* p2) { }
+EXPORT void f2_V_ISP_D(int p0, struct S_D p1, void* p2) { }
+EXPORT void f2_V_ISP_P(int p0, struct S_P p1, void* p2) { }
+EXPORT void f2_V_ISP_II(int p0, struct S_II p1, void* p2) { }
+EXPORT void f2_V_ISP_IF(int p0, struct S_IF p1, void* p2) { }
+EXPORT void f2_V_ISP_ID(int p0, struct S_ID p1, void* p2) { }
+EXPORT void f2_V_ISP_IP(int p0, struct S_IP p1, void* p2) { }
+EXPORT void f2_V_ISP_FI(int p0, struct S_FI p1, void* p2) { }
+EXPORT void f2_V_ISP_FF(int p0, struct S_FF p1, void* p2) { }
+EXPORT void f2_V_ISP_FD(int p0, struct S_FD p1, void* p2) { }
+EXPORT void f2_V_ISP_FP(int p0, struct S_FP p1, void* p2) { }
+EXPORT void f2_V_ISP_DI(int p0, struct S_DI p1, void* p2) { }
+EXPORT void f2_V_ISP_DF(int p0, struct S_DF p1, void* p2) { }
+EXPORT void f2_V_ISP_DD(int p0, struct S_DD p1, void* p2) { }
+EXPORT void f2_V_ISP_DP(int p0, struct S_DP p1, void* p2) { }
+EXPORT void f2_V_ISP_PI(int p0, struct S_PI p1, void* p2) { }
+EXPORT void f2_V_ISP_PF(int p0, struct S_PF p1, void* p2) { }
+EXPORT void f2_V_ISP_PD(int p0, struct S_PD p1, void* p2) { }
+EXPORT void f2_V_ISP_PP(int p0, struct S_PP p1, void* p2) { }
+EXPORT void f2_V_ISP_III(int p0, struct S_III p1, void* p2) { }
+EXPORT void f2_V_ISP_IIF(int p0, struct S_IIF p1, void* p2) { }
+EXPORT void f2_V_ISP_IID(int p0, struct S_IID p1, void* p2) { }
+EXPORT void f2_V_ISP_IIP(int p0, struct S_IIP p1, void* p2) { }
+EXPORT void f2_V_ISP_IFI(int p0, struct S_IFI p1, void* p2) { }
+EXPORT void f2_V_ISP_IFF(int p0, struct S_IFF p1, void* p2) { }
+EXPORT void f2_V_ISP_IFD(int p0, struct S_IFD p1, void* p2) { }
+EXPORT void f2_V_ISP_IFP(int p0, struct S_IFP p1, void* p2) { }
+EXPORT void f2_V_ISP_IDI(int p0, struct S_IDI p1, void* p2) { }
+EXPORT void f2_V_ISP_IDF(int p0, struct S_IDF p1, void* p2) { }
+EXPORT void f2_V_ISP_IDD(int p0, struct S_IDD p1, void* p2) { }
+EXPORT void f2_V_ISP_IDP(int p0, struct S_IDP p1, void* p2) { }
+EXPORT void f2_V_ISP_IPI(int p0, struct S_IPI p1, void* p2) { }
+EXPORT void f2_V_ISP_IPF(int p0, struct S_IPF p1, void* p2) { }
+EXPORT void f2_V_ISP_IPD(int p0, struct S_IPD p1, void* p2) { }
+EXPORT void f2_V_ISP_IPP(int p0, struct S_IPP p1, void* p2) { }
+EXPORT void f2_V_ISP_FII(int p0, struct S_FII p1, void* p2) { }
+EXPORT void f2_V_ISP_FIF(int p0, struct S_FIF p1, void* p2) { }
+EXPORT void f2_V_ISP_FID(int p0, struct S_FID p1, void* p2) { }
+EXPORT void f2_V_ISP_FIP(int p0, struct S_FIP p1, void* p2) { }
+EXPORT void f2_V_ISP_FFI(int p0, struct S_FFI p1, void* p2) { }
+EXPORT void f2_V_ISP_FFF(int p0, struct S_FFF p1, void* p2) { }
+EXPORT void f2_V_ISP_FFD(int p0, struct S_FFD p1, void* p2) { }
+EXPORT void f2_V_ISP_FFP(int p0, struct S_FFP p1, void* p2) { }
+EXPORT void f2_V_ISP_FDI(int p0, struct S_FDI p1, void* p2) { }
+EXPORT void f2_V_ISP_FDF(int p0, struct S_FDF p1, void* p2) { }
+EXPORT void f2_V_ISP_FDD(int p0, struct S_FDD p1, void* p2) { }
+EXPORT void f2_V_ISP_FDP(int p0, struct S_FDP p1, void* p2) { }
+EXPORT void f2_V_ISP_FPI(int p0, struct S_FPI p1, void* p2) { }
+EXPORT void f2_V_ISP_FPF(int p0, struct S_FPF p1, void* p2) { }
+EXPORT void f2_V_ISP_FPD(int p0, struct S_FPD p1, void* p2) { }
+EXPORT void f2_V_ISP_FPP(int p0, struct S_FPP p1, void* p2) { }
+EXPORT void f2_V_ISP_DII(int p0, struct S_DII p1, void* p2) { }
+EXPORT void f2_V_ISP_DIF(int p0, struct S_DIF p1, void* p2) { }
+EXPORT void f2_V_ISP_DID(int p0, struct S_DID p1, void* p2) { }
+EXPORT void f2_V_ISP_DIP(int p0, struct S_DIP p1, void* p2) { }
+EXPORT void f2_V_ISP_DFI(int p0, struct S_DFI p1, void* p2) { }
+EXPORT void f2_V_ISP_DFF(int p0, struct S_DFF p1, void* p2) { }
+EXPORT void f2_V_ISP_DFD(int p0, struct S_DFD p1, void* p2) { }
+EXPORT void f2_V_ISP_DFP(int p0, struct S_DFP p1, void* p2) { }
+EXPORT void f2_V_ISP_DDI(int p0, struct S_DDI p1, void* p2) { }
+EXPORT void f2_V_ISP_DDF(int p0, struct S_DDF p1, void* p2) { }
+EXPORT void f2_V_ISP_DDD(int p0, struct S_DDD p1, void* p2) { }
+EXPORT void f2_V_ISP_DDP(int p0, struct S_DDP p1, void* p2) { }
+EXPORT void f2_V_ISP_DPI(int p0, struct S_DPI p1, void* p2) { }
+EXPORT void f2_V_ISP_DPF(int p0, struct S_DPF p1, void* p2) { }
+EXPORT void f2_V_ISP_DPD(int p0, struct S_DPD p1, void* p2) { }
+EXPORT void f2_V_ISP_DPP(int p0, struct S_DPP p1, void* p2) { }
+EXPORT void f2_V_ISP_PII(int p0, struct S_PII p1, void* p2) { }
+EXPORT void f2_V_ISP_PIF(int p0, struct S_PIF p1, void* p2) { }
+EXPORT void f2_V_ISP_PID(int p0, struct S_PID p1, void* p2) { }
+EXPORT void f2_V_ISP_PIP(int p0, struct S_PIP p1, void* p2) { }
+EXPORT void f2_V_ISP_PFI(int p0, struct S_PFI p1, void* p2) { }
+EXPORT void f2_V_ISP_PFF(int p0, struct S_PFF p1, void* p2) { }
+EXPORT void f2_V_ISP_PFD(int p0, struct S_PFD p1, void* p2) { }
+EXPORT void f2_V_ISP_PFP(int p0, struct S_PFP p1, void* p2) { }
+EXPORT void f2_V_ISP_PDI(int p0, struct S_PDI p1, void* p2) { }
+EXPORT void f2_V_ISP_PDF(int p0, struct S_PDF p1, void* p2) { }
+EXPORT void f2_V_ISP_PDD(int p0, struct S_PDD p1, void* p2) { }
+EXPORT void f2_V_ISP_PDP(int p0, struct S_PDP p1, void* p2) { }
+EXPORT void f2_V_ISP_PPI(int p0, struct S_PPI p1, void* p2) { }
+EXPORT void f2_V_ISP_PPF(int p0, struct S_PPF p1, void* p2) { }
+EXPORT void f2_V_ISP_PPD(int p0, struct S_PPD p1, void* p2) { }
+EXPORT void f2_V_ISP_PPP(int p0, struct S_PPP p1, void* p2) { }
+EXPORT void f2_V_ISS_I(int p0, struct S_I p1, struct S_I p2) { }
+EXPORT void f2_V_ISS_F(int p0, struct S_F p1, struct S_F p2) { }
+EXPORT void f2_V_ISS_D(int p0, struct S_D p1, struct S_D p2) { }
+EXPORT void f2_V_ISS_P(int p0, struct S_P p1, struct S_P p2) { }
+EXPORT void f2_V_ISS_II(int p0, struct S_II p1, struct S_II p2) { }
+EXPORT void f2_V_ISS_IF(int p0, struct S_IF p1, struct S_IF p2) { }
+EXPORT void f2_V_ISS_ID(int p0, struct S_ID p1, struct S_ID p2) { }
+EXPORT void f2_V_ISS_IP(int p0, struct S_IP p1, struct S_IP p2) { }
+EXPORT void f2_V_ISS_FI(int p0, struct S_FI p1, struct S_FI p2) { }
+EXPORT void f2_V_ISS_FF(int p0, struct S_FF p1, struct S_FF p2) { }
+EXPORT void f2_V_ISS_FD(int p0, struct S_FD p1, struct S_FD p2) { }
+EXPORT void f2_V_ISS_FP(int p0, struct S_FP p1, struct S_FP p2) { }
+EXPORT void f2_V_ISS_DI(int p0, struct S_DI p1, struct S_DI p2) { }
+EXPORT void f2_V_ISS_DF(int p0, struct S_DF p1, struct S_DF p2) { }
+EXPORT void f2_V_ISS_DD(int p0, struct S_DD p1, struct S_DD p2) { }
+EXPORT void f2_V_ISS_DP(int p0, struct S_DP p1, struct S_DP p2) { }
+EXPORT void f2_V_ISS_PI(int p0, struct S_PI p1, struct S_PI p2) { }
+EXPORT void f2_V_ISS_PF(int p0, struct S_PF p1, struct S_PF p2) { }
+EXPORT void f2_V_ISS_PD(int p0, struct S_PD p1, struct S_PD p2) { }
+EXPORT void f2_V_ISS_PP(int p0, struct S_PP p1, struct S_PP p2) { }
+EXPORT void f2_V_ISS_III(int p0, struct S_III p1, struct S_III p2) { }
+EXPORT void f2_V_ISS_IIF(int p0, struct S_IIF p1, struct S_IIF p2) { }
+EXPORT void f2_V_ISS_IID(int p0, struct S_IID p1, struct S_IID p2) { }
+EXPORT void f2_V_ISS_IIP(int p0, struct S_IIP p1, struct S_IIP p2) { }
+EXPORT void f2_V_ISS_IFI(int p0, struct S_IFI p1, struct S_IFI p2) { }
+EXPORT void f2_V_ISS_IFF(int p0, struct S_IFF p1, struct S_IFF p2) { }
+EXPORT void f2_V_ISS_IFD(int p0, struct S_IFD p1, struct S_IFD p2) { }
+EXPORT void f2_V_ISS_IFP(int p0, struct S_IFP p1, struct S_IFP p2) { }
+EXPORT void f2_V_ISS_IDI(int p0, struct S_IDI p1, struct S_IDI p2) { }
+EXPORT void f2_V_ISS_IDF(int p0, struct S_IDF p1, struct S_IDF p2) { }
+EXPORT void f2_V_ISS_IDD(int p0, struct S_IDD p1, struct S_IDD p2) { }
+EXPORT void f2_V_ISS_IDP(int p0, struct S_IDP p1, struct S_IDP p2) { }
+EXPORT void f2_V_ISS_IPI(int p0, struct S_IPI p1, struct S_IPI p2) { }
+EXPORT void f2_V_ISS_IPF(int p0, struct S_IPF p1, struct S_IPF p2) { }
+EXPORT void f2_V_ISS_IPD(int p0, struct S_IPD p1, struct S_IPD p2) { }
+EXPORT void f2_V_ISS_IPP(int p0, struct S_IPP p1, struct S_IPP p2) { }
+EXPORT void f2_V_ISS_FII(int p0, struct S_FII p1, struct S_FII p2) { }
+EXPORT void f2_V_ISS_FIF(int p0, struct S_FIF p1, struct S_FIF p2) { }
+EXPORT void f2_V_ISS_FID(int p0, struct S_FID p1, struct S_FID p2) { }
+EXPORT void f2_V_ISS_FIP(int p0, struct S_FIP p1, struct S_FIP p2) { }
+EXPORT void f2_V_ISS_FFI(int p0, struct S_FFI p1, struct S_FFI p2) { }
+EXPORT void f2_V_ISS_FFF(int p0, struct S_FFF p1, struct S_FFF p2) { }
+EXPORT void f2_V_ISS_FFD(int p0, struct S_FFD p1, struct S_FFD p2) { }
+EXPORT void f2_V_ISS_FFP(int p0, struct S_FFP p1, struct S_FFP p2) { }
+EXPORT void f2_V_ISS_FDI(int p0, struct S_FDI p1, struct S_FDI p2) { }
+EXPORT void f2_V_ISS_FDF(int p0, struct S_FDF p1, struct S_FDF p2) { }
+EXPORT void f2_V_ISS_FDD(int p0, struct S_FDD p1, struct S_FDD p2) { }
+EXPORT void f2_V_ISS_FDP(int p0, struct S_FDP p1, struct S_FDP p2) { }
+EXPORT void f2_V_ISS_FPI(int p0, struct S_FPI p1, struct S_FPI p2) { }
+EXPORT void f2_V_ISS_FPF(int p0, struct S_FPF p1, struct S_FPF p2) { }
+EXPORT void f2_V_ISS_FPD(int p0, struct S_FPD p1, struct S_FPD p2) { }
+EXPORT void f2_V_ISS_FPP(int p0, struct S_FPP p1, struct S_FPP p2) { }
+EXPORT void f2_V_ISS_DII(int p0, struct S_DII p1, struct S_DII p2) { }
+EXPORT void f2_V_ISS_DIF(int p0, struct S_DIF p1, struct S_DIF p2) { }
+EXPORT void f2_V_ISS_DID(int p0, struct S_DID p1, struct S_DID p2) { }
+EXPORT void f2_V_ISS_DIP(int p0, struct S_DIP p1, struct S_DIP p2) { }
+EXPORT void f2_V_ISS_DFI(int p0, struct S_DFI p1, struct S_DFI p2) { }
+EXPORT void f2_V_ISS_DFF(int p0, struct S_DFF p1, struct S_DFF p2) { }
+EXPORT void f2_V_ISS_DFD(int p0, struct S_DFD p1, struct S_DFD p2) { }
+EXPORT void f2_V_ISS_DFP(int p0, struct S_DFP p1, struct S_DFP p2) { }
+EXPORT void f2_V_ISS_DDI(int p0, struct S_DDI p1, struct S_DDI p2) { }
+EXPORT void f2_V_ISS_DDF(int p0, struct S_DDF p1, struct S_DDF p2) { }
+EXPORT void f2_V_ISS_DDD(int p0, struct S_DDD p1, struct S_DDD p2) { }
+EXPORT void f2_V_ISS_DDP(int p0, struct S_DDP p1, struct S_DDP p2) { }
+EXPORT void f2_V_ISS_DPI(int p0, struct S_DPI p1, struct S_DPI p2) { }
+EXPORT void f2_V_ISS_DPF(int p0, struct S_DPF p1, struct S_DPF p2) { }
+EXPORT void f2_V_ISS_DPD(int p0, struct S_DPD p1, struct S_DPD p2) { }
+EXPORT void f2_V_ISS_DPP(int p0, struct S_DPP p1, struct S_DPP p2) { }
+EXPORT void f2_V_ISS_PII(int p0, struct S_PII p1, struct S_PII p2) { }
+EXPORT void f2_V_ISS_PIF(int p0, struct S_PIF p1, struct S_PIF p2) { }
+EXPORT void f2_V_ISS_PID(int p0, struct S_PID p1, struct S_PID p2) { }
+EXPORT void f2_V_ISS_PIP(int p0, struct S_PIP p1, struct S_PIP p2) { }
+EXPORT void f2_V_ISS_PFI(int p0, struct S_PFI p1, struct S_PFI p2) { }
+EXPORT void f2_V_ISS_PFF(int p0, struct S_PFF p1, struct S_PFF p2) { }
+EXPORT void f2_V_ISS_PFD(int p0, struct S_PFD p1, struct S_PFD p2) { }
+EXPORT void f2_V_ISS_PFP(int p0, struct S_PFP p1, struct S_PFP p2) { }
+EXPORT void f2_V_ISS_PDI(int p0, struct S_PDI p1, struct S_PDI p2) { }
+EXPORT void f2_V_ISS_PDF(int p0, struct S_PDF p1, struct S_PDF p2) { }
+EXPORT void f2_V_ISS_PDD(int p0, struct S_PDD p1, struct S_PDD p2) { }
+EXPORT void f2_V_ISS_PDP(int p0, struct S_PDP p1, struct S_PDP p2) { }
+EXPORT void f2_V_ISS_PPI(int p0, struct S_PPI p1, struct S_PPI p2) { }
+EXPORT void f2_V_ISS_PPF(int p0, struct S_PPF p1, struct S_PPF p2) { }
+EXPORT void f2_V_ISS_PPD(int p0, struct S_PPD p1, struct S_PPD p2) { }
+EXPORT void f2_V_ISS_PPP(int p0, struct S_PPP p1, struct S_PPP p2) { }
+EXPORT void f2_V_FII_(float p0, int p1, int p2) { }
+EXPORT void f2_V_FIF_(float p0, int p1, float p2) { }
+EXPORT void f2_V_FID_(float p0, int p1, double p2) { }
+EXPORT void f2_V_FIP_(float p0, int p1, void* p2) { }
+EXPORT void f2_V_FIS_I(float p0, int p1, struct S_I p2) { }
+EXPORT void f2_V_FIS_F(float p0, int p1, struct S_F p2) { }
+EXPORT void f2_V_FIS_D(float p0, int p1, struct S_D p2) { }
+EXPORT void f2_V_FIS_P(float p0, int p1, struct S_P p2) { }
+EXPORT void f2_V_FIS_II(float p0, int p1, struct S_II p2) { }
+EXPORT void f2_V_FIS_IF(float p0, int p1, struct S_IF p2) { }
+EXPORT void f2_V_FIS_ID(float p0, int p1, struct S_ID p2) { }
+EXPORT void f2_V_FIS_IP(float p0, int p1, struct S_IP p2) { }
+EXPORT void f2_V_FIS_FI(float p0, int p1, struct S_FI p2) { }
+EXPORT void f2_V_FIS_FF(float p0, int p1, struct S_FF p2) { }
+EXPORT void f2_V_FIS_FD(float p0, int p1, struct S_FD p2) { }
+EXPORT void f2_V_FIS_FP(float p0, int p1, struct S_FP p2) { }
+EXPORT void f2_V_FIS_DI(float p0, int p1, struct S_DI p2) { }
+EXPORT void f2_V_FIS_DF(float p0, int p1, struct S_DF p2) { }
+EXPORT void f2_V_FIS_DD(float p0, int p1, struct S_DD p2) { }
+EXPORT void f2_V_FIS_DP(float p0, int p1, struct S_DP p2) { }
+EXPORT void f2_V_FIS_PI(float p0, int p1, struct S_PI p2) { }
+EXPORT void f2_V_FIS_PF(float p0, int p1, struct S_PF p2) { }
+EXPORT void f2_V_FIS_PD(float p0, int p1, struct S_PD p2) { }
+EXPORT void f2_V_FIS_PP(float p0, int p1, struct S_PP p2) { }
+EXPORT void f2_V_FIS_III(float p0, int p1, struct S_III p2) { }
+EXPORT void f2_V_FIS_IIF(float p0, int p1, struct S_IIF p2) { }
+EXPORT void f2_V_FIS_IID(float p0, int p1, struct S_IID p2) { }
+EXPORT void f2_V_FIS_IIP(float p0, int p1, struct S_IIP p2) { }
+EXPORT void f2_V_FIS_IFI(float p0, int p1, struct S_IFI p2) { }
+EXPORT void f2_V_FIS_IFF(float p0, int p1, struct S_IFF p2) { }
+EXPORT void f2_V_FIS_IFD(float p0, int p1, struct S_IFD p2) { }
+EXPORT void f2_V_FIS_IFP(float p0, int p1, struct S_IFP p2) { }
+EXPORT void f2_V_FIS_IDI(float p0, int p1, struct S_IDI p2) { }
+EXPORT void f2_V_FIS_IDF(float p0, int p1, struct S_IDF p2) { }
+EXPORT void f2_V_FIS_IDD(float p0, int p1, struct S_IDD p2) { }
+EXPORT void f2_V_FIS_IDP(float p0, int p1, struct S_IDP p2) { }
+EXPORT void f2_V_FIS_IPI(float p0, int p1, struct S_IPI p2) { }
+EXPORT void f2_V_FIS_IPF(float p0, int p1, struct S_IPF p2) { }
+EXPORT void f2_V_FIS_IPD(float p0, int p1, struct S_IPD p2) { }
+EXPORT void f2_V_FIS_IPP(float p0, int p1, struct S_IPP p2) { }
+EXPORT void f2_V_FIS_FII(float p0, int p1, struct S_FII p2) { }
+EXPORT void f2_V_FIS_FIF(float p0, int p1, struct S_FIF p2) { }
+EXPORT void f2_V_FIS_FID(float p0, int p1, struct S_FID p2) { }
+EXPORT void f2_V_FIS_FIP(float p0, int p1, struct S_FIP p2) { }
+EXPORT void f2_V_FIS_FFI(float p0, int p1, struct S_FFI p2) { }
+EXPORT void f2_V_FIS_FFF(float p0, int p1, struct S_FFF p2) { }
+EXPORT void f2_V_FIS_FFD(float p0, int p1, struct S_FFD p2) { }
+EXPORT void f2_V_FIS_FFP(float p0, int p1, struct S_FFP p2) { }
+EXPORT void f2_V_FIS_FDI(float p0, int p1, struct S_FDI p2) { }
+EXPORT void f2_V_FIS_FDF(float p0, int p1, struct S_FDF p2) { }
+EXPORT void f2_V_FIS_FDD(float p0, int p1, struct S_FDD p2) { }
+EXPORT void f2_V_FIS_FDP(float p0, int p1, struct S_FDP p2) { }
+EXPORT void f2_V_FIS_FPI(float p0, int p1, struct S_FPI p2) { }
+EXPORT void f2_V_FIS_FPF(float p0, int p1, struct S_FPF p2) { }
+EXPORT void f2_V_FIS_FPD(float p0, int p1, struct S_FPD p2) { }
+EXPORT void f2_V_FIS_FPP(float p0, int p1, struct S_FPP p2) { }
+EXPORT void f2_V_FIS_DII(float p0, int p1, struct S_DII p2) { }
+EXPORT void f2_V_FIS_DIF(float p0, int p1, struct S_DIF p2) { }
+EXPORT void f2_V_FIS_DID(float p0, int p1, struct S_DID p2) { }
+EXPORT void f2_V_FIS_DIP(float p0, int p1, struct S_DIP p2) { }
+EXPORT void f2_V_FIS_DFI(float p0, int p1, struct S_DFI p2) { }
+EXPORT void f2_V_FIS_DFF(float p0, int p1, struct S_DFF p2) { }
+EXPORT void f2_V_FIS_DFD(float p0, int p1, struct S_DFD p2) { }
+EXPORT void f2_V_FIS_DFP(float p0, int p1, struct S_DFP p2) { }
+EXPORT void f2_V_FIS_DDI(float p0, int p1, struct S_DDI p2) { }
+EXPORT void f2_V_FIS_DDF(float p0, int p1, struct S_DDF p2) { }
+EXPORT void f2_V_FIS_DDD(float p0, int p1, struct S_DDD p2) { }
+EXPORT void f2_V_FIS_DDP(float p0, int p1, struct S_DDP p2) { }
+EXPORT void f2_V_FIS_DPI(float p0, int p1, struct S_DPI p2) { }
+EXPORT void f2_V_FIS_DPF(float p0, int p1, struct S_DPF p2) { }
+EXPORT void f2_V_FIS_DPD(float p0, int p1, struct S_DPD p2) { }
+EXPORT void f2_V_FIS_DPP(float p0, int p1, struct S_DPP p2) { }
+EXPORT void f2_V_FIS_PII(float p0, int p1, struct S_PII p2) { }
+EXPORT void f2_V_FIS_PIF(float p0, int p1, struct S_PIF p2) { }
+EXPORT void f2_V_FIS_PID(float p0, int p1, struct S_PID p2) { }
+EXPORT void f2_V_FIS_PIP(float p0, int p1, struct S_PIP p2) { }
+EXPORT void f2_V_FIS_PFI(float p0, int p1, struct S_PFI p2) { }
+EXPORT void f2_V_FIS_PFF(float p0, int p1, struct S_PFF p2) { }
+EXPORT void f2_V_FIS_PFD(float p0, int p1, struct S_PFD p2) { }
+EXPORT void f2_V_FIS_PFP(float p0, int p1, struct S_PFP p2) { }
+EXPORT void f2_V_FIS_PDI(float p0, int p1, struct S_PDI p2) { }
+EXPORT void f2_V_FIS_PDF(float p0, int p1, struct S_PDF p2) { }
+EXPORT void f2_V_FIS_PDD(float p0, int p1, struct S_PDD p2) { }
+EXPORT void f2_V_FIS_PDP(float p0, int p1, struct S_PDP p2) { }
+EXPORT void f2_V_FIS_PPI(float p0, int p1, struct S_PPI p2) { }
+EXPORT void f2_V_FIS_PPF(float p0, int p1, struct S_PPF p2) { }
+EXPORT void f2_V_FIS_PPD(float p0, int p1, struct S_PPD p2) { }
+EXPORT void f2_V_FIS_PPP(float p0, int p1, struct S_PPP p2) { }
+EXPORT void f2_V_FFI_(float p0, float p1, int p2) { }
+EXPORT void f2_V_FFF_(float p0, float p1, float p2) { }
+EXPORT void f2_V_FFD_(float p0, float p1, double p2) { }
+EXPORT void f2_V_FFP_(float p0, float p1, void* p2) { }
+EXPORT void f2_V_FFS_I(float p0, float p1, struct S_I p2) { }
+EXPORT void f2_V_FFS_F(float p0, float p1, struct S_F p2) { }
+EXPORT void f2_V_FFS_D(float p0, float p1, struct S_D p2) { }
+EXPORT void f2_V_FFS_P(float p0, float p1, struct S_P p2) { }
+EXPORT void f2_V_FFS_II(float p0, float p1, struct S_II p2) { }
+EXPORT void f2_V_FFS_IF(float p0, float p1, struct S_IF p2) { }
+EXPORT void f2_V_FFS_ID(float p0, float p1, struct S_ID p2) { }
+EXPORT void f2_V_FFS_IP(float p0, float p1, struct S_IP p2) { }
+EXPORT void f2_V_FFS_FI(float p0, float p1, struct S_FI p2) { }
+EXPORT void f2_V_FFS_FF(float p0, float p1, struct S_FF p2) { }
+EXPORT void f2_V_FFS_FD(float p0, float p1, struct S_FD p2) { }
+EXPORT void f2_V_FFS_FP(float p0, float p1, struct S_FP p2) { }
+EXPORT void f2_V_FFS_DI(float p0, float p1, struct S_DI p2) { }
+EXPORT void f2_V_FFS_DF(float p0, float p1, struct S_DF p2) { }
+EXPORT void f2_V_FFS_DD(float p0, float p1, struct S_DD p2) { }
+EXPORT void f2_V_FFS_DP(float p0, float p1, struct S_DP p2) { }
+EXPORT void f2_V_FFS_PI(float p0, float p1, struct S_PI p2) { }
+EXPORT void f2_V_FFS_PF(float p0, float p1, struct S_PF p2) { }
+EXPORT void f2_V_FFS_PD(float p0, float p1, struct S_PD p2) { }
+EXPORT void f2_V_FFS_PP(float p0, float p1, struct S_PP p2) { }
+EXPORT void f2_V_FFS_III(float p0, float p1, struct S_III p2) { }
+EXPORT void f2_V_FFS_IIF(float p0, float p1, struct S_IIF p2) { }
+EXPORT void f2_V_FFS_IID(float p0, float p1, struct S_IID p2) { }
+EXPORT void f2_V_FFS_IIP(float p0, float p1, struct S_IIP p2) { }
+EXPORT void f2_V_FFS_IFI(float p0, float p1, struct S_IFI p2) { }
+EXPORT void f2_V_FFS_IFF(float p0, float p1, struct S_IFF p2) { }
+EXPORT void f2_V_FFS_IFD(float p0, float p1, struct S_IFD p2) { }
+EXPORT void f2_V_FFS_IFP(float p0, float p1, struct S_IFP p2) { }
+EXPORT void f2_V_FFS_IDI(float p0, float p1, struct S_IDI p2) { }
+EXPORT void f2_V_FFS_IDF(float p0, float p1, struct S_IDF p2) { }
+EXPORT void f2_V_FFS_IDD(float p0, float p1, struct S_IDD p2) { }
+EXPORT void f2_V_FFS_IDP(float p0, float p1, struct S_IDP p2) { }
+EXPORT void f2_V_FFS_IPI(float p0, float p1, struct S_IPI p2) { }
+EXPORT void f2_V_FFS_IPF(float p0, float p1, struct S_IPF p2) { }
+EXPORT void f2_V_FFS_IPD(float p0, float p1, struct S_IPD p2) { }
+EXPORT void f2_V_FFS_IPP(float p0, float p1, struct S_IPP p2) { }
+EXPORT void f2_V_FFS_FII(float p0, float p1, struct S_FII p2) { }
+EXPORT void f2_V_FFS_FIF(float p0, float p1, struct S_FIF p2) { }
+EXPORT void f2_V_FFS_FID(float p0, float p1, struct S_FID p2) { }
+EXPORT void f2_V_FFS_FIP(float p0, float p1, struct S_FIP p2) { }
+EXPORT void f2_V_FFS_FFI(float p0, float p1, struct S_FFI p2) { }
+EXPORT void f2_V_FFS_FFF(float p0, float p1, struct S_FFF p2) { }
+EXPORT void f2_V_FFS_FFD(float p0, float p1, struct S_FFD p2) { }
+EXPORT void f2_V_FFS_FFP(float p0, float p1, struct S_FFP p2) { }
+EXPORT void f2_V_FFS_FDI(float p0, float p1, struct S_FDI p2) { }
+EXPORT void f2_V_FFS_FDF(float p0, float p1, struct S_FDF p2) { }
+EXPORT void f2_V_FFS_FDD(float p0, float p1, struct S_FDD p2) { }
+EXPORT void f2_V_FFS_FDP(float p0, float p1, struct S_FDP p2) { }
+EXPORT void f2_V_FFS_FPI(float p0, float p1, struct S_FPI p2) { }
+EXPORT void f2_V_FFS_FPF(float p0, float p1, struct S_FPF p2) { }
+EXPORT void f2_V_FFS_FPD(float p0, float p1, struct S_FPD p2) { }
+EXPORT void f2_V_FFS_FPP(float p0, float p1, struct S_FPP p2) { }
+EXPORT void f2_V_FFS_DII(float p0, float p1, struct S_DII p2) { }
+EXPORT void f2_V_FFS_DIF(float p0, float p1, struct S_DIF p2) { }
+EXPORT void f2_V_FFS_DID(float p0, float p1, struct S_DID p2) { }
+EXPORT void f2_V_FFS_DIP(float p0, float p1, struct S_DIP p2) { }
+EXPORT void f2_V_FFS_DFI(float p0, float p1, struct S_DFI p2) { }
+EXPORT void f2_V_FFS_DFF(float p0, float p1, struct S_DFF p2) { }
+EXPORT void f2_V_FFS_DFD(float p0, float p1, struct S_DFD p2) { }
+EXPORT void f2_V_FFS_DFP(float p0, float p1, struct S_DFP p2) { }
+EXPORT void f2_V_FFS_DDI(float p0, float p1, struct S_DDI p2) { }
+EXPORT void f2_V_FFS_DDF(float p0, float p1, struct S_DDF p2) { }
+EXPORT void f2_V_FFS_DDD(float p0, float p1, struct S_DDD p2) { }
+EXPORT void f2_V_FFS_DDP(float p0, float p1, struct S_DDP p2) { }
+EXPORT void f2_V_FFS_DPI(float p0, float p1, struct S_DPI p2) { }
+EXPORT void f2_V_FFS_DPF(float p0, float p1, struct S_DPF p2) { }
+EXPORT void f2_V_FFS_DPD(float p0, float p1, struct S_DPD p2) { }
+EXPORT void f2_V_FFS_DPP(float p0, float p1, struct S_DPP p2) { }
+EXPORT void f2_V_FFS_PII(float p0, float p1, struct S_PII p2) { }
+EXPORT void f2_V_FFS_PIF(float p0, float p1, struct S_PIF p2) { }
+EXPORT void f2_V_FFS_PID(float p0, float p1, struct S_PID p2) { }
+EXPORT void f2_V_FFS_PIP(float p0, float p1, struct S_PIP p2) { }
+EXPORT void f2_V_FFS_PFI(float p0, float p1, struct S_PFI p2) { }
+EXPORT void f2_V_FFS_PFF(float p0, float p1, struct S_PFF p2) { }
+EXPORT void f2_V_FFS_PFD(float p0, float p1, struct S_PFD p2) { }
+EXPORT void f3_V_FFS_PFP(float p0, float p1, struct S_PFP p2) { }
+EXPORT void f3_V_FFS_PDI(float p0, float p1, struct S_PDI p2) { }
+EXPORT void f3_V_FFS_PDF(float p0, float p1, struct S_PDF p2) { }
+EXPORT void f3_V_FFS_PDD(float p0, float p1, struct S_PDD p2) { }
+EXPORT void f3_V_FFS_PDP(float p0, float p1, struct S_PDP p2) { }
+EXPORT void f3_V_FFS_PPI(float p0, float p1, struct S_PPI p2) { }
+EXPORT void f3_V_FFS_PPF(float p0, float p1, struct S_PPF p2) { }
+EXPORT void f3_V_FFS_PPD(float p0, float p1, struct S_PPD p2) { }
+EXPORT void f3_V_FFS_PPP(float p0, float p1, struct S_PPP p2) { }
+EXPORT void f3_V_FDI_(float p0, double p1, int p2) { }
+EXPORT void f3_V_FDF_(float p0, double p1, float p2) { }
+EXPORT void f3_V_FDD_(float p0, double p1, double p2) { }
+EXPORT void f3_V_FDP_(float p0, double p1, void* p2) { }
+EXPORT void f3_V_FDS_I(float p0, double p1, struct S_I p2) { }
+EXPORT void f3_V_FDS_F(float p0, double p1, struct S_F p2) { }
+EXPORT void f3_V_FDS_D(float p0, double p1, struct S_D p2) { }
+EXPORT void f3_V_FDS_P(float p0, double p1, struct S_P p2) { }
+EXPORT void f3_V_FDS_II(float p0, double p1, struct S_II p2) { }
+EXPORT void f3_V_FDS_IF(float p0, double p1, struct S_IF p2) { }
+EXPORT void f3_V_FDS_ID(float p0, double p1, struct S_ID p2) { }
+EXPORT void f3_V_FDS_IP(float p0, double p1, struct S_IP p2) { }
+EXPORT void f3_V_FDS_FI(float p0, double p1, struct S_FI p2) { }
+EXPORT void f3_V_FDS_FF(float p0, double p1, struct S_FF p2) { }
+EXPORT void f3_V_FDS_FD(float p0, double p1, struct S_FD p2) { }
+EXPORT void f3_V_FDS_FP(float p0, double p1, struct S_FP p2) { }
+EXPORT void f3_V_FDS_DI(float p0, double p1, struct S_DI p2) { }
+EXPORT void f3_V_FDS_DF(float p0, double p1, struct S_DF p2) { }
+EXPORT void f3_V_FDS_DD(float p0, double p1, struct S_DD p2) { }
+EXPORT void f3_V_FDS_DP(float p0, double p1, struct S_DP p2) { }
+EXPORT void f3_V_FDS_PI(float p0, double p1, struct S_PI p2) { }
+EXPORT void f3_V_FDS_PF(float p0, double p1, struct S_PF p2) { }
+EXPORT void f3_V_FDS_PD(float p0, double p1, struct S_PD p2) { }
+EXPORT void f3_V_FDS_PP(float p0, double p1, struct S_PP p2) { }
+EXPORT void f3_V_FDS_III(float p0, double p1, struct S_III p2) { }
+EXPORT void f3_V_FDS_IIF(float p0, double p1, struct S_IIF p2) { }
+EXPORT void f3_V_FDS_IID(float p0, double p1, struct S_IID p2) { }
+EXPORT void f3_V_FDS_IIP(float p0, double p1, struct S_IIP p2) { }
+EXPORT void f3_V_FDS_IFI(float p0, double p1, struct S_IFI p2) { }
+EXPORT void f3_V_FDS_IFF(float p0, double p1, struct S_IFF p2) { }
+EXPORT void f3_V_FDS_IFD(float p0, double p1, struct S_IFD p2) { }
+EXPORT void f3_V_FDS_IFP(float p0, double p1, struct S_IFP p2) { }
+EXPORT void f3_V_FDS_IDI(float p0, double p1, struct S_IDI p2) { }
+EXPORT void f3_V_FDS_IDF(float p0, double p1, struct S_IDF p2) { }
+EXPORT void f3_V_FDS_IDD(float p0, double p1, struct S_IDD p2) { }
+EXPORT void f3_V_FDS_IDP(float p0, double p1, struct S_IDP p2) { }
+EXPORT void f3_V_FDS_IPI(float p0, double p1, struct S_IPI p2) { }
+EXPORT void f3_V_FDS_IPF(float p0, double p1, struct S_IPF p2) { }
+EXPORT void f3_V_FDS_IPD(float p0, double p1, struct S_IPD p2) { }
+EXPORT void f3_V_FDS_IPP(float p0, double p1, struct S_IPP p2) { }
+EXPORT void f3_V_FDS_FII(float p0, double p1, struct S_FII p2) { }
+EXPORT void f3_V_FDS_FIF(float p0, double p1, struct S_FIF p2) { }
+EXPORT void f3_V_FDS_FID(float p0, double p1, struct S_FID p2) { }
+EXPORT void f3_V_FDS_FIP(float p0, double p1, struct S_FIP p2) { }
+EXPORT void f3_V_FDS_FFI(float p0, double p1, struct S_FFI p2) { }
+EXPORT void f3_V_FDS_FFF(float p0, double p1, struct S_FFF p2) { }
+EXPORT void f3_V_FDS_FFD(float p0, double p1, struct S_FFD p2) { }
+EXPORT void f3_V_FDS_FFP(float p0, double p1, struct S_FFP p2) { }
+EXPORT void f3_V_FDS_FDI(float p0, double p1, struct S_FDI p2) { }
+EXPORT void f3_V_FDS_FDF(float p0, double p1, struct S_FDF p2) { }
+EXPORT void f3_V_FDS_FDD(float p0, double p1, struct S_FDD p2) { }
+EXPORT void f3_V_FDS_FDP(float p0, double p1, struct S_FDP p2) { }
+EXPORT void f3_V_FDS_FPI(float p0, double p1, struct S_FPI p2) { }
+EXPORT void f3_V_FDS_FPF(float p0, double p1, struct S_FPF p2) { }
+EXPORT void f3_V_FDS_FPD(float p0, double p1, struct S_FPD p2) { }
+EXPORT void f3_V_FDS_FPP(float p0, double p1, struct S_FPP p2) { }
+EXPORT void f3_V_FDS_DII(float p0, double p1, struct S_DII p2) { }
+EXPORT void f3_V_FDS_DIF(float p0, double p1, struct S_DIF p2) { }
+EXPORT void f3_V_FDS_DID(float p0, double p1, struct S_DID p2) { }
+EXPORT void f3_V_FDS_DIP(float p0, double p1, struct S_DIP p2) { }
+EXPORT void f3_V_FDS_DFI(float p0, double p1, struct S_DFI p2) { }
+EXPORT void f3_V_FDS_DFF(float p0, double p1, struct S_DFF p2) { }
+EXPORT void f3_V_FDS_DFD(float p0, double p1, struct S_DFD p2) { }
+EXPORT void f3_V_FDS_DFP(float p0, double p1, struct S_DFP p2) { }
+EXPORT void f3_V_FDS_DDI(float p0, double p1, struct S_DDI p2) { }
+EXPORT void f3_V_FDS_DDF(float p0, double p1, struct S_DDF p2) { }
+EXPORT void f3_V_FDS_DDD(float p0, double p1, struct S_DDD p2) { }
+EXPORT void f3_V_FDS_DDP(float p0, double p1, struct S_DDP p2) { }
+EXPORT void f3_V_FDS_DPI(float p0, double p1, struct S_DPI p2) { }
+EXPORT void f3_V_FDS_DPF(float p0, double p1, struct S_DPF p2) { }
+EXPORT void f3_V_FDS_DPD(float p0, double p1, struct S_DPD p2) { }
+EXPORT void f3_V_FDS_DPP(float p0, double p1, struct S_DPP p2) { }
+EXPORT void f3_V_FDS_PII(float p0, double p1, struct S_PII p2) { }
+EXPORT void f3_V_FDS_PIF(float p0, double p1, struct S_PIF p2) { }
+EXPORT void f3_V_FDS_PID(float p0, double p1, struct S_PID p2) { }
+EXPORT void f3_V_FDS_PIP(float p0, double p1, struct S_PIP p2) { }
+EXPORT void f3_V_FDS_PFI(float p0, double p1, struct S_PFI p2) { }
+EXPORT void f3_V_FDS_PFF(float p0, double p1, struct S_PFF p2) { }
+EXPORT void f3_V_FDS_PFD(float p0, double p1, struct S_PFD p2) { }
+EXPORT void f3_V_FDS_PFP(float p0, double p1, struct S_PFP p2) { }
+EXPORT void f3_V_FDS_PDI(float p0, double p1, struct S_PDI p2) { }
+EXPORT void f3_V_FDS_PDF(float p0, double p1, struct S_PDF p2) { }
+EXPORT void f3_V_FDS_PDD(float p0, double p1, struct S_PDD p2) { }
+EXPORT void f3_V_FDS_PDP(float p0, double p1, struct S_PDP p2) { }
+EXPORT void f3_V_FDS_PPI(float p0, double p1, struct S_PPI p2) { }
+EXPORT void f3_V_FDS_PPF(float p0, double p1, struct S_PPF p2) { }
+EXPORT void f3_V_FDS_PPD(float p0, double p1, struct S_PPD p2) { }
+EXPORT void f3_V_FDS_PPP(float p0, double p1, struct S_PPP p2) { }
+EXPORT void f3_V_FPI_(float p0, void* p1, int p2) { }
+EXPORT void f3_V_FPF_(float p0, void* p1, float p2) { }
+EXPORT void f3_V_FPD_(float p0, void* p1, double p2) { }
+EXPORT void f3_V_FPP_(float p0, void* p1, void* p2) { }
+EXPORT void f3_V_FPS_I(float p0, void* p1, struct S_I p2) { }
+EXPORT void f3_V_FPS_F(float p0, void* p1, struct S_F p2) { }
+EXPORT void f3_V_FPS_D(float p0, void* p1, struct S_D p2) { }
+EXPORT void f3_V_FPS_P(float p0, void* p1, struct S_P p2) { }
+EXPORT void f3_V_FPS_II(float p0, void* p1, struct S_II p2) { }
+EXPORT void f3_V_FPS_IF(float p0, void* p1, struct S_IF p2) { }
+EXPORT void f3_V_FPS_ID(float p0, void* p1, struct S_ID p2) { }
+EXPORT void f3_V_FPS_IP(float p0, void* p1, struct S_IP p2) { }
+EXPORT void f3_V_FPS_FI(float p0, void* p1, struct S_FI p2) { }
+EXPORT void f3_V_FPS_FF(float p0, void* p1, struct S_FF p2) { }
+EXPORT void f3_V_FPS_FD(float p0, void* p1, struct S_FD p2) { }
+EXPORT void f3_V_FPS_FP(float p0, void* p1, struct S_FP p2) { }
+EXPORT void f3_V_FPS_DI(float p0, void* p1, struct S_DI p2) { }
+EXPORT void f3_V_FPS_DF(float p0, void* p1, struct S_DF p2) { }
+EXPORT void f3_V_FPS_DD(float p0, void* p1, struct S_DD p2) { }
+EXPORT void f3_V_FPS_DP(float p0, void* p1, struct S_DP p2) { }
+EXPORT void f3_V_FPS_PI(float p0, void* p1, struct S_PI p2) { }
+EXPORT void f3_V_FPS_PF(float p0, void* p1, struct S_PF p2) { }
+EXPORT void f3_V_FPS_PD(float p0, void* p1, struct S_PD p2) { }
+EXPORT void f3_V_FPS_PP(float p0, void* p1, struct S_PP p2) { }
+EXPORT void f3_V_FPS_III(float p0, void* p1, struct S_III p2) { }
+EXPORT void f3_V_FPS_IIF(float p0, void* p1, struct S_IIF p2) { }
+EXPORT void f3_V_FPS_IID(float p0, void* p1, struct S_IID p2) { }
+EXPORT void f3_V_FPS_IIP(float p0, void* p1, struct S_IIP p2) { }
+EXPORT void f3_V_FPS_IFI(float p0, void* p1, struct S_IFI p2) { }
+EXPORT void f3_V_FPS_IFF(float p0, void* p1, struct S_IFF p2) { }
+EXPORT void f3_V_FPS_IFD(float p0, void* p1, struct S_IFD p2) { }
+EXPORT void f3_V_FPS_IFP(float p0, void* p1, struct S_IFP p2) { }
+EXPORT void f3_V_FPS_IDI(float p0, void* p1, struct S_IDI p2) { }
+EXPORT void f3_V_FPS_IDF(float p0, void* p1, struct S_IDF p2) { }
+EXPORT void f3_V_FPS_IDD(float p0, void* p1, struct S_IDD p2) { }
+EXPORT void f3_V_FPS_IDP(float p0, void* p1, struct S_IDP p2) { }
+EXPORT void f3_V_FPS_IPI(float p0, void* p1, struct S_IPI p2) { }
+EXPORT void f3_V_FPS_IPF(float p0, void* p1, struct S_IPF p2) { }
+EXPORT void f3_V_FPS_IPD(float p0, void* p1, struct S_IPD p2) { }
+EXPORT void f3_V_FPS_IPP(float p0, void* p1, struct S_IPP p2) { }
+EXPORT void f3_V_FPS_FII(float p0, void* p1, struct S_FII p2) { }
+EXPORT void f3_V_FPS_FIF(float p0, void* p1, struct S_FIF p2) { }
+EXPORT void f3_V_FPS_FID(float p0, void* p1, struct S_FID p2) { }
+EXPORT void f3_V_FPS_FIP(float p0, void* p1, struct S_FIP p2) { }
+EXPORT void f3_V_FPS_FFI(float p0, void* p1, struct S_FFI p2) { }
+EXPORT void f3_V_FPS_FFF(float p0, void* p1, struct S_FFF p2) { }
+EXPORT void f3_V_FPS_FFD(float p0, void* p1, struct S_FFD p2) { }
+EXPORT void f3_V_FPS_FFP(float p0, void* p1, struct S_FFP p2) { }
+EXPORT void f3_V_FPS_FDI(float p0, void* p1, struct S_FDI p2) { }
+EXPORT void f3_V_FPS_FDF(float p0, void* p1, struct S_FDF p2) { }
+EXPORT void f3_V_FPS_FDD(float p0, void* p1, struct S_FDD p2) { }
+EXPORT void f3_V_FPS_FDP(float p0, void* p1, struct S_FDP p2) { }
+EXPORT void f3_V_FPS_FPI(float p0, void* p1, struct S_FPI p2) { }
+EXPORT void f3_V_FPS_FPF(float p0, void* p1, struct S_FPF p2) { }
+EXPORT void f3_V_FPS_FPD(float p0, void* p1, struct S_FPD p2) { }
+EXPORT void f3_V_FPS_FPP(float p0, void* p1, struct S_FPP p2) { }
+EXPORT void f3_V_FPS_DII(float p0, void* p1, struct S_DII p2) { }
+EXPORT void f3_V_FPS_DIF(float p0, void* p1, struct S_DIF p2) { }
+EXPORT void f3_V_FPS_DID(float p0, void* p1, struct S_DID p2) { }
+EXPORT void f3_V_FPS_DIP(float p0, void* p1, struct S_DIP p2) { }
+EXPORT void f3_V_FPS_DFI(float p0, void* p1, struct S_DFI p2) { }
+EXPORT void f3_V_FPS_DFF(float p0, void* p1, struct S_DFF p2) { }
+EXPORT void f3_V_FPS_DFD(float p0, void* p1, struct S_DFD p2) { }
+EXPORT void f3_V_FPS_DFP(float p0, void* p1, struct S_DFP p2) { }
+EXPORT void f3_V_FPS_DDI(float p0, void* p1, struct S_DDI p2) { }
+EXPORT void f3_V_FPS_DDF(float p0, void* p1, struct S_DDF p2) { }
+EXPORT void f3_V_FPS_DDD(float p0, void* p1, struct S_DDD p2) { }
+EXPORT void f3_V_FPS_DDP(float p0, void* p1, struct S_DDP p2) { }
+EXPORT void f3_V_FPS_DPI(float p0, void* p1, struct S_DPI p2) { }
+EXPORT void f3_V_FPS_DPF(float p0, void* p1, struct S_DPF p2) { }
+EXPORT void f3_V_FPS_DPD(float p0, void* p1, struct S_DPD p2) { }
+EXPORT void f3_V_FPS_DPP(float p0, void* p1, struct S_DPP p2) { }
+EXPORT void f3_V_FPS_PII(float p0, void* p1, struct S_PII p2) { }
+EXPORT void f3_V_FPS_PIF(float p0, void* p1, struct S_PIF p2) { }
+EXPORT void f3_V_FPS_PID(float p0, void* p1, struct S_PID p2) { }
+EXPORT void f3_V_FPS_PIP(float p0, void* p1, struct S_PIP p2) { }
+EXPORT void f3_V_FPS_PFI(float p0, void* p1, struct S_PFI p2) { }
+EXPORT void f3_V_FPS_PFF(float p0, void* p1, struct S_PFF p2) { }
+EXPORT void f3_V_FPS_PFD(float p0, void* p1, struct S_PFD p2) { }
+EXPORT void f3_V_FPS_PFP(float p0, void* p1, struct S_PFP p2) { }
+EXPORT void f3_V_FPS_PDI(float p0, void* p1, struct S_PDI p2) { }
+EXPORT void f3_V_FPS_PDF(float p0, void* p1, struct S_PDF p2) { }
+EXPORT void f3_V_FPS_PDD(float p0, void* p1, struct S_PDD p2) { }
+EXPORT void f3_V_FPS_PDP(float p0, void* p1, struct S_PDP p2) { }
+EXPORT void f3_V_FPS_PPI(float p0, void* p1, struct S_PPI p2) { }
+EXPORT void f3_V_FPS_PPF(float p0, void* p1, struct S_PPF p2) { }
+EXPORT void f3_V_FPS_PPD(float p0, void* p1, struct S_PPD p2) { }
+EXPORT void f3_V_FPS_PPP(float p0, void* p1, struct S_PPP p2) { }
+EXPORT void f3_V_FSI_I(float p0, struct S_I p1, int p2) { }
+EXPORT void f3_V_FSI_F(float p0, struct S_F p1, int p2) { }
+EXPORT void f3_V_FSI_D(float p0, struct S_D p1, int p2) { }
+EXPORT void f3_V_FSI_P(float p0, struct S_P p1, int p2) { }
+EXPORT void f3_V_FSI_II(float p0, struct S_II p1, int p2) { }
+EXPORT void f3_V_FSI_IF(float p0, struct S_IF p1, int p2) { }
+EXPORT void f3_V_FSI_ID(float p0, struct S_ID p1, int p2) { }
+EXPORT void f3_V_FSI_IP(float p0, struct S_IP p1, int p2) { }
+EXPORT void f3_V_FSI_FI(float p0, struct S_FI p1, int p2) { }
+EXPORT void f3_V_FSI_FF(float p0, struct S_FF p1, int p2) { }
+EXPORT void f3_V_FSI_FD(float p0, struct S_FD p1, int p2) { }
+EXPORT void f3_V_FSI_FP(float p0, struct S_FP p1, int p2) { }
+EXPORT void f3_V_FSI_DI(float p0, struct S_DI p1, int p2) { }
+EXPORT void f3_V_FSI_DF(float p0, struct S_DF p1, int p2) { }
+EXPORT void f3_V_FSI_DD(float p0, struct S_DD p1, int p2) { }
+EXPORT void f3_V_FSI_DP(float p0, struct S_DP p1, int p2) { }
+EXPORT void f3_V_FSI_PI(float p0, struct S_PI p1, int p2) { }
+EXPORT void f3_V_FSI_PF(float p0, struct S_PF p1, int p2) { }
+EXPORT void f3_V_FSI_PD(float p0, struct S_PD p1, int p2) { }
+EXPORT void f3_V_FSI_PP(float p0, struct S_PP p1, int p2) { }
+EXPORT void f3_V_FSI_III(float p0, struct S_III p1, int p2) { }
+EXPORT void f3_V_FSI_IIF(float p0, struct S_IIF p1, int p2) { }
+EXPORT void f3_V_FSI_IID(float p0, struct S_IID p1, int p2) { }
+EXPORT void f3_V_FSI_IIP(float p0, struct S_IIP p1, int p2) { }
+EXPORT void f3_V_FSI_IFI(float p0, struct S_IFI p1, int p2) { }
+EXPORT void f3_V_FSI_IFF(float p0, struct S_IFF p1, int p2) { }
+EXPORT void f3_V_FSI_IFD(float p0, struct S_IFD p1, int p2) { }
+EXPORT void f3_V_FSI_IFP(float p0, struct S_IFP p1, int p2) { }
+EXPORT void f3_V_FSI_IDI(float p0, struct S_IDI p1, int p2) { }
+EXPORT void f3_V_FSI_IDF(float p0, struct S_IDF p1, int p2) { }
+EXPORT void f3_V_FSI_IDD(float p0, struct S_IDD p1, int p2) { }
+EXPORT void f3_V_FSI_IDP(float p0, struct S_IDP p1, int p2) { }
+EXPORT void f3_V_FSI_IPI(float p0, struct S_IPI p1, int p2) { }
+EXPORT void f3_V_FSI_IPF(float p0, struct S_IPF p1, int p2) { }
+EXPORT void f3_V_FSI_IPD(float p0, struct S_IPD p1, int p2) { }
+EXPORT void f3_V_FSI_IPP(float p0, struct S_IPP p1, int p2) { }
+EXPORT void f3_V_FSI_FII(float p0, struct S_FII p1, int p2) { }
+EXPORT void f3_V_FSI_FIF(float p0, struct S_FIF p1, int p2) { }
+EXPORT void f3_V_FSI_FID(float p0, struct S_FID p1, int p2) { }
+EXPORT void f3_V_FSI_FIP(float p0, struct S_FIP p1, int p2) { }
+EXPORT void f3_V_FSI_FFI(float p0, struct S_FFI p1, int p2) { }
+EXPORT void f3_V_FSI_FFF(float p0, struct S_FFF p1, int p2) { }
+EXPORT void f3_V_FSI_FFD(float p0, struct S_FFD p1, int p2) { }
+EXPORT void f3_V_FSI_FFP(float p0, struct S_FFP p1, int p2) { }
+EXPORT void f3_V_FSI_FDI(float p0, struct S_FDI p1, int p2) { }
+EXPORT void f3_V_FSI_FDF(float p0, struct S_FDF p1, int p2) { }
+EXPORT void f3_V_FSI_FDD(float p0, struct S_FDD p1, int p2) { }
+EXPORT void f3_V_FSI_FDP(float p0, struct S_FDP p1, int p2) { }
+EXPORT void f3_V_FSI_FPI(float p0, struct S_FPI p1, int p2) { }
+EXPORT void f3_V_FSI_FPF(float p0, struct S_FPF p1, int p2) { }
+EXPORT void f3_V_FSI_FPD(float p0, struct S_FPD p1, int p2) { }
+EXPORT void f3_V_FSI_FPP(float p0, struct S_FPP p1, int p2) { }
+EXPORT void f3_V_FSI_DII(float p0, struct S_DII p1, int p2) { }
+EXPORT void f3_V_FSI_DIF(float p0, struct S_DIF p1, int p2) { }
+EXPORT void f3_V_FSI_DID(float p0, struct S_DID p1, int p2) { }
+EXPORT void f3_V_FSI_DIP(float p0, struct S_DIP p1, int p2) { }
+EXPORT void f3_V_FSI_DFI(float p0, struct S_DFI p1, int p2) { }
+EXPORT void f3_V_FSI_DFF(float p0, struct S_DFF p1, int p2) { }
+EXPORT void f3_V_FSI_DFD(float p0, struct S_DFD p1, int p2) { }
+EXPORT void f3_V_FSI_DFP(float p0, struct S_DFP p1, int p2) { }
+EXPORT void f3_V_FSI_DDI(float p0, struct S_DDI p1, int p2) { }
+EXPORT void f3_V_FSI_DDF(float p0, struct S_DDF p1, int p2) { }
+EXPORT void f3_V_FSI_DDD(float p0, struct S_DDD p1, int p2) { }
+EXPORT void f3_V_FSI_DDP(float p0, struct S_DDP p1, int p2) { }
+EXPORT void f3_V_FSI_DPI(float p0, struct S_DPI p1, int p2) { }
+EXPORT void f3_V_FSI_DPF(float p0, struct S_DPF p1, int p2) { }
+EXPORT void f3_V_FSI_DPD(float p0, struct S_DPD p1, int p2) { }
+EXPORT void f3_V_FSI_DPP(float p0, struct S_DPP p1, int p2) { }
+EXPORT void f3_V_FSI_PII(float p0, struct S_PII p1, int p2) { }
+EXPORT void f3_V_FSI_PIF(float p0, struct S_PIF p1, int p2) { }
+EXPORT void f3_V_FSI_PID(float p0, struct S_PID p1, int p2) { }
+EXPORT void f3_V_FSI_PIP(float p0, struct S_PIP p1, int p2) { }
+EXPORT void f3_V_FSI_PFI(float p0, struct S_PFI p1, int p2) { }
+EXPORT void f3_V_FSI_PFF(float p0, struct S_PFF p1, int p2) { }
+EXPORT void f3_V_FSI_PFD(float p0, struct S_PFD p1, int p2) { }
+EXPORT void f3_V_FSI_PFP(float p0, struct S_PFP p1, int p2) { }
+EXPORT void f3_V_FSI_PDI(float p0, struct S_PDI p1, int p2) { }
+EXPORT void f3_V_FSI_PDF(float p0, struct S_PDF p1, int p2) { }
+EXPORT void f3_V_FSI_PDD(float p0, struct S_PDD p1, int p2) { }
+EXPORT void f3_V_FSI_PDP(float p0, struct S_PDP p1, int p2) { }
+EXPORT void f3_V_FSI_PPI(float p0, struct S_PPI p1, int p2) { }
+EXPORT void f3_V_FSI_PPF(float p0, struct S_PPF p1, int p2) { }
+EXPORT void f3_V_FSI_PPD(float p0, struct S_PPD p1, int p2) { }
+EXPORT void f3_V_FSI_PPP(float p0, struct S_PPP p1, int p2) { }
+EXPORT void f3_V_FSF_I(float p0, struct S_I p1, float p2) { }
+EXPORT void f3_V_FSF_F(float p0, struct S_F p1, float p2) { }
+EXPORT void f3_V_FSF_D(float p0, struct S_D p1, float p2) { }
+EXPORT void f3_V_FSF_P(float p0, struct S_P p1, float p2) { }
+EXPORT void f3_V_FSF_II(float p0, struct S_II p1, float p2) { }
+EXPORT void f3_V_FSF_IF(float p0, struct S_IF p1, float p2) { }
+EXPORT void f3_V_FSF_ID(float p0, struct S_ID p1, float p2) { }
+EXPORT void f3_V_FSF_IP(float p0, struct S_IP p1, float p2) { }
+EXPORT void f3_V_FSF_FI(float p0, struct S_FI p1, float p2) { }
+EXPORT void f3_V_FSF_FF(float p0, struct S_FF p1, float p2) { }
+EXPORT void f3_V_FSF_FD(float p0, struct S_FD p1, float p2) { }
+EXPORT void f3_V_FSF_FP(float p0, struct S_FP p1, float p2) { }
+EXPORT void f3_V_FSF_DI(float p0, struct S_DI p1, float p2) { }
+EXPORT void f3_V_FSF_DF(float p0, struct S_DF p1, float p2) { }
+EXPORT void f3_V_FSF_DD(float p0, struct S_DD p1, float p2) { }
+EXPORT void f3_V_FSF_DP(float p0, struct S_DP p1, float p2) { }
+EXPORT void f3_V_FSF_PI(float p0, struct S_PI p1, float p2) { }
+EXPORT void f3_V_FSF_PF(float p0, struct S_PF p1, float p2) { }
+EXPORT void f3_V_FSF_PD(float p0, struct S_PD p1, float p2) { }
+EXPORT void f3_V_FSF_PP(float p0, struct S_PP p1, float p2) { }
+EXPORT void f3_V_FSF_III(float p0, struct S_III p1, float p2) { }
+EXPORT void f3_V_FSF_IIF(float p0, struct S_IIF p1, float p2) { }
+EXPORT void f3_V_FSF_IID(float p0, struct S_IID p1, float p2) { }
+EXPORT void f3_V_FSF_IIP(float p0, struct S_IIP p1, float p2) { }
+EXPORT void f3_V_FSF_IFI(float p0, struct S_IFI p1, float p2) { }
+EXPORT void f3_V_FSF_IFF(float p0, struct S_IFF p1, float p2) { }
+EXPORT void f3_V_FSF_IFD(float p0, struct S_IFD p1, float p2) { }
+EXPORT void f3_V_FSF_IFP(float p0, struct S_IFP p1, float p2) { }
+EXPORT void f3_V_FSF_IDI(float p0, struct S_IDI p1, float p2) { }
+EXPORT void f3_V_FSF_IDF(float p0, struct S_IDF p1, float p2) { }
+EXPORT void f3_V_FSF_IDD(float p0, struct S_IDD p1, float p2) { }
+EXPORT void f3_V_FSF_IDP(float p0, struct S_IDP p1, float p2) { }
+EXPORT void f3_V_FSF_IPI(float p0, struct S_IPI p1, float p2) { }
+EXPORT void f3_V_FSF_IPF(float p0, struct S_IPF p1, float p2) { }
+EXPORT void f3_V_FSF_IPD(float p0, struct S_IPD p1, float p2) { }
+EXPORT void f3_V_FSF_IPP(float p0, struct S_IPP p1, float p2) { }
+EXPORT void f3_V_FSF_FII(float p0, struct S_FII p1, float p2) { }
+EXPORT void f3_V_FSF_FIF(float p0, struct S_FIF p1, float p2) { }
+EXPORT void f3_V_FSF_FID(float p0, struct S_FID p1, float p2) { }
+EXPORT void f3_V_FSF_FIP(float p0, struct S_FIP p1, float p2) { }
+EXPORT void f3_V_FSF_FFI(float p0, struct S_FFI p1, float p2) { }
+EXPORT void f3_V_FSF_FFF(float p0, struct S_FFF p1, float p2) { }
+EXPORT void f3_V_FSF_FFD(float p0, struct S_FFD p1, float p2) { }
+EXPORT void f3_V_FSF_FFP(float p0, struct S_FFP p1, float p2) { }
+EXPORT void f3_V_FSF_FDI(float p0, struct S_FDI p1, float p2) { }
+EXPORT void f3_V_FSF_FDF(float p0, struct S_FDF p1, float p2) { }
+EXPORT void f3_V_FSF_FDD(float p0, struct S_FDD p1, float p2) { }
+EXPORT void f3_V_FSF_FDP(float p0, struct S_FDP p1, float p2) { }
+EXPORT void f3_V_FSF_FPI(float p0, struct S_FPI p1, float p2) { }
+EXPORT void f3_V_FSF_FPF(float p0, struct S_FPF p1, float p2) { }
+EXPORT void f3_V_FSF_FPD(float p0, struct S_FPD p1, float p2) { }
+EXPORT void f3_V_FSF_FPP(float p0, struct S_FPP p1, float p2) { }
+EXPORT void f3_V_FSF_DII(float p0, struct S_DII p1, float p2) { }
+EXPORT void f3_V_FSF_DIF(float p0, struct S_DIF p1, float p2) { }
+EXPORT void f3_V_FSF_DID(float p0, struct S_DID p1, float p2) { }
+EXPORT void f3_V_FSF_DIP(float p0, struct S_DIP p1, float p2) { }
+EXPORT void f3_V_FSF_DFI(float p0, struct S_DFI p1, float p2) { }
+EXPORT void f3_V_FSF_DFF(float p0, struct S_DFF p1, float p2) { }
+EXPORT void f3_V_FSF_DFD(float p0, struct S_DFD p1, float p2) { }
+EXPORT void f3_V_FSF_DFP(float p0, struct S_DFP p1, float p2) { }
+EXPORT void f3_V_FSF_DDI(float p0, struct S_DDI p1, float p2) { }
+EXPORT void f3_V_FSF_DDF(float p0, struct S_DDF p1, float p2) { }
+EXPORT void f3_V_FSF_DDD(float p0, struct S_DDD p1, float p2) { }
+EXPORT void f3_V_FSF_DDP(float p0, struct S_DDP p1, float p2) { }
+EXPORT void f3_V_FSF_DPI(float p0, struct S_DPI p1, float p2) { }
+EXPORT void f3_V_FSF_DPF(float p0, struct S_DPF p1, float p2) { }
+EXPORT void f3_V_FSF_DPD(float p0, struct S_DPD p1, float p2) { }
+EXPORT void f3_V_FSF_DPP(float p0, struct S_DPP p1, float p2) { }
+EXPORT void f3_V_FSF_PII(float p0, struct S_PII p1, float p2) { }
+EXPORT void f3_V_FSF_PIF(float p0, struct S_PIF p1, float p2) { }
+EXPORT void f3_V_FSF_PID(float p0, struct S_PID p1, float p2) { }
+EXPORT void f3_V_FSF_PIP(float p0, struct S_PIP p1, float p2) { }
+EXPORT void f3_V_FSF_PFI(float p0, struct S_PFI p1, float p2) { }
+EXPORT void f3_V_FSF_PFF(float p0, struct S_PFF p1, float p2) { }
+EXPORT void f3_V_FSF_PFD(float p0, struct S_PFD p1, float p2) { }
+EXPORT void f3_V_FSF_PFP(float p0, struct S_PFP p1, float p2) { }
+EXPORT void f3_V_FSF_PDI(float p0, struct S_PDI p1, float p2) { }
+EXPORT void f3_V_FSF_PDF(float p0, struct S_PDF p1, float p2) { }
+EXPORT void f3_V_FSF_PDD(float p0, struct S_PDD p1, float p2) { }
+EXPORT void f3_V_FSF_PDP(float p0, struct S_PDP p1, float p2) { }
+EXPORT void f3_V_FSF_PPI(float p0, struct S_PPI p1, float p2) { }
+EXPORT void f3_V_FSF_PPF(float p0, struct S_PPF p1, float p2) { }
+EXPORT void f3_V_FSF_PPD(float p0, struct S_PPD p1, float p2) { }
+EXPORT void f3_V_FSF_PPP(float p0, struct S_PPP p1, float p2) { }
+EXPORT void f3_V_FSD_I(float p0, struct S_I p1, double p2) { }
+EXPORT void f3_V_FSD_F(float p0, struct S_F p1, double p2) { }
+EXPORT void f3_V_FSD_D(float p0, struct S_D p1, double p2) { }
+EXPORT void f3_V_FSD_P(float p0, struct S_P p1, double p2) { }
+EXPORT void f3_V_FSD_II(float p0, struct S_II p1, double p2) { }
+EXPORT void f3_V_FSD_IF(float p0, struct S_IF p1, double p2) { }
+EXPORT void f3_V_FSD_ID(float p0, struct S_ID p1, double p2) { }
+EXPORT void f3_V_FSD_IP(float p0, struct S_IP p1, double p2) { }
+EXPORT void f3_V_FSD_FI(float p0, struct S_FI p1, double p2) { }
+EXPORT void f3_V_FSD_FF(float p0, struct S_FF p1, double p2) { }
+EXPORT void f3_V_FSD_FD(float p0, struct S_FD p1, double p2) { }
+EXPORT void f3_V_FSD_FP(float p0, struct S_FP p1, double p2) { }
+EXPORT void f3_V_FSD_DI(float p0, struct S_DI p1, double p2) { }
+EXPORT void f3_V_FSD_DF(float p0, struct S_DF p1, double p2) { }
+EXPORT void f3_V_FSD_DD(float p0, struct S_DD p1, double p2) { }
+EXPORT void f3_V_FSD_DP(float p0, struct S_DP p1, double p2) { }
+EXPORT void f3_V_FSD_PI(float p0, struct S_PI p1, double p2) { }
+EXPORT void f3_V_FSD_PF(float p0, struct S_PF p1, double p2) { }
+EXPORT void f3_V_FSD_PD(float p0, struct S_PD p1, double p2) { }
+EXPORT void f3_V_FSD_PP(float p0, struct S_PP p1, double p2) { }
+EXPORT void f3_V_FSD_III(float p0, struct S_III p1, double p2) { }
+EXPORT void f3_V_FSD_IIF(float p0, struct S_IIF p1, double p2) { }
+EXPORT void f3_V_FSD_IID(float p0, struct S_IID p1, double p2) { }
+EXPORT void f3_V_FSD_IIP(float p0, struct S_IIP p1, double p2) { }
+EXPORT void f3_V_FSD_IFI(float p0, struct S_IFI p1, double p2) { }
+EXPORT void f3_V_FSD_IFF(float p0, struct S_IFF p1, double p2) { }
+EXPORT void f3_V_FSD_IFD(float p0, struct S_IFD p1, double p2) { }
+EXPORT void f3_V_FSD_IFP(float p0, struct S_IFP p1, double p2) { }
+EXPORT void f3_V_FSD_IDI(float p0, struct S_IDI p1, double p2) { }
+EXPORT void f3_V_FSD_IDF(float p0, struct S_IDF p1, double p2) { }
+EXPORT void f3_V_FSD_IDD(float p0, struct S_IDD p1, double p2) { }
+EXPORT void f3_V_FSD_IDP(float p0, struct S_IDP p1, double p2) { }
+EXPORT void f3_V_FSD_IPI(float p0, struct S_IPI p1, double p2) { }
+EXPORT void f3_V_FSD_IPF(float p0, struct S_IPF p1, double p2) { }
+EXPORT void f3_V_FSD_IPD(float p0, struct S_IPD p1, double p2) { }
+EXPORT void f3_V_FSD_IPP(float p0, struct S_IPP p1, double p2) { }
+EXPORT void f3_V_FSD_FII(float p0, struct S_FII p1, double p2) { }
+EXPORT void f3_V_FSD_FIF(float p0, struct S_FIF p1, double p2) { }
+EXPORT void f3_V_FSD_FID(float p0, struct S_FID p1, double p2) { }
+EXPORT void f3_V_FSD_FIP(float p0, struct S_FIP p1, double p2) { }
+EXPORT void f3_V_FSD_FFI(float p0, struct S_FFI p1, double p2) { }
+EXPORT void f3_V_FSD_FFF(float p0, struct S_FFF p1, double p2) { }
+EXPORT void f3_V_FSD_FFD(float p0, struct S_FFD p1, double p2) { }
+EXPORT void f3_V_FSD_FFP(float p0, struct S_FFP p1, double p2) { }
+EXPORT void f3_V_FSD_FDI(float p0, struct S_FDI p1, double p2) { }
+EXPORT void f3_V_FSD_FDF(float p0, struct S_FDF p1, double p2) { }
+EXPORT void f3_V_FSD_FDD(float p0, struct S_FDD p1, double p2) { }
+EXPORT void f3_V_FSD_FDP(float p0, struct S_FDP p1, double p2) { }
+EXPORT void f3_V_FSD_FPI(float p0, struct S_FPI p1, double p2) { }
+EXPORT void f3_V_FSD_FPF(float p0, struct S_FPF p1, double p2) { }
+EXPORT void f3_V_FSD_FPD(float p0, struct S_FPD p1, double p2) { }
+EXPORT void f3_V_FSD_FPP(float p0, struct S_FPP p1, double p2) { }
+EXPORT void f3_V_FSD_DII(float p0, struct S_DII p1, double p2) { }
+EXPORT void f3_V_FSD_DIF(float p0, struct S_DIF p1, double p2) { }
+EXPORT void f3_V_FSD_DID(float p0, struct S_DID p1, double p2) { }
+EXPORT void f3_V_FSD_DIP(float p0, struct S_DIP p1, double p2) { }
+EXPORT void f3_V_FSD_DFI(float p0, struct S_DFI p1, double p2) { }
+EXPORT void f3_V_FSD_DFF(float p0, struct S_DFF p1, double p2) { }
+EXPORT void f3_V_FSD_DFD(float p0, struct S_DFD p1, double p2) { }
+EXPORT void f3_V_FSD_DFP(float p0, struct S_DFP p1, double p2) { }
+EXPORT void f3_V_FSD_DDI(float p0, struct S_DDI p1, double p2) { }
+EXPORT void f3_V_FSD_DDF(float p0, struct S_DDF p1, double p2) { }
+EXPORT void f3_V_FSD_DDD(float p0, struct S_DDD p1, double p2) { }
+EXPORT void f3_V_FSD_DDP(float p0, struct S_DDP p1, double p2) { }
+EXPORT void f3_V_FSD_DPI(float p0, struct S_DPI p1, double p2) { }
+EXPORT void f3_V_FSD_DPF(float p0, struct S_DPF p1, double p2) { }
+EXPORT void f3_V_FSD_DPD(float p0, struct S_DPD p1, double p2) { }
+EXPORT void f3_V_FSD_DPP(float p0, struct S_DPP p1, double p2) { }
+EXPORT void f3_V_FSD_PII(float p0, struct S_PII p1, double p2) { }
+EXPORT void f3_V_FSD_PIF(float p0, struct S_PIF p1, double p2) { }
+EXPORT void f3_V_FSD_PID(float p0, struct S_PID p1, double p2) { }
+EXPORT void f3_V_FSD_PIP(float p0, struct S_PIP p1, double p2) { }
+EXPORT void f3_V_FSD_PFI(float p0, struct S_PFI p1, double p2) { }
+EXPORT void f3_V_FSD_PFF(float p0, struct S_PFF p1, double p2) { }
+EXPORT void f3_V_FSD_PFD(float p0, struct S_PFD p1, double p2) { }
+EXPORT void f3_V_FSD_PFP(float p0, struct S_PFP p1, double p2) { }
+EXPORT void f3_V_FSD_PDI(float p0, struct S_PDI p1, double p2) { }
+EXPORT void f3_V_FSD_PDF(float p0, struct S_PDF p1, double p2) { }
+EXPORT void f3_V_FSD_PDD(float p0, struct S_PDD p1, double p2) { }
+EXPORT void f3_V_FSD_PDP(float p0, struct S_PDP p1, double p2) { }
+EXPORT void f3_V_FSD_PPI(float p0, struct S_PPI p1, double p2) { }
+EXPORT void f3_V_FSD_PPF(float p0, struct S_PPF p1, double p2) { }
+EXPORT void f3_V_FSD_PPD(float p0, struct S_PPD p1, double p2) { }
+EXPORT void f3_V_FSD_PPP(float p0, struct S_PPP p1, double p2) { }
+EXPORT void f3_V_FSP_I(float p0, struct S_I p1, void* p2) { }
+EXPORT void f3_V_FSP_F(float p0, struct S_F p1, void* p2) { }
+EXPORT void f3_V_FSP_D(float p0, struct S_D p1, void* p2) { }
+EXPORT void f3_V_FSP_P(float p0, struct S_P p1, void* p2) { }
+EXPORT void f3_V_FSP_II(float p0, struct S_II p1, void* p2) { }
+EXPORT void f3_V_FSP_IF(float p0, struct S_IF p1, void* p2) { }
+EXPORT void f3_V_FSP_ID(float p0, struct S_ID p1, void* p2) { }
+EXPORT void f3_V_FSP_IP(float p0, struct S_IP p1, void* p2) { }
+EXPORT void f3_V_FSP_FI(float p0, struct S_FI p1, void* p2) { }
+EXPORT void f3_V_FSP_FF(float p0, struct S_FF p1, void* p2) { }
+EXPORT void f3_V_FSP_FD(float p0, struct S_FD p1, void* p2) { }
+EXPORT void f3_V_FSP_FP(float p0, struct S_FP p1, void* p2) { }
+EXPORT void f3_V_FSP_DI(float p0, struct S_DI p1, void* p2) { }
+EXPORT void f3_V_FSP_DF(float p0, struct S_DF p1, void* p2) { }
+EXPORT void f3_V_FSP_DD(float p0, struct S_DD p1, void* p2) { }
+EXPORT void f3_V_FSP_DP(float p0, struct S_DP p1, void* p2) { }
+EXPORT void f3_V_FSP_PI(float p0, struct S_PI p1, void* p2) { }
+EXPORT void f3_V_FSP_PF(float p0, struct S_PF p1, void* p2) { }
+EXPORT void f3_V_FSP_PD(float p0, struct S_PD p1, void* p2) { }
+EXPORT void f3_V_FSP_PP(float p0, struct S_PP p1, void* p2) { }
+EXPORT void f3_V_FSP_III(float p0, struct S_III p1, void* p2) { }
+EXPORT void f3_V_FSP_IIF(float p0, struct S_IIF p1, void* p2) { }
+EXPORT void f3_V_FSP_IID(float p0, struct S_IID p1, void* p2) { }
+EXPORT void f3_V_FSP_IIP(float p0, struct S_IIP p1, void* p2) { }
+EXPORT void f3_V_FSP_IFI(float p0, struct S_IFI p1, void* p2) { }
+EXPORT void f3_V_FSP_IFF(float p0, struct S_IFF p1, void* p2) { }
+EXPORT void f3_V_FSP_IFD(float p0, struct S_IFD p1, void* p2) { }
+EXPORT void f3_V_FSP_IFP(float p0, struct S_IFP p1, void* p2) { }
+EXPORT void f3_V_FSP_IDI(float p0, struct S_IDI p1, void* p2) { }
+EXPORT void f3_V_FSP_IDF(float p0, struct S_IDF p1, void* p2) { }
+EXPORT void f3_V_FSP_IDD(float p0, struct S_IDD p1, void* p2) { }
+EXPORT void f3_V_FSP_IDP(float p0, struct S_IDP p1, void* p2) { }
+EXPORT void f3_V_FSP_IPI(float p0, struct S_IPI p1, void* p2) { }
+EXPORT void f3_V_FSP_IPF(float p0, struct S_IPF p1, void* p2) { }
+EXPORT void f3_V_FSP_IPD(float p0, struct S_IPD p1, void* p2) { }
+EXPORT void f3_V_FSP_IPP(float p0, struct S_IPP p1, void* p2) { }
+EXPORT void f3_V_FSP_FII(float p0, struct S_FII p1, void* p2) { }
+EXPORT void f3_V_FSP_FIF(float p0, struct S_FIF p1, void* p2) { }
+EXPORT void f3_V_FSP_FID(float p0, struct S_FID p1, void* p2) { }
+EXPORT void f3_V_FSP_FIP(float p0, struct S_FIP p1, void* p2) { }
+EXPORT void f3_V_FSP_FFI(float p0, struct S_FFI p1, void* p2) { }
+EXPORT void f3_V_FSP_FFF(float p0, struct S_FFF p1, void* p2) { }
+EXPORT void f3_V_FSP_FFD(float p0, struct S_FFD p1, void* p2) { }
+EXPORT void f3_V_FSP_FFP(float p0, struct S_FFP p1, void* p2) { }
+EXPORT void f3_V_FSP_FDI(float p0, struct S_FDI p1, void* p2) { }
+EXPORT void f3_V_FSP_FDF(float p0, struct S_FDF p1, void* p2) { }
+EXPORT void f3_V_FSP_FDD(float p0, struct S_FDD p1, void* p2) { }
+EXPORT void f3_V_FSP_FDP(float p0, struct S_FDP p1, void* p2) { }
+EXPORT void f3_V_FSP_FPI(float p0, struct S_FPI p1, void* p2) { }
+EXPORT void f3_V_FSP_FPF(float p0, struct S_FPF p1, void* p2) { }
+EXPORT void f3_V_FSP_FPD(float p0, struct S_FPD p1, void* p2) { }
+EXPORT void f3_V_FSP_FPP(float p0, struct S_FPP p1, void* p2) { }
+EXPORT void f3_V_FSP_DII(float p0, struct S_DII p1, void* p2) { }
+EXPORT void f3_V_FSP_DIF(float p0, struct S_DIF p1, void* p2) { }
+EXPORT void f3_V_FSP_DID(float p0, struct S_DID p1, void* p2) { }
+EXPORT void f3_V_FSP_DIP(float p0, struct S_DIP p1, void* p2) { }
+EXPORT void f3_V_FSP_DFI(float p0, struct S_DFI p1, void* p2) { }
+EXPORT void f3_V_FSP_DFF(float p0, struct S_DFF p1, void* p2) { }
+EXPORT void f3_V_FSP_DFD(float p0, struct S_DFD p1, void* p2) { }
+EXPORT void f3_V_FSP_DFP(float p0, struct S_DFP p1, void* p2) { }
+EXPORT void f3_V_FSP_DDI(float p0, struct S_DDI p1, void* p2) { }
+EXPORT void f3_V_FSP_DDF(float p0, struct S_DDF p1, void* p2) { }
+EXPORT void f3_V_FSP_DDD(float p0, struct S_DDD p1, void* p2) { }
+EXPORT void f3_V_FSP_DDP(float p0, struct S_DDP p1, void* p2) { }
+EXPORT void f3_V_FSP_DPI(float p0, struct S_DPI p1, void* p2) { }
+EXPORT void f3_V_FSP_DPF(float p0, struct S_DPF p1, void* p2) { }
+EXPORT void f3_V_FSP_DPD(float p0, struct S_DPD p1, void* p2) { }
+EXPORT void f3_V_FSP_DPP(float p0, struct S_DPP p1, void* p2) { }
+EXPORT void f3_V_FSP_PII(float p0, struct S_PII p1, void* p2) { }
+EXPORT void f3_V_FSP_PIF(float p0, struct S_PIF p1, void* p2) { }
+EXPORT void f3_V_FSP_PID(float p0, struct S_PID p1, void* p2) { }
+EXPORT void f3_V_FSP_PIP(float p0, struct S_PIP p1, void* p2) { }
+EXPORT void f3_V_FSP_PFI(float p0, struct S_PFI p1, void* p2) { }
+EXPORT void f3_V_FSP_PFF(float p0, struct S_PFF p1, void* p2) { }
+EXPORT void f3_V_FSP_PFD(float p0, struct S_PFD p1, void* p2) { }
+EXPORT void f3_V_FSP_PFP(float p0, struct S_PFP p1, void* p2) { }
+EXPORT void f3_V_FSP_PDI(float p0, struct S_PDI p1, void* p2) { }
+EXPORT void f3_V_FSP_PDF(float p0, struct S_PDF p1, void* p2) { }
+EXPORT void f3_V_FSP_PDD(float p0, struct S_PDD p1, void* p2) { }
+EXPORT void f3_V_FSP_PDP(float p0, struct S_PDP p1, void* p2) { }
+EXPORT void f3_V_FSP_PPI(float p0, struct S_PPI p1, void* p2) { }
+EXPORT void f3_V_FSP_PPF(float p0, struct S_PPF p1, void* p2) { }
+EXPORT void f3_V_FSP_PPD(float p0, struct S_PPD p1, void* p2) { }
+EXPORT void f3_V_FSP_PPP(float p0, struct S_PPP p1, void* p2) { }
+EXPORT void f3_V_FSS_I(float p0, struct S_I p1, struct S_I p2) { }
+EXPORT void f3_V_FSS_F(float p0, struct S_F p1, struct S_F p2) { }
+EXPORT void f3_V_FSS_D(float p0, struct S_D p1, struct S_D p2) { }
+EXPORT void f3_V_FSS_P(float p0, struct S_P p1, struct S_P p2) { }
+EXPORT void f3_V_FSS_II(float p0, struct S_II p1, struct S_II p2) { }
+EXPORT void f3_V_FSS_IF(float p0, struct S_IF p1, struct S_IF p2) { }
+EXPORT void f3_V_FSS_ID(float p0, struct S_ID p1, struct S_ID p2) { }
+EXPORT void f3_V_FSS_IP(float p0, struct S_IP p1, struct S_IP p2) { }
+EXPORT void f3_V_FSS_FI(float p0, struct S_FI p1, struct S_FI p2) { }
+EXPORT void f3_V_FSS_FF(float p0, struct S_FF p1, struct S_FF p2) { }
+EXPORT void f3_V_FSS_FD(float p0, struct S_FD p1, struct S_FD p2) { }
+EXPORT void f3_V_FSS_FP(float p0, struct S_FP p1, struct S_FP p2) { }
+EXPORT void f3_V_FSS_DI(float p0, struct S_DI p1, struct S_DI p2) { }
+EXPORT void f3_V_FSS_DF(float p0, struct S_DF p1, struct S_DF p2) { }
+EXPORT void f3_V_FSS_DD(float p0, struct S_DD p1, struct S_DD p2) { }
+EXPORT void f3_V_FSS_DP(float p0, struct S_DP p1, struct S_DP p2) { }
+EXPORT void f3_V_FSS_PI(float p0, struct S_PI p1, struct S_PI p2) { }
+EXPORT void f3_V_FSS_PF(float p0, struct S_PF p1, struct S_PF p2) { }
+EXPORT void f3_V_FSS_PD(float p0, struct S_PD p1, struct S_PD p2) { }
+EXPORT void f3_V_FSS_PP(float p0, struct S_PP p1, struct S_PP p2) { }
+EXPORT void f3_V_FSS_III(float p0, struct S_III p1, struct S_III p2) { }
+EXPORT void f3_V_FSS_IIF(float p0, struct S_IIF p1, struct S_IIF p2) { }
+EXPORT void f3_V_FSS_IID(float p0, struct S_IID p1, struct S_IID p2) { }
+EXPORT void f3_V_FSS_IIP(float p0, struct S_IIP p1, struct S_IIP p2) { }
+EXPORT void f3_V_FSS_IFI(float p0, struct S_IFI p1, struct S_IFI p2) { }
+EXPORT void f3_V_FSS_IFF(float p0, struct S_IFF p1, struct S_IFF p2) { }
+EXPORT void f3_V_FSS_IFD(float p0, struct S_IFD p1, struct S_IFD p2) { }
+EXPORT void f3_V_FSS_IFP(float p0, struct S_IFP p1, struct S_IFP p2) { }
+EXPORT void f3_V_FSS_IDI(float p0, struct S_IDI p1, struct S_IDI p2) { }
+EXPORT void f3_V_FSS_IDF(float p0, struct S_IDF p1, struct S_IDF p2) { }
+EXPORT void f3_V_FSS_IDD(float p0, struct S_IDD p1, struct S_IDD p2) { }
+EXPORT void f3_V_FSS_IDP(float p0, struct S_IDP p1, struct S_IDP p2) { }
+EXPORT void f3_V_FSS_IPI(float p0, struct S_IPI p1, struct S_IPI p2) { }
+EXPORT void f3_V_FSS_IPF(float p0, struct S_IPF p1, struct S_IPF p2) { }
+EXPORT void f3_V_FSS_IPD(float p0, struct S_IPD p1, struct S_IPD p2) { }
+EXPORT void f3_V_FSS_IPP(float p0, struct S_IPP p1, struct S_IPP p2) { }
+EXPORT void f3_V_FSS_FII(float p0, struct S_FII p1, struct S_FII p2) { }
+EXPORT void f3_V_FSS_FIF(float p0, struct S_FIF p1, struct S_FIF p2) { }
+EXPORT void f3_V_FSS_FID(float p0, struct S_FID p1, struct S_FID p2) { }
+EXPORT void f3_V_FSS_FIP(float p0, struct S_FIP p1, struct S_FIP p2) { }
+EXPORT void f3_V_FSS_FFI(float p0, struct S_FFI p1, struct S_FFI p2) { }
+EXPORT void f3_V_FSS_FFF(float p0, struct S_FFF p1, struct S_FFF p2) { }
+EXPORT void f3_V_FSS_FFD(float p0, struct S_FFD p1, struct S_FFD p2) { }
+EXPORT void f3_V_FSS_FFP(float p0, struct S_FFP p1, struct S_FFP p2) { }
+EXPORT void f3_V_FSS_FDI(float p0, struct S_FDI p1, struct S_FDI p2) { }
+EXPORT void f3_V_FSS_FDF(float p0, struct S_FDF p1, struct S_FDF p2) { }
+EXPORT void f3_V_FSS_FDD(float p0, struct S_FDD p1, struct S_FDD p2) { }
+EXPORT void f3_V_FSS_FDP(float p0, struct S_FDP p1, struct S_FDP p2) { }
+EXPORT void f3_V_FSS_FPI(float p0, struct S_FPI p1, struct S_FPI p2) { }
+EXPORT void f3_V_FSS_FPF(float p0, struct S_FPF p1, struct S_FPF p2) { }
+EXPORT void f3_V_FSS_FPD(float p0, struct S_FPD p1, struct S_FPD p2) { }
+EXPORT void f3_V_FSS_FPP(float p0, struct S_FPP p1, struct S_FPP p2) { }
+EXPORT void f3_V_FSS_DII(float p0, struct S_DII p1, struct S_DII p2) { }
+EXPORT void f3_V_FSS_DIF(float p0, struct S_DIF p1, struct S_DIF p2) { }
+EXPORT void f3_V_FSS_DID(float p0, struct S_DID p1, struct S_DID p2) { }
+EXPORT void f3_V_FSS_DIP(float p0, struct S_DIP p1, struct S_DIP p2) { }
+EXPORT void f3_V_FSS_DFI(float p0, struct S_DFI p1, struct S_DFI p2) { }
+EXPORT void f3_V_FSS_DFF(float p0, struct S_DFF p1, struct S_DFF p2) { }
+EXPORT void f3_V_FSS_DFD(float p0, struct S_DFD p1, struct S_DFD p2) { }
+EXPORT void f3_V_FSS_DFP(float p0, struct S_DFP p1, struct S_DFP p2) { }
+EXPORT void f3_V_FSS_DDI(float p0, struct S_DDI p1, struct S_DDI p2) { }
+EXPORT void f3_V_FSS_DDF(float p0, struct S_DDF p1, struct S_DDF p2) { }
+EXPORT void f3_V_FSS_DDD(float p0, struct S_DDD p1, struct S_DDD p2) { }
+EXPORT void f3_V_FSS_DDP(float p0, struct S_DDP p1, struct S_DDP p2) { }
+EXPORT void f3_V_FSS_DPI(float p0, struct S_DPI p1, struct S_DPI p2) { }
+EXPORT void f3_V_FSS_DPF(float p0, struct S_DPF p1, struct S_DPF p2) { }
+EXPORT void f3_V_FSS_DPD(float p0, struct S_DPD p1, struct S_DPD p2) { }
+EXPORT void f3_V_FSS_DPP(float p0, struct S_DPP p1, struct S_DPP p2) { }
+EXPORT void f3_V_FSS_PII(float p0, struct S_PII p1, struct S_PII p2) { }
+EXPORT void f3_V_FSS_PIF(float p0, struct S_PIF p1, struct S_PIF p2) { }
+EXPORT void f3_V_FSS_PID(float p0, struct S_PID p1, struct S_PID p2) { }
+EXPORT void f3_V_FSS_PIP(float p0, struct S_PIP p1, struct S_PIP p2) { }
+EXPORT void f3_V_FSS_PFI(float p0, struct S_PFI p1, struct S_PFI p2) { }
+EXPORT void f3_V_FSS_PFF(float p0, struct S_PFF p1, struct S_PFF p2) { }
+EXPORT void f3_V_FSS_PFD(float p0, struct S_PFD p1, struct S_PFD p2) { }
+EXPORT void f3_V_FSS_PFP(float p0, struct S_PFP p1, struct S_PFP p2) { }
+EXPORT void f3_V_FSS_PDI(float p0, struct S_PDI p1, struct S_PDI p2) { }
+EXPORT void f3_V_FSS_PDF(float p0, struct S_PDF p1, struct S_PDF p2) { }
+EXPORT void f3_V_FSS_PDD(float p0, struct S_PDD p1, struct S_PDD p2) { }
+EXPORT void f4_V_FSS_PDP(float p0, struct S_PDP p1, struct S_PDP p2) { }
+EXPORT void f4_V_FSS_PPI(float p0, struct S_PPI p1, struct S_PPI p2) { }
+EXPORT void f4_V_FSS_PPF(float p0, struct S_PPF p1, struct S_PPF p2) { }
+EXPORT void f4_V_FSS_PPD(float p0, struct S_PPD p1, struct S_PPD p2) { }
+EXPORT void f4_V_FSS_PPP(float p0, struct S_PPP p1, struct S_PPP p2) { }
+EXPORT void f4_V_DII_(double p0, int p1, int p2) { }
+EXPORT void f4_V_DIF_(double p0, int p1, float p2) { }
+EXPORT void f4_V_DID_(double p0, int p1, double p2) { }
+EXPORT void f4_V_DIP_(double p0, int p1, void* p2) { }
+EXPORT void f4_V_DIS_I(double p0, int p1, struct S_I p2) { }
+EXPORT void f4_V_DIS_F(double p0, int p1, struct S_F p2) { }
+EXPORT void f4_V_DIS_D(double p0, int p1, struct S_D p2) { }
+EXPORT void f4_V_DIS_P(double p0, int p1, struct S_P p2) { }
+EXPORT void f4_V_DIS_II(double p0, int p1, struct S_II p2) { }
+EXPORT void f4_V_DIS_IF(double p0, int p1, struct S_IF p2) { }
+EXPORT void f4_V_DIS_ID(double p0, int p1, struct S_ID p2) { }
+EXPORT void f4_V_DIS_IP(double p0, int p1, struct S_IP p2) { }
+EXPORT void f4_V_DIS_FI(double p0, int p1, struct S_FI p2) { }
+EXPORT void f4_V_DIS_FF(double p0, int p1, struct S_FF p2) { }
+EXPORT void f4_V_DIS_FD(double p0, int p1, struct S_FD p2) { }
+EXPORT void f4_V_DIS_FP(double p0, int p1, struct S_FP p2) { }
+EXPORT void f4_V_DIS_DI(double p0, int p1, struct S_DI p2) { }
+EXPORT void f4_V_DIS_DF(double p0, int p1, struct S_DF p2) { }
+EXPORT void f4_V_DIS_DD(double p0, int p1, struct S_DD p2) { }
+EXPORT void f4_V_DIS_DP(double p0, int p1, struct S_DP p2) { }
+EXPORT void f4_V_DIS_PI(double p0, int p1, struct S_PI p2) { }
+EXPORT void f4_V_DIS_PF(double p0, int p1, struct S_PF p2) { }
+EXPORT void f4_V_DIS_PD(double p0, int p1, struct S_PD p2) { }
+EXPORT void f4_V_DIS_PP(double p0, int p1, struct S_PP p2) { }
+EXPORT void f4_V_DIS_III(double p0, int p1, struct S_III p2) { }
+EXPORT void f4_V_DIS_IIF(double p0, int p1, struct S_IIF p2) { }
+EXPORT void f4_V_DIS_IID(double p0, int p1, struct S_IID p2) { }
+EXPORT void f4_V_DIS_IIP(double p0, int p1, struct S_IIP p2) { }
+EXPORT void f4_V_DIS_IFI(double p0, int p1, struct S_IFI p2) { }
+EXPORT void f4_V_DIS_IFF(double p0, int p1, struct S_IFF p2) { }
+EXPORT void f4_V_DIS_IFD(double p0, int p1, struct S_IFD p2) { }
+EXPORT void f4_V_DIS_IFP(double p0, int p1, struct S_IFP p2) { }
+EXPORT void f4_V_DIS_IDI(double p0, int p1, struct S_IDI p2) { }
+EXPORT void f4_V_DIS_IDF(double p0, int p1, struct S_IDF p2) { }
+EXPORT void f4_V_DIS_IDD(double p0, int p1, struct S_IDD p2) { }
+EXPORT void f4_V_DIS_IDP(double p0, int p1, struct S_IDP p2) { }
+EXPORT void f4_V_DIS_IPI(double p0, int p1, struct S_IPI p2) { }
+EXPORT void f4_V_DIS_IPF(double p0, int p1, struct S_IPF p2) { }
+EXPORT void f4_V_DIS_IPD(double p0, int p1, struct S_IPD p2) { }
+EXPORT void f4_V_DIS_IPP(double p0, int p1, struct S_IPP p2) { }
+EXPORT void f4_V_DIS_FII(double p0, int p1, struct S_FII p2) { }
+EXPORT void f4_V_DIS_FIF(double p0, int p1, struct S_FIF p2) { }
+EXPORT void f4_V_DIS_FID(double p0, int p1, struct S_FID p2) { }
+EXPORT void f4_V_DIS_FIP(double p0, int p1, struct S_FIP p2) { }
+EXPORT void f4_V_DIS_FFI(double p0, int p1, struct S_FFI p2) { }
+EXPORT void f4_V_DIS_FFF(double p0, int p1, struct S_FFF p2) { }
+EXPORT void f4_V_DIS_FFD(double p0, int p1, struct S_FFD p2) { }
+EXPORT void f4_V_DIS_FFP(double p0, int p1, struct S_FFP p2) { }
+EXPORT void f4_V_DIS_FDI(double p0, int p1, struct S_FDI p2) { }
+EXPORT void f4_V_DIS_FDF(double p0, int p1, struct S_FDF p2) { }
+EXPORT void f4_V_DIS_FDD(double p0, int p1, struct S_FDD p2) { }
+EXPORT void f4_V_DIS_FDP(double p0, int p1, struct S_FDP p2) { }
+EXPORT void f4_V_DIS_FPI(double p0, int p1, struct S_FPI p2) { }
+EXPORT void f4_V_DIS_FPF(double p0, int p1, struct S_FPF p2) { }
+EXPORT void f4_V_DIS_FPD(double p0, int p1, struct S_FPD p2) { }
+EXPORT void f4_V_DIS_FPP(double p0, int p1, struct S_FPP p2) { }
+EXPORT void f4_V_DIS_DII(double p0, int p1, struct S_DII p2) { }
+EXPORT void f4_V_DIS_DIF(double p0, int p1, struct S_DIF p2) { }
+EXPORT void f4_V_DIS_DID(double p0, int p1, struct S_DID p2) { }
+EXPORT void f4_V_DIS_DIP(double p0, int p1, struct S_DIP p2) { }
+EXPORT void f4_V_DIS_DFI(double p0, int p1, struct S_DFI p2) { }
+EXPORT void f4_V_DIS_DFF(double p0, int p1, struct S_DFF p2) { }
+EXPORT void f4_V_DIS_DFD(double p0, int p1, struct S_DFD p2) { }
+EXPORT void f4_V_DIS_DFP(double p0, int p1, struct S_DFP p2) { }
+EXPORT void f4_V_DIS_DDI(double p0, int p1, struct S_DDI p2) { }
+EXPORT void f4_V_DIS_DDF(double p0, int p1, struct S_DDF p2) { }
+EXPORT void f4_V_DIS_DDD(double p0, int p1, struct S_DDD p2) { }
+EXPORT void f4_V_DIS_DDP(double p0, int p1, struct S_DDP p2) { }
+EXPORT void f4_V_DIS_DPI(double p0, int p1, struct S_DPI p2) { }
+EXPORT void f4_V_DIS_DPF(double p0, int p1, struct S_DPF p2) { }
+EXPORT void f4_V_DIS_DPD(double p0, int p1, struct S_DPD p2) { }
+EXPORT void f4_V_DIS_DPP(double p0, int p1, struct S_DPP p2) { }
+EXPORT void f4_V_DIS_PII(double p0, int p1, struct S_PII p2) { }
+EXPORT void f4_V_DIS_PIF(double p0, int p1, struct S_PIF p2) { }
+EXPORT void f4_V_DIS_PID(double p0, int p1, struct S_PID p2) { }
+EXPORT void f4_V_DIS_PIP(double p0, int p1, struct S_PIP p2) { }
+EXPORT void f4_V_DIS_PFI(double p0, int p1, struct S_PFI p2) { }
+EXPORT void f4_V_DIS_PFF(double p0, int p1, struct S_PFF p2) { }
+EXPORT void f4_V_DIS_PFD(double p0, int p1, struct S_PFD p2) { }
+EXPORT void f4_V_DIS_PFP(double p0, int p1, struct S_PFP p2) { }
+EXPORT void f4_V_DIS_PDI(double p0, int p1, struct S_PDI p2) { }
+EXPORT void f4_V_DIS_PDF(double p0, int p1, struct S_PDF p2) { }
+EXPORT void f4_V_DIS_PDD(double p0, int p1, struct S_PDD p2) { }
+EXPORT void f4_V_DIS_PDP(double p0, int p1, struct S_PDP p2) { }
+EXPORT void f4_V_DIS_PPI(double p0, int p1, struct S_PPI p2) { }
+EXPORT void f4_V_DIS_PPF(double p0, int p1, struct S_PPF p2) { }
+EXPORT void f4_V_DIS_PPD(double p0, int p1, struct S_PPD p2) { }
+EXPORT void f4_V_DIS_PPP(double p0, int p1, struct S_PPP p2) { }
+EXPORT void f4_V_DFI_(double p0, float p1, int p2) { }
+EXPORT void f4_V_DFF_(double p0, float p1, float p2) { }
+EXPORT void f4_V_DFD_(double p0, float p1, double p2) { }
+EXPORT void f4_V_DFP_(double p0, float p1, void* p2) { }
+EXPORT void f4_V_DFS_I(double p0, float p1, struct S_I p2) { }
+EXPORT void f4_V_DFS_F(double p0, float p1, struct S_F p2) { }
+EXPORT void f4_V_DFS_D(double p0, float p1, struct S_D p2) { }
+EXPORT void f4_V_DFS_P(double p0, float p1, struct S_P p2) { }
+EXPORT void f4_V_DFS_II(double p0, float p1, struct S_II p2) { }
+EXPORT void f4_V_DFS_IF(double p0, float p1, struct S_IF p2) { }
+EXPORT void f4_V_DFS_ID(double p0, float p1, struct S_ID p2) { }
+EXPORT void f4_V_DFS_IP(double p0, float p1, struct S_IP p2) { }
+EXPORT void f4_V_DFS_FI(double p0, float p1, struct S_FI p2) { }
+EXPORT void f4_V_DFS_FF(double p0, float p1, struct S_FF p2) { }
+EXPORT void f4_V_DFS_FD(double p0, float p1, struct S_FD p2) { }
+EXPORT void f4_V_DFS_FP(double p0, float p1, struct S_FP p2) { }
+EXPORT void f4_V_DFS_DI(double p0, float p1, struct S_DI p2) { }
+EXPORT void f4_V_DFS_DF(double p0, float p1, struct S_DF p2) { }
+EXPORT void f4_V_DFS_DD(double p0, float p1, struct S_DD p2) { }
+EXPORT void f4_V_DFS_DP(double p0, float p1, struct S_DP p2) { }
+EXPORT void f4_V_DFS_PI(double p0, float p1, struct S_PI p2) { }
+EXPORT void f4_V_DFS_PF(double p0, float p1, struct S_PF p2) { }
+EXPORT void f4_V_DFS_PD(double p0, float p1, struct S_PD p2) { }
+EXPORT void f4_V_DFS_PP(double p0, float p1, struct S_PP p2) { }
+EXPORT void f4_V_DFS_III(double p0, float p1, struct S_III p2) { }
+EXPORT void f4_V_DFS_IIF(double p0, float p1, struct S_IIF p2) { }
+EXPORT void f4_V_DFS_IID(double p0, float p1, struct S_IID p2) { }
+EXPORT void f4_V_DFS_IIP(double p0, float p1, struct S_IIP p2) { }
+EXPORT void f4_V_DFS_IFI(double p0, float p1, struct S_IFI p2) { }
+EXPORT void f4_V_DFS_IFF(double p0, float p1, struct S_IFF p2) { }
+EXPORT void f4_V_DFS_IFD(double p0, float p1, struct S_IFD p2) { }
+EXPORT void f4_V_DFS_IFP(double p0, float p1, struct S_IFP p2) { }
+EXPORT void f4_V_DFS_IDI(double p0, float p1, struct S_IDI p2) { }
+EXPORT void f4_V_DFS_IDF(double p0, float p1, struct S_IDF p2) { }
+EXPORT void f4_V_DFS_IDD(double p0, float p1, struct S_IDD p2) { }
+EXPORT void f4_V_DFS_IDP(double p0, float p1, struct S_IDP p2) { }
+EXPORT void f4_V_DFS_IPI(double p0, float p1, struct S_IPI p2) { }
+EXPORT void f4_V_DFS_IPF(double p0, float p1, struct S_IPF p2) { }
+EXPORT void f4_V_DFS_IPD(double p0, float p1, struct S_IPD p2) { }
+EXPORT void f4_V_DFS_IPP(double p0, float p1, struct S_IPP p2) { }
+EXPORT void f4_V_DFS_FII(double p0, float p1, struct S_FII p2) { }
+EXPORT void f4_V_DFS_FIF(double p0, float p1, struct S_FIF p2) { }
+EXPORT void f4_V_DFS_FID(double p0, float p1, struct S_FID p2) { }
+EXPORT void f4_V_DFS_FIP(double p0, float p1, struct S_FIP p2) { }
+EXPORT void f4_V_DFS_FFI(double p0, float p1, struct S_FFI p2) { }
+EXPORT void f4_V_DFS_FFF(double p0, float p1, struct S_FFF p2) { }
+EXPORT void f4_V_DFS_FFD(double p0, float p1, struct S_FFD p2) { }
+EXPORT void f4_V_DFS_FFP(double p0, float p1, struct S_FFP p2) { }
+EXPORT void f4_V_DFS_FDI(double p0, float p1, struct S_FDI p2) { }
+EXPORT void f4_V_DFS_FDF(double p0, float p1, struct S_FDF p2) { }
+EXPORT void f4_V_DFS_FDD(double p0, float p1, struct S_FDD p2) { }
+EXPORT void f4_V_DFS_FDP(double p0, float p1, struct S_FDP p2) { }
+EXPORT void f4_V_DFS_FPI(double p0, float p1, struct S_FPI p2) { }
+EXPORT void f4_V_DFS_FPF(double p0, float p1, struct S_FPF p2) { }
+EXPORT void f4_V_DFS_FPD(double p0, float p1, struct S_FPD p2) { }
+EXPORT void f4_V_DFS_FPP(double p0, float p1, struct S_FPP p2) { }
+EXPORT void f4_V_DFS_DII(double p0, float p1, struct S_DII p2) { }
+EXPORT void f4_V_DFS_DIF(double p0, float p1, struct S_DIF p2) { }
+EXPORT void f4_V_DFS_DID(double p0, float p1, struct S_DID p2) { }
+EXPORT void f4_V_DFS_DIP(double p0, float p1, struct S_DIP p2) { }
+EXPORT void f4_V_DFS_DFI(double p0, float p1, struct S_DFI p2) { }
+EXPORT void f4_V_DFS_DFF(double p0, float p1, struct S_DFF p2) { }
+EXPORT void f4_V_DFS_DFD(double p0, float p1, struct S_DFD p2) { }
+EXPORT void f4_V_DFS_DFP(double p0, float p1, struct S_DFP p2) { }
+EXPORT void f4_V_DFS_DDI(double p0, float p1, struct S_DDI p2) { }
+EXPORT void f4_V_DFS_DDF(double p0, float p1, struct S_DDF p2) { }
+EXPORT void f4_V_DFS_DDD(double p0, float p1, struct S_DDD p2) { }
+EXPORT void f4_V_DFS_DDP(double p0, float p1, struct S_DDP p2) { }
+EXPORT void f4_V_DFS_DPI(double p0, float p1, struct S_DPI p2) { }
+EXPORT void f4_V_DFS_DPF(double p0, float p1, struct S_DPF p2) { }
+EXPORT void f4_V_DFS_DPD(double p0, float p1, struct S_DPD p2) { }
+EXPORT void f4_V_DFS_DPP(double p0, float p1, struct S_DPP p2) { }
+EXPORT void f4_V_DFS_PII(double p0, float p1, struct S_PII p2) { }
+EXPORT void f4_V_DFS_PIF(double p0, float p1, struct S_PIF p2) { }
+EXPORT void f4_V_DFS_PID(double p0, float p1, struct S_PID p2) { }
+EXPORT void f4_V_DFS_PIP(double p0, float p1, struct S_PIP p2) { }
+EXPORT void f4_V_DFS_PFI(double p0, float p1, struct S_PFI p2) { }
+EXPORT void f4_V_DFS_PFF(double p0, float p1, struct S_PFF p2) { }
+EXPORT void f4_V_DFS_PFD(double p0, float p1, struct S_PFD p2) { }
+EXPORT void f4_V_DFS_PFP(double p0, float p1, struct S_PFP p2) { }
+EXPORT void f4_V_DFS_PDI(double p0, float p1, struct S_PDI p2) { }
+EXPORT void f4_V_DFS_PDF(double p0, float p1, struct S_PDF p2) { }
+EXPORT void f4_V_DFS_PDD(double p0, float p1, struct S_PDD p2) { }
+EXPORT void f4_V_DFS_PDP(double p0, float p1, struct S_PDP p2) { }
+EXPORT void f4_V_DFS_PPI(double p0, float p1, struct S_PPI p2) { }
+EXPORT void f4_V_DFS_PPF(double p0, float p1, struct S_PPF p2) { }
+EXPORT void f4_V_DFS_PPD(double p0, float p1, struct S_PPD p2) { }
+EXPORT void f4_V_DFS_PPP(double p0, float p1, struct S_PPP p2) { }
+EXPORT void f4_V_DDI_(double p0, double p1, int p2) { }
+EXPORT void f4_V_DDF_(double p0, double p1, float p2) { }
+EXPORT void f4_V_DDD_(double p0, double p1, double p2) { }
+EXPORT void f4_V_DDP_(double p0, double p1, void* p2) { }
+EXPORT void f4_V_DDS_I(double p0, double p1, struct S_I p2) { }
+EXPORT void f4_V_DDS_F(double p0, double p1, struct S_F p2) { }
+EXPORT void f4_V_DDS_D(double p0, double p1, struct S_D p2) { }
+EXPORT void f4_V_DDS_P(double p0, double p1, struct S_P p2) { }
+EXPORT void f4_V_DDS_II(double p0, double p1, struct S_II p2) { }
+EXPORT void f4_V_DDS_IF(double p0, double p1, struct S_IF p2) { }
+EXPORT void f4_V_DDS_ID(double p0, double p1, struct S_ID p2) { }
+EXPORT void f4_V_DDS_IP(double p0, double p1, struct S_IP p2) { }
+EXPORT void f4_V_DDS_FI(double p0, double p1, struct S_FI p2) { }
+EXPORT void f4_V_DDS_FF(double p0, double p1, struct S_FF p2) { }
+EXPORT void f4_V_DDS_FD(double p0, double p1, struct S_FD p2) { }
+EXPORT void f4_V_DDS_FP(double p0, double p1, struct S_FP p2) { }
+EXPORT void f4_V_DDS_DI(double p0, double p1, struct S_DI p2) { }
+EXPORT void f4_V_DDS_DF(double p0, double p1, struct S_DF p2) { }
+EXPORT void f4_V_DDS_DD(double p0, double p1, struct S_DD p2) { }
+EXPORT void f4_V_DDS_DP(double p0, double p1, struct S_DP p2) { }
+EXPORT void f4_V_DDS_PI(double p0, double p1, struct S_PI p2) { }
+EXPORT void f4_V_DDS_PF(double p0, double p1, struct S_PF p2) { }
+EXPORT void f4_V_DDS_PD(double p0, double p1, struct S_PD p2) { }
+EXPORT void f4_V_DDS_PP(double p0, double p1, struct S_PP p2) { }
+EXPORT void f4_V_DDS_III(double p0, double p1, struct S_III p2) { }
+EXPORT void f4_V_DDS_IIF(double p0, double p1, struct S_IIF p2) { }
+EXPORT void f4_V_DDS_IID(double p0, double p1, struct S_IID p2) { }
+EXPORT void f4_V_DDS_IIP(double p0, double p1, struct S_IIP p2) { }
+EXPORT void f4_V_DDS_IFI(double p0, double p1, struct S_IFI p2) { }
+EXPORT void f4_V_DDS_IFF(double p0, double p1, struct S_IFF p2) { }
+EXPORT void f4_V_DDS_IFD(double p0, double p1, struct S_IFD p2) { }
+EXPORT void f4_V_DDS_IFP(double p0, double p1, struct S_IFP p2) { }
+EXPORT void f4_V_DDS_IDI(double p0, double p1, struct S_IDI p2) { }
+EXPORT void f4_V_DDS_IDF(double p0, double p1, struct S_IDF p2) { }
+EXPORT void f4_V_DDS_IDD(double p0, double p1, struct S_IDD p2) { }
+EXPORT void f4_V_DDS_IDP(double p0, double p1, struct S_IDP p2) { }
+EXPORT void f4_V_DDS_IPI(double p0, double p1, struct S_IPI p2) { }
+EXPORT void f4_V_DDS_IPF(double p0, double p1, struct S_IPF p2) { }
+EXPORT void f4_V_DDS_IPD(double p0, double p1, struct S_IPD p2) { }
+EXPORT void f4_V_DDS_IPP(double p0, double p1, struct S_IPP p2) { }
+EXPORT void f4_V_DDS_FII(double p0, double p1, struct S_FII p2) { }
+EXPORT void f4_V_DDS_FIF(double p0, double p1, struct S_FIF p2) { }
+EXPORT void f4_V_DDS_FID(double p0, double p1, struct S_FID p2) { }
+EXPORT void f4_V_DDS_FIP(double p0, double p1, struct S_FIP p2) { }
+EXPORT void f4_V_DDS_FFI(double p0, double p1, struct S_FFI p2) { }
+EXPORT void f4_V_DDS_FFF(double p0, double p1, struct S_FFF p2) { }
+EXPORT void f4_V_DDS_FFD(double p0, double p1, struct S_FFD p2) { }
+EXPORT void f4_V_DDS_FFP(double p0, double p1, struct S_FFP p2) { }
+EXPORT void f4_V_DDS_FDI(double p0, double p1, struct S_FDI p2) { }
+EXPORT void f4_V_DDS_FDF(double p0, double p1, struct S_FDF p2) { }
+EXPORT void f4_V_DDS_FDD(double p0, double p1, struct S_FDD p2) { }
+EXPORT void f4_V_DDS_FDP(double p0, double p1, struct S_FDP p2) { }
+EXPORT void f4_V_DDS_FPI(double p0, double p1, struct S_FPI p2) { }
+EXPORT void f4_V_DDS_FPF(double p0, double p1, struct S_FPF p2) { }
+EXPORT void f4_V_DDS_FPD(double p0, double p1, struct S_FPD p2) { }
+EXPORT void f4_V_DDS_FPP(double p0, double p1, struct S_FPP p2) { }
+EXPORT void f4_V_DDS_DII(double p0, double p1, struct S_DII p2) { }
+EXPORT void f4_V_DDS_DIF(double p0, double p1, struct S_DIF p2) { }
+EXPORT void f4_V_DDS_DID(double p0, double p1, struct S_DID p2) { }
+EXPORT void f4_V_DDS_DIP(double p0, double p1, struct S_DIP p2) { }
+EXPORT void f4_V_DDS_DFI(double p0, double p1, struct S_DFI p2) { }
+EXPORT void f4_V_DDS_DFF(double p0, double p1, struct S_DFF p2) { }
+EXPORT void f4_V_DDS_DFD(double p0, double p1, struct S_DFD p2) { }
+EXPORT void f4_V_DDS_DFP(double p0, double p1, struct S_DFP p2) { }
+EXPORT void f4_V_DDS_DDI(double p0, double p1, struct S_DDI p2) { }
+EXPORT void f4_V_DDS_DDF(double p0, double p1, struct S_DDF p2) { }
+EXPORT void f4_V_DDS_DDD(double p0, double p1, struct S_DDD p2) { }
+EXPORT void f4_V_DDS_DDP(double p0, double p1, struct S_DDP p2) { }
+EXPORT void f4_V_DDS_DPI(double p0, double p1, struct S_DPI p2) { }
+EXPORT void f4_V_DDS_DPF(double p0, double p1, struct S_DPF p2) { }
+EXPORT void f4_V_DDS_DPD(double p0, double p1, struct S_DPD p2) { }
+EXPORT void f4_V_DDS_DPP(double p0, double p1, struct S_DPP p2) { }
+EXPORT void f4_V_DDS_PII(double p0, double p1, struct S_PII p2) { }
+EXPORT void f4_V_DDS_PIF(double p0, double p1, struct S_PIF p2) { }
+EXPORT void f4_V_DDS_PID(double p0, double p1, struct S_PID p2) { }
+EXPORT void f4_V_DDS_PIP(double p0, double p1, struct S_PIP p2) { }
+EXPORT void f4_V_DDS_PFI(double p0, double p1, struct S_PFI p2) { }
+EXPORT void f4_V_DDS_PFF(double p0, double p1, struct S_PFF p2) { }
+EXPORT void f4_V_DDS_PFD(double p0, double p1, struct S_PFD p2) { }
+EXPORT void f4_V_DDS_PFP(double p0, double p1, struct S_PFP p2) { }
+EXPORT void f4_V_DDS_PDI(double p0, double p1, struct S_PDI p2) { }
+EXPORT void f4_V_DDS_PDF(double p0, double p1, struct S_PDF p2) { }
+EXPORT void f4_V_DDS_PDD(double p0, double p1, struct S_PDD p2) { }
+EXPORT void f4_V_DDS_PDP(double p0, double p1, struct S_PDP p2) { }
+EXPORT void f4_V_DDS_PPI(double p0, double p1, struct S_PPI p2) { }
+EXPORT void f4_V_DDS_PPF(double p0, double p1, struct S_PPF p2) { }
+EXPORT void f4_V_DDS_PPD(double p0, double p1, struct S_PPD p2) { }
+EXPORT void f4_V_DDS_PPP(double p0, double p1, struct S_PPP p2) { }
+EXPORT void f4_V_DPI_(double p0, void* p1, int p2) { }
+EXPORT void f4_V_DPF_(double p0, void* p1, float p2) { }
+EXPORT void f4_V_DPD_(double p0, void* p1, double p2) { }
+EXPORT void f4_V_DPP_(double p0, void* p1, void* p2) { }
+EXPORT void f4_V_DPS_I(double p0, void* p1, struct S_I p2) { }
+EXPORT void f4_V_DPS_F(double p0, void* p1, struct S_F p2) { }
+EXPORT void f4_V_DPS_D(double p0, void* p1, struct S_D p2) { }
+EXPORT void f4_V_DPS_P(double p0, void* p1, struct S_P p2) { }
+EXPORT void f4_V_DPS_II(double p0, void* p1, struct S_II p2) { }
+EXPORT void f4_V_DPS_IF(double p0, void* p1, struct S_IF p2) { }
+EXPORT void f4_V_DPS_ID(double p0, void* p1, struct S_ID p2) { }
+EXPORT void f4_V_DPS_IP(double p0, void* p1, struct S_IP p2) { }
+EXPORT void f4_V_DPS_FI(double p0, void* p1, struct S_FI p2) { }
+EXPORT void f4_V_DPS_FF(double p0, void* p1, struct S_FF p2) { }
+EXPORT void f4_V_DPS_FD(double p0, void* p1, struct S_FD p2) { }
+EXPORT void f4_V_DPS_FP(double p0, void* p1, struct S_FP p2) { }
+EXPORT void f4_V_DPS_DI(double p0, void* p1, struct S_DI p2) { }
+EXPORT void f4_V_DPS_DF(double p0, void* p1, struct S_DF p2) { }
+EXPORT void f4_V_DPS_DD(double p0, void* p1, struct S_DD p2) { }
+EXPORT void f4_V_DPS_DP(double p0, void* p1, struct S_DP p2) { }
+EXPORT void f4_V_DPS_PI(double p0, void* p1, struct S_PI p2) { }
+EXPORT void f4_V_DPS_PF(double p0, void* p1, struct S_PF p2) { }
+EXPORT void f4_V_DPS_PD(double p0, void* p1, struct S_PD p2) { }
+EXPORT void f4_V_DPS_PP(double p0, void* p1, struct S_PP p2) { }
+EXPORT void f4_V_DPS_III(double p0, void* p1, struct S_III p2) { }
+EXPORT void f4_V_DPS_IIF(double p0, void* p1, struct S_IIF p2) { }
+EXPORT void f4_V_DPS_IID(double p0, void* p1, struct S_IID p2) { }
+EXPORT void f4_V_DPS_IIP(double p0, void* p1, struct S_IIP p2) { }
+EXPORT void f4_V_DPS_IFI(double p0, void* p1, struct S_IFI p2) { }
+EXPORT void f4_V_DPS_IFF(double p0, void* p1, struct S_IFF p2) { }
+EXPORT void f4_V_DPS_IFD(double p0, void* p1, struct S_IFD p2) { }
+EXPORT void f4_V_DPS_IFP(double p0, void* p1, struct S_IFP p2) { }
+EXPORT void f4_V_DPS_IDI(double p0, void* p1, struct S_IDI p2) { }
+EXPORT void f4_V_DPS_IDF(double p0, void* p1, struct S_IDF p2) { }
+EXPORT void f4_V_DPS_IDD(double p0, void* p1, struct S_IDD p2) { }
+EXPORT void f4_V_DPS_IDP(double p0, void* p1, struct S_IDP p2) { }
+EXPORT void f4_V_DPS_IPI(double p0, void* p1, struct S_IPI p2) { }
+EXPORT void f4_V_DPS_IPF(double p0, void* p1, struct S_IPF p2) { }
+EXPORT void f4_V_DPS_IPD(double p0, void* p1, struct S_IPD p2) { }
+EXPORT void f4_V_DPS_IPP(double p0, void* p1, struct S_IPP p2) { }
+EXPORT void f4_V_DPS_FII(double p0, void* p1, struct S_FII p2) { }
+EXPORT void f4_V_DPS_FIF(double p0, void* p1, struct S_FIF p2) { }
+EXPORT void f4_V_DPS_FID(double p0, void* p1, struct S_FID p2) { }
+EXPORT void f4_V_DPS_FIP(double p0, void* p1, struct S_FIP p2) { }
+EXPORT void f4_V_DPS_FFI(double p0, void* p1, struct S_FFI p2) { }
+EXPORT void f4_V_DPS_FFF(double p0, void* p1, struct S_FFF p2) { }
+EXPORT void f4_V_DPS_FFD(double p0, void* p1, struct S_FFD p2) { }
+EXPORT void f4_V_DPS_FFP(double p0, void* p1, struct S_FFP p2) { }
+EXPORT void f4_V_DPS_FDI(double p0, void* p1, struct S_FDI p2) { }
+EXPORT void f4_V_DPS_FDF(double p0, void* p1, struct S_FDF p2) { }
+EXPORT void f4_V_DPS_FDD(double p0, void* p1, struct S_FDD p2) { }
+EXPORT void f4_V_DPS_FDP(double p0, void* p1, struct S_FDP p2) { }
+EXPORT void f4_V_DPS_FPI(double p0, void* p1, struct S_FPI p2) { }
+EXPORT void f4_V_DPS_FPF(double p0, void* p1, struct S_FPF p2) { }
+EXPORT void f4_V_DPS_FPD(double p0, void* p1, struct S_FPD p2) { }
+EXPORT void f4_V_DPS_FPP(double p0, void* p1, struct S_FPP p2) { }
+EXPORT void f4_V_DPS_DII(double p0, void* p1, struct S_DII p2) { }
+EXPORT void f4_V_DPS_DIF(double p0, void* p1, struct S_DIF p2) { }
+EXPORT void f4_V_DPS_DID(double p0, void* p1, struct S_DID p2) { }
+EXPORT void f4_V_DPS_DIP(double p0, void* p1, struct S_DIP p2) { }
+EXPORT void f4_V_DPS_DFI(double p0, void* p1, struct S_DFI p2) { }
+EXPORT void f4_V_DPS_DFF(double p0, void* p1, struct S_DFF p2) { }
+EXPORT void f4_V_DPS_DFD(double p0, void* p1, struct S_DFD p2) { }
+EXPORT void f4_V_DPS_DFP(double p0, void* p1, struct S_DFP p2) { }
+EXPORT void f4_V_DPS_DDI(double p0, void* p1, struct S_DDI p2) { }
+EXPORT void f4_V_DPS_DDF(double p0, void* p1, struct S_DDF p2) { }
+EXPORT void f4_V_DPS_DDD(double p0, void* p1, struct S_DDD p2) { }
+EXPORT void f4_V_DPS_DDP(double p0, void* p1, struct S_DDP p2) { }
+EXPORT void f4_V_DPS_DPI(double p0, void* p1, struct S_DPI p2) { }
+EXPORT void f4_V_DPS_DPF(double p0, void* p1, struct S_DPF p2) { }
+EXPORT void f4_V_DPS_DPD(double p0, void* p1, struct S_DPD p2) { }
+EXPORT void f4_V_DPS_DPP(double p0, void* p1, struct S_DPP p2) { }
+EXPORT void f4_V_DPS_PII(double p0, void* p1, struct S_PII p2) { }
+EXPORT void f4_V_DPS_PIF(double p0, void* p1, struct S_PIF p2) { }
+EXPORT void f4_V_DPS_PID(double p0, void* p1, struct S_PID p2) { }
+EXPORT void f4_V_DPS_PIP(double p0, void* p1, struct S_PIP p2) { }
+EXPORT void f4_V_DPS_PFI(double p0, void* p1, struct S_PFI p2) { }
+EXPORT void f4_V_DPS_PFF(double p0, void* p1, struct S_PFF p2) { }
+EXPORT void f4_V_DPS_PFD(double p0, void* p1, struct S_PFD p2) { }
+EXPORT void f4_V_DPS_PFP(double p0, void* p1, struct S_PFP p2) { }
+EXPORT void f4_V_DPS_PDI(double p0, void* p1, struct S_PDI p2) { }
+EXPORT void f4_V_DPS_PDF(double p0, void* p1, struct S_PDF p2) { }
+EXPORT void f4_V_DPS_PDD(double p0, void* p1, struct S_PDD p2) { }
+EXPORT void f4_V_DPS_PDP(double p0, void* p1, struct S_PDP p2) { }
+EXPORT void f4_V_DPS_PPI(double p0, void* p1, struct S_PPI p2) { }
+EXPORT void f4_V_DPS_PPF(double p0, void* p1, struct S_PPF p2) { }
+EXPORT void f4_V_DPS_PPD(double p0, void* p1, struct S_PPD p2) { }
+EXPORT void f4_V_DPS_PPP(double p0, void* p1, struct S_PPP p2) { }
+EXPORT void f4_V_DSI_I(double p0, struct S_I p1, int p2) { }
+EXPORT void f4_V_DSI_F(double p0, struct S_F p1, int p2) { }
+EXPORT void f4_V_DSI_D(double p0, struct S_D p1, int p2) { }
+EXPORT void f4_V_DSI_P(double p0, struct S_P p1, int p2) { }
+EXPORT void f4_V_DSI_II(double p0, struct S_II p1, int p2) { }
+EXPORT void f4_V_DSI_IF(double p0, struct S_IF p1, int p2) { }
+EXPORT void f4_V_DSI_ID(double p0, struct S_ID p1, int p2) { }
+EXPORT void f4_V_DSI_IP(double p0, struct S_IP p1, int p2) { }
+EXPORT void f4_V_DSI_FI(double p0, struct S_FI p1, int p2) { }
+EXPORT void f4_V_DSI_FF(double p0, struct S_FF p1, int p2) { }
+EXPORT void f4_V_DSI_FD(double p0, struct S_FD p1, int p2) { }
+EXPORT void f4_V_DSI_FP(double p0, struct S_FP p1, int p2) { }
+EXPORT void f4_V_DSI_DI(double p0, struct S_DI p1, int p2) { }
+EXPORT void f4_V_DSI_DF(double p0, struct S_DF p1, int p2) { }
+EXPORT void f4_V_DSI_DD(double p0, struct S_DD p1, int p2) { }
+EXPORT void f4_V_DSI_DP(double p0, struct S_DP p1, int p2) { }
+EXPORT void f4_V_DSI_PI(double p0, struct S_PI p1, int p2) { }
+EXPORT void f4_V_DSI_PF(double p0, struct S_PF p1, int p2) { }
+EXPORT void f4_V_DSI_PD(double p0, struct S_PD p1, int p2) { }
+EXPORT void f4_V_DSI_PP(double p0, struct S_PP p1, int p2) { }
+EXPORT void f4_V_DSI_III(double p0, struct S_III p1, int p2) { }
+EXPORT void f4_V_DSI_IIF(double p0, struct S_IIF p1, int p2) { }
+EXPORT void f4_V_DSI_IID(double p0, struct S_IID p1, int p2) { }
+EXPORT void f4_V_DSI_IIP(double p0, struct S_IIP p1, int p2) { }
+EXPORT void f4_V_DSI_IFI(double p0, struct S_IFI p1, int p2) { }
+EXPORT void f4_V_DSI_IFF(double p0, struct S_IFF p1, int p2) { }
+EXPORT void f4_V_DSI_IFD(double p0, struct S_IFD p1, int p2) { }
+EXPORT void f4_V_DSI_IFP(double p0, struct S_IFP p1, int p2) { }
+EXPORT void f4_V_DSI_IDI(double p0, struct S_IDI p1, int p2) { }
+EXPORT void f4_V_DSI_IDF(double p0, struct S_IDF p1, int p2) { }
+EXPORT void f4_V_DSI_IDD(double p0, struct S_IDD p1, int p2) { }
+EXPORT void f4_V_DSI_IDP(double p0, struct S_IDP p1, int p2) { }
+EXPORT void f4_V_DSI_IPI(double p0, struct S_IPI p1, int p2) { }
+EXPORT void f4_V_DSI_IPF(double p0, struct S_IPF p1, int p2) { }
+EXPORT void f4_V_DSI_IPD(double p0, struct S_IPD p1, int p2) { }
+EXPORT void f4_V_DSI_IPP(double p0, struct S_IPP p1, int p2) { }
+EXPORT void f4_V_DSI_FII(double p0, struct S_FII p1, int p2) { }
+EXPORT void f4_V_DSI_FIF(double p0, struct S_FIF p1, int p2) { }
+EXPORT void f4_V_DSI_FID(double p0, struct S_FID p1, int p2) { }
+EXPORT void f4_V_DSI_FIP(double p0, struct S_FIP p1, int p2) { }
+EXPORT void f4_V_DSI_FFI(double p0, struct S_FFI p1, int p2) { }
+EXPORT void f4_V_DSI_FFF(double p0, struct S_FFF p1, int p2) { }
+EXPORT void f4_V_DSI_FFD(double p0, struct S_FFD p1, int p2) { }
+EXPORT void f4_V_DSI_FFP(double p0, struct S_FFP p1, int p2) { }
+EXPORT void f4_V_DSI_FDI(double p0, struct S_FDI p1, int p2) { }
+EXPORT void f4_V_DSI_FDF(double p0, struct S_FDF p1, int p2) { }
+EXPORT void f4_V_DSI_FDD(double p0, struct S_FDD p1, int p2) { }
+EXPORT void f4_V_DSI_FDP(double p0, struct S_FDP p1, int p2) { }
+EXPORT void f4_V_DSI_FPI(double p0, struct S_FPI p1, int p2) { }
+EXPORT void f4_V_DSI_FPF(double p0, struct S_FPF p1, int p2) { }
+EXPORT void f4_V_DSI_FPD(double p0, struct S_FPD p1, int p2) { }
+EXPORT void f4_V_DSI_FPP(double p0, struct S_FPP p1, int p2) { }
+EXPORT void f4_V_DSI_DII(double p0, struct S_DII p1, int p2) { }
+EXPORT void f4_V_DSI_DIF(double p0, struct S_DIF p1, int p2) { }
+EXPORT void f4_V_DSI_DID(double p0, struct S_DID p1, int p2) { }
+EXPORT void f4_V_DSI_DIP(double p0, struct S_DIP p1, int p2) { }
+EXPORT void f4_V_DSI_DFI(double p0, struct S_DFI p1, int p2) { }
+EXPORT void f4_V_DSI_DFF(double p0, struct S_DFF p1, int p2) { }
+EXPORT void f4_V_DSI_DFD(double p0, struct S_DFD p1, int p2) { }
+EXPORT void f4_V_DSI_DFP(double p0, struct S_DFP p1, int p2) { }
+EXPORT void f4_V_DSI_DDI(double p0, struct S_DDI p1, int p2) { }
+EXPORT void f4_V_DSI_DDF(double p0, struct S_DDF p1, int p2) { }
+EXPORT void f4_V_DSI_DDD(double p0, struct S_DDD p1, int p2) { }
+EXPORT void f4_V_DSI_DDP(double p0, struct S_DDP p1, int p2) { }
+EXPORT void f4_V_DSI_DPI(double p0, struct S_DPI p1, int p2) { }
+EXPORT void f4_V_DSI_DPF(double p0, struct S_DPF p1, int p2) { }
+EXPORT void f4_V_DSI_DPD(double p0, struct S_DPD p1, int p2) { }
+EXPORT void f4_V_DSI_DPP(double p0, struct S_DPP p1, int p2) { }
+EXPORT void f4_V_DSI_PII(double p0, struct S_PII p1, int p2) { }
+EXPORT void f4_V_DSI_PIF(double p0, struct S_PIF p1, int p2) { }
+EXPORT void f4_V_DSI_PID(double p0, struct S_PID p1, int p2) { }
+EXPORT void f4_V_DSI_PIP(double p0, struct S_PIP p1, int p2) { }
+EXPORT void f4_V_DSI_PFI(double p0, struct S_PFI p1, int p2) { }
+EXPORT void f4_V_DSI_PFF(double p0, struct S_PFF p1, int p2) { }
+EXPORT void f4_V_DSI_PFD(double p0, struct S_PFD p1, int p2) { }
+EXPORT void f4_V_DSI_PFP(double p0, struct S_PFP p1, int p2) { }
+EXPORT void f4_V_DSI_PDI(double p0, struct S_PDI p1, int p2) { }
+EXPORT void f4_V_DSI_PDF(double p0, struct S_PDF p1, int p2) { }
+EXPORT void f4_V_DSI_PDD(double p0, struct S_PDD p1, int p2) { }
+EXPORT void f4_V_DSI_PDP(double p0, struct S_PDP p1, int p2) { }
+EXPORT void f4_V_DSI_PPI(double p0, struct S_PPI p1, int p2) { }
+EXPORT void f4_V_DSI_PPF(double p0, struct S_PPF p1, int p2) { }
+EXPORT void f4_V_DSI_PPD(double p0, struct S_PPD p1, int p2) { }
+EXPORT void f4_V_DSI_PPP(double p0, struct S_PPP p1, int p2) { }
+EXPORT void f4_V_DSF_I(double p0, struct S_I p1, float p2) { }
+EXPORT void f4_V_DSF_F(double p0, struct S_F p1, float p2) { }
+EXPORT void f4_V_DSF_D(double p0, struct S_D p1, float p2) { }
+EXPORT void f4_V_DSF_P(double p0, struct S_P p1, float p2) { }
+EXPORT void f4_V_DSF_II(double p0, struct S_II p1, float p2) { }
+EXPORT void f4_V_DSF_IF(double p0, struct S_IF p1, float p2) { }
+EXPORT void f4_V_DSF_ID(double p0, struct S_ID p1, float p2) { }
+EXPORT void f4_V_DSF_IP(double p0, struct S_IP p1, float p2) { }
+EXPORT void f4_V_DSF_FI(double p0, struct S_FI p1, float p2) { }
+EXPORT void f4_V_DSF_FF(double p0, struct S_FF p1, float p2) { }
+EXPORT void f4_V_DSF_FD(double p0, struct S_FD p1, float p2) { }
+EXPORT void f4_V_DSF_FP(double p0, struct S_FP p1, float p2) { }
+EXPORT void f4_V_DSF_DI(double p0, struct S_DI p1, float p2) { }
+EXPORT void f4_V_DSF_DF(double p0, struct S_DF p1, float p2) { }
+EXPORT void f4_V_DSF_DD(double p0, struct S_DD p1, float p2) { }
+EXPORT void f4_V_DSF_DP(double p0, struct S_DP p1, float p2) { }
+EXPORT void f4_V_DSF_PI(double p0, struct S_PI p1, float p2) { }
+EXPORT void f4_V_DSF_PF(double p0, struct S_PF p1, float p2) { }
+EXPORT void f4_V_DSF_PD(double p0, struct S_PD p1, float p2) { }
+EXPORT void f4_V_DSF_PP(double p0, struct S_PP p1, float p2) { }
+EXPORT void f4_V_DSF_III(double p0, struct S_III p1, float p2) { }
+EXPORT void f4_V_DSF_IIF(double p0, struct S_IIF p1, float p2) { }
+EXPORT void f4_V_DSF_IID(double p0, struct S_IID p1, float p2) { }
+EXPORT void f4_V_DSF_IIP(double p0, struct S_IIP p1, float p2) { }
+EXPORT void f4_V_DSF_IFI(double p0, struct S_IFI p1, float p2) { }
+EXPORT void f4_V_DSF_IFF(double p0, struct S_IFF p1, float p2) { }
+EXPORT void f4_V_DSF_IFD(double p0, struct S_IFD p1, float p2) { }
+EXPORT void f4_V_DSF_IFP(double p0, struct S_IFP p1, float p2) { }
+EXPORT void f4_V_DSF_IDI(double p0, struct S_IDI p1, float p2) { }
+EXPORT void f4_V_DSF_IDF(double p0, struct S_IDF p1, float p2) { }
+EXPORT void f4_V_DSF_IDD(double p0, struct S_IDD p1, float p2) { }
+EXPORT void f4_V_DSF_IDP(double p0, struct S_IDP p1, float p2) { }
+EXPORT void f4_V_DSF_IPI(double p0, struct S_IPI p1, float p2) { }
+EXPORT void f4_V_DSF_IPF(double p0, struct S_IPF p1, float p2) { }
+EXPORT void f4_V_DSF_IPD(double p0, struct S_IPD p1, float p2) { }
+EXPORT void f4_V_DSF_IPP(double p0, struct S_IPP p1, float p2) { }
+EXPORT void f4_V_DSF_FII(double p0, struct S_FII p1, float p2) { }
+EXPORT void f4_V_DSF_FIF(double p0, struct S_FIF p1, float p2) { }
+EXPORT void f4_V_DSF_FID(double p0, struct S_FID p1, float p2) { }
+EXPORT void f4_V_DSF_FIP(double p0, struct S_FIP p1, float p2) { }
+EXPORT void f4_V_DSF_FFI(double p0, struct S_FFI p1, float p2) { }
+EXPORT void f4_V_DSF_FFF(double p0, struct S_FFF p1, float p2) { }
+EXPORT void f4_V_DSF_FFD(double p0, struct S_FFD p1, float p2) { }
+EXPORT void f4_V_DSF_FFP(double p0, struct S_FFP p1, float p2) { }
+EXPORT void f4_V_DSF_FDI(double p0, struct S_FDI p1, float p2) { }
+EXPORT void f4_V_DSF_FDF(double p0, struct S_FDF p1, float p2) { }
+EXPORT void f4_V_DSF_FDD(double p0, struct S_FDD p1, float p2) { }
+EXPORT void f4_V_DSF_FDP(double p0, struct S_FDP p1, float p2) { }
+EXPORT void f4_V_DSF_FPI(double p0, struct S_FPI p1, float p2) { }
+EXPORT void f4_V_DSF_FPF(double p0, struct S_FPF p1, float p2) { }
+EXPORT void f4_V_DSF_FPD(double p0, struct S_FPD p1, float p2) { }
+EXPORT void f4_V_DSF_FPP(double p0, struct S_FPP p1, float p2) { }
+EXPORT void f4_V_DSF_DII(double p0, struct S_DII p1, float p2) { }
+EXPORT void f4_V_DSF_DIF(double p0, struct S_DIF p1, float p2) { }
+EXPORT void f4_V_DSF_DID(double p0, struct S_DID p1, float p2) { }
+EXPORT void f4_V_DSF_DIP(double p0, struct S_DIP p1, float p2) { }
+EXPORT void f4_V_DSF_DFI(double p0, struct S_DFI p1, float p2) { }
+EXPORT void f4_V_DSF_DFF(double p0, struct S_DFF p1, float p2) { }
+EXPORT void f4_V_DSF_DFD(double p0, struct S_DFD p1, float p2) { }
+EXPORT void f4_V_DSF_DFP(double p0, struct S_DFP p1, float p2) { }
+EXPORT void f4_V_DSF_DDI(double p0, struct S_DDI p1, float p2) { }
+EXPORT void f4_V_DSF_DDF(double p0, struct S_DDF p1, float p2) { }
+EXPORT void f4_V_DSF_DDD(double p0, struct S_DDD p1, float p2) { }
+EXPORT void f4_V_DSF_DDP(double p0, struct S_DDP p1, float p2) { }
+EXPORT void f4_V_DSF_DPI(double p0, struct S_DPI p1, float p2) { }
+EXPORT void f4_V_DSF_DPF(double p0, struct S_DPF p1, float p2) { }
+EXPORT void f4_V_DSF_DPD(double p0, struct S_DPD p1, float p2) { }
+EXPORT void f4_V_DSF_DPP(double p0, struct S_DPP p1, float p2) { }
+EXPORT void f4_V_DSF_PII(double p0, struct S_PII p1, float p2) { }
+EXPORT void f4_V_DSF_PIF(double p0, struct S_PIF p1, float p2) { }
+EXPORT void f4_V_DSF_PID(double p0, struct S_PID p1, float p2) { }
+EXPORT void f4_V_DSF_PIP(double p0, struct S_PIP p1, float p2) { }
+EXPORT void f4_V_DSF_PFI(double p0, struct S_PFI p1, float p2) { }
+EXPORT void f4_V_DSF_PFF(double p0, struct S_PFF p1, float p2) { }
+EXPORT void f4_V_DSF_PFD(double p0, struct S_PFD p1, float p2) { }
+EXPORT void f4_V_DSF_PFP(double p0, struct S_PFP p1, float p2) { }
+EXPORT void f4_V_DSF_PDI(double p0, struct S_PDI p1, float p2) { }
+EXPORT void f4_V_DSF_PDF(double p0, struct S_PDF p1, float p2) { }
+EXPORT void f4_V_DSF_PDD(double p0, struct S_PDD p1, float p2) { }
+EXPORT void f4_V_DSF_PDP(double p0, struct S_PDP p1, float p2) { }
+EXPORT void f4_V_DSF_PPI(double p0, struct S_PPI p1, float p2) { }
+EXPORT void f4_V_DSF_PPF(double p0, struct S_PPF p1, float p2) { }
+EXPORT void f4_V_DSF_PPD(double p0, struct S_PPD p1, float p2) { }
+EXPORT void f4_V_DSF_PPP(double p0, struct S_PPP p1, float p2) { }
+EXPORT void f4_V_DSD_I(double p0, struct S_I p1, double p2) { }
+EXPORT void f4_V_DSD_F(double p0, struct S_F p1, double p2) { }
+EXPORT void f4_V_DSD_D(double p0, struct S_D p1, double p2) { }
+EXPORT void f4_V_DSD_P(double p0, struct S_P p1, double p2) { }
+EXPORT void f4_V_DSD_II(double p0, struct S_II p1, double p2) { }
+EXPORT void f4_V_DSD_IF(double p0, struct S_IF p1, double p2) { }
+EXPORT void f4_V_DSD_ID(double p0, struct S_ID p1, double p2) { }
+EXPORT void f4_V_DSD_IP(double p0, struct S_IP p1, double p2) { }
+EXPORT void f4_V_DSD_FI(double p0, struct S_FI p1, double p2) { }
+EXPORT void f4_V_DSD_FF(double p0, struct S_FF p1, double p2) { }
+EXPORT void f4_V_DSD_FD(double p0, struct S_FD p1, double p2) { }
+EXPORT void f4_V_DSD_FP(double p0, struct S_FP p1, double p2) { }
+EXPORT void f4_V_DSD_DI(double p0, struct S_DI p1, double p2) { }
+EXPORT void f4_V_DSD_DF(double p0, struct S_DF p1, double p2) { }
+EXPORT void f4_V_DSD_DD(double p0, struct S_DD p1, double p2) { }
+EXPORT void f4_V_DSD_DP(double p0, struct S_DP p1, double p2) { }
+EXPORT void f4_V_DSD_PI(double p0, struct S_PI p1, double p2) { }
+EXPORT void f4_V_DSD_PF(double p0, struct S_PF p1, double p2) { }
+EXPORT void f4_V_DSD_PD(double p0, struct S_PD p1, double p2) { }
+EXPORT void f4_V_DSD_PP(double p0, struct S_PP p1, double p2) { }
+EXPORT void f4_V_DSD_III(double p0, struct S_III p1, double p2) { }
+EXPORT void f4_V_DSD_IIF(double p0, struct S_IIF p1, double p2) { }
+EXPORT void f4_V_DSD_IID(double p0, struct S_IID p1, double p2) { }
+EXPORT void f4_V_DSD_IIP(double p0, struct S_IIP p1, double p2) { }
+EXPORT void f4_V_DSD_IFI(double p0, struct S_IFI p1, double p2) { }
+EXPORT void f4_V_DSD_IFF(double p0, struct S_IFF p1, double p2) { }
+EXPORT void f4_V_DSD_IFD(double p0, struct S_IFD p1, double p2) { }
+EXPORT void f4_V_DSD_IFP(double p0, struct S_IFP p1, double p2) { }
+EXPORT void f4_V_DSD_IDI(double p0, struct S_IDI p1, double p2) { }
+EXPORT void f4_V_DSD_IDF(double p0, struct S_IDF p1, double p2) { }
+EXPORT void f4_V_DSD_IDD(double p0, struct S_IDD p1, double p2) { }
+EXPORT void f4_V_DSD_IDP(double p0, struct S_IDP p1, double p2) { }
+EXPORT void f4_V_DSD_IPI(double p0, struct S_IPI p1, double p2) { }
+EXPORT void f4_V_DSD_IPF(double p0, struct S_IPF p1, double p2) { }
+EXPORT void f4_V_DSD_IPD(double p0, struct S_IPD p1, double p2) { }
+EXPORT void f4_V_DSD_IPP(double p0, struct S_IPP p1, double p2) { }
+EXPORT void f4_V_DSD_FII(double p0, struct S_FII p1, double p2) { }
+EXPORT void f4_V_DSD_FIF(double p0, struct S_FIF p1, double p2) { }
+EXPORT void f4_V_DSD_FID(double p0, struct S_FID p1, double p2) { }
+EXPORT void f4_V_DSD_FIP(double p0, struct S_FIP p1, double p2) { }
+EXPORT void f4_V_DSD_FFI(double p0, struct S_FFI p1, double p2) { }
+EXPORT void f4_V_DSD_FFF(double p0, struct S_FFF p1, double p2) { }
+EXPORT void f4_V_DSD_FFD(double p0, struct S_FFD p1, double p2) { }
+EXPORT void f4_V_DSD_FFP(double p0, struct S_FFP p1, double p2) { }
+EXPORT void f4_V_DSD_FDI(double p0, struct S_FDI p1, double p2) { }
+EXPORT void f4_V_DSD_FDF(double p0, struct S_FDF p1, double p2) { }
+EXPORT void f4_V_DSD_FDD(double p0, struct S_FDD p1, double p2) { }
+EXPORT void f4_V_DSD_FDP(double p0, struct S_FDP p1, double p2) { }
+EXPORT void f4_V_DSD_FPI(double p0, struct S_FPI p1, double p2) { }
+EXPORT void f4_V_DSD_FPF(double p0, struct S_FPF p1, double p2) { }
+EXPORT void f4_V_DSD_FPD(double p0, struct S_FPD p1, double p2) { }
+EXPORT void f4_V_DSD_FPP(double p0, struct S_FPP p1, double p2) { }
+EXPORT void f4_V_DSD_DII(double p0, struct S_DII p1, double p2) { }
+EXPORT void f4_V_DSD_DIF(double p0, struct S_DIF p1, double p2) { }
+EXPORT void f4_V_DSD_DID(double p0, struct S_DID p1, double p2) { }
+EXPORT void f4_V_DSD_DIP(double p0, struct S_DIP p1, double p2) { }
+EXPORT void f4_V_DSD_DFI(double p0, struct S_DFI p1, double p2) { }
+EXPORT void f4_V_DSD_DFF(double p0, struct S_DFF p1, double p2) { }
+EXPORT void f4_V_DSD_DFD(double p0, struct S_DFD p1, double p2) { }
+EXPORT void f4_V_DSD_DFP(double p0, struct S_DFP p1, double p2) { }
+EXPORT void f4_V_DSD_DDI(double p0, struct S_DDI p1, double p2) { }
+EXPORT void f4_V_DSD_DDF(double p0, struct S_DDF p1, double p2) { }
+EXPORT void f4_V_DSD_DDD(double p0, struct S_DDD p1, double p2) { }
+EXPORT void f4_V_DSD_DDP(double p0, struct S_DDP p1, double p2) { }
+EXPORT void f4_V_DSD_DPI(double p0, struct S_DPI p1, double p2) { }
+EXPORT void f4_V_DSD_DPF(double p0, struct S_DPF p1, double p2) { }
+EXPORT void f4_V_DSD_DPD(double p0, struct S_DPD p1, double p2) { }
+EXPORT void f4_V_DSD_DPP(double p0, struct S_DPP p1, double p2) { }
+EXPORT void f4_V_DSD_PII(double p0, struct S_PII p1, double p2) { }
+EXPORT void f4_V_DSD_PIF(double p0, struct S_PIF p1, double p2) { }
+EXPORT void f4_V_DSD_PID(double p0, struct S_PID p1, double p2) { }
+EXPORT void f4_V_DSD_PIP(double p0, struct S_PIP p1, double p2) { }
+EXPORT void f4_V_DSD_PFI(double p0, struct S_PFI p1, double p2) { }
+EXPORT void f4_V_DSD_PFF(double p0, struct S_PFF p1, double p2) { }
+EXPORT void f4_V_DSD_PFD(double p0, struct S_PFD p1, double p2) { }
+EXPORT void f5_V_DSD_PFP(double p0, struct S_PFP p1, double p2) { }
+EXPORT void f5_V_DSD_PDI(double p0, struct S_PDI p1, double p2) { }
+EXPORT void f5_V_DSD_PDF(double p0, struct S_PDF p1, double p2) { }
+EXPORT void f5_V_DSD_PDD(double p0, struct S_PDD p1, double p2) { }
+EXPORT void f5_V_DSD_PDP(double p0, struct S_PDP p1, double p2) { }
+EXPORT void f5_V_DSD_PPI(double p0, struct S_PPI p1, double p2) { }
+EXPORT void f5_V_DSD_PPF(double p0, struct S_PPF p1, double p2) { }
+EXPORT void f5_V_DSD_PPD(double p0, struct S_PPD p1, double p2) { }
+EXPORT void f5_V_DSD_PPP(double p0, struct S_PPP p1, double p2) { }
+EXPORT void f5_V_DSP_I(double p0, struct S_I p1, void* p2) { }
+EXPORT void f5_V_DSP_F(double p0, struct S_F p1, void* p2) { }
+EXPORT void f5_V_DSP_D(double p0, struct S_D p1, void* p2) { }
+EXPORT void f5_V_DSP_P(double p0, struct S_P p1, void* p2) { }
+EXPORT void f5_V_DSP_II(double p0, struct S_II p1, void* p2) { }
+EXPORT void f5_V_DSP_IF(double p0, struct S_IF p1, void* p2) { }
+EXPORT void f5_V_DSP_ID(double p0, struct S_ID p1, void* p2) { }
+EXPORT void f5_V_DSP_IP(double p0, struct S_IP p1, void* p2) { }
+EXPORT void f5_V_DSP_FI(double p0, struct S_FI p1, void* p2) { }
+EXPORT void f5_V_DSP_FF(double p0, struct S_FF p1, void* p2) { }
+EXPORT void f5_V_DSP_FD(double p0, struct S_FD p1, void* p2) { }
+EXPORT void f5_V_DSP_FP(double p0, struct S_FP p1, void* p2) { }
+EXPORT void f5_V_DSP_DI(double p0, struct S_DI p1, void* p2) { }
+EXPORT void f5_V_DSP_DF(double p0, struct S_DF p1, void* p2) { }
+EXPORT void f5_V_DSP_DD(double p0, struct S_DD p1, void* p2) { }
+EXPORT void f5_V_DSP_DP(double p0, struct S_DP p1, void* p2) { }
+EXPORT void f5_V_DSP_PI(double p0, struct S_PI p1, void* p2) { }
+EXPORT void f5_V_DSP_PF(double p0, struct S_PF p1, void* p2) { }
+EXPORT void f5_V_DSP_PD(double p0, struct S_PD p1, void* p2) { }
+EXPORT void f5_V_DSP_PP(double p0, struct S_PP p1, void* p2) { }
+EXPORT void f5_V_DSP_III(double p0, struct S_III p1, void* p2) { }
+EXPORT void f5_V_DSP_IIF(double p0, struct S_IIF p1, void* p2) { }
+EXPORT void f5_V_DSP_IID(double p0, struct S_IID p1, void* p2) { }
+EXPORT void f5_V_DSP_IIP(double p0, struct S_IIP p1, void* p2) { }
+EXPORT void f5_V_DSP_IFI(double p0, struct S_IFI p1, void* p2) { }
+EXPORT void f5_V_DSP_IFF(double p0, struct S_IFF p1, void* p2) { }
+EXPORT void f5_V_DSP_IFD(double p0, struct S_IFD p1, void* p2) { }
+EXPORT void f5_V_DSP_IFP(double p0, struct S_IFP p1, void* p2) { }
+EXPORT void f5_V_DSP_IDI(double p0, struct S_IDI p1, void* p2) { }
+EXPORT void f5_V_DSP_IDF(double p0, struct S_IDF p1, void* p2) { }
+EXPORT void f5_V_DSP_IDD(double p0, struct S_IDD p1, void* p2) { }
+EXPORT void f5_V_DSP_IDP(double p0, struct S_IDP p1, void* p2) { }
+EXPORT void f5_V_DSP_IPI(double p0, struct S_IPI p1, void* p2) { }
+EXPORT void f5_V_DSP_IPF(double p0, struct S_IPF p1, void* p2) { }
+EXPORT void f5_V_DSP_IPD(double p0, struct S_IPD p1, void* p2) { }
+EXPORT void f5_V_DSP_IPP(double p0, struct S_IPP p1, void* p2) { }
+EXPORT void f5_V_DSP_FII(double p0, struct S_FII p1, void* p2) { }
+EXPORT void f5_V_DSP_FIF(double p0, struct S_FIF p1, void* p2) { }
+EXPORT void f5_V_DSP_FID(double p0, struct S_FID p1, void* p2) { }
+EXPORT void f5_V_DSP_FIP(double p0, struct S_FIP p1, void* p2) { }
+EXPORT void f5_V_DSP_FFI(double p0, struct S_FFI p1, void* p2) { }
+EXPORT void f5_V_DSP_FFF(double p0, struct S_FFF p1, void* p2) { }
+EXPORT void f5_V_DSP_FFD(double p0, struct S_FFD p1, void* p2) { }
+EXPORT void f5_V_DSP_FFP(double p0, struct S_FFP p1, void* p2) { }
+EXPORT void f5_V_DSP_FDI(double p0, struct S_FDI p1, void* p2) { }
+EXPORT void f5_V_DSP_FDF(double p0, struct S_FDF p1, void* p2) { }
+EXPORT void f5_V_DSP_FDD(double p0, struct S_FDD p1, void* p2) { }
+EXPORT void f5_V_DSP_FDP(double p0, struct S_FDP p1, void* p2) { }
+EXPORT void f5_V_DSP_FPI(double p0, struct S_FPI p1, void* p2) { }
+EXPORT void f5_V_DSP_FPF(double p0, struct S_FPF p1, void* p2) { }
+EXPORT void f5_V_DSP_FPD(double p0, struct S_FPD p1, void* p2) { }
+EXPORT void f5_V_DSP_FPP(double p0, struct S_FPP p1, void* p2) { }
+EXPORT void f5_V_DSP_DII(double p0, struct S_DII p1, void* p2) { }
+EXPORT void f5_V_DSP_DIF(double p0, struct S_DIF p1, void* p2) { }
+EXPORT void f5_V_DSP_DID(double p0, struct S_DID p1, void* p2) { }
+EXPORT void f5_V_DSP_DIP(double p0, struct S_DIP p1, void* p2) { }
+EXPORT void f5_V_DSP_DFI(double p0, struct S_DFI p1, void* p2) { }
+EXPORT void f5_V_DSP_DFF(double p0, struct S_DFF p1, void* p2) { }
+EXPORT void f5_V_DSP_DFD(double p0, struct S_DFD p1, void* p2) { }
+EXPORT void f5_V_DSP_DFP(double p0, struct S_DFP p1, void* p2) { }
+EXPORT void f5_V_DSP_DDI(double p0, struct S_DDI p1, void* p2) { }
+EXPORT void f5_V_DSP_DDF(double p0, struct S_DDF p1, void* p2) { }
+EXPORT void f5_V_DSP_DDD(double p0, struct S_DDD p1, void* p2) { }
+EXPORT void f5_V_DSP_DDP(double p0, struct S_DDP p1, void* p2) { }
+EXPORT void f5_V_DSP_DPI(double p0, struct S_DPI p1, void* p2) { }
+EXPORT void f5_V_DSP_DPF(double p0, struct S_DPF p1, void* p2) { }
+EXPORT void f5_V_DSP_DPD(double p0, struct S_DPD p1, void* p2) { }
+EXPORT void f5_V_DSP_DPP(double p0, struct S_DPP p1, void* p2) { }
+EXPORT void f5_V_DSP_PII(double p0, struct S_PII p1, void* p2) { }
+EXPORT void f5_V_DSP_PIF(double p0, struct S_PIF p1, void* p2) { }
+EXPORT void f5_V_DSP_PID(double p0, struct S_PID p1, void* p2) { }
+EXPORT void f5_V_DSP_PIP(double p0, struct S_PIP p1, void* p2) { }
+EXPORT void f5_V_DSP_PFI(double p0, struct S_PFI p1, void* p2) { }
+EXPORT void f5_V_DSP_PFF(double p0, struct S_PFF p1, void* p2) { }
+EXPORT void f5_V_DSP_PFD(double p0, struct S_PFD p1, void* p2) { }
+EXPORT void f5_V_DSP_PFP(double p0, struct S_PFP p1, void* p2) { }
+EXPORT void f5_V_DSP_PDI(double p0, struct S_PDI p1, void* p2) { }
+EXPORT void f5_V_DSP_PDF(double p0, struct S_PDF p1, void* p2) { }
+EXPORT void f5_V_DSP_PDD(double p0, struct S_PDD p1, void* p2) { }
+EXPORT void f5_V_DSP_PDP(double p0, struct S_PDP p1, void* p2) { }
+EXPORT void f5_V_DSP_PPI(double p0, struct S_PPI p1, void* p2) { }
+EXPORT void f5_V_DSP_PPF(double p0, struct S_PPF p1, void* p2) { }
+EXPORT void f5_V_DSP_PPD(double p0, struct S_PPD p1, void* p2) { }
+EXPORT void f5_V_DSP_PPP(double p0, struct S_PPP p1, void* p2) { }
+EXPORT void f5_V_DSS_I(double p0, struct S_I p1, struct S_I p2) { }
+EXPORT void f5_V_DSS_F(double p0, struct S_F p1, struct S_F p2) { }
+EXPORT void f5_V_DSS_D(double p0, struct S_D p1, struct S_D p2) { }
+EXPORT void f5_V_DSS_P(double p0, struct S_P p1, struct S_P p2) { }
+EXPORT void f5_V_DSS_II(double p0, struct S_II p1, struct S_II p2) { }
+EXPORT void f5_V_DSS_IF(double p0, struct S_IF p1, struct S_IF p2) { }
+EXPORT void f5_V_DSS_ID(double p0, struct S_ID p1, struct S_ID p2) { }
+EXPORT void f5_V_DSS_IP(double p0, struct S_IP p1, struct S_IP p2) { }
+EXPORT void f5_V_DSS_FI(double p0, struct S_FI p1, struct S_FI p2) { }
+EXPORT void f5_V_DSS_FF(double p0, struct S_FF p1, struct S_FF p2) { }
+EXPORT void f5_V_DSS_FD(double p0, struct S_FD p1, struct S_FD p2) { }
+EXPORT void f5_V_DSS_FP(double p0, struct S_FP p1, struct S_FP p2) { }
+EXPORT void f5_V_DSS_DI(double p0, struct S_DI p1, struct S_DI p2) { }
+EXPORT void f5_V_DSS_DF(double p0, struct S_DF p1, struct S_DF p2) { }
+EXPORT void f5_V_DSS_DD(double p0, struct S_DD p1, struct S_DD p2) { }
+EXPORT void f5_V_DSS_DP(double p0, struct S_DP p1, struct S_DP p2) { }
+EXPORT void f5_V_DSS_PI(double p0, struct S_PI p1, struct S_PI p2) { }
+EXPORT void f5_V_DSS_PF(double p0, struct S_PF p1, struct S_PF p2) { }
+EXPORT void f5_V_DSS_PD(double p0, struct S_PD p1, struct S_PD p2) { }
+EXPORT void f5_V_DSS_PP(double p0, struct S_PP p1, struct S_PP p2) { }
+EXPORT void f5_V_DSS_III(double p0, struct S_III p1, struct S_III p2) { }
+EXPORT void f5_V_DSS_IIF(double p0, struct S_IIF p1, struct S_IIF p2) { }
+EXPORT void f5_V_DSS_IID(double p0, struct S_IID p1, struct S_IID p2) { }
+EXPORT void f5_V_DSS_IIP(double p0, struct S_IIP p1, struct S_IIP p2) { }
+EXPORT void f5_V_DSS_IFI(double p0, struct S_IFI p1, struct S_IFI p2) { }
+EXPORT void f5_V_DSS_IFF(double p0, struct S_IFF p1, struct S_IFF p2) { }
+EXPORT void f5_V_DSS_IFD(double p0, struct S_IFD p1, struct S_IFD p2) { }
+EXPORT void f5_V_DSS_IFP(double p0, struct S_IFP p1, struct S_IFP p2) { }
+EXPORT void f5_V_DSS_IDI(double p0, struct S_IDI p1, struct S_IDI p2) { }
+EXPORT void f5_V_DSS_IDF(double p0, struct S_IDF p1, struct S_IDF p2) { }
+EXPORT void f5_V_DSS_IDD(double p0, struct S_IDD p1, struct S_IDD p2) { }
+EXPORT void f5_V_DSS_IDP(double p0, struct S_IDP p1, struct S_IDP p2) { }
+EXPORT void f5_V_DSS_IPI(double p0, struct S_IPI p1, struct S_IPI p2) { }
+EXPORT void f5_V_DSS_IPF(double p0, struct S_IPF p1, struct S_IPF p2) { }
+EXPORT void f5_V_DSS_IPD(double p0, struct S_IPD p1, struct S_IPD p2) { }
+EXPORT void f5_V_DSS_IPP(double p0, struct S_IPP p1, struct S_IPP p2) { }
+EXPORT void f5_V_DSS_FII(double p0, struct S_FII p1, struct S_FII p2) { }
+EXPORT void f5_V_DSS_FIF(double p0, struct S_FIF p1, struct S_FIF p2) { }
+EXPORT void f5_V_DSS_FID(double p0, struct S_FID p1, struct S_FID p2) { }
+EXPORT void f5_V_DSS_FIP(double p0, struct S_FIP p1, struct S_FIP p2) { }
+EXPORT void f5_V_DSS_FFI(double p0, struct S_FFI p1, struct S_FFI p2) { }
+EXPORT void f5_V_DSS_FFF(double p0, struct S_FFF p1, struct S_FFF p2) { }
+EXPORT void f5_V_DSS_FFD(double p0, struct S_FFD p1, struct S_FFD p2) { }
+EXPORT void f5_V_DSS_FFP(double p0, struct S_FFP p1, struct S_FFP p2) { }
+EXPORT void f5_V_DSS_FDI(double p0, struct S_FDI p1, struct S_FDI p2) { }
+EXPORT void f5_V_DSS_FDF(double p0, struct S_FDF p1, struct S_FDF p2) { }
+EXPORT void f5_V_DSS_FDD(double p0, struct S_FDD p1, struct S_FDD p2) { }
+EXPORT void f5_V_DSS_FDP(double p0, struct S_FDP p1, struct S_FDP p2) { }
+EXPORT void f5_V_DSS_FPI(double p0, struct S_FPI p1, struct S_FPI p2) { }
+EXPORT void f5_V_DSS_FPF(double p0, struct S_FPF p1, struct S_FPF p2) { }
+EXPORT void f5_V_DSS_FPD(double p0, struct S_FPD p1, struct S_FPD p2) { }
+EXPORT void f5_V_DSS_FPP(double p0, struct S_FPP p1, struct S_FPP p2) { }
+EXPORT void f5_V_DSS_DII(double p0, struct S_DII p1, struct S_DII p2) { }
+EXPORT void f5_V_DSS_DIF(double p0, struct S_DIF p1, struct S_DIF p2) { }
+EXPORT void f5_V_DSS_DID(double p0, struct S_DID p1, struct S_DID p2) { }
+EXPORT void f5_V_DSS_DIP(double p0, struct S_DIP p1, struct S_DIP p2) { }
+EXPORT void f5_V_DSS_DFI(double p0, struct S_DFI p1, struct S_DFI p2) { }
+EXPORT void f5_V_DSS_DFF(double p0, struct S_DFF p1, struct S_DFF p2) { }
+EXPORT void f5_V_DSS_DFD(double p0, struct S_DFD p1, struct S_DFD p2) { }
+EXPORT void f5_V_DSS_DFP(double p0, struct S_DFP p1, struct S_DFP p2) { }
+EXPORT void f5_V_DSS_DDI(double p0, struct S_DDI p1, struct S_DDI p2) { }
+EXPORT void f5_V_DSS_DDF(double p0, struct S_DDF p1, struct S_DDF p2) { }
+EXPORT void f5_V_DSS_DDD(double p0, struct S_DDD p1, struct S_DDD p2) { }
+EXPORT void f5_V_DSS_DDP(double p0, struct S_DDP p1, struct S_DDP p2) { }
+EXPORT void f5_V_DSS_DPI(double p0, struct S_DPI p1, struct S_DPI p2) { }
+EXPORT void f5_V_DSS_DPF(double p0, struct S_DPF p1, struct S_DPF p2) { }
+EXPORT void f5_V_DSS_DPD(double p0, struct S_DPD p1, struct S_DPD p2) { }
+EXPORT void f5_V_DSS_DPP(double p0, struct S_DPP p1, struct S_DPP p2) { }
+EXPORT void f5_V_DSS_PII(double p0, struct S_PII p1, struct S_PII p2) { }
+EXPORT void f5_V_DSS_PIF(double p0, struct S_PIF p1, struct S_PIF p2) { }
+EXPORT void f5_V_DSS_PID(double p0, struct S_PID p1, struct S_PID p2) { }
+EXPORT void f5_V_DSS_PIP(double p0, struct S_PIP p1, struct S_PIP p2) { }
+EXPORT void f5_V_DSS_PFI(double p0, struct S_PFI p1, struct S_PFI p2) { }
+EXPORT void f5_V_DSS_PFF(double p0, struct S_PFF p1, struct S_PFF p2) { }
+EXPORT void f5_V_DSS_PFD(double p0, struct S_PFD p1, struct S_PFD p2) { }
+EXPORT void f5_V_DSS_PFP(double p0, struct S_PFP p1, struct S_PFP p2) { }
+EXPORT void f5_V_DSS_PDI(double p0, struct S_PDI p1, struct S_PDI p2) { }
+EXPORT void f5_V_DSS_PDF(double p0, struct S_PDF p1, struct S_PDF p2) { }
+EXPORT void f5_V_DSS_PDD(double p0, struct S_PDD p1, struct S_PDD p2) { }
+EXPORT void f5_V_DSS_PDP(double p0, struct S_PDP p1, struct S_PDP p2) { }
+EXPORT void f5_V_DSS_PPI(double p0, struct S_PPI p1, struct S_PPI p2) { }
+EXPORT void f5_V_DSS_PPF(double p0, struct S_PPF p1, struct S_PPF p2) { }
+EXPORT void f5_V_DSS_PPD(double p0, struct S_PPD p1, struct S_PPD p2) { }
+EXPORT void f5_V_DSS_PPP(double p0, struct S_PPP p1, struct S_PPP p2) { }
+EXPORT void f5_V_PII_(void* p0, int p1, int p2) { }
+EXPORT void f5_V_PIF_(void* p0, int p1, float p2) { }
+EXPORT void f5_V_PID_(void* p0, int p1, double p2) { }
+EXPORT void f5_V_PIP_(void* p0, int p1, void* p2) { }
+EXPORT void f5_V_PIS_I(void* p0, int p1, struct S_I p2) { }
+EXPORT void f5_V_PIS_F(void* p0, int p1, struct S_F p2) { }
+EXPORT void f5_V_PIS_D(void* p0, int p1, struct S_D p2) { }
+EXPORT void f5_V_PIS_P(void* p0, int p1, struct S_P p2) { }
+EXPORT void f5_V_PIS_II(void* p0, int p1, struct S_II p2) { }
+EXPORT void f5_V_PIS_IF(void* p0, int p1, struct S_IF p2) { }
+EXPORT void f5_V_PIS_ID(void* p0, int p1, struct S_ID p2) { }
+EXPORT void f5_V_PIS_IP(void* p0, int p1, struct S_IP p2) { }
+EXPORT void f5_V_PIS_FI(void* p0, int p1, struct S_FI p2) { }
+EXPORT void f5_V_PIS_FF(void* p0, int p1, struct S_FF p2) { }
+EXPORT void f5_V_PIS_FD(void* p0, int p1, struct S_FD p2) { }
+EXPORT void f5_V_PIS_FP(void* p0, int p1, struct S_FP p2) { }
+EXPORT void f5_V_PIS_DI(void* p0, int p1, struct S_DI p2) { }
+EXPORT void f5_V_PIS_DF(void* p0, int p1, struct S_DF p2) { }
+EXPORT void f5_V_PIS_DD(void* p0, int p1, struct S_DD p2) { }
+EXPORT void f5_V_PIS_DP(void* p0, int p1, struct S_DP p2) { }
+EXPORT void f5_V_PIS_PI(void* p0, int p1, struct S_PI p2) { }
+EXPORT void f5_V_PIS_PF(void* p0, int p1, struct S_PF p2) { }
+EXPORT void f5_V_PIS_PD(void* p0, int p1, struct S_PD p2) { }
+EXPORT void f5_V_PIS_PP(void* p0, int p1, struct S_PP p2) { }
+EXPORT void f5_V_PIS_III(void* p0, int p1, struct S_III p2) { }
+EXPORT void f5_V_PIS_IIF(void* p0, int p1, struct S_IIF p2) { }
+EXPORT void f5_V_PIS_IID(void* p0, int p1, struct S_IID p2) { }
+EXPORT void f5_V_PIS_IIP(void* p0, int p1, struct S_IIP p2) { }
+EXPORT void f5_V_PIS_IFI(void* p0, int p1, struct S_IFI p2) { }
+EXPORT void f5_V_PIS_IFF(void* p0, int p1, struct S_IFF p2) { }
+EXPORT void f5_V_PIS_IFD(void* p0, int p1, struct S_IFD p2) { }
+EXPORT void f5_V_PIS_IFP(void* p0, int p1, struct S_IFP p2) { }
+EXPORT void f5_V_PIS_IDI(void* p0, int p1, struct S_IDI p2) { }
+EXPORT void f5_V_PIS_IDF(void* p0, int p1, struct S_IDF p2) { }
+EXPORT void f5_V_PIS_IDD(void* p0, int p1, struct S_IDD p2) { }
+EXPORT void f5_V_PIS_IDP(void* p0, int p1, struct S_IDP p2) { }
+EXPORT void f5_V_PIS_IPI(void* p0, int p1, struct S_IPI p2) { }
+EXPORT void f5_V_PIS_IPF(void* p0, int p1, struct S_IPF p2) { }
+EXPORT void f5_V_PIS_IPD(void* p0, int p1, struct S_IPD p2) { }
+EXPORT void f5_V_PIS_IPP(void* p0, int p1, struct S_IPP p2) { }
+EXPORT void f5_V_PIS_FII(void* p0, int p1, struct S_FII p2) { }
+EXPORT void f5_V_PIS_FIF(void* p0, int p1, struct S_FIF p2) { }
+EXPORT void f5_V_PIS_FID(void* p0, int p1, struct S_FID p2) { }
+EXPORT void f5_V_PIS_FIP(void* p0, int p1, struct S_FIP p2) { }
+EXPORT void f5_V_PIS_FFI(void* p0, int p1, struct S_FFI p2) { }
+EXPORT void f5_V_PIS_FFF(void* p0, int p1, struct S_FFF p2) { }
+EXPORT void f5_V_PIS_FFD(void* p0, int p1, struct S_FFD p2) { }
+EXPORT void f5_V_PIS_FFP(void* p0, int p1, struct S_FFP p2) { }
+EXPORT void f5_V_PIS_FDI(void* p0, int p1, struct S_FDI p2) { }
+EXPORT void f5_V_PIS_FDF(void* p0, int p1, struct S_FDF p2) { }
+EXPORT void f5_V_PIS_FDD(void* p0, int p1, struct S_FDD p2) { }
+EXPORT void f5_V_PIS_FDP(void* p0, int p1, struct S_FDP p2) { }
+EXPORT void f5_V_PIS_FPI(void* p0, int p1, struct S_FPI p2) { }
+EXPORT void f5_V_PIS_FPF(void* p0, int p1, struct S_FPF p2) { }
+EXPORT void f5_V_PIS_FPD(void* p0, int p1, struct S_FPD p2) { }
+EXPORT void f5_V_PIS_FPP(void* p0, int p1, struct S_FPP p2) { }
+EXPORT void f5_V_PIS_DII(void* p0, int p1, struct S_DII p2) { }
+EXPORT void f5_V_PIS_DIF(void* p0, int p1, struct S_DIF p2) { }
+EXPORT void f5_V_PIS_DID(void* p0, int p1, struct S_DID p2) { }
+EXPORT void f5_V_PIS_DIP(void* p0, int p1, struct S_DIP p2) { }
+EXPORT void f5_V_PIS_DFI(void* p0, int p1, struct S_DFI p2) { }
+EXPORT void f5_V_PIS_DFF(void* p0, int p1, struct S_DFF p2) { }
+EXPORT void f5_V_PIS_DFD(void* p0, int p1, struct S_DFD p2) { }
+EXPORT void f5_V_PIS_DFP(void* p0, int p1, struct S_DFP p2) { }
+EXPORT void f5_V_PIS_DDI(void* p0, int p1, struct S_DDI p2) { }
+EXPORT void f5_V_PIS_DDF(void* p0, int p1, struct S_DDF p2) { }
+EXPORT void f5_V_PIS_DDD(void* p0, int p1, struct S_DDD p2) { }
+EXPORT void f5_V_PIS_DDP(void* p0, int p1, struct S_DDP p2) { }
+EXPORT void f5_V_PIS_DPI(void* p0, int p1, struct S_DPI p2) { }
+EXPORT void f5_V_PIS_DPF(void* p0, int p1, struct S_DPF p2) { }
+EXPORT void f5_V_PIS_DPD(void* p0, int p1, struct S_DPD p2) { }
+EXPORT void f5_V_PIS_DPP(void* p0, int p1, struct S_DPP p2) { }
+EXPORT void f5_V_PIS_PII(void* p0, int p1, struct S_PII p2) { }
+EXPORT void f5_V_PIS_PIF(void* p0, int p1, struct S_PIF p2) { }
+EXPORT void f5_V_PIS_PID(void* p0, int p1, struct S_PID p2) { }
+EXPORT void f5_V_PIS_PIP(void* p0, int p1, struct S_PIP p2) { }
+EXPORT void f5_V_PIS_PFI(void* p0, int p1, struct S_PFI p2) { }
+EXPORT void f5_V_PIS_PFF(void* p0, int p1, struct S_PFF p2) { }
+EXPORT void f5_V_PIS_PFD(void* p0, int p1, struct S_PFD p2) { }
+EXPORT void f5_V_PIS_PFP(void* p0, int p1, struct S_PFP p2) { }
+EXPORT void f5_V_PIS_PDI(void* p0, int p1, struct S_PDI p2) { }
+EXPORT void f5_V_PIS_PDF(void* p0, int p1, struct S_PDF p2) { }
+EXPORT void f5_V_PIS_PDD(void* p0, int p1, struct S_PDD p2) { }
+EXPORT void f5_V_PIS_PDP(void* p0, int p1, struct S_PDP p2) { }
+EXPORT void f5_V_PIS_PPI(void* p0, int p1, struct S_PPI p2) { }
+EXPORT void f5_V_PIS_PPF(void* p0, int p1, struct S_PPF p2) { }
+EXPORT void f5_V_PIS_PPD(void* p0, int p1, struct S_PPD p2) { }
+EXPORT void f5_V_PIS_PPP(void* p0, int p1, struct S_PPP p2) { }
+EXPORT void f5_V_PFI_(void* p0, float p1, int p2) { }
+EXPORT void f5_V_PFF_(void* p0, float p1, float p2) { }
+EXPORT void f5_V_PFD_(void* p0, float p1, double p2) { }
+EXPORT void f5_V_PFP_(void* p0, float p1, void* p2) { }
+EXPORT void f5_V_PFS_I(void* p0, float p1, struct S_I p2) { }
+EXPORT void f5_V_PFS_F(void* p0, float p1, struct S_F p2) { }
+EXPORT void f5_V_PFS_D(void* p0, float p1, struct S_D p2) { }
+EXPORT void f5_V_PFS_P(void* p0, float p1, struct S_P p2) { }
+EXPORT void f5_V_PFS_II(void* p0, float p1, struct S_II p2) { }
+EXPORT void f5_V_PFS_IF(void* p0, float p1, struct S_IF p2) { }
+EXPORT void f5_V_PFS_ID(void* p0, float p1, struct S_ID p2) { }
+EXPORT void f5_V_PFS_IP(void* p0, float p1, struct S_IP p2) { }
+EXPORT void f5_V_PFS_FI(void* p0, float p1, struct S_FI p2) { }
+EXPORT void f5_V_PFS_FF(void* p0, float p1, struct S_FF p2) { }
+EXPORT void f5_V_PFS_FD(void* p0, float p1, struct S_FD p2) { }
+EXPORT void f5_V_PFS_FP(void* p0, float p1, struct S_FP p2) { }
+EXPORT void f5_V_PFS_DI(void* p0, float p1, struct S_DI p2) { }
+EXPORT void f5_V_PFS_DF(void* p0, float p1, struct S_DF p2) { }
+EXPORT void f5_V_PFS_DD(void* p0, float p1, struct S_DD p2) { }
+EXPORT void f5_V_PFS_DP(void* p0, float p1, struct S_DP p2) { }
+EXPORT void f5_V_PFS_PI(void* p0, float p1, struct S_PI p2) { }
+EXPORT void f5_V_PFS_PF(void* p0, float p1, struct S_PF p2) { }
+EXPORT void f5_V_PFS_PD(void* p0, float p1, struct S_PD p2) { }
+EXPORT void f5_V_PFS_PP(void* p0, float p1, struct S_PP p2) { }
+EXPORT void f5_V_PFS_III(void* p0, float p1, struct S_III p2) { }
+EXPORT void f5_V_PFS_IIF(void* p0, float p1, struct S_IIF p2) { }
+EXPORT void f5_V_PFS_IID(void* p0, float p1, struct S_IID p2) { }
+EXPORT void f5_V_PFS_IIP(void* p0, float p1, struct S_IIP p2) { }
+EXPORT void f5_V_PFS_IFI(void* p0, float p1, struct S_IFI p2) { }
+EXPORT void f5_V_PFS_IFF(void* p0, float p1, struct S_IFF p2) { }
+EXPORT void f5_V_PFS_IFD(void* p0, float p1, struct S_IFD p2) { }
+EXPORT void f5_V_PFS_IFP(void* p0, float p1, struct S_IFP p2) { }
+EXPORT void f5_V_PFS_IDI(void* p0, float p1, struct S_IDI p2) { }
+EXPORT void f5_V_PFS_IDF(void* p0, float p1, struct S_IDF p2) { }
+EXPORT void f5_V_PFS_IDD(void* p0, float p1, struct S_IDD p2) { }
+EXPORT void f5_V_PFS_IDP(void* p0, float p1, struct S_IDP p2) { }
+EXPORT void f5_V_PFS_IPI(void* p0, float p1, struct S_IPI p2) { }
+EXPORT void f5_V_PFS_IPF(void* p0, float p1, struct S_IPF p2) { }
+EXPORT void f5_V_PFS_IPD(void* p0, float p1, struct S_IPD p2) { }
+EXPORT void f5_V_PFS_IPP(void* p0, float p1, struct S_IPP p2) { }
+EXPORT void f5_V_PFS_FII(void* p0, float p1, struct S_FII p2) { }
+EXPORT void f5_V_PFS_FIF(void* p0, float p1, struct S_FIF p2) { }
+EXPORT void f5_V_PFS_FID(void* p0, float p1, struct S_FID p2) { }
+EXPORT void f5_V_PFS_FIP(void* p0, float p1, struct S_FIP p2) { }
+EXPORT void f5_V_PFS_FFI(void* p0, float p1, struct S_FFI p2) { }
+EXPORT void f5_V_PFS_FFF(void* p0, float p1, struct S_FFF p2) { }
+EXPORT void f5_V_PFS_FFD(void* p0, float p1, struct S_FFD p2) { }
+EXPORT void f5_V_PFS_FFP(void* p0, float p1, struct S_FFP p2) { }
+EXPORT void f5_V_PFS_FDI(void* p0, float p1, struct S_FDI p2) { }
+EXPORT void f5_V_PFS_FDF(void* p0, float p1, struct S_FDF p2) { }
+EXPORT void f5_V_PFS_FDD(void* p0, float p1, struct S_FDD p2) { }
+EXPORT void f5_V_PFS_FDP(void* p0, float p1, struct S_FDP p2) { }
+EXPORT void f5_V_PFS_FPI(void* p0, float p1, struct S_FPI p2) { }
+EXPORT void f5_V_PFS_FPF(void* p0, float p1, struct S_FPF p2) { }
+EXPORT void f5_V_PFS_FPD(void* p0, float p1, struct S_FPD p2) { }
+EXPORT void f5_V_PFS_FPP(void* p0, float p1, struct S_FPP p2) { }
+EXPORT void f5_V_PFS_DII(void* p0, float p1, struct S_DII p2) { }
+EXPORT void f5_V_PFS_DIF(void* p0, float p1, struct S_DIF p2) { }
+EXPORT void f5_V_PFS_DID(void* p0, float p1, struct S_DID p2) { }
+EXPORT void f5_V_PFS_DIP(void* p0, float p1, struct S_DIP p2) { }
+EXPORT void f5_V_PFS_DFI(void* p0, float p1, struct S_DFI p2) { }
+EXPORT void f5_V_PFS_DFF(void* p0, float p1, struct S_DFF p2) { }
+EXPORT void f5_V_PFS_DFD(void* p0, float p1, struct S_DFD p2) { }
+EXPORT void f5_V_PFS_DFP(void* p0, float p1, struct S_DFP p2) { }
+EXPORT void f5_V_PFS_DDI(void* p0, float p1, struct S_DDI p2) { }
+EXPORT void f5_V_PFS_DDF(void* p0, float p1, struct S_DDF p2) { }
+EXPORT void f5_V_PFS_DDD(void* p0, float p1, struct S_DDD p2) { }
+EXPORT void f5_V_PFS_DDP(void* p0, float p1, struct S_DDP p2) { }
+EXPORT void f5_V_PFS_DPI(void* p0, float p1, struct S_DPI p2) { }
+EXPORT void f5_V_PFS_DPF(void* p0, float p1, struct S_DPF p2) { }
+EXPORT void f5_V_PFS_DPD(void* p0, float p1, struct S_DPD p2) { }
+EXPORT void f5_V_PFS_DPP(void* p0, float p1, struct S_DPP p2) { }
+EXPORT void f5_V_PFS_PII(void* p0, float p1, struct S_PII p2) { }
+EXPORT void f5_V_PFS_PIF(void* p0, float p1, struct S_PIF p2) { }
+EXPORT void f5_V_PFS_PID(void* p0, float p1, struct S_PID p2) { }
+EXPORT void f5_V_PFS_PIP(void* p0, float p1, struct S_PIP p2) { }
+EXPORT void f5_V_PFS_PFI(void* p0, float p1, struct S_PFI p2) { }
+EXPORT void f5_V_PFS_PFF(void* p0, float p1, struct S_PFF p2) { }
+EXPORT void f5_V_PFS_PFD(void* p0, float p1, struct S_PFD p2) { }
+EXPORT void f5_V_PFS_PFP(void* p0, float p1, struct S_PFP p2) { }
+EXPORT void f5_V_PFS_PDI(void* p0, float p1, struct S_PDI p2) { }
+EXPORT void f5_V_PFS_PDF(void* p0, float p1, struct S_PDF p2) { }
+EXPORT void f5_V_PFS_PDD(void* p0, float p1, struct S_PDD p2) { }
+EXPORT void f5_V_PFS_PDP(void* p0, float p1, struct S_PDP p2) { }
+EXPORT void f5_V_PFS_PPI(void* p0, float p1, struct S_PPI p2) { }
+EXPORT void f5_V_PFS_PPF(void* p0, float p1, struct S_PPF p2) { }
+EXPORT void f5_V_PFS_PPD(void* p0, float p1, struct S_PPD p2) { }
+EXPORT void f5_V_PFS_PPP(void* p0, float p1, struct S_PPP p2) { }
+EXPORT void f5_V_PDI_(void* p0, double p1, int p2) { }
+EXPORT void f5_V_PDF_(void* p0, double p1, float p2) { }
+EXPORT void f5_V_PDD_(void* p0, double p1, double p2) { }
+EXPORT void f5_V_PDP_(void* p0, double p1, void* p2) { }
+EXPORT void f5_V_PDS_I(void* p0, double p1, struct S_I p2) { }
+EXPORT void f5_V_PDS_F(void* p0, double p1, struct S_F p2) { }
+EXPORT void f5_V_PDS_D(void* p0, double p1, struct S_D p2) { }
+EXPORT void f5_V_PDS_P(void* p0, double p1, struct S_P p2) { }
+EXPORT void f5_V_PDS_II(void* p0, double p1, struct S_II p2) { }
+EXPORT void f5_V_PDS_IF(void* p0, double p1, struct S_IF p2) { }
+EXPORT void f5_V_PDS_ID(void* p0, double p1, struct S_ID p2) { }
+EXPORT void f5_V_PDS_IP(void* p0, double p1, struct S_IP p2) { }
+EXPORT void f5_V_PDS_FI(void* p0, double p1, struct S_FI p2) { }
+EXPORT void f5_V_PDS_FF(void* p0, double p1, struct S_FF p2) { }
+EXPORT void f5_V_PDS_FD(void* p0, double p1, struct S_FD p2) { }
+EXPORT void f5_V_PDS_FP(void* p0, double p1, struct S_FP p2) { }
+EXPORT void f5_V_PDS_DI(void* p0, double p1, struct S_DI p2) { }
+EXPORT void f5_V_PDS_DF(void* p0, double p1, struct S_DF p2) { }
+EXPORT void f5_V_PDS_DD(void* p0, double p1, struct S_DD p2) { }
+EXPORT void f5_V_PDS_DP(void* p0, double p1, struct S_DP p2) { }
+EXPORT void f5_V_PDS_PI(void* p0, double p1, struct S_PI p2) { }
+EXPORT void f5_V_PDS_PF(void* p0, double p1, struct S_PF p2) { }
+EXPORT void f5_V_PDS_PD(void* p0, double p1, struct S_PD p2) { }
+EXPORT void f5_V_PDS_PP(void* p0, double p1, struct S_PP p2) { }
+EXPORT void f5_V_PDS_III(void* p0, double p1, struct S_III p2) { }
+EXPORT void f5_V_PDS_IIF(void* p0, double p1, struct S_IIF p2) { }
+EXPORT void f5_V_PDS_IID(void* p0, double p1, struct S_IID p2) { }
+EXPORT void f5_V_PDS_IIP(void* p0, double p1, struct S_IIP p2) { }
+EXPORT void f5_V_PDS_IFI(void* p0, double p1, struct S_IFI p2) { }
+EXPORT void f5_V_PDS_IFF(void* p0, double p1, struct S_IFF p2) { }
+EXPORT void f5_V_PDS_IFD(void* p0, double p1, struct S_IFD p2) { }
+EXPORT void f5_V_PDS_IFP(void* p0, double p1, struct S_IFP p2) { }
+EXPORT void f5_V_PDS_IDI(void* p0, double p1, struct S_IDI p2) { }
+EXPORT void f5_V_PDS_IDF(void* p0, double p1, struct S_IDF p2) { }
+EXPORT void f5_V_PDS_IDD(void* p0, double p1, struct S_IDD p2) { }
+EXPORT void f5_V_PDS_IDP(void* p0, double p1, struct S_IDP p2) { }
+EXPORT void f5_V_PDS_IPI(void* p0, double p1, struct S_IPI p2) { }
+EXPORT void f5_V_PDS_IPF(void* p0, double p1, struct S_IPF p2) { }
+EXPORT void f5_V_PDS_IPD(void* p0, double p1, struct S_IPD p2) { }
+EXPORT void f5_V_PDS_IPP(void* p0, double p1, struct S_IPP p2) { }
+EXPORT void f5_V_PDS_FII(void* p0, double p1, struct S_FII p2) { }
+EXPORT void f5_V_PDS_FIF(void* p0, double p1, struct S_FIF p2) { }
+EXPORT void f5_V_PDS_FID(void* p0, double p1, struct S_FID p2) { }
+EXPORT void f5_V_PDS_FIP(void* p0, double p1, struct S_FIP p2) { }
+EXPORT void f5_V_PDS_FFI(void* p0, double p1, struct S_FFI p2) { }
+EXPORT void f5_V_PDS_FFF(void* p0, double p1, struct S_FFF p2) { }
+EXPORT void f5_V_PDS_FFD(void* p0, double p1, struct S_FFD p2) { }
+EXPORT void f5_V_PDS_FFP(void* p0, double p1, struct S_FFP p2) { }
+EXPORT void f5_V_PDS_FDI(void* p0, double p1, struct S_FDI p2) { }
+EXPORT void f5_V_PDS_FDF(void* p0, double p1, struct S_FDF p2) { }
+EXPORT void f5_V_PDS_FDD(void* p0, double p1, struct S_FDD p2) { }
+EXPORT void f5_V_PDS_FDP(void* p0, double p1, struct S_FDP p2) { }
+EXPORT void f5_V_PDS_FPI(void* p0, double p1, struct S_FPI p2) { }
+EXPORT void f5_V_PDS_FPF(void* p0, double p1, struct S_FPF p2) { }
+EXPORT void f5_V_PDS_FPD(void* p0, double p1, struct S_FPD p2) { }
+EXPORT void f5_V_PDS_FPP(void* p0, double p1, struct S_FPP p2) { }
+EXPORT void f5_V_PDS_DII(void* p0, double p1, struct S_DII p2) { }
+EXPORT void f5_V_PDS_DIF(void* p0, double p1, struct S_DIF p2) { }
+EXPORT void f5_V_PDS_DID(void* p0, double p1, struct S_DID p2) { }
+EXPORT void f5_V_PDS_DIP(void* p0, double p1, struct S_DIP p2) { }
+EXPORT void f5_V_PDS_DFI(void* p0, double p1, struct S_DFI p2) { }
+EXPORT void f5_V_PDS_DFF(void* p0, double p1, struct S_DFF p2) { }
+EXPORT void f5_V_PDS_DFD(void* p0, double p1, struct S_DFD p2) { }
+EXPORT void f5_V_PDS_DFP(void* p0, double p1, struct S_DFP p2) { }
+EXPORT void f5_V_PDS_DDI(void* p0, double p1, struct S_DDI p2) { }
+EXPORT void f5_V_PDS_DDF(void* p0, double p1, struct S_DDF p2) { }
+EXPORT void f5_V_PDS_DDD(void* p0, double p1, struct S_DDD p2) { }
+EXPORT void f5_V_PDS_DDP(void* p0, double p1, struct S_DDP p2) { }
+EXPORT void f5_V_PDS_DPI(void* p0, double p1, struct S_DPI p2) { }
+EXPORT void f5_V_PDS_DPF(void* p0, double p1, struct S_DPF p2) { }
+EXPORT void f5_V_PDS_DPD(void* p0, double p1, struct S_DPD p2) { }
+EXPORT void f5_V_PDS_DPP(void* p0, double p1, struct S_DPP p2) { }
+EXPORT void f5_V_PDS_PII(void* p0, double p1, struct S_PII p2) { }
+EXPORT void f5_V_PDS_PIF(void* p0, double p1, struct S_PIF p2) { }
+EXPORT void f5_V_PDS_PID(void* p0, double p1, struct S_PID p2) { }
+EXPORT void f5_V_PDS_PIP(void* p0, double p1, struct S_PIP p2) { }
+EXPORT void f5_V_PDS_PFI(void* p0, double p1, struct S_PFI p2) { }
+EXPORT void f5_V_PDS_PFF(void* p0, double p1, struct S_PFF p2) { }
+EXPORT void f5_V_PDS_PFD(void* p0, double p1, struct S_PFD p2) { }
+EXPORT void f5_V_PDS_PFP(void* p0, double p1, struct S_PFP p2) { }
+EXPORT void f5_V_PDS_PDI(void* p0, double p1, struct S_PDI p2) { }
+EXPORT void f5_V_PDS_PDF(void* p0, double p1, struct S_PDF p2) { }
+EXPORT void f5_V_PDS_PDD(void* p0, double p1, struct S_PDD p2) { }
+EXPORT void f5_V_PDS_PDP(void* p0, double p1, struct S_PDP p2) { }
+EXPORT void f5_V_PDS_PPI(void* p0, double p1, struct S_PPI p2) { }
+EXPORT void f5_V_PDS_PPF(void* p0, double p1, struct S_PPF p2) { }
+EXPORT void f5_V_PDS_PPD(void* p0, double p1, struct S_PPD p2) { }
+EXPORT void f5_V_PDS_PPP(void* p0, double p1, struct S_PPP p2) { }
+EXPORT void f5_V_PPI_(void* p0, void* p1, int p2) { }
+EXPORT void f5_V_PPF_(void* p0, void* p1, float p2) { }
+EXPORT void f5_V_PPD_(void* p0, void* p1, double p2) { }
+EXPORT void f5_V_PPP_(void* p0, void* p1, void* p2) { }
+EXPORT void f5_V_PPS_I(void* p0, void* p1, struct S_I p2) { }
+EXPORT void f5_V_PPS_F(void* p0, void* p1, struct S_F p2) { }
+EXPORT void f5_V_PPS_D(void* p0, void* p1, struct S_D p2) { }
+EXPORT void f5_V_PPS_P(void* p0, void* p1, struct S_P p2) { }
+EXPORT void f5_V_PPS_II(void* p0, void* p1, struct S_II p2) { }
+EXPORT void f5_V_PPS_IF(void* p0, void* p1, struct S_IF p2) { }
+EXPORT void f5_V_PPS_ID(void* p0, void* p1, struct S_ID p2) { }
+EXPORT void f5_V_PPS_IP(void* p0, void* p1, struct S_IP p2) { }
+EXPORT void f5_V_PPS_FI(void* p0, void* p1, struct S_FI p2) { }
+EXPORT void f5_V_PPS_FF(void* p0, void* p1, struct S_FF p2) { }
+EXPORT void f5_V_PPS_FD(void* p0, void* p1, struct S_FD p2) { }
+EXPORT void f5_V_PPS_FP(void* p0, void* p1, struct S_FP p2) { }
+EXPORT void f5_V_PPS_DI(void* p0, void* p1, struct S_DI p2) { }
+EXPORT void f5_V_PPS_DF(void* p0, void* p1, struct S_DF p2) { }
+EXPORT void f5_V_PPS_DD(void* p0, void* p1, struct S_DD p2) { }
+EXPORT void f5_V_PPS_DP(void* p0, void* p1, struct S_DP p2) { }
+EXPORT void f5_V_PPS_PI(void* p0, void* p1, struct S_PI p2) { }
+EXPORT void f5_V_PPS_PF(void* p0, void* p1, struct S_PF p2) { }
+EXPORT void f5_V_PPS_PD(void* p0, void* p1, struct S_PD p2) { }
+EXPORT void f5_V_PPS_PP(void* p0, void* p1, struct S_PP p2) { }
+EXPORT void f5_V_PPS_III(void* p0, void* p1, struct S_III p2) { }
+EXPORT void f5_V_PPS_IIF(void* p0, void* p1, struct S_IIF p2) { }
+EXPORT void f5_V_PPS_IID(void* p0, void* p1, struct S_IID p2) { }
+EXPORT void f5_V_PPS_IIP(void* p0, void* p1, struct S_IIP p2) { }
+EXPORT void f5_V_PPS_IFI(void* p0, void* p1, struct S_IFI p2) { }
+EXPORT void f5_V_PPS_IFF(void* p0, void* p1, struct S_IFF p2) { }
+EXPORT void f5_V_PPS_IFD(void* p0, void* p1, struct S_IFD p2) { }
+EXPORT void f5_V_PPS_IFP(void* p0, void* p1, struct S_IFP p2) { }
+EXPORT void f5_V_PPS_IDI(void* p0, void* p1, struct S_IDI p2) { }
+EXPORT void f5_V_PPS_IDF(void* p0, void* p1, struct S_IDF p2) { }
+EXPORT void f5_V_PPS_IDD(void* p0, void* p1, struct S_IDD p2) { }
+EXPORT void f5_V_PPS_IDP(void* p0, void* p1, struct S_IDP p2) { }
+EXPORT void f5_V_PPS_IPI(void* p0, void* p1, struct S_IPI p2) { }
+EXPORT void f5_V_PPS_IPF(void* p0, void* p1, struct S_IPF p2) { }
+EXPORT void f5_V_PPS_IPD(void* p0, void* p1, struct S_IPD p2) { }
+EXPORT void f5_V_PPS_IPP(void* p0, void* p1, struct S_IPP p2) { }
+EXPORT void f5_V_PPS_FII(void* p0, void* p1, struct S_FII p2) { }
+EXPORT void f5_V_PPS_FIF(void* p0, void* p1, struct S_FIF p2) { }
+EXPORT void f5_V_PPS_FID(void* p0, void* p1, struct S_FID p2) { }
+EXPORT void f5_V_PPS_FIP(void* p0, void* p1, struct S_FIP p2) { }
+EXPORT void f5_V_PPS_FFI(void* p0, void* p1, struct S_FFI p2) { }
+EXPORT void f5_V_PPS_FFF(void* p0, void* p1, struct S_FFF p2) { }
+EXPORT void f5_V_PPS_FFD(void* p0, void* p1, struct S_FFD p2) { }
+EXPORT void f5_V_PPS_FFP(void* p0, void* p1, struct S_FFP p2) { }
+EXPORT void f5_V_PPS_FDI(void* p0, void* p1, struct S_FDI p2) { }
+EXPORT void f5_V_PPS_FDF(void* p0, void* p1, struct S_FDF p2) { }
+EXPORT void f5_V_PPS_FDD(void* p0, void* p1, struct S_FDD p2) { }
+EXPORT void f5_V_PPS_FDP(void* p0, void* p1, struct S_FDP p2) { }
+EXPORT void f5_V_PPS_FPI(void* p0, void* p1, struct S_FPI p2) { }
+EXPORT void f5_V_PPS_FPF(void* p0, void* p1, struct S_FPF p2) { }
+EXPORT void f5_V_PPS_FPD(void* p0, void* p1, struct S_FPD p2) { }
+EXPORT void f5_V_PPS_FPP(void* p0, void* p1, struct S_FPP p2) { }
+EXPORT void f5_V_PPS_DII(void* p0, void* p1, struct S_DII p2) { }
+EXPORT void f5_V_PPS_DIF(void* p0, void* p1, struct S_DIF p2) { }
+EXPORT void f5_V_PPS_DID(void* p0, void* p1, struct S_DID p2) { }
+EXPORT void f5_V_PPS_DIP(void* p0, void* p1, struct S_DIP p2) { }
+EXPORT void f5_V_PPS_DFI(void* p0, void* p1, struct S_DFI p2) { }
+EXPORT void f5_V_PPS_DFF(void* p0, void* p1, struct S_DFF p2) { }
+EXPORT void f5_V_PPS_DFD(void* p0, void* p1, struct S_DFD p2) { }
+EXPORT void f5_V_PPS_DFP(void* p0, void* p1, struct S_DFP p2) { }
+EXPORT void f5_V_PPS_DDI(void* p0, void* p1, struct S_DDI p2) { }
+EXPORT void f5_V_PPS_DDF(void* p0, void* p1, struct S_DDF p2) { }
+EXPORT void f5_V_PPS_DDD(void* p0, void* p1, struct S_DDD p2) { }
+EXPORT void f5_V_PPS_DDP(void* p0, void* p1, struct S_DDP p2) { }
+EXPORT void f5_V_PPS_DPI(void* p0, void* p1, struct S_DPI p2) { }
+EXPORT void f5_V_PPS_DPF(void* p0, void* p1, struct S_DPF p2) { }
+EXPORT void f5_V_PPS_DPD(void* p0, void* p1, struct S_DPD p2) { }
+EXPORT void f5_V_PPS_DPP(void* p0, void* p1, struct S_DPP p2) { }
+EXPORT void f5_V_PPS_PII(void* p0, void* p1, struct S_PII p2) { }
+EXPORT void f5_V_PPS_PIF(void* p0, void* p1, struct S_PIF p2) { }
+EXPORT void f5_V_PPS_PID(void* p0, void* p1, struct S_PID p2) { }
+EXPORT void f5_V_PPS_PIP(void* p0, void* p1, struct S_PIP p2) { }
+EXPORT void f5_V_PPS_PFI(void* p0, void* p1, struct S_PFI p2) { }
+EXPORT void f5_V_PPS_PFF(void* p0, void* p1, struct S_PFF p2) { }
+EXPORT void f5_V_PPS_PFD(void* p0, void* p1, struct S_PFD p2) { }
+EXPORT void f5_V_PPS_PFP(void* p0, void* p1, struct S_PFP p2) { }
+EXPORT void f5_V_PPS_PDI(void* p0, void* p1, struct S_PDI p2) { }
+EXPORT void f5_V_PPS_PDF(void* p0, void* p1, struct S_PDF p2) { }
+EXPORT void f5_V_PPS_PDD(void* p0, void* p1, struct S_PDD p2) { }
+EXPORT void f5_V_PPS_PDP(void* p0, void* p1, struct S_PDP p2) { }
+EXPORT void f5_V_PPS_PPI(void* p0, void* p1, struct S_PPI p2) { }
+EXPORT void f5_V_PPS_PPF(void* p0, void* p1, struct S_PPF p2) { }
+EXPORT void f5_V_PPS_PPD(void* p0, void* p1, struct S_PPD p2) { }
+EXPORT void f5_V_PPS_PPP(void* p0, void* p1, struct S_PPP p2) { }
+EXPORT void f5_V_PSI_I(void* p0, struct S_I p1, int p2) { }
+EXPORT void f5_V_PSI_F(void* p0, struct S_F p1, int p2) { }
+EXPORT void f5_V_PSI_D(void* p0, struct S_D p1, int p2) { }
+EXPORT void f5_V_PSI_P(void* p0, struct S_P p1, int p2) { }
+EXPORT void f5_V_PSI_II(void* p0, struct S_II p1, int p2) { }
+EXPORT void f5_V_PSI_IF(void* p0, struct S_IF p1, int p2) { }
+EXPORT void f5_V_PSI_ID(void* p0, struct S_ID p1, int p2) { }
+EXPORT void f5_V_PSI_IP(void* p0, struct S_IP p1, int p2) { }
+EXPORT void f5_V_PSI_FI(void* p0, struct S_FI p1, int p2) { }
+EXPORT void f5_V_PSI_FF(void* p0, struct S_FF p1, int p2) { }
+EXPORT void f5_V_PSI_FD(void* p0, struct S_FD p1, int p2) { }
+EXPORT void f5_V_PSI_FP(void* p0, struct S_FP p1, int p2) { }
+EXPORT void f5_V_PSI_DI(void* p0, struct S_DI p1, int p2) { }
+EXPORT void f5_V_PSI_DF(void* p0, struct S_DF p1, int p2) { }
+EXPORT void f5_V_PSI_DD(void* p0, struct S_DD p1, int p2) { }
+EXPORT void f5_V_PSI_DP(void* p0, struct S_DP p1, int p2) { }
+EXPORT void f5_V_PSI_PI(void* p0, struct S_PI p1, int p2) { }
+EXPORT void f5_V_PSI_PF(void* p0, struct S_PF p1, int p2) { }
+EXPORT void f5_V_PSI_PD(void* p0, struct S_PD p1, int p2) { }
+EXPORT void f5_V_PSI_PP(void* p0, struct S_PP p1, int p2) { }
+EXPORT void f5_V_PSI_III(void* p0, struct S_III p1, int p2) { }
+EXPORT void f5_V_PSI_IIF(void* p0, struct S_IIF p1, int p2) { }
+EXPORT void f5_V_PSI_IID(void* p0, struct S_IID p1, int p2) { }
+EXPORT void f5_V_PSI_IIP(void* p0, struct S_IIP p1, int p2) { }
+EXPORT void f5_V_PSI_IFI(void* p0, struct S_IFI p1, int p2) { }
+EXPORT void f5_V_PSI_IFF(void* p0, struct S_IFF p1, int p2) { }
+EXPORT void f5_V_PSI_IFD(void* p0, struct S_IFD p1, int p2) { }
+EXPORT void f5_V_PSI_IFP(void* p0, struct S_IFP p1, int p2) { }
+EXPORT void f5_V_PSI_IDI(void* p0, struct S_IDI p1, int p2) { }
+EXPORT void f5_V_PSI_IDF(void* p0, struct S_IDF p1, int p2) { }
+EXPORT void f5_V_PSI_IDD(void* p0, struct S_IDD p1, int p2) { }
+EXPORT void f5_V_PSI_IDP(void* p0, struct S_IDP p1, int p2) { }
+EXPORT void f5_V_PSI_IPI(void* p0, struct S_IPI p1, int p2) { }
+EXPORT void f5_V_PSI_IPF(void* p0, struct S_IPF p1, int p2) { }
+EXPORT void f5_V_PSI_IPD(void* p0, struct S_IPD p1, int p2) { }
+EXPORT void f5_V_PSI_IPP(void* p0, struct S_IPP p1, int p2) { }
+EXPORT void f5_V_PSI_FII(void* p0, struct S_FII p1, int p2) { }
+EXPORT void f5_V_PSI_FIF(void* p0, struct S_FIF p1, int p2) { }
+EXPORT void f5_V_PSI_FID(void* p0, struct S_FID p1, int p2) { }
+EXPORT void f5_V_PSI_FIP(void* p0, struct S_FIP p1, int p2) { }
+EXPORT void f5_V_PSI_FFI(void* p0, struct S_FFI p1, int p2) { }
+EXPORT void f5_V_PSI_FFF(void* p0, struct S_FFF p1, int p2) { }
+EXPORT void f5_V_PSI_FFD(void* p0, struct S_FFD p1, int p2) { }
+EXPORT void f5_V_PSI_FFP(void* p0, struct S_FFP p1, int p2) { }
+EXPORT void f5_V_PSI_FDI(void* p0, struct S_FDI p1, int p2) { }
+EXPORT void f5_V_PSI_FDF(void* p0, struct S_FDF p1, int p2) { }
+EXPORT void f5_V_PSI_FDD(void* p0, struct S_FDD p1, int p2) { }
+EXPORT void f5_V_PSI_FDP(void* p0, struct S_FDP p1, int p2) { }
+EXPORT void f5_V_PSI_FPI(void* p0, struct S_FPI p1, int p2) { }
+EXPORT void f5_V_PSI_FPF(void* p0, struct S_FPF p1, int p2) { }
+EXPORT void f5_V_PSI_FPD(void* p0, struct S_FPD p1, int p2) { }
+EXPORT void f5_V_PSI_FPP(void* p0, struct S_FPP p1, int p2) { }
+EXPORT void f5_V_PSI_DII(void* p0, struct S_DII p1, int p2) { }
+EXPORT void f5_V_PSI_DIF(void* p0, struct S_DIF p1, int p2) { }
+EXPORT void f5_V_PSI_DID(void* p0, struct S_DID p1, int p2) { }
+EXPORT void f5_V_PSI_DIP(void* p0, struct S_DIP p1, int p2) { }
+EXPORT void f5_V_PSI_DFI(void* p0, struct S_DFI p1, int p2) { }
+EXPORT void f5_V_PSI_DFF(void* p0, struct S_DFF p1, int p2) { }
+EXPORT void f5_V_PSI_DFD(void* p0, struct S_DFD p1, int p2) { }
+EXPORT void f5_V_PSI_DFP(void* p0, struct S_DFP p1, int p2) { }
+EXPORT void f5_V_PSI_DDI(void* p0, struct S_DDI p1, int p2) { }
+EXPORT void f5_V_PSI_DDF(void* p0, struct S_DDF p1, int p2) { }
+EXPORT void f5_V_PSI_DDD(void* p0, struct S_DDD p1, int p2) { }
+EXPORT void f5_V_PSI_DDP(void* p0, struct S_DDP p1, int p2) { }
+EXPORT void f5_V_PSI_DPI(void* p0, struct S_DPI p1, int p2) { }
+EXPORT void f5_V_PSI_DPF(void* p0, struct S_DPF p1, int p2) { }
+EXPORT void f5_V_PSI_DPD(void* p0, struct S_DPD p1, int p2) { }
+EXPORT void f5_V_PSI_DPP(void* p0, struct S_DPP p1, int p2) { }
+EXPORT void f5_V_PSI_PII(void* p0, struct S_PII p1, int p2) { }
+EXPORT void f5_V_PSI_PIF(void* p0, struct S_PIF p1, int p2) { }
+EXPORT void f5_V_PSI_PID(void* p0, struct S_PID p1, int p2) { }
+EXPORT void f6_V_PSI_PIP(void* p0, struct S_PIP p1, int p2) { }
+EXPORT void f6_V_PSI_PFI(void* p0, struct S_PFI p1, int p2) { }
+EXPORT void f6_V_PSI_PFF(void* p0, struct S_PFF p1, int p2) { }
+EXPORT void f6_V_PSI_PFD(void* p0, struct S_PFD p1, int p2) { }
+EXPORT void f6_V_PSI_PFP(void* p0, struct S_PFP p1, int p2) { }
+EXPORT void f6_V_PSI_PDI(void* p0, struct S_PDI p1, int p2) { }
+EXPORT void f6_V_PSI_PDF(void* p0, struct S_PDF p1, int p2) { }
+EXPORT void f6_V_PSI_PDD(void* p0, struct S_PDD p1, int p2) { }
+EXPORT void f6_V_PSI_PDP(void* p0, struct S_PDP p1, int p2) { }
+EXPORT void f6_V_PSI_PPI(void* p0, struct S_PPI p1, int p2) { }
+EXPORT void f6_V_PSI_PPF(void* p0, struct S_PPF p1, int p2) { }
+EXPORT void f6_V_PSI_PPD(void* p0, struct S_PPD p1, int p2) { }
+EXPORT void f6_V_PSI_PPP(void* p0, struct S_PPP p1, int p2) { }
+EXPORT void f6_V_PSF_I(void* p0, struct S_I p1, float p2) { }
+EXPORT void f6_V_PSF_F(void* p0, struct S_F p1, float p2) { }
+EXPORT void f6_V_PSF_D(void* p0, struct S_D p1, float p2) { }
+EXPORT void f6_V_PSF_P(void* p0, struct S_P p1, float p2) { }
+EXPORT void f6_V_PSF_II(void* p0, struct S_II p1, float p2) { }
+EXPORT void f6_V_PSF_IF(void* p0, struct S_IF p1, float p2) { }
+EXPORT void f6_V_PSF_ID(void* p0, struct S_ID p1, float p2) { }
+EXPORT void f6_V_PSF_IP(void* p0, struct S_IP p1, float p2) { }
+EXPORT void f6_V_PSF_FI(void* p0, struct S_FI p1, float p2) { }
+EXPORT void f6_V_PSF_FF(void* p0, struct S_FF p1, float p2) { }
+EXPORT void f6_V_PSF_FD(void* p0, struct S_FD p1, float p2) { }
+EXPORT void f6_V_PSF_FP(void* p0, struct S_FP p1, float p2) { }
+EXPORT void f6_V_PSF_DI(void* p0, struct S_DI p1, float p2) { }
+EXPORT void f6_V_PSF_DF(void* p0, struct S_DF p1, float p2) { }
+EXPORT void f6_V_PSF_DD(void* p0, struct S_DD p1, float p2) { }
+EXPORT void f6_V_PSF_DP(void* p0, struct S_DP p1, float p2) { }
+EXPORT void f6_V_PSF_PI(void* p0, struct S_PI p1, float p2) { }
+EXPORT void f6_V_PSF_PF(void* p0, struct S_PF p1, float p2) { }
+EXPORT void f6_V_PSF_PD(void* p0, struct S_PD p1, float p2) { }
+EXPORT void f6_V_PSF_PP(void* p0, struct S_PP p1, float p2) { }
+EXPORT void f6_V_PSF_III(void* p0, struct S_III p1, float p2) { }
+EXPORT void f6_V_PSF_IIF(void* p0, struct S_IIF p1, float p2) { }
+EXPORT void f6_V_PSF_IID(void* p0, struct S_IID p1, float p2) { }
+EXPORT void f6_V_PSF_IIP(void* p0, struct S_IIP p1, float p2) { }
+EXPORT void f6_V_PSF_IFI(void* p0, struct S_IFI p1, float p2) { }
+EXPORT void f6_V_PSF_IFF(void* p0, struct S_IFF p1, float p2) { }
+EXPORT void f6_V_PSF_IFD(void* p0, struct S_IFD p1, float p2) { }
+EXPORT void f6_V_PSF_IFP(void* p0, struct S_IFP p1, float p2) { }
+EXPORT void f6_V_PSF_IDI(void* p0, struct S_IDI p1, float p2) { }
+EXPORT void f6_V_PSF_IDF(void* p0, struct S_IDF p1, float p2) { }
+EXPORT void f6_V_PSF_IDD(void* p0, struct S_IDD p1, float p2) { }
+EXPORT void f6_V_PSF_IDP(void* p0, struct S_IDP p1, float p2) { }
+EXPORT void f6_V_PSF_IPI(void* p0, struct S_IPI p1, float p2) { }
+EXPORT void f6_V_PSF_IPF(void* p0, struct S_IPF p1, float p2) { }
+EXPORT void f6_V_PSF_IPD(void* p0, struct S_IPD p1, float p2) { }
+EXPORT void f6_V_PSF_IPP(void* p0, struct S_IPP p1, float p2) { }
+EXPORT void f6_V_PSF_FII(void* p0, struct S_FII p1, float p2) { }
+EXPORT void f6_V_PSF_FIF(void* p0, struct S_FIF p1, float p2) { }
+EXPORT void f6_V_PSF_FID(void* p0, struct S_FID p1, float p2) { }
+EXPORT void f6_V_PSF_FIP(void* p0, struct S_FIP p1, float p2) { }
+EXPORT void f6_V_PSF_FFI(void* p0, struct S_FFI p1, float p2) { }
+EXPORT void f6_V_PSF_FFF(void* p0, struct S_FFF p1, float p2) { }
+EXPORT void f6_V_PSF_FFD(void* p0, struct S_FFD p1, float p2) { }
+EXPORT void f6_V_PSF_FFP(void* p0, struct S_FFP p1, float p2) { }
+EXPORT void f6_V_PSF_FDI(void* p0, struct S_FDI p1, float p2) { }
+EXPORT void f6_V_PSF_FDF(void* p0, struct S_FDF p1, float p2) { }
+EXPORT void f6_V_PSF_FDD(void* p0, struct S_FDD p1, float p2) { }
+EXPORT void f6_V_PSF_FDP(void* p0, struct S_FDP p1, float p2) { }
+EXPORT void f6_V_PSF_FPI(void* p0, struct S_FPI p1, float p2) { }
+EXPORT void f6_V_PSF_FPF(void* p0, struct S_FPF p1, float p2) { }
+EXPORT void f6_V_PSF_FPD(void* p0, struct S_FPD p1, float p2) { }
+EXPORT void f6_V_PSF_FPP(void* p0, struct S_FPP p1, float p2) { }
+EXPORT void f6_V_PSF_DII(void* p0, struct S_DII p1, float p2) { }
+EXPORT void f6_V_PSF_DIF(void* p0, struct S_DIF p1, float p2) { }
+EXPORT void f6_V_PSF_DID(void* p0, struct S_DID p1, float p2) { }
+EXPORT void f6_V_PSF_DIP(void* p0, struct S_DIP p1, float p2) { }
+EXPORT void f6_V_PSF_DFI(void* p0, struct S_DFI p1, float p2) { }
+EXPORT void f6_V_PSF_DFF(void* p0, struct S_DFF p1, float p2) { }
+EXPORT void f6_V_PSF_DFD(void* p0, struct S_DFD p1, float p2) { }
+EXPORT void f6_V_PSF_DFP(void* p0, struct S_DFP p1, float p2) { }
+EXPORT void f6_V_PSF_DDI(void* p0, struct S_DDI p1, float p2) { }
+EXPORT void f6_V_PSF_DDF(void* p0, struct S_DDF p1, float p2) { }
+EXPORT void f6_V_PSF_DDD(void* p0, struct S_DDD p1, float p2) { }
+EXPORT void f6_V_PSF_DDP(void* p0, struct S_DDP p1, float p2) { }
+EXPORT void f6_V_PSF_DPI(void* p0, struct S_DPI p1, float p2) { }
+EXPORT void f6_V_PSF_DPF(void* p0, struct S_DPF p1, float p2) { }
+EXPORT void f6_V_PSF_DPD(void* p0, struct S_DPD p1, float p2) { }
+EXPORT void f6_V_PSF_DPP(void* p0, struct S_DPP p1, float p2) { }
+EXPORT void f6_V_PSF_PII(void* p0, struct S_PII p1, float p2) { }
+EXPORT void f6_V_PSF_PIF(void* p0, struct S_PIF p1, float p2) { }
+EXPORT void f6_V_PSF_PID(void* p0, struct S_PID p1, float p2) { }
+EXPORT void f6_V_PSF_PIP(void* p0, struct S_PIP p1, float p2) { }
+EXPORT void f6_V_PSF_PFI(void* p0, struct S_PFI p1, float p2) { }
+EXPORT void f6_V_PSF_PFF(void* p0, struct S_PFF p1, float p2) { }
+EXPORT void f6_V_PSF_PFD(void* p0, struct S_PFD p1, float p2) { }
+EXPORT void f6_V_PSF_PFP(void* p0, struct S_PFP p1, float p2) { }
+EXPORT void f6_V_PSF_PDI(void* p0, struct S_PDI p1, float p2) { }
+EXPORT void f6_V_PSF_PDF(void* p0, struct S_PDF p1, float p2) { }
+EXPORT void f6_V_PSF_PDD(void* p0, struct S_PDD p1, float p2) { }
+EXPORT void f6_V_PSF_PDP(void* p0, struct S_PDP p1, float p2) { }
+EXPORT void f6_V_PSF_PPI(void* p0, struct S_PPI p1, float p2) { }
+EXPORT void f6_V_PSF_PPF(void* p0, struct S_PPF p1, float p2) { }
+EXPORT void f6_V_PSF_PPD(void* p0, struct S_PPD p1, float p2) { }
+EXPORT void f6_V_PSF_PPP(void* p0, struct S_PPP p1, float p2) { }
+EXPORT void f6_V_PSD_I(void* p0, struct S_I p1, double p2) { }
+EXPORT void f6_V_PSD_F(void* p0, struct S_F p1, double p2) { }
+EXPORT void f6_V_PSD_D(void* p0, struct S_D p1, double p2) { }
+EXPORT void f6_V_PSD_P(void* p0, struct S_P p1, double p2) { }
+EXPORT void f6_V_PSD_II(void* p0, struct S_II p1, double p2) { }
+EXPORT void f6_V_PSD_IF(void* p0, struct S_IF p1, double p2) { }
+EXPORT void f6_V_PSD_ID(void* p0, struct S_ID p1, double p2) { }
+EXPORT void f6_V_PSD_IP(void* p0, struct S_IP p1, double p2) { }
+EXPORT void f6_V_PSD_FI(void* p0, struct S_FI p1, double p2) { }
+EXPORT void f6_V_PSD_FF(void* p0, struct S_FF p1, double p2) { }
+EXPORT void f6_V_PSD_FD(void* p0, struct S_FD p1, double p2) { }
+EXPORT void f6_V_PSD_FP(void* p0, struct S_FP p1, double p2) { }
+EXPORT void f6_V_PSD_DI(void* p0, struct S_DI p1, double p2) { }
+EXPORT void f6_V_PSD_DF(void* p0, struct S_DF p1, double p2) { }
+EXPORT void f6_V_PSD_DD(void* p0, struct S_DD p1, double p2) { }
+EXPORT void f6_V_PSD_DP(void* p0, struct S_DP p1, double p2) { }
+EXPORT void f6_V_PSD_PI(void* p0, struct S_PI p1, double p2) { }
+EXPORT void f6_V_PSD_PF(void* p0, struct S_PF p1, double p2) { }
+EXPORT void f6_V_PSD_PD(void* p0, struct S_PD p1, double p2) { }
+EXPORT void f6_V_PSD_PP(void* p0, struct S_PP p1, double p2) { }
+EXPORT void f6_V_PSD_III(void* p0, struct S_III p1, double p2) { }
+EXPORT void f6_V_PSD_IIF(void* p0, struct S_IIF p1, double p2) { }
+EXPORT void f6_V_PSD_IID(void* p0, struct S_IID p1, double p2) { }
+EXPORT void f6_V_PSD_IIP(void* p0, struct S_IIP p1, double p2) { }
+EXPORT void f6_V_PSD_IFI(void* p0, struct S_IFI p1, double p2) { }
+EXPORT void f6_V_PSD_IFF(void* p0, struct S_IFF p1, double p2) { }
+EXPORT void f6_V_PSD_IFD(void* p0, struct S_IFD p1, double p2) { }
+EXPORT void f6_V_PSD_IFP(void* p0, struct S_IFP p1, double p2) { }
+EXPORT void f6_V_PSD_IDI(void* p0, struct S_IDI p1, double p2) { }
+EXPORT void f6_V_PSD_IDF(void* p0, struct S_IDF p1, double p2) { }
+EXPORT void f6_V_PSD_IDD(void* p0, struct S_IDD p1, double p2) { }
+EXPORT void f6_V_PSD_IDP(void* p0, struct S_IDP p1, double p2) { }
+EXPORT void f6_V_PSD_IPI(void* p0, struct S_IPI p1, double p2) { }
+EXPORT void f6_V_PSD_IPF(void* p0, struct S_IPF p1, double p2) { }
+EXPORT void f6_V_PSD_IPD(void* p0, struct S_IPD p1, double p2) { }
+EXPORT void f6_V_PSD_IPP(void* p0, struct S_IPP p1, double p2) { }
+EXPORT void f6_V_PSD_FII(void* p0, struct S_FII p1, double p2) { }
+EXPORT void f6_V_PSD_FIF(void* p0, struct S_FIF p1, double p2) { }
+EXPORT void f6_V_PSD_FID(void* p0, struct S_FID p1, double p2) { }
+EXPORT void f6_V_PSD_FIP(void* p0, struct S_FIP p1, double p2) { }
+EXPORT void f6_V_PSD_FFI(void* p0, struct S_FFI p1, double p2) { }
+EXPORT void f6_V_PSD_FFF(void* p0, struct S_FFF p1, double p2) { }
+EXPORT void f6_V_PSD_FFD(void* p0, struct S_FFD p1, double p2) { }
+EXPORT void f6_V_PSD_FFP(void* p0, struct S_FFP p1, double p2) { }
+EXPORT void f6_V_PSD_FDI(void* p0, struct S_FDI p1, double p2) { }
+EXPORT void f6_V_PSD_FDF(void* p0, struct S_FDF p1, double p2) { }
+EXPORT void f6_V_PSD_FDD(void* p0, struct S_FDD p1, double p2) { }
+EXPORT void f6_V_PSD_FDP(void* p0, struct S_FDP p1, double p2) { }
+EXPORT void f6_V_PSD_FPI(void* p0, struct S_FPI p1, double p2) { }
+EXPORT void f6_V_PSD_FPF(void* p0, struct S_FPF p1, double p2) { }
+EXPORT void f6_V_PSD_FPD(void* p0, struct S_FPD p1, double p2) { }
+EXPORT void f6_V_PSD_FPP(void* p0, struct S_FPP p1, double p2) { }
+EXPORT void f6_V_PSD_DII(void* p0, struct S_DII p1, double p2) { }
+EXPORT void f6_V_PSD_DIF(void* p0, struct S_DIF p1, double p2) { }
+EXPORT void f6_V_PSD_DID(void* p0, struct S_DID p1, double p2) { }
+EXPORT void f6_V_PSD_DIP(void* p0, struct S_DIP p1, double p2) { }
+EXPORT void f6_V_PSD_DFI(void* p0, struct S_DFI p1, double p2) { }
+EXPORT void f6_V_PSD_DFF(void* p0, struct S_DFF p1, double p2) { }
+EXPORT void f6_V_PSD_DFD(void* p0, struct S_DFD p1, double p2) { }
+EXPORT void f6_V_PSD_DFP(void* p0, struct S_DFP p1, double p2) { }
+EXPORT void f6_V_PSD_DDI(void* p0, struct S_DDI p1, double p2) { }
+EXPORT void f6_V_PSD_DDF(void* p0, struct S_DDF p1, double p2) { }
+EXPORT void f6_V_PSD_DDD(void* p0, struct S_DDD p1, double p2) { }
+EXPORT void f6_V_PSD_DDP(void* p0, struct S_DDP p1, double p2) { }
+EXPORT void f6_V_PSD_DPI(void* p0, struct S_DPI p1, double p2) { }
+EXPORT void f6_V_PSD_DPF(void* p0, struct S_DPF p1, double p2) { }
+EXPORT void f6_V_PSD_DPD(void* p0, struct S_DPD p1, double p2) { }
+EXPORT void f6_V_PSD_DPP(void* p0, struct S_DPP p1, double p2) { }
+EXPORT void f6_V_PSD_PII(void* p0, struct S_PII p1, double p2) { }
+EXPORT void f6_V_PSD_PIF(void* p0, struct S_PIF p1, double p2) { }
+EXPORT void f6_V_PSD_PID(void* p0, struct S_PID p1, double p2) { }
+EXPORT void f6_V_PSD_PIP(void* p0, struct S_PIP p1, double p2) { }
+EXPORT void f6_V_PSD_PFI(void* p0, struct S_PFI p1, double p2) { }
+EXPORT void f6_V_PSD_PFF(void* p0, struct S_PFF p1, double p2) { }
+EXPORT void f6_V_PSD_PFD(void* p0, struct S_PFD p1, double p2) { }
+EXPORT void f6_V_PSD_PFP(void* p0, struct S_PFP p1, double p2) { }
+EXPORT void f6_V_PSD_PDI(void* p0, struct S_PDI p1, double p2) { }
+EXPORT void f6_V_PSD_PDF(void* p0, struct S_PDF p1, double p2) { }
+EXPORT void f6_V_PSD_PDD(void* p0, struct S_PDD p1, double p2) { }
+EXPORT void f6_V_PSD_PDP(void* p0, struct S_PDP p1, double p2) { }
+EXPORT void f6_V_PSD_PPI(void* p0, struct S_PPI p1, double p2) { }
+EXPORT void f6_V_PSD_PPF(void* p0, struct S_PPF p1, double p2) { }
+EXPORT void f6_V_PSD_PPD(void* p0, struct S_PPD p1, double p2) { }
+EXPORT void f6_V_PSD_PPP(void* p0, struct S_PPP p1, double p2) { }
+EXPORT void f6_V_PSP_I(void* p0, struct S_I p1, void* p2) { }
+EXPORT void f6_V_PSP_F(void* p0, struct S_F p1, void* p2) { }
+EXPORT void f6_V_PSP_D(void* p0, struct S_D p1, void* p2) { }
+EXPORT void f6_V_PSP_P(void* p0, struct S_P p1, void* p2) { }
+EXPORT void f6_V_PSP_II(void* p0, struct S_II p1, void* p2) { }
+EXPORT void f6_V_PSP_IF(void* p0, struct S_IF p1, void* p2) { }
+EXPORT void f6_V_PSP_ID(void* p0, struct S_ID p1, void* p2) { }
+EXPORT void f6_V_PSP_IP(void* p0, struct S_IP p1, void* p2) { }
+EXPORT void f6_V_PSP_FI(void* p0, struct S_FI p1, void* p2) { }
+EXPORT void f6_V_PSP_FF(void* p0, struct S_FF p1, void* p2) { }
+EXPORT void f6_V_PSP_FD(void* p0, struct S_FD p1, void* p2) { }
+EXPORT void f6_V_PSP_FP(void* p0, struct S_FP p1, void* p2) { }
+EXPORT void f6_V_PSP_DI(void* p0, struct S_DI p1, void* p2) { }
+EXPORT void f6_V_PSP_DF(void* p0, struct S_DF p1, void* p2) { }
+EXPORT void f6_V_PSP_DD(void* p0, struct S_DD p1, void* p2) { }
+EXPORT void f6_V_PSP_DP(void* p0, struct S_DP p1, void* p2) { }
+EXPORT void f6_V_PSP_PI(void* p0, struct S_PI p1, void* p2) { }
+EXPORT void f6_V_PSP_PF(void* p0, struct S_PF p1, void* p2) { }
+EXPORT void f6_V_PSP_PD(void* p0, struct S_PD p1, void* p2) { }
+EXPORT void f6_V_PSP_PP(void* p0, struct S_PP p1, void* p2) { }
+EXPORT void f6_V_PSP_III(void* p0, struct S_III p1, void* p2) { }
+EXPORT void f6_V_PSP_IIF(void* p0, struct S_IIF p1, void* p2) { }
+EXPORT void f6_V_PSP_IID(void* p0, struct S_IID p1, void* p2) { }
+EXPORT void f6_V_PSP_IIP(void* p0, struct S_IIP p1, void* p2) { }
+EXPORT void f6_V_PSP_IFI(void* p0, struct S_IFI p1, void* p2) { }
+EXPORT void f6_V_PSP_IFF(void* p0, struct S_IFF p1, void* p2) { }
+EXPORT void f6_V_PSP_IFD(void* p0, struct S_IFD p1, void* p2) { }
+EXPORT void f6_V_PSP_IFP(void* p0, struct S_IFP p1, void* p2) { }
+EXPORT void f6_V_PSP_IDI(void* p0, struct S_IDI p1, void* p2) { }
+EXPORT void f6_V_PSP_IDF(void* p0, struct S_IDF p1, void* p2) { }
+EXPORT void f6_V_PSP_IDD(void* p0, struct S_IDD p1, void* p2) { }
+EXPORT void f6_V_PSP_IDP(void* p0, struct S_IDP p1, void* p2) { }
+EXPORT void f6_V_PSP_IPI(void* p0, struct S_IPI p1, void* p2) { }
+EXPORT void f6_V_PSP_IPF(void* p0, struct S_IPF p1, void* p2) { }
+EXPORT void f6_V_PSP_IPD(void* p0, struct S_IPD p1, void* p2) { }
+EXPORT void f6_V_PSP_IPP(void* p0, struct S_IPP p1, void* p2) { }
+EXPORT void f6_V_PSP_FII(void* p0, struct S_FII p1, void* p2) { }
+EXPORT void f6_V_PSP_FIF(void* p0, struct S_FIF p1, void* p2) { }
+EXPORT void f6_V_PSP_FID(void* p0, struct S_FID p1, void* p2) { }
+EXPORT void f6_V_PSP_FIP(void* p0, struct S_FIP p1, void* p2) { }
+EXPORT void f6_V_PSP_FFI(void* p0, struct S_FFI p1, void* p2) { }
+EXPORT void f6_V_PSP_FFF(void* p0, struct S_FFF p1, void* p2) { }
+EXPORT void f6_V_PSP_FFD(void* p0, struct S_FFD p1, void* p2) { }
+EXPORT void f6_V_PSP_FFP(void* p0, struct S_FFP p1, void* p2) { }
+EXPORT void f6_V_PSP_FDI(void* p0, struct S_FDI p1, void* p2) { }
+EXPORT void f6_V_PSP_FDF(void* p0, struct S_FDF p1, void* p2) { }
+EXPORT void f6_V_PSP_FDD(void* p0, struct S_FDD p1, void* p2) { }
+EXPORT void f6_V_PSP_FDP(void* p0, struct S_FDP p1, void* p2) { }
+EXPORT void f6_V_PSP_FPI(void* p0, struct S_FPI p1, void* p2) { }
+EXPORT void f6_V_PSP_FPF(void* p0, struct S_FPF p1, void* p2) { }
+EXPORT void f6_V_PSP_FPD(void* p0, struct S_FPD p1, void* p2) { }
+EXPORT void f6_V_PSP_FPP(void* p0, struct S_FPP p1, void* p2) { }
+EXPORT void f6_V_PSP_DII(void* p0, struct S_DII p1, void* p2) { }
+EXPORT void f6_V_PSP_DIF(void* p0, struct S_DIF p1, void* p2) { }
+EXPORT void f6_V_PSP_DID(void* p0, struct S_DID p1, void* p2) { }
+EXPORT void f6_V_PSP_DIP(void* p0, struct S_DIP p1, void* p2) { }
+EXPORT void f6_V_PSP_DFI(void* p0, struct S_DFI p1, void* p2) { }
+EXPORT void f6_V_PSP_DFF(void* p0, struct S_DFF p1, void* p2) { }
+EXPORT void f6_V_PSP_DFD(void* p0, struct S_DFD p1, void* p2) { }
+EXPORT void f6_V_PSP_DFP(void* p0, struct S_DFP p1, void* p2) { }
+EXPORT void f6_V_PSP_DDI(void* p0, struct S_DDI p1, void* p2) { }
+EXPORT void f6_V_PSP_DDF(void* p0, struct S_DDF p1, void* p2) { }
+EXPORT void f6_V_PSP_DDD(void* p0, struct S_DDD p1, void* p2) { }
+EXPORT void f6_V_PSP_DDP(void* p0, struct S_DDP p1, void* p2) { }
+EXPORT void f6_V_PSP_DPI(void* p0, struct S_DPI p1, void* p2) { }
+EXPORT void f6_V_PSP_DPF(void* p0, struct S_DPF p1, void* p2) { }
+EXPORT void f6_V_PSP_DPD(void* p0, struct S_DPD p1, void* p2) { }
+EXPORT void f6_V_PSP_DPP(void* p0, struct S_DPP p1, void* p2) { }
+EXPORT void f6_V_PSP_PII(void* p0, struct S_PII p1, void* p2) { }
+EXPORT void f6_V_PSP_PIF(void* p0, struct S_PIF p1, void* p2) { }
+EXPORT void f6_V_PSP_PID(void* p0, struct S_PID p1, void* p2) { }
+EXPORT void f6_V_PSP_PIP(void* p0, struct S_PIP p1, void* p2) { }
+EXPORT void f6_V_PSP_PFI(void* p0, struct S_PFI p1, void* p2) { }
+EXPORT void f6_V_PSP_PFF(void* p0, struct S_PFF p1, void* p2) { }
+EXPORT void f6_V_PSP_PFD(void* p0, struct S_PFD p1, void* p2) { }
+EXPORT void f6_V_PSP_PFP(void* p0, struct S_PFP p1, void* p2) { }
+EXPORT void f6_V_PSP_PDI(void* p0, struct S_PDI p1, void* p2) { }
+EXPORT void f6_V_PSP_PDF(void* p0, struct S_PDF p1, void* p2) { }
+EXPORT void f6_V_PSP_PDD(void* p0, struct S_PDD p1, void* p2) { }
+EXPORT void f6_V_PSP_PDP(void* p0, struct S_PDP p1, void* p2) { }
+EXPORT void f6_V_PSP_PPI(void* p0, struct S_PPI p1, void* p2) { }
+EXPORT void f6_V_PSP_PPF(void* p0, struct S_PPF p1, void* p2) { }
+EXPORT void f6_V_PSP_PPD(void* p0, struct S_PPD p1, void* p2) { }
+EXPORT void f6_V_PSP_PPP(void* p0, struct S_PPP p1, void* p2) { }
+EXPORT void f6_V_PSS_I(void* p0, struct S_I p1, struct S_I p2) { }
+EXPORT void f6_V_PSS_F(void* p0, struct S_F p1, struct S_F p2) { }
+EXPORT void f6_V_PSS_D(void* p0, struct S_D p1, struct S_D p2) { }
+EXPORT void f6_V_PSS_P(void* p0, struct S_P p1, struct S_P p2) { }
+EXPORT void f6_V_PSS_II(void* p0, struct S_II p1, struct S_II p2) { }
+EXPORT void f6_V_PSS_IF(void* p0, struct S_IF p1, struct S_IF p2) { }
+EXPORT void f6_V_PSS_ID(void* p0, struct S_ID p1, struct S_ID p2) { }
+EXPORT void f6_V_PSS_IP(void* p0, struct S_IP p1, struct S_IP p2) { }
+EXPORT void f6_V_PSS_FI(void* p0, struct S_FI p1, struct S_FI p2) { }
+EXPORT void f6_V_PSS_FF(void* p0, struct S_FF p1, struct S_FF p2) { }
+EXPORT void f6_V_PSS_FD(void* p0, struct S_FD p1, struct S_FD p2) { }
+EXPORT void f6_V_PSS_FP(void* p0, struct S_FP p1, struct S_FP p2) { }
+EXPORT void f6_V_PSS_DI(void* p0, struct S_DI p1, struct S_DI p2) { }
+EXPORT void f6_V_PSS_DF(void* p0, struct S_DF p1, struct S_DF p2) { }
+EXPORT void f6_V_PSS_DD(void* p0, struct S_DD p1, struct S_DD p2) { }
+EXPORT void f6_V_PSS_DP(void* p0, struct S_DP p1, struct S_DP p2) { }
+EXPORT void f6_V_PSS_PI(void* p0, struct S_PI p1, struct S_PI p2) { }
+EXPORT void f6_V_PSS_PF(void* p0, struct S_PF p1, struct S_PF p2) { }
+EXPORT void f6_V_PSS_PD(void* p0, struct S_PD p1, struct S_PD p2) { }
+EXPORT void f6_V_PSS_PP(void* p0, struct S_PP p1, struct S_PP p2) { }
+EXPORT void f6_V_PSS_III(void* p0, struct S_III p1, struct S_III p2) { }
+EXPORT void f6_V_PSS_IIF(void* p0, struct S_IIF p1, struct S_IIF p2) { }
+EXPORT void f6_V_PSS_IID(void* p0, struct S_IID p1, struct S_IID p2) { }
+EXPORT void f6_V_PSS_IIP(void* p0, struct S_IIP p1, struct S_IIP p2) { }
+EXPORT void f6_V_PSS_IFI(void* p0, struct S_IFI p1, struct S_IFI p2) { }
+EXPORT void f6_V_PSS_IFF(void* p0, struct S_IFF p1, struct S_IFF p2) { }
+EXPORT void f6_V_PSS_IFD(void* p0, struct S_IFD p1, struct S_IFD p2) { }
+EXPORT void f6_V_PSS_IFP(void* p0, struct S_IFP p1, struct S_IFP p2) { }
+EXPORT void f6_V_PSS_IDI(void* p0, struct S_IDI p1, struct S_IDI p2) { }
+EXPORT void f6_V_PSS_IDF(void* p0, struct S_IDF p1, struct S_IDF p2) { }
+EXPORT void f6_V_PSS_IDD(void* p0, struct S_IDD p1, struct S_IDD p2) { }
+EXPORT void f6_V_PSS_IDP(void* p0, struct S_IDP p1, struct S_IDP p2) { }
+EXPORT void f6_V_PSS_IPI(void* p0, struct S_IPI p1, struct S_IPI p2) { }
+EXPORT void f6_V_PSS_IPF(void* p0, struct S_IPF p1, struct S_IPF p2) { }
+EXPORT void f6_V_PSS_IPD(void* p0, struct S_IPD p1, struct S_IPD p2) { }
+EXPORT void f6_V_PSS_IPP(void* p0, struct S_IPP p1, struct S_IPP p2) { }
+EXPORT void f6_V_PSS_FII(void* p0, struct S_FII p1, struct S_FII p2) { }
+EXPORT void f6_V_PSS_FIF(void* p0, struct S_FIF p1, struct S_FIF p2) { }
+EXPORT void f6_V_PSS_FID(void* p0, struct S_FID p1, struct S_FID p2) { }
+EXPORT void f6_V_PSS_FIP(void* p0, struct S_FIP p1, struct S_FIP p2) { }
+EXPORT void f6_V_PSS_FFI(void* p0, struct S_FFI p1, struct S_FFI p2) { }
+EXPORT void f6_V_PSS_FFF(void* p0, struct S_FFF p1, struct S_FFF p2) { }
+EXPORT void f6_V_PSS_FFD(void* p0, struct S_FFD p1, struct S_FFD p2) { }
+EXPORT void f6_V_PSS_FFP(void* p0, struct S_FFP p1, struct S_FFP p2) { }
+EXPORT void f6_V_PSS_FDI(void* p0, struct S_FDI p1, struct S_FDI p2) { }
+EXPORT void f6_V_PSS_FDF(void* p0, struct S_FDF p1, struct S_FDF p2) { }
+EXPORT void f6_V_PSS_FDD(void* p0, struct S_FDD p1, struct S_FDD p2) { }
+EXPORT void f6_V_PSS_FDP(void* p0, struct S_FDP p1, struct S_FDP p2) { }
+EXPORT void f6_V_PSS_FPI(void* p0, struct S_FPI p1, struct S_FPI p2) { }
+EXPORT void f6_V_PSS_FPF(void* p0, struct S_FPF p1, struct S_FPF p2) { }
+EXPORT void f6_V_PSS_FPD(void* p0, struct S_FPD p1, struct S_FPD p2) { }
+EXPORT void f6_V_PSS_FPP(void* p0, struct S_FPP p1, struct S_FPP p2) { }
+EXPORT void f6_V_PSS_DII(void* p0, struct S_DII p1, struct S_DII p2) { }
+EXPORT void f6_V_PSS_DIF(void* p0, struct S_DIF p1, struct S_DIF p2) { }
+EXPORT void f6_V_PSS_DID(void* p0, struct S_DID p1, struct S_DID p2) { }
+EXPORT void f6_V_PSS_DIP(void* p0, struct S_DIP p1, struct S_DIP p2) { }
+EXPORT void f6_V_PSS_DFI(void* p0, struct S_DFI p1, struct S_DFI p2) { }
+EXPORT void f6_V_PSS_DFF(void* p0, struct S_DFF p1, struct S_DFF p2) { }
+EXPORT void f6_V_PSS_DFD(void* p0, struct S_DFD p1, struct S_DFD p2) { }
+EXPORT void f6_V_PSS_DFP(void* p0, struct S_DFP p1, struct S_DFP p2) { }
+EXPORT void f6_V_PSS_DDI(void* p0, struct S_DDI p1, struct S_DDI p2) { }
+EXPORT void f6_V_PSS_DDF(void* p0, struct S_DDF p1, struct S_DDF p2) { }
+EXPORT void f6_V_PSS_DDD(void* p0, struct S_DDD p1, struct S_DDD p2) { }
+EXPORT void f6_V_PSS_DDP(void* p0, struct S_DDP p1, struct S_DDP p2) { }
+EXPORT void f6_V_PSS_DPI(void* p0, struct S_DPI p1, struct S_DPI p2) { }
+EXPORT void f6_V_PSS_DPF(void* p0, struct S_DPF p1, struct S_DPF p2) { }
+EXPORT void f6_V_PSS_DPD(void* p0, struct S_DPD p1, struct S_DPD p2) { }
+EXPORT void f6_V_PSS_DPP(void* p0, struct S_DPP p1, struct S_DPP p2) { }
+EXPORT void f6_V_PSS_PII(void* p0, struct S_PII p1, struct S_PII p2) { }
+EXPORT void f6_V_PSS_PIF(void* p0, struct S_PIF p1, struct S_PIF p2) { }
+EXPORT void f6_V_PSS_PID(void* p0, struct S_PID p1, struct S_PID p2) { }
+EXPORT void f6_V_PSS_PIP(void* p0, struct S_PIP p1, struct S_PIP p2) { }
+EXPORT void f6_V_PSS_PFI(void* p0, struct S_PFI p1, struct S_PFI p2) { }
+EXPORT void f6_V_PSS_PFF(void* p0, struct S_PFF p1, struct S_PFF p2) { }
+EXPORT void f6_V_PSS_PFD(void* p0, struct S_PFD p1, struct S_PFD p2) { }
+EXPORT void f6_V_PSS_PFP(void* p0, struct S_PFP p1, struct S_PFP p2) { }
+EXPORT void f6_V_PSS_PDI(void* p0, struct S_PDI p1, struct S_PDI p2) { }
+EXPORT void f6_V_PSS_PDF(void* p0, struct S_PDF p1, struct S_PDF p2) { }
+EXPORT void f6_V_PSS_PDD(void* p0, struct S_PDD p1, struct S_PDD p2) { }
+EXPORT void f6_V_PSS_PDP(void* p0, struct S_PDP p1, struct S_PDP p2) { }
+EXPORT void f6_V_PSS_PPI(void* p0, struct S_PPI p1, struct S_PPI p2) { }
+EXPORT void f6_V_PSS_PPF(void* p0, struct S_PPF p1, struct S_PPF p2) { }
+EXPORT void f6_V_PSS_PPD(void* p0, struct S_PPD p1, struct S_PPD p2) { }
+EXPORT void f6_V_PSS_PPP(void* p0, struct S_PPP p1, struct S_PPP p2) { }
+EXPORT void f6_V_SII_I(struct S_I p0, int p1, int p2) { }
+EXPORT void f6_V_SII_F(struct S_F p0, int p1, int p2) { }
+EXPORT void f6_V_SII_D(struct S_D p0, int p1, int p2) { }
+EXPORT void f6_V_SII_P(struct S_P p0, int p1, int p2) { }
+EXPORT void f6_V_SII_II(struct S_II p0, int p1, int p2) { }
+EXPORT void f6_V_SII_IF(struct S_IF p0, int p1, int p2) { }
+EXPORT void f6_V_SII_ID(struct S_ID p0, int p1, int p2) { }
+EXPORT void f6_V_SII_IP(struct S_IP p0, int p1, int p2) { }
+EXPORT void f6_V_SII_FI(struct S_FI p0, int p1, int p2) { }
+EXPORT void f6_V_SII_FF(struct S_FF p0, int p1, int p2) { }
+EXPORT void f6_V_SII_FD(struct S_FD p0, int p1, int p2) { }
+EXPORT void f6_V_SII_FP(struct S_FP p0, int p1, int p2) { }
+EXPORT void f6_V_SII_DI(struct S_DI p0, int p1, int p2) { }
+EXPORT void f6_V_SII_DF(struct S_DF p0, int p1, int p2) { }
+EXPORT void f6_V_SII_DD(struct S_DD p0, int p1, int p2) { }
+EXPORT void f6_V_SII_DP(struct S_DP p0, int p1, int p2) { }
+EXPORT void f6_V_SII_PI(struct S_PI p0, int p1, int p2) { }
+EXPORT void f6_V_SII_PF(struct S_PF p0, int p1, int p2) { }
+EXPORT void f6_V_SII_PD(struct S_PD p0, int p1, int p2) { }
+EXPORT void f6_V_SII_PP(struct S_PP p0, int p1, int p2) { }
+EXPORT void f6_V_SII_III(struct S_III p0, int p1, int p2) { }
+EXPORT void f6_V_SII_IIF(struct S_IIF p0, int p1, int p2) { }
+EXPORT void f6_V_SII_IID(struct S_IID p0, int p1, int p2) { }
+EXPORT void f6_V_SII_IIP(struct S_IIP p0, int p1, int p2) { }
+EXPORT void f6_V_SII_IFI(struct S_IFI p0, int p1, int p2) { }
+EXPORT void f6_V_SII_IFF(struct S_IFF p0, int p1, int p2) { }
+EXPORT void f6_V_SII_IFD(struct S_IFD p0, int p1, int p2) { }
+EXPORT void f6_V_SII_IFP(struct S_IFP p0, int p1, int p2) { }
+EXPORT void f6_V_SII_IDI(struct S_IDI p0, int p1, int p2) { }
+EXPORT void f6_V_SII_IDF(struct S_IDF p0, int p1, int p2) { }
+EXPORT void f6_V_SII_IDD(struct S_IDD p0, int p1, int p2) { }
+EXPORT void f6_V_SII_IDP(struct S_IDP p0, int p1, int p2) { }
+EXPORT void f6_V_SII_IPI(struct S_IPI p0, int p1, int p2) { }
+EXPORT void f6_V_SII_IPF(struct S_IPF p0, int p1, int p2) { }
+EXPORT void f6_V_SII_IPD(struct S_IPD p0, int p1, int p2) { }
+EXPORT void f6_V_SII_IPP(struct S_IPP p0, int p1, int p2) { }
+EXPORT void f6_V_SII_FII(struct S_FII p0, int p1, int p2) { }
+EXPORT void f6_V_SII_FIF(struct S_FIF p0, int p1, int p2) { }
+EXPORT void f6_V_SII_FID(struct S_FID p0, int p1, int p2) { }
+EXPORT void f6_V_SII_FIP(struct S_FIP p0, int p1, int p2) { }
+EXPORT void f6_V_SII_FFI(struct S_FFI p0, int p1, int p2) { }
+EXPORT void f6_V_SII_FFF(struct S_FFF p0, int p1, int p2) { }
+EXPORT void f6_V_SII_FFD(struct S_FFD p0, int p1, int p2) { }
+EXPORT void f6_V_SII_FFP(struct S_FFP p0, int p1, int p2) { }
+EXPORT void f6_V_SII_FDI(struct S_FDI p0, int p1, int p2) { }
+EXPORT void f6_V_SII_FDF(struct S_FDF p0, int p1, int p2) { }
+EXPORT void f6_V_SII_FDD(struct S_FDD p0, int p1, int p2) { }
+EXPORT void f6_V_SII_FDP(struct S_FDP p0, int p1, int p2) { }
+EXPORT void f6_V_SII_FPI(struct S_FPI p0, int p1, int p2) { }
+EXPORT void f6_V_SII_FPF(struct S_FPF p0, int p1, int p2) { }
+EXPORT void f6_V_SII_FPD(struct S_FPD p0, int p1, int p2) { }
+EXPORT void f6_V_SII_FPP(struct S_FPP p0, int p1, int p2) { }
+EXPORT void f6_V_SII_DII(struct S_DII p0, int p1, int p2) { }
+EXPORT void f6_V_SII_DIF(struct S_DIF p0, int p1, int p2) { }
+EXPORT void f6_V_SII_DID(struct S_DID p0, int p1, int p2) { }
+EXPORT void f6_V_SII_DIP(struct S_DIP p0, int p1, int p2) { }
+EXPORT void f6_V_SII_DFI(struct S_DFI p0, int p1, int p2) { }
+EXPORT void f6_V_SII_DFF(struct S_DFF p0, int p1, int p2) { }
+EXPORT void f6_V_SII_DFD(struct S_DFD p0, int p1, int p2) { }
+EXPORT void f6_V_SII_DFP(struct S_DFP p0, int p1, int p2) { }
+EXPORT void f6_V_SII_DDI(struct S_DDI p0, int p1, int p2) { }
+EXPORT void f6_V_SII_DDF(struct S_DDF p0, int p1, int p2) { }
+EXPORT void f6_V_SII_DDD(struct S_DDD p0, int p1, int p2) { }
+EXPORT void f6_V_SII_DDP(struct S_DDP p0, int p1, int p2) { }
+EXPORT void f6_V_SII_DPI(struct S_DPI p0, int p1, int p2) { }
+EXPORT void f6_V_SII_DPF(struct S_DPF p0, int p1, int p2) { }
+EXPORT void f6_V_SII_DPD(struct S_DPD p0, int p1, int p2) { }
+EXPORT void f6_V_SII_DPP(struct S_DPP p0, int p1, int p2) { }
+EXPORT void f6_V_SII_PII(struct S_PII p0, int p1, int p2) { }
+EXPORT void f6_V_SII_PIF(struct S_PIF p0, int p1, int p2) { }
+EXPORT void f6_V_SII_PID(struct S_PID p0, int p1, int p2) { }
+EXPORT void f6_V_SII_PIP(struct S_PIP p0, int p1, int p2) { }
+EXPORT void f6_V_SII_PFI(struct S_PFI p0, int p1, int p2) { }
+EXPORT void f6_V_SII_PFF(struct S_PFF p0, int p1, int p2) { }
+EXPORT void f6_V_SII_PFD(struct S_PFD p0, int p1, int p2) { }
+EXPORT void f6_V_SII_PFP(struct S_PFP p0, int p1, int p2) { }
+EXPORT void f6_V_SII_PDI(struct S_PDI p0, int p1, int p2) { }
+EXPORT void f6_V_SII_PDF(struct S_PDF p0, int p1, int p2) { }
+EXPORT void f6_V_SII_PDD(struct S_PDD p0, int p1, int p2) { }
+EXPORT void f6_V_SII_PDP(struct S_PDP p0, int p1, int p2) { }
+EXPORT void f6_V_SII_PPI(struct S_PPI p0, int p1, int p2) { }
+EXPORT void f6_V_SII_PPF(struct S_PPF p0, int p1, int p2) { }
+EXPORT void f6_V_SII_PPD(struct S_PPD p0, int p1, int p2) { }
+EXPORT void f6_V_SII_PPP(struct S_PPP p0, int p1, int p2) { }
+EXPORT void f6_V_SIF_I(struct S_I p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_F(struct S_F p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_D(struct S_D p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_P(struct S_P p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_II(struct S_II p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_IF(struct S_IF p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_ID(struct S_ID p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_IP(struct S_IP p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_FI(struct S_FI p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_FF(struct S_FF p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_FD(struct S_FD p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_FP(struct S_FP p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_DI(struct S_DI p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_DF(struct S_DF p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_DD(struct S_DD p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_DP(struct S_DP p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_PI(struct S_PI p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_PF(struct S_PF p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_PD(struct S_PD p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_PP(struct S_PP p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_III(struct S_III p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_IIF(struct S_IIF p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_IID(struct S_IID p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_IIP(struct S_IIP p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_IFI(struct S_IFI p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_IFF(struct S_IFF p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_IFD(struct S_IFD p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_IFP(struct S_IFP p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_IDI(struct S_IDI p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_IDF(struct S_IDF p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_IDD(struct S_IDD p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_IDP(struct S_IDP p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_IPI(struct S_IPI p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_IPF(struct S_IPF p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_IPD(struct S_IPD p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_IPP(struct S_IPP p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_FII(struct S_FII p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_FIF(struct S_FIF p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_FID(struct S_FID p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_FIP(struct S_FIP p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_FFI(struct S_FFI p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_FFF(struct S_FFF p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_FFD(struct S_FFD p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_FFP(struct S_FFP p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_FDI(struct S_FDI p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_FDF(struct S_FDF p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_FDD(struct S_FDD p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_FDP(struct S_FDP p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_FPI(struct S_FPI p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_FPF(struct S_FPF p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_FPD(struct S_FPD p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_FPP(struct S_FPP p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_DII(struct S_DII p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_DIF(struct S_DIF p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_DID(struct S_DID p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_DIP(struct S_DIP p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_DFI(struct S_DFI p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_DFF(struct S_DFF p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_DFD(struct S_DFD p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_DFP(struct S_DFP p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_DDI(struct S_DDI p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_DDF(struct S_DDF p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_DDD(struct S_DDD p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_DDP(struct S_DDP p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_DPI(struct S_DPI p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_DPF(struct S_DPF p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_DPD(struct S_DPD p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_DPP(struct S_DPP p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_PII(struct S_PII p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_PIF(struct S_PIF p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_PID(struct S_PID p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_PIP(struct S_PIP p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_PFI(struct S_PFI p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_PFF(struct S_PFF p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_PFD(struct S_PFD p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_PFP(struct S_PFP p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_PDI(struct S_PDI p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_PDF(struct S_PDF p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_PDD(struct S_PDD p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_PDP(struct S_PDP p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_PPI(struct S_PPI p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_PPF(struct S_PPF p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_PPD(struct S_PPD p0, int p1, float p2) { }
+EXPORT void f6_V_SIF_PPP(struct S_PPP p0, int p1, float p2) { }
+EXPORT void f6_V_SID_I(struct S_I p0, int p1, double p2) { }
+EXPORT void f6_V_SID_F(struct S_F p0, int p1, double p2) { }
+EXPORT void f6_V_SID_D(struct S_D p0, int p1, double p2) { }
+EXPORT void f6_V_SID_P(struct S_P p0, int p1, double p2) { }
+EXPORT void f6_V_SID_II(struct S_II p0, int p1, double p2) { }
+EXPORT void f6_V_SID_IF(struct S_IF p0, int p1, double p2) { }
+EXPORT void f6_V_SID_ID(struct S_ID p0, int p1, double p2) { }
+EXPORT void f6_V_SID_IP(struct S_IP p0, int p1, double p2) { }
+EXPORT void f6_V_SID_FI(struct S_FI p0, int p1, double p2) { }
+EXPORT void f6_V_SID_FF(struct S_FF p0, int p1, double p2) { }
+EXPORT void f6_V_SID_FD(struct S_FD p0, int p1, double p2) { }
+EXPORT void f6_V_SID_FP(struct S_FP p0, int p1, double p2) { }
+EXPORT void f6_V_SID_DI(struct S_DI p0, int p1, double p2) { }
+EXPORT void f6_V_SID_DF(struct S_DF p0, int p1, double p2) { }
+EXPORT void f6_V_SID_DD(struct S_DD p0, int p1, double p2) { }
+EXPORT void f6_V_SID_DP(struct S_DP p0, int p1, double p2) { }
+EXPORT void f6_V_SID_PI(struct S_PI p0, int p1, double p2) { }
+EXPORT void f6_V_SID_PF(struct S_PF p0, int p1, double p2) { }
+EXPORT void f6_V_SID_PD(struct S_PD p0, int p1, double p2) { }
+EXPORT void f6_V_SID_PP(struct S_PP p0, int p1, double p2) { }
+EXPORT void f6_V_SID_III(struct S_III p0, int p1, double p2) { }
+EXPORT void f6_V_SID_IIF(struct S_IIF p0, int p1, double p2) { }
+EXPORT void f6_V_SID_IID(struct S_IID p0, int p1, double p2) { }
+EXPORT void f6_V_SID_IIP(struct S_IIP p0, int p1, double p2) { }
+EXPORT void f6_V_SID_IFI(struct S_IFI p0, int p1, double p2) { }
+EXPORT void f6_V_SID_IFF(struct S_IFF p0, int p1, double p2) { }
+EXPORT void f6_V_SID_IFD(struct S_IFD p0, int p1, double p2) { }
+EXPORT void f6_V_SID_IFP(struct S_IFP p0, int p1, double p2) { }
+EXPORT void f6_V_SID_IDI(struct S_IDI p0, int p1, double p2) { }
+EXPORT void f6_V_SID_IDF(struct S_IDF p0, int p1, double p2) { }
+EXPORT void f6_V_SID_IDD(struct S_IDD p0, int p1, double p2) { }
+EXPORT void f6_V_SID_IDP(struct S_IDP p0, int p1, double p2) { }
+EXPORT void f6_V_SID_IPI(struct S_IPI p0, int p1, double p2) { }
+EXPORT void f6_V_SID_IPF(struct S_IPF p0, int p1, double p2) { }
+EXPORT void f6_V_SID_IPD(struct S_IPD p0, int p1, double p2) { }
+EXPORT void f6_V_SID_IPP(struct S_IPP p0, int p1, double p2) { }
+EXPORT void f6_V_SID_FII(struct S_FII p0, int p1, double p2) { }
+EXPORT void f6_V_SID_FIF(struct S_FIF p0, int p1, double p2) { }
+EXPORT void f6_V_SID_FID(struct S_FID p0, int p1, double p2) { }
+EXPORT void f6_V_SID_FIP(struct S_FIP p0, int p1, double p2) { }
+EXPORT void f6_V_SID_FFI(struct S_FFI p0, int p1, double p2) { }
+EXPORT void f6_V_SID_FFF(struct S_FFF p0, int p1, double p2) { }
+EXPORT void f6_V_SID_FFD(struct S_FFD p0, int p1, double p2) { }
+EXPORT void f6_V_SID_FFP(struct S_FFP p0, int p1, double p2) { }
+EXPORT void f6_V_SID_FDI(struct S_FDI p0, int p1, double p2) { }
+EXPORT void f6_V_SID_FDF(struct S_FDF p0, int p1, double p2) { }
+EXPORT void f6_V_SID_FDD(struct S_FDD p0, int p1, double p2) { }
+EXPORT void f6_V_SID_FDP(struct S_FDP p0, int p1, double p2) { }
+EXPORT void f6_V_SID_FPI(struct S_FPI p0, int p1, double p2) { }
+EXPORT void f6_V_SID_FPF(struct S_FPF p0, int p1, double p2) { }
+EXPORT void f6_V_SID_FPD(struct S_FPD p0, int p1, double p2) { }
+EXPORT void f6_V_SID_FPP(struct S_FPP p0, int p1, double p2) { }
+EXPORT void f6_V_SID_DII(struct S_DII p0, int p1, double p2) { }
+EXPORT void f6_V_SID_DIF(struct S_DIF p0, int p1, double p2) { }
+EXPORT void f6_V_SID_DID(struct S_DID p0, int p1, double p2) { }
+EXPORT void f6_V_SID_DIP(struct S_DIP p0, int p1, double p2) { }
+EXPORT void f6_V_SID_DFI(struct S_DFI p0, int p1, double p2) { }
+EXPORT void f6_V_SID_DFF(struct S_DFF p0, int p1, double p2) { }
+EXPORT void f6_V_SID_DFD(struct S_DFD p0, int p1, double p2) { }
+EXPORT void f6_V_SID_DFP(struct S_DFP p0, int p1, double p2) { }
+EXPORT void f6_V_SID_DDI(struct S_DDI p0, int p1, double p2) { }
+EXPORT void f6_V_SID_DDF(struct S_DDF p0, int p1, double p2) { }
+EXPORT void f6_V_SID_DDD(struct S_DDD p0, int p1, double p2) { }
+EXPORT void f6_V_SID_DDP(struct S_DDP p0, int p1, double p2) { }
+EXPORT void f6_V_SID_DPI(struct S_DPI p0, int p1, double p2) { }
+EXPORT void f6_V_SID_DPF(struct S_DPF p0, int p1, double p2) { }
+EXPORT void f6_V_SID_DPD(struct S_DPD p0, int p1, double p2) { }
+EXPORT void f6_V_SID_DPP(struct S_DPP p0, int p1, double p2) { }
+EXPORT void f6_V_SID_PII(struct S_PII p0, int p1, double p2) { }
+EXPORT void f6_V_SID_PIF(struct S_PIF p0, int p1, double p2) { }
+EXPORT void f6_V_SID_PID(struct S_PID p0, int p1, double p2) { }
+EXPORT void f6_V_SID_PIP(struct S_PIP p0, int p1, double p2) { }
+EXPORT void f6_V_SID_PFI(struct S_PFI p0, int p1, double p2) { }
+EXPORT void f6_V_SID_PFF(struct S_PFF p0, int p1, double p2) { }
+EXPORT void f6_V_SID_PFD(struct S_PFD p0, int p1, double p2) { }
+EXPORT void f6_V_SID_PFP(struct S_PFP p0, int p1, double p2) { }
+EXPORT void f6_V_SID_PDI(struct S_PDI p0, int p1, double p2) { }
+EXPORT void f6_V_SID_PDF(struct S_PDF p0, int p1, double p2) { }
+EXPORT void f6_V_SID_PDD(struct S_PDD p0, int p1, double p2) { }
+EXPORT void f6_V_SID_PDP(struct S_PDP p0, int p1, double p2) { }
+EXPORT void f6_V_SID_PPI(struct S_PPI p0, int p1, double p2) { }
+EXPORT void f6_V_SID_PPF(struct S_PPF p0, int p1, double p2) { }
+EXPORT void f6_V_SID_PPD(struct S_PPD p0, int p1, double p2) { }
+EXPORT void f7_V_SID_PPP(struct S_PPP p0, int p1, double p2) { }
+EXPORT void f7_V_SIP_I(struct S_I p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_F(struct S_F p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_D(struct S_D p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_P(struct S_P p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_II(struct S_II p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_IF(struct S_IF p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_ID(struct S_ID p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_IP(struct S_IP p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_FI(struct S_FI p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_FF(struct S_FF p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_FD(struct S_FD p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_FP(struct S_FP p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_DI(struct S_DI p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_DF(struct S_DF p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_DD(struct S_DD p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_DP(struct S_DP p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_PI(struct S_PI p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_PF(struct S_PF p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_PD(struct S_PD p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_PP(struct S_PP p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_III(struct S_III p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_IIF(struct S_IIF p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_IID(struct S_IID p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_IIP(struct S_IIP p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_IFI(struct S_IFI p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_IFF(struct S_IFF p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_IFD(struct S_IFD p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_IFP(struct S_IFP p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_IDI(struct S_IDI p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_IDF(struct S_IDF p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_IDD(struct S_IDD p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_IDP(struct S_IDP p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_IPI(struct S_IPI p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_IPF(struct S_IPF p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_IPD(struct S_IPD p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_IPP(struct S_IPP p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_FII(struct S_FII p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_FIF(struct S_FIF p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_FID(struct S_FID p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_FIP(struct S_FIP p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_FFI(struct S_FFI p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_FFF(struct S_FFF p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_FFD(struct S_FFD p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_FFP(struct S_FFP p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_FDI(struct S_FDI p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_FDF(struct S_FDF p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_FDD(struct S_FDD p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_FDP(struct S_FDP p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_FPI(struct S_FPI p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_FPF(struct S_FPF p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_FPD(struct S_FPD p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_FPP(struct S_FPP p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_DII(struct S_DII p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_DIF(struct S_DIF p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_DID(struct S_DID p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_DIP(struct S_DIP p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_DFI(struct S_DFI p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_DFF(struct S_DFF p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_DFD(struct S_DFD p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_DFP(struct S_DFP p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_DDI(struct S_DDI p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_DDF(struct S_DDF p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_DDD(struct S_DDD p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_DDP(struct S_DDP p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_DPI(struct S_DPI p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_DPF(struct S_DPF p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_DPD(struct S_DPD p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_DPP(struct S_DPP p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_PII(struct S_PII p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_PIF(struct S_PIF p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_PID(struct S_PID p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_PIP(struct S_PIP p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_PFI(struct S_PFI p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_PFF(struct S_PFF p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_PFD(struct S_PFD p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_PFP(struct S_PFP p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_PDI(struct S_PDI p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_PDF(struct S_PDF p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_PDD(struct S_PDD p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_PDP(struct S_PDP p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_PPI(struct S_PPI p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_PPF(struct S_PPF p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_PPD(struct S_PPD p0, int p1, void* p2) { }
+EXPORT void f7_V_SIP_PPP(struct S_PPP p0, int p1, void* p2) { }
+EXPORT void f7_V_SIS_I(struct S_I p0, int p1, struct S_I p2) { }
+EXPORT void f7_V_SIS_F(struct S_F p0, int p1, struct S_F p2) { }
+EXPORT void f7_V_SIS_D(struct S_D p0, int p1, struct S_D p2) { }
+EXPORT void f7_V_SIS_P(struct S_P p0, int p1, struct S_P p2) { }
+EXPORT void f7_V_SIS_II(struct S_II p0, int p1, struct S_II p2) { }
+EXPORT void f7_V_SIS_IF(struct S_IF p0, int p1, struct S_IF p2) { }
+EXPORT void f7_V_SIS_ID(struct S_ID p0, int p1, struct S_ID p2) { }
+EXPORT void f7_V_SIS_IP(struct S_IP p0, int p1, struct S_IP p2) { }
+EXPORT void f7_V_SIS_FI(struct S_FI p0, int p1, struct S_FI p2) { }
+EXPORT void f7_V_SIS_FF(struct S_FF p0, int p1, struct S_FF p2) { }
+EXPORT void f7_V_SIS_FD(struct S_FD p0, int p1, struct S_FD p2) { }
+EXPORT void f7_V_SIS_FP(struct S_FP p0, int p1, struct S_FP p2) { }
+EXPORT void f7_V_SIS_DI(struct S_DI p0, int p1, struct S_DI p2) { }
+EXPORT void f7_V_SIS_DF(struct S_DF p0, int p1, struct S_DF p2) { }
+EXPORT void f7_V_SIS_DD(struct S_DD p0, int p1, struct S_DD p2) { }
+EXPORT void f7_V_SIS_DP(struct S_DP p0, int p1, struct S_DP p2) { }
+EXPORT void f7_V_SIS_PI(struct S_PI p0, int p1, struct S_PI p2) { }
+EXPORT void f7_V_SIS_PF(struct S_PF p0, int p1, struct S_PF p2) { }
+EXPORT void f7_V_SIS_PD(struct S_PD p0, int p1, struct S_PD p2) { }
+EXPORT void f7_V_SIS_PP(struct S_PP p0, int p1, struct S_PP p2) { }
+EXPORT void f7_V_SIS_III(struct S_III p0, int p1, struct S_III p2) { }
+EXPORT void f7_V_SIS_IIF(struct S_IIF p0, int p1, struct S_IIF p2) { }
+EXPORT void f7_V_SIS_IID(struct S_IID p0, int p1, struct S_IID p2) { }
+EXPORT void f7_V_SIS_IIP(struct S_IIP p0, int p1, struct S_IIP p2) { }
+EXPORT void f7_V_SIS_IFI(struct S_IFI p0, int p1, struct S_IFI p2) { }
+EXPORT void f7_V_SIS_IFF(struct S_IFF p0, int p1, struct S_IFF p2) { }
+EXPORT void f7_V_SIS_IFD(struct S_IFD p0, int p1, struct S_IFD p2) { }
+EXPORT void f7_V_SIS_IFP(struct S_IFP p0, int p1, struct S_IFP p2) { }
+EXPORT void f7_V_SIS_IDI(struct S_IDI p0, int p1, struct S_IDI p2) { }
+EXPORT void f7_V_SIS_IDF(struct S_IDF p0, int p1, struct S_IDF p2) { }
+EXPORT void f7_V_SIS_IDD(struct S_IDD p0, int p1, struct S_IDD p2) { }
+EXPORT void f7_V_SIS_IDP(struct S_IDP p0, int p1, struct S_IDP p2) { }
+EXPORT void f7_V_SIS_IPI(struct S_IPI p0, int p1, struct S_IPI p2) { }
+EXPORT void f7_V_SIS_IPF(struct S_IPF p0, int p1, struct S_IPF p2) { }
+EXPORT void f7_V_SIS_IPD(struct S_IPD p0, int p1, struct S_IPD p2) { }
+EXPORT void f7_V_SIS_IPP(struct S_IPP p0, int p1, struct S_IPP p2) { }
+EXPORT void f7_V_SIS_FII(struct S_FII p0, int p1, struct S_FII p2) { }
+EXPORT void f7_V_SIS_FIF(struct S_FIF p0, int p1, struct S_FIF p2) { }
+EXPORT void f7_V_SIS_FID(struct S_FID p0, int p1, struct S_FID p2) { }
+EXPORT void f7_V_SIS_FIP(struct S_FIP p0, int p1, struct S_FIP p2) { }
+EXPORT void f7_V_SIS_FFI(struct S_FFI p0, int p1, struct S_FFI p2) { }
+EXPORT void f7_V_SIS_FFF(struct S_FFF p0, int p1, struct S_FFF p2) { }
+EXPORT void f7_V_SIS_FFD(struct S_FFD p0, int p1, struct S_FFD p2) { }
+EXPORT void f7_V_SIS_FFP(struct S_FFP p0, int p1, struct S_FFP p2) { }
+EXPORT void f7_V_SIS_FDI(struct S_FDI p0, int p1, struct S_FDI p2) { }
+EXPORT void f7_V_SIS_FDF(struct S_FDF p0, int p1, struct S_FDF p2) { }
+EXPORT void f7_V_SIS_FDD(struct S_FDD p0, int p1, struct S_FDD p2) { }
+EXPORT void f7_V_SIS_FDP(struct S_FDP p0, int p1, struct S_FDP p2) { }
+EXPORT void f7_V_SIS_FPI(struct S_FPI p0, int p1, struct S_FPI p2) { }
+EXPORT void f7_V_SIS_FPF(struct S_FPF p0, int p1, struct S_FPF p2) { }
+EXPORT void f7_V_SIS_FPD(struct S_FPD p0, int p1, struct S_FPD p2) { }
+EXPORT void f7_V_SIS_FPP(struct S_FPP p0, int p1, struct S_FPP p2) { }
+EXPORT void f7_V_SIS_DII(struct S_DII p0, int p1, struct S_DII p2) { }
+EXPORT void f7_V_SIS_DIF(struct S_DIF p0, int p1, struct S_DIF p2) { }
+EXPORT void f7_V_SIS_DID(struct S_DID p0, int p1, struct S_DID p2) { }
+EXPORT void f7_V_SIS_DIP(struct S_DIP p0, int p1, struct S_DIP p2) { }
+EXPORT void f7_V_SIS_DFI(struct S_DFI p0, int p1, struct S_DFI p2) { }
+EXPORT void f7_V_SIS_DFF(struct S_DFF p0, int p1, struct S_DFF p2) { }
+EXPORT void f7_V_SIS_DFD(struct S_DFD p0, int p1, struct S_DFD p2) { }
+EXPORT void f7_V_SIS_DFP(struct S_DFP p0, int p1, struct S_DFP p2) { }
+EXPORT void f7_V_SIS_DDI(struct S_DDI p0, int p1, struct S_DDI p2) { }
+EXPORT void f7_V_SIS_DDF(struct S_DDF p0, int p1, struct S_DDF p2) { }
+EXPORT void f7_V_SIS_DDD(struct S_DDD p0, int p1, struct S_DDD p2) { }
+EXPORT void f7_V_SIS_DDP(struct S_DDP p0, int p1, struct S_DDP p2) { }
+EXPORT void f7_V_SIS_DPI(struct S_DPI p0, int p1, struct S_DPI p2) { }
+EXPORT void f7_V_SIS_DPF(struct S_DPF p0, int p1, struct S_DPF p2) { }
+EXPORT void f7_V_SIS_DPD(struct S_DPD p0, int p1, struct S_DPD p2) { }
+EXPORT void f7_V_SIS_DPP(struct S_DPP p0, int p1, struct S_DPP p2) { }
+EXPORT void f7_V_SIS_PII(struct S_PII p0, int p1, struct S_PII p2) { }
+EXPORT void f7_V_SIS_PIF(struct S_PIF p0, int p1, struct S_PIF p2) { }
+EXPORT void f7_V_SIS_PID(struct S_PID p0, int p1, struct S_PID p2) { }
+EXPORT void f7_V_SIS_PIP(struct S_PIP p0, int p1, struct S_PIP p2) { }
+EXPORT void f7_V_SIS_PFI(struct S_PFI p0, int p1, struct S_PFI p2) { }
+EXPORT void f7_V_SIS_PFF(struct S_PFF p0, int p1, struct S_PFF p2) { }
+EXPORT void f7_V_SIS_PFD(struct S_PFD p0, int p1, struct S_PFD p2) { }
+EXPORT void f7_V_SIS_PFP(struct S_PFP p0, int p1, struct S_PFP p2) { }
+EXPORT void f7_V_SIS_PDI(struct S_PDI p0, int p1, struct S_PDI p2) { }
+EXPORT void f7_V_SIS_PDF(struct S_PDF p0, int p1, struct S_PDF p2) { }
+EXPORT void f7_V_SIS_PDD(struct S_PDD p0, int p1, struct S_PDD p2) { }
+EXPORT void f7_V_SIS_PDP(struct S_PDP p0, int p1, struct S_PDP p2) { }
+EXPORT void f7_V_SIS_PPI(struct S_PPI p0, int p1, struct S_PPI p2) { }
+EXPORT void f7_V_SIS_PPF(struct S_PPF p0, int p1, struct S_PPF p2) { }
+EXPORT void f7_V_SIS_PPD(struct S_PPD p0, int p1, struct S_PPD p2) { }
+EXPORT void f7_V_SIS_PPP(struct S_PPP p0, int p1, struct S_PPP p2) { }
+EXPORT void f7_V_SFI_I(struct S_I p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_F(struct S_F p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_D(struct S_D p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_P(struct S_P p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_II(struct S_II p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_IF(struct S_IF p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_ID(struct S_ID p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_IP(struct S_IP p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_FI(struct S_FI p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_FF(struct S_FF p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_FD(struct S_FD p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_FP(struct S_FP p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_DI(struct S_DI p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_DF(struct S_DF p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_DD(struct S_DD p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_DP(struct S_DP p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_PI(struct S_PI p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_PF(struct S_PF p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_PD(struct S_PD p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_PP(struct S_PP p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_III(struct S_III p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_IIF(struct S_IIF p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_IID(struct S_IID p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_IIP(struct S_IIP p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_IFI(struct S_IFI p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_IFF(struct S_IFF p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_IFD(struct S_IFD p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_IFP(struct S_IFP p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_IDI(struct S_IDI p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_IDF(struct S_IDF p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_IDD(struct S_IDD p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_IDP(struct S_IDP p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_IPI(struct S_IPI p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_IPF(struct S_IPF p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_IPD(struct S_IPD p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_IPP(struct S_IPP p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_FII(struct S_FII p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_FIF(struct S_FIF p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_FID(struct S_FID p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_FIP(struct S_FIP p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_FFI(struct S_FFI p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_FFF(struct S_FFF p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_FFD(struct S_FFD p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_FFP(struct S_FFP p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_FDI(struct S_FDI p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_FDF(struct S_FDF p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_FDD(struct S_FDD p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_FDP(struct S_FDP p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_FPI(struct S_FPI p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_FPF(struct S_FPF p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_FPD(struct S_FPD p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_FPP(struct S_FPP p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_DII(struct S_DII p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_DIF(struct S_DIF p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_DID(struct S_DID p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_DIP(struct S_DIP p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_DFI(struct S_DFI p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_DFF(struct S_DFF p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_DFD(struct S_DFD p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_DFP(struct S_DFP p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_DDI(struct S_DDI p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_DDF(struct S_DDF p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_DDD(struct S_DDD p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_DDP(struct S_DDP p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_DPI(struct S_DPI p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_DPF(struct S_DPF p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_DPD(struct S_DPD p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_DPP(struct S_DPP p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_PII(struct S_PII p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_PIF(struct S_PIF p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_PID(struct S_PID p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_PIP(struct S_PIP p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_PFI(struct S_PFI p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_PFF(struct S_PFF p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_PFD(struct S_PFD p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_PFP(struct S_PFP p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_PDI(struct S_PDI p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_PDF(struct S_PDF p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_PDD(struct S_PDD p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_PDP(struct S_PDP p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_PPI(struct S_PPI p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_PPF(struct S_PPF p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_PPD(struct S_PPD p0, float p1, int p2) { }
+EXPORT void f7_V_SFI_PPP(struct S_PPP p0, float p1, int p2) { }
+EXPORT void f7_V_SFF_I(struct S_I p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_F(struct S_F p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_D(struct S_D p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_P(struct S_P p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_II(struct S_II p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_IF(struct S_IF p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_ID(struct S_ID p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_IP(struct S_IP p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_FI(struct S_FI p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_FF(struct S_FF p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_FD(struct S_FD p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_FP(struct S_FP p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_DI(struct S_DI p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_DF(struct S_DF p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_DD(struct S_DD p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_DP(struct S_DP p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_PI(struct S_PI p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_PF(struct S_PF p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_PD(struct S_PD p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_PP(struct S_PP p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_III(struct S_III p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_IIF(struct S_IIF p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_IID(struct S_IID p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_IIP(struct S_IIP p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_IFI(struct S_IFI p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_IFF(struct S_IFF p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_IFD(struct S_IFD p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_IFP(struct S_IFP p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_IDI(struct S_IDI p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_IDF(struct S_IDF p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_IDD(struct S_IDD p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_IDP(struct S_IDP p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_IPI(struct S_IPI p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_IPF(struct S_IPF p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_IPD(struct S_IPD p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_IPP(struct S_IPP p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_FII(struct S_FII p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_FIF(struct S_FIF p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_FID(struct S_FID p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_FIP(struct S_FIP p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_FFI(struct S_FFI p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_FFF(struct S_FFF p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_FFD(struct S_FFD p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_FFP(struct S_FFP p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_FDI(struct S_FDI p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_FDF(struct S_FDF p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_FDD(struct S_FDD p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_FDP(struct S_FDP p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_FPI(struct S_FPI p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_FPF(struct S_FPF p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_FPD(struct S_FPD p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_FPP(struct S_FPP p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_DII(struct S_DII p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_DIF(struct S_DIF p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_DID(struct S_DID p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_DIP(struct S_DIP p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_DFI(struct S_DFI p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_DFF(struct S_DFF p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_DFD(struct S_DFD p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_DFP(struct S_DFP p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_DDI(struct S_DDI p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_DDF(struct S_DDF p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_DDD(struct S_DDD p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_DDP(struct S_DDP p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_DPI(struct S_DPI p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_DPF(struct S_DPF p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_DPD(struct S_DPD p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_DPP(struct S_DPP p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_PII(struct S_PII p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_PIF(struct S_PIF p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_PID(struct S_PID p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_PIP(struct S_PIP p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_PFI(struct S_PFI p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_PFF(struct S_PFF p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_PFD(struct S_PFD p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_PFP(struct S_PFP p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_PDI(struct S_PDI p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_PDF(struct S_PDF p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_PDD(struct S_PDD p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_PDP(struct S_PDP p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_PPI(struct S_PPI p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_PPF(struct S_PPF p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_PPD(struct S_PPD p0, float p1, float p2) { }
+EXPORT void f7_V_SFF_PPP(struct S_PPP p0, float p1, float p2) { }
+EXPORT void f7_V_SFD_I(struct S_I p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_F(struct S_F p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_D(struct S_D p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_P(struct S_P p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_II(struct S_II p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_IF(struct S_IF p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_ID(struct S_ID p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_IP(struct S_IP p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_FI(struct S_FI p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_FF(struct S_FF p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_FD(struct S_FD p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_FP(struct S_FP p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_DI(struct S_DI p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_DF(struct S_DF p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_DD(struct S_DD p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_DP(struct S_DP p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_PI(struct S_PI p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_PF(struct S_PF p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_PD(struct S_PD p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_PP(struct S_PP p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_III(struct S_III p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_IIF(struct S_IIF p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_IID(struct S_IID p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_IIP(struct S_IIP p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_IFI(struct S_IFI p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_IFF(struct S_IFF p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_IFD(struct S_IFD p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_IFP(struct S_IFP p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_IDI(struct S_IDI p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_IDF(struct S_IDF p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_IDD(struct S_IDD p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_IDP(struct S_IDP p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_IPI(struct S_IPI p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_IPF(struct S_IPF p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_IPD(struct S_IPD p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_IPP(struct S_IPP p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_FII(struct S_FII p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_FIF(struct S_FIF p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_FID(struct S_FID p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_FIP(struct S_FIP p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_FFI(struct S_FFI p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_FFF(struct S_FFF p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_FFD(struct S_FFD p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_FFP(struct S_FFP p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_FDI(struct S_FDI p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_FDF(struct S_FDF p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_FDD(struct S_FDD p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_FDP(struct S_FDP p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_FPI(struct S_FPI p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_FPF(struct S_FPF p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_FPD(struct S_FPD p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_FPP(struct S_FPP p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_DII(struct S_DII p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_DIF(struct S_DIF p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_DID(struct S_DID p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_DIP(struct S_DIP p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_DFI(struct S_DFI p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_DFF(struct S_DFF p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_DFD(struct S_DFD p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_DFP(struct S_DFP p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_DDI(struct S_DDI p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_DDF(struct S_DDF p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_DDD(struct S_DDD p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_DDP(struct S_DDP p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_DPI(struct S_DPI p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_DPF(struct S_DPF p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_DPD(struct S_DPD p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_DPP(struct S_DPP p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_PII(struct S_PII p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_PIF(struct S_PIF p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_PID(struct S_PID p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_PIP(struct S_PIP p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_PFI(struct S_PFI p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_PFF(struct S_PFF p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_PFD(struct S_PFD p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_PFP(struct S_PFP p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_PDI(struct S_PDI p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_PDF(struct S_PDF p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_PDD(struct S_PDD p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_PDP(struct S_PDP p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_PPI(struct S_PPI p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_PPF(struct S_PPF p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_PPD(struct S_PPD p0, float p1, double p2) { }
+EXPORT void f7_V_SFD_PPP(struct S_PPP p0, float p1, double p2) { }
+EXPORT void f7_V_SFP_I(struct S_I p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_F(struct S_F p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_D(struct S_D p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_P(struct S_P p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_II(struct S_II p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_IF(struct S_IF p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_ID(struct S_ID p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_IP(struct S_IP p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_FI(struct S_FI p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_FF(struct S_FF p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_FD(struct S_FD p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_FP(struct S_FP p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_DI(struct S_DI p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_DF(struct S_DF p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_DD(struct S_DD p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_DP(struct S_DP p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_PI(struct S_PI p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_PF(struct S_PF p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_PD(struct S_PD p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_PP(struct S_PP p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_III(struct S_III p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_IIF(struct S_IIF p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_IID(struct S_IID p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_IIP(struct S_IIP p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_IFI(struct S_IFI p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_IFF(struct S_IFF p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_IFD(struct S_IFD p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_IFP(struct S_IFP p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_IDI(struct S_IDI p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_IDF(struct S_IDF p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_IDD(struct S_IDD p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_IDP(struct S_IDP p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_IPI(struct S_IPI p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_IPF(struct S_IPF p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_IPD(struct S_IPD p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_IPP(struct S_IPP p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_FII(struct S_FII p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_FIF(struct S_FIF p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_FID(struct S_FID p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_FIP(struct S_FIP p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_FFI(struct S_FFI p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_FFF(struct S_FFF p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_FFD(struct S_FFD p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_FFP(struct S_FFP p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_FDI(struct S_FDI p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_FDF(struct S_FDF p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_FDD(struct S_FDD p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_FDP(struct S_FDP p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_FPI(struct S_FPI p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_FPF(struct S_FPF p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_FPD(struct S_FPD p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_FPP(struct S_FPP p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_DII(struct S_DII p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_DIF(struct S_DIF p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_DID(struct S_DID p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_DIP(struct S_DIP p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_DFI(struct S_DFI p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_DFF(struct S_DFF p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_DFD(struct S_DFD p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_DFP(struct S_DFP p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_DDI(struct S_DDI p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_DDF(struct S_DDF p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_DDD(struct S_DDD p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_DDP(struct S_DDP p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_DPI(struct S_DPI p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_DPF(struct S_DPF p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_DPD(struct S_DPD p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_DPP(struct S_DPP p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_PII(struct S_PII p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_PIF(struct S_PIF p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_PID(struct S_PID p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_PIP(struct S_PIP p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_PFI(struct S_PFI p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_PFF(struct S_PFF p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_PFD(struct S_PFD p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_PFP(struct S_PFP p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_PDI(struct S_PDI p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_PDF(struct S_PDF p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_PDD(struct S_PDD p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_PDP(struct S_PDP p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_PPI(struct S_PPI p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_PPF(struct S_PPF p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_PPD(struct S_PPD p0, float p1, void* p2) { }
+EXPORT void f7_V_SFP_PPP(struct S_PPP p0, float p1, void* p2) { }
+EXPORT void f7_V_SFS_I(struct S_I p0, float p1, struct S_I p2) { }
+EXPORT void f7_V_SFS_F(struct S_F p0, float p1, struct S_F p2) { }
+EXPORT void f7_V_SFS_D(struct S_D p0, float p1, struct S_D p2) { }
+EXPORT void f7_V_SFS_P(struct S_P p0, float p1, struct S_P p2) { }
+EXPORT void f7_V_SFS_II(struct S_II p0, float p1, struct S_II p2) { }
+EXPORT void f7_V_SFS_IF(struct S_IF p0, float p1, struct S_IF p2) { }
+EXPORT void f7_V_SFS_ID(struct S_ID p0, float p1, struct S_ID p2) { }
+EXPORT void f7_V_SFS_IP(struct S_IP p0, float p1, struct S_IP p2) { }
+EXPORT void f7_V_SFS_FI(struct S_FI p0, float p1, struct S_FI p2) { }
+EXPORT void f7_V_SFS_FF(struct S_FF p0, float p1, struct S_FF p2) { }
+EXPORT void f7_V_SFS_FD(struct S_FD p0, float p1, struct S_FD p2) { }
+EXPORT void f7_V_SFS_FP(struct S_FP p0, float p1, struct S_FP p2) { }
+EXPORT void f7_V_SFS_DI(struct S_DI p0, float p1, struct S_DI p2) { }
+EXPORT void f7_V_SFS_DF(struct S_DF p0, float p1, struct S_DF p2) { }
+EXPORT void f7_V_SFS_DD(struct S_DD p0, float p1, struct S_DD p2) { }
+EXPORT void f7_V_SFS_DP(struct S_DP p0, float p1, struct S_DP p2) { }
+EXPORT void f7_V_SFS_PI(struct S_PI p0, float p1, struct S_PI p2) { }
+EXPORT void f7_V_SFS_PF(struct S_PF p0, float p1, struct S_PF p2) { }
+EXPORT void f7_V_SFS_PD(struct S_PD p0, float p1, struct S_PD p2) { }
+EXPORT void f7_V_SFS_PP(struct S_PP p0, float p1, struct S_PP p2) { }
+EXPORT void f7_V_SFS_III(struct S_III p0, float p1, struct S_III p2) { }
+EXPORT void f7_V_SFS_IIF(struct S_IIF p0, float p1, struct S_IIF p2) { }
+EXPORT void f7_V_SFS_IID(struct S_IID p0, float p1, struct S_IID p2) { }
+EXPORT void f7_V_SFS_IIP(struct S_IIP p0, float p1, struct S_IIP p2) { }
+EXPORT void f7_V_SFS_IFI(struct S_IFI p0, float p1, struct S_IFI p2) { }
+EXPORT void f7_V_SFS_IFF(struct S_IFF p0, float p1, struct S_IFF p2) { }
+EXPORT void f7_V_SFS_IFD(struct S_IFD p0, float p1, struct S_IFD p2) { }
+EXPORT void f7_V_SFS_IFP(struct S_IFP p0, float p1, struct S_IFP p2) { }
+EXPORT void f7_V_SFS_IDI(struct S_IDI p0, float p1, struct S_IDI p2) { }
+EXPORT void f7_V_SFS_IDF(struct S_IDF p0, float p1, struct S_IDF p2) { }
+EXPORT void f7_V_SFS_IDD(struct S_IDD p0, float p1, struct S_IDD p2) { }
+EXPORT void f7_V_SFS_IDP(struct S_IDP p0, float p1, struct S_IDP p2) { }
+EXPORT void f7_V_SFS_IPI(struct S_IPI p0, float p1, struct S_IPI p2) { }
+EXPORT void f7_V_SFS_IPF(struct S_IPF p0, float p1, struct S_IPF p2) { }
+EXPORT void f7_V_SFS_IPD(struct S_IPD p0, float p1, struct S_IPD p2) { }
+EXPORT void f7_V_SFS_IPP(struct S_IPP p0, float p1, struct S_IPP p2) { }
+EXPORT void f7_V_SFS_FII(struct S_FII p0, float p1, struct S_FII p2) { }
+EXPORT void f7_V_SFS_FIF(struct S_FIF p0, float p1, struct S_FIF p2) { }
+EXPORT void f7_V_SFS_FID(struct S_FID p0, float p1, struct S_FID p2) { }
+EXPORT void f7_V_SFS_FIP(struct S_FIP p0, float p1, struct S_FIP p2) { }
+EXPORT void f7_V_SFS_FFI(struct S_FFI p0, float p1, struct S_FFI p2) { }
+EXPORT void f7_V_SFS_FFF(struct S_FFF p0, float p1, struct S_FFF p2) { }
+EXPORT void f7_V_SFS_FFD(struct S_FFD p0, float p1, struct S_FFD p2) { }
+EXPORT void f7_V_SFS_FFP(struct S_FFP p0, float p1, struct S_FFP p2) { }
+EXPORT void f7_V_SFS_FDI(struct S_FDI p0, float p1, struct S_FDI p2) { }
+EXPORT void f7_V_SFS_FDF(struct S_FDF p0, float p1, struct S_FDF p2) { }
+EXPORT void f7_V_SFS_FDD(struct S_FDD p0, float p1, struct S_FDD p2) { }
+EXPORT void f7_V_SFS_FDP(struct S_FDP p0, float p1, struct S_FDP p2) { }
+EXPORT void f7_V_SFS_FPI(struct S_FPI p0, float p1, struct S_FPI p2) { }
+EXPORT void f7_V_SFS_FPF(struct S_FPF p0, float p1, struct S_FPF p2) { }
+EXPORT void f7_V_SFS_FPD(struct S_FPD p0, float p1, struct S_FPD p2) { }
+EXPORT void f7_V_SFS_FPP(struct S_FPP p0, float p1, struct S_FPP p2) { }
+EXPORT void f7_V_SFS_DII(struct S_DII p0, float p1, struct S_DII p2) { }
+EXPORT void f7_V_SFS_DIF(struct S_DIF p0, float p1, struct S_DIF p2) { }
+EXPORT void f7_V_SFS_DID(struct S_DID p0, float p1, struct S_DID p2) { }
+EXPORT void f7_V_SFS_DIP(struct S_DIP p0, float p1, struct S_DIP p2) { }
+EXPORT void f7_V_SFS_DFI(struct S_DFI p0, float p1, struct S_DFI p2) { }
+EXPORT void f7_V_SFS_DFF(struct S_DFF p0, float p1, struct S_DFF p2) { }
+EXPORT void f7_V_SFS_DFD(struct S_DFD p0, float p1, struct S_DFD p2) { }
+EXPORT void f7_V_SFS_DFP(struct S_DFP p0, float p1, struct S_DFP p2) { }
+EXPORT void f7_V_SFS_DDI(struct S_DDI p0, float p1, struct S_DDI p2) { }
+EXPORT void f7_V_SFS_DDF(struct S_DDF p0, float p1, struct S_DDF p2) { }
+EXPORT void f7_V_SFS_DDD(struct S_DDD p0, float p1, struct S_DDD p2) { }
+EXPORT void f7_V_SFS_DDP(struct S_DDP p0, float p1, struct S_DDP p2) { }
+EXPORT void f7_V_SFS_DPI(struct S_DPI p0, float p1, struct S_DPI p2) { }
+EXPORT void f7_V_SFS_DPF(struct S_DPF p0, float p1, struct S_DPF p2) { }
+EXPORT void f7_V_SFS_DPD(struct S_DPD p0, float p1, struct S_DPD p2) { }
+EXPORT void f7_V_SFS_DPP(struct S_DPP p0, float p1, struct S_DPP p2) { }
+EXPORT void f7_V_SFS_PII(struct S_PII p0, float p1, struct S_PII p2) { }
+EXPORT void f7_V_SFS_PIF(struct S_PIF p0, float p1, struct S_PIF p2) { }
+EXPORT void f7_V_SFS_PID(struct S_PID p0, float p1, struct S_PID p2) { }
+EXPORT void f7_V_SFS_PIP(struct S_PIP p0, float p1, struct S_PIP p2) { }
+EXPORT void f7_V_SFS_PFI(struct S_PFI p0, float p1, struct S_PFI p2) { }
+EXPORT void f7_V_SFS_PFF(struct S_PFF p0, float p1, struct S_PFF p2) { }
+EXPORT void f7_V_SFS_PFD(struct S_PFD p0, float p1, struct S_PFD p2) { }
+EXPORT void f7_V_SFS_PFP(struct S_PFP p0, float p1, struct S_PFP p2) { }
+EXPORT void f7_V_SFS_PDI(struct S_PDI p0, float p1, struct S_PDI p2) { }
+EXPORT void f7_V_SFS_PDF(struct S_PDF p0, float p1, struct S_PDF p2) { }
+EXPORT void f7_V_SFS_PDD(struct S_PDD p0, float p1, struct S_PDD p2) { }
+EXPORT void f7_V_SFS_PDP(struct S_PDP p0, float p1, struct S_PDP p2) { }
+EXPORT void f7_V_SFS_PPI(struct S_PPI p0, float p1, struct S_PPI p2) { }
+EXPORT void f7_V_SFS_PPF(struct S_PPF p0, float p1, struct S_PPF p2) { }
+EXPORT void f7_V_SFS_PPD(struct S_PPD p0, float p1, struct S_PPD p2) { }
+EXPORT void f7_V_SFS_PPP(struct S_PPP p0, float p1, struct S_PPP p2) { }
+EXPORT void f7_V_SDI_I(struct S_I p0, double p1, int p2) { }
+EXPORT void f7_V_SDI_F(struct S_F p0, double p1, int p2) { }
+EXPORT void f7_V_SDI_D(struct S_D p0, double p1, int p2) { }
+EXPORT void f7_V_SDI_P(struct S_P p0, double p1, int p2) { }
+EXPORT void f7_V_SDI_II(struct S_II p0, double p1, int p2) { }
+EXPORT void f7_V_SDI_IF(struct S_IF p0, double p1, int p2) { }
+EXPORT void f7_V_SDI_ID(struct S_ID p0, double p1, int p2) { }
+EXPORT void f7_V_SDI_IP(struct S_IP p0, double p1, int p2) { }
+EXPORT void f7_V_SDI_FI(struct S_FI p0, double p1, int p2) { }
+EXPORT void f7_V_SDI_FF(struct S_FF p0, double p1, int p2) { }
+EXPORT void f7_V_SDI_FD(struct S_FD p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_FP(struct S_FP p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_DI(struct S_DI p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_DF(struct S_DF p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_DD(struct S_DD p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_DP(struct S_DP p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_PI(struct S_PI p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_PF(struct S_PF p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_PD(struct S_PD p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_PP(struct S_PP p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_III(struct S_III p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_IIF(struct S_IIF p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_IID(struct S_IID p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_IIP(struct S_IIP p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_IFI(struct S_IFI p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_IFF(struct S_IFF p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_IFD(struct S_IFD p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_IFP(struct S_IFP p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_IDI(struct S_IDI p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_IDF(struct S_IDF p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_IDD(struct S_IDD p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_IDP(struct S_IDP p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_IPI(struct S_IPI p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_IPF(struct S_IPF p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_IPD(struct S_IPD p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_IPP(struct S_IPP p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_FII(struct S_FII p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_FIF(struct S_FIF p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_FID(struct S_FID p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_FIP(struct S_FIP p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_FFI(struct S_FFI p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_FFF(struct S_FFF p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_FFD(struct S_FFD p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_FFP(struct S_FFP p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_FDI(struct S_FDI p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_FDF(struct S_FDF p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_FDD(struct S_FDD p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_FDP(struct S_FDP p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_FPI(struct S_FPI p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_FPF(struct S_FPF p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_FPD(struct S_FPD p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_FPP(struct S_FPP p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_DII(struct S_DII p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_DIF(struct S_DIF p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_DID(struct S_DID p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_DIP(struct S_DIP p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_DFI(struct S_DFI p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_DFF(struct S_DFF p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_DFD(struct S_DFD p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_DFP(struct S_DFP p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_DDI(struct S_DDI p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_DDF(struct S_DDF p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_DDD(struct S_DDD p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_DDP(struct S_DDP p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_DPI(struct S_DPI p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_DPF(struct S_DPF p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_DPD(struct S_DPD p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_DPP(struct S_DPP p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_PII(struct S_PII p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_PIF(struct S_PIF p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_PID(struct S_PID p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_PIP(struct S_PIP p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_PFI(struct S_PFI p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_PFF(struct S_PFF p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_PFD(struct S_PFD p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_PFP(struct S_PFP p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_PDI(struct S_PDI p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_PDF(struct S_PDF p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_PDD(struct S_PDD p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_PDP(struct S_PDP p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_PPI(struct S_PPI p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_PPF(struct S_PPF p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_PPD(struct S_PPD p0, double p1, int p2) { }
+EXPORT void f8_V_SDI_PPP(struct S_PPP p0, double p1, int p2) { }
+EXPORT void f8_V_SDF_I(struct S_I p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_F(struct S_F p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_D(struct S_D p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_P(struct S_P p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_II(struct S_II p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_IF(struct S_IF p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_ID(struct S_ID p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_IP(struct S_IP p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_FI(struct S_FI p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_FF(struct S_FF p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_FD(struct S_FD p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_FP(struct S_FP p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_DI(struct S_DI p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_DF(struct S_DF p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_DD(struct S_DD p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_DP(struct S_DP p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_PI(struct S_PI p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_PF(struct S_PF p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_PD(struct S_PD p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_PP(struct S_PP p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_III(struct S_III p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_IIF(struct S_IIF p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_IID(struct S_IID p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_IIP(struct S_IIP p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_IFI(struct S_IFI p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_IFF(struct S_IFF p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_IFD(struct S_IFD p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_IFP(struct S_IFP p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_IDI(struct S_IDI p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_IDF(struct S_IDF p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_IDD(struct S_IDD p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_IDP(struct S_IDP p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_IPI(struct S_IPI p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_IPF(struct S_IPF p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_IPD(struct S_IPD p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_IPP(struct S_IPP p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_FII(struct S_FII p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_FIF(struct S_FIF p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_FID(struct S_FID p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_FIP(struct S_FIP p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_FFI(struct S_FFI p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_FFF(struct S_FFF p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_FFD(struct S_FFD p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_FFP(struct S_FFP p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_FDI(struct S_FDI p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_FDF(struct S_FDF p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_FDD(struct S_FDD p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_FDP(struct S_FDP p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_FPI(struct S_FPI p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_FPF(struct S_FPF p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_FPD(struct S_FPD p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_FPP(struct S_FPP p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_DII(struct S_DII p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_DIF(struct S_DIF p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_DID(struct S_DID p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_DIP(struct S_DIP p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_DFI(struct S_DFI p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_DFF(struct S_DFF p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_DFD(struct S_DFD p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_DFP(struct S_DFP p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_DDI(struct S_DDI p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_DDF(struct S_DDF p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_DDD(struct S_DDD p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_DDP(struct S_DDP p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_DPI(struct S_DPI p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_DPF(struct S_DPF p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_DPD(struct S_DPD p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_DPP(struct S_DPP p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_PII(struct S_PII p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_PIF(struct S_PIF p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_PID(struct S_PID p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_PIP(struct S_PIP p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_PFI(struct S_PFI p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_PFF(struct S_PFF p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_PFD(struct S_PFD p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_PFP(struct S_PFP p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_PDI(struct S_PDI p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_PDF(struct S_PDF p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_PDD(struct S_PDD p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_PDP(struct S_PDP p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_PPI(struct S_PPI p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_PPF(struct S_PPF p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_PPD(struct S_PPD p0, double p1, float p2) { }
+EXPORT void f8_V_SDF_PPP(struct S_PPP p0, double p1, float p2) { }
+EXPORT void f8_V_SDD_I(struct S_I p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_F(struct S_F p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_D(struct S_D p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_P(struct S_P p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_II(struct S_II p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_IF(struct S_IF p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_ID(struct S_ID p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_IP(struct S_IP p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_FI(struct S_FI p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_FF(struct S_FF p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_FD(struct S_FD p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_FP(struct S_FP p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_DI(struct S_DI p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_DF(struct S_DF p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_DD(struct S_DD p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_DP(struct S_DP p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_PI(struct S_PI p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_PF(struct S_PF p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_PD(struct S_PD p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_PP(struct S_PP p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_III(struct S_III p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_IIF(struct S_IIF p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_IID(struct S_IID p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_IIP(struct S_IIP p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_IFI(struct S_IFI p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_IFF(struct S_IFF p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_IFD(struct S_IFD p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_IFP(struct S_IFP p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_IDI(struct S_IDI p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_IDF(struct S_IDF p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_IDD(struct S_IDD p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_IDP(struct S_IDP p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_IPI(struct S_IPI p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_IPF(struct S_IPF p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_IPD(struct S_IPD p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_IPP(struct S_IPP p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_FII(struct S_FII p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_FIF(struct S_FIF p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_FID(struct S_FID p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_FIP(struct S_FIP p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_FFI(struct S_FFI p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_FFF(struct S_FFF p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_FFD(struct S_FFD p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_FFP(struct S_FFP p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_FDI(struct S_FDI p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_FDF(struct S_FDF p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_FDD(struct S_FDD p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_FDP(struct S_FDP p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_FPI(struct S_FPI p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_FPF(struct S_FPF p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_FPD(struct S_FPD p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_FPP(struct S_FPP p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_DII(struct S_DII p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_DIF(struct S_DIF p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_DID(struct S_DID p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_DIP(struct S_DIP p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_DFI(struct S_DFI p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_DFF(struct S_DFF p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_DFD(struct S_DFD p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_DFP(struct S_DFP p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_DDI(struct S_DDI p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_DDF(struct S_DDF p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_DDD(struct S_DDD p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_DDP(struct S_DDP p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_DPI(struct S_DPI p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_DPF(struct S_DPF p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_DPD(struct S_DPD p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_DPP(struct S_DPP p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_PII(struct S_PII p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_PIF(struct S_PIF p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_PID(struct S_PID p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_PIP(struct S_PIP p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_PFI(struct S_PFI p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_PFF(struct S_PFF p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_PFD(struct S_PFD p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_PFP(struct S_PFP p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_PDI(struct S_PDI p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_PDF(struct S_PDF p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_PDD(struct S_PDD p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_PDP(struct S_PDP p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_PPI(struct S_PPI p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_PPF(struct S_PPF p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_PPD(struct S_PPD p0, double p1, double p2) { }
+EXPORT void f8_V_SDD_PPP(struct S_PPP p0, double p1, double p2) { }
+EXPORT void f8_V_SDP_I(struct S_I p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_F(struct S_F p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_D(struct S_D p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_P(struct S_P p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_II(struct S_II p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_IF(struct S_IF p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_ID(struct S_ID p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_IP(struct S_IP p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_FI(struct S_FI p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_FF(struct S_FF p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_FD(struct S_FD p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_FP(struct S_FP p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_DI(struct S_DI p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_DF(struct S_DF p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_DD(struct S_DD p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_DP(struct S_DP p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_PI(struct S_PI p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_PF(struct S_PF p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_PD(struct S_PD p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_PP(struct S_PP p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_III(struct S_III p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_IIF(struct S_IIF p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_IID(struct S_IID p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_IIP(struct S_IIP p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_IFI(struct S_IFI p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_IFF(struct S_IFF p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_IFD(struct S_IFD p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_IFP(struct S_IFP p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_IDI(struct S_IDI p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_IDF(struct S_IDF p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_IDD(struct S_IDD p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_IDP(struct S_IDP p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_IPI(struct S_IPI p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_IPF(struct S_IPF p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_IPD(struct S_IPD p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_IPP(struct S_IPP p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_FII(struct S_FII p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_FIF(struct S_FIF p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_FID(struct S_FID p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_FIP(struct S_FIP p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_FFI(struct S_FFI p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_FFF(struct S_FFF p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_FFD(struct S_FFD p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_FFP(struct S_FFP p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_FDI(struct S_FDI p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_FDF(struct S_FDF p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_FDD(struct S_FDD p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_FDP(struct S_FDP p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_FPI(struct S_FPI p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_FPF(struct S_FPF p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_FPD(struct S_FPD p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_FPP(struct S_FPP p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_DII(struct S_DII p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_DIF(struct S_DIF p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_DID(struct S_DID p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_DIP(struct S_DIP p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_DFI(struct S_DFI p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_DFF(struct S_DFF p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_DFD(struct S_DFD p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_DFP(struct S_DFP p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_DDI(struct S_DDI p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_DDF(struct S_DDF p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_DDD(struct S_DDD p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_DDP(struct S_DDP p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_DPI(struct S_DPI p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_DPF(struct S_DPF p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_DPD(struct S_DPD p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_DPP(struct S_DPP p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_PII(struct S_PII p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_PIF(struct S_PIF p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_PID(struct S_PID p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_PIP(struct S_PIP p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_PFI(struct S_PFI p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_PFF(struct S_PFF p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_PFD(struct S_PFD p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_PFP(struct S_PFP p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_PDI(struct S_PDI p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_PDF(struct S_PDF p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_PDD(struct S_PDD p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_PDP(struct S_PDP p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_PPI(struct S_PPI p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_PPF(struct S_PPF p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_PPD(struct S_PPD p0, double p1, void* p2) { }
+EXPORT void f8_V_SDP_PPP(struct S_PPP p0, double p1, void* p2) { }
+EXPORT void f8_V_SDS_I(struct S_I p0, double p1, struct S_I p2) { }
+EXPORT void f8_V_SDS_F(struct S_F p0, double p1, struct S_F p2) { }
+EXPORT void f8_V_SDS_D(struct S_D p0, double p1, struct S_D p2) { }
+EXPORT void f8_V_SDS_P(struct S_P p0, double p1, struct S_P p2) { }
+EXPORT void f8_V_SDS_II(struct S_II p0, double p1, struct S_II p2) { }
+EXPORT void f8_V_SDS_IF(struct S_IF p0, double p1, struct S_IF p2) { }
+EXPORT void f8_V_SDS_ID(struct S_ID p0, double p1, struct S_ID p2) { }
+EXPORT void f8_V_SDS_IP(struct S_IP p0, double p1, struct S_IP p2) { }
+EXPORT void f8_V_SDS_FI(struct S_FI p0, double p1, struct S_FI p2) { }
+EXPORT void f8_V_SDS_FF(struct S_FF p0, double p1, struct S_FF p2) { }
+EXPORT void f8_V_SDS_FD(struct S_FD p0, double p1, struct S_FD p2) { }
+EXPORT void f8_V_SDS_FP(struct S_FP p0, double p1, struct S_FP p2) { }
+EXPORT void f8_V_SDS_DI(struct S_DI p0, double p1, struct S_DI p2) { }
+EXPORT void f8_V_SDS_DF(struct S_DF p0, double p1, struct S_DF p2) { }
+EXPORT void f8_V_SDS_DD(struct S_DD p0, double p1, struct S_DD p2) { }
+EXPORT void f8_V_SDS_DP(struct S_DP p0, double p1, struct S_DP p2) { }
+EXPORT void f8_V_SDS_PI(struct S_PI p0, double p1, struct S_PI p2) { }
+EXPORT void f8_V_SDS_PF(struct S_PF p0, double p1, struct S_PF p2) { }
+EXPORT void f8_V_SDS_PD(struct S_PD p0, double p1, struct S_PD p2) { }
+EXPORT void f8_V_SDS_PP(struct S_PP p0, double p1, struct S_PP p2) { }
+EXPORT void f8_V_SDS_III(struct S_III p0, double p1, struct S_III p2) { }
+EXPORT void f8_V_SDS_IIF(struct S_IIF p0, double p1, struct S_IIF p2) { }
+EXPORT void f8_V_SDS_IID(struct S_IID p0, double p1, struct S_IID p2) { }
+EXPORT void f8_V_SDS_IIP(struct S_IIP p0, double p1, struct S_IIP p2) { }
+EXPORT void f8_V_SDS_IFI(struct S_IFI p0, double p1, struct S_IFI p2) { }
+EXPORT void f8_V_SDS_IFF(struct S_IFF p0, double p1, struct S_IFF p2) { }
+EXPORT void f8_V_SDS_IFD(struct S_IFD p0, double p1, struct S_IFD p2) { }
+EXPORT void f8_V_SDS_IFP(struct S_IFP p0, double p1, struct S_IFP p2) { }
+EXPORT void f8_V_SDS_IDI(struct S_IDI p0, double p1, struct S_IDI p2) { }
+EXPORT void f8_V_SDS_IDF(struct S_IDF p0, double p1, struct S_IDF p2) { }
+EXPORT void f8_V_SDS_IDD(struct S_IDD p0, double p1, struct S_IDD p2) { }
+EXPORT void f8_V_SDS_IDP(struct S_IDP p0, double p1, struct S_IDP p2) { }
+EXPORT void f8_V_SDS_IPI(struct S_IPI p0, double p1, struct S_IPI p2) { }
+EXPORT void f8_V_SDS_IPF(struct S_IPF p0, double p1, struct S_IPF p2) { }
+EXPORT void f8_V_SDS_IPD(struct S_IPD p0, double p1, struct S_IPD p2) { }
+EXPORT void f8_V_SDS_IPP(struct S_IPP p0, double p1, struct S_IPP p2) { }
+EXPORT void f8_V_SDS_FII(struct S_FII p0, double p1, struct S_FII p2) { }
+EXPORT void f8_V_SDS_FIF(struct S_FIF p0, double p1, struct S_FIF p2) { }
+EXPORT void f8_V_SDS_FID(struct S_FID p0, double p1, struct S_FID p2) { }
+EXPORT void f8_V_SDS_FIP(struct S_FIP p0, double p1, struct S_FIP p2) { }
+EXPORT void f8_V_SDS_FFI(struct S_FFI p0, double p1, struct S_FFI p2) { }
+EXPORT void f8_V_SDS_FFF(struct S_FFF p0, double p1, struct S_FFF p2) { }
+EXPORT void f8_V_SDS_FFD(struct S_FFD p0, double p1, struct S_FFD p2) { }
+EXPORT void f8_V_SDS_FFP(struct S_FFP p0, double p1, struct S_FFP p2) { }
+EXPORT void f8_V_SDS_FDI(struct S_FDI p0, double p1, struct S_FDI p2) { }
+EXPORT void f8_V_SDS_FDF(struct S_FDF p0, double p1, struct S_FDF p2) { }
+EXPORT void f8_V_SDS_FDD(struct S_FDD p0, double p1, struct S_FDD p2) { }
+EXPORT void f8_V_SDS_FDP(struct S_FDP p0, double p1, struct S_FDP p2) { }
+EXPORT void f8_V_SDS_FPI(struct S_FPI p0, double p1, struct S_FPI p2) { }
+EXPORT void f8_V_SDS_FPF(struct S_FPF p0, double p1, struct S_FPF p2) { }
+EXPORT void f8_V_SDS_FPD(struct S_FPD p0, double p1, struct S_FPD p2) { }
+EXPORT void f8_V_SDS_FPP(struct S_FPP p0, double p1, struct S_FPP p2) { }
+EXPORT void f8_V_SDS_DII(struct S_DII p0, double p1, struct S_DII p2) { }
+EXPORT void f8_V_SDS_DIF(struct S_DIF p0, double p1, struct S_DIF p2) { }
+EXPORT void f8_V_SDS_DID(struct S_DID p0, double p1, struct S_DID p2) { }
+EXPORT void f8_V_SDS_DIP(struct S_DIP p0, double p1, struct S_DIP p2) { }
+EXPORT void f8_V_SDS_DFI(struct S_DFI p0, double p1, struct S_DFI p2) { }
+EXPORT void f8_V_SDS_DFF(struct S_DFF p0, double p1, struct S_DFF p2) { }
+EXPORT void f8_V_SDS_DFD(struct S_DFD p0, double p1, struct S_DFD p2) { }
+EXPORT void f8_V_SDS_DFP(struct S_DFP p0, double p1, struct S_DFP p2) { }
+EXPORT void f8_V_SDS_DDI(struct S_DDI p0, double p1, struct S_DDI p2) { }
+EXPORT void f8_V_SDS_DDF(struct S_DDF p0, double p1, struct S_DDF p2) { }
+EXPORT void f8_V_SDS_DDD(struct S_DDD p0, double p1, struct S_DDD p2) { }
+EXPORT void f8_V_SDS_DDP(struct S_DDP p0, double p1, struct S_DDP p2) { }
+EXPORT void f8_V_SDS_DPI(struct S_DPI p0, double p1, struct S_DPI p2) { }
+EXPORT void f8_V_SDS_DPF(struct S_DPF p0, double p1, struct S_DPF p2) { }
+EXPORT void f8_V_SDS_DPD(struct S_DPD p0, double p1, struct S_DPD p2) { }
+EXPORT void f8_V_SDS_DPP(struct S_DPP p0, double p1, struct S_DPP p2) { }
+EXPORT void f8_V_SDS_PII(struct S_PII p0, double p1, struct S_PII p2) { }
+EXPORT void f8_V_SDS_PIF(struct S_PIF p0, double p1, struct S_PIF p2) { }
+EXPORT void f8_V_SDS_PID(struct S_PID p0, double p1, struct S_PID p2) { }
+EXPORT void f8_V_SDS_PIP(struct S_PIP p0, double p1, struct S_PIP p2) { }
+EXPORT void f8_V_SDS_PFI(struct S_PFI p0, double p1, struct S_PFI p2) { }
+EXPORT void f8_V_SDS_PFF(struct S_PFF p0, double p1, struct S_PFF p2) { }
+EXPORT void f8_V_SDS_PFD(struct S_PFD p0, double p1, struct S_PFD p2) { }
+EXPORT void f8_V_SDS_PFP(struct S_PFP p0, double p1, struct S_PFP p2) { }
+EXPORT void f8_V_SDS_PDI(struct S_PDI p0, double p1, struct S_PDI p2) { }
+EXPORT void f8_V_SDS_PDF(struct S_PDF p0, double p1, struct S_PDF p2) { }
+EXPORT void f8_V_SDS_PDD(struct S_PDD p0, double p1, struct S_PDD p2) { }
+EXPORT void f8_V_SDS_PDP(struct S_PDP p0, double p1, struct S_PDP p2) { }
+EXPORT void f8_V_SDS_PPI(struct S_PPI p0, double p1, struct S_PPI p2) { }
+EXPORT void f8_V_SDS_PPF(struct S_PPF p0, double p1, struct S_PPF p2) { }
+EXPORT void f8_V_SDS_PPD(struct S_PPD p0, double p1, struct S_PPD p2) { }
+EXPORT void f8_V_SDS_PPP(struct S_PPP p0, double p1, struct S_PPP p2) { }
+EXPORT void f8_V_SPI_I(struct S_I p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_F(struct S_F p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_D(struct S_D p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_P(struct S_P p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_II(struct S_II p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_IF(struct S_IF p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_ID(struct S_ID p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_IP(struct S_IP p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_FI(struct S_FI p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_FF(struct S_FF p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_FD(struct S_FD p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_FP(struct S_FP p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_DI(struct S_DI p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_DF(struct S_DF p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_DD(struct S_DD p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_DP(struct S_DP p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_PI(struct S_PI p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_PF(struct S_PF p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_PD(struct S_PD p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_PP(struct S_PP p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_III(struct S_III p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_IIF(struct S_IIF p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_IID(struct S_IID p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_IIP(struct S_IIP p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_IFI(struct S_IFI p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_IFF(struct S_IFF p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_IFD(struct S_IFD p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_IFP(struct S_IFP p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_IDI(struct S_IDI p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_IDF(struct S_IDF p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_IDD(struct S_IDD p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_IDP(struct S_IDP p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_IPI(struct S_IPI p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_IPF(struct S_IPF p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_IPD(struct S_IPD p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_IPP(struct S_IPP p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_FII(struct S_FII p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_FIF(struct S_FIF p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_FID(struct S_FID p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_FIP(struct S_FIP p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_FFI(struct S_FFI p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_FFF(struct S_FFF p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_FFD(struct S_FFD p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_FFP(struct S_FFP p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_FDI(struct S_FDI p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_FDF(struct S_FDF p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_FDD(struct S_FDD p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_FDP(struct S_FDP p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_FPI(struct S_FPI p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_FPF(struct S_FPF p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_FPD(struct S_FPD p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_FPP(struct S_FPP p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_DII(struct S_DII p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_DIF(struct S_DIF p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_DID(struct S_DID p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_DIP(struct S_DIP p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_DFI(struct S_DFI p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_DFF(struct S_DFF p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_DFD(struct S_DFD p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_DFP(struct S_DFP p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_DDI(struct S_DDI p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_DDF(struct S_DDF p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_DDD(struct S_DDD p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_DDP(struct S_DDP p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_DPI(struct S_DPI p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_DPF(struct S_DPF p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_DPD(struct S_DPD p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_DPP(struct S_DPP p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_PII(struct S_PII p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_PIF(struct S_PIF p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_PID(struct S_PID p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_PIP(struct S_PIP p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_PFI(struct S_PFI p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_PFF(struct S_PFF p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_PFD(struct S_PFD p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_PFP(struct S_PFP p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_PDI(struct S_PDI p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_PDF(struct S_PDF p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_PDD(struct S_PDD p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_PDP(struct S_PDP p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_PPI(struct S_PPI p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_PPF(struct S_PPF p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_PPD(struct S_PPD p0, void* p1, int p2) { }
+EXPORT void f8_V_SPI_PPP(struct S_PPP p0, void* p1, int p2) { }
+EXPORT void f8_V_SPF_I(struct S_I p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_F(struct S_F p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_D(struct S_D p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_P(struct S_P p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_II(struct S_II p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_IF(struct S_IF p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_ID(struct S_ID p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_IP(struct S_IP p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_FI(struct S_FI p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_FF(struct S_FF p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_FD(struct S_FD p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_FP(struct S_FP p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_DI(struct S_DI p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_DF(struct S_DF p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_DD(struct S_DD p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_DP(struct S_DP p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_PI(struct S_PI p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_PF(struct S_PF p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_PD(struct S_PD p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_PP(struct S_PP p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_III(struct S_III p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_IIF(struct S_IIF p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_IID(struct S_IID p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_IIP(struct S_IIP p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_IFI(struct S_IFI p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_IFF(struct S_IFF p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_IFD(struct S_IFD p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_IFP(struct S_IFP p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_IDI(struct S_IDI p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_IDF(struct S_IDF p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_IDD(struct S_IDD p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_IDP(struct S_IDP p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_IPI(struct S_IPI p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_IPF(struct S_IPF p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_IPD(struct S_IPD p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_IPP(struct S_IPP p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_FII(struct S_FII p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_FIF(struct S_FIF p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_FID(struct S_FID p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_FIP(struct S_FIP p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_FFI(struct S_FFI p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_FFF(struct S_FFF p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_FFD(struct S_FFD p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_FFP(struct S_FFP p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_FDI(struct S_FDI p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_FDF(struct S_FDF p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_FDD(struct S_FDD p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_FDP(struct S_FDP p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_FPI(struct S_FPI p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_FPF(struct S_FPF p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_FPD(struct S_FPD p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_FPP(struct S_FPP p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_DII(struct S_DII p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_DIF(struct S_DIF p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_DID(struct S_DID p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_DIP(struct S_DIP p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_DFI(struct S_DFI p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_DFF(struct S_DFF p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_DFD(struct S_DFD p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_DFP(struct S_DFP p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_DDI(struct S_DDI p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_DDF(struct S_DDF p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_DDD(struct S_DDD p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_DDP(struct S_DDP p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_DPI(struct S_DPI p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_DPF(struct S_DPF p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_DPD(struct S_DPD p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_DPP(struct S_DPP p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_PII(struct S_PII p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_PIF(struct S_PIF p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_PID(struct S_PID p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_PIP(struct S_PIP p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_PFI(struct S_PFI p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_PFF(struct S_PFF p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_PFD(struct S_PFD p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_PFP(struct S_PFP p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_PDI(struct S_PDI p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_PDF(struct S_PDF p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_PDD(struct S_PDD p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_PDP(struct S_PDP p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_PPI(struct S_PPI p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_PPF(struct S_PPF p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_PPD(struct S_PPD p0, void* p1, float p2) { }
+EXPORT void f8_V_SPF_PPP(struct S_PPP p0, void* p1, float p2) { }
+EXPORT void f8_V_SPD_I(struct S_I p0, void* p1, double p2) { }
+EXPORT void f8_V_SPD_F(struct S_F p0, void* p1, double p2) { }
+EXPORT void f8_V_SPD_D(struct S_D p0, void* p1, double p2) { }
+EXPORT void f8_V_SPD_P(struct S_P p0, void* p1, double p2) { }
+EXPORT void f8_V_SPD_II(struct S_II p0, void* p1, double p2) { }
+EXPORT void f8_V_SPD_IF(struct S_IF p0, void* p1, double p2) { }
+EXPORT void f8_V_SPD_ID(struct S_ID p0, void* p1, double p2) { }
+EXPORT void f8_V_SPD_IP(struct S_IP p0, void* p1, double p2) { }
+EXPORT void f8_V_SPD_FI(struct S_FI p0, void* p1, double p2) { }
+EXPORT void f8_V_SPD_FF(struct S_FF p0, void* p1, double p2) { }
+EXPORT void f8_V_SPD_FD(struct S_FD p0, void* p1, double p2) { }
+EXPORT void f8_V_SPD_FP(struct S_FP p0, void* p1, double p2) { }
+EXPORT void f8_V_SPD_DI(struct S_DI p0, void* p1, double p2) { }
+EXPORT void f8_V_SPD_DF(struct S_DF p0, void* p1, double p2) { }
+EXPORT void f8_V_SPD_DD(struct S_DD p0, void* p1, double p2) { }
+EXPORT void f8_V_SPD_DP(struct S_DP p0, void* p1, double p2) { }
+EXPORT void f8_V_SPD_PI(struct S_PI p0, void* p1, double p2) { }
+EXPORT void f8_V_SPD_PF(struct S_PF p0, void* p1, double p2) { }
+EXPORT void f8_V_SPD_PD(struct S_PD p0, void* p1, double p2) { }
+EXPORT void f8_V_SPD_PP(struct S_PP p0, void* p1, double p2) { }
+EXPORT void f8_V_SPD_III(struct S_III p0, void* p1, double p2) { }
+EXPORT void f8_V_SPD_IIF(struct S_IIF p0, void* p1, double p2) { }
+EXPORT void f8_V_SPD_IID(struct S_IID p0, void* p1, double p2) { }
+EXPORT void f9_V_SPD_IIP(struct S_IIP p0, void* p1, double p2) { }
+EXPORT void f9_V_SPD_IFI(struct S_IFI p0, void* p1, double p2) { }
+EXPORT void f9_V_SPD_IFF(struct S_IFF p0, void* p1, double p2) { }
+EXPORT void f9_V_SPD_IFD(struct S_IFD p0, void* p1, double p2) { }
+EXPORT void f9_V_SPD_IFP(struct S_IFP p0, void* p1, double p2) { }
+EXPORT void f9_V_SPD_IDI(struct S_IDI p0, void* p1, double p2) { }
+EXPORT void f9_V_SPD_IDF(struct S_IDF p0, void* p1, double p2) { }
+EXPORT void f9_V_SPD_IDD(struct S_IDD p0, void* p1, double p2) { }
+EXPORT void f9_V_SPD_IDP(struct S_IDP p0, void* p1, double p2) { }
+EXPORT void f9_V_SPD_IPI(struct S_IPI p0, void* p1, double p2) { }
+EXPORT void f9_V_SPD_IPF(struct S_IPF p0, void* p1, double p2) { }
+EXPORT void f9_V_SPD_IPD(struct S_IPD p0, void* p1, double p2) { }
+EXPORT void f9_V_SPD_IPP(struct S_IPP p0, void* p1, double p2) { }
+EXPORT void f9_V_SPD_FII(struct S_FII p0, void* p1, double p2) { }
+EXPORT void f9_V_SPD_FIF(struct S_FIF p0, void* p1, double p2) { }
+EXPORT void f9_V_SPD_FID(struct S_FID p0, void* p1, double p2) { }
+EXPORT void f9_V_SPD_FIP(struct S_FIP p0, void* p1, double p2) { }
+EXPORT void f9_V_SPD_FFI(struct S_FFI p0, void* p1, double p2) { }
+EXPORT void f9_V_SPD_FFF(struct S_FFF p0, void* p1, double p2) { }
+EXPORT void f9_V_SPD_FFD(struct S_FFD p0, void* p1, double p2) { }
+EXPORT void f9_V_SPD_FFP(struct S_FFP p0, void* p1, double p2) { }
+EXPORT void f9_V_SPD_FDI(struct S_FDI p0, void* p1, double p2) { }
+EXPORT void f9_V_SPD_FDF(struct S_FDF p0, void* p1, double p2) { }
+EXPORT void f9_V_SPD_FDD(struct S_FDD p0, void* p1, double p2) { }
+EXPORT void f9_V_SPD_FDP(struct S_FDP p0, void* p1, double p2) { }
+EXPORT void f9_V_SPD_FPI(struct S_FPI p0, void* p1, double p2) { }
+EXPORT void f9_V_SPD_FPF(struct S_FPF p0, void* p1, double p2) { }
+EXPORT void f9_V_SPD_FPD(struct S_FPD p0, void* p1, double p2) { }
+EXPORT void f9_V_SPD_FPP(struct S_FPP p0, void* p1, double p2) { }
+EXPORT void f9_V_SPD_DII(struct S_DII p0, void* p1, double p2) { }
+EXPORT void f9_V_SPD_DIF(struct S_DIF p0, void* p1, double p2) { }
+EXPORT void f9_V_SPD_DID(struct S_DID p0, void* p1, double p2) { }
+EXPORT void f9_V_SPD_DIP(struct S_DIP p0, void* p1, double p2) { }
+EXPORT void f9_V_SPD_DFI(struct S_DFI p0, void* p1, double p2) { }
+EXPORT void f9_V_SPD_DFF(struct S_DFF p0, void* p1, double p2) { }
+EXPORT void f9_V_SPD_DFD(struct S_DFD p0, void* p1, double p2) { }
+EXPORT void f9_V_SPD_DFP(struct S_DFP p0, void* p1, double p2) { }
+EXPORT void f9_V_SPD_DDI(struct S_DDI p0, void* p1, double p2) { }
+EXPORT void f9_V_SPD_DDF(struct S_DDF p0, void* p1, double p2) { }
+EXPORT void f9_V_SPD_DDD(struct S_DDD p0, void* p1, double p2) { }
+EXPORT void f9_V_SPD_DDP(struct S_DDP p0, void* p1, double p2) { }
+EXPORT void f9_V_SPD_DPI(struct S_DPI p0, void* p1, double p2) { }
+EXPORT void f9_V_SPD_DPF(struct S_DPF p0, void* p1, double p2) { }
+EXPORT void f9_V_SPD_DPD(struct S_DPD p0, void* p1, double p2) { }
+EXPORT void f9_V_SPD_DPP(struct S_DPP p0, void* p1, double p2) { }
+EXPORT void f9_V_SPD_PII(struct S_PII p0, void* p1, double p2) { }
+EXPORT void f9_V_SPD_PIF(struct S_PIF p0, void* p1, double p2) { }
+EXPORT void f9_V_SPD_PID(struct S_PID p0, void* p1, double p2) { }
+EXPORT void f9_V_SPD_PIP(struct S_PIP p0, void* p1, double p2) { }
+EXPORT void f9_V_SPD_PFI(struct S_PFI p0, void* p1, double p2) { }
+EXPORT void f9_V_SPD_PFF(struct S_PFF p0, void* p1, double p2) { }
+EXPORT void f9_V_SPD_PFD(struct S_PFD p0, void* p1, double p2) { }
+EXPORT void f9_V_SPD_PFP(struct S_PFP p0, void* p1, double p2) { }
+EXPORT void f9_V_SPD_PDI(struct S_PDI p0, void* p1, double p2) { }
+EXPORT void f9_V_SPD_PDF(struct S_PDF p0, void* p1, double p2) { }
+EXPORT void f9_V_SPD_PDD(struct S_PDD p0, void* p1, double p2) { }
+EXPORT void f9_V_SPD_PDP(struct S_PDP p0, void* p1, double p2) { }
+EXPORT void f9_V_SPD_PPI(struct S_PPI p0, void* p1, double p2) { }
+EXPORT void f9_V_SPD_PPF(struct S_PPF p0, void* p1, double p2) { }
+EXPORT void f9_V_SPD_PPD(struct S_PPD p0, void* p1, double p2) { }
+EXPORT void f9_V_SPD_PPP(struct S_PPP p0, void* p1, double p2) { }
+EXPORT void f9_V_SPP_I(struct S_I p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_F(struct S_F p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_D(struct S_D p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_P(struct S_P p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_II(struct S_II p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_IF(struct S_IF p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_ID(struct S_ID p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_IP(struct S_IP p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_FI(struct S_FI p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_FF(struct S_FF p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_FD(struct S_FD p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_FP(struct S_FP p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_DI(struct S_DI p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_DF(struct S_DF p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_DD(struct S_DD p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_DP(struct S_DP p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_PI(struct S_PI p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_PF(struct S_PF p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_PD(struct S_PD p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_PP(struct S_PP p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_III(struct S_III p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_IIF(struct S_IIF p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_IID(struct S_IID p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_IIP(struct S_IIP p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_IFI(struct S_IFI p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_IFF(struct S_IFF p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_IFD(struct S_IFD p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_IFP(struct S_IFP p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_IDI(struct S_IDI p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_IDF(struct S_IDF p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_IDD(struct S_IDD p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_IDP(struct S_IDP p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_IPI(struct S_IPI p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_IPF(struct S_IPF p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_IPD(struct S_IPD p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_IPP(struct S_IPP p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_FII(struct S_FII p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_FIF(struct S_FIF p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_FID(struct S_FID p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_FIP(struct S_FIP p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_FFI(struct S_FFI p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_FFF(struct S_FFF p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_FFD(struct S_FFD p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_FFP(struct S_FFP p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_FDI(struct S_FDI p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_FDF(struct S_FDF p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_FDD(struct S_FDD p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_FDP(struct S_FDP p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_FPI(struct S_FPI p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_FPF(struct S_FPF p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_FPD(struct S_FPD p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_FPP(struct S_FPP p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_DII(struct S_DII p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_DIF(struct S_DIF p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_DID(struct S_DID p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_DIP(struct S_DIP p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_DFI(struct S_DFI p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_DFF(struct S_DFF p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_DFD(struct S_DFD p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_DFP(struct S_DFP p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_DDI(struct S_DDI p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_DDF(struct S_DDF p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_DDD(struct S_DDD p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_DDP(struct S_DDP p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_DPI(struct S_DPI p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_DPF(struct S_DPF p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_DPD(struct S_DPD p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_DPP(struct S_DPP p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_PII(struct S_PII p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_PIF(struct S_PIF p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_PID(struct S_PID p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_PIP(struct S_PIP p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_PFI(struct S_PFI p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_PFF(struct S_PFF p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_PFD(struct S_PFD p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_PFP(struct S_PFP p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_PDI(struct S_PDI p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_PDF(struct S_PDF p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_PDD(struct S_PDD p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_PDP(struct S_PDP p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_PPI(struct S_PPI p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_PPF(struct S_PPF p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_PPD(struct S_PPD p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPP_PPP(struct S_PPP p0, void* p1, void* p2) { }
+EXPORT void f9_V_SPS_I(struct S_I p0, void* p1, struct S_I p2) { }
+EXPORT void f9_V_SPS_F(struct S_F p0, void* p1, struct S_F p2) { }
+EXPORT void f9_V_SPS_D(struct S_D p0, void* p1, struct S_D p2) { }
+EXPORT void f9_V_SPS_P(struct S_P p0, void* p1, struct S_P p2) { }
+EXPORT void f9_V_SPS_II(struct S_II p0, void* p1, struct S_II p2) { }
+EXPORT void f9_V_SPS_IF(struct S_IF p0, void* p1, struct S_IF p2) { }
+EXPORT void f9_V_SPS_ID(struct S_ID p0, void* p1, struct S_ID p2) { }
+EXPORT void f9_V_SPS_IP(struct S_IP p0, void* p1, struct S_IP p2) { }
+EXPORT void f9_V_SPS_FI(struct S_FI p0, void* p1, struct S_FI p2) { }
+EXPORT void f9_V_SPS_FF(struct S_FF p0, void* p1, struct S_FF p2) { }
+EXPORT void f9_V_SPS_FD(struct S_FD p0, void* p1, struct S_FD p2) { }
+EXPORT void f9_V_SPS_FP(struct S_FP p0, void* p1, struct S_FP p2) { }
+EXPORT void f9_V_SPS_DI(struct S_DI p0, void* p1, struct S_DI p2) { }
+EXPORT void f9_V_SPS_DF(struct S_DF p0, void* p1, struct S_DF p2) { }
+EXPORT void f9_V_SPS_DD(struct S_DD p0, void* p1, struct S_DD p2) { }
+EXPORT void f9_V_SPS_DP(struct S_DP p0, void* p1, struct S_DP p2) { }
+EXPORT void f9_V_SPS_PI(struct S_PI p0, void* p1, struct S_PI p2) { }
+EXPORT void f9_V_SPS_PF(struct S_PF p0, void* p1, struct S_PF p2) { }
+EXPORT void f9_V_SPS_PD(struct S_PD p0, void* p1, struct S_PD p2) { }
+EXPORT void f9_V_SPS_PP(struct S_PP p0, void* p1, struct S_PP p2) { }
+EXPORT void f9_V_SPS_III(struct S_III p0, void* p1, struct S_III p2) { }
+EXPORT void f9_V_SPS_IIF(struct S_IIF p0, void* p1, struct S_IIF p2) { }
+EXPORT void f9_V_SPS_IID(struct S_IID p0, void* p1, struct S_IID p2) { }
+EXPORT void f9_V_SPS_IIP(struct S_IIP p0, void* p1, struct S_IIP p2) { }
+EXPORT void f9_V_SPS_IFI(struct S_IFI p0, void* p1, struct S_IFI p2) { }
+EXPORT void f9_V_SPS_IFF(struct S_IFF p0, void* p1, struct S_IFF p2) { }
+EXPORT void f9_V_SPS_IFD(struct S_IFD p0, void* p1, struct S_IFD p2) { }
+EXPORT void f9_V_SPS_IFP(struct S_IFP p0, void* p1, struct S_IFP p2) { }
+EXPORT void f9_V_SPS_IDI(struct S_IDI p0, void* p1, struct S_IDI p2) { }
+EXPORT void f9_V_SPS_IDF(struct S_IDF p0, void* p1, struct S_IDF p2) { }
+EXPORT void f9_V_SPS_IDD(struct S_IDD p0, void* p1, struct S_IDD p2) { }
+EXPORT void f9_V_SPS_IDP(struct S_IDP p0, void* p1, struct S_IDP p2) { }
+EXPORT void f9_V_SPS_IPI(struct S_IPI p0, void* p1, struct S_IPI p2) { }
+EXPORT void f9_V_SPS_IPF(struct S_IPF p0, void* p1, struct S_IPF p2) { }
+EXPORT void f9_V_SPS_IPD(struct S_IPD p0, void* p1, struct S_IPD p2) { }
+EXPORT void f9_V_SPS_IPP(struct S_IPP p0, void* p1, struct S_IPP p2) { }
+EXPORT void f9_V_SPS_FII(struct S_FII p0, void* p1, struct S_FII p2) { }
+EXPORT void f9_V_SPS_FIF(struct S_FIF p0, void* p1, struct S_FIF p2) { }
+EXPORT void f9_V_SPS_FID(struct S_FID p0, void* p1, struct S_FID p2) { }
+EXPORT void f9_V_SPS_FIP(struct S_FIP p0, void* p1, struct S_FIP p2) { }
+EXPORT void f9_V_SPS_FFI(struct S_FFI p0, void* p1, struct S_FFI p2) { }
+EXPORT void f9_V_SPS_FFF(struct S_FFF p0, void* p1, struct S_FFF p2) { }
+EXPORT void f9_V_SPS_FFD(struct S_FFD p0, void* p1, struct S_FFD p2) { }
+EXPORT void f9_V_SPS_FFP(struct S_FFP p0, void* p1, struct S_FFP p2) { }
+EXPORT void f9_V_SPS_FDI(struct S_FDI p0, void* p1, struct S_FDI p2) { }
+EXPORT void f9_V_SPS_FDF(struct S_FDF p0, void* p1, struct S_FDF p2) { }
+EXPORT void f9_V_SPS_FDD(struct S_FDD p0, void* p1, struct S_FDD p2) { }
+EXPORT void f9_V_SPS_FDP(struct S_FDP p0, void* p1, struct S_FDP p2) { }
+EXPORT void f9_V_SPS_FPI(struct S_FPI p0, void* p1, struct S_FPI p2) { }
+EXPORT void f9_V_SPS_FPF(struct S_FPF p0, void* p1, struct S_FPF p2) { }
+EXPORT void f9_V_SPS_FPD(struct S_FPD p0, void* p1, struct S_FPD p2) { }
+EXPORT void f9_V_SPS_FPP(struct S_FPP p0, void* p1, struct S_FPP p2) { }
+EXPORT void f9_V_SPS_DII(struct S_DII p0, void* p1, struct S_DII p2) { }
+EXPORT void f9_V_SPS_DIF(struct S_DIF p0, void* p1, struct S_DIF p2) { }
+EXPORT void f9_V_SPS_DID(struct S_DID p0, void* p1, struct S_DID p2) { }
+EXPORT void f9_V_SPS_DIP(struct S_DIP p0, void* p1, struct S_DIP p2) { }
+EXPORT void f9_V_SPS_DFI(struct S_DFI p0, void* p1, struct S_DFI p2) { }
+EXPORT void f9_V_SPS_DFF(struct S_DFF p0, void* p1, struct S_DFF p2) { }
+EXPORT void f9_V_SPS_DFD(struct S_DFD p0, void* p1, struct S_DFD p2) { }
+EXPORT void f9_V_SPS_DFP(struct S_DFP p0, void* p1, struct S_DFP p2) { }
+EXPORT void f9_V_SPS_DDI(struct S_DDI p0, void* p1, struct S_DDI p2) { }
+EXPORT void f9_V_SPS_DDF(struct S_DDF p0, void* p1, struct S_DDF p2) { }
+EXPORT void f9_V_SPS_DDD(struct S_DDD p0, void* p1, struct S_DDD p2) { }
+EXPORT void f9_V_SPS_DDP(struct S_DDP p0, void* p1, struct S_DDP p2) { }
+EXPORT void f9_V_SPS_DPI(struct S_DPI p0, void* p1, struct S_DPI p2) { }
+EXPORT void f9_V_SPS_DPF(struct S_DPF p0, void* p1, struct S_DPF p2) { }
+EXPORT void f9_V_SPS_DPD(struct S_DPD p0, void* p1, struct S_DPD p2) { }
+EXPORT void f9_V_SPS_DPP(struct S_DPP p0, void* p1, struct S_DPP p2) { }
+EXPORT void f9_V_SPS_PII(struct S_PII p0, void* p1, struct S_PII p2) { }
+EXPORT void f9_V_SPS_PIF(struct S_PIF p0, void* p1, struct S_PIF p2) { }
+EXPORT void f9_V_SPS_PID(struct S_PID p0, void* p1, struct S_PID p2) { }
+EXPORT void f9_V_SPS_PIP(struct S_PIP p0, void* p1, struct S_PIP p2) { }
+EXPORT void f9_V_SPS_PFI(struct S_PFI p0, void* p1, struct S_PFI p2) { }
+EXPORT void f9_V_SPS_PFF(struct S_PFF p0, void* p1, struct S_PFF p2) { }
+EXPORT void f9_V_SPS_PFD(struct S_PFD p0, void* p1, struct S_PFD p2) { }
+EXPORT void f9_V_SPS_PFP(struct S_PFP p0, void* p1, struct S_PFP p2) { }
+EXPORT void f9_V_SPS_PDI(struct S_PDI p0, void* p1, struct S_PDI p2) { }
+EXPORT void f9_V_SPS_PDF(struct S_PDF p0, void* p1, struct S_PDF p2) { }
+EXPORT void f9_V_SPS_PDD(struct S_PDD p0, void* p1, struct S_PDD p2) { }
+EXPORT void f9_V_SPS_PDP(struct S_PDP p0, void* p1, struct S_PDP p2) { }
+EXPORT void f9_V_SPS_PPI(struct S_PPI p0, void* p1, struct S_PPI p2) { }
+EXPORT void f9_V_SPS_PPF(struct S_PPF p0, void* p1, struct S_PPF p2) { }
+EXPORT void f9_V_SPS_PPD(struct S_PPD p0, void* p1, struct S_PPD p2) { }
+EXPORT void f9_V_SPS_PPP(struct S_PPP p0, void* p1, struct S_PPP p2) { }
+EXPORT void f9_V_SSI_I(struct S_I p0, struct S_I p1, int p2) { }
+EXPORT void f9_V_SSI_F(struct S_F p0, struct S_F p1, int p2) { }
+EXPORT void f9_V_SSI_D(struct S_D p0, struct S_D p1, int p2) { }
+EXPORT void f9_V_SSI_P(struct S_P p0, struct S_P p1, int p2) { }
+EXPORT void f9_V_SSI_II(struct S_II p0, struct S_II p1, int p2) { }
+EXPORT void f9_V_SSI_IF(struct S_IF p0, struct S_IF p1, int p2) { }
+EXPORT void f9_V_SSI_ID(struct S_ID p0, struct S_ID p1, int p2) { }
+EXPORT void f9_V_SSI_IP(struct S_IP p0, struct S_IP p1, int p2) { }
+EXPORT void f9_V_SSI_FI(struct S_FI p0, struct S_FI p1, int p2) { }
+EXPORT void f9_V_SSI_FF(struct S_FF p0, struct S_FF p1, int p2) { }
+EXPORT void f9_V_SSI_FD(struct S_FD p0, struct S_FD p1, int p2) { }
+EXPORT void f9_V_SSI_FP(struct S_FP p0, struct S_FP p1, int p2) { }
+EXPORT void f9_V_SSI_DI(struct S_DI p0, struct S_DI p1, int p2) { }
+EXPORT void f9_V_SSI_DF(struct S_DF p0, struct S_DF p1, int p2) { }
+EXPORT void f9_V_SSI_DD(struct S_DD p0, struct S_DD p1, int p2) { }
+EXPORT void f9_V_SSI_DP(struct S_DP p0, struct S_DP p1, int p2) { }
+EXPORT void f9_V_SSI_PI(struct S_PI p0, struct S_PI p1, int p2) { }
+EXPORT void f9_V_SSI_PF(struct S_PF p0, struct S_PF p1, int p2) { }
+EXPORT void f9_V_SSI_PD(struct S_PD p0, struct S_PD p1, int p2) { }
+EXPORT void f9_V_SSI_PP(struct S_PP p0, struct S_PP p1, int p2) { }
+EXPORT void f9_V_SSI_III(struct S_III p0, struct S_III p1, int p2) { }
+EXPORT void f9_V_SSI_IIF(struct S_IIF p0, struct S_IIF p1, int p2) { }
+EXPORT void f9_V_SSI_IID(struct S_IID p0, struct S_IID p1, int p2) { }
+EXPORT void f9_V_SSI_IIP(struct S_IIP p0, struct S_IIP p1, int p2) { }
+EXPORT void f9_V_SSI_IFI(struct S_IFI p0, struct S_IFI p1, int p2) { }
+EXPORT void f9_V_SSI_IFF(struct S_IFF p0, struct S_IFF p1, int p2) { }
+EXPORT void f9_V_SSI_IFD(struct S_IFD p0, struct S_IFD p1, int p2) { }
+EXPORT void f9_V_SSI_IFP(struct S_IFP p0, struct S_IFP p1, int p2) { }
+EXPORT void f9_V_SSI_IDI(struct S_IDI p0, struct S_IDI p1, int p2) { }
+EXPORT void f9_V_SSI_IDF(struct S_IDF p0, struct S_IDF p1, int p2) { }
+EXPORT void f9_V_SSI_IDD(struct S_IDD p0, struct S_IDD p1, int p2) { }
+EXPORT void f9_V_SSI_IDP(struct S_IDP p0, struct S_IDP p1, int p2) { }
+EXPORT void f9_V_SSI_IPI(struct S_IPI p0, struct S_IPI p1, int p2) { }
+EXPORT void f9_V_SSI_IPF(struct S_IPF p0, struct S_IPF p1, int p2) { }
+EXPORT void f9_V_SSI_IPD(struct S_IPD p0, struct S_IPD p1, int p2) { }
+EXPORT void f9_V_SSI_IPP(struct S_IPP p0, struct S_IPP p1, int p2) { }
+EXPORT void f9_V_SSI_FII(struct S_FII p0, struct S_FII p1, int p2) { }
+EXPORT void f9_V_SSI_FIF(struct S_FIF p0, struct S_FIF p1, int p2) { }
+EXPORT void f9_V_SSI_FID(struct S_FID p0, struct S_FID p1, int p2) { }
+EXPORT void f9_V_SSI_FIP(struct S_FIP p0, struct S_FIP p1, int p2) { }
+EXPORT void f9_V_SSI_FFI(struct S_FFI p0, struct S_FFI p1, int p2) { }
+EXPORT void f9_V_SSI_FFF(struct S_FFF p0, struct S_FFF p1, int p2) { }
+EXPORT void f9_V_SSI_FFD(struct S_FFD p0, struct S_FFD p1, int p2) { }
+EXPORT void f9_V_SSI_FFP(struct S_FFP p0, struct S_FFP p1, int p2) { }
+EXPORT void f9_V_SSI_FDI(struct S_FDI p0, struct S_FDI p1, int p2) { }
+EXPORT void f9_V_SSI_FDF(struct S_FDF p0, struct S_FDF p1, int p2) { }
+EXPORT void f9_V_SSI_FDD(struct S_FDD p0, struct S_FDD p1, int p2) { }
+EXPORT void f9_V_SSI_FDP(struct S_FDP p0, struct S_FDP p1, int p2) { }
+EXPORT void f9_V_SSI_FPI(struct S_FPI p0, struct S_FPI p1, int p2) { }
+EXPORT void f9_V_SSI_FPF(struct S_FPF p0, struct S_FPF p1, int p2) { }
+EXPORT void f9_V_SSI_FPD(struct S_FPD p0, struct S_FPD p1, int p2) { }
+EXPORT void f9_V_SSI_FPP(struct S_FPP p0, struct S_FPP p1, int p2) { }
+EXPORT void f9_V_SSI_DII(struct S_DII p0, struct S_DII p1, int p2) { }
+EXPORT void f9_V_SSI_DIF(struct S_DIF p0, struct S_DIF p1, int p2) { }
+EXPORT void f9_V_SSI_DID(struct S_DID p0, struct S_DID p1, int p2) { }
+EXPORT void f9_V_SSI_DIP(struct S_DIP p0, struct S_DIP p1, int p2) { }
+EXPORT void f9_V_SSI_DFI(struct S_DFI p0, struct S_DFI p1, int p2) { }
+EXPORT void f9_V_SSI_DFF(struct S_DFF p0, struct S_DFF p1, int p2) { }
+EXPORT void f9_V_SSI_DFD(struct S_DFD p0, struct S_DFD p1, int p2) { }
+EXPORT void f9_V_SSI_DFP(struct S_DFP p0, struct S_DFP p1, int p2) { }
+EXPORT void f9_V_SSI_DDI(struct S_DDI p0, struct S_DDI p1, int p2) { }
+EXPORT void f9_V_SSI_DDF(struct S_DDF p0, struct S_DDF p1, int p2) { }
+EXPORT void f9_V_SSI_DDD(struct S_DDD p0, struct S_DDD p1, int p2) { }
+EXPORT void f9_V_SSI_DDP(struct S_DDP p0, struct S_DDP p1, int p2) { }
+EXPORT void f9_V_SSI_DPI(struct S_DPI p0, struct S_DPI p1, int p2) { }
+EXPORT void f9_V_SSI_DPF(struct S_DPF p0, struct S_DPF p1, int p2) { }
+EXPORT void f9_V_SSI_DPD(struct S_DPD p0, struct S_DPD p1, int p2) { }
+EXPORT void f9_V_SSI_DPP(struct S_DPP p0, struct S_DPP p1, int p2) { }
+EXPORT void f9_V_SSI_PII(struct S_PII p0, struct S_PII p1, int p2) { }
+EXPORT void f9_V_SSI_PIF(struct S_PIF p0, struct S_PIF p1, int p2) { }
+EXPORT void f9_V_SSI_PID(struct S_PID p0, struct S_PID p1, int p2) { }
+EXPORT void f9_V_SSI_PIP(struct S_PIP p0, struct S_PIP p1, int p2) { }
+EXPORT void f9_V_SSI_PFI(struct S_PFI p0, struct S_PFI p1, int p2) { }
+EXPORT void f9_V_SSI_PFF(struct S_PFF p0, struct S_PFF p1, int p2) { }
+EXPORT void f9_V_SSI_PFD(struct S_PFD p0, struct S_PFD p1, int p2) { }
+EXPORT void f9_V_SSI_PFP(struct S_PFP p0, struct S_PFP p1, int p2) { }
+EXPORT void f9_V_SSI_PDI(struct S_PDI p0, struct S_PDI p1, int p2) { }
+EXPORT void f9_V_SSI_PDF(struct S_PDF p0, struct S_PDF p1, int p2) { }
+EXPORT void f9_V_SSI_PDD(struct S_PDD p0, struct S_PDD p1, int p2) { }
+EXPORT void f9_V_SSI_PDP(struct S_PDP p0, struct S_PDP p1, int p2) { }
+EXPORT void f9_V_SSI_PPI(struct S_PPI p0, struct S_PPI p1, int p2) { }
+EXPORT void f9_V_SSI_PPF(struct S_PPF p0, struct S_PPF p1, int p2) { }
+EXPORT void f9_V_SSI_PPD(struct S_PPD p0, struct S_PPD p1, int p2) { }
+EXPORT void f9_V_SSI_PPP(struct S_PPP p0, struct S_PPP p1, int p2) { }
+EXPORT void f9_V_SSF_I(struct S_I p0, struct S_I p1, float p2) { }
+EXPORT void f9_V_SSF_F(struct S_F p0, struct S_F p1, float p2) { }
+EXPORT void f9_V_SSF_D(struct S_D p0, struct S_D p1, float p2) { }
+EXPORT void f9_V_SSF_P(struct S_P p0, struct S_P p1, float p2) { }
+EXPORT void f9_V_SSF_II(struct S_II p0, struct S_II p1, float p2) { }
+EXPORT void f9_V_SSF_IF(struct S_IF p0, struct S_IF p1, float p2) { }
+EXPORT void f9_V_SSF_ID(struct S_ID p0, struct S_ID p1, float p2) { }
+EXPORT void f9_V_SSF_IP(struct S_IP p0, struct S_IP p1, float p2) { }
+EXPORT void f9_V_SSF_FI(struct S_FI p0, struct S_FI p1, float p2) { }
+EXPORT void f9_V_SSF_FF(struct S_FF p0, struct S_FF p1, float p2) { }
+EXPORT void f9_V_SSF_FD(struct S_FD p0, struct S_FD p1, float p2) { }
+EXPORT void f9_V_SSF_FP(struct S_FP p0, struct S_FP p1, float p2) { }
+EXPORT void f9_V_SSF_DI(struct S_DI p0, struct S_DI p1, float p2) { }
+EXPORT void f9_V_SSF_DF(struct S_DF p0, struct S_DF p1, float p2) { }
+EXPORT void f9_V_SSF_DD(struct S_DD p0, struct S_DD p1, float p2) { }
+EXPORT void f9_V_SSF_DP(struct S_DP p0, struct S_DP p1, float p2) { }
+EXPORT void f9_V_SSF_PI(struct S_PI p0, struct S_PI p1, float p2) { }
+EXPORT void f9_V_SSF_PF(struct S_PF p0, struct S_PF p1, float p2) { }
+EXPORT void f9_V_SSF_PD(struct S_PD p0, struct S_PD p1, float p2) { }
+EXPORT void f9_V_SSF_PP(struct S_PP p0, struct S_PP p1, float p2) { }
+EXPORT void f9_V_SSF_III(struct S_III p0, struct S_III p1, float p2) { }
+EXPORT void f9_V_SSF_IIF(struct S_IIF p0, struct S_IIF p1, float p2) { }
+EXPORT void f9_V_SSF_IID(struct S_IID p0, struct S_IID p1, float p2) { }
+EXPORT void f9_V_SSF_IIP(struct S_IIP p0, struct S_IIP p1, float p2) { }
+EXPORT void f9_V_SSF_IFI(struct S_IFI p0, struct S_IFI p1, float p2) { }
+EXPORT void f9_V_SSF_IFF(struct S_IFF p0, struct S_IFF p1, float p2) { }
+EXPORT void f9_V_SSF_IFD(struct S_IFD p0, struct S_IFD p1, float p2) { }
+EXPORT void f9_V_SSF_IFP(struct S_IFP p0, struct S_IFP p1, float p2) { }
+EXPORT void f9_V_SSF_IDI(struct S_IDI p0, struct S_IDI p1, float p2) { }
+EXPORT void f9_V_SSF_IDF(struct S_IDF p0, struct S_IDF p1, float p2) { }
+EXPORT void f9_V_SSF_IDD(struct S_IDD p0, struct S_IDD p1, float p2) { }
+EXPORT void f9_V_SSF_IDP(struct S_IDP p0, struct S_IDP p1, float p2) { }
+EXPORT void f9_V_SSF_IPI(struct S_IPI p0, struct S_IPI p1, float p2) { }
+EXPORT void f9_V_SSF_IPF(struct S_IPF p0, struct S_IPF p1, float p2) { }
+EXPORT void f9_V_SSF_IPD(struct S_IPD p0, struct S_IPD p1, float p2) { }
+EXPORT void f9_V_SSF_IPP(struct S_IPP p0, struct S_IPP p1, float p2) { }
+EXPORT void f9_V_SSF_FII(struct S_FII p0, struct S_FII p1, float p2) { }
+EXPORT void f9_V_SSF_FIF(struct S_FIF p0, struct S_FIF p1, float p2) { }
+EXPORT void f9_V_SSF_FID(struct S_FID p0, struct S_FID p1, float p2) { }
+EXPORT void f9_V_SSF_FIP(struct S_FIP p0, struct S_FIP p1, float p2) { }
+EXPORT void f9_V_SSF_FFI(struct S_FFI p0, struct S_FFI p1, float p2) { }
+EXPORT void f9_V_SSF_FFF(struct S_FFF p0, struct S_FFF p1, float p2) { }
+EXPORT void f9_V_SSF_FFD(struct S_FFD p0, struct S_FFD p1, float p2) { }
+EXPORT void f9_V_SSF_FFP(struct S_FFP p0, struct S_FFP p1, float p2) { }
+EXPORT void f9_V_SSF_FDI(struct S_FDI p0, struct S_FDI p1, float p2) { }
+EXPORT void f9_V_SSF_FDF(struct S_FDF p0, struct S_FDF p1, float p2) { }
+EXPORT void f9_V_SSF_FDD(struct S_FDD p0, struct S_FDD p1, float p2) { }
+EXPORT void f9_V_SSF_FDP(struct S_FDP p0, struct S_FDP p1, float p2) { }
+EXPORT void f9_V_SSF_FPI(struct S_FPI p0, struct S_FPI p1, float p2) { }
+EXPORT void f9_V_SSF_FPF(struct S_FPF p0, struct S_FPF p1, float p2) { }
+EXPORT void f9_V_SSF_FPD(struct S_FPD p0, struct S_FPD p1, float p2) { }
+EXPORT void f9_V_SSF_FPP(struct S_FPP p0, struct S_FPP p1, float p2) { }
+EXPORT void f9_V_SSF_DII(struct S_DII p0, struct S_DII p1, float p2) { }
+EXPORT void f9_V_SSF_DIF(struct S_DIF p0, struct S_DIF p1, float p2) { }
+EXPORT void f9_V_SSF_DID(struct S_DID p0, struct S_DID p1, float p2) { }
+EXPORT void f9_V_SSF_DIP(struct S_DIP p0, struct S_DIP p1, float p2) { }
+EXPORT void f9_V_SSF_DFI(struct S_DFI p0, struct S_DFI p1, float p2) { }
+EXPORT void f9_V_SSF_DFF(struct S_DFF p0, struct S_DFF p1, float p2) { }
+EXPORT void f9_V_SSF_DFD(struct S_DFD p0, struct S_DFD p1, float p2) { }
+EXPORT void f9_V_SSF_DFP(struct S_DFP p0, struct S_DFP p1, float p2) { }
+EXPORT void f9_V_SSF_DDI(struct S_DDI p0, struct S_DDI p1, float p2) { }
+EXPORT void f9_V_SSF_DDF(struct S_DDF p0, struct S_DDF p1, float p2) { }
+EXPORT void f9_V_SSF_DDD(struct S_DDD p0, struct S_DDD p1, float p2) { }
+EXPORT void f9_V_SSF_DDP(struct S_DDP p0, struct S_DDP p1, float p2) { }
+EXPORT void f9_V_SSF_DPI(struct S_DPI p0, struct S_DPI p1, float p2) { }
+EXPORT void f9_V_SSF_DPF(struct S_DPF p0, struct S_DPF p1, float p2) { }
+EXPORT void f9_V_SSF_DPD(struct S_DPD p0, struct S_DPD p1, float p2) { }
+EXPORT void f9_V_SSF_DPP(struct S_DPP p0, struct S_DPP p1, float p2) { }
+EXPORT void f9_V_SSF_PII(struct S_PII p0, struct S_PII p1, float p2) { }
+EXPORT void f9_V_SSF_PIF(struct S_PIF p0, struct S_PIF p1, float p2) { }
+EXPORT void f9_V_SSF_PID(struct S_PID p0, struct S_PID p1, float p2) { }
+EXPORT void f9_V_SSF_PIP(struct S_PIP p0, struct S_PIP p1, float p2) { }
+EXPORT void f9_V_SSF_PFI(struct S_PFI p0, struct S_PFI p1, float p2) { }
+EXPORT void f9_V_SSF_PFF(struct S_PFF p0, struct S_PFF p1, float p2) { }
+EXPORT void f9_V_SSF_PFD(struct S_PFD p0, struct S_PFD p1, float p2) { }
+EXPORT void f9_V_SSF_PFP(struct S_PFP p0, struct S_PFP p1, float p2) { }
+EXPORT void f9_V_SSF_PDI(struct S_PDI p0, struct S_PDI p1, float p2) { }
+EXPORT void f9_V_SSF_PDF(struct S_PDF p0, struct S_PDF p1, float p2) { }
+EXPORT void f9_V_SSF_PDD(struct S_PDD p0, struct S_PDD p1, float p2) { }
+EXPORT void f9_V_SSF_PDP(struct S_PDP p0, struct S_PDP p1, float p2) { }
+EXPORT void f9_V_SSF_PPI(struct S_PPI p0, struct S_PPI p1, float p2) { }
+EXPORT void f9_V_SSF_PPF(struct S_PPF p0, struct S_PPF p1, float p2) { }
+EXPORT void f9_V_SSF_PPD(struct S_PPD p0, struct S_PPD p1, float p2) { }
+EXPORT void f9_V_SSF_PPP(struct S_PPP p0, struct S_PPP p1, float p2) { }
+EXPORT void f9_V_SSD_I(struct S_I p0, struct S_I p1, double p2) { }
+EXPORT void f9_V_SSD_F(struct S_F p0, struct S_F p1, double p2) { }
+EXPORT void f9_V_SSD_D(struct S_D p0, struct S_D p1, double p2) { }
+EXPORT void f9_V_SSD_P(struct S_P p0, struct S_P p1, double p2) { }
+EXPORT void f9_V_SSD_II(struct S_II p0, struct S_II p1, double p2) { }
+EXPORT void f9_V_SSD_IF(struct S_IF p0, struct S_IF p1, double p2) { }
+EXPORT void f9_V_SSD_ID(struct S_ID p0, struct S_ID p1, double p2) { }
+EXPORT void f9_V_SSD_IP(struct S_IP p0, struct S_IP p1, double p2) { }
+EXPORT void f9_V_SSD_FI(struct S_FI p0, struct S_FI p1, double p2) { }
+EXPORT void f9_V_SSD_FF(struct S_FF p0, struct S_FF p1, double p2) { }
+EXPORT void f9_V_SSD_FD(struct S_FD p0, struct S_FD p1, double p2) { }
+EXPORT void f9_V_SSD_FP(struct S_FP p0, struct S_FP p1, double p2) { }
+EXPORT void f9_V_SSD_DI(struct S_DI p0, struct S_DI p1, double p2) { }
+EXPORT void f9_V_SSD_DF(struct S_DF p0, struct S_DF p1, double p2) { }
+EXPORT void f9_V_SSD_DD(struct S_DD p0, struct S_DD p1, double p2) { }
+EXPORT void f9_V_SSD_DP(struct S_DP p0, struct S_DP p1, double p2) { }
+EXPORT void f9_V_SSD_PI(struct S_PI p0, struct S_PI p1, double p2) { }
+EXPORT void f9_V_SSD_PF(struct S_PF p0, struct S_PF p1, double p2) { }
+EXPORT void f9_V_SSD_PD(struct S_PD p0, struct S_PD p1, double p2) { }
+EXPORT void f9_V_SSD_PP(struct S_PP p0, struct S_PP p1, double p2) { }
+EXPORT void f9_V_SSD_III(struct S_III p0, struct S_III p1, double p2) { }
+EXPORT void f9_V_SSD_IIF(struct S_IIF p0, struct S_IIF p1, double p2) { }
+EXPORT void f9_V_SSD_IID(struct S_IID p0, struct S_IID p1, double p2) { }
+EXPORT void f9_V_SSD_IIP(struct S_IIP p0, struct S_IIP p1, double p2) { }
+EXPORT void f9_V_SSD_IFI(struct S_IFI p0, struct S_IFI p1, double p2) { }
+EXPORT void f9_V_SSD_IFF(struct S_IFF p0, struct S_IFF p1, double p2) { }
+EXPORT void f9_V_SSD_IFD(struct S_IFD p0, struct S_IFD p1, double p2) { }
+EXPORT void f9_V_SSD_IFP(struct S_IFP p0, struct S_IFP p1, double p2) { }
+EXPORT void f9_V_SSD_IDI(struct S_IDI p0, struct S_IDI p1, double p2) { }
+EXPORT void f9_V_SSD_IDF(struct S_IDF p0, struct S_IDF p1, double p2) { }
+EXPORT void f9_V_SSD_IDD(struct S_IDD p0, struct S_IDD p1, double p2) { }
+EXPORT void f9_V_SSD_IDP(struct S_IDP p0, struct S_IDP p1, double p2) { }
+EXPORT void f9_V_SSD_IPI(struct S_IPI p0, struct S_IPI p1, double p2) { }
+EXPORT void f9_V_SSD_IPF(struct S_IPF p0, struct S_IPF p1, double p2) { }
+EXPORT void f9_V_SSD_IPD(struct S_IPD p0, struct S_IPD p1, double p2) { }
+EXPORT void f9_V_SSD_IPP(struct S_IPP p0, struct S_IPP p1, double p2) { }
+EXPORT void f9_V_SSD_FII(struct S_FII p0, struct S_FII p1, double p2) { }
+EXPORT void f9_V_SSD_FIF(struct S_FIF p0, struct S_FIF p1, double p2) { }
+EXPORT void f9_V_SSD_FID(struct S_FID p0, struct S_FID p1, double p2) { }
+EXPORT void f9_V_SSD_FIP(struct S_FIP p0, struct S_FIP p1, double p2) { }
+EXPORT void f9_V_SSD_FFI(struct S_FFI p0, struct S_FFI p1, double p2) { }
+EXPORT void f9_V_SSD_FFF(struct S_FFF p0, struct S_FFF p1, double p2) { }
+EXPORT void f9_V_SSD_FFD(struct S_FFD p0, struct S_FFD p1, double p2) { }
+EXPORT void f9_V_SSD_FFP(struct S_FFP p0, struct S_FFP p1, double p2) { }
+EXPORT void f9_V_SSD_FDI(struct S_FDI p0, struct S_FDI p1, double p2) { }
+EXPORT void f9_V_SSD_FDF(struct S_FDF p0, struct S_FDF p1, double p2) { }
+EXPORT void f9_V_SSD_FDD(struct S_FDD p0, struct S_FDD p1, double p2) { }
+EXPORT void f9_V_SSD_FDP(struct S_FDP p0, struct S_FDP p1, double p2) { }
+EXPORT void f9_V_SSD_FPI(struct S_FPI p0, struct S_FPI p1, double p2) { }
+EXPORT void f9_V_SSD_FPF(struct S_FPF p0, struct S_FPF p1, double p2) { }
+EXPORT void f9_V_SSD_FPD(struct S_FPD p0, struct S_FPD p1, double p2) { }
+EXPORT void f9_V_SSD_FPP(struct S_FPP p0, struct S_FPP p1, double p2) { }
+EXPORT void f9_V_SSD_DII(struct S_DII p0, struct S_DII p1, double p2) { }
+EXPORT void f9_V_SSD_DIF(struct S_DIF p0, struct S_DIF p1, double p2) { }
+EXPORT void f9_V_SSD_DID(struct S_DID p0, struct S_DID p1, double p2) { }
+EXPORT void f9_V_SSD_DIP(struct S_DIP p0, struct S_DIP p1, double p2) { }
+EXPORT void f9_V_SSD_DFI(struct S_DFI p0, struct S_DFI p1, double p2) { }
+EXPORT void f9_V_SSD_DFF(struct S_DFF p0, struct S_DFF p1, double p2) { }
+EXPORT void f9_V_SSD_DFD(struct S_DFD p0, struct S_DFD p1, double p2) { }
+EXPORT void f9_V_SSD_DFP(struct S_DFP p0, struct S_DFP p1, double p2) { }
+EXPORT void f9_V_SSD_DDI(struct S_DDI p0, struct S_DDI p1, double p2) { }
+EXPORT void f9_V_SSD_DDF(struct S_DDF p0, struct S_DDF p1, double p2) { }
+EXPORT void f9_V_SSD_DDD(struct S_DDD p0, struct S_DDD p1, double p2) { }
+EXPORT void f9_V_SSD_DDP(struct S_DDP p0, struct S_DDP p1, double p2) { }
+EXPORT void f9_V_SSD_DPI(struct S_DPI p0, struct S_DPI p1, double p2) { }
+EXPORT void f9_V_SSD_DPF(struct S_DPF p0, struct S_DPF p1, double p2) { }
+EXPORT void f9_V_SSD_DPD(struct S_DPD p0, struct S_DPD p1, double p2) { }
+EXPORT void f9_V_SSD_DPP(struct S_DPP p0, struct S_DPP p1, double p2) { }
+EXPORT void f9_V_SSD_PII(struct S_PII p0, struct S_PII p1, double p2) { }
+EXPORT void f9_V_SSD_PIF(struct S_PIF p0, struct S_PIF p1, double p2) { }
+EXPORT void f9_V_SSD_PID(struct S_PID p0, struct S_PID p1, double p2) { }
+EXPORT void f9_V_SSD_PIP(struct S_PIP p0, struct S_PIP p1, double p2) { }
+EXPORT void f9_V_SSD_PFI(struct S_PFI p0, struct S_PFI p1, double p2) { }
+EXPORT void f9_V_SSD_PFF(struct S_PFF p0, struct S_PFF p1, double p2) { }
+EXPORT void f9_V_SSD_PFD(struct S_PFD p0, struct S_PFD p1, double p2) { }
+EXPORT void f9_V_SSD_PFP(struct S_PFP p0, struct S_PFP p1, double p2) { }
+EXPORT void f9_V_SSD_PDI(struct S_PDI p0, struct S_PDI p1, double p2) { }
+EXPORT void f9_V_SSD_PDF(struct S_PDF p0, struct S_PDF p1, double p2) { }
+EXPORT void f9_V_SSD_PDD(struct S_PDD p0, struct S_PDD p1, double p2) { }
+EXPORT void f9_V_SSD_PDP(struct S_PDP p0, struct S_PDP p1, double p2) { }
+EXPORT void f9_V_SSD_PPI(struct S_PPI p0, struct S_PPI p1, double p2) { }
+EXPORT void f9_V_SSD_PPF(struct S_PPF p0, struct S_PPF p1, double p2) { }
+EXPORT void f9_V_SSD_PPD(struct S_PPD p0, struct S_PPD p1, double p2) { }
+EXPORT void f9_V_SSD_PPP(struct S_PPP p0, struct S_PPP p1, double p2) { }
+EXPORT void f9_V_SSP_I(struct S_I p0, struct S_I p1, void* p2) { }
+EXPORT void f9_V_SSP_F(struct S_F p0, struct S_F p1, void* p2) { }
+EXPORT void f9_V_SSP_D(struct S_D p0, struct S_D p1, void* p2) { }
+EXPORT void f9_V_SSP_P(struct S_P p0, struct S_P p1, void* p2) { }
+EXPORT void f9_V_SSP_II(struct S_II p0, struct S_II p1, void* p2) { }
+EXPORT void f9_V_SSP_IF(struct S_IF p0, struct S_IF p1, void* p2) { }
+EXPORT void f9_V_SSP_ID(struct S_ID p0, struct S_ID p1, void* p2) { }
+EXPORT void f9_V_SSP_IP(struct S_IP p0, struct S_IP p1, void* p2) { }
+EXPORT void f9_V_SSP_FI(struct S_FI p0, struct S_FI p1, void* p2) { }
+EXPORT void f9_V_SSP_FF(struct S_FF p0, struct S_FF p1, void* p2) { }
+EXPORT void f9_V_SSP_FD(struct S_FD p0, struct S_FD p1, void* p2) { }
+EXPORT void f9_V_SSP_FP(struct S_FP p0, struct S_FP p1, void* p2) { }
+EXPORT void f9_V_SSP_DI(struct S_DI p0, struct S_DI p1, void* p2) { }
+EXPORT void f9_V_SSP_DF(struct S_DF p0, struct S_DF p1, void* p2) { }
+EXPORT void f9_V_SSP_DD(struct S_DD p0, struct S_DD p1, void* p2) { }
+EXPORT void f9_V_SSP_DP(struct S_DP p0, struct S_DP p1, void* p2) { }
+EXPORT void f9_V_SSP_PI(struct S_PI p0, struct S_PI p1, void* p2) { }
+EXPORT void f9_V_SSP_PF(struct S_PF p0, struct S_PF p1, void* p2) { }
+EXPORT void f9_V_SSP_PD(struct S_PD p0, struct S_PD p1, void* p2) { }
+EXPORT void f9_V_SSP_PP(struct S_PP p0, struct S_PP p1, void* p2) { }
+EXPORT void f9_V_SSP_III(struct S_III p0, struct S_III p1, void* p2) { }
+EXPORT void f9_V_SSP_IIF(struct S_IIF p0, struct S_IIF p1, void* p2) { }
+EXPORT void f9_V_SSP_IID(struct S_IID p0, struct S_IID p1, void* p2) { }
+EXPORT void f9_V_SSP_IIP(struct S_IIP p0, struct S_IIP p1, void* p2) { }
+EXPORT void f9_V_SSP_IFI(struct S_IFI p0, struct S_IFI p1, void* p2) { }
+EXPORT void f9_V_SSP_IFF(struct S_IFF p0, struct S_IFF p1, void* p2) { }
+EXPORT void f9_V_SSP_IFD(struct S_IFD p0, struct S_IFD p1, void* p2) { }
+EXPORT void f9_V_SSP_IFP(struct S_IFP p0, struct S_IFP p1, void* p2) { }
+EXPORT void f9_V_SSP_IDI(struct S_IDI p0, struct S_IDI p1, void* p2) { }
+EXPORT void f9_V_SSP_IDF(struct S_IDF p0, struct S_IDF p1, void* p2) { }
+EXPORT void f9_V_SSP_IDD(struct S_IDD p0, struct S_IDD p1, void* p2) { }
+EXPORT void f9_V_SSP_IDP(struct S_IDP p0, struct S_IDP p1, void* p2) { }
+EXPORT void f9_V_SSP_IPI(struct S_IPI p0, struct S_IPI p1, void* p2) { }
+EXPORT void f9_V_SSP_IPF(struct S_IPF p0, struct S_IPF p1, void* p2) { }
+EXPORT void f9_V_SSP_IPD(struct S_IPD p0, struct S_IPD p1, void* p2) { }
+EXPORT void f9_V_SSP_IPP(struct S_IPP p0, struct S_IPP p1, void* p2) { }
+EXPORT void f9_V_SSP_FII(struct S_FII p0, struct S_FII p1, void* p2) { }
+EXPORT void f9_V_SSP_FIF(struct S_FIF p0, struct S_FIF p1, void* p2) { }
+EXPORT void f9_V_SSP_FID(struct S_FID p0, struct S_FID p1, void* p2) { }
+EXPORT void f9_V_SSP_FIP(struct S_FIP p0, struct S_FIP p1, void* p2) { }
+EXPORT void f9_V_SSP_FFI(struct S_FFI p0, struct S_FFI p1, void* p2) { }
+EXPORT void f9_V_SSP_FFF(struct S_FFF p0, struct S_FFF p1, void* p2) { }
+EXPORT void f9_V_SSP_FFD(struct S_FFD p0, struct S_FFD p1, void* p2) { }
+EXPORT void f9_V_SSP_FFP(struct S_FFP p0, struct S_FFP p1, void* p2) { }
+EXPORT void f9_V_SSP_FDI(struct S_FDI p0, struct S_FDI p1, void* p2) { }
+EXPORT void f9_V_SSP_FDF(struct S_FDF p0, struct S_FDF p1, void* p2) { }
+EXPORT void f9_V_SSP_FDD(struct S_FDD p0, struct S_FDD p1, void* p2) { }
+EXPORT void f9_V_SSP_FDP(struct S_FDP p0, struct S_FDP p1, void* p2) { }
+EXPORT void f9_V_SSP_FPI(struct S_FPI p0, struct S_FPI p1, void* p2) { }
+EXPORT void f9_V_SSP_FPF(struct S_FPF p0, struct S_FPF p1, void* p2) { }
+EXPORT void f9_V_SSP_FPD(struct S_FPD p0, struct S_FPD p1, void* p2) { }
+EXPORT void f9_V_SSP_FPP(struct S_FPP p0, struct S_FPP p1, void* p2) { }
+EXPORT void f9_V_SSP_DII(struct S_DII p0, struct S_DII p1, void* p2) { }
+EXPORT void f9_V_SSP_DIF(struct S_DIF p0, struct S_DIF p1, void* p2) { }
+EXPORT void f9_V_SSP_DID(struct S_DID p0, struct S_DID p1, void* p2) { }
+EXPORT void f9_V_SSP_DIP(struct S_DIP p0, struct S_DIP p1, void* p2) { }
+EXPORT void f9_V_SSP_DFI(struct S_DFI p0, struct S_DFI p1, void* p2) { }
+EXPORT void f9_V_SSP_DFF(struct S_DFF p0, struct S_DFF p1, void* p2) { }
+EXPORT void f9_V_SSP_DFD(struct S_DFD p0, struct S_DFD p1, void* p2) { }
+EXPORT void f9_V_SSP_DFP(struct S_DFP p0, struct S_DFP p1, void* p2) { }
+EXPORT void f9_V_SSP_DDI(struct S_DDI p0, struct S_DDI p1, void* p2) { }
+EXPORT void f9_V_SSP_DDF(struct S_DDF p0, struct S_DDF p1, void* p2) { }
+EXPORT void f9_V_SSP_DDD(struct S_DDD p0, struct S_DDD p1, void* p2) { }
+EXPORT void f9_V_SSP_DDP(struct S_DDP p0, struct S_DDP p1, void* p2) { }
+EXPORT void f9_V_SSP_DPI(struct S_DPI p0, struct S_DPI p1, void* p2) { }
+EXPORT void f9_V_SSP_DPF(struct S_DPF p0, struct S_DPF p1, void* p2) { }
+EXPORT void f9_V_SSP_DPD(struct S_DPD p0, struct S_DPD p1, void* p2) { }
+EXPORT void f9_V_SSP_DPP(struct S_DPP p0, struct S_DPP p1, void* p2) { }
+EXPORT void f9_V_SSP_PII(struct S_PII p0, struct S_PII p1, void* p2) { }
+EXPORT void f9_V_SSP_PIF(struct S_PIF p0, struct S_PIF p1, void* p2) { }
+EXPORT void f9_V_SSP_PID(struct S_PID p0, struct S_PID p1, void* p2) { }
+EXPORT void f9_V_SSP_PIP(struct S_PIP p0, struct S_PIP p1, void* p2) { }
+EXPORT void f9_V_SSP_PFI(struct S_PFI p0, struct S_PFI p1, void* p2) { }
+EXPORT void f9_V_SSP_PFF(struct S_PFF p0, struct S_PFF p1, void* p2) { }
+EXPORT void f9_V_SSP_PFD(struct S_PFD p0, struct S_PFD p1, void* p2) { }
+EXPORT void f9_V_SSP_PFP(struct S_PFP p0, struct S_PFP p1, void* p2) { }
+EXPORT void f9_V_SSP_PDI(struct S_PDI p0, struct S_PDI p1, void* p2) { }
+EXPORT void f9_V_SSP_PDF(struct S_PDF p0, struct S_PDF p1, void* p2) { }
+EXPORT void f9_V_SSP_PDD(struct S_PDD p0, struct S_PDD p1, void* p2) { }
+EXPORT void f9_V_SSP_PDP(struct S_PDP p0, struct S_PDP p1, void* p2) { }
+EXPORT void f9_V_SSP_PPI(struct S_PPI p0, struct S_PPI p1, void* p2) { }
+EXPORT void f9_V_SSP_PPF(struct S_PPF p0, struct S_PPF p1, void* p2) { }
+EXPORT void f9_V_SSP_PPD(struct S_PPD p0, struct S_PPD p1, void* p2) { }
+EXPORT void f9_V_SSP_PPP(struct S_PPP p0, struct S_PPP p1, void* p2) { }
+EXPORT void f9_V_SSS_I(struct S_I p0, struct S_I p1, struct S_I p2) { }
+EXPORT void f9_V_SSS_F(struct S_F p0, struct S_F p1, struct S_F p2) { }
+EXPORT void f9_V_SSS_D(struct S_D p0, struct S_D p1, struct S_D p2) { }
+EXPORT void f9_V_SSS_P(struct S_P p0, struct S_P p1, struct S_P p2) { }
+EXPORT void f9_V_SSS_II(struct S_II p0, struct S_II p1, struct S_II p2) { }
+EXPORT void f9_V_SSS_IF(struct S_IF p0, struct S_IF p1, struct S_IF p2) { }
+EXPORT void f9_V_SSS_ID(struct S_ID p0, struct S_ID p1, struct S_ID p2) { }
+EXPORT void f9_V_SSS_IP(struct S_IP p0, struct S_IP p1, struct S_IP p2) { }
+EXPORT void f9_V_SSS_FI(struct S_FI p0, struct S_FI p1, struct S_FI p2) { }
+EXPORT void f9_V_SSS_FF(struct S_FF p0, struct S_FF p1, struct S_FF p2) { }
+EXPORT void f9_V_SSS_FD(struct S_FD p0, struct S_FD p1, struct S_FD p2) { }
+EXPORT void f9_V_SSS_FP(struct S_FP p0, struct S_FP p1, struct S_FP p2) { }
+EXPORT void f9_V_SSS_DI(struct S_DI p0, struct S_DI p1, struct S_DI p2) { }
+EXPORT void f9_V_SSS_DF(struct S_DF p0, struct S_DF p1, struct S_DF p2) { }
+EXPORT void f9_V_SSS_DD(struct S_DD p0, struct S_DD p1, struct S_DD p2) { }
+EXPORT void f9_V_SSS_DP(struct S_DP p0, struct S_DP p1, struct S_DP p2) { }
+EXPORT void f9_V_SSS_PI(struct S_PI p0, struct S_PI p1, struct S_PI p2) { }
+EXPORT void f9_V_SSS_PF(struct S_PF p0, struct S_PF p1, struct S_PF p2) { }
+EXPORT void f9_V_SSS_PD(struct S_PD p0, struct S_PD p1, struct S_PD p2) { }
+EXPORT void f9_V_SSS_PP(struct S_PP p0, struct S_PP p1, struct S_PP p2) { }
+EXPORT void f9_V_SSS_III(struct S_III p0, struct S_III p1, struct S_III p2) { }
+EXPORT void f9_V_SSS_IIF(struct S_IIF p0, struct S_IIF p1, struct S_IIF p2) { }
+EXPORT void f9_V_SSS_IID(struct S_IID p0, struct S_IID p1, struct S_IID p2) { }
+EXPORT void f9_V_SSS_IIP(struct S_IIP p0, struct S_IIP p1, struct S_IIP p2) { }
+EXPORT void f9_V_SSS_IFI(struct S_IFI p0, struct S_IFI p1, struct S_IFI p2) { }
+EXPORT void f9_V_SSS_IFF(struct S_IFF p0, struct S_IFF p1, struct S_IFF p2) { }
+EXPORT void f9_V_SSS_IFD(struct S_IFD p0, struct S_IFD p1, struct S_IFD p2) { }
+EXPORT void f9_V_SSS_IFP(struct S_IFP p0, struct S_IFP p1, struct S_IFP p2) { }
+EXPORT void f9_V_SSS_IDI(struct S_IDI p0, struct S_IDI p1, struct S_IDI p2) { }
+EXPORT void f9_V_SSS_IDF(struct S_IDF p0, struct S_IDF p1, struct S_IDF p2) { }
+EXPORT void f9_V_SSS_IDD(struct S_IDD p0, struct S_IDD p1, struct S_IDD p2) { }
+EXPORT void f9_V_SSS_IDP(struct S_IDP p0, struct S_IDP p1, struct S_IDP p2) { }
+EXPORT void f9_V_SSS_IPI(struct S_IPI p0, struct S_IPI p1, struct S_IPI p2) { }
+EXPORT void f9_V_SSS_IPF(struct S_IPF p0, struct S_IPF p1, struct S_IPF p2) { }
+EXPORT void f9_V_SSS_IPD(struct S_IPD p0, struct S_IPD p1, struct S_IPD p2) { }
+EXPORT void f10_V_SSS_IPP(struct S_IPP p0, struct S_IPP p1, struct S_IPP p2) { }
+EXPORT void f10_V_SSS_FII(struct S_FII p0, struct S_FII p1, struct S_FII p2) { }
+EXPORT void f10_V_SSS_FIF(struct S_FIF p0, struct S_FIF p1, struct S_FIF p2) { }
+EXPORT void f10_V_SSS_FID(struct S_FID p0, struct S_FID p1, struct S_FID p2) { }
+EXPORT void f10_V_SSS_FIP(struct S_FIP p0, struct S_FIP p1, struct S_FIP p2) { }
+EXPORT void f10_V_SSS_FFI(struct S_FFI p0, struct S_FFI p1, struct S_FFI p2) { }
+EXPORT void f10_V_SSS_FFF(struct S_FFF p0, struct S_FFF p1, struct S_FFF p2) { }
+EXPORT void f10_V_SSS_FFD(struct S_FFD p0, struct S_FFD p1, struct S_FFD p2) { }
+EXPORT void f10_V_SSS_FFP(struct S_FFP p0, struct S_FFP p1, struct S_FFP p2) { }
+EXPORT void f10_V_SSS_FDI(struct S_FDI p0, struct S_FDI p1, struct S_FDI p2) { }
+EXPORT void f10_V_SSS_FDF(struct S_FDF p0, struct S_FDF p1, struct S_FDF p2) { }
+EXPORT void f10_V_SSS_FDD(struct S_FDD p0, struct S_FDD p1, struct S_FDD p2) { }
+EXPORT void f10_V_SSS_FDP(struct S_FDP p0, struct S_FDP p1, struct S_FDP p2) { }
+EXPORT void f10_V_SSS_FPI(struct S_FPI p0, struct S_FPI p1, struct S_FPI p2) { }
+EXPORT void f10_V_SSS_FPF(struct S_FPF p0, struct S_FPF p1, struct S_FPF p2) { }
+EXPORT void f10_V_SSS_FPD(struct S_FPD p0, struct S_FPD p1, struct S_FPD p2) { }
+EXPORT void f10_V_SSS_FPP(struct S_FPP p0, struct S_FPP p1, struct S_FPP p2) { }
+EXPORT void f10_V_SSS_DII(struct S_DII p0, struct S_DII p1, struct S_DII p2) { }
+EXPORT void f10_V_SSS_DIF(struct S_DIF p0, struct S_DIF p1, struct S_DIF p2) { }
+EXPORT void f10_V_SSS_DID(struct S_DID p0, struct S_DID p1, struct S_DID p2) { }
+EXPORT void f10_V_SSS_DIP(struct S_DIP p0, struct S_DIP p1, struct S_DIP p2) { }
+EXPORT void f10_V_SSS_DFI(struct S_DFI p0, struct S_DFI p1, struct S_DFI p2) { }
+EXPORT void f10_V_SSS_DFF(struct S_DFF p0, struct S_DFF p1, struct S_DFF p2) { }
+EXPORT void f10_V_SSS_DFD(struct S_DFD p0, struct S_DFD p1, struct S_DFD p2) { }
+EXPORT void f10_V_SSS_DFP(struct S_DFP p0, struct S_DFP p1, struct S_DFP p2) { }
+EXPORT void f10_V_SSS_DDI(struct S_DDI p0, struct S_DDI p1, struct S_DDI p2) { }
+EXPORT void f10_V_SSS_DDF(struct S_DDF p0, struct S_DDF p1, struct S_DDF p2) { }
+EXPORT void f10_V_SSS_DDD(struct S_DDD p0, struct S_DDD p1, struct S_DDD p2) { }
+EXPORT void f10_V_SSS_DDP(struct S_DDP p0, struct S_DDP p1, struct S_DDP p2) { }
+EXPORT void f10_V_SSS_DPI(struct S_DPI p0, struct S_DPI p1, struct S_DPI p2) { }
+EXPORT void f10_V_SSS_DPF(struct S_DPF p0, struct S_DPF p1, struct S_DPF p2) { }
+EXPORT void f10_V_SSS_DPD(struct S_DPD p0, struct S_DPD p1, struct S_DPD p2) { }
+EXPORT void f10_V_SSS_DPP(struct S_DPP p0, struct S_DPP p1, struct S_DPP p2) { }
+EXPORT void f10_V_SSS_PII(struct S_PII p0, struct S_PII p1, struct S_PII p2) { }
+EXPORT void f10_V_SSS_PIF(struct S_PIF p0, struct S_PIF p1, struct S_PIF p2) { }
+EXPORT void f10_V_SSS_PID(struct S_PID p0, struct S_PID p1, struct S_PID p2) { }
+EXPORT void f10_V_SSS_PIP(struct S_PIP p0, struct S_PIP p1, struct S_PIP p2) { }
+EXPORT void f10_V_SSS_PFI(struct S_PFI p0, struct S_PFI p1, struct S_PFI p2) { }
+EXPORT void f10_V_SSS_PFF(struct S_PFF p0, struct S_PFF p1, struct S_PFF p2) { }
+EXPORT void f10_V_SSS_PFD(struct S_PFD p0, struct S_PFD p1, struct S_PFD p2) { }
+EXPORT void f10_V_SSS_PFP(struct S_PFP p0, struct S_PFP p1, struct S_PFP p2) { }
+EXPORT void f10_V_SSS_PDI(struct S_PDI p0, struct S_PDI p1, struct S_PDI p2) { }
+EXPORT void f10_V_SSS_PDF(struct S_PDF p0, struct S_PDF p1, struct S_PDF p2) { }
+EXPORT void f10_V_SSS_PDD(struct S_PDD p0, struct S_PDD p1, struct S_PDD p2) { }
+EXPORT void f10_V_SSS_PDP(struct S_PDP p0, struct S_PDP p1, struct S_PDP p2) { }
+EXPORT void f10_V_SSS_PPI(struct S_PPI p0, struct S_PPI p1, struct S_PPI p2) { }
+EXPORT void f10_V_SSS_PPF(struct S_PPF p0, struct S_PPF p1, struct S_PPF p2) { }
+EXPORT void f10_V_SSS_PPD(struct S_PPD p0, struct S_PPD p1, struct S_PPD p2) { }
+EXPORT void f10_V_SSS_PPP(struct S_PPP p0, struct S_PPP p1, struct S_PPP p2) { }
+EXPORT int f10_I_I_(int p0) { return p0; }
+EXPORT float f10_F_F_(float p0) { return p0; }
+EXPORT double f10_D_D_(double p0) { return p0; }
+EXPORT void* f10_P_P_(void* p0) { return p0; }
+EXPORT struct S_I f10_S_S_I(struct S_I p0) { return p0; }
+EXPORT struct S_F f10_S_S_F(struct S_F p0) { return p0; }
+EXPORT struct S_D f10_S_S_D(struct S_D p0) { return p0; }
+EXPORT struct S_P f10_S_S_P(struct S_P p0) { return p0; }
+EXPORT struct S_II f10_S_S_II(struct S_II p0) { return p0; }
+EXPORT struct S_IF f10_S_S_IF(struct S_IF p0) { return p0; }
+EXPORT struct S_ID f10_S_S_ID(struct S_ID p0) { return p0; }
+EXPORT struct S_IP f10_S_S_IP(struct S_IP p0) { return p0; }
+EXPORT struct S_FI f10_S_S_FI(struct S_FI p0) { return p0; }
+EXPORT struct S_FF f10_S_S_FF(struct S_FF p0) { return p0; }
+EXPORT struct S_FD f10_S_S_FD(struct S_FD p0) { return p0; }
+EXPORT struct S_FP f10_S_S_FP(struct S_FP p0) { return p0; }
+EXPORT struct S_DI f10_S_S_DI(struct S_DI p0) { return p0; }
+EXPORT struct S_DF f10_S_S_DF(struct S_DF p0) { return p0; }
+EXPORT struct S_DD f10_S_S_DD(struct S_DD p0) { return p0; }
+EXPORT struct S_DP f10_S_S_DP(struct S_DP p0) { return p0; }
+EXPORT struct S_PI f10_S_S_PI(struct S_PI p0) { return p0; }
+EXPORT struct S_PF f10_S_S_PF(struct S_PF p0) { return p0; }
+EXPORT struct S_PD f10_S_S_PD(struct S_PD p0) { return p0; }
+EXPORT struct S_PP f10_S_S_PP(struct S_PP p0) { return p0; }
+EXPORT struct S_III f10_S_S_III(struct S_III p0) { return p0; }
+EXPORT struct S_IIF f10_S_S_IIF(struct S_IIF p0) { return p0; }
+EXPORT struct S_IID f10_S_S_IID(struct S_IID p0) { return p0; }
+EXPORT struct S_IIP f10_S_S_IIP(struct S_IIP p0) { return p0; }
+EXPORT struct S_IFI f10_S_S_IFI(struct S_IFI p0) { return p0; }
+EXPORT struct S_IFF f10_S_S_IFF(struct S_IFF p0) { return p0; }
+EXPORT struct S_IFD f10_S_S_IFD(struct S_IFD p0) { return p0; }
+EXPORT struct S_IFP f10_S_S_IFP(struct S_IFP p0) { return p0; }
+EXPORT struct S_IDI f10_S_S_IDI(struct S_IDI p0) { return p0; }
+EXPORT struct S_IDF f10_S_S_IDF(struct S_IDF p0) { return p0; }
+EXPORT struct S_IDD f10_S_S_IDD(struct S_IDD p0) { return p0; }
+EXPORT struct S_IDP f10_S_S_IDP(struct S_IDP p0) { return p0; }
+EXPORT struct S_IPI f10_S_S_IPI(struct S_IPI p0) { return p0; }
+EXPORT struct S_IPF f10_S_S_IPF(struct S_IPF p0) { return p0; }
+EXPORT struct S_IPD f10_S_S_IPD(struct S_IPD p0) { return p0; }
+EXPORT struct S_IPP f10_S_S_IPP(struct S_IPP p0) { return p0; }
+EXPORT struct S_FII f10_S_S_FII(struct S_FII p0) { return p0; }
+EXPORT struct S_FIF f10_S_S_FIF(struct S_FIF p0) { return p0; }
+EXPORT struct S_FID f10_S_S_FID(struct S_FID p0) { return p0; }
+EXPORT struct S_FIP f10_S_S_FIP(struct S_FIP p0) { return p0; }
+EXPORT struct S_FFI f10_S_S_FFI(struct S_FFI p0) { return p0; }
+EXPORT struct S_FFF f10_S_S_FFF(struct S_FFF p0) { return p0; }
+EXPORT struct S_FFD f10_S_S_FFD(struct S_FFD p0) { return p0; }
+EXPORT struct S_FFP f10_S_S_FFP(struct S_FFP p0) { return p0; }
+EXPORT struct S_FDI f10_S_S_FDI(struct S_FDI p0) { return p0; }
+EXPORT struct S_FDF f10_S_S_FDF(struct S_FDF p0) { return p0; }
+EXPORT struct S_FDD f10_S_S_FDD(struct S_FDD p0) { return p0; }
+EXPORT struct S_FDP f10_S_S_FDP(struct S_FDP p0) { return p0; }
+EXPORT struct S_FPI f10_S_S_FPI(struct S_FPI p0) { return p0; }
+EXPORT struct S_FPF f10_S_S_FPF(struct S_FPF p0) { return p0; }
+EXPORT struct S_FPD f10_S_S_FPD(struct S_FPD p0) { return p0; }
+EXPORT struct S_FPP f10_S_S_FPP(struct S_FPP p0) { return p0; }
+EXPORT struct S_DII f10_S_S_DII(struct S_DII p0) { return p0; }
+EXPORT struct S_DIF f10_S_S_DIF(struct S_DIF p0) { return p0; }
+EXPORT struct S_DID f10_S_S_DID(struct S_DID p0) { return p0; }
+EXPORT struct S_DIP f10_S_S_DIP(struct S_DIP p0) { return p0; }
+EXPORT struct S_DFI f10_S_S_DFI(struct S_DFI p0) { return p0; }
+EXPORT struct S_DFF f10_S_S_DFF(struct S_DFF p0) { return p0; }
+EXPORT struct S_DFD f10_S_S_DFD(struct S_DFD p0) { return p0; }
+EXPORT struct S_DFP f10_S_S_DFP(struct S_DFP p0) { return p0; }
+EXPORT struct S_DDI f10_S_S_DDI(struct S_DDI p0) { return p0; }
+EXPORT struct S_DDF f10_S_S_DDF(struct S_DDF p0) { return p0; }
+EXPORT struct S_DDD f10_S_S_DDD(struct S_DDD p0) { return p0; }
+EXPORT struct S_DDP f10_S_S_DDP(struct S_DDP p0) { return p0; }
+EXPORT struct S_DPI f10_S_S_DPI(struct S_DPI p0) { return p0; }
+EXPORT struct S_DPF f10_S_S_DPF(struct S_DPF p0) { return p0; }
+EXPORT struct S_DPD f10_S_S_DPD(struct S_DPD p0) { return p0; }
+EXPORT struct S_DPP f10_S_S_DPP(struct S_DPP p0) { return p0; }
+EXPORT struct S_PII f10_S_S_PII(struct S_PII p0) { return p0; }
+EXPORT struct S_PIF f10_S_S_PIF(struct S_PIF p0) { return p0; }
+EXPORT struct S_PID f10_S_S_PID(struct S_PID p0) { return p0; }
+EXPORT struct S_PIP f10_S_S_PIP(struct S_PIP p0) { return p0; }
+EXPORT struct S_PFI f10_S_S_PFI(struct S_PFI p0) { return p0; }
+EXPORT struct S_PFF f10_S_S_PFF(struct S_PFF p0) { return p0; }
+EXPORT struct S_PFD f10_S_S_PFD(struct S_PFD p0) { return p0; }
+EXPORT struct S_PFP f10_S_S_PFP(struct S_PFP p0) { return p0; }
+EXPORT struct S_PDI f10_S_S_PDI(struct S_PDI p0) { return p0; }
+EXPORT struct S_PDF f10_S_S_PDF(struct S_PDF p0) { return p0; }
+EXPORT struct S_PDD f10_S_S_PDD(struct S_PDD p0) { return p0; }
+EXPORT struct S_PDP f10_S_S_PDP(struct S_PDP p0) { return p0; }
+EXPORT struct S_PPI f10_S_S_PPI(struct S_PPI p0) { return p0; }
+EXPORT struct S_PPF f10_S_S_PPF(struct S_PPF p0) { return p0; }
+EXPORT struct S_PPD f10_S_S_PPD(struct S_PPD p0) { return p0; }
+EXPORT struct S_PPP f10_S_S_PPP(struct S_PPP p0) { return p0; }
+EXPORT int f10_I_II_(int p0, int p1) { return p0; }
+EXPORT int f10_I_IF_(int p0, float p1) { return p0; }
+EXPORT int f10_I_ID_(int p0, double p1) { return p0; }
+EXPORT int f10_I_IP_(int p0, void* p1) { return p0; }
+EXPORT int f10_I_IS_I(int p0, struct S_I p1) { return p0; }
+EXPORT int f10_I_IS_F(int p0, struct S_F p1) { return p0; }
+EXPORT int f10_I_IS_D(int p0, struct S_D p1) { return p0; }
+EXPORT int f10_I_IS_P(int p0, struct S_P p1) { return p0; }
+EXPORT int f10_I_IS_II(int p0, struct S_II p1) { return p0; }
+EXPORT int f10_I_IS_IF(int p0, struct S_IF p1) { return p0; }
+EXPORT int f10_I_IS_ID(int p0, struct S_ID p1) { return p0; }
+EXPORT int f10_I_IS_IP(int p0, struct S_IP p1) { return p0; }
+EXPORT int f10_I_IS_FI(int p0, struct S_FI p1) { return p0; }
+EXPORT int f10_I_IS_FF(int p0, struct S_FF p1) { return p0; }
+EXPORT int f10_I_IS_FD(int p0, struct S_FD p1) { return p0; }
+EXPORT int f10_I_IS_FP(int p0, struct S_FP p1) { return p0; }
+EXPORT int f10_I_IS_DI(int p0, struct S_DI p1) { return p0; }
+EXPORT int f10_I_IS_DF(int p0, struct S_DF p1) { return p0; }
+EXPORT int f10_I_IS_DD(int p0, struct S_DD p1) { return p0; }
+EXPORT int f10_I_IS_DP(int p0, struct S_DP p1) { return p0; }
+EXPORT int f10_I_IS_PI(int p0, struct S_PI p1) { return p0; }
+EXPORT int f10_I_IS_PF(int p0, struct S_PF p1) { return p0; }
+EXPORT int f10_I_IS_PD(int p0, struct S_PD p1) { return p0; }
+EXPORT int f10_I_IS_PP(int p0, struct S_PP p1) { return p0; }
+EXPORT int f10_I_IS_III(int p0, struct S_III p1) { return p0; }
+EXPORT int f10_I_IS_IIF(int p0, struct S_IIF p1) { return p0; }
+EXPORT int f10_I_IS_IID(int p0, struct S_IID p1) { return p0; }
+EXPORT int f10_I_IS_IIP(int p0, struct S_IIP p1) { return p0; }
+EXPORT int f10_I_IS_IFI(int p0, struct S_IFI p1) { return p0; }
+EXPORT int f10_I_IS_IFF(int p0, struct S_IFF p1) { return p0; }
+EXPORT int f10_I_IS_IFD(int p0, struct S_IFD p1) { return p0; }
+EXPORT int f10_I_IS_IFP(int p0, struct S_IFP p1) { return p0; }
+EXPORT int f10_I_IS_IDI(int p0, struct S_IDI p1) { return p0; }
+EXPORT int f10_I_IS_IDF(int p0, struct S_IDF p1) { return p0; }
+EXPORT int f10_I_IS_IDD(int p0, struct S_IDD p1) { return p0; }
+EXPORT int f10_I_IS_IDP(int p0, struct S_IDP p1) { return p0; }
+EXPORT int f10_I_IS_IPI(int p0, struct S_IPI p1) { return p0; }
+EXPORT int f10_I_IS_IPF(int p0, struct S_IPF p1) { return p0; }
+EXPORT int f10_I_IS_IPD(int p0, struct S_IPD p1) { return p0; }
+EXPORT int f10_I_IS_IPP(int p0, struct S_IPP p1) { return p0; }
+EXPORT int f10_I_IS_FII(int p0, struct S_FII p1) { return p0; }
+EXPORT int f10_I_IS_FIF(int p0, struct S_FIF p1) { return p0; }
+EXPORT int f10_I_IS_FID(int p0, struct S_FID p1) { return p0; }
+EXPORT int f10_I_IS_FIP(int p0, struct S_FIP p1) { return p0; }
+EXPORT int f10_I_IS_FFI(int p0, struct S_FFI p1) { return p0; }
+EXPORT int f10_I_IS_FFF(int p0, struct S_FFF p1) { return p0; }
+EXPORT int f10_I_IS_FFD(int p0, struct S_FFD p1) { return p0; }
+EXPORT int f10_I_IS_FFP(int p0, struct S_FFP p1) { return p0; }
+EXPORT int f10_I_IS_FDI(int p0, struct S_FDI p1) { return p0; }
+EXPORT int f10_I_IS_FDF(int p0, struct S_FDF p1) { return p0; }
+EXPORT int f10_I_IS_FDD(int p0, struct S_FDD p1) { return p0; }
+EXPORT int f10_I_IS_FDP(int p0, struct S_FDP p1) { return p0; }
+EXPORT int f10_I_IS_FPI(int p0, struct S_FPI p1) { return p0; }
+EXPORT int f10_I_IS_FPF(int p0, struct S_FPF p1) { return p0; }
+EXPORT int f10_I_IS_FPD(int p0, struct S_FPD p1) { return p0; }
+EXPORT int f10_I_IS_FPP(int p0, struct S_FPP p1) { return p0; }
+EXPORT int f10_I_IS_DII(int p0, struct S_DII p1) { return p0; }
+EXPORT int f10_I_IS_DIF(int p0, struct S_DIF p1) { return p0; }
+EXPORT int f10_I_IS_DID(int p0, struct S_DID p1) { return p0; }
+EXPORT int f10_I_IS_DIP(int p0, struct S_DIP p1) { return p0; }
+EXPORT int f10_I_IS_DFI(int p0, struct S_DFI p1) { return p0; }
+EXPORT int f10_I_IS_DFF(int p0, struct S_DFF p1) { return p0; }
+EXPORT int f10_I_IS_DFD(int p0, struct S_DFD p1) { return p0; }
+EXPORT int f10_I_IS_DFP(int p0, struct S_DFP p1) { return p0; }
+EXPORT int f10_I_IS_DDI(int p0, struct S_DDI p1) { return p0; }
+EXPORT int f10_I_IS_DDF(int p0, struct S_DDF p1) { return p0; }
+EXPORT int f10_I_IS_DDD(int p0, struct S_DDD p1) { return p0; }
+EXPORT int f10_I_IS_DDP(int p0, struct S_DDP p1) { return p0; }
+EXPORT int f10_I_IS_DPI(int p0, struct S_DPI p1) { return p0; }
+EXPORT int f10_I_IS_DPF(int p0, struct S_DPF p1) { return p0; }
+EXPORT int f10_I_IS_DPD(int p0, struct S_DPD p1) { return p0; }
+EXPORT int f10_I_IS_DPP(int p0, struct S_DPP p1) { return p0; }
+EXPORT int f10_I_IS_PII(int p0, struct S_PII p1) { return p0; }
+EXPORT int f10_I_IS_PIF(int p0, struct S_PIF p1) { return p0; }
+EXPORT int f10_I_IS_PID(int p0, struct S_PID p1) { return p0; }
+EXPORT int f10_I_IS_PIP(int p0, struct S_PIP p1) { return p0; }
+EXPORT int f10_I_IS_PFI(int p0, struct S_PFI p1) { return p0; }
+EXPORT int f10_I_IS_PFF(int p0, struct S_PFF p1) { return p0; }
+EXPORT int f10_I_IS_PFD(int p0, struct S_PFD p1) { return p0; }
+EXPORT int f10_I_IS_PFP(int p0, struct S_PFP p1) { return p0; }
+EXPORT int f10_I_IS_PDI(int p0, struct S_PDI p1) { return p0; }
+EXPORT int f10_I_IS_PDF(int p0, struct S_PDF p1) { return p0; }
+EXPORT int f10_I_IS_PDD(int p0, struct S_PDD p1) { return p0; }
+EXPORT int f10_I_IS_PDP(int p0, struct S_PDP p1) { return p0; }
+EXPORT int f10_I_IS_PPI(int p0, struct S_PPI p1) { return p0; }
+EXPORT int f10_I_IS_PPF(int p0, struct S_PPF p1) { return p0; }
+EXPORT int f10_I_IS_PPD(int p0, struct S_PPD p1) { return p0; }
+EXPORT int f10_I_IS_PPP(int p0, struct S_PPP p1) { return p0; }
+EXPORT float f10_F_FI_(float p0, int p1) { return p0; }
+EXPORT float f10_F_FF_(float p0, float p1) { return p0; }
+EXPORT float f10_F_FD_(float p0, double p1) { return p0; }
+EXPORT float f10_F_FP_(float p0, void* p1) { return p0; }
+EXPORT float f10_F_FS_I(float p0, struct S_I p1) { return p0; }
+EXPORT float f10_F_FS_F(float p0, struct S_F p1) { return p0; }
+EXPORT float f10_F_FS_D(float p0, struct S_D p1) { return p0; }
+EXPORT float f10_F_FS_P(float p0, struct S_P p1) { return p0; }
+EXPORT float f10_F_FS_II(float p0, struct S_II p1) { return p0; }
+EXPORT float f10_F_FS_IF(float p0, struct S_IF p1) { return p0; }
+EXPORT float f10_F_FS_ID(float p0, struct S_ID p1) { return p0; }
+EXPORT float f10_F_FS_IP(float p0, struct S_IP p1) { return p0; }
+EXPORT float f10_F_FS_FI(float p0, struct S_FI p1) { return p0; }
+EXPORT float f10_F_FS_FF(float p0, struct S_FF p1) { return p0; }
+EXPORT float f10_F_FS_FD(float p0, struct S_FD p1) { return p0; }
+EXPORT float f10_F_FS_FP(float p0, struct S_FP p1) { return p0; }
+EXPORT float f10_F_FS_DI(float p0, struct S_DI p1) { return p0; }
+EXPORT float f10_F_FS_DF(float p0, struct S_DF p1) { return p0; }
+EXPORT float f10_F_FS_DD(float p0, struct S_DD p1) { return p0; }
+EXPORT float f10_F_FS_DP(float p0, struct S_DP p1) { return p0; }
+EXPORT float f10_F_FS_PI(float p0, struct S_PI p1) { return p0; }
+EXPORT float f10_F_FS_PF(float p0, struct S_PF p1) { return p0; }
+EXPORT float f10_F_FS_PD(float p0, struct S_PD p1) { return p0; }
+EXPORT float f10_F_FS_PP(float p0, struct S_PP p1) { return p0; }
+EXPORT float f10_F_FS_III(float p0, struct S_III p1) { return p0; }
+EXPORT float f10_F_FS_IIF(float p0, struct S_IIF p1) { return p0; }
+EXPORT float f10_F_FS_IID(float p0, struct S_IID p1) { return p0; }
+EXPORT float f10_F_FS_IIP(float p0, struct S_IIP p1) { return p0; }
+EXPORT float f10_F_FS_IFI(float p0, struct S_IFI p1) { return p0; }
+EXPORT float f10_F_FS_IFF(float p0, struct S_IFF p1) { return p0; }
+EXPORT float f10_F_FS_IFD(float p0, struct S_IFD p1) { return p0; }
+EXPORT float f10_F_FS_IFP(float p0, struct S_IFP p1) { return p0; }
+EXPORT float f10_F_FS_IDI(float p0, struct S_IDI p1) { return p0; }
+EXPORT float f10_F_FS_IDF(float p0, struct S_IDF p1) { return p0; }
+EXPORT float f10_F_FS_IDD(float p0, struct S_IDD p1) { return p0; }
+EXPORT float f10_F_FS_IDP(float p0, struct S_IDP p1) { return p0; }
+EXPORT float f10_F_FS_IPI(float p0, struct S_IPI p1) { return p0; }
+EXPORT float f10_F_FS_IPF(float p0, struct S_IPF p1) { return p0; }
+EXPORT float f10_F_FS_IPD(float p0, struct S_IPD p1) { return p0; }
+EXPORT float f10_F_FS_IPP(float p0, struct S_IPP p1) { return p0; }
+EXPORT float f10_F_FS_FII(float p0, struct S_FII p1) { return p0; }
+EXPORT float f10_F_FS_FIF(float p0, struct S_FIF p1) { return p0; }
+EXPORT float f10_F_FS_FID(float p0, struct S_FID p1) { return p0; }
+EXPORT float f10_F_FS_FIP(float p0, struct S_FIP p1) { return p0; }
+EXPORT float f10_F_FS_FFI(float p0, struct S_FFI p1) { return p0; }
+EXPORT float f10_F_FS_FFF(float p0, struct S_FFF p1) { return p0; }
+EXPORT float f10_F_FS_FFD(float p0, struct S_FFD p1) { return p0; }
+EXPORT float f10_F_FS_FFP(float p0, struct S_FFP p1) { return p0; }
+EXPORT float f10_F_FS_FDI(float p0, struct S_FDI p1) { return p0; }
+EXPORT float f10_F_FS_FDF(float p0, struct S_FDF p1) { return p0; }
+EXPORT float f10_F_FS_FDD(float p0, struct S_FDD p1) { return p0; }
+EXPORT float f10_F_FS_FDP(float p0, struct S_FDP p1) { return p0; }
+EXPORT float f10_F_FS_FPI(float p0, struct S_FPI p1) { return p0; }
+EXPORT float f10_F_FS_FPF(float p0, struct S_FPF p1) { return p0; }
+EXPORT float f10_F_FS_FPD(float p0, struct S_FPD p1) { return p0; }
+EXPORT float f10_F_FS_FPP(float p0, struct S_FPP p1) { return p0; }
+EXPORT float f10_F_FS_DII(float p0, struct S_DII p1) { return p0; }
+EXPORT float f10_F_FS_DIF(float p0, struct S_DIF p1) { return p0; }
+EXPORT float f10_F_FS_DID(float p0, struct S_DID p1) { return p0; }
+EXPORT float f10_F_FS_DIP(float p0, struct S_DIP p1) { return p0; }
+EXPORT float f10_F_FS_DFI(float p0, struct S_DFI p1) { return p0; }
+EXPORT float f10_F_FS_DFF(float p0, struct S_DFF p1) { return p0; }
+EXPORT float f10_F_FS_DFD(float p0, struct S_DFD p1) { return p0; }
+EXPORT float f10_F_FS_DFP(float p0, struct S_DFP p1) { return p0; }
+EXPORT float f10_F_FS_DDI(float p0, struct S_DDI p1) { return p0; }
+EXPORT float f10_F_FS_DDF(float p0, struct S_DDF p1) { return p0; }
+EXPORT float f10_F_FS_DDD(float p0, struct S_DDD p1) { return p0; }
+EXPORT float f10_F_FS_DDP(float p0, struct S_DDP p1) { return p0; }
+EXPORT float f10_F_FS_DPI(float p0, struct S_DPI p1) { return p0; }
+EXPORT float f10_F_FS_DPF(float p0, struct S_DPF p1) { return p0; }
+EXPORT float f10_F_FS_DPD(float p0, struct S_DPD p1) { return p0; }
+EXPORT float f10_F_FS_DPP(float p0, struct S_DPP p1) { return p0; }
+EXPORT float f10_F_FS_PII(float p0, struct S_PII p1) { return p0; }
+EXPORT float f10_F_FS_PIF(float p0, struct S_PIF p1) { return p0; }
+EXPORT float f10_F_FS_PID(float p0, struct S_PID p1) { return p0; }
+EXPORT float f10_F_FS_PIP(float p0, struct S_PIP p1) { return p0; }
+EXPORT float f10_F_FS_PFI(float p0, struct S_PFI p1) { return p0; }
+EXPORT float f10_F_FS_PFF(float p0, struct S_PFF p1) { return p0; }
+EXPORT float f10_F_FS_PFD(float p0, struct S_PFD p1) { return p0; }
+EXPORT float f10_F_FS_PFP(float p0, struct S_PFP p1) { return p0; }
+EXPORT float f10_F_FS_PDI(float p0, struct S_PDI p1) { return p0; }
+EXPORT float f10_F_FS_PDF(float p0, struct S_PDF p1) { return p0; }
+EXPORT float f10_F_FS_PDD(float p0, struct S_PDD p1) { return p0; }
+EXPORT float f10_F_FS_PDP(float p0, struct S_PDP p1) { return p0; }
+EXPORT float f10_F_FS_PPI(float p0, struct S_PPI p1) { return p0; }
+EXPORT float f10_F_FS_PPF(float p0, struct S_PPF p1) { return p0; }
+EXPORT float f10_F_FS_PPD(float p0, struct S_PPD p1) { return p0; }
+EXPORT float f10_F_FS_PPP(float p0, struct S_PPP p1) { return p0; }
+EXPORT double f10_D_DI_(double p0, int p1) { return p0; }
+EXPORT double f10_D_DF_(double p0, float p1) { return p0; }
+EXPORT double f10_D_DD_(double p0, double p1) { return p0; }
+EXPORT double f10_D_DP_(double p0, void* p1) { return p0; }
+EXPORT double f10_D_DS_I(double p0, struct S_I p1) { return p0; }
+EXPORT double f10_D_DS_F(double p0, struct S_F p1) { return p0; }
+EXPORT double f10_D_DS_D(double p0, struct S_D p1) { return p0; }
+EXPORT double f10_D_DS_P(double p0, struct S_P p1) { return p0; }
+EXPORT double f10_D_DS_II(double p0, struct S_II p1) { return p0; }
+EXPORT double f10_D_DS_IF(double p0, struct S_IF p1) { return p0; }
+EXPORT double f10_D_DS_ID(double p0, struct S_ID p1) { return p0; }
+EXPORT double f10_D_DS_IP(double p0, struct S_IP p1) { return p0; }
+EXPORT double f10_D_DS_FI(double p0, struct S_FI p1) { return p0; }
+EXPORT double f10_D_DS_FF(double p0, struct S_FF p1) { return p0; }
+EXPORT double f10_D_DS_FD(double p0, struct S_FD p1) { return p0; }
+EXPORT double f10_D_DS_FP(double p0, struct S_FP p1) { return p0; }
+EXPORT double f10_D_DS_DI(double p0, struct S_DI p1) { return p0; }
+EXPORT double f10_D_DS_DF(double p0, struct S_DF p1) { return p0; }
+EXPORT double f10_D_DS_DD(double p0, struct S_DD p1) { return p0; }
+EXPORT double f10_D_DS_DP(double p0, struct S_DP p1) { return p0; }
+EXPORT double f10_D_DS_PI(double p0, struct S_PI p1) { return p0; }
+EXPORT double f10_D_DS_PF(double p0, struct S_PF p1) { return p0; }
+EXPORT double f10_D_DS_PD(double p0, struct S_PD p1) { return p0; }
+EXPORT double f10_D_DS_PP(double p0, struct S_PP p1) { return p0; }
+EXPORT double f10_D_DS_III(double p0, struct S_III p1) { return p0; }
+EXPORT double f10_D_DS_IIF(double p0, struct S_IIF p1) { return p0; }
+EXPORT double f10_D_DS_IID(double p0, struct S_IID p1) { return p0; }
+EXPORT double f10_D_DS_IIP(double p0, struct S_IIP p1) { return p0; }
+EXPORT double f10_D_DS_IFI(double p0, struct S_IFI p1) { return p0; }
+EXPORT double f10_D_DS_IFF(double p0, struct S_IFF p1) { return p0; }
+EXPORT double f10_D_DS_IFD(double p0, struct S_IFD p1) { return p0; }
+EXPORT double f10_D_DS_IFP(double p0, struct S_IFP p1) { return p0; }
+EXPORT double f10_D_DS_IDI(double p0, struct S_IDI p1) { return p0; }
+EXPORT double f10_D_DS_IDF(double p0, struct S_IDF p1) { return p0; }
+EXPORT double f10_D_DS_IDD(double p0, struct S_IDD p1) { return p0; }
+EXPORT double f10_D_DS_IDP(double p0, struct S_IDP p1) { return p0; }
+EXPORT double f10_D_DS_IPI(double p0, struct S_IPI p1) { return p0; }
+EXPORT double f10_D_DS_IPF(double p0, struct S_IPF p1) { return p0; }
+EXPORT double f10_D_DS_IPD(double p0, struct S_IPD p1) { return p0; }
+EXPORT double f10_D_DS_IPP(double p0, struct S_IPP p1) { return p0; }
+EXPORT double f10_D_DS_FII(double p0, struct S_FII p1) { return p0; }
+EXPORT double f10_D_DS_FIF(double p0, struct S_FIF p1) { return p0; }
+EXPORT double f10_D_DS_FID(double p0, struct S_FID p1) { return p0; }
+EXPORT double f10_D_DS_FIP(double p0, struct S_FIP p1) { return p0; }
+EXPORT double f10_D_DS_FFI(double p0, struct S_FFI p1) { return p0; }
+EXPORT double f10_D_DS_FFF(double p0, struct S_FFF p1) { return p0; }
+EXPORT double f10_D_DS_FFD(double p0, struct S_FFD p1) { return p0; }
+EXPORT double f10_D_DS_FFP(double p0, struct S_FFP p1) { return p0; }
+EXPORT double f10_D_DS_FDI(double p0, struct S_FDI p1) { return p0; }
+EXPORT double f10_D_DS_FDF(double p0, struct S_FDF p1) { return p0; }
+EXPORT double f10_D_DS_FDD(double p0, struct S_FDD p1) { return p0; }
+EXPORT double f10_D_DS_FDP(double p0, struct S_FDP p1) { return p0; }
+EXPORT double f10_D_DS_FPI(double p0, struct S_FPI p1) { return p0; }
+EXPORT double f10_D_DS_FPF(double p0, struct S_FPF p1) { return p0; }
+EXPORT double f10_D_DS_FPD(double p0, struct S_FPD p1) { return p0; }
+EXPORT double f10_D_DS_FPP(double p0, struct S_FPP p1) { return p0; }
+EXPORT double f10_D_DS_DII(double p0, struct S_DII p1) { return p0; }
+EXPORT double f10_D_DS_DIF(double p0, struct S_DIF p1) { return p0; }
+EXPORT double f10_D_DS_DID(double p0, struct S_DID p1) { return p0; }
+EXPORT double f10_D_DS_DIP(double p0, struct S_DIP p1) { return p0; }
+EXPORT double f10_D_DS_DFI(double p0, struct S_DFI p1) { return p0; }
+EXPORT double f10_D_DS_DFF(double p0, struct S_DFF p1) { return p0; }
+EXPORT double f10_D_DS_DFD(double p0, struct S_DFD p1) { return p0; }
+EXPORT double f10_D_DS_DFP(double p0, struct S_DFP p1) { return p0; }
+EXPORT double f10_D_DS_DDI(double p0, struct S_DDI p1) { return p0; }
+EXPORT double f10_D_DS_DDF(double p0, struct S_DDF p1) { return p0; }
+EXPORT double f10_D_DS_DDD(double p0, struct S_DDD p1) { return p0; }
+EXPORT double f10_D_DS_DDP(double p0, struct S_DDP p1) { return p0; }
+EXPORT double f10_D_DS_DPI(double p0, struct S_DPI p1) { return p0; }
+EXPORT double f10_D_DS_DPF(double p0, struct S_DPF p1) { return p0; }
+EXPORT double f10_D_DS_DPD(double p0, struct S_DPD p1) { return p0; }
+EXPORT double f10_D_DS_DPP(double p0, struct S_DPP p1) { return p0; }
+EXPORT double f10_D_DS_PII(double p0, struct S_PII p1) { return p0; }
+EXPORT double f10_D_DS_PIF(double p0, struct S_PIF p1) { return p0; }
+EXPORT double f10_D_DS_PID(double p0, struct S_PID p1) { return p0; }
+EXPORT double f10_D_DS_PIP(double p0, struct S_PIP p1) { return p0; }
+EXPORT double f10_D_DS_PFI(double p0, struct S_PFI p1) { return p0; }
+EXPORT double f10_D_DS_PFF(double p0, struct S_PFF p1) { return p0; }
+EXPORT double f10_D_DS_PFD(double p0, struct S_PFD p1) { return p0; }
+EXPORT double f10_D_DS_PFP(double p0, struct S_PFP p1) { return p0; }
+EXPORT double f10_D_DS_PDI(double p0, struct S_PDI p1) { return p0; }
+EXPORT double f10_D_DS_PDF(double p0, struct S_PDF p1) { return p0; }
+EXPORT double f10_D_DS_PDD(double p0, struct S_PDD p1) { return p0; }
+EXPORT double f10_D_DS_PDP(double p0, struct S_PDP p1) { return p0; }
+EXPORT double f10_D_DS_PPI(double p0, struct S_PPI p1) { return p0; }
+EXPORT double f10_D_DS_PPF(double p0, struct S_PPF p1) { return p0; }
+EXPORT double f10_D_DS_PPD(double p0, struct S_PPD p1) { return p0; }
+EXPORT double f10_D_DS_PPP(double p0, struct S_PPP p1) { return p0; }
+EXPORT void* f10_P_PI_(void* p0, int p1) { return p0; }
+EXPORT void* f10_P_PF_(void* p0, float p1) { return p0; }
+EXPORT void* f10_P_PD_(void* p0, double p1) { return p0; }
+EXPORT void* f10_P_PP_(void* p0, void* p1) { return p0; }
+EXPORT void* f10_P_PS_I(void* p0, struct S_I p1) { return p0; }
+EXPORT void* f10_P_PS_F(void* p0, struct S_F p1) { return p0; }
+EXPORT void* f10_P_PS_D(void* p0, struct S_D p1) { return p0; }
+EXPORT void* f10_P_PS_P(void* p0, struct S_P p1) { return p0; }
+EXPORT void* f10_P_PS_II(void* p0, struct S_II p1) { return p0; }
+EXPORT void* f10_P_PS_IF(void* p0, struct S_IF p1) { return p0; }
+EXPORT void* f10_P_PS_ID(void* p0, struct S_ID p1) { return p0; }
+EXPORT void* f10_P_PS_IP(void* p0, struct S_IP p1) { return p0; }
+EXPORT void* f10_P_PS_FI(void* p0, struct S_FI p1) { return p0; }
+EXPORT void* f10_P_PS_FF(void* p0, struct S_FF p1) { return p0; }
+EXPORT void* f10_P_PS_FD(void* p0, struct S_FD p1) { return p0; }
+EXPORT void* f10_P_PS_FP(void* p0, struct S_FP p1) { return p0; }
+EXPORT void* f10_P_PS_DI(void* p0, struct S_DI p1) { return p0; }
+EXPORT void* f10_P_PS_DF(void* p0, struct S_DF p1) { return p0; }
+EXPORT void* f10_P_PS_DD(void* p0, struct S_DD p1) { return p0; }
+EXPORT void* f10_P_PS_DP(void* p0, struct S_DP p1) { return p0; }
+EXPORT void* f10_P_PS_PI(void* p0, struct S_PI p1) { return p0; }
+EXPORT void* f10_P_PS_PF(void* p0, struct S_PF p1) { return p0; }
+EXPORT void* f10_P_PS_PD(void* p0, struct S_PD p1) { return p0; }
+EXPORT void* f10_P_PS_PP(void* p0, struct S_PP p1) { return p0; }
+EXPORT void* f10_P_PS_III(void* p0, struct S_III p1) { return p0; }
+EXPORT void* f10_P_PS_IIF(void* p0, struct S_IIF p1) { return p0; }
+EXPORT void* f10_P_PS_IID(void* p0, struct S_IID p1) { return p0; }
+EXPORT void* f10_P_PS_IIP(void* p0, struct S_IIP p1) { return p0; }
+EXPORT void* f10_P_PS_IFI(void* p0, struct S_IFI p1) { return p0; }
+EXPORT void* f10_P_PS_IFF(void* p0, struct S_IFF p1) { return p0; }
+EXPORT void* f10_P_PS_IFD(void* p0, struct S_IFD p1) { return p0; }
+EXPORT void* f10_P_PS_IFP(void* p0, struct S_IFP p1) { return p0; }
+EXPORT void* f10_P_PS_IDI(void* p0, struct S_IDI p1) { return p0; }
+EXPORT void* f10_P_PS_IDF(void* p0, struct S_IDF p1) { return p0; }
+EXPORT void* f10_P_PS_IDD(void* p0, struct S_IDD p1) { return p0; }
+EXPORT void* f10_P_PS_IDP(void* p0, struct S_IDP p1) { return p0; }
+EXPORT void* f10_P_PS_IPI(void* p0, struct S_IPI p1) { return p0; }
+EXPORT void* f10_P_PS_IPF(void* p0, struct S_IPF p1) { return p0; }
+EXPORT void* f10_P_PS_IPD(void* p0, struct S_IPD p1) { return p0; }
+EXPORT void* f10_P_PS_IPP(void* p0, struct S_IPP p1) { return p0; }
+EXPORT void* f10_P_PS_FII(void* p0, struct S_FII p1) { return p0; }
+EXPORT void* f10_P_PS_FIF(void* p0, struct S_FIF p1) { return p0; }
+EXPORT void* f10_P_PS_FID(void* p0, struct S_FID p1) { return p0; }
+EXPORT void* f10_P_PS_FIP(void* p0, struct S_FIP p1) { return p0; }
+EXPORT void* f10_P_PS_FFI(void* p0, struct S_FFI p1) { return p0; }
+EXPORT void* f10_P_PS_FFF(void* p0, struct S_FFF p1) { return p0; }
+EXPORT void* f10_P_PS_FFD(void* p0, struct S_FFD p1) { return p0; }
+EXPORT void* f10_P_PS_FFP(void* p0, struct S_FFP p1) { return p0; }
+EXPORT void* f10_P_PS_FDI(void* p0, struct S_FDI p1) { return p0; }
+EXPORT void* f10_P_PS_FDF(void* p0, struct S_FDF p1) { return p0; }
+EXPORT void* f10_P_PS_FDD(void* p0, struct S_FDD p1) { return p0; }
+EXPORT void* f10_P_PS_FDP(void* p0, struct S_FDP p1) { return p0; }
+EXPORT void* f10_P_PS_FPI(void* p0, struct S_FPI p1) { return p0; }
+EXPORT void* f10_P_PS_FPF(void* p0, struct S_FPF p1) { return p0; }
+EXPORT void* f10_P_PS_FPD(void* p0, struct S_FPD p1) { return p0; }
+EXPORT void* f10_P_PS_FPP(void* p0, struct S_FPP p1) { return p0; }
+EXPORT void* f10_P_PS_DII(void* p0, struct S_DII p1) { return p0; }
+EXPORT void* f10_P_PS_DIF(void* p0, struct S_DIF p1) { return p0; }
+EXPORT void* f10_P_PS_DID(void* p0, struct S_DID p1) { return p0; }
+EXPORT void* f10_P_PS_DIP(void* p0, struct S_DIP p1) { return p0; }
+EXPORT void* f10_P_PS_DFI(void* p0, struct S_DFI p1) { return p0; }
+EXPORT void* f10_P_PS_DFF(void* p0, struct S_DFF p1) { return p0; }
+EXPORT void* f10_P_PS_DFD(void* p0, struct S_DFD p1) { return p0; }
+EXPORT void* f10_P_PS_DFP(void* p0, struct S_DFP p1) { return p0; }
+EXPORT void* f10_P_PS_DDI(void* p0, struct S_DDI p1) { return p0; }
+EXPORT void* f10_P_PS_DDF(void* p0, struct S_DDF p1) { return p0; }
+EXPORT void* f10_P_PS_DDD(void* p0, struct S_DDD p1) { return p0; }
+EXPORT void* f10_P_PS_DDP(void* p0, struct S_DDP p1) { return p0; }
+EXPORT void* f10_P_PS_DPI(void* p0, struct S_DPI p1) { return p0; }
+EXPORT void* f10_P_PS_DPF(void* p0, struct S_DPF p1) { return p0; }
+EXPORT void* f10_P_PS_DPD(void* p0, struct S_DPD p1) { return p0; }
+EXPORT void* f10_P_PS_DPP(void* p0, struct S_DPP p1) { return p0; }
+EXPORT void* f10_P_PS_PII(void* p0, struct S_PII p1) { return p0; }
+EXPORT void* f10_P_PS_PIF(void* p0, struct S_PIF p1) { return p0; }
+EXPORT void* f10_P_PS_PID(void* p0, struct S_PID p1) { return p0; }
+EXPORT void* f10_P_PS_PIP(void* p0, struct S_PIP p1) { return p0; }
+EXPORT void* f10_P_PS_PFI(void* p0, struct S_PFI p1) { return p0; }
+EXPORT void* f10_P_PS_PFF(void* p0, struct S_PFF p1) { return p0; }
+EXPORT void* f10_P_PS_PFD(void* p0, struct S_PFD p1) { return p0; }
+EXPORT void* f10_P_PS_PFP(void* p0, struct S_PFP p1) { return p0; }
+EXPORT void* f10_P_PS_PDI(void* p0, struct S_PDI p1) { return p0; }
+EXPORT void* f10_P_PS_PDF(void* p0, struct S_PDF p1) { return p0; }
+EXPORT void* f10_P_PS_PDD(void* p0, struct S_PDD p1) { return p0; }
+EXPORT void* f10_P_PS_PDP(void* p0, struct S_PDP p1) { return p0; }
+EXPORT void* f10_P_PS_PPI(void* p0, struct S_PPI p1) { return p0; }
+EXPORT void* f10_P_PS_PPF(void* p0, struct S_PPF p1) { return p0; }
+EXPORT void* f10_P_PS_PPD(void* p0, struct S_PPD p1) { return p0; }
+EXPORT void* f10_P_PS_PPP(void* p0, struct S_PPP p1) { return p0; }
+EXPORT struct S_I f10_S_SI_I(struct S_I p0, int p1) { return p0; }
+EXPORT struct S_F f10_S_SI_F(struct S_F p0, int p1) { return p0; }
+EXPORT struct S_D f10_S_SI_D(struct S_D p0, int p1) { return p0; }
+EXPORT struct S_P f10_S_SI_P(struct S_P p0, int p1) { return p0; }
+EXPORT struct S_II f10_S_SI_II(struct S_II p0, int p1) { return p0; }
+EXPORT struct S_IF f10_S_SI_IF(struct S_IF p0, int p1) { return p0; }
+EXPORT struct S_ID f10_S_SI_ID(struct S_ID p0, int p1) { return p0; }
+EXPORT struct S_IP f10_S_SI_IP(struct S_IP p0, int p1) { return p0; }
+EXPORT struct S_FI f10_S_SI_FI(struct S_FI p0, int p1) { return p0; }
+EXPORT struct S_FF f10_S_SI_FF(struct S_FF p0, int p1) { return p0; }
+EXPORT struct S_FD f10_S_SI_FD(struct S_FD p0, int p1) { return p0; }
+EXPORT struct S_FP f10_S_SI_FP(struct S_FP p0, int p1) { return p0; }
+EXPORT struct S_DI f10_S_SI_DI(struct S_DI p0, int p1) { return p0; }
+EXPORT struct S_DF f10_S_SI_DF(struct S_DF p0, int p1) { return p0; }
+EXPORT struct S_DD f10_S_SI_DD(struct S_DD p0, int p1) { return p0; }
+EXPORT struct S_DP f10_S_SI_DP(struct S_DP p0, int p1) { return p0; }
+EXPORT struct S_PI f10_S_SI_PI(struct S_PI p0, int p1) { return p0; }
+EXPORT struct S_PF f10_S_SI_PF(struct S_PF p0, int p1) { return p0; }
+EXPORT struct S_PD f10_S_SI_PD(struct S_PD p0, int p1) { return p0; }
+EXPORT struct S_PP f10_S_SI_PP(struct S_PP p0, int p1) { return p0; }
+EXPORT struct S_III f10_S_SI_III(struct S_III p0, int p1) { return p0; }
+EXPORT struct S_IIF f10_S_SI_IIF(struct S_IIF p0, int p1) { return p0; }
+EXPORT struct S_IID f10_S_SI_IID(struct S_IID p0, int p1) { return p0; }
+EXPORT struct S_IIP f10_S_SI_IIP(struct S_IIP p0, int p1) { return p0; }
+EXPORT struct S_IFI f10_S_SI_IFI(struct S_IFI p0, int p1) { return p0; }
+EXPORT struct S_IFF f10_S_SI_IFF(struct S_IFF p0, int p1) { return p0; }
+EXPORT struct S_IFD f10_S_SI_IFD(struct S_IFD p0, int p1) { return p0; }
+EXPORT struct S_IFP f10_S_SI_IFP(struct S_IFP p0, int p1) { return p0; }
+EXPORT struct S_IDI f10_S_SI_IDI(struct S_IDI p0, int p1) { return p0; }
+EXPORT struct S_IDF f10_S_SI_IDF(struct S_IDF p0, int p1) { return p0; }
+EXPORT struct S_IDD f10_S_SI_IDD(struct S_IDD p0, int p1) { return p0; }
+EXPORT struct S_IDP f10_S_SI_IDP(struct S_IDP p0, int p1) { return p0; }
+EXPORT struct S_IPI f10_S_SI_IPI(struct S_IPI p0, int p1) { return p0; }
+EXPORT struct S_IPF f10_S_SI_IPF(struct S_IPF p0, int p1) { return p0; }
+EXPORT struct S_IPD f10_S_SI_IPD(struct S_IPD p0, int p1) { return p0; }
+EXPORT struct S_IPP f10_S_SI_IPP(struct S_IPP p0, int p1) { return p0; }
+EXPORT struct S_FII f10_S_SI_FII(struct S_FII p0, int p1) { return p0; }
+EXPORT struct S_FIF f10_S_SI_FIF(struct S_FIF p0, int p1) { return p0; }
+EXPORT struct S_FID f10_S_SI_FID(struct S_FID p0, int p1) { return p0; }
+EXPORT struct S_FIP f10_S_SI_FIP(struct S_FIP p0, int p1) { return p0; }
+EXPORT struct S_FFI f10_S_SI_FFI(struct S_FFI p0, int p1) { return p0; }
+EXPORT struct S_FFF f10_S_SI_FFF(struct S_FFF p0, int p1) { return p0; }
+EXPORT struct S_FFD f10_S_SI_FFD(struct S_FFD p0, int p1) { return p0; }
+EXPORT struct S_FFP f10_S_SI_FFP(struct S_FFP p0, int p1) { return p0; }
+EXPORT struct S_FDI f10_S_SI_FDI(struct S_FDI p0, int p1) { return p0; }
+EXPORT struct S_FDF f10_S_SI_FDF(struct S_FDF p0, int p1) { return p0; }
+EXPORT struct S_FDD f10_S_SI_FDD(struct S_FDD p0, int p1) { return p0; }
+EXPORT struct S_FDP f10_S_SI_FDP(struct S_FDP p0, int p1) { return p0; }
+EXPORT struct S_FPI f10_S_SI_FPI(struct S_FPI p0, int p1) { return p0; }
+EXPORT struct S_FPF f10_S_SI_FPF(struct S_FPF p0, int p1) { return p0; }
+EXPORT struct S_FPD f10_S_SI_FPD(struct S_FPD p0, int p1) { return p0; }
+EXPORT struct S_FPP f10_S_SI_FPP(struct S_FPP p0, int p1) { return p0; }
+EXPORT struct S_DII f10_S_SI_DII(struct S_DII p0, int p1) { return p0; }
+EXPORT struct S_DIF f10_S_SI_DIF(struct S_DIF p0, int p1) { return p0; }
+EXPORT struct S_DID f10_S_SI_DID(struct S_DID p0, int p1) { return p0; }
+EXPORT struct S_DIP f10_S_SI_DIP(struct S_DIP p0, int p1) { return p0; }
+EXPORT struct S_DFI f10_S_SI_DFI(struct S_DFI p0, int p1) { return p0; }
+EXPORT struct S_DFF f10_S_SI_DFF(struct S_DFF p0, int p1) { return p0; }
+EXPORT struct S_DFD f10_S_SI_DFD(struct S_DFD p0, int p1) { return p0; }
+EXPORT struct S_DFP f10_S_SI_DFP(struct S_DFP p0, int p1) { return p0; }
+EXPORT struct S_DDI f10_S_SI_DDI(struct S_DDI p0, int p1) { return p0; }
+EXPORT struct S_DDF f10_S_SI_DDF(struct S_DDF p0, int p1) { return p0; }
+EXPORT struct S_DDD f10_S_SI_DDD(struct S_DDD p0, int p1) { return p0; }
+EXPORT struct S_DDP f10_S_SI_DDP(struct S_DDP p0, int p1) { return p0; }
+EXPORT struct S_DPI f10_S_SI_DPI(struct S_DPI p0, int p1) { return p0; }
+EXPORT struct S_DPF f10_S_SI_DPF(struct S_DPF p0, int p1) { return p0; }
+EXPORT struct S_DPD f10_S_SI_DPD(struct S_DPD p0, int p1) { return p0; }
+EXPORT struct S_DPP f10_S_SI_DPP(struct S_DPP p0, int p1) { return p0; }
+EXPORT struct S_PII f10_S_SI_PII(struct S_PII p0, int p1) { return p0; }
+EXPORT struct S_PIF f10_S_SI_PIF(struct S_PIF p0, int p1) { return p0; }
+EXPORT struct S_PID f10_S_SI_PID(struct S_PID p0, int p1) { return p0; }
+EXPORT struct S_PIP f10_S_SI_PIP(struct S_PIP p0, int p1) { return p0; }
+EXPORT struct S_PFI f10_S_SI_PFI(struct S_PFI p0, int p1) { return p0; }
+EXPORT struct S_PFF f10_S_SI_PFF(struct S_PFF p0, int p1) { return p0; }
+EXPORT struct S_PFD f10_S_SI_PFD(struct S_PFD p0, int p1) { return p0; }
+EXPORT struct S_PFP f10_S_SI_PFP(struct S_PFP p0, int p1) { return p0; }
+EXPORT struct S_PDI f10_S_SI_PDI(struct S_PDI p0, int p1) { return p0; }
+EXPORT struct S_PDF f10_S_SI_PDF(struct S_PDF p0, int p1) { return p0; }
+EXPORT struct S_PDD f10_S_SI_PDD(struct S_PDD p0, int p1) { return p0; }
+EXPORT struct S_PDP f10_S_SI_PDP(struct S_PDP p0, int p1) { return p0; }
+EXPORT struct S_PPI f10_S_SI_PPI(struct S_PPI p0, int p1) { return p0; }
+EXPORT struct S_PPF f10_S_SI_PPF(struct S_PPF p0, int p1) { return p0; }
+EXPORT struct S_PPD f10_S_SI_PPD(struct S_PPD p0, int p1) { return p0; }
+EXPORT struct S_PPP f10_S_SI_PPP(struct S_PPP p0, int p1) { return p0; }
+EXPORT struct S_I f10_S_SF_I(struct S_I p0, float p1) { return p0; }
+EXPORT struct S_F f10_S_SF_F(struct S_F p0, float p1) { return p0; }
+EXPORT struct S_D f10_S_SF_D(struct S_D p0, float p1) { return p0; }
+EXPORT struct S_P f10_S_SF_P(struct S_P p0, float p1) { return p0; }
+EXPORT struct S_II f10_S_SF_II(struct S_II p0, float p1) { return p0; }
+EXPORT struct S_IF f10_S_SF_IF(struct S_IF p0, float p1) { return p0; }
+EXPORT struct S_ID f10_S_SF_ID(struct S_ID p0, float p1) { return p0; }
+EXPORT struct S_IP f10_S_SF_IP(struct S_IP p0, float p1) { return p0; }
+EXPORT struct S_FI f10_S_SF_FI(struct S_FI p0, float p1) { return p0; }
+EXPORT struct S_FF f10_S_SF_FF(struct S_FF p0, float p1) { return p0; }
+EXPORT struct S_FD f10_S_SF_FD(struct S_FD p0, float p1) { return p0; }
+EXPORT struct S_FP f10_S_SF_FP(struct S_FP p0, float p1) { return p0; }
+EXPORT struct S_DI f10_S_SF_DI(struct S_DI p0, float p1) { return p0; }
+EXPORT struct S_DF f10_S_SF_DF(struct S_DF p0, float p1) { return p0; }
+EXPORT struct S_DD f10_S_SF_DD(struct S_DD p0, float p1) { return p0; }
+EXPORT struct S_DP f10_S_SF_DP(struct S_DP p0, float p1) { return p0; }
+EXPORT struct S_PI f10_S_SF_PI(struct S_PI p0, float p1) { return p0; }
+EXPORT struct S_PF f10_S_SF_PF(struct S_PF p0, float p1) { return p0; }
+EXPORT struct S_PD f10_S_SF_PD(struct S_PD p0, float p1) { return p0; }
+EXPORT struct S_PP f10_S_SF_PP(struct S_PP p0, float p1) { return p0; }
+EXPORT struct S_III f10_S_SF_III(struct S_III p0, float p1) { return p0; }
+EXPORT struct S_IIF f10_S_SF_IIF(struct S_IIF p0, float p1) { return p0; }
+EXPORT struct S_IID f10_S_SF_IID(struct S_IID p0, float p1) { return p0; }
+EXPORT struct S_IIP f10_S_SF_IIP(struct S_IIP p0, float p1) { return p0; }
+EXPORT struct S_IFI f10_S_SF_IFI(struct S_IFI p0, float p1) { return p0; }
+EXPORT struct S_IFF f10_S_SF_IFF(struct S_IFF p0, float p1) { return p0; }
+EXPORT struct S_IFD f10_S_SF_IFD(struct S_IFD p0, float p1) { return p0; }
+EXPORT struct S_IFP f11_S_SF_IFP(struct S_IFP p0, float p1) { return p0; }
+EXPORT struct S_IDI f11_S_SF_IDI(struct S_IDI p0, float p1) { return p0; }
+EXPORT struct S_IDF f11_S_SF_IDF(struct S_IDF p0, float p1) { return p0; }
+EXPORT struct S_IDD f11_S_SF_IDD(struct S_IDD p0, float p1) { return p0; }
+EXPORT struct S_IDP f11_S_SF_IDP(struct S_IDP p0, float p1) { return p0; }
+EXPORT struct S_IPI f11_S_SF_IPI(struct S_IPI p0, float p1) { return p0; }
+EXPORT struct S_IPF f11_S_SF_IPF(struct S_IPF p0, float p1) { return p0; }
+EXPORT struct S_IPD f11_S_SF_IPD(struct S_IPD p0, float p1) { return p0; }
+EXPORT struct S_IPP f11_S_SF_IPP(struct S_IPP p0, float p1) { return p0; }
+EXPORT struct S_FII f11_S_SF_FII(struct S_FII p0, float p1) { return p0; }
+EXPORT struct S_FIF f11_S_SF_FIF(struct S_FIF p0, float p1) { return p0; }
+EXPORT struct S_FID f11_S_SF_FID(struct S_FID p0, float p1) { return p0; }
+EXPORT struct S_FIP f11_S_SF_FIP(struct S_FIP p0, float p1) { return p0; }
+EXPORT struct S_FFI f11_S_SF_FFI(struct S_FFI p0, float p1) { return p0; }
+EXPORT struct S_FFF f11_S_SF_FFF(struct S_FFF p0, float p1) { return p0; }
+EXPORT struct S_FFD f11_S_SF_FFD(struct S_FFD p0, float p1) { return p0; }
+EXPORT struct S_FFP f11_S_SF_FFP(struct S_FFP p0, float p1) { return p0; }
+EXPORT struct S_FDI f11_S_SF_FDI(struct S_FDI p0, float p1) { return p0; }
+EXPORT struct S_FDF f11_S_SF_FDF(struct S_FDF p0, float p1) { return p0; }
+EXPORT struct S_FDD f11_S_SF_FDD(struct S_FDD p0, float p1) { return p0; }
+EXPORT struct S_FDP f11_S_SF_FDP(struct S_FDP p0, float p1) { return p0; }
+EXPORT struct S_FPI f11_S_SF_FPI(struct S_FPI p0, float p1) { return p0; }
+EXPORT struct S_FPF f11_S_SF_FPF(struct S_FPF p0, float p1) { return p0; }
+EXPORT struct S_FPD f11_S_SF_FPD(struct S_FPD p0, float p1) { return p0; }
+EXPORT struct S_FPP f11_S_SF_FPP(struct S_FPP p0, float p1) { return p0; }
+EXPORT struct S_DII f11_S_SF_DII(struct S_DII p0, float p1) { return p0; }
+EXPORT struct S_DIF f11_S_SF_DIF(struct S_DIF p0, float p1) { return p0; }
+EXPORT struct S_DID f11_S_SF_DID(struct S_DID p0, float p1) { return p0; }
+EXPORT struct S_DIP f11_S_SF_DIP(struct S_DIP p0, float p1) { return p0; }
+EXPORT struct S_DFI f11_S_SF_DFI(struct S_DFI p0, float p1) { return p0; }
+EXPORT struct S_DFF f11_S_SF_DFF(struct S_DFF p0, float p1) { return p0; }
+EXPORT struct S_DFD f11_S_SF_DFD(struct S_DFD p0, float p1) { return p0; }
+EXPORT struct S_DFP f11_S_SF_DFP(struct S_DFP p0, float p1) { return p0; }
+EXPORT struct S_DDI f11_S_SF_DDI(struct S_DDI p0, float p1) { return p0; }
+EXPORT struct S_DDF f11_S_SF_DDF(struct S_DDF p0, float p1) { return p0; }
+EXPORT struct S_DDD f11_S_SF_DDD(struct S_DDD p0, float p1) { return p0; }
+EXPORT struct S_DDP f11_S_SF_DDP(struct S_DDP p0, float p1) { return p0; }
+EXPORT struct S_DPI f11_S_SF_DPI(struct S_DPI p0, float p1) { return p0; }
+EXPORT struct S_DPF f11_S_SF_DPF(struct S_DPF p0, float p1) { return p0; }
+EXPORT struct S_DPD f11_S_SF_DPD(struct S_DPD p0, float p1) { return p0; }
+EXPORT struct S_DPP f11_S_SF_DPP(struct S_DPP p0, float p1) { return p0; }
+EXPORT struct S_PII f11_S_SF_PII(struct S_PII p0, float p1) { return p0; }
+EXPORT struct S_PIF f11_S_SF_PIF(struct S_PIF p0, float p1) { return p0; }
+EXPORT struct S_PID f11_S_SF_PID(struct S_PID p0, float p1) { return p0; }
+EXPORT struct S_PIP f11_S_SF_PIP(struct S_PIP p0, float p1) { return p0; }
+EXPORT struct S_PFI f11_S_SF_PFI(struct S_PFI p0, float p1) { return p0; }
+EXPORT struct S_PFF f11_S_SF_PFF(struct S_PFF p0, float p1) { return p0; }
+EXPORT struct S_PFD f11_S_SF_PFD(struct S_PFD p0, float p1) { return p0; }
+EXPORT struct S_PFP f11_S_SF_PFP(struct S_PFP p0, float p1) { return p0; }
+EXPORT struct S_PDI f11_S_SF_PDI(struct S_PDI p0, float p1) { return p0; }
+EXPORT struct S_PDF f11_S_SF_PDF(struct S_PDF p0, float p1) { return p0; }
+EXPORT struct S_PDD f11_S_SF_PDD(struct S_PDD p0, float p1) { return p0; }
+EXPORT struct S_PDP f11_S_SF_PDP(struct S_PDP p0, float p1) { return p0; }
+EXPORT struct S_PPI f11_S_SF_PPI(struct S_PPI p0, float p1) { return p0; }
+EXPORT struct S_PPF f11_S_SF_PPF(struct S_PPF p0, float p1) { return p0; }
+EXPORT struct S_PPD f11_S_SF_PPD(struct S_PPD p0, float p1) { return p0; }
+EXPORT struct S_PPP f11_S_SF_PPP(struct S_PPP p0, float p1) { return p0; }
+EXPORT struct S_I f11_S_SD_I(struct S_I p0, double p1) { return p0; }
+EXPORT struct S_F f11_S_SD_F(struct S_F p0, double p1) { return p0; }
+EXPORT struct S_D f11_S_SD_D(struct S_D p0, double p1) { return p0; }
+EXPORT struct S_P f11_S_SD_P(struct S_P p0, double p1) { return p0; }
+EXPORT struct S_II f11_S_SD_II(struct S_II p0, double p1) { return p0; }
+EXPORT struct S_IF f11_S_SD_IF(struct S_IF p0, double p1) { return p0; }
+EXPORT struct S_ID f11_S_SD_ID(struct S_ID p0, double p1) { return p0; }
+EXPORT struct S_IP f11_S_SD_IP(struct S_IP p0, double p1) { return p0; }
+EXPORT struct S_FI f11_S_SD_FI(struct S_FI p0, double p1) { return p0; }
+EXPORT struct S_FF f11_S_SD_FF(struct S_FF p0, double p1) { return p0; }
+EXPORT struct S_FD f11_S_SD_FD(struct S_FD p0, double p1) { return p0; }
+EXPORT struct S_FP f11_S_SD_FP(struct S_FP p0, double p1) { return p0; }
+EXPORT struct S_DI f11_S_SD_DI(struct S_DI p0, double p1) { return p0; }
+EXPORT struct S_DF f11_S_SD_DF(struct S_DF p0, double p1) { return p0; }
+EXPORT struct S_DD f11_S_SD_DD(struct S_DD p0, double p1) { return p0; }
+EXPORT struct S_DP f11_S_SD_DP(struct S_DP p0, double p1) { return p0; }
+EXPORT struct S_PI f11_S_SD_PI(struct S_PI p0, double p1) { return p0; }
+EXPORT struct S_PF f11_S_SD_PF(struct S_PF p0, double p1) { return p0; }
+EXPORT struct S_PD f11_S_SD_PD(struct S_PD p0, double p1) { return p0; }
+EXPORT struct S_PP f11_S_SD_PP(struct S_PP p0, double p1) { return p0; }
+EXPORT struct S_III f11_S_SD_III(struct S_III p0, double p1) { return p0; }
+EXPORT struct S_IIF f11_S_SD_IIF(struct S_IIF p0, double p1) { return p0; }
+EXPORT struct S_IID f11_S_SD_IID(struct S_IID p0, double p1) { return p0; }
+EXPORT struct S_IIP f11_S_SD_IIP(struct S_IIP p0, double p1) { return p0; }
+EXPORT struct S_IFI f11_S_SD_IFI(struct S_IFI p0, double p1) { return p0; }
+EXPORT struct S_IFF f11_S_SD_IFF(struct S_IFF p0, double p1) { return p0; }
+EXPORT struct S_IFD f11_S_SD_IFD(struct S_IFD p0, double p1) { return p0; }
+EXPORT struct S_IFP f11_S_SD_IFP(struct S_IFP p0, double p1) { return p0; }
+EXPORT struct S_IDI f11_S_SD_IDI(struct S_IDI p0, double p1) { return p0; }
+EXPORT struct S_IDF f11_S_SD_IDF(struct S_IDF p0, double p1) { return p0; }
+EXPORT struct S_IDD f11_S_SD_IDD(struct S_IDD p0, double p1) { return p0; }
+EXPORT struct S_IDP f11_S_SD_IDP(struct S_IDP p0, double p1) { return p0; }
+EXPORT struct S_IPI f11_S_SD_IPI(struct S_IPI p0, double p1) { return p0; }
+EXPORT struct S_IPF f11_S_SD_IPF(struct S_IPF p0, double p1) { return p0; }
+EXPORT struct S_IPD f11_S_SD_IPD(struct S_IPD p0, double p1) { return p0; }
+EXPORT struct S_IPP f11_S_SD_IPP(struct S_IPP p0, double p1) { return p0; }
+EXPORT struct S_FII f11_S_SD_FII(struct S_FII p0, double p1) { return p0; }
+EXPORT struct S_FIF f11_S_SD_FIF(struct S_FIF p0, double p1) { return p0; }
+EXPORT struct S_FID f11_S_SD_FID(struct S_FID p0, double p1) { return p0; }
+EXPORT struct S_FIP f11_S_SD_FIP(struct S_FIP p0, double p1) { return p0; }
+EXPORT struct S_FFI f11_S_SD_FFI(struct S_FFI p0, double p1) { return p0; }
+EXPORT struct S_FFF f11_S_SD_FFF(struct S_FFF p0, double p1) { return p0; }
+EXPORT struct S_FFD f11_S_SD_FFD(struct S_FFD p0, double p1) { return p0; }
+EXPORT struct S_FFP f11_S_SD_FFP(struct S_FFP p0, double p1) { return p0; }
+EXPORT struct S_FDI f11_S_SD_FDI(struct S_FDI p0, double p1) { return p0; }
+EXPORT struct S_FDF f11_S_SD_FDF(struct S_FDF p0, double p1) { return p0; }
+EXPORT struct S_FDD f11_S_SD_FDD(struct S_FDD p0, double p1) { return p0; }
+EXPORT struct S_FDP f11_S_SD_FDP(struct S_FDP p0, double p1) { return p0; }
+EXPORT struct S_FPI f11_S_SD_FPI(struct S_FPI p0, double p1) { return p0; }
+EXPORT struct S_FPF f11_S_SD_FPF(struct S_FPF p0, double p1) { return p0; }
+EXPORT struct S_FPD f11_S_SD_FPD(struct S_FPD p0, double p1) { return p0; }
+EXPORT struct S_FPP f11_S_SD_FPP(struct S_FPP p0, double p1) { return p0; }
+EXPORT struct S_DII f11_S_SD_DII(struct S_DII p0, double p1) { return p0; }
+EXPORT struct S_DIF f11_S_SD_DIF(struct S_DIF p0, double p1) { return p0; }
+EXPORT struct S_DID f11_S_SD_DID(struct S_DID p0, double p1) { return p0; }
+EXPORT struct S_DIP f11_S_SD_DIP(struct S_DIP p0, double p1) { return p0; }
+EXPORT struct S_DFI f11_S_SD_DFI(struct S_DFI p0, double p1) { return p0; }
+EXPORT struct S_DFF f11_S_SD_DFF(struct S_DFF p0, double p1) { return p0; }
+EXPORT struct S_DFD f11_S_SD_DFD(struct S_DFD p0, double p1) { return p0; }
+EXPORT struct S_DFP f11_S_SD_DFP(struct S_DFP p0, double p1) { return p0; }
+EXPORT struct S_DDI f11_S_SD_DDI(struct S_DDI p0, double p1) { return p0; }
+EXPORT struct S_DDF f11_S_SD_DDF(struct S_DDF p0, double p1) { return p0; }
+EXPORT struct S_DDD f11_S_SD_DDD(struct S_DDD p0, double p1) { return p0; }
+EXPORT struct S_DDP f11_S_SD_DDP(struct S_DDP p0, double p1) { return p0; }
+EXPORT struct S_DPI f11_S_SD_DPI(struct S_DPI p0, double p1) { return p0; }
+EXPORT struct S_DPF f11_S_SD_DPF(struct S_DPF p0, double p1) { return p0; }
+EXPORT struct S_DPD f11_S_SD_DPD(struct S_DPD p0, double p1) { return p0; }
+EXPORT struct S_DPP f11_S_SD_DPP(struct S_DPP p0, double p1) { return p0; }
+EXPORT struct S_PII f11_S_SD_PII(struct S_PII p0, double p1) { return p0; }
+EXPORT struct S_PIF f11_S_SD_PIF(struct S_PIF p0, double p1) { return p0; }
+EXPORT struct S_PID f11_S_SD_PID(struct S_PID p0, double p1) { return p0; }
+EXPORT struct S_PIP f11_S_SD_PIP(struct S_PIP p0, double p1) { return p0; }
+EXPORT struct S_PFI f11_S_SD_PFI(struct S_PFI p0, double p1) { return p0; }
+EXPORT struct S_PFF f11_S_SD_PFF(struct S_PFF p0, double p1) { return p0; }
+EXPORT struct S_PFD f11_S_SD_PFD(struct S_PFD p0, double p1) { return p0; }
+EXPORT struct S_PFP f11_S_SD_PFP(struct S_PFP p0, double p1) { return p0; }
+EXPORT struct S_PDI f11_S_SD_PDI(struct S_PDI p0, double p1) { return p0; }
+EXPORT struct S_PDF f11_S_SD_PDF(struct S_PDF p0, double p1) { return p0; }
+EXPORT struct S_PDD f11_S_SD_PDD(struct S_PDD p0, double p1) { return p0; }
+EXPORT struct S_PDP f11_S_SD_PDP(struct S_PDP p0, double p1) { return p0; }
+EXPORT struct S_PPI f11_S_SD_PPI(struct S_PPI p0, double p1) { return p0; }
+EXPORT struct S_PPF f11_S_SD_PPF(struct S_PPF p0, double p1) { return p0; }
+EXPORT struct S_PPD f11_S_SD_PPD(struct S_PPD p0, double p1) { return p0; }
+EXPORT struct S_PPP f11_S_SD_PPP(struct S_PPP p0, double p1) { return p0; }
+EXPORT struct S_I f11_S_SP_I(struct S_I p0, void* p1) { return p0; }
+EXPORT struct S_F f11_S_SP_F(struct S_F p0, void* p1) { return p0; }
+EXPORT struct S_D f11_S_SP_D(struct S_D p0, void* p1) { return p0; }
+EXPORT struct S_P f11_S_SP_P(struct S_P p0, void* p1) { return p0; }
+EXPORT struct S_II f11_S_SP_II(struct S_II p0, void* p1) { return p0; }
+EXPORT struct S_IF f11_S_SP_IF(struct S_IF p0, void* p1) { return p0; }
+EXPORT struct S_ID f11_S_SP_ID(struct S_ID p0, void* p1) { return p0; }
+EXPORT struct S_IP f11_S_SP_IP(struct S_IP p0, void* p1) { return p0; }
+EXPORT struct S_FI f11_S_SP_FI(struct S_FI p0, void* p1) { return p0; }
+EXPORT struct S_FF f11_S_SP_FF(struct S_FF p0, void* p1) { return p0; }
+EXPORT struct S_FD f11_S_SP_FD(struct S_FD p0, void* p1) { return p0; }
+EXPORT struct S_FP f11_S_SP_FP(struct S_FP p0, void* p1) { return p0; }
+EXPORT struct S_DI f11_S_SP_DI(struct S_DI p0, void* p1) { return p0; }
+EXPORT struct S_DF f11_S_SP_DF(struct S_DF p0, void* p1) { return p0; }
+EXPORT struct S_DD f11_S_SP_DD(struct S_DD p0, void* p1) { return p0; }
+EXPORT struct S_DP f11_S_SP_DP(struct S_DP p0, void* p1) { return p0; }
+EXPORT struct S_PI f11_S_SP_PI(struct S_PI p0, void* p1) { return p0; }
+EXPORT struct S_PF f11_S_SP_PF(struct S_PF p0, void* p1) { return p0; }
+EXPORT struct S_PD f11_S_SP_PD(struct S_PD p0, void* p1) { return p0; }
+EXPORT struct S_PP f11_S_SP_PP(struct S_PP p0, void* p1) { return p0; }
+EXPORT struct S_III f11_S_SP_III(struct S_III p0, void* p1) { return p0; }
+EXPORT struct S_IIF f11_S_SP_IIF(struct S_IIF p0, void* p1) { return p0; }
+EXPORT struct S_IID f11_S_SP_IID(struct S_IID p0, void* p1) { return p0; }
+EXPORT struct S_IIP f11_S_SP_IIP(struct S_IIP p0, void* p1) { return p0; }
+EXPORT struct S_IFI f11_S_SP_IFI(struct S_IFI p0, void* p1) { return p0; }
+EXPORT struct S_IFF f11_S_SP_IFF(struct S_IFF p0, void* p1) { return p0; }
+EXPORT struct S_IFD f11_S_SP_IFD(struct S_IFD p0, void* p1) { return p0; }
+EXPORT struct S_IFP f11_S_SP_IFP(struct S_IFP p0, void* p1) { return p0; }
+EXPORT struct S_IDI f11_S_SP_IDI(struct S_IDI p0, void* p1) { return p0; }
+EXPORT struct S_IDF f11_S_SP_IDF(struct S_IDF p0, void* p1) { return p0; }
+EXPORT struct S_IDD f11_S_SP_IDD(struct S_IDD p0, void* p1) { return p0; }
+EXPORT struct S_IDP f11_S_SP_IDP(struct S_IDP p0, void* p1) { return p0; }
+EXPORT struct S_IPI f11_S_SP_IPI(struct S_IPI p0, void* p1) { return p0; }
+EXPORT struct S_IPF f11_S_SP_IPF(struct S_IPF p0, void* p1) { return p0; }
+EXPORT struct S_IPD f11_S_SP_IPD(struct S_IPD p0, void* p1) { return p0; }
+EXPORT struct S_IPP f11_S_SP_IPP(struct S_IPP p0, void* p1) { return p0; }
+EXPORT struct S_FII f11_S_SP_FII(struct S_FII p0, void* p1) { return p0; }
+EXPORT struct S_FIF f11_S_SP_FIF(struct S_FIF p0, void* p1) { return p0; }
+EXPORT struct S_FID f11_S_SP_FID(struct S_FID p0, void* p1) { return p0; }
+EXPORT struct S_FIP f11_S_SP_FIP(struct S_FIP p0, void* p1) { return p0; }
+EXPORT struct S_FFI f11_S_SP_FFI(struct S_FFI p0, void* p1) { return p0; }
+EXPORT struct S_FFF f11_S_SP_FFF(struct S_FFF p0, void* p1) { return p0; }
+EXPORT struct S_FFD f11_S_SP_FFD(struct S_FFD p0, void* p1) { return p0; }
+EXPORT struct S_FFP f11_S_SP_FFP(struct S_FFP p0, void* p1) { return p0; }
+EXPORT struct S_FDI f11_S_SP_FDI(struct S_FDI p0, void* p1) { return p0; }
+EXPORT struct S_FDF f11_S_SP_FDF(struct S_FDF p0, void* p1) { return p0; }
+EXPORT struct S_FDD f11_S_SP_FDD(struct S_FDD p0, void* p1) { return p0; }
+EXPORT struct S_FDP f11_S_SP_FDP(struct S_FDP p0, void* p1) { return p0; }
+EXPORT struct S_FPI f11_S_SP_FPI(struct S_FPI p0, void* p1) { return p0; }
+EXPORT struct S_FPF f11_S_SP_FPF(struct S_FPF p0, void* p1) { return p0; }
+EXPORT struct S_FPD f11_S_SP_FPD(struct S_FPD p0, void* p1) { return p0; }
+EXPORT struct S_FPP f11_S_SP_FPP(struct S_FPP p0, void* p1) { return p0; }
+EXPORT struct S_DII f11_S_SP_DII(struct S_DII p0, void* p1) { return p0; }
+EXPORT struct S_DIF f11_S_SP_DIF(struct S_DIF p0, void* p1) { return p0; }
+EXPORT struct S_DID f11_S_SP_DID(struct S_DID p0, void* p1) { return p0; }
+EXPORT struct S_DIP f11_S_SP_DIP(struct S_DIP p0, void* p1) { return p0; }
+EXPORT struct S_DFI f11_S_SP_DFI(struct S_DFI p0, void* p1) { return p0; }
+EXPORT struct S_DFF f11_S_SP_DFF(struct S_DFF p0, void* p1) { return p0; }
+EXPORT struct S_DFD f11_S_SP_DFD(struct S_DFD p0, void* p1) { return p0; }
+EXPORT struct S_DFP f11_S_SP_DFP(struct S_DFP p0, void* p1) { return p0; }
+EXPORT struct S_DDI f11_S_SP_DDI(struct S_DDI p0, void* p1) { return p0; }
+EXPORT struct S_DDF f11_S_SP_DDF(struct S_DDF p0, void* p1) { return p0; }
+EXPORT struct S_DDD f11_S_SP_DDD(struct S_DDD p0, void* p1) { return p0; }
+EXPORT struct S_DDP f11_S_SP_DDP(struct S_DDP p0, void* p1) { return p0; }
+EXPORT struct S_DPI f11_S_SP_DPI(struct S_DPI p0, void* p1) { return p0; }
+EXPORT struct S_DPF f11_S_SP_DPF(struct S_DPF p0, void* p1) { return p0; }
+EXPORT struct S_DPD f11_S_SP_DPD(struct S_DPD p0, void* p1) { return p0; }
+EXPORT struct S_DPP f11_S_SP_DPP(struct S_DPP p0, void* p1) { return p0; }
+EXPORT struct S_PII f11_S_SP_PII(struct S_PII p0, void* p1) { return p0; }
+EXPORT struct S_PIF f11_S_SP_PIF(struct S_PIF p0, void* p1) { return p0; }
+EXPORT struct S_PID f11_S_SP_PID(struct S_PID p0, void* p1) { return p0; }
+EXPORT struct S_PIP f11_S_SP_PIP(struct S_PIP p0, void* p1) { return p0; }
+EXPORT struct S_PFI f11_S_SP_PFI(struct S_PFI p0, void* p1) { return p0; }
+EXPORT struct S_PFF f11_S_SP_PFF(struct S_PFF p0, void* p1) { return p0; }
+EXPORT struct S_PFD f11_S_SP_PFD(struct S_PFD p0, void* p1) { return p0; }
+EXPORT struct S_PFP f11_S_SP_PFP(struct S_PFP p0, void* p1) { return p0; }
+EXPORT struct S_PDI f11_S_SP_PDI(struct S_PDI p0, void* p1) { return p0; }
+EXPORT struct S_PDF f11_S_SP_PDF(struct S_PDF p0, void* p1) { return p0; }
+EXPORT struct S_PDD f11_S_SP_PDD(struct S_PDD p0, void* p1) { return p0; }
+EXPORT struct S_PDP f11_S_SP_PDP(struct S_PDP p0, void* p1) { return p0; }
+EXPORT struct S_PPI f11_S_SP_PPI(struct S_PPI p0, void* p1) { return p0; }
+EXPORT struct S_PPF f11_S_SP_PPF(struct S_PPF p0, void* p1) { return p0; }
+EXPORT struct S_PPD f11_S_SP_PPD(struct S_PPD p0, void* p1) { return p0; }
+EXPORT struct S_PPP f11_S_SP_PPP(struct S_PPP p0, void* p1) { return p0; }
+EXPORT struct S_I f11_S_SS_I(struct S_I p0, struct S_I p1) { return p0; }
+EXPORT struct S_F f11_S_SS_F(struct S_F p0, struct S_F p1) { return p0; }
+EXPORT struct S_D f11_S_SS_D(struct S_D p0, struct S_D p1) { return p0; }
+EXPORT struct S_P f11_S_SS_P(struct S_P p0, struct S_P p1) { return p0; }
+EXPORT struct S_II f11_S_SS_II(struct S_II p0, struct S_II p1) { return p0; }
+EXPORT struct S_IF f11_S_SS_IF(struct S_IF p0, struct S_IF p1) { return p0; }
+EXPORT struct S_ID f11_S_SS_ID(struct S_ID p0, struct S_ID p1) { return p0; }
+EXPORT struct S_IP f11_S_SS_IP(struct S_IP p0, struct S_IP p1) { return p0; }
+EXPORT struct S_FI f11_S_SS_FI(struct S_FI p0, struct S_FI p1) { return p0; }
+EXPORT struct S_FF f11_S_SS_FF(struct S_FF p0, struct S_FF p1) { return p0; }
+EXPORT struct S_FD f11_S_SS_FD(struct S_FD p0, struct S_FD p1) { return p0; }
+EXPORT struct S_FP f11_S_SS_FP(struct S_FP p0, struct S_FP p1) { return p0; }
+EXPORT struct S_DI f11_S_SS_DI(struct S_DI p0, struct S_DI p1) { return p0; }
+EXPORT struct S_DF f11_S_SS_DF(struct S_DF p0, struct S_DF p1) { return p0; }
+EXPORT struct S_DD f11_S_SS_DD(struct S_DD p0, struct S_DD p1) { return p0; }
+EXPORT struct S_DP f11_S_SS_DP(struct S_DP p0, struct S_DP p1) { return p0; }
+EXPORT struct S_PI f11_S_SS_PI(struct S_PI p0, struct S_PI p1) { return p0; }
+EXPORT struct S_PF f11_S_SS_PF(struct S_PF p0, struct S_PF p1) { return p0; }
+EXPORT struct S_PD f11_S_SS_PD(struct S_PD p0, struct S_PD p1) { return p0; }
+EXPORT struct S_PP f11_S_SS_PP(struct S_PP p0, struct S_PP p1) { return p0; }
+EXPORT struct S_III f11_S_SS_III(struct S_III p0, struct S_III p1) { return p0; }
+EXPORT struct S_IIF f11_S_SS_IIF(struct S_IIF p0, struct S_IIF p1) { return p0; }
+EXPORT struct S_IID f11_S_SS_IID(struct S_IID p0, struct S_IID p1) { return p0; }
+EXPORT struct S_IIP f11_S_SS_IIP(struct S_IIP p0, struct S_IIP p1) { return p0; }
+EXPORT struct S_IFI f11_S_SS_IFI(struct S_IFI p0, struct S_IFI p1) { return p0; }
+EXPORT struct S_IFF f11_S_SS_IFF(struct S_IFF p0, struct S_IFF p1) { return p0; }
+EXPORT struct S_IFD f11_S_SS_IFD(struct S_IFD p0, struct S_IFD p1) { return p0; }
+EXPORT struct S_IFP f11_S_SS_IFP(struct S_IFP p0, struct S_IFP p1) { return p0; }
+EXPORT struct S_IDI f11_S_SS_IDI(struct S_IDI p0, struct S_IDI p1) { return p0; }
+EXPORT struct S_IDF f11_S_SS_IDF(struct S_IDF p0, struct S_IDF p1) { return p0; }
+EXPORT struct S_IDD f11_S_SS_IDD(struct S_IDD p0, struct S_IDD p1) { return p0; }
+EXPORT struct S_IDP f11_S_SS_IDP(struct S_IDP p0, struct S_IDP p1) { return p0; }
+EXPORT struct S_IPI f11_S_SS_IPI(struct S_IPI p0, struct S_IPI p1) { return p0; }
+EXPORT struct S_IPF f11_S_SS_IPF(struct S_IPF p0, struct S_IPF p1) { return p0; }
+EXPORT struct S_IPD f11_S_SS_IPD(struct S_IPD p0, struct S_IPD p1) { return p0; }
+EXPORT struct S_IPP f11_S_SS_IPP(struct S_IPP p0, struct S_IPP p1) { return p0; }
+EXPORT struct S_FII f11_S_SS_FII(struct S_FII p0, struct S_FII p1) { return p0; }
+EXPORT struct S_FIF f11_S_SS_FIF(struct S_FIF p0, struct S_FIF p1) { return p0; }
+EXPORT struct S_FID f11_S_SS_FID(struct S_FID p0, struct S_FID p1) { return p0; }
+EXPORT struct S_FIP f11_S_SS_FIP(struct S_FIP p0, struct S_FIP p1) { return p0; }
+EXPORT struct S_FFI f11_S_SS_FFI(struct S_FFI p0, struct S_FFI p1) { return p0; }
+EXPORT struct S_FFF f11_S_SS_FFF(struct S_FFF p0, struct S_FFF p1) { return p0; }
+EXPORT struct S_FFD f11_S_SS_FFD(struct S_FFD p0, struct S_FFD p1) { return p0; }
+EXPORT struct S_FFP f11_S_SS_FFP(struct S_FFP p0, struct S_FFP p1) { return p0; }
+EXPORT struct S_FDI f11_S_SS_FDI(struct S_FDI p0, struct S_FDI p1) { return p0; }
+EXPORT struct S_FDF f11_S_SS_FDF(struct S_FDF p0, struct S_FDF p1) { return p0; }
+EXPORT struct S_FDD f11_S_SS_FDD(struct S_FDD p0, struct S_FDD p1) { return p0; }
+EXPORT struct S_FDP f11_S_SS_FDP(struct S_FDP p0, struct S_FDP p1) { return p0; }
+EXPORT struct S_FPI f11_S_SS_FPI(struct S_FPI p0, struct S_FPI p1) { return p0; }
+EXPORT struct S_FPF f11_S_SS_FPF(struct S_FPF p0, struct S_FPF p1) { return p0; }
+EXPORT struct S_FPD f11_S_SS_FPD(struct S_FPD p0, struct S_FPD p1) { return p0; }
+EXPORT struct S_FPP f11_S_SS_FPP(struct S_FPP p0, struct S_FPP p1) { return p0; }
+EXPORT struct S_DII f11_S_SS_DII(struct S_DII p0, struct S_DII p1) { return p0; }
+EXPORT struct S_DIF f11_S_SS_DIF(struct S_DIF p0, struct S_DIF p1) { return p0; }
+EXPORT struct S_DID f11_S_SS_DID(struct S_DID p0, struct S_DID p1) { return p0; }
+EXPORT struct S_DIP f11_S_SS_DIP(struct S_DIP p0, struct S_DIP p1) { return p0; }
+EXPORT struct S_DFI f11_S_SS_DFI(struct S_DFI p0, struct S_DFI p1) { return p0; }
+EXPORT struct S_DFF f11_S_SS_DFF(struct S_DFF p0, struct S_DFF p1) { return p0; }
+EXPORT struct S_DFD f11_S_SS_DFD(struct S_DFD p0, struct S_DFD p1) { return p0; }
+EXPORT struct S_DFP f11_S_SS_DFP(struct S_DFP p0, struct S_DFP p1) { return p0; }
+EXPORT struct S_DDI f11_S_SS_DDI(struct S_DDI p0, struct S_DDI p1) { return p0; }
+EXPORT struct S_DDF f11_S_SS_DDF(struct S_DDF p0, struct S_DDF p1) { return p0; }
+EXPORT struct S_DDD f11_S_SS_DDD(struct S_DDD p0, struct S_DDD p1) { return p0; }
+EXPORT struct S_DDP f11_S_SS_DDP(struct S_DDP p0, struct S_DDP p1) { return p0; }
+EXPORT struct S_DPI f11_S_SS_DPI(struct S_DPI p0, struct S_DPI p1) { return p0; }
+EXPORT struct S_DPF f11_S_SS_DPF(struct S_DPF p0, struct S_DPF p1) { return p0; }
+EXPORT struct S_DPD f11_S_SS_DPD(struct S_DPD p0, struct S_DPD p1) { return p0; }
+EXPORT struct S_DPP f11_S_SS_DPP(struct S_DPP p0, struct S_DPP p1) { return p0; }
+EXPORT struct S_PII f11_S_SS_PII(struct S_PII p0, struct S_PII p1) { return p0; }
+EXPORT struct S_PIF f11_S_SS_PIF(struct S_PIF p0, struct S_PIF p1) { return p0; }
+EXPORT struct S_PID f11_S_SS_PID(struct S_PID p0, struct S_PID p1) { return p0; }
+EXPORT struct S_PIP f11_S_SS_PIP(struct S_PIP p0, struct S_PIP p1) { return p0; }
+EXPORT struct S_PFI f11_S_SS_PFI(struct S_PFI p0, struct S_PFI p1) { return p0; }
+EXPORT struct S_PFF f11_S_SS_PFF(struct S_PFF p0, struct S_PFF p1) { return p0; }
+EXPORT struct S_PFD f11_S_SS_PFD(struct S_PFD p0, struct S_PFD p1) { return p0; }
+EXPORT struct S_PFP f11_S_SS_PFP(struct S_PFP p0, struct S_PFP p1) { return p0; }
+EXPORT struct S_PDI f11_S_SS_PDI(struct S_PDI p0, struct S_PDI p1) { return p0; }
+EXPORT struct S_PDF f11_S_SS_PDF(struct S_PDF p0, struct S_PDF p1) { return p0; }
+EXPORT struct S_PDD f11_S_SS_PDD(struct S_PDD p0, struct S_PDD p1) { return p0; }
+EXPORT struct S_PDP f11_S_SS_PDP(struct S_PDP p0, struct S_PDP p1) { return p0; }
+EXPORT struct S_PPI f11_S_SS_PPI(struct S_PPI p0, struct S_PPI p1) { return p0; }
+EXPORT struct S_PPF f11_S_SS_PPF(struct S_PPF p0, struct S_PPF p1) { return p0; }
+EXPORT struct S_PPD f11_S_SS_PPD(struct S_PPD p0, struct S_PPD p1) { return p0; }
+EXPORT struct S_PPP f11_S_SS_PPP(struct S_PPP p0, struct S_PPP p1) { return p0; }
+EXPORT int f11_I_III_(int p0, int p1, int p2) { return p0; }
+EXPORT int f11_I_IIF_(int p0, int p1, float p2) { return p0; }
+EXPORT int f11_I_IID_(int p0, int p1, double p2) { return p0; }
+EXPORT int f11_I_IIP_(int p0, int p1, void* p2) { return p0; }
+EXPORT int f11_I_IIS_I(int p0, int p1, struct S_I p2) { return p0; }
+EXPORT int f11_I_IIS_F(int p0, int p1, struct S_F p2) { return p0; }
+EXPORT int f11_I_IIS_D(int p0, int p1, struct S_D p2) { return p0; }
+EXPORT int f11_I_IIS_P(int p0, int p1, struct S_P p2) { return p0; }
+EXPORT int f11_I_IIS_II(int p0, int p1, struct S_II p2) { return p0; }
+EXPORT int f11_I_IIS_IF(int p0, int p1, struct S_IF p2) { return p0; }
+EXPORT int f11_I_IIS_ID(int p0, int p1, struct S_ID p2) { return p0; }
+EXPORT int f11_I_IIS_IP(int p0, int p1, struct S_IP p2) { return p0; }
+EXPORT int f11_I_IIS_FI(int p0, int p1, struct S_FI p2) { return p0; }
+EXPORT int f11_I_IIS_FF(int p0, int p1, struct S_FF p2) { return p0; }
+EXPORT int f11_I_IIS_FD(int p0, int p1, struct S_FD p2) { return p0; }
+EXPORT int f11_I_IIS_FP(int p0, int p1, struct S_FP p2) { return p0; }
+EXPORT int f11_I_IIS_DI(int p0, int p1, struct S_DI p2) { return p0; }
+EXPORT int f11_I_IIS_DF(int p0, int p1, struct S_DF p2) { return p0; }
+EXPORT int f11_I_IIS_DD(int p0, int p1, struct S_DD p2) { return p0; }
+EXPORT int f11_I_IIS_DP(int p0, int p1, struct S_DP p2) { return p0; }
+EXPORT int f11_I_IIS_PI(int p0, int p1, struct S_PI p2) { return p0; }
+EXPORT int f11_I_IIS_PF(int p0, int p1, struct S_PF p2) { return p0; }
+EXPORT int f11_I_IIS_PD(int p0, int p1, struct S_PD p2) { return p0; }
+EXPORT int f11_I_IIS_PP(int p0, int p1, struct S_PP p2) { return p0; }
+EXPORT int f11_I_IIS_III(int p0, int p1, struct S_III p2) { return p0; }
+EXPORT int f11_I_IIS_IIF(int p0, int p1, struct S_IIF p2) { return p0; }
+EXPORT int f11_I_IIS_IID(int p0, int p1, struct S_IID p2) { return p0; }
+EXPORT int f11_I_IIS_IIP(int p0, int p1, struct S_IIP p2) { return p0; }
+EXPORT int f11_I_IIS_IFI(int p0, int p1, struct S_IFI p2) { return p0; }
+EXPORT int f11_I_IIS_IFF(int p0, int p1, struct S_IFF p2) { return p0; }
+EXPORT int f11_I_IIS_IFD(int p0, int p1, struct S_IFD p2) { return p0; }
+EXPORT int f11_I_IIS_IFP(int p0, int p1, struct S_IFP p2) { return p0; }
+EXPORT int f11_I_IIS_IDI(int p0, int p1, struct S_IDI p2) { return p0; }
+EXPORT int f11_I_IIS_IDF(int p0, int p1, struct S_IDF p2) { return p0; }
+EXPORT int f11_I_IIS_IDD(int p0, int p1, struct S_IDD p2) { return p0; }
+EXPORT int f11_I_IIS_IDP(int p0, int p1, struct S_IDP p2) { return p0; }
+EXPORT int f11_I_IIS_IPI(int p0, int p1, struct S_IPI p2) { return p0; }
+EXPORT int f11_I_IIS_IPF(int p0, int p1, struct S_IPF p2) { return p0; }
+EXPORT int f11_I_IIS_IPD(int p0, int p1, struct S_IPD p2) { return p0; }
+EXPORT int f11_I_IIS_IPP(int p0, int p1, struct S_IPP p2) { return p0; }
+EXPORT int f11_I_IIS_FII(int p0, int p1, struct S_FII p2) { return p0; }
+EXPORT int f11_I_IIS_FIF(int p0, int p1, struct S_FIF p2) { return p0; }
+EXPORT int f11_I_IIS_FID(int p0, int p1, struct S_FID p2) { return p0; }
+EXPORT int f11_I_IIS_FIP(int p0, int p1, struct S_FIP p2) { return p0; }
+EXPORT int f11_I_IIS_FFI(int p0, int p1, struct S_FFI p2) { return p0; }
+EXPORT int f11_I_IIS_FFF(int p0, int p1, struct S_FFF p2) { return p0; }
+EXPORT int f11_I_IIS_FFD(int p0, int p1, struct S_FFD p2) { return p0; }
+EXPORT int f11_I_IIS_FFP(int p0, int p1, struct S_FFP p2) { return p0; }
+EXPORT int f11_I_IIS_FDI(int p0, int p1, struct S_FDI p2) { return p0; }
+EXPORT int f11_I_IIS_FDF(int p0, int p1, struct S_FDF p2) { return p0; }
+EXPORT int f11_I_IIS_FDD(int p0, int p1, struct S_FDD p2) { return p0; }
+EXPORT int f11_I_IIS_FDP(int p0, int p1, struct S_FDP p2) { return p0; }
+EXPORT int f11_I_IIS_FPI(int p0, int p1, struct S_FPI p2) { return p0; }
+EXPORT int f11_I_IIS_FPF(int p0, int p1, struct S_FPF p2) { return p0; }
+EXPORT int f11_I_IIS_FPD(int p0, int p1, struct S_FPD p2) { return p0; }
+EXPORT int f11_I_IIS_FPP(int p0, int p1, struct S_FPP p2) { return p0; }
+EXPORT int f11_I_IIS_DII(int p0, int p1, struct S_DII p2) { return p0; }
+EXPORT int f11_I_IIS_DIF(int p0, int p1, struct S_DIF p2) { return p0; }
+EXPORT int f11_I_IIS_DID(int p0, int p1, struct S_DID p2) { return p0; }
+EXPORT int f11_I_IIS_DIP(int p0, int p1, struct S_DIP p2) { return p0; }
+EXPORT int f11_I_IIS_DFI(int p0, int p1, struct S_DFI p2) { return p0; }
+EXPORT int f11_I_IIS_DFF(int p0, int p1, struct S_DFF p2) { return p0; }
+EXPORT int f11_I_IIS_DFD(int p0, int p1, struct S_DFD p2) { return p0; }
+EXPORT int f11_I_IIS_DFP(int p0, int p1, struct S_DFP p2) { return p0; }
+EXPORT int f11_I_IIS_DDI(int p0, int p1, struct S_DDI p2) { return p0; }
+EXPORT int f11_I_IIS_DDF(int p0, int p1, struct S_DDF p2) { return p0; }
+EXPORT int f11_I_IIS_DDD(int p0, int p1, struct S_DDD p2) { return p0; }
+EXPORT int f11_I_IIS_DDP(int p0, int p1, struct S_DDP p2) { return p0; }
+EXPORT int f11_I_IIS_DPI(int p0, int p1, struct S_DPI p2) { return p0; }
+EXPORT int f11_I_IIS_DPF(int p0, int p1, struct S_DPF p2) { return p0; }
+EXPORT int f11_I_IIS_DPD(int p0, int p1, struct S_DPD p2) { return p0; }
+EXPORT int f11_I_IIS_DPP(int p0, int p1, struct S_DPP p2) { return p0; }
+EXPORT int f11_I_IIS_PII(int p0, int p1, struct S_PII p2) { return p0; }
+EXPORT int f11_I_IIS_PIF(int p0, int p1, struct S_PIF p2) { return p0; }
+EXPORT int f11_I_IIS_PID(int p0, int p1, struct S_PID p2) { return p0; }
+EXPORT int f11_I_IIS_PIP(int p0, int p1, struct S_PIP p2) { return p0; }
+EXPORT int f11_I_IIS_PFI(int p0, int p1, struct S_PFI p2) { return p0; }
+EXPORT int f11_I_IIS_PFF(int p0, int p1, struct S_PFF p2) { return p0; }
+EXPORT int f11_I_IIS_PFD(int p0, int p1, struct S_PFD p2) { return p0; }
+EXPORT int f11_I_IIS_PFP(int p0, int p1, struct S_PFP p2) { return p0; }
+EXPORT int f11_I_IIS_PDI(int p0, int p1, struct S_PDI p2) { return p0; }
+EXPORT int f11_I_IIS_PDF(int p0, int p1, struct S_PDF p2) { return p0; }
+EXPORT int f11_I_IIS_PDD(int p0, int p1, struct S_PDD p2) { return p0; }
+EXPORT int f11_I_IIS_PDP(int p0, int p1, struct S_PDP p2) { return p0; }
+EXPORT int f11_I_IIS_PPI(int p0, int p1, struct S_PPI p2) { return p0; }
+EXPORT int f11_I_IIS_PPF(int p0, int p1, struct S_PPF p2) { return p0; }
+EXPORT int f11_I_IIS_PPD(int p0, int p1, struct S_PPD p2) { return p0; }
+EXPORT int f11_I_IIS_PPP(int p0, int p1, struct S_PPP p2) { return p0; }
+EXPORT int f11_I_IFI_(int p0, float p1, int p2) { return p0; }
+EXPORT int f11_I_IFF_(int p0, float p1, float p2) { return p0; }
+EXPORT int f11_I_IFD_(int p0, float p1, double p2) { return p0; }
+EXPORT int f11_I_IFP_(int p0, float p1, void* p2) { return p0; }
+EXPORT int f11_I_IFS_I(int p0, float p1, struct S_I p2) { return p0; }
+EXPORT int f11_I_IFS_F(int p0, float p1, struct S_F p2) { return p0; }
+EXPORT int f11_I_IFS_D(int p0, float p1, struct S_D p2) { return p0; }
+EXPORT int f11_I_IFS_P(int p0, float p1, struct S_P p2) { return p0; }
+EXPORT int f11_I_IFS_II(int p0, float p1, struct S_II p2) { return p0; }
+EXPORT int f11_I_IFS_IF(int p0, float p1, struct S_IF p2) { return p0; }
+EXPORT int f11_I_IFS_ID(int p0, float p1, struct S_ID p2) { return p0; }
+EXPORT int f11_I_IFS_IP(int p0, float p1, struct S_IP p2) { return p0; }
+EXPORT int f11_I_IFS_FI(int p0, float p1, struct S_FI p2) { return p0; }
+EXPORT int f11_I_IFS_FF(int p0, float p1, struct S_FF p2) { return p0; }
+EXPORT int f11_I_IFS_FD(int p0, float p1, struct S_FD p2) { return p0; }
+EXPORT int f11_I_IFS_FP(int p0, float p1, struct S_FP p2) { return p0; }
+EXPORT int f11_I_IFS_DI(int p0, float p1, struct S_DI p2) { return p0; }
+EXPORT int f11_I_IFS_DF(int p0, float p1, struct S_DF p2) { return p0; }
+EXPORT int f11_I_IFS_DD(int p0, float p1, struct S_DD p2) { return p0; }
+EXPORT int f11_I_IFS_DP(int p0, float p1, struct S_DP p2) { return p0; }
+EXPORT int f11_I_IFS_PI(int p0, float p1, struct S_PI p2) { return p0; }
+EXPORT int f11_I_IFS_PF(int p0, float p1, struct S_PF p2) { return p0; }
+EXPORT int f11_I_IFS_PD(int p0, float p1, struct S_PD p2) { return p0; }
+EXPORT int f11_I_IFS_PP(int p0, float p1, struct S_PP p2) { return p0; }
+EXPORT int f11_I_IFS_III(int p0, float p1, struct S_III p2) { return p0; }
+EXPORT int f11_I_IFS_IIF(int p0, float p1, struct S_IIF p2) { return p0; }
+EXPORT int f11_I_IFS_IID(int p0, float p1, struct S_IID p2) { return p0; }
+EXPORT int f11_I_IFS_IIP(int p0, float p1, struct S_IIP p2) { return p0; }
+EXPORT int f11_I_IFS_IFI(int p0, float p1, struct S_IFI p2) { return p0; }
+EXPORT int f11_I_IFS_IFF(int p0, float p1, struct S_IFF p2) { return p0; }
+EXPORT int f11_I_IFS_IFD(int p0, float p1, struct S_IFD p2) { return p0; }
+EXPORT int f11_I_IFS_IFP(int p0, float p1, struct S_IFP p2) { return p0; }
+EXPORT int f11_I_IFS_IDI(int p0, float p1, struct S_IDI p2) { return p0; }
+EXPORT int f11_I_IFS_IDF(int p0, float p1, struct S_IDF p2) { return p0; }
+EXPORT int f11_I_IFS_IDD(int p0, float p1, struct S_IDD p2) { return p0; }
+EXPORT int f11_I_IFS_IDP(int p0, float p1, struct S_IDP p2) { return p0; }
+EXPORT int f11_I_IFS_IPI(int p0, float p1, struct S_IPI p2) { return p0; }
+EXPORT int f11_I_IFS_IPF(int p0, float p1, struct S_IPF p2) { return p0; }
+EXPORT int f11_I_IFS_IPD(int p0, float p1, struct S_IPD p2) { return p0; }
+EXPORT int f11_I_IFS_IPP(int p0, float p1, struct S_IPP p2) { return p0; }
+EXPORT int f11_I_IFS_FII(int p0, float p1, struct S_FII p2) { return p0; }
+EXPORT int f11_I_IFS_FIF(int p0, float p1, struct S_FIF p2) { return p0; }
+EXPORT int f11_I_IFS_FID(int p0, float p1, struct S_FID p2) { return p0; }
+EXPORT int f11_I_IFS_FIP(int p0, float p1, struct S_FIP p2) { return p0; }
+EXPORT int f11_I_IFS_FFI(int p0, float p1, struct S_FFI p2) { return p0; }
+EXPORT int f11_I_IFS_FFF(int p0, float p1, struct S_FFF p2) { return p0; }
+EXPORT int f11_I_IFS_FFD(int p0, float p1, struct S_FFD p2) { return p0; }
+EXPORT int f11_I_IFS_FFP(int p0, float p1, struct S_FFP p2) { return p0; }
+EXPORT int f11_I_IFS_FDI(int p0, float p1, struct S_FDI p2) { return p0; }
+EXPORT int f11_I_IFS_FDF(int p0, float p1, struct S_FDF p2) { return p0; }
+EXPORT int f11_I_IFS_FDD(int p0, float p1, struct S_FDD p2) { return p0; }
+EXPORT int f11_I_IFS_FDP(int p0, float p1, struct S_FDP p2) { return p0; }
+EXPORT int f11_I_IFS_FPI(int p0, float p1, struct S_FPI p2) { return p0; }
+EXPORT int f11_I_IFS_FPF(int p0, float p1, struct S_FPF p2) { return p0; }
+EXPORT int f11_I_IFS_FPD(int p0, float p1, struct S_FPD p2) { return p0; }
+EXPORT int f11_I_IFS_FPP(int p0, float p1, struct S_FPP p2) { return p0; }
+EXPORT int f11_I_IFS_DII(int p0, float p1, struct S_DII p2) { return p0; }
+EXPORT int f11_I_IFS_DIF(int p0, float p1, struct S_DIF p2) { return p0; }
+EXPORT int f11_I_IFS_DID(int p0, float p1, struct S_DID p2) { return p0; }
+EXPORT int f11_I_IFS_DIP(int p0, float p1, struct S_DIP p2) { return p0; }
+EXPORT int f11_I_IFS_DFI(int p0, float p1, struct S_DFI p2) { return p0; }
+EXPORT int f11_I_IFS_DFF(int p0, float p1, struct S_DFF p2) { return p0; }
+EXPORT int f11_I_IFS_DFD(int p0, float p1, struct S_DFD p2) { return p0; }
+EXPORT int f11_I_IFS_DFP(int p0, float p1, struct S_DFP p2) { return p0; }
+EXPORT int f11_I_IFS_DDI(int p0, float p1, struct S_DDI p2) { return p0; }
+EXPORT int f11_I_IFS_DDF(int p0, float p1, struct S_DDF p2) { return p0; }
+EXPORT int f11_I_IFS_DDD(int p0, float p1, struct S_DDD p2) { return p0; }
+EXPORT int f11_I_IFS_DDP(int p0, float p1, struct S_DDP p2) { return p0; }
+EXPORT int f11_I_IFS_DPI(int p0, float p1, struct S_DPI p2) { return p0; }
+EXPORT int f11_I_IFS_DPF(int p0, float p1, struct S_DPF p2) { return p0; }
+EXPORT int f11_I_IFS_DPD(int p0, float p1, struct S_DPD p2) { return p0; }
+EXPORT int f11_I_IFS_DPP(int p0, float p1, struct S_DPP p2) { return p0; }
+EXPORT int f11_I_IFS_PII(int p0, float p1, struct S_PII p2) { return p0; }
+EXPORT int f11_I_IFS_PIF(int p0, float p1, struct S_PIF p2) { return p0; }
+EXPORT int f11_I_IFS_PID(int p0, float p1, struct S_PID p2) { return p0; }
+EXPORT int f11_I_IFS_PIP(int p0, float p1, struct S_PIP p2) { return p0; }
+EXPORT int f11_I_IFS_PFI(int p0, float p1, struct S_PFI p2) { return p0; }
+EXPORT int f11_I_IFS_PFF(int p0, float p1, struct S_PFF p2) { return p0; }
+EXPORT int f11_I_IFS_PFD(int p0, float p1, struct S_PFD p2) { return p0; }
+EXPORT int f11_I_IFS_PFP(int p0, float p1, struct S_PFP p2) { return p0; }
+EXPORT int f11_I_IFS_PDI(int p0, float p1, struct S_PDI p2) { return p0; }
+EXPORT int f11_I_IFS_PDF(int p0, float p1, struct S_PDF p2) { return p0; }
+EXPORT int f11_I_IFS_PDD(int p0, float p1, struct S_PDD p2) { return p0; }
+EXPORT int f11_I_IFS_PDP(int p0, float p1, struct S_PDP p2) { return p0; }
+EXPORT int f11_I_IFS_PPI(int p0, float p1, struct S_PPI p2) { return p0; }
+EXPORT int f11_I_IFS_PPF(int p0, float p1, struct S_PPF p2) { return p0; }
+EXPORT int f11_I_IFS_PPD(int p0, float p1, struct S_PPD p2) { return p0; }
+EXPORT int f11_I_IFS_PPP(int p0, float p1, struct S_PPP p2) { return p0; }
+EXPORT int f11_I_IDI_(int p0, double p1, int p2) { return p0; }
+EXPORT int f11_I_IDF_(int p0, double p1, float p2) { return p0; }
+EXPORT int f11_I_IDD_(int p0, double p1, double p2) { return p0; }
+EXPORT int f11_I_IDP_(int p0, double p1, void* p2) { return p0; }
+EXPORT int f11_I_IDS_I(int p0, double p1, struct S_I p2) { return p0; }
+EXPORT int f11_I_IDS_F(int p0, double p1, struct S_F p2) { return p0; }
+EXPORT int f11_I_IDS_D(int p0, double p1, struct S_D p2) { return p0; }
+EXPORT int f11_I_IDS_P(int p0, double p1, struct S_P p2) { return p0; }
+EXPORT int f11_I_IDS_II(int p0, double p1, struct S_II p2) { return p0; }
+EXPORT int f11_I_IDS_IF(int p0, double p1, struct S_IF p2) { return p0; }
+EXPORT int f11_I_IDS_ID(int p0, double p1, struct S_ID p2) { return p0; }
+EXPORT int f11_I_IDS_IP(int p0, double p1, struct S_IP p2) { return p0; }
+EXPORT int f11_I_IDS_FI(int p0, double p1, struct S_FI p2) { return p0; }
+EXPORT int f11_I_IDS_FF(int p0, double p1, struct S_FF p2) { return p0; }
+EXPORT int f11_I_IDS_FD(int p0, double p1, struct S_FD p2) { return p0; }
+EXPORT int f11_I_IDS_FP(int p0, double p1, struct S_FP p2) { return p0; }
+EXPORT int f11_I_IDS_DI(int p0, double p1, struct S_DI p2) { return p0; }
+EXPORT int f11_I_IDS_DF(int p0, double p1, struct S_DF p2) { return p0; }
+EXPORT int f11_I_IDS_DD(int p0, double p1, struct S_DD p2) { return p0; }
+EXPORT int f11_I_IDS_DP(int p0, double p1, struct S_DP p2) { return p0; }
+EXPORT int f11_I_IDS_PI(int p0, double p1, struct S_PI p2) { return p0; }
+EXPORT int f11_I_IDS_PF(int p0, double p1, struct S_PF p2) { return p0; }
+EXPORT int f11_I_IDS_PD(int p0, double p1, struct S_PD p2) { return p0; }
+EXPORT int f11_I_IDS_PP(int p0, double p1, struct S_PP p2) { return p0; }
+EXPORT int f11_I_IDS_III(int p0, double p1, struct S_III p2) { return p0; }
+EXPORT int f11_I_IDS_IIF(int p0, double p1, struct S_IIF p2) { return p0; }
+EXPORT int f11_I_IDS_IID(int p0, double p1, struct S_IID p2) { return p0; }
+EXPORT int f11_I_IDS_IIP(int p0, double p1, struct S_IIP p2) { return p0; }
+EXPORT int f11_I_IDS_IFI(int p0, double p1, struct S_IFI p2) { return p0; }
+EXPORT int f11_I_IDS_IFF(int p0, double p1, struct S_IFF p2) { return p0; }
+EXPORT int f11_I_IDS_IFD(int p0, double p1, struct S_IFD p2) { return p0; }
+EXPORT int f11_I_IDS_IFP(int p0, double p1, struct S_IFP p2) { return p0; }
+EXPORT int f11_I_IDS_IDI(int p0, double p1, struct S_IDI p2) { return p0; }
+EXPORT int f11_I_IDS_IDF(int p0, double p1, struct S_IDF p2) { return p0; }
+EXPORT int f11_I_IDS_IDD(int p0, double p1, struct S_IDD p2) { return p0; }
+EXPORT int f11_I_IDS_IDP(int p0, double p1, struct S_IDP p2) { return p0; }
+EXPORT int f11_I_IDS_IPI(int p0, double p1, struct S_IPI p2) { return p0; }
+EXPORT int f11_I_IDS_IPF(int p0, double p1, struct S_IPF p2) { return p0; }
+EXPORT int f11_I_IDS_IPD(int p0, double p1, struct S_IPD p2) { return p0; }
+EXPORT int f11_I_IDS_IPP(int p0, double p1, struct S_IPP p2) { return p0; }
+EXPORT int f11_I_IDS_FII(int p0, double p1, struct S_FII p2) { return p0; }
+EXPORT int f11_I_IDS_FIF(int p0, double p1, struct S_FIF p2) { return p0; }
+EXPORT int f11_I_IDS_FID(int p0, double p1, struct S_FID p2) { return p0; }
+EXPORT int f11_I_IDS_FIP(int p0, double p1, struct S_FIP p2) { return p0; }
+EXPORT int f11_I_IDS_FFI(int p0, double p1, struct S_FFI p2) { return p0; }
+EXPORT int f11_I_IDS_FFF(int p0, double p1, struct S_FFF p2) { return p0; }
+EXPORT int f11_I_IDS_FFD(int p0, double p1, struct S_FFD p2) { return p0; }
+EXPORT int f11_I_IDS_FFP(int p0, double p1, struct S_FFP p2) { return p0; }
+EXPORT int f11_I_IDS_FDI(int p0, double p1, struct S_FDI p2) { return p0; }
+EXPORT int f11_I_IDS_FDF(int p0, double p1, struct S_FDF p2) { return p0; }
+EXPORT int f11_I_IDS_FDD(int p0, double p1, struct S_FDD p2) { return p0; }
+EXPORT int f11_I_IDS_FDP(int p0, double p1, struct S_FDP p2) { return p0; }
+EXPORT int f11_I_IDS_FPI(int p0, double p1, struct S_FPI p2) { return p0; }
+EXPORT int f11_I_IDS_FPF(int p0, double p1, struct S_FPF p2) { return p0; }
+EXPORT int f11_I_IDS_FPD(int p0, double p1, struct S_FPD p2) { return p0; }
+EXPORT int f11_I_IDS_FPP(int p0, double p1, struct S_FPP p2) { return p0; }
+EXPORT int f11_I_IDS_DII(int p0, double p1, struct S_DII p2) { return p0; }
+EXPORT int f11_I_IDS_DIF(int p0, double p1, struct S_DIF p2) { return p0; }
+EXPORT int f11_I_IDS_DID(int p0, double p1, struct S_DID p2) { return p0; }
+EXPORT int f11_I_IDS_DIP(int p0, double p1, struct S_DIP p2) { return p0; }
+EXPORT int f11_I_IDS_DFI(int p0, double p1, struct S_DFI p2) { return p0; }
+EXPORT int f11_I_IDS_DFF(int p0, double p1, struct S_DFF p2) { return p0; }
+EXPORT int f11_I_IDS_DFD(int p0, double p1, struct S_DFD p2) { return p0; }
+EXPORT int f11_I_IDS_DFP(int p0, double p1, struct S_DFP p2) { return p0; }
+EXPORT int f11_I_IDS_DDI(int p0, double p1, struct S_DDI p2) { return p0; }
+EXPORT int f11_I_IDS_DDF(int p0, double p1, struct S_DDF p2) { return p0; }
+EXPORT int f11_I_IDS_DDD(int p0, double p1, struct S_DDD p2) { return p0; }
+EXPORT int f11_I_IDS_DDP(int p0, double p1, struct S_DDP p2) { return p0; }
+EXPORT int f11_I_IDS_DPI(int p0, double p1, struct S_DPI p2) { return p0; }
+EXPORT int f11_I_IDS_DPF(int p0, double p1, struct S_DPF p2) { return p0; }
+EXPORT int f11_I_IDS_DPD(int p0, double p1, struct S_DPD p2) { return p0; }
+EXPORT int f11_I_IDS_DPP(int p0, double p1, struct S_DPP p2) { return p0; }
+EXPORT int f11_I_IDS_PII(int p0, double p1, struct S_PII p2) { return p0; }
+EXPORT int f11_I_IDS_PIF(int p0, double p1, struct S_PIF p2) { return p0; }
+EXPORT int f11_I_IDS_PID(int p0, double p1, struct S_PID p2) { return p0; }
+EXPORT int f11_I_IDS_PIP(int p0, double p1, struct S_PIP p2) { return p0; }
+EXPORT int f11_I_IDS_PFI(int p0, double p1, struct S_PFI p2) { return p0; }
+EXPORT int f11_I_IDS_PFF(int p0, double p1, struct S_PFF p2) { return p0; }
+EXPORT int f11_I_IDS_PFD(int p0, double p1, struct S_PFD p2) { return p0; }
+EXPORT int f11_I_IDS_PFP(int p0, double p1, struct S_PFP p2) { return p0; }
+EXPORT int f11_I_IDS_PDI(int p0, double p1, struct S_PDI p2) { return p0; }
+EXPORT int f11_I_IDS_PDF(int p0, double p1, struct S_PDF p2) { return p0; }
+EXPORT int f11_I_IDS_PDD(int p0, double p1, struct S_PDD p2) { return p0; }
+EXPORT int f11_I_IDS_PDP(int p0, double p1, struct S_PDP p2) { return p0; }
+EXPORT int f11_I_IDS_PPI(int p0, double p1, struct S_PPI p2) { return p0; }
+EXPORT int f11_I_IDS_PPF(int p0, double p1, struct S_PPF p2) { return p0; }
+EXPORT int f11_I_IDS_PPD(int p0, double p1, struct S_PPD p2) { return p0; }
+EXPORT int f11_I_IDS_PPP(int p0, double p1, struct S_PPP p2) { return p0; }
+EXPORT int f11_I_IPI_(int p0, void* p1, int p2) { return p0; }
+EXPORT int f11_I_IPF_(int p0, void* p1, float p2) { return p0; }
+EXPORT int f11_I_IPD_(int p0, void* p1, double p2) { return p0; }
+EXPORT int f11_I_IPP_(int p0, void* p1, void* p2) { return p0; }
+EXPORT int f11_I_IPS_I(int p0, void* p1, struct S_I p2) { return p0; }
+EXPORT int f11_I_IPS_F(int p0, void* p1, struct S_F p2) { return p0; }
+EXPORT int f11_I_IPS_D(int p0, void* p1, struct S_D p2) { return p0; }
+EXPORT int f11_I_IPS_P(int p0, void* p1, struct S_P p2) { return p0; }
+EXPORT int f11_I_IPS_II(int p0, void* p1, struct S_II p2) { return p0; }
+EXPORT int f11_I_IPS_IF(int p0, void* p1, struct S_IF p2) { return p0; }
+EXPORT int f11_I_IPS_ID(int p0, void* p1, struct S_ID p2) { return p0; }
+EXPORT int f11_I_IPS_IP(int p0, void* p1, struct S_IP p2) { return p0; }
+EXPORT int f11_I_IPS_FI(int p0, void* p1, struct S_FI p2) { return p0; }
+EXPORT int f11_I_IPS_FF(int p0, void* p1, struct S_FF p2) { return p0; }
+EXPORT int f11_I_IPS_FD(int p0, void* p1, struct S_FD p2) { return p0; }
+EXPORT int f11_I_IPS_FP(int p0, void* p1, struct S_FP p2) { return p0; }
+EXPORT int f11_I_IPS_DI(int p0, void* p1, struct S_DI p2) { return p0; }
+EXPORT int f11_I_IPS_DF(int p0, void* p1, struct S_DF p2) { return p0; }
+EXPORT int f11_I_IPS_DD(int p0, void* p1, struct S_DD p2) { return p0; }
+EXPORT int f11_I_IPS_DP(int p0, void* p1, struct S_DP p2) { return p0; }
+EXPORT int f11_I_IPS_PI(int p0, void* p1, struct S_PI p2) { return p0; }
+EXPORT int f11_I_IPS_PF(int p0, void* p1, struct S_PF p2) { return p0; }
+EXPORT int f11_I_IPS_PD(int p0, void* p1, struct S_PD p2) { return p0; }
+EXPORT int f11_I_IPS_PP(int p0, void* p1, struct S_PP p2) { return p0; }
+EXPORT int f11_I_IPS_III(int p0, void* p1, struct S_III p2) { return p0; }
+EXPORT int f11_I_IPS_IIF(int p0, void* p1, struct S_IIF p2) { return p0; }
+EXPORT int f11_I_IPS_IID(int p0, void* p1, struct S_IID p2) { return p0; }
+EXPORT int f12_I_IPS_IIP(int p0, void* p1, struct S_IIP p2) { return p0; }
+EXPORT int f12_I_IPS_IFI(int p0, void* p1, struct S_IFI p2) { return p0; }
+EXPORT int f12_I_IPS_IFF(int p0, void* p1, struct S_IFF p2) { return p0; }
+EXPORT int f12_I_IPS_IFD(int p0, void* p1, struct S_IFD p2) { return p0; }
+EXPORT int f12_I_IPS_IFP(int p0, void* p1, struct S_IFP p2) { return p0; }
+EXPORT int f12_I_IPS_IDI(int p0, void* p1, struct S_IDI p2) { return p0; }
+EXPORT int f12_I_IPS_IDF(int p0, void* p1, struct S_IDF p2) { return p0; }
+EXPORT int f12_I_IPS_IDD(int p0, void* p1, struct S_IDD p2) { return p0; }
+EXPORT int f12_I_IPS_IDP(int p0, void* p1, struct S_IDP p2) { return p0; }
+EXPORT int f12_I_IPS_IPI(int p0, void* p1, struct S_IPI p2) { return p0; }
+EXPORT int f12_I_IPS_IPF(int p0, void* p1, struct S_IPF p2) { return p0; }
+EXPORT int f12_I_IPS_IPD(int p0, void* p1, struct S_IPD p2) { return p0; }
+EXPORT int f12_I_IPS_IPP(int p0, void* p1, struct S_IPP p2) { return p0; }
+EXPORT int f12_I_IPS_FII(int p0, void* p1, struct S_FII p2) { return p0; }
+EXPORT int f12_I_IPS_FIF(int p0, void* p1, struct S_FIF p2) { return p0; }
+EXPORT int f12_I_IPS_FID(int p0, void* p1, struct S_FID p2) { return p0; }
+EXPORT int f12_I_IPS_FIP(int p0, void* p1, struct S_FIP p2) { return p0; }
+EXPORT int f12_I_IPS_FFI(int p0, void* p1, struct S_FFI p2) { return p0; }
+EXPORT int f12_I_IPS_FFF(int p0, void* p1, struct S_FFF p2) { return p0; }
+EXPORT int f12_I_IPS_FFD(int p0, void* p1, struct S_FFD p2) { return p0; }
+EXPORT int f12_I_IPS_FFP(int p0, void* p1, struct S_FFP p2) { return p0; }
+EXPORT int f12_I_IPS_FDI(int p0, void* p1, struct S_FDI p2) { return p0; }
+EXPORT int f12_I_IPS_FDF(int p0, void* p1, struct S_FDF p2) { return p0; }
+EXPORT int f12_I_IPS_FDD(int p0, void* p1, struct S_FDD p2) { return p0; }
+EXPORT int f12_I_IPS_FDP(int p0, void* p1, struct S_FDP p2) { return p0; }
+EXPORT int f12_I_IPS_FPI(int p0, void* p1, struct S_FPI p2) { return p0; }
+EXPORT int f12_I_IPS_FPF(int p0, void* p1, struct S_FPF p2) { return p0; }
+EXPORT int f12_I_IPS_FPD(int p0, void* p1, struct S_FPD p2) { return p0; }
+EXPORT int f12_I_IPS_FPP(int p0, void* p1, struct S_FPP p2) { return p0; }
+EXPORT int f12_I_IPS_DII(int p0, void* p1, struct S_DII p2) { return p0; }
+EXPORT int f12_I_IPS_DIF(int p0, void* p1, struct S_DIF p2) { return p0; }
+EXPORT int f12_I_IPS_DID(int p0, void* p1, struct S_DID p2) { return p0; }
+EXPORT int f12_I_IPS_DIP(int p0, void* p1, struct S_DIP p2) { return p0; }
+EXPORT int f12_I_IPS_DFI(int p0, void* p1, struct S_DFI p2) { return p0; }
+EXPORT int f12_I_IPS_DFF(int p0, void* p1, struct S_DFF p2) { return p0; }
+EXPORT int f12_I_IPS_DFD(int p0, void* p1, struct S_DFD p2) { return p0; }
+EXPORT int f12_I_IPS_DFP(int p0, void* p1, struct S_DFP p2) { return p0; }
+EXPORT int f12_I_IPS_DDI(int p0, void* p1, struct S_DDI p2) { return p0; }
+EXPORT int f12_I_IPS_DDF(int p0, void* p1, struct S_DDF p2) { return p0; }
+EXPORT int f12_I_IPS_DDD(int p0, void* p1, struct S_DDD p2) { return p0; }
+EXPORT int f12_I_IPS_DDP(int p0, void* p1, struct S_DDP p2) { return p0; }
+EXPORT int f12_I_IPS_DPI(int p0, void* p1, struct S_DPI p2) { return p0; }
+EXPORT int f12_I_IPS_DPF(int p0, void* p1, struct S_DPF p2) { return p0; }
+EXPORT int f12_I_IPS_DPD(int p0, void* p1, struct S_DPD p2) { return p0; }
+EXPORT int f12_I_IPS_DPP(int p0, void* p1, struct S_DPP p2) { return p0; }
+EXPORT int f12_I_IPS_PII(int p0, void* p1, struct S_PII p2) { return p0; }
+EXPORT int f12_I_IPS_PIF(int p0, void* p1, struct S_PIF p2) { return p0; }
+EXPORT int f12_I_IPS_PID(int p0, void* p1, struct S_PID p2) { return p0; }
+EXPORT int f12_I_IPS_PIP(int p0, void* p1, struct S_PIP p2) { return p0; }
+EXPORT int f12_I_IPS_PFI(int p0, void* p1, struct S_PFI p2) { return p0; }
+EXPORT int f12_I_IPS_PFF(int p0, void* p1, struct S_PFF p2) { return p0; }
+EXPORT int f12_I_IPS_PFD(int p0, void* p1, struct S_PFD p2) { return p0; }
+EXPORT int f12_I_IPS_PFP(int p0, void* p1, struct S_PFP p2) { return p0; }
+EXPORT int f12_I_IPS_PDI(int p0, void* p1, struct S_PDI p2) { return p0; }
+EXPORT int f12_I_IPS_PDF(int p0, void* p1, struct S_PDF p2) { return p0; }
+EXPORT int f12_I_IPS_PDD(int p0, void* p1, struct S_PDD p2) { return p0; }
+EXPORT int f12_I_IPS_PDP(int p0, void* p1, struct S_PDP p2) { return p0; }
+EXPORT int f12_I_IPS_PPI(int p0, void* p1, struct S_PPI p2) { return p0; }
+EXPORT int f12_I_IPS_PPF(int p0, void* p1, struct S_PPF p2) { return p0; }
+EXPORT int f12_I_IPS_PPD(int p0, void* p1, struct S_PPD p2) { return p0; }
+EXPORT int f12_I_IPS_PPP(int p0, void* p1, struct S_PPP p2) { return p0; }
+EXPORT int f12_I_ISI_I(int p0, struct S_I p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_F(int p0, struct S_F p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_D(int p0, struct S_D p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_P(int p0, struct S_P p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_II(int p0, struct S_II p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_IF(int p0, struct S_IF p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_ID(int p0, struct S_ID p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_IP(int p0, struct S_IP p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_FI(int p0, struct S_FI p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_FF(int p0, struct S_FF p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_FD(int p0, struct S_FD p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_FP(int p0, struct S_FP p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_DI(int p0, struct S_DI p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_DF(int p0, struct S_DF p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_DD(int p0, struct S_DD p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_DP(int p0, struct S_DP p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_PI(int p0, struct S_PI p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_PF(int p0, struct S_PF p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_PD(int p0, struct S_PD p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_PP(int p0, struct S_PP p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_III(int p0, struct S_III p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_IIF(int p0, struct S_IIF p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_IID(int p0, struct S_IID p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_IIP(int p0, struct S_IIP p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_IFI(int p0, struct S_IFI p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_IFF(int p0, struct S_IFF p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_IFD(int p0, struct S_IFD p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_IFP(int p0, struct S_IFP p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_IDI(int p0, struct S_IDI p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_IDF(int p0, struct S_IDF p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_IDD(int p0, struct S_IDD p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_IDP(int p0, struct S_IDP p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_IPI(int p0, struct S_IPI p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_IPF(int p0, struct S_IPF p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_IPD(int p0, struct S_IPD p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_IPP(int p0, struct S_IPP p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_FII(int p0, struct S_FII p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_FIF(int p0, struct S_FIF p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_FID(int p0, struct S_FID p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_FIP(int p0, struct S_FIP p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_FFI(int p0, struct S_FFI p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_FFF(int p0, struct S_FFF p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_FFD(int p0, struct S_FFD p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_FFP(int p0, struct S_FFP p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_FDI(int p0, struct S_FDI p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_FDF(int p0, struct S_FDF p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_FDD(int p0, struct S_FDD p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_FDP(int p0, struct S_FDP p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_FPI(int p0, struct S_FPI p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_FPF(int p0, struct S_FPF p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_FPD(int p0, struct S_FPD p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_FPP(int p0, struct S_FPP p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_DII(int p0, struct S_DII p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_DIF(int p0, struct S_DIF p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_DID(int p0, struct S_DID p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_DIP(int p0, struct S_DIP p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_DFI(int p0, struct S_DFI p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_DFF(int p0, struct S_DFF p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_DFD(int p0, struct S_DFD p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_DFP(int p0, struct S_DFP p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_DDI(int p0, struct S_DDI p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_DDF(int p0, struct S_DDF p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_DDD(int p0, struct S_DDD p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_DDP(int p0, struct S_DDP p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_DPI(int p0, struct S_DPI p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_DPF(int p0, struct S_DPF p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_DPD(int p0, struct S_DPD p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_DPP(int p0, struct S_DPP p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_PII(int p0, struct S_PII p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_PIF(int p0, struct S_PIF p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_PID(int p0, struct S_PID p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_PIP(int p0, struct S_PIP p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_PFI(int p0, struct S_PFI p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_PFF(int p0, struct S_PFF p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_PFD(int p0, struct S_PFD p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_PFP(int p0, struct S_PFP p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_PDI(int p0, struct S_PDI p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_PDF(int p0, struct S_PDF p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_PDD(int p0, struct S_PDD p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_PDP(int p0, struct S_PDP p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_PPI(int p0, struct S_PPI p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_PPF(int p0, struct S_PPF p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_PPD(int p0, struct S_PPD p1, int p2) { return p0; }
+EXPORT int f12_I_ISI_PPP(int p0, struct S_PPP p1, int p2) { return p0; }
+EXPORT int f12_I_ISF_I(int p0, struct S_I p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_F(int p0, struct S_F p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_D(int p0, struct S_D p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_P(int p0, struct S_P p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_II(int p0, struct S_II p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_IF(int p0, struct S_IF p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_ID(int p0, struct S_ID p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_IP(int p0, struct S_IP p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_FI(int p0, struct S_FI p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_FF(int p0, struct S_FF p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_FD(int p0, struct S_FD p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_FP(int p0, struct S_FP p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_DI(int p0, struct S_DI p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_DF(int p0, struct S_DF p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_DD(int p0, struct S_DD p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_DP(int p0, struct S_DP p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_PI(int p0, struct S_PI p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_PF(int p0, struct S_PF p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_PD(int p0, struct S_PD p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_PP(int p0, struct S_PP p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_III(int p0, struct S_III p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_IIF(int p0, struct S_IIF p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_IID(int p0, struct S_IID p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_IIP(int p0, struct S_IIP p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_IFI(int p0, struct S_IFI p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_IFF(int p0, struct S_IFF p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_IFD(int p0, struct S_IFD p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_IFP(int p0, struct S_IFP p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_IDI(int p0, struct S_IDI p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_IDF(int p0, struct S_IDF p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_IDD(int p0, struct S_IDD p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_IDP(int p0, struct S_IDP p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_IPI(int p0, struct S_IPI p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_IPF(int p0, struct S_IPF p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_IPD(int p0, struct S_IPD p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_IPP(int p0, struct S_IPP p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_FII(int p0, struct S_FII p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_FIF(int p0, struct S_FIF p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_FID(int p0, struct S_FID p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_FIP(int p0, struct S_FIP p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_FFI(int p0, struct S_FFI p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_FFF(int p0, struct S_FFF p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_FFD(int p0, struct S_FFD p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_FFP(int p0, struct S_FFP p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_FDI(int p0, struct S_FDI p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_FDF(int p0, struct S_FDF p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_FDD(int p0, struct S_FDD p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_FDP(int p0, struct S_FDP p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_FPI(int p0, struct S_FPI p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_FPF(int p0, struct S_FPF p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_FPD(int p0, struct S_FPD p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_FPP(int p0, struct S_FPP p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_DII(int p0, struct S_DII p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_DIF(int p0, struct S_DIF p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_DID(int p0, struct S_DID p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_DIP(int p0, struct S_DIP p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_DFI(int p0, struct S_DFI p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_DFF(int p0, struct S_DFF p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_DFD(int p0, struct S_DFD p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_DFP(int p0, struct S_DFP p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_DDI(int p0, struct S_DDI p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_DDF(int p0, struct S_DDF p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_DDD(int p0, struct S_DDD p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_DDP(int p0, struct S_DDP p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_DPI(int p0, struct S_DPI p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_DPF(int p0, struct S_DPF p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_DPD(int p0, struct S_DPD p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_DPP(int p0, struct S_DPP p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_PII(int p0, struct S_PII p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_PIF(int p0, struct S_PIF p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_PID(int p0, struct S_PID p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_PIP(int p0, struct S_PIP p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_PFI(int p0, struct S_PFI p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_PFF(int p0, struct S_PFF p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_PFD(int p0, struct S_PFD p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_PFP(int p0, struct S_PFP p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_PDI(int p0, struct S_PDI p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_PDF(int p0, struct S_PDF p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_PDD(int p0, struct S_PDD p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_PDP(int p0, struct S_PDP p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_PPI(int p0, struct S_PPI p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_PPF(int p0, struct S_PPF p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_PPD(int p0, struct S_PPD p1, float p2) { return p0; }
+EXPORT int f12_I_ISF_PPP(int p0, struct S_PPP p1, float p2) { return p0; }
+EXPORT int f12_I_ISD_I(int p0, struct S_I p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_F(int p0, struct S_F p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_D(int p0, struct S_D p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_P(int p0, struct S_P p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_II(int p0, struct S_II p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_IF(int p0, struct S_IF p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_ID(int p0, struct S_ID p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_IP(int p0, struct S_IP p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_FI(int p0, struct S_FI p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_FF(int p0, struct S_FF p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_FD(int p0, struct S_FD p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_FP(int p0, struct S_FP p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_DI(int p0, struct S_DI p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_DF(int p0, struct S_DF p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_DD(int p0, struct S_DD p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_DP(int p0, struct S_DP p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_PI(int p0, struct S_PI p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_PF(int p0, struct S_PF p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_PD(int p0, struct S_PD p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_PP(int p0, struct S_PP p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_III(int p0, struct S_III p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_IIF(int p0, struct S_IIF p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_IID(int p0, struct S_IID p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_IIP(int p0, struct S_IIP p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_IFI(int p0, struct S_IFI p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_IFF(int p0, struct S_IFF p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_IFD(int p0, struct S_IFD p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_IFP(int p0, struct S_IFP p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_IDI(int p0, struct S_IDI p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_IDF(int p0, struct S_IDF p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_IDD(int p0, struct S_IDD p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_IDP(int p0, struct S_IDP p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_IPI(int p0, struct S_IPI p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_IPF(int p0, struct S_IPF p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_IPD(int p0, struct S_IPD p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_IPP(int p0, struct S_IPP p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_FII(int p0, struct S_FII p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_FIF(int p0, struct S_FIF p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_FID(int p0, struct S_FID p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_FIP(int p0, struct S_FIP p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_FFI(int p0, struct S_FFI p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_FFF(int p0, struct S_FFF p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_FFD(int p0, struct S_FFD p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_FFP(int p0, struct S_FFP p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_FDI(int p0, struct S_FDI p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_FDF(int p0, struct S_FDF p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_FDD(int p0, struct S_FDD p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_FDP(int p0, struct S_FDP p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_FPI(int p0, struct S_FPI p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_FPF(int p0, struct S_FPF p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_FPD(int p0, struct S_FPD p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_FPP(int p0, struct S_FPP p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_DII(int p0, struct S_DII p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_DIF(int p0, struct S_DIF p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_DID(int p0, struct S_DID p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_DIP(int p0, struct S_DIP p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_DFI(int p0, struct S_DFI p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_DFF(int p0, struct S_DFF p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_DFD(int p0, struct S_DFD p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_DFP(int p0, struct S_DFP p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_DDI(int p0, struct S_DDI p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_DDF(int p0, struct S_DDF p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_DDD(int p0, struct S_DDD p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_DDP(int p0, struct S_DDP p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_DPI(int p0, struct S_DPI p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_DPF(int p0, struct S_DPF p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_DPD(int p0, struct S_DPD p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_DPP(int p0, struct S_DPP p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_PII(int p0, struct S_PII p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_PIF(int p0, struct S_PIF p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_PID(int p0, struct S_PID p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_PIP(int p0, struct S_PIP p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_PFI(int p0, struct S_PFI p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_PFF(int p0, struct S_PFF p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_PFD(int p0, struct S_PFD p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_PFP(int p0, struct S_PFP p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_PDI(int p0, struct S_PDI p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_PDF(int p0, struct S_PDF p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_PDD(int p0, struct S_PDD p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_PDP(int p0, struct S_PDP p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_PPI(int p0, struct S_PPI p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_PPF(int p0, struct S_PPF p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_PPD(int p0, struct S_PPD p1, double p2) { return p0; }
+EXPORT int f12_I_ISD_PPP(int p0, struct S_PPP p1, double p2) { return p0; }
+EXPORT int f12_I_ISP_I(int p0, struct S_I p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_F(int p0, struct S_F p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_D(int p0, struct S_D p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_P(int p0, struct S_P p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_II(int p0, struct S_II p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_IF(int p0, struct S_IF p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_ID(int p0, struct S_ID p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_IP(int p0, struct S_IP p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_FI(int p0, struct S_FI p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_FF(int p0, struct S_FF p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_FD(int p0, struct S_FD p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_FP(int p0, struct S_FP p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_DI(int p0, struct S_DI p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_DF(int p0, struct S_DF p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_DD(int p0, struct S_DD p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_DP(int p0, struct S_DP p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_PI(int p0, struct S_PI p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_PF(int p0, struct S_PF p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_PD(int p0, struct S_PD p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_PP(int p0, struct S_PP p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_III(int p0, struct S_III p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_IIF(int p0, struct S_IIF p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_IID(int p0, struct S_IID p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_IIP(int p0, struct S_IIP p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_IFI(int p0, struct S_IFI p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_IFF(int p0, struct S_IFF p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_IFD(int p0, struct S_IFD p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_IFP(int p0, struct S_IFP p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_IDI(int p0, struct S_IDI p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_IDF(int p0, struct S_IDF p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_IDD(int p0, struct S_IDD p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_IDP(int p0, struct S_IDP p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_IPI(int p0, struct S_IPI p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_IPF(int p0, struct S_IPF p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_IPD(int p0, struct S_IPD p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_IPP(int p0, struct S_IPP p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_FII(int p0, struct S_FII p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_FIF(int p0, struct S_FIF p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_FID(int p0, struct S_FID p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_FIP(int p0, struct S_FIP p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_FFI(int p0, struct S_FFI p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_FFF(int p0, struct S_FFF p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_FFD(int p0, struct S_FFD p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_FFP(int p0, struct S_FFP p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_FDI(int p0, struct S_FDI p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_FDF(int p0, struct S_FDF p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_FDD(int p0, struct S_FDD p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_FDP(int p0, struct S_FDP p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_FPI(int p0, struct S_FPI p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_FPF(int p0, struct S_FPF p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_FPD(int p0, struct S_FPD p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_FPP(int p0, struct S_FPP p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_DII(int p0, struct S_DII p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_DIF(int p0, struct S_DIF p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_DID(int p0, struct S_DID p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_DIP(int p0, struct S_DIP p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_DFI(int p0, struct S_DFI p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_DFF(int p0, struct S_DFF p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_DFD(int p0, struct S_DFD p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_DFP(int p0, struct S_DFP p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_DDI(int p0, struct S_DDI p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_DDF(int p0, struct S_DDF p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_DDD(int p0, struct S_DDD p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_DDP(int p0, struct S_DDP p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_DPI(int p0, struct S_DPI p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_DPF(int p0, struct S_DPF p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_DPD(int p0, struct S_DPD p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_DPP(int p0, struct S_DPP p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_PII(int p0, struct S_PII p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_PIF(int p0, struct S_PIF p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_PID(int p0, struct S_PID p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_PIP(int p0, struct S_PIP p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_PFI(int p0, struct S_PFI p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_PFF(int p0, struct S_PFF p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_PFD(int p0, struct S_PFD p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_PFP(int p0, struct S_PFP p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_PDI(int p0, struct S_PDI p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_PDF(int p0, struct S_PDF p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_PDD(int p0, struct S_PDD p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_PDP(int p0, struct S_PDP p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_PPI(int p0, struct S_PPI p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_PPF(int p0, struct S_PPF p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_PPD(int p0, struct S_PPD p1, void* p2) { return p0; }
+EXPORT int f12_I_ISP_PPP(int p0, struct S_PPP p1, void* p2) { return p0; }
+EXPORT int f12_I_ISS_I(int p0, struct S_I p1, struct S_I p2) { return p0; }
+EXPORT int f12_I_ISS_F(int p0, struct S_F p1, struct S_F p2) { return p0; }
+EXPORT int f12_I_ISS_D(int p0, struct S_D p1, struct S_D p2) { return p0; }
+EXPORT int f12_I_ISS_P(int p0, struct S_P p1, struct S_P p2) { return p0; }
+EXPORT int f12_I_ISS_II(int p0, struct S_II p1, struct S_II p2) { return p0; }
+EXPORT int f12_I_ISS_IF(int p0, struct S_IF p1, struct S_IF p2) { return p0; }
+EXPORT int f12_I_ISS_ID(int p0, struct S_ID p1, struct S_ID p2) { return p0; }
+EXPORT int f12_I_ISS_IP(int p0, struct S_IP p1, struct S_IP p2) { return p0; }
+EXPORT int f12_I_ISS_FI(int p0, struct S_FI p1, struct S_FI p2) { return p0; }
+EXPORT int f12_I_ISS_FF(int p0, struct S_FF p1, struct S_FF p2) { return p0; }
+EXPORT int f12_I_ISS_FD(int p0, struct S_FD p1, struct S_FD p2) { return p0; }
+EXPORT int f12_I_ISS_FP(int p0, struct S_FP p1, struct S_FP p2) { return p0; }
+EXPORT int f12_I_ISS_DI(int p0, struct S_DI p1, struct S_DI p2) { return p0; }
+EXPORT int f12_I_ISS_DF(int p0, struct S_DF p1, struct S_DF p2) { return p0; }
+EXPORT int f12_I_ISS_DD(int p0, struct S_DD p1, struct S_DD p2) { return p0; }
+EXPORT int f12_I_ISS_DP(int p0, struct S_DP p1, struct S_DP p2) { return p0; }
+EXPORT int f12_I_ISS_PI(int p0, struct S_PI p1, struct S_PI p2) { return p0; }
+EXPORT int f12_I_ISS_PF(int p0, struct S_PF p1, struct S_PF p2) { return p0; }
+EXPORT int f12_I_ISS_PD(int p0, struct S_PD p1, struct S_PD p2) { return p0; }
+EXPORT int f12_I_ISS_PP(int p0, struct S_PP p1, struct S_PP p2) { return p0; }
+EXPORT int f12_I_ISS_III(int p0, struct S_III p1, struct S_III p2) { return p0; }
+EXPORT int f12_I_ISS_IIF(int p0, struct S_IIF p1, struct S_IIF p2) { return p0; }
+EXPORT int f12_I_ISS_IID(int p0, struct S_IID p1, struct S_IID p2) { return p0; }
+EXPORT int f12_I_ISS_IIP(int p0, struct S_IIP p1, struct S_IIP p2) { return p0; }
+EXPORT int f12_I_ISS_IFI(int p0, struct S_IFI p1, struct S_IFI p2) { return p0; }
+EXPORT int f12_I_ISS_IFF(int p0, struct S_IFF p1, struct S_IFF p2) { return p0; }
+EXPORT int f12_I_ISS_IFD(int p0, struct S_IFD p1, struct S_IFD p2) { return p0; }
+EXPORT int f12_I_ISS_IFP(int p0, struct S_IFP p1, struct S_IFP p2) { return p0; }
+EXPORT int f12_I_ISS_IDI(int p0, struct S_IDI p1, struct S_IDI p2) { return p0; }
+EXPORT int f12_I_ISS_IDF(int p0, struct S_IDF p1, struct S_IDF p2) { return p0; }
+EXPORT int f12_I_ISS_IDD(int p0, struct S_IDD p1, struct S_IDD p2) { return p0; }
+EXPORT int f12_I_ISS_IDP(int p0, struct S_IDP p1, struct S_IDP p2) { return p0; }
+EXPORT int f12_I_ISS_IPI(int p0, struct S_IPI p1, struct S_IPI p2) { return p0; }
+EXPORT int f12_I_ISS_IPF(int p0, struct S_IPF p1, struct S_IPF p2) { return p0; }
+EXPORT int f12_I_ISS_IPD(int p0, struct S_IPD p1, struct S_IPD p2) { return p0; }
+EXPORT int f12_I_ISS_IPP(int p0, struct S_IPP p1, struct S_IPP p2) { return p0; }
+EXPORT int f12_I_ISS_FII(int p0, struct S_FII p1, struct S_FII p2) { return p0; }
+EXPORT int f12_I_ISS_FIF(int p0, struct S_FIF p1, struct S_FIF p2) { return p0; }
+EXPORT int f12_I_ISS_FID(int p0, struct S_FID p1, struct S_FID p2) { return p0; }
+EXPORT int f12_I_ISS_FIP(int p0, struct S_FIP p1, struct S_FIP p2) { return p0; }
+EXPORT int f12_I_ISS_FFI(int p0, struct S_FFI p1, struct S_FFI p2) { return p0; }
+EXPORT int f12_I_ISS_FFF(int p0, struct S_FFF p1, struct S_FFF p2) { return p0; }
+EXPORT int f12_I_ISS_FFD(int p0, struct S_FFD p1, struct S_FFD p2) { return p0; }
+EXPORT int f12_I_ISS_FFP(int p0, struct S_FFP p1, struct S_FFP p2) { return p0; }
+EXPORT int f12_I_ISS_FDI(int p0, struct S_FDI p1, struct S_FDI p2) { return p0; }
+EXPORT int f12_I_ISS_FDF(int p0, struct S_FDF p1, struct S_FDF p2) { return p0; }
+EXPORT int f12_I_ISS_FDD(int p0, struct S_FDD p1, struct S_FDD p2) { return p0; }
+EXPORT int f12_I_ISS_FDP(int p0, struct S_FDP p1, struct S_FDP p2) { return p0; }
+EXPORT int f12_I_ISS_FPI(int p0, struct S_FPI p1, struct S_FPI p2) { return p0; }
+EXPORT int f12_I_ISS_FPF(int p0, struct S_FPF p1, struct S_FPF p2) { return p0; }
+EXPORT int f12_I_ISS_FPD(int p0, struct S_FPD p1, struct S_FPD p2) { return p0; }
+EXPORT int f12_I_ISS_FPP(int p0, struct S_FPP p1, struct S_FPP p2) { return p0; }
+EXPORT int f12_I_ISS_DII(int p0, struct S_DII p1, struct S_DII p2) { return p0; }
+EXPORT int f12_I_ISS_DIF(int p0, struct S_DIF p1, struct S_DIF p2) { return p0; }
+EXPORT int f12_I_ISS_DID(int p0, struct S_DID p1, struct S_DID p2) { return p0; }
+EXPORT int f12_I_ISS_DIP(int p0, struct S_DIP p1, struct S_DIP p2) { return p0; }
+EXPORT int f12_I_ISS_DFI(int p0, struct S_DFI p1, struct S_DFI p2) { return p0; }
+EXPORT int f12_I_ISS_DFF(int p0, struct S_DFF p1, struct S_DFF p2) { return p0; }
+EXPORT int f12_I_ISS_DFD(int p0, struct S_DFD p1, struct S_DFD p2) { return p0; }
+EXPORT int f12_I_ISS_DFP(int p0, struct S_DFP p1, struct S_DFP p2) { return p0; }
+EXPORT int f12_I_ISS_DDI(int p0, struct S_DDI p1, struct S_DDI p2) { return p0; }
+EXPORT int f12_I_ISS_DDF(int p0, struct S_DDF p1, struct S_DDF p2) { return p0; }
+EXPORT int f12_I_ISS_DDD(int p0, struct S_DDD p1, struct S_DDD p2) { return p0; }
+EXPORT int f12_I_ISS_DDP(int p0, struct S_DDP p1, struct S_DDP p2) { return p0; }
+EXPORT int f12_I_ISS_DPI(int p0, struct S_DPI p1, struct S_DPI p2) { return p0; }
+EXPORT int f12_I_ISS_DPF(int p0, struct S_DPF p1, struct S_DPF p2) { return p0; }
+EXPORT int f12_I_ISS_DPD(int p0, struct S_DPD p1, struct S_DPD p2) { return p0; }
+EXPORT int f12_I_ISS_DPP(int p0, struct S_DPP p1, struct S_DPP p2) { return p0; }
+EXPORT int f12_I_ISS_PII(int p0, struct S_PII p1, struct S_PII p2) { return p0; }
+EXPORT int f12_I_ISS_PIF(int p0, struct S_PIF p1, struct S_PIF p2) { return p0; }
+EXPORT int f12_I_ISS_PID(int p0, struct S_PID p1, struct S_PID p2) { return p0; }
+EXPORT int f12_I_ISS_PIP(int p0, struct S_PIP p1, struct S_PIP p2) { return p0; }
+EXPORT int f12_I_ISS_PFI(int p0, struct S_PFI p1, struct S_PFI p2) { return p0; }
+EXPORT int f12_I_ISS_PFF(int p0, struct S_PFF p1, struct S_PFF p2) { return p0; }
+EXPORT int f12_I_ISS_PFD(int p0, struct S_PFD p1, struct S_PFD p2) { return p0; }
+EXPORT int f12_I_ISS_PFP(int p0, struct S_PFP p1, struct S_PFP p2) { return p0; }
+EXPORT int f12_I_ISS_PDI(int p0, struct S_PDI p1, struct S_PDI p2) { return p0; }
+EXPORT int f12_I_ISS_PDF(int p0, struct S_PDF p1, struct S_PDF p2) { return p0; }
+EXPORT int f12_I_ISS_PDD(int p0, struct S_PDD p1, struct S_PDD p2) { return p0; }
+EXPORT int f12_I_ISS_PDP(int p0, struct S_PDP p1, struct S_PDP p2) { return p0; }
+EXPORT int f12_I_ISS_PPI(int p0, struct S_PPI p1, struct S_PPI p2) { return p0; }
+EXPORT int f12_I_ISS_PPF(int p0, struct S_PPF p1, struct S_PPF p2) { return p0; }
+EXPORT int f12_I_ISS_PPD(int p0, struct S_PPD p1, struct S_PPD p2) { return p0; }
+EXPORT int f12_I_ISS_PPP(int p0, struct S_PPP p1, struct S_PPP p2) { return p0; }
+EXPORT float f12_F_FII_(float p0, int p1, int p2) { return p0; }
+EXPORT float f12_F_FIF_(float p0, int p1, float p2) { return p0; }
+EXPORT float f12_F_FID_(float p0, int p1, double p2) { return p0; }
+EXPORT float f12_F_FIP_(float p0, int p1, void* p2) { return p0; }
+EXPORT float f12_F_FIS_I(float p0, int p1, struct S_I p2) { return p0; }
+EXPORT float f12_F_FIS_F(float p0, int p1, struct S_F p2) { return p0; }
+EXPORT float f12_F_FIS_D(float p0, int p1, struct S_D p2) { return p0; }
+EXPORT float f12_F_FIS_P(float p0, int p1, struct S_P p2) { return p0; }
+EXPORT float f12_F_FIS_II(float p0, int p1, struct S_II p2) { return p0; }
+EXPORT float f12_F_FIS_IF(float p0, int p1, struct S_IF p2) { return p0; }
+EXPORT float f12_F_FIS_ID(float p0, int p1, struct S_ID p2) { return p0; }
+EXPORT float f12_F_FIS_IP(float p0, int p1, struct S_IP p2) { return p0; }
+EXPORT float f12_F_FIS_FI(float p0, int p1, struct S_FI p2) { return p0; }
+EXPORT float f12_F_FIS_FF(float p0, int p1, struct S_FF p2) { return p0; }
+EXPORT float f12_F_FIS_FD(float p0, int p1, struct S_FD p2) { return p0; }
+EXPORT float f12_F_FIS_FP(float p0, int p1, struct S_FP p2) { return p0; }
+EXPORT float f12_F_FIS_DI(float p0, int p1, struct S_DI p2) { return p0; }
+EXPORT float f12_F_FIS_DF(float p0, int p1, struct S_DF p2) { return p0; }
+EXPORT float f12_F_FIS_DD(float p0, int p1, struct S_DD p2) { return p0; }
+EXPORT float f12_F_FIS_DP(float p0, int p1, struct S_DP p2) { return p0; }
+EXPORT float f12_F_FIS_PI(float p0, int p1, struct S_PI p2) { return p0; }
+EXPORT float f12_F_FIS_PF(float p0, int p1, struct S_PF p2) { return p0; }
+EXPORT float f12_F_FIS_PD(float p0, int p1, struct S_PD p2) { return p0; }
+EXPORT float f12_F_FIS_PP(float p0, int p1, struct S_PP p2) { return p0; }
+EXPORT float f12_F_FIS_III(float p0, int p1, struct S_III p2) { return p0; }
+EXPORT float f12_F_FIS_IIF(float p0, int p1, struct S_IIF p2) { return p0; }
+EXPORT float f12_F_FIS_IID(float p0, int p1, struct S_IID p2) { return p0; }
+EXPORT float f12_F_FIS_IIP(float p0, int p1, struct S_IIP p2) { return p0; }
+EXPORT float f12_F_FIS_IFI(float p0, int p1, struct S_IFI p2) { return p0; }
+EXPORT float f12_F_FIS_IFF(float p0, int p1, struct S_IFF p2) { return p0; }
+EXPORT float f12_F_FIS_IFD(float p0, int p1, struct S_IFD p2) { return p0; }
+EXPORT float f12_F_FIS_IFP(float p0, int p1, struct S_IFP p2) { return p0; }
+EXPORT float f12_F_FIS_IDI(float p0, int p1, struct S_IDI p2) { return p0; }
+EXPORT float f12_F_FIS_IDF(float p0, int p1, struct S_IDF p2) { return p0; }
+EXPORT float f12_F_FIS_IDD(float p0, int p1, struct S_IDD p2) { return p0; }
+EXPORT float f12_F_FIS_IDP(float p0, int p1, struct S_IDP p2) { return p0; }
+EXPORT float f12_F_FIS_IPI(float p0, int p1, struct S_IPI p2) { return p0; }
+EXPORT float f12_F_FIS_IPF(float p0, int p1, struct S_IPF p2) { return p0; }
+EXPORT float f12_F_FIS_IPD(float p0, int p1, struct S_IPD p2) { return p0; }
+EXPORT float f12_F_FIS_IPP(float p0, int p1, struct S_IPP p2) { return p0; }
+EXPORT float f12_F_FIS_FII(float p0, int p1, struct S_FII p2) { return p0; }
+EXPORT float f12_F_FIS_FIF(float p0, int p1, struct S_FIF p2) { return p0; }
+EXPORT float f12_F_FIS_FID(float p0, int p1, struct S_FID p2) { return p0; }
+EXPORT float f12_F_FIS_FIP(float p0, int p1, struct S_FIP p2) { return p0; }
+EXPORT float f12_F_FIS_FFI(float p0, int p1, struct S_FFI p2) { return p0; }
+EXPORT float f12_F_FIS_FFF(float p0, int p1, struct S_FFF p2) { return p0; }
+EXPORT float f12_F_FIS_FFD(float p0, int p1, struct S_FFD p2) { return p0; }
+EXPORT float f12_F_FIS_FFP(float p0, int p1, struct S_FFP p2) { return p0; }
+EXPORT float f12_F_FIS_FDI(float p0, int p1, struct S_FDI p2) { return p0; }
+EXPORT float f12_F_FIS_FDF(float p0, int p1, struct S_FDF p2) { return p0; }
+EXPORT float f12_F_FIS_FDD(float p0, int p1, struct S_FDD p2) { return p0; }
+EXPORT float f12_F_FIS_FDP(float p0, int p1, struct S_FDP p2) { return p0; }
+EXPORT float f12_F_FIS_FPI(float p0, int p1, struct S_FPI p2) { return p0; }
+EXPORT float f12_F_FIS_FPF(float p0, int p1, struct S_FPF p2) { return p0; }
+EXPORT float f12_F_FIS_FPD(float p0, int p1, struct S_FPD p2) { return p0; }
+EXPORT float f12_F_FIS_FPP(float p0, int p1, struct S_FPP p2) { return p0; }
+EXPORT float f12_F_FIS_DII(float p0, int p1, struct S_DII p2) { return p0; }
+EXPORT float f12_F_FIS_DIF(float p0, int p1, struct S_DIF p2) { return p0; }
+EXPORT float f12_F_FIS_DID(float p0, int p1, struct S_DID p2) { return p0; }
+EXPORT float f12_F_FIS_DIP(float p0, int p1, struct S_DIP p2) { return p0; }
+EXPORT float f12_F_FIS_DFI(float p0, int p1, struct S_DFI p2) { return p0; }
+EXPORT float f12_F_FIS_DFF(float p0, int p1, struct S_DFF p2) { return p0; }
+EXPORT float f12_F_FIS_DFD(float p0, int p1, struct S_DFD p2) { return p0; }
+EXPORT float f12_F_FIS_DFP(float p0, int p1, struct S_DFP p2) { return p0; }
+EXPORT float f12_F_FIS_DDI(float p0, int p1, struct S_DDI p2) { return p0; }
+EXPORT float f12_F_FIS_DDF(float p0, int p1, struct S_DDF p2) { return p0; }
+EXPORT float f12_F_FIS_DDD(float p0, int p1, struct S_DDD p2) { return p0; }
+EXPORT float f12_F_FIS_DDP(float p0, int p1, struct S_DDP p2) { return p0; }
+EXPORT float f12_F_FIS_DPI(float p0, int p1, struct S_DPI p2) { return p0; }
+EXPORT float f12_F_FIS_DPF(float p0, int p1, struct S_DPF p2) { return p0; }
+EXPORT float f12_F_FIS_DPD(float p0, int p1, struct S_DPD p2) { return p0; }
+EXPORT float f12_F_FIS_DPP(float p0, int p1, struct S_DPP p2) { return p0; }
+EXPORT float f12_F_FIS_PII(float p0, int p1, struct S_PII p2) { return p0; }
+EXPORT float f12_F_FIS_PIF(float p0, int p1, struct S_PIF p2) { return p0; }
+EXPORT float f12_F_FIS_PID(float p0, int p1, struct S_PID p2) { return p0; }
+EXPORT float f12_F_FIS_PIP(float p0, int p1, struct S_PIP p2) { return p0; }
+EXPORT float f12_F_FIS_PFI(float p0, int p1, struct S_PFI p2) { return p0; }
+EXPORT float f12_F_FIS_PFF(float p0, int p1, struct S_PFF p2) { return p0; }
+EXPORT float f12_F_FIS_PFD(float p0, int p1, struct S_PFD p2) { return p0; }
+EXPORT float f12_F_FIS_PFP(float p0, int p1, struct S_PFP p2) { return p0; }
+EXPORT float f12_F_FIS_PDI(float p0, int p1, struct S_PDI p2) { return p0; }
+EXPORT float f12_F_FIS_PDF(float p0, int p1, struct S_PDF p2) { return p0; }
+EXPORT float f12_F_FIS_PDD(float p0, int p1, struct S_PDD p2) { return p0; }
+EXPORT float f12_F_FIS_PDP(float p0, int p1, struct S_PDP p2) { return p0; }
+EXPORT float f12_F_FIS_PPI(float p0, int p1, struct S_PPI p2) { return p0; }
+EXPORT float f12_F_FIS_PPF(float p0, int p1, struct S_PPF p2) { return p0; }
+EXPORT float f12_F_FIS_PPD(float p0, int p1, struct S_PPD p2) { return p0; }
+EXPORT float f12_F_FIS_PPP(float p0, int p1, struct S_PPP p2) { return p0; }
+EXPORT float f12_F_FFI_(float p0, float p1, int p2) { return p0; }
+EXPORT float f12_F_FFF_(float p0, float p1, float p2) { return p0; }
+EXPORT float f12_F_FFD_(float p0, float p1, double p2) { return p0; }
+EXPORT float f12_F_FFP_(float p0, float p1, void* p2) { return p0; }
+EXPORT float f12_F_FFS_I(float p0, float p1, struct S_I p2) { return p0; }
+EXPORT float f12_F_FFS_F(float p0, float p1, struct S_F p2) { return p0; }
+EXPORT float f12_F_FFS_D(float p0, float p1, struct S_D p2) { return p0; }
+EXPORT float f12_F_FFS_P(float p0, float p1, struct S_P p2) { return p0; }
+EXPORT float f12_F_FFS_II(float p0, float p1, struct S_II p2) { return p0; }
+EXPORT float f12_F_FFS_IF(float p0, float p1, struct S_IF p2) { return p0; }
+EXPORT float f12_F_FFS_ID(float p0, float p1, struct S_ID p2) { return p0; }
+EXPORT float f12_F_FFS_IP(float p0, float p1, struct S_IP p2) { return p0; }
+EXPORT float f12_F_FFS_FI(float p0, float p1, struct S_FI p2) { return p0; }
+EXPORT float f12_F_FFS_FF(float p0, float p1, struct S_FF p2) { return p0; }
+EXPORT float f12_F_FFS_FD(float p0, float p1, struct S_FD p2) { return p0; }
+EXPORT float f12_F_FFS_FP(float p0, float p1, struct S_FP p2) { return p0; }
+EXPORT float f12_F_FFS_DI(float p0, float p1, struct S_DI p2) { return p0; }
+EXPORT float f12_F_FFS_DF(float p0, float p1, struct S_DF p2) { return p0; }
+EXPORT float f12_F_FFS_DD(float p0, float p1, struct S_DD p2) { return p0; }
+EXPORT float f12_F_FFS_DP(float p0, float p1, struct S_DP p2) { return p0; }
+EXPORT float f12_F_FFS_PI(float p0, float p1, struct S_PI p2) { return p0; }
+EXPORT float f12_F_FFS_PF(float p0, float p1, struct S_PF p2) { return p0; }
+EXPORT float f12_F_FFS_PD(float p0, float p1, struct S_PD p2) { return p0; }
+EXPORT float f12_F_FFS_PP(float p0, float p1, struct S_PP p2) { return p0; }
+EXPORT float f12_F_FFS_III(float p0, float p1, struct S_III p2) { return p0; }
+EXPORT float f12_F_FFS_IIF(float p0, float p1, struct S_IIF p2) { return p0; }
+EXPORT float f12_F_FFS_IID(float p0, float p1, struct S_IID p2) { return p0; }
+EXPORT float f12_F_FFS_IIP(float p0, float p1, struct S_IIP p2) { return p0; }
+EXPORT float f12_F_FFS_IFI(float p0, float p1, struct S_IFI p2) { return p0; }
+EXPORT float f12_F_FFS_IFF(float p0, float p1, struct S_IFF p2) { return p0; }
+EXPORT float f12_F_FFS_IFD(float p0, float p1, struct S_IFD p2) { return p0; }
+EXPORT float f13_F_FFS_IFP(float p0, float p1, struct S_IFP p2) { return p0; }
+EXPORT float f13_F_FFS_IDI(float p0, float p1, struct S_IDI p2) { return p0; }
+EXPORT float f13_F_FFS_IDF(float p0, float p1, struct S_IDF p2) { return p0; }
+EXPORT float f13_F_FFS_IDD(float p0, float p1, struct S_IDD p2) { return p0; }
+EXPORT float f13_F_FFS_IDP(float p0, float p1, struct S_IDP p2) { return p0; }
+EXPORT float f13_F_FFS_IPI(float p0, float p1, struct S_IPI p2) { return p0; }
+EXPORT float f13_F_FFS_IPF(float p0, float p1, struct S_IPF p2) { return p0; }
+EXPORT float f13_F_FFS_IPD(float p0, float p1, struct S_IPD p2) { return p0; }
+EXPORT float f13_F_FFS_IPP(float p0, float p1, struct S_IPP p2) { return p0; }
+EXPORT float f13_F_FFS_FII(float p0, float p1, struct S_FII p2) { return p0; }
+EXPORT float f13_F_FFS_FIF(float p0, float p1, struct S_FIF p2) { return p0; }
+EXPORT float f13_F_FFS_FID(float p0, float p1, struct S_FID p2) { return p0; }
+EXPORT float f13_F_FFS_FIP(float p0, float p1, struct S_FIP p2) { return p0; }
+EXPORT float f13_F_FFS_FFI(float p0, float p1, struct S_FFI p2) { return p0; }
+EXPORT float f13_F_FFS_FFF(float p0, float p1, struct S_FFF p2) { return p0; }
+EXPORT float f13_F_FFS_FFD(float p0, float p1, struct S_FFD p2) { return p0; }
+EXPORT float f13_F_FFS_FFP(float p0, float p1, struct S_FFP p2) { return p0; }
+EXPORT float f13_F_FFS_FDI(float p0, float p1, struct S_FDI p2) { return p0; }
+EXPORT float f13_F_FFS_FDF(float p0, float p1, struct S_FDF p2) { return p0; }
+EXPORT float f13_F_FFS_FDD(float p0, float p1, struct S_FDD p2) { return p0; }
+EXPORT float f13_F_FFS_FDP(float p0, float p1, struct S_FDP p2) { return p0; }
+EXPORT float f13_F_FFS_FPI(float p0, float p1, struct S_FPI p2) { return p0; }
+EXPORT float f13_F_FFS_FPF(float p0, float p1, struct S_FPF p2) { return p0; }
+EXPORT float f13_F_FFS_FPD(float p0, float p1, struct S_FPD p2) { return p0; }
+EXPORT float f13_F_FFS_FPP(float p0, float p1, struct S_FPP p2) { return p0; }
+EXPORT float f13_F_FFS_DII(float p0, float p1, struct S_DII p2) { return p0; }
+EXPORT float f13_F_FFS_DIF(float p0, float p1, struct S_DIF p2) { return p0; }
+EXPORT float f13_F_FFS_DID(float p0, float p1, struct S_DID p2) { return p0; }
+EXPORT float f13_F_FFS_DIP(float p0, float p1, struct S_DIP p2) { return p0; }
+EXPORT float f13_F_FFS_DFI(float p0, float p1, struct S_DFI p2) { return p0; }
+EXPORT float f13_F_FFS_DFF(float p0, float p1, struct S_DFF p2) { return p0; }
+EXPORT float f13_F_FFS_DFD(float p0, float p1, struct S_DFD p2) { return p0; }
+EXPORT float f13_F_FFS_DFP(float p0, float p1, struct S_DFP p2) { return p0; }
+EXPORT float f13_F_FFS_DDI(float p0, float p1, struct S_DDI p2) { return p0; }
+EXPORT float f13_F_FFS_DDF(float p0, float p1, struct S_DDF p2) { return p0; }
+EXPORT float f13_F_FFS_DDD(float p0, float p1, struct S_DDD p2) { return p0; }
+EXPORT float f13_F_FFS_DDP(float p0, float p1, struct S_DDP p2) { return p0; }
+EXPORT float f13_F_FFS_DPI(float p0, float p1, struct S_DPI p2) { return p0; }
+EXPORT float f13_F_FFS_DPF(float p0, float p1, struct S_DPF p2) { return p0; }
+EXPORT float f13_F_FFS_DPD(float p0, float p1, struct S_DPD p2) { return p0; }
+EXPORT float f13_F_FFS_DPP(float p0, float p1, struct S_DPP p2) { return p0; }
+EXPORT float f13_F_FFS_PII(float p0, float p1, struct S_PII p2) { return p0; }
+EXPORT float f13_F_FFS_PIF(float p0, float p1, struct S_PIF p2) { return p0; }
+EXPORT float f13_F_FFS_PID(float p0, float p1, struct S_PID p2) { return p0; }
+EXPORT float f13_F_FFS_PIP(float p0, float p1, struct S_PIP p2) { return p0; }
+EXPORT float f13_F_FFS_PFI(float p0, float p1, struct S_PFI p2) { return p0; }
+EXPORT float f13_F_FFS_PFF(float p0, float p1, struct S_PFF p2) { return p0; }
+EXPORT float f13_F_FFS_PFD(float p0, float p1, struct S_PFD p2) { return p0; }
+EXPORT float f13_F_FFS_PFP(float p0, float p1, struct S_PFP p2) { return p0; }
+EXPORT float f13_F_FFS_PDI(float p0, float p1, struct S_PDI p2) { return p0; }
+EXPORT float f13_F_FFS_PDF(float p0, float p1, struct S_PDF p2) { return p0; }
+EXPORT float f13_F_FFS_PDD(float p0, float p1, struct S_PDD p2) { return p0; }
+EXPORT float f13_F_FFS_PDP(float p0, float p1, struct S_PDP p2) { return p0; }
+EXPORT float f13_F_FFS_PPI(float p0, float p1, struct S_PPI p2) { return p0; }
+EXPORT float f13_F_FFS_PPF(float p0, float p1, struct S_PPF p2) { return p0; }
+EXPORT float f13_F_FFS_PPD(float p0, float p1, struct S_PPD p2) { return p0; }
+EXPORT float f13_F_FFS_PPP(float p0, float p1, struct S_PPP p2) { return p0; }
+EXPORT float f13_F_FDI_(float p0, double p1, int p2) { return p0; }
+EXPORT float f13_F_FDF_(float p0, double p1, float p2) { return p0; }
+EXPORT float f13_F_FDD_(float p0, double p1, double p2) { return p0; }
+EXPORT float f13_F_FDP_(float p0, double p1, void* p2) { return p0; }
+EXPORT float f13_F_FDS_I(float p0, double p1, struct S_I p2) { return p0; }
+EXPORT float f13_F_FDS_F(float p0, double p1, struct S_F p2) { return p0; }
+EXPORT float f13_F_FDS_D(float p0, double p1, struct S_D p2) { return p0; }
+EXPORT float f13_F_FDS_P(float p0, double p1, struct S_P p2) { return p0; }
+EXPORT float f13_F_FDS_II(float p0, double p1, struct S_II p2) { return p0; }
+EXPORT float f13_F_FDS_IF(float p0, double p1, struct S_IF p2) { return p0; }
+EXPORT float f13_F_FDS_ID(float p0, double p1, struct S_ID p2) { return p0; }
+EXPORT float f13_F_FDS_IP(float p0, double p1, struct S_IP p2) { return p0; }
+EXPORT float f13_F_FDS_FI(float p0, double p1, struct S_FI p2) { return p0; }
+EXPORT float f13_F_FDS_FF(float p0, double p1, struct S_FF p2) { return p0; }
+EXPORT float f13_F_FDS_FD(float p0, double p1, struct S_FD p2) { return p0; }
+EXPORT float f13_F_FDS_FP(float p0, double p1, struct S_FP p2) { return p0; }
+EXPORT float f13_F_FDS_DI(float p0, double p1, struct S_DI p2) { return p0; }
+EXPORT float f13_F_FDS_DF(float p0, double p1, struct S_DF p2) { return p0; }
+EXPORT float f13_F_FDS_DD(float p0, double p1, struct S_DD p2) { return p0; }
+EXPORT float f13_F_FDS_DP(float p0, double p1, struct S_DP p2) { return p0; }
+EXPORT float f13_F_FDS_PI(float p0, double p1, struct S_PI p2) { return p0; }
+EXPORT float f13_F_FDS_PF(float p0, double p1, struct S_PF p2) { return p0; }
+EXPORT float f13_F_FDS_PD(float p0, double p1, struct S_PD p2) { return p0; }
+EXPORT float f13_F_FDS_PP(float p0, double p1, struct S_PP p2) { return p0; }
+EXPORT float f13_F_FDS_III(float p0, double p1, struct S_III p2) { return p0; }
+EXPORT float f13_F_FDS_IIF(float p0, double p1, struct S_IIF p2) { return p0; }
+EXPORT float f13_F_FDS_IID(float p0, double p1, struct S_IID p2) { return p0; }
+EXPORT float f13_F_FDS_IIP(float p0, double p1, struct S_IIP p2) { return p0; }
+EXPORT float f13_F_FDS_IFI(float p0, double p1, struct S_IFI p2) { return p0; }
+EXPORT float f13_F_FDS_IFF(float p0, double p1, struct S_IFF p2) { return p0; }
+EXPORT float f13_F_FDS_IFD(float p0, double p1, struct S_IFD p2) { return p0; }
+EXPORT float f13_F_FDS_IFP(float p0, double p1, struct S_IFP p2) { return p0; }
+EXPORT float f13_F_FDS_IDI(float p0, double p1, struct S_IDI p2) { return p0; }
+EXPORT float f13_F_FDS_IDF(float p0, double p1, struct S_IDF p2) { return p0; }
+EXPORT float f13_F_FDS_IDD(float p0, double p1, struct S_IDD p2) { return p0; }
+EXPORT float f13_F_FDS_IDP(float p0, double p1, struct S_IDP p2) { return p0; }
+EXPORT float f13_F_FDS_IPI(float p0, double p1, struct S_IPI p2) { return p0; }
+EXPORT float f13_F_FDS_IPF(float p0, double p1, struct S_IPF p2) { return p0; }
+EXPORT float f13_F_FDS_IPD(float p0, double p1, struct S_IPD p2) { return p0; }
+EXPORT float f13_F_FDS_IPP(float p0, double p1, struct S_IPP p2) { return p0; }
+EXPORT float f13_F_FDS_FII(float p0, double p1, struct S_FII p2) { return p0; }
+EXPORT float f13_F_FDS_FIF(float p0, double p1, struct S_FIF p2) { return p0; }
+EXPORT float f13_F_FDS_FID(float p0, double p1, struct S_FID p2) { return p0; }
+EXPORT float f13_F_FDS_FIP(float p0, double p1, struct S_FIP p2) { return p0; }
+EXPORT float f13_F_FDS_FFI(float p0, double p1, struct S_FFI p2) { return p0; }
+EXPORT float f13_F_FDS_FFF(float p0, double p1, struct S_FFF p2) { return p0; }
+EXPORT float f13_F_FDS_FFD(float p0, double p1, struct S_FFD p2) { return p0; }
+EXPORT float f13_F_FDS_FFP(float p0, double p1, struct S_FFP p2) { return p0; }
+EXPORT float f13_F_FDS_FDI(float p0, double p1, struct S_FDI p2) { return p0; }
+EXPORT float f13_F_FDS_FDF(float p0, double p1, struct S_FDF p2) { return p0; }
+EXPORT float f13_F_FDS_FDD(float p0, double p1, struct S_FDD p2) { return p0; }
+EXPORT float f13_F_FDS_FDP(float p0, double p1, struct S_FDP p2) { return p0; }
+EXPORT float f13_F_FDS_FPI(float p0, double p1, struct S_FPI p2) { return p0; }
+EXPORT float f13_F_FDS_FPF(float p0, double p1, struct S_FPF p2) { return p0; }
+EXPORT float f13_F_FDS_FPD(float p0, double p1, struct S_FPD p2) { return p0; }
+EXPORT float f13_F_FDS_FPP(float p0, double p1, struct S_FPP p2) { return p0; }
+EXPORT float f13_F_FDS_DII(float p0, double p1, struct S_DII p2) { return p0; }
+EXPORT float f13_F_FDS_DIF(float p0, double p1, struct S_DIF p2) { return p0; }
+EXPORT float f13_F_FDS_DID(float p0, double p1, struct S_DID p2) { return p0; }
+EXPORT float f13_F_FDS_DIP(float p0, double p1, struct S_DIP p2) { return p0; }
+EXPORT float f13_F_FDS_DFI(float p0, double p1, struct S_DFI p2) { return p0; }
+EXPORT float f13_F_FDS_DFF(float p0, double p1, struct S_DFF p2) { return p0; }
+EXPORT float f13_F_FDS_DFD(float p0, double p1, struct S_DFD p2) { return p0; }
+EXPORT float f13_F_FDS_DFP(float p0, double p1, struct S_DFP p2) { return p0; }
+EXPORT float f13_F_FDS_DDI(float p0, double p1, struct S_DDI p2) { return p0; }
+EXPORT float f13_F_FDS_DDF(float p0, double p1, struct S_DDF p2) { return p0; }
+EXPORT float f13_F_FDS_DDD(float p0, double p1, struct S_DDD p2) { return p0; }
+EXPORT float f13_F_FDS_DDP(float p0, double p1, struct S_DDP p2) { return p0; }
+EXPORT float f13_F_FDS_DPI(float p0, double p1, struct S_DPI p2) { return p0; }
+EXPORT float f13_F_FDS_DPF(float p0, double p1, struct S_DPF p2) { return p0; }
+EXPORT float f13_F_FDS_DPD(float p0, double p1, struct S_DPD p2) { return p0; }
+EXPORT float f13_F_FDS_DPP(float p0, double p1, struct S_DPP p2) { return p0; }
+EXPORT float f13_F_FDS_PII(float p0, double p1, struct S_PII p2) { return p0; }
+EXPORT float f13_F_FDS_PIF(float p0, double p1, struct S_PIF p2) { return p0; }
+EXPORT float f13_F_FDS_PID(float p0, double p1, struct S_PID p2) { return p0; }
+EXPORT float f13_F_FDS_PIP(float p0, double p1, struct S_PIP p2) { return p0; }
+EXPORT float f13_F_FDS_PFI(float p0, double p1, struct S_PFI p2) { return p0; }
+EXPORT float f13_F_FDS_PFF(float p0, double p1, struct S_PFF p2) { return p0; }
+EXPORT float f13_F_FDS_PFD(float p0, double p1, struct S_PFD p2) { return p0; }
+EXPORT float f13_F_FDS_PFP(float p0, double p1, struct S_PFP p2) { return p0; }
+EXPORT float f13_F_FDS_PDI(float p0, double p1, struct S_PDI p2) { return p0; }
+EXPORT float f13_F_FDS_PDF(float p0, double p1, struct S_PDF p2) { return p0; }
+EXPORT float f13_F_FDS_PDD(float p0, double p1, struct S_PDD p2) { return p0; }
+EXPORT float f13_F_FDS_PDP(float p0, double p1, struct S_PDP p2) { return p0; }
+EXPORT float f13_F_FDS_PPI(float p0, double p1, struct S_PPI p2) { return p0; }
+EXPORT float f13_F_FDS_PPF(float p0, double p1, struct S_PPF p2) { return p0; }
+EXPORT float f13_F_FDS_PPD(float p0, double p1, struct S_PPD p2) { return p0; }
+EXPORT float f13_F_FDS_PPP(float p0, double p1, struct S_PPP p2) { return p0; }
+EXPORT float f13_F_FPI_(float p0, void* p1, int p2) { return p0; }
+EXPORT float f13_F_FPF_(float p0, void* p1, float p2) { return p0; }
+EXPORT float f13_F_FPD_(float p0, void* p1, double p2) { return p0; }
+EXPORT float f13_F_FPP_(float p0, void* p1, void* p2) { return p0; }
+EXPORT float f13_F_FPS_I(float p0, void* p1, struct S_I p2) { return p0; }
+EXPORT float f13_F_FPS_F(float p0, void* p1, struct S_F p2) { return p0; }
+EXPORT float f13_F_FPS_D(float p0, void* p1, struct S_D p2) { return p0; }
+EXPORT float f13_F_FPS_P(float p0, void* p1, struct S_P p2) { return p0; }
+EXPORT float f13_F_FPS_II(float p0, void* p1, struct S_II p2) { return p0; }
+EXPORT float f13_F_FPS_IF(float p0, void* p1, struct S_IF p2) { return p0; }
+EXPORT float f13_F_FPS_ID(float p0, void* p1, struct S_ID p2) { return p0; }
+EXPORT float f13_F_FPS_IP(float p0, void* p1, struct S_IP p2) { return p0; }
+EXPORT float f13_F_FPS_FI(float p0, void* p1, struct S_FI p2) { return p0; }
+EXPORT float f13_F_FPS_FF(float p0, void* p1, struct S_FF p2) { return p0; }
+EXPORT float f13_F_FPS_FD(float p0, void* p1, struct S_FD p2) { return p0; }
+EXPORT float f13_F_FPS_FP(float p0, void* p1, struct S_FP p2) { return p0; }
+EXPORT float f13_F_FPS_DI(float p0, void* p1, struct S_DI p2) { return p0; }
+EXPORT float f13_F_FPS_DF(float p0, void* p1, struct S_DF p2) { return p0; }
+EXPORT float f13_F_FPS_DD(float p0, void* p1, struct S_DD p2) { return p0; }
+EXPORT float f13_F_FPS_DP(float p0, void* p1, struct S_DP p2) { return p0; }
+EXPORT float f13_F_FPS_PI(float p0, void* p1, struct S_PI p2) { return p0; }
+EXPORT float f13_F_FPS_PF(float p0, void* p1, struct S_PF p2) { return p0; }
+EXPORT float f13_F_FPS_PD(float p0, void* p1, struct S_PD p2) { return p0; }
+EXPORT float f13_F_FPS_PP(float p0, void* p1, struct S_PP p2) { return p0; }
+EXPORT float f13_F_FPS_III(float p0, void* p1, struct S_III p2) { return p0; }
+EXPORT float f13_F_FPS_IIF(float p0, void* p1, struct S_IIF p2) { return p0; }
+EXPORT float f13_F_FPS_IID(float p0, void* p1, struct S_IID p2) { return p0; }
+EXPORT float f13_F_FPS_IIP(float p0, void* p1, struct S_IIP p2) { return p0; }
+EXPORT float f13_F_FPS_IFI(float p0, void* p1, struct S_IFI p2) { return p0; }
+EXPORT float f13_F_FPS_IFF(float p0, void* p1, struct S_IFF p2) { return p0; }
+EXPORT float f13_F_FPS_IFD(float p0, void* p1, struct S_IFD p2) { return p0; }
+EXPORT float f13_F_FPS_IFP(float p0, void* p1, struct S_IFP p2) { return p0; }
+EXPORT float f13_F_FPS_IDI(float p0, void* p1, struct S_IDI p2) { return p0; }
+EXPORT float f13_F_FPS_IDF(float p0, void* p1, struct S_IDF p2) { return p0; }
+EXPORT float f13_F_FPS_IDD(float p0, void* p1, struct S_IDD p2) { return p0; }
+EXPORT float f13_F_FPS_IDP(float p0, void* p1, struct S_IDP p2) { return p0; }
+EXPORT float f13_F_FPS_IPI(float p0, void* p1, struct S_IPI p2) { return p0; }
+EXPORT float f13_F_FPS_IPF(float p0, void* p1, struct S_IPF p2) { return p0; }
+EXPORT float f13_F_FPS_IPD(float p0, void* p1, struct S_IPD p2) { return p0; }
+EXPORT float f13_F_FPS_IPP(float p0, void* p1, struct S_IPP p2) { return p0; }
+EXPORT float f13_F_FPS_FII(float p0, void* p1, struct S_FII p2) { return p0; }
+EXPORT float f13_F_FPS_FIF(float p0, void* p1, struct S_FIF p2) { return p0; }
+EXPORT float f13_F_FPS_FID(float p0, void* p1, struct S_FID p2) { return p0; }
+EXPORT float f13_F_FPS_FIP(float p0, void* p1, struct S_FIP p2) { return p0; }
+EXPORT float f13_F_FPS_FFI(float p0, void* p1, struct S_FFI p2) { return p0; }
+EXPORT float f13_F_FPS_FFF(float p0, void* p1, struct S_FFF p2) { return p0; }
+EXPORT float f13_F_FPS_FFD(float p0, void* p1, struct S_FFD p2) { return p0; }
+EXPORT float f13_F_FPS_FFP(float p0, void* p1, struct S_FFP p2) { return p0; }
+EXPORT float f13_F_FPS_FDI(float p0, void* p1, struct S_FDI p2) { return p0; }
+EXPORT float f13_F_FPS_FDF(float p0, void* p1, struct S_FDF p2) { return p0; }
+EXPORT float f13_F_FPS_FDD(float p0, void* p1, struct S_FDD p2) { return p0; }
+EXPORT float f13_F_FPS_FDP(float p0, void* p1, struct S_FDP p2) { return p0; }
+EXPORT float f13_F_FPS_FPI(float p0, void* p1, struct S_FPI p2) { return p0; }
+EXPORT float f13_F_FPS_FPF(float p0, void* p1, struct S_FPF p2) { return p0; }
+EXPORT float f13_F_FPS_FPD(float p0, void* p1, struct S_FPD p2) { return p0; }
+EXPORT float f13_F_FPS_FPP(float p0, void* p1, struct S_FPP p2) { return p0; }
+EXPORT float f13_F_FPS_DII(float p0, void* p1, struct S_DII p2) { return p0; }
+EXPORT float f13_F_FPS_DIF(float p0, void* p1, struct S_DIF p2) { return p0; }
+EXPORT float f13_F_FPS_DID(float p0, void* p1, struct S_DID p2) { return p0; }
+EXPORT float f13_F_FPS_DIP(float p0, void* p1, struct S_DIP p2) { return p0; }
+EXPORT float f13_F_FPS_DFI(float p0, void* p1, struct S_DFI p2) { return p0; }
+EXPORT float f13_F_FPS_DFF(float p0, void* p1, struct S_DFF p2) { return p0; }
+EXPORT float f13_F_FPS_DFD(float p0, void* p1, struct S_DFD p2) { return p0; }
+EXPORT float f13_F_FPS_DFP(float p0, void* p1, struct S_DFP p2) { return p0; }
+EXPORT float f13_F_FPS_DDI(float p0, void* p1, struct S_DDI p2) { return p0; }
+EXPORT float f13_F_FPS_DDF(float p0, void* p1, struct S_DDF p2) { return p0; }
+EXPORT float f13_F_FPS_DDD(float p0, void* p1, struct S_DDD p2) { return p0; }
+EXPORT float f13_F_FPS_DDP(float p0, void* p1, struct S_DDP p2) { return p0; }
+EXPORT float f13_F_FPS_DPI(float p0, void* p1, struct S_DPI p2) { return p0; }
+EXPORT float f13_F_FPS_DPF(float p0, void* p1, struct S_DPF p2) { return p0; }
+EXPORT float f13_F_FPS_DPD(float p0, void* p1, struct S_DPD p2) { return p0; }
+EXPORT float f13_F_FPS_DPP(float p0, void* p1, struct S_DPP p2) { return p0; }
+EXPORT float f13_F_FPS_PII(float p0, void* p1, struct S_PII p2) { return p0; }
+EXPORT float f13_F_FPS_PIF(float p0, void* p1, struct S_PIF p2) { return p0; }
+EXPORT float f13_F_FPS_PID(float p0, void* p1, struct S_PID p2) { return p0; }
+EXPORT float f13_F_FPS_PIP(float p0, void* p1, struct S_PIP p2) { return p0; }
+EXPORT float f13_F_FPS_PFI(float p0, void* p1, struct S_PFI p2) { return p0; }
+EXPORT float f13_F_FPS_PFF(float p0, void* p1, struct S_PFF p2) { return p0; }
+EXPORT float f13_F_FPS_PFD(float p0, void* p1, struct S_PFD p2) { return p0; }
+EXPORT float f13_F_FPS_PFP(float p0, void* p1, struct S_PFP p2) { return p0; }
+EXPORT float f13_F_FPS_PDI(float p0, void* p1, struct S_PDI p2) { return p0; }
+EXPORT float f13_F_FPS_PDF(float p0, void* p1, struct S_PDF p2) { return p0; }
+EXPORT float f13_F_FPS_PDD(float p0, void* p1, struct S_PDD p2) { return p0; }
+EXPORT float f13_F_FPS_PDP(float p0, void* p1, struct S_PDP p2) { return p0; }
+EXPORT float f13_F_FPS_PPI(float p0, void* p1, struct S_PPI p2) { return p0; }
+EXPORT float f13_F_FPS_PPF(float p0, void* p1, struct S_PPF p2) { return p0; }
+EXPORT float f13_F_FPS_PPD(float p0, void* p1, struct S_PPD p2) { return p0; }
+EXPORT float f13_F_FPS_PPP(float p0, void* p1, struct S_PPP p2) { return p0; }
+EXPORT float f13_F_FSI_I(float p0, struct S_I p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_F(float p0, struct S_F p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_D(float p0, struct S_D p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_P(float p0, struct S_P p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_II(float p0, struct S_II p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_IF(float p0, struct S_IF p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_ID(float p0, struct S_ID p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_IP(float p0, struct S_IP p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_FI(float p0, struct S_FI p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_FF(float p0, struct S_FF p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_FD(float p0, struct S_FD p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_FP(float p0, struct S_FP p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_DI(float p0, struct S_DI p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_DF(float p0, struct S_DF p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_DD(float p0, struct S_DD p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_DP(float p0, struct S_DP p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_PI(float p0, struct S_PI p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_PF(float p0, struct S_PF p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_PD(float p0, struct S_PD p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_PP(float p0, struct S_PP p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_III(float p0, struct S_III p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_IIF(float p0, struct S_IIF p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_IID(float p0, struct S_IID p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_IIP(float p0, struct S_IIP p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_IFI(float p0, struct S_IFI p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_IFF(float p0, struct S_IFF p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_IFD(float p0, struct S_IFD p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_IFP(float p0, struct S_IFP p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_IDI(float p0, struct S_IDI p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_IDF(float p0, struct S_IDF p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_IDD(float p0, struct S_IDD p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_IDP(float p0, struct S_IDP p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_IPI(float p0, struct S_IPI p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_IPF(float p0, struct S_IPF p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_IPD(float p0, struct S_IPD p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_IPP(float p0, struct S_IPP p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_FII(float p0, struct S_FII p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_FIF(float p0, struct S_FIF p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_FID(float p0, struct S_FID p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_FIP(float p0, struct S_FIP p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_FFI(float p0, struct S_FFI p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_FFF(float p0, struct S_FFF p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_FFD(float p0, struct S_FFD p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_FFP(float p0, struct S_FFP p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_FDI(float p0, struct S_FDI p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_FDF(float p0, struct S_FDF p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_FDD(float p0, struct S_FDD p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_FDP(float p0, struct S_FDP p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_FPI(float p0, struct S_FPI p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_FPF(float p0, struct S_FPF p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_FPD(float p0, struct S_FPD p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_FPP(float p0, struct S_FPP p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_DII(float p0, struct S_DII p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_DIF(float p0, struct S_DIF p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_DID(float p0, struct S_DID p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_DIP(float p0, struct S_DIP p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_DFI(float p0, struct S_DFI p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_DFF(float p0, struct S_DFF p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_DFD(float p0, struct S_DFD p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_DFP(float p0, struct S_DFP p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_DDI(float p0, struct S_DDI p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_DDF(float p0, struct S_DDF p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_DDD(float p0, struct S_DDD p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_DDP(float p0, struct S_DDP p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_DPI(float p0, struct S_DPI p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_DPF(float p0, struct S_DPF p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_DPD(float p0, struct S_DPD p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_DPP(float p0, struct S_DPP p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_PII(float p0, struct S_PII p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_PIF(float p0, struct S_PIF p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_PID(float p0, struct S_PID p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_PIP(float p0, struct S_PIP p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_PFI(float p0, struct S_PFI p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_PFF(float p0, struct S_PFF p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_PFD(float p0, struct S_PFD p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_PFP(float p0, struct S_PFP p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_PDI(float p0, struct S_PDI p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_PDF(float p0, struct S_PDF p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_PDD(float p0, struct S_PDD p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_PDP(float p0, struct S_PDP p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_PPI(float p0, struct S_PPI p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_PPF(float p0, struct S_PPF p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_PPD(float p0, struct S_PPD p1, int p2) { return p0; }
+EXPORT float f13_F_FSI_PPP(float p0, struct S_PPP p1, int p2) { return p0; }
+EXPORT float f13_F_FSF_I(float p0, struct S_I p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_F(float p0, struct S_F p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_D(float p0, struct S_D p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_P(float p0, struct S_P p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_II(float p0, struct S_II p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_IF(float p0, struct S_IF p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_ID(float p0, struct S_ID p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_IP(float p0, struct S_IP p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_FI(float p0, struct S_FI p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_FF(float p0, struct S_FF p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_FD(float p0, struct S_FD p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_FP(float p0, struct S_FP p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_DI(float p0, struct S_DI p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_DF(float p0, struct S_DF p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_DD(float p0, struct S_DD p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_DP(float p0, struct S_DP p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_PI(float p0, struct S_PI p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_PF(float p0, struct S_PF p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_PD(float p0, struct S_PD p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_PP(float p0, struct S_PP p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_III(float p0, struct S_III p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_IIF(float p0, struct S_IIF p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_IID(float p0, struct S_IID p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_IIP(float p0, struct S_IIP p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_IFI(float p0, struct S_IFI p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_IFF(float p0, struct S_IFF p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_IFD(float p0, struct S_IFD p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_IFP(float p0, struct S_IFP p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_IDI(float p0, struct S_IDI p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_IDF(float p0, struct S_IDF p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_IDD(float p0, struct S_IDD p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_IDP(float p0, struct S_IDP p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_IPI(float p0, struct S_IPI p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_IPF(float p0, struct S_IPF p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_IPD(float p0, struct S_IPD p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_IPP(float p0, struct S_IPP p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_FII(float p0, struct S_FII p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_FIF(float p0, struct S_FIF p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_FID(float p0, struct S_FID p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_FIP(float p0, struct S_FIP p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_FFI(float p0, struct S_FFI p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_FFF(float p0, struct S_FFF p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_FFD(float p0, struct S_FFD p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_FFP(float p0, struct S_FFP p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_FDI(float p0, struct S_FDI p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_FDF(float p0, struct S_FDF p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_FDD(float p0, struct S_FDD p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_FDP(float p0, struct S_FDP p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_FPI(float p0, struct S_FPI p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_FPF(float p0, struct S_FPF p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_FPD(float p0, struct S_FPD p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_FPP(float p0, struct S_FPP p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_DII(float p0, struct S_DII p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_DIF(float p0, struct S_DIF p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_DID(float p0, struct S_DID p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_DIP(float p0, struct S_DIP p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_DFI(float p0, struct S_DFI p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_DFF(float p0, struct S_DFF p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_DFD(float p0, struct S_DFD p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_DFP(float p0, struct S_DFP p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_DDI(float p0, struct S_DDI p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_DDF(float p0, struct S_DDF p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_DDD(float p0, struct S_DDD p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_DDP(float p0, struct S_DDP p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_DPI(float p0, struct S_DPI p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_DPF(float p0, struct S_DPF p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_DPD(float p0, struct S_DPD p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_DPP(float p0, struct S_DPP p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_PII(float p0, struct S_PII p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_PIF(float p0, struct S_PIF p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_PID(float p0, struct S_PID p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_PIP(float p0, struct S_PIP p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_PFI(float p0, struct S_PFI p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_PFF(float p0, struct S_PFF p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_PFD(float p0, struct S_PFD p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_PFP(float p0, struct S_PFP p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_PDI(float p0, struct S_PDI p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_PDF(float p0, struct S_PDF p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_PDD(float p0, struct S_PDD p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_PDP(float p0, struct S_PDP p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_PPI(float p0, struct S_PPI p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_PPF(float p0, struct S_PPF p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_PPD(float p0, struct S_PPD p1, float p2) { return p0; }
+EXPORT float f13_F_FSF_PPP(float p0, struct S_PPP p1, float p2) { return p0; }
+EXPORT float f13_F_FSD_I(float p0, struct S_I p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_F(float p0, struct S_F p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_D(float p0, struct S_D p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_P(float p0, struct S_P p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_II(float p0, struct S_II p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_IF(float p0, struct S_IF p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_ID(float p0, struct S_ID p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_IP(float p0, struct S_IP p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_FI(float p0, struct S_FI p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_FF(float p0, struct S_FF p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_FD(float p0, struct S_FD p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_FP(float p0, struct S_FP p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_DI(float p0, struct S_DI p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_DF(float p0, struct S_DF p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_DD(float p0, struct S_DD p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_DP(float p0, struct S_DP p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_PI(float p0, struct S_PI p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_PF(float p0, struct S_PF p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_PD(float p0, struct S_PD p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_PP(float p0, struct S_PP p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_III(float p0, struct S_III p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_IIF(float p0, struct S_IIF p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_IID(float p0, struct S_IID p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_IIP(float p0, struct S_IIP p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_IFI(float p0, struct S_IFI p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_IFF(float p0, struct S_IFF p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_IFD(float p0, struct S_IFD p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_IFP(float p0, struct S_IFP p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_IDI(float p0, struct S_IDI p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_IDF(float p0, struct S_IDF p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_IDD(float p0, struct S_IDD p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_IDP(float p0, struct S_IDP p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_IPI(float p0, struct S_IPI p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_IPF(float p0, struct S_IPF p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_IPD(float p0, struct S_IPD p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_IPP(float p0, struct S_IPP p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_FII(float p0, struct S_FII p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_FIF(float p0, struct S_FIF p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_FID(float p0, struct S_FID p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_FIP(float p0, struct S_FIP p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_FFI(float p0, struct S_FFI p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_FFF(float p0, struct S_FFF p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_FFD(float p0, struct S_FFD p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_FFP(float p0, struct S_FFP p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_FDI(float p0, struct S_FDI p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_FDF(float p0, struct S_FDF p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_FDD(float p0, struct S_FDD p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_FDP(float p0, struct S_FDP p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_FPI(float p0, struct S_FPI p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_FPF(float p0, struct S_FPF p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_FPD(float p0, struct S_FPD p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_FPP(float p0, struct S_FPP p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_DII(float p0, struct S_DII p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_DIF(float p0, struct S_DIF p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_DID(float p0, struct S_DID p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_DIP(float p0, struct S_DIP p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_DFI(float p0, struct S_DFI p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_DFF(float p0, struct S_DFF p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_DFD(float p0, struct S_DFD p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_DFP(float p0, struct S_DFP p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_DDI(float p0, struct S_DDI p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_DDF(float p0, struct S_DDF p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_DDD(float p0, struct S_DDD p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_DDP(float p0, struct S_DDP p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_DPI(float p0, struct S_DPI p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_DPF(float p0, struct S_DPF p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_DPD(float p0, struct S_DPD p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_DPP(float p0, struct S_DPP p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_PII(float p0, struct S_PII p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_PIF(float p0, struct S_PIF p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_PID(float p0, struct S_PID p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_PIP(float p0, struct S_PIP p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_PFI(float p0, struct S_PFI p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_PFF(float p0, struct S_PFF p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_PFD(float p0, struct S_PFD p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_PFP(float p0, struct S_PFP p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_PDI(float p0, struct S_PDI p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_PDF(float p0, struct S_PDF p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_PDD(float p0, struct S_PDD p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_PDP(float p0, struct S_PDP p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_PPI(float p0, struct S_PPI p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_PPF(float p0, struct S_PPF p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_PPD(float p0, struct S_PPD p1, double p2) { return p0; }
+EXPORT float f13_F_FSD_PPP(float p0, struct S_PPP p1, double p2) { return p0; }
+EXPORT float f13_F_FSP_I(float p0, struct S_I p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_F(float p0, struct S_F p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_D(float p0, struct S_D p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_P(float p0, struct S_P p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_II(float p0, struct S_II p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_IF(float p0, struct S_IF p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_ID(float p0, struct S_ID p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_IP(float p0, struct S_IP p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_FI(float p0, struct S_FI p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_FF(float p0, struct S_FF p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_FD(float p0, struct S_FD p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_FP(float p0, struct S_FP p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_DI(float p0, struct S_DI p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_DF(float p0, struct S_DF p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_DD(float p0, struct S_DD p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_DP(float p0, struct S_DP p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_PI(float p0, struct S_PI p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_PF(float p0, struct S_PF p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_PD(float p0, struct S_PD p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_PP(float p0, struct S_PP p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_III(float p0, struct S_III p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_IIF(float p0, struct S_IIF p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_IID(float p0, struct S_IID p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_IIP(float p0, struct S_IIP p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_IFI(float p0, struct S_IFI p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_IFF(float p0, struct S_IFF p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_IFD(float p0, struct S_IFD p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_IFP(float p0, struct S_IFP p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_IDI(float p0, struct S_IDI p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_IDF(float p0, struct S_IDF p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_IDD(float p0, struct S_IDD p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_IDP(float p0, struct S_IDP p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_IPI(float p0, struct S_IPI p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_IPF(float p0, struct S_IPF p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_IPD(float p0, struct S_IPD p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_IPP(float p0, struct S_IPP p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_FII(float p0, struct S_FII p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_FIF(float p0, struct S_FIF p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_FID(float p0, struct S_FID p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_FIP(float p0, struct S_FIP p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_FFI(float p0, struct S_FFI p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_FFF(float p0, struct S_FFF p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_FFD(float p0, struct S_FFD p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_FFP(float p0, struct S_FFP p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_FDI(float p0, struct S_FDI p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_FDF(float p0, struct S_FDF p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_FDD(float p0, struct S_FDD p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_FDP(float p0, struct S_FDP p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_FPI(float p0, struct S_FPI p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_FPF(float p0, struct S_FPF p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_FPD(float p0, struct S_FPD p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_FPP(float p0, struct S_FPP p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_DII(float p0, struct S_DII p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_DIF(float p0, struct S_DIF p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_DID(float p0, struct S_DID p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_DIP(float p0, struct S_DIP p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_DFI(float p0, struct S_DFI p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_DFF(float p0, struct S_DFF p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_DFD(float p0, struct S_DFD p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_DFP(float p0, struct S_DFP p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_DDI(float p0, struct S_DDI p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_DDF(float p0, struct S_DDF p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_DDD(float p0, struct S_DDD p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_DDP(float p0, struct S_DDP p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_DPI(float p0, struct S_DPI p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_DPF(float p0, struct S_DPF p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_DPD(float p0, struct S_DPD p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_DPP(float p0, struct S_DPP p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_PII(float p0, struct S_PII p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_PIF(float p0, struct S_PIF p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_PID(float p0, struct S_PID p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_PIP(float p0, struct S_PIP p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_PFI(float p0, struct S_PFI p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_PFF(float p0, struct S_PFF p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_PFD(float p0, struct S_PFD p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_PFP(float p0, struct S_PFP p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_PDI(float p0, struct S_PDI p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_PDF(float p0, struct S_PDF p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_PDD(float p0, struct S_PDD p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_PDP(float p0, struct S_PDP p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_PPI(float p0, struct S_PPI p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_PPF(float p0, struct S_PPF p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_PPD(float p0, struct S_PPD p1, void* p2) { return p0; }
+EXPORT float f13_F_FSP_PPP(float p0, struct S_PPP p1, void* p2) { return p0; }
+EXPORT float f13_F_FSS_I(float p0, struct S_I p1, struct S_I p2) { return p0; }
+EXPORT float f13_F_FSS_F(float p0, struct S_F p1, struct S_F p2) { return p0; }
+EXPORT float f13_F_FSS_D(float p0, struct S_D p1, struct S_D p2) { return p0; }
+EXPORT float f13_F_FSS_P(float p0, struct S_P p1, struct S_P p2) { return p0; }
+EXPORT float f13_F_FSS_II(float p0, struct S_II p1, struct S_II p2) { return p0; }
+EXPORT float f13_F_FSS_IF(float p0, struct S_IF p1, struct S_IF p2) { return p0; }
+EXPORT float f13_F_FSS_ID(float p0, struct S_ID p1, struct S_ID p2) { return p0; }
+EXPORT float f13_F_FSS_IP(float p0, struct S_IP p1, struct S_IP p2) { return p0; }
+EXPORT float f13_F_FSS_FI(float p0, struct S_FI p1, struct S_FI p2) { return p0; }
+EXPORT float f13_F_FSS_FF(float p0, struct S_FF p1, struct S_FF p2) { return p0; }
+EXPORT float f13_F_FSS_FD(float p0, struct S_FD p1, struct S_FD p2) { return p0; }
+EXPORT float f13_F_FSS_FP(float p0, struct S_FP p1, struct S_FP p2) { return p0; }
+EXPORT float f13_F_FSS_DI(float p0, struct S_DI p1, struct S_DI p2) { return p0; }
+EXPORT float f13_F_FSS_DF(float p0, struct S_DF p1, struct S_DF p2) { return p0; }
+EXPORT float f13_F_FSS_DD(float p0, struct S_DD p1, struct S_DD p2) { return p0; }
+EXPORT float f13_F_FSS_DP(float p0, struct S_DP p1, struct S_DP p2) { return p0; }
+EXPORT float f13_F_FSS_PI(float p0, struct S_PI p1, struct S_PI p2) { return p0; }
+EXPORT float f13_F_FSS_PF(float p0, struct S_PF p1, struct S_PF p2) { return p0; }
+EXPORT float f13_F_FSS_PD(float p0, struct S_PD p1, struct S_PD p2) { return p0; }
+EXPORT float f13_F_FSS_PP(float p0, struct S_PP p1, struct S_PP p2) { return p0; }
+EXPORT float f13_F_FSS_III(float p0, struct S_III p1, struct S_III p2) { return p0; }
+EXPORT float f13_F_FSS_IIF(float p0, struct S_IIF p1, struct S_IIF p2) { return p0; }
+EXPORT float f13_F_FSS_IID(float p0, struct S_IID p1, struct S_IID p2) { return p0; }
+EXPORT float f13_F_FSS_IIP(float p0, struct S_IIP p1, struct S_IIP p2) { return p0; }
+EXPORT float f13_F_FSS_IFI(float p0, struct S_IFI p1, struct S_IFI p2) { return p0; }
+EXPORT float f13_F_FSS_IFF(float p0, struct S_IFF p1, struct S_IFF p2) { return p0; }
+EXPORT float f13_F_FSS_IFD(float p0, struct S_IFD p1, struct S_IFD p2) { return p0; }
+EXPORT float f13_F_FSS_IFP(float p0, struct S_IFP p1, struct S_IFP p2) { return p0; }
+EXPORT float f13_F_FSS_IDI(float p0, struct S_IDI p1, struct S_IDI p2) { return p0; }
+EXPORT float f13_F_FSS_IDF(float p0, struct S_IDF p1, struct S_IDF p2) { return p0; }
+EXPORT float f13_F_FSS_IDD(float p0, struct S_IDD p1, struct S_IDD p2) { return p0; }
+EXPORT float f14_F_FSS_IDP(float p0, struct S_IDP p1, struct S_IDP p2) { return p0; }
+EXPORT float f14_F_FSS_IPI(float p0, struct S_IPI p1, struct S_IPI p2) { return p0; }
+EXPORT float f14_F_FSS_IPF(float p0, struct S_IPF p1, struct S_IPF p2) { return p0; }
+EXPORT float f14_F_FSS_IPD(float p0, struct S_IPD p1, struct S_IPD p2) { return p0; }
+EXPORT float f14_F_FSS_IPP(float p0, struct S_IPP p1, struct S_IPP p2) { return p0; }
+EXPORT float f14_F_FSS_FII(float p0, struct S_FII p1, struct S_FII p2) { return p0; }
+EXPORT float f14_F_FSS_FIF(float p0, struct S_FIF p1, struct S_FIF p2) { return p0; }
+EXPORT float f14_F_FSS_FID(float p0, struct S_FID p1, struct S_FID p2) { return p0; }
+EXPORT float f14_F_FSS_FIP(float p0, struct S_FIP p1, struct S_FIP p2) { return p0; }
+EXPORT float f14_F_FSS_FFI(float p0, struct S_FFI p1, struct S_FFI p2) { return p0; }
+EXPORT float f14_F_FSS_FFF(float p0, struct S_FFF p1, struct S_FFF p2) { return p0; }
+EXPORT float f14_F_FSS_FFD(float p0, struct S_FFD p1, struct S_FFD p2) { return p0; }
+EXPORT float f14_F_FSS_FFP(float p0, struct S_FFP p1, struct S_FFP p2) { return p0; }
+EXPORT float f14_F_FSS_FDI(float p0, struct S_FDI p1, struct S_FDI p2) { return p0; }
+EXPORT float f14_F_FSS_FDF(float p0, struct S_FDF p1, struct S_FDF p2) { return p0; }
+EXPORT float f14_F_FSS_FDD(float p0, struct S_FDD p1, struct S_FDD p2) { return p0; }
+EXPORT float f14_F_FSS_FDP(float p0, struct S_FDP p1, struct S_FDP p2) { return p0; }
+EXPORT float f14_F_FSS_FPI(float p0, struct S_FPI p1, struct S_FPI p2) { return p0; }
+EXPORT float f14_F_FSS_FPF(float p0, struct S_FPF p1, struct S_FPF p2) { return p0; }
+EXPORT float f14_F_FSS_FPD(float p0, struct S_FPD p1, struct S_FPD p2) { return p0; }
+EXPORT float f14_F_FSS_FPP(float p0, struct S_FPP p1, struct S_FPP p2) { return p0; }
+EXPORT float f14_F_FSS_DII(float p0, struct S_DII p1, struct S_DII p2) { return p0; }
+EXPORT float f14_F_FSS_DIF(float p0, struct S_DIF p1, struct S_DIF p2) { return p0; }
+EXPORT float f14_F_FSS_DID(float p0, struct S_DID p1, struct S_DID p2) { return p0; }
+EXPORT float f14_F_FSS_DIP(float p0, struct S_DIP p1, struct S_DIP p2) { return p0; }
+EXPORT float f14_F_FSS_DFI(float p0, struct S_DFI p1, struct S_DFI p2) { return p0; }
+EXPORT float f14_F_FSS_DFF(float p0, struct S_DFF p1, struct S_DFF p2) { return p0; }
+EXPORT float f14_F_FSS_DFD(float p0, struct S_DFD p1, struct S_DFD p2) { return p0; }
+EXPORT float f14_F_FSS_DFP(float p0, struct S_DFP p1, struct S_DFP p2) { return p0; }
+EXPORT float f14_F_FSS_DDI(float p0, struct S_DDI p1, struct S_DDI p2) { return p0; }
+EXPORT float f14_F_FSS_DDF(float p0, struct S_DDF p1, struct S_DDF p2) { return p0; }
+EXPORT float f14_F_FSS_DDD(float p0, struct S_DDD p1, struct S_DDD p2) { return p0; }
+EXPORT float f14_F_FSS_DDP(float p0, struct S_DDP p1, struct S_DDP p2) { return p0; }
+EXPORT float f14_F_FSS_DPI(float p0, struct S_DPI p1, struct S_DPI p2) { return p0; }
+EXPORT float f14_F_FSS_DPF(float p0, struct S_DPF p1, struct S_DPF p2) { return p0; }
+EXPORT float f14_F_FSS_DPD(float p0, struct S_DPD p1, struct S_DPD p2) { return p0; }
+EXPORT float f14_F_FSS_DPP(float p0, struct S_DPP p1, struct S_DPP p2) { return p0; }
+EXPORT float f14_F_FSS_PII(float p0, struct S_PII p1, struct S_PII p2) { return p0; }
+EXPORT float f14_F_FSS_PIF(float p0, struct S_PIF p1, struct S_PIF p2) { return p0; }
+EXPORT float f14_F_FSS_PID(float p0, struct S_PID p1, struct S_PID p2) { return p0; }
+EXPORT float f14_F_FSS_PIP(float p0, struct S_PIP p1, struct S_PIP p2) { return p0; }
+EXPORT float f14_F_FSS_PFI(float p0, struct S_PFI p1, struct S_PFI p2) { return p0; }
+EXPORT float f14_F_FSS_PFF(float p0, struct S_PFF p1, struct S_PFF p2) { return p0; }
+EXPORT float f14_F_FSS_PFD(float p0, struct S_PFD p1, struct S_PFD p2) { return p0; }
+EXPORT float f14_F_FSS_PFP(float p0, struct S_PFP p1, struct S_PFP p2) { return p0; }
+EXPORT float f14_F_FSS_PDI(float p0, struct S_PDI p1, struct S_PDI p2) { return p0; }
+EXPORT float f14_F_FSS_PDF(float p0, struct S_PDF p1, struct S_PDF p2) { return p0; }
+EXPORT float f14_F_FSS_PDD(float p0, struct S_PDD p1, struct S_PDD p2) { return p0; }
+EXPORT float f14_F_FSS_PDP(float p0, struct S_PDP p1, struct S_PDP p2) { return p0; }
+EXPORT float f14_F_FSS_PPI(float p0, struct S_PPI p1, struct S_PPI p2) { return p0; }
+EXPORT float f14_F_FSS_PPF(float p0, struct S_PPF p1, struct S_PPF p2) { return p0; }
+EXPORT float f14_F_FSS_PPD(float p0, struct S_PPD p1, struct S_PPD p2) { return p0; }
+EXPORT float f14_F_FSS_PPP(float p0, struct S_PPP p1, struct S_PPP p2) { return p0; }
+EXPORT double f14_D_DII_(double p0, int p1, int p2) { return p0; }
+EXPORT double f14_D_DIF_(double p0, int p1, float p2) { return p0; }
+EXPORT double f14_D_DID_(double p0, int p1, double p2) { return p0; }
+EXPORT double f14_D_DIP_(double p0, int p1, void* p2) { return p0; }
+EXPORT double f14_D_DIS_I(double p0, int p1, struct S_I p2) { return p0; }
+EXPORT double f14_D_DIS_F(double p0, int p1, struct S_F p2) { return p0; }
+EXPORT double f14_D_DIS_D(double p0, int p1, struct S_D p2) { return p0; }
+EXPORT double f14_D_DIS_P(double p0, int p1, struct S_P p2) { return p0; }
+EXPORT double f14_D_DIS_II(double p0, int p1, struct S_II p2) { return p0; }
+EXPORT double f14_D_DIS_IF(double p0, int p1, struct S_IF p2) { return p0; }
+EXPORT double f14_D_DIS_ID(double p0, int p1, struct S_ID p2) { return p0; }
+EXPORT double f14_D_DIS_IP(double p0, int p1, struct S_IP p2) { return p0; }
+EXPORT double f14_D_DIS_FI(double p0, int p1, struct S_FI p2) { return p0; }
+EXPORT double f14_D_DIS_FF(double p0, int p1, struct S_FF p2) { return p0; }
+EXPORT double f14_D_DIS_FD(double p0, int p1, struct S_FD p2) { return p0; }
+EXPORT double f14_D_DIS_FP(double p0, int p1, struct S_FP p2) { return p0; }
+EXPORT double f14_D_DIS_DI(double p0, int p1, struct S_DI p2) { return p0; }
+EXPORT double f14_D_DIS_DF(double p0, int p1, struct S_DF p2) { return p0; }
+EXPORT double f14_D_DIS_DD(double p0, int p1, struct S_DD p2) { return p0; }
+EXPORT double f14_D_DIS_DP(double p0, int p1, struct S_DP p2) { return p0; }
+EXPORT double f14_D_DIS_PI(double p0, int p1, struct S_PI p2) { return p0; }
+EXPORT double f14_D_DIS_PF(double p0, int p1, struct S_PF p2) { return p0; }
+EXPORT double f14_D_DIS_PD(double p0, int p1, struct S_PD p2) { return p0; }
+EXPORT double f14_D_DIS_PP(double p0, int p1, struct S_PP p2) { return p0; }
+EXPORT double f14_D_DIS_III(double p0, int p1, struct S_III p2) { return p0; }
+EXPORT double f14_D_DIS_IIF(double p0, int p1, struct S_IIF p2) { return p0; }
+EXPORT double f14_D_DIS_IID(double p0, int p1, struct S_IID p2) { return p0; }
+EXPORT double f14_D_DIS_IIP(double p0, int p1, struct S_IIP p2) { return p0; }
+EXPORT double f14_D_DIS_IFI(double p0, int p1, struct S_IFI p2) { return p0; }
+EXPORT double f14_D_DIS_IFF(double p0, int p1, struct S_IFF p2) { return p0; }
+EXPORT double f14_D_DIS_IFD(double p0, int p1, struct S_IFD p2) { return p0; }
+EXPORT double f14_D_DIS_IFP(double p0, int p1, struct S_IFP p2) { return p0; }
+EXPORT double f14_D_DIS_IDI(double p0, int p1, struct S_IDI p2) { return p0; }
+EXPORT double f14_D_DIS_IDF(double p0, int p1, struct S_IDF p2) { return p0; }
+EXPORT double f14_D_DIS_IDD(double p0, int p1, struct S_IDD p2) { return p0; }
+EXPORT double f14_D_DIS_IDP(double p0, int p1, struct S_IDP p2) { return p0; }
+EXPORT double f14_D_DIS_IPI(double p0, int p1, struct S_IPI p2) { return p0; }
+EXPORT double f14_D_DIS_IPF(double p0, int p1, struct S_IPF p2) { return p0; }
+EXPORT double f14_D_DIS_IPD(double p0, int p1, struct S_IPD p2) { return p0; }
+EXPORT double f14_D_DIS_IPP(double p0, int p1, struct S_IPP p2) { return p0; }
+EXPORT double f14_D_DIS_FII(double p0, int p1, struct S_FII p2) { return p0; }
+EXPORT double f14_D_DIS_FIF(double p0, int p1, struct S_FIF p2) { return p0; }
+EXPORT double f14_D_DIS_FID(double p0, int p1, struct S_FID p2) { return p0; }
+EXPORT double f14_D_DIS_FIP(double p0, int p1, struct S_FIP p2) { return p0; }
+EXPORT double f14_D_DIS_FFI(double p0, int p1, struct S_FFI p2) { return p0; }
+EXPORT double f14_D_DIS_FFF(double p0, int p1, struct S_FFF p2) { return p0; }
+EXPORT double f14_D_DIS_FFD(double p0, int p1, struct S_FFD p2) { return p0; }
+EXPORT double f14_D_DIS_FFP(double p0, int p1, struct S_FFP p2) { return p0; }
+EXPORT double f14_D_DIS_FDI(double p0, int p1, struct S_FDI p2) { return p0; }
+EXPORT double f14_D_DIS_FDF(double p0, int p1, struct S_FDF p2) { return p0; }
+EXPORT double f14_D_DIS_FDD(double p0, int p1, struct S_FDD p2) { return p0; }
+EXPORT double f14_D_DIS_FDP(double p0, int p1, struct S_FDP p2) { return p0; }
+EXPORT double f14_D_DIS_FPI(double p0, int p1, struct S_FPI p2) { return p0; }
+EXPORT double f14_D_DIS_FPF(double p0, int p1, struct S_FPF p2) { return p0; }
+EXPORT double f14_D_DIS_FPD(double p0, int p1, struct S_FPD p2) { return p0; }
+EXPORT double f14_D_DIS_FPP(double p0, int p1, struct S_FPP p2) { return p0; }
+EXPORT double f14_D_DIS_DII(double p0, int p1, struct S_DII p2) { return p0; }
+EXPORT double f14_D_DIS_DIF(double p0, int p1, struct S_DIF p2) { return p0; }
+EXPORT double f14_D_DIS_DID(double p0, int p1, struct S_DID p2) { return p0; }
+EXPORT double f14_D_DIS_DIP(double p0, int p1, struct S_DIP p2) { return p0; }
+EXPORT double f14_D_DIS_DFI(double p0, int p1, struct S_DFI p2) { return p0; }
+EXPORT double f14_D_DIS_DFF(double p0, int p1, struct S_DFF p2) { return p0; }
+EXPORT double f14_D_DIS_DFD(double p0, int p1, struct S_DFD p2) { return p0; }
+EXPORT double f14_D_DIS_DFP(double p0, int p1, struct S_DFP p2) { return p0; }
+EXPORT double f14_D_DIS_DDI(double p0, int p1, struct S_DDI p2) { return p0; }
+EXPORT double f14_D_DIS_DDF(double p0, int p1, struct S_DDF p2) { return p0; }
+EXPORT double f14_D_DIS_DDD(double p0, int p1, struct S_DDD p2) { return p0; }
+EXPORT double f14_D_DIS_DDP(double p0, int p1, struct S_DDP p2) { return p0; }
+EXPORT double f14_D_DIS_DPI(double p0, int p1, struct S_DPI p2) { return p0; }
+EXPORT double f14_D_DIS_DPF(double p0, int p1, struct S_DPF p2) { return p0; }
+EXPORT double f14_D_DIS_DPD(double p0, int p1, struct S_DPD p2) { return p0; }
+EXPORT double f14_D_DIS_DPP(double p0, int p1, struct S_DPP p2) { return p0; }
+EXPORT double f14_D_DIS_PII(double p0, int p1, struct S_PII p2) { return p0; }
+EXPORT double f14_D_DIS_PIF(double p0, int p1, struct S_PIF p2) { return p0; }
+EXPORT double f14_D_DIS_PID(double p0, int p1, struct S_PID p2) { return p0; }
+EXPORT double f14_D_DIS_PIP(double p0, int p1, struct S_PIP p2) { return p0; }
+EXPORT double f14_D_DIS_PFI(double p0, int p1, struct S_PFI p2) { return p0; }
+EXPORT double f14_D_DIS_PFF(double p0, int p1, struct S_PFF p2) { return p0; }
+EXPORT double f14_D_DIS_PFD(double p0, int p1, struct S_PFD p2) { return p0; }
+EXPORT double f14_D_DIS_PFP(double p0, int p1, struct S_PFP p2) { return p0; }
+EXPORT double f14_D_DIS_PDI(double p0, int p1, struct S_PDI p2) { return p0; }
+EXPORT double f14_D_DIS_PDF(double p0, int p1, struct S_PDF p2) { return p0; }
+EXPORT double f14_D_DIS_PDD(double p0, int p1, struct S_PDD p2) { return p0; }
+EXPORT double f14_D_DIS_PDP(double p0, int p1, struct S_PDP p2) { return p0; }
+EXPORT double f14_D_DIS_PPI(double p0, int p1, struct S_PPI p2) { return p0; }
+EXPORT double f14_D_DIS_PPF(double p0, int p1, struct S_PPF p2) { return p0; }
+EXPORT double f14_D_DIS_PPD(double p0, int p1, struct S_PPD p2) { return p0; }
+EXPORT double f14_D_DIS_PPP(double p0, int p1, struct S_PPP p2) { return p0; }
+EXPORT double f14_D_DFI_(double p0, float p1, int p2) { return p0; }
+EXPORT double f14_D_DFF_(double p0, float p1, float p2) { return p0; }
+EXPORT double f14_D_DFD_(double p0, float p1, double p2) { return p0; }
+EXPORT double f14_D_DFP_(double p0, float p1, void* p2) { return p0; }
+EXPORT double f14_D_DFS_I(double p0, float p1, struct S_I p2) { return p0; }
+EXPORT double f14_D_DFS_F(double p0, float p1, struct S_F p2) { return p0; }
+EXPORT double f14_D_DFS_D(double p0, float p1, struct S_D p2) { return p0; }
+EXPORT double f14_D_DFS_P(double p0, float p1, struct S_P p2) { return p0; }
+EXPORT double f14_D_DFS_II(double p0, float p1, struct S_II p2) { return p0; }
+EXPORT double f14_D_DFS_IF(double p0, float p1, struct S_IF p2) { return p0; }
+EXPORT double f14_D_DFS_ID(double p0, float p1, struct S_ID p2) { return p0; }
+EXPORT double f14_D_DFS_IP(double p0, float p1, struct S_IP p2) { return p0; }
+EXPORT double f14_D_DFS_FI(double p0, float p1, struct S_FI p2) { return p0; }
+EXPORT double f14_D_DFS_FF(double p0, float p1, struct S_FF p2) { return p0; }
+EXPORT double f14_D_DFS_FD(double p0, float p1, struct S_FD p2) { return p0; }
+EXPORT double f14_D_DFS_FP(double p0, float p1, struct S_FP p2) { return p0; }
+EXPORT double f14_D_DFS_DI(double p0, float p1, struct S_DI p2) { return p0; }
+EXPORT double f14_D_DFS_DF(double p0, float p1, struct S_DF p2) { return p0; }
+EXPORT double f14_D_DFS_DD(double p0, float p1, struct S_DD p2) { return p0; }
+EXPORT double f14_D_DFS_DP(double p0, float p1, struct S_DP p2) { return p0; }
+EXPORT double f14_D_DFS_PI(double p0, float p1, struct S_PI p2) { return p0; }
+EXPORT double f14_D_DFS_PF(double p0, float p1, struct S_PF p2) { return p0; }
+EXPORT double f14_D_DFS_PD(double p0, float p1, struct S_PD p2) { return p0; }
+EXPORT double f14_D_DFS_PP(double p0, float p1, struct S_PP p2) { return p0; }
+EXPORT double f14_D_DFS_III(double p0, float p1, struct S_III p2) { return p0; }
+EXPORT double f14_D_DFS_IIF(double p0, float p1, struct S_IIF p2) { return p0; }
+EXPORT double f14_D_DFS_IID(double p0, float p1, struct S_IID p2) { return p0; }
+EXPORT double f14_D_DFS_IIP(double p0, float p1, struct S_IIP p2) { return p0; }
+EXPORT double f14_D_DFS_IFI(double p0, float p1, struct S_IFI p2) { return p0; }
+EXPORT double f14_D_DFS_IFF(double p0, float p1, struct S_IFF p2) { return p0; }
+EXPORT double f14_D_DFS_IFD(double p0, float p1, struct S_IFD p2) { return p0; }
+EXPORT double f14_D_DFS_IFP(double p0, float p1, struct S_IFP p2) { return p0; }
+EXPORT double f14_D_DFS_IDI(double p0, float p1, struct S_IDI p2) { return p0; }
+EXPORT double f14_D_DFS_IDF(double p0, float p1, struct S_IDF p2) { return p0; }
+EXPORT double f14_D_DFS_IDD(double p0, float p1, struct S_IDD p2) { return p0; }
+EXPORT double f14_D_DFS_IDP(double p0, float p1, struct S_IDP p2) { return p0; }
+EXPORT double f14_D_DFS_IPI(double p0, float p1, struct S_IPI p2) { return p0; }
+EXPORT double f14_D_DFS_IPF(double p0, float p1, struct S_IPF p2) { return p0; }
+EXPORT double f14_D_DFS_IPD(double p0, float p1, struct S_IPD p2) { return p0; }
+EXPORT double f14_D_DFS_IPP(double p0, float p1, struct S_IPP p2) { return p0; }
+EXPORT double f14_D_DFS_FII(double p0, float p1, struct S_FII p2) { return p0; }
+EXPORT double f14_D_DFS_FIF(double p0, float p1, struct S_FIF p2) { return p0; }
+EXPORT double f14_D_DFS_FID(double p0, float p1, struct S_FID p2) { return p0; }
+EXPORT double f14_D_DFS_FIP(double p0, float p1, struct S_FIP p2) { return p0; }
+EXPORT double f14_D_DFS_FFI(double p0, float p1, struct S_FFI p2) { return p0; }
+EXPORT double f14_D_DFS_FFF(double p0, float p1, struct S_FFF p2) { return p0; }
+EXPORT double f14_D_DFS_FFD(double p0, float p1, struct S_FFD p2) { return p0; }
+EXPORT double f14_D_DFS_FFP(double p0, float p1, struct S_FFP p2) { return p0; }
+EXPORT double f14_D_DFS_FDI(double p0, float p1, struct S_FDI p2) { return p0; }
+EXPORT double f14_D_DFS_FDF(double p0, float p1, struct S_FDF p2) { return p0; }
+EXPORT double f14_D_DFS_FDD(double p0, float p1, struct S_FDD p2) { return p0; }
+EXPORT double f14_D_DFS_FDP(double p0, float p1, struct S_FDP p2) { return p0; }
+EXPORT double f14_D_DFS_FPI(double p0, float p1, struct S_FPI p2) { return p0; }
+EXPORT double f14_D_DFS_FPF(double p0, float p1, struct S_FPF p2) { return p0; }
+EXPORT double f14_D_DFS_FPD(double p0, float p1, struct S_FPD p2) { return p0; }
+EXPORT double f14_D_DFS_FPP(double p0, float p1, struct S_FPP p2) { return p0; }
+EXPORT double f14_D_DFS_DII(double p0, float p1, struct S_DII p2) { return p0; }
+EXPORT double f14_D_DFS_DIF(double p0, float p1, struct S_DIF p2) { return p0; }
+EXPORT double f14_D_DFS_DID(double p0, float p1, struct S_DID p2) { return p0; }
+EXPORT double f14_D_DFS_DIP(double p0, float p1, struct S_DIP p2) { return p0; }
+EXPORT double f14_D_DFS_DFI(double p0, float p1, struct S_DFI p2) { return p0; }
+EXPORT double f14_D_DFS_DFF(double p0, float p1, struct S_DFF p2) { return p0; }
+EXPORT double f14_D_DFS_DFD(double p0, float p1, struct S_DFD p2) { return p0; }
+EXPORT double f14_D_DFS_DFP(double p0, float p1, struct S_DFP p2) { return p0; }
+EXPORT double f14_D_DFS_DDI(double p0, float p1, struct S_DDI p2) { return p0; }
+EXPORT double f14_D_DFS_DDF(double p0, float p1, struct S_DDF p2) { return p0; }
+EXPORT double f14_D_DFS_DDD(double p0, float p1, struct S_DDD p2) { return p0; }
+EXPORT double f14_D_DFS_DDP(double p0, float p1, struct S_DDP p2) { return p0; }
+EXPORT double f14_D_DFS_DPI(double p0, float p1, struct S_DPI p2) { return p0; }
+EXPORT double f14_D_DFS_DPF(double p0, float p1, struct S_DPF p2) { return p0; }
+EXPORT double f14_D_DFS_DPD(double p0, float p1, struct S_DPD p2) { return p0; }
+EXPORT double f14_D_DFS_DPP(double p0, float p1, struct S_DPP p2) { return p0; }
+EXPORT double f14_D_DFS_PII(double p0, float p1, struct S_PII p2) { return p0; }
+EXPORT double f14_D_DFS_PIF(double p0, float p1, struct S_PIF p2) { return p0; }
+EXPORT double f14_D_DFS_PID(double p0, float p1, struct S_PID p2) { return p0; }
+EXPORT double f14_D_DFS_PIP(double p0, float p1, struct S_PIP p2) { return p0; }
+EXPORT double f14_D_DFS_PFI(double p0, float p1, struct S_PFI p2) { return p0; }
+EXPORT double f14_D_DFS_PFF(double p0, float p1, struct S_PFF p2) { return p0; }
+EXPORT double f14_D_DFS_PFD(double p0, float p1, struct S_PFD p2) { return p0; }
+EXPORT double f14_D_DFS_PFP(double p0, float p1, struct S_PFP p2) { return p0; }
+EXPORT double f14_D_DFS_PDI(double p0, float p1, struct S_PDI p2) { return p0; }
+EXPORT double f14_D_DFS_PDF(double p0, float p1, struct S_PDF p2) { return p0; }
+EXPORT double f14_D_DFS_PDD(double p0, float p1, struct S_PDD p2) { return p0; }
+EXPORT double f14_D_DFS_PDP(double p0, float p1, struct S_PDP p2) { return p0; }
+EXPORT double f14_D_DFS_PPI(double p0, float p1, struct S_PPI p2) { return p0; }
+EXPORT double f14_D_DFS_PPF(double p0, float p1, struct S_PPF p2) { return p0; }
+EXPORT double f14_D_DFS_PPD(double p0, float p1, struct S_PPD p2) { return p0; }
+EXPORT double f14_D_DFS_PPP(double p0, float p1, struct S_PPP p2) { return p0; }
+EXPORT double f14_D_DDI_(double p0, double p1, int p2) { return p0; }
+EXPORT double f14_D_DDF_(double p0, double p1, float p2) { return p0; }
+EXPORT double f14_D_DDD_(double p0, double p1, double p2) { return p0; }
+EXPORT double f14_D_DDP_(double p0, double p1, void* p2) { return p0; }
+EXPORT double f14_D_DDS_I(double p0, double p1, struct S_I p2) { return p0; }
+EXPORT double f14_D_DDS_F(double p0, double p1, struct S_F p2) { return p0; }
+EXPORT double f14_D_DDS_D(double p0, double p1, struct S_D p2) { return p0; }
+EXPORT double f14_D_DDS_P(double p0, double p1, struct S_P p2) { return p0; }
+EXPORT double f14_D_DDS_II(double p0, double p1, struct S_II p2) { return p0; }
+EXPORT double f14_D_DDS_IF(double p0, double p1, struct S_IF p2) { return p0; }
+EXPORT double f14_D_DDS_ID(double p0, double p1, struct S_ID p2) { return p0; }
+EXPORT double f14_D_DDS_IP(double p0, double p1, struct S_IP p2) { return p0; }
+EXPORT double f14_D_DDS_FI(double p0, double p1, struct S_FI p2) { return p0; }
+EXPORT double f14_D_DDS_FF(double p0, double p1, struct S_FF p2) { return p0; }
+EXPORT double f14_D_DDS_FD(double p0, double p1, struct S_FD p2) { return p0; }
+EXPORT double f14_D_DDS_FP(double p0, double p1, struct S_FP p2) { return p0; }
+EXPORT double f14_D_DDS_DI(double p0, double p1, struct S_DI p2) { return p0; }
+EXPORT double f14_D_DDS_DF(double p0, double p1, struct S_DF p2) { return p0; }
+EXPORT double f14_D_DDS_DD(double p0, double p1, struct S_DD p2) { return p0; }
+EXPORT double f14_D_DDS_DP(double p0, double p1, struct S_DP p2) { return p0; }
+EXPORT double f14_D_DDS_PI(double p0, double p1, struct S_PI p2) { return p0; }
+EXPORT double f14_D_DDS_PF(double p0, double p1, struct S_PF p2) { return p0; }
+EXPORT double f14_D_DDS_PD(double p0, double p1, struct S_PD p2) { return p0; }
+EXPORT double f14_D_DDS_PP(double p0, double p1, struct S_PP p2) { return p0; }
+EXPORT double f14_D_DDS_III(double p0, double p1, struct S_III p2) { return p0; }
+EXPORT double f14_D_DDS_IIF(double p0, double p1, struct S_IIF p2) { return p0; }
+EXPORT double f14_D_DDS_IID(double p0, double p1, struct S_IID p2) { return p0; }
+EXPORT double f14_D_DDS_IIP(double p0, double p1, struct S_IIP p2) { return p0; }
+EXPORT double f14_D_DDS_IFI(double p0, double p1, struct S_IFI p2) { return p0; }
+EXPORT double f14_D_DDS_IFF(double p0, double p1, struct S_IFF p2) { return p0; }
+EXPORT double f14_D_DDS_IFD(double p0, double p1, struct S_IFD p2) { return p0; }
+EXPORT double f14_D_DDS_IFP(double p0, double p1, struct S_IFP p2) { return p0; }
+EXPORT double f14_D_DDS_IDI(double p0, double p1, struct S_IDI p2) { return p0; }
+EXPORT double f14_D_DDS_IDF(double p0, double p1, struct S_IDF p2) { return p0; }
+EXPORT double f14_D_DDS_IDD(double p0, double p1, struct S_IDD p2) { return p0; }
+EXPORT double f14_D_DDS_IDP(double p0, double p1, struct S_IDP p2) { return p0; }
+EXPORT double f14_D_DDS_IPI(double p0, double p1, struct S_IPI p2) { return p0; }
+EXPORT double f14_D_DDS_IPF(double p0, double p1, struct S_IPF p2) { return p0; }
+EXPORT double f14_D_DDS_IPD(double p0, double p1, struct S_IPD p2) { return p0; }
+EXPORT double f14_D_DDS_IPP(double p0, double p1, struct S_IPP p2) { return p0; }
+EXPORT double f14_D_DDS_FII(double p0, double p1, struct S_FII p2) { return p0; }
+EXPORT double f14_D_DDS_FIF(double p0, double p1, struct S_FIF p2) { return p0; }
+EXPORT double f14_D_DDS_FID(double p0, double p1, struct S_FID p2) { return p0; }
+EXPORT double f14_D_DDS_FIP(double p0, double p1, struct S_FIP p2) { return p0; }
+EXPORT double f14_D_DDS_FFI(double p0, double p1, struct S_FFI p2) { return p0; }
+EXPORT double f14_D_DDS_FFF(double p0, double p1, struct S_FFF p2) { return p0; }
+EXPORT double f14_D_DDS_FFD(double p0, double p1, struct S_FFD p2) { return p0; }
+EXPORT double f14_D_DDS_FFP(double p0, double p1, struct S_FFP p2) { return p0; }
+EXPORT double f14_D_DDS_FDI(double p0, double p1, struct S_FDI p2) { return p0; }
+EXPORT double f14_D_DDS_FDF(double p0, double p1, struct S_FDF p2) { return p0; }
+EXPORT double f14_D_DDS_FDD(double p0, double p1, struct S_FDD p2) { return p0; }
+EXPORT double f14_D_DDS_FDP(double p0, double p1, struct S_FDP p2) { return p0; }
+EXPORT double f14_D_DDS_FPI(double p0, double p1, struct S_FPI p2) { return p0; }
+EXPORT double f14_D_DDS_FPF(double p0, double p1, struct S_FPF p2) { return p0; }
+EXPORT double f14_D_DDS_FPD(double p0, double p1, struct S_FPD p2) { return p0; }
+EXPORT double f14_D_DDS_FPP(double p0, double p1, struct S_FPP p2) { return p0; }
+EXPORT double f14_D_DDS_DII(double p0, double p1, struct S_DII p2) { return p0; }
+EXPORT double f14_D_DDS_DIF(double p0, double p1, struct S_DIF p2) { return p0; }
+EXPORT double f14_D_DDS_DID(double p0, double p1, struct S_DID p2) { return p0; }
+EXPORT double f14_D_DDS_DIP(double p0, double p1, struct S_DIP p2) { return p0; }
+EXPORT double f14_D_DDS_DFI(double p0, double p1, struct S_DFI p2) { return p0; }
+EXPORT double f14_D_DDS_DFF(double p0, double p1, struct S_DFF p2) { return p0; }
+EXPORT double f14_D_DDS_DFD(double p0, double p1, struct S_DFD p2) { return p0; }
+EXPORT double f14_D_DDS_DFP(double p0, double p1, struct S_DFP p2) { return p0; }
+EXPORT double f14_D_DDS_DDI(double p0, double p1, struct S_DDI p2) { return p0; }
+EXPORT double f14_D_DDS_DDF(double p0, double p1, struct S_DDF p2) { return p0; }
+EXPORT double f14_D_DDS_DDD(double p0, double p1, struct S_DDD p2) { return p0; }
+EXPORT double f14_D_DDS_DDP(double p0, double p1, struct S_DDP p2) { return p0; }
+EXPORT double f14_D_DDS_DPI(double p0, double p1, struct S_DPI p2) { return p0; }
+EXPORT double f14_D_DDS_DPF(double p0, double p1, struct S_DPF p2) { return p0; }
+EXPORT double f14_D_DDS_DPD(double p0, double p1, struct S_DPD p2) { return p0; }
+EXPORT double f14_D_DDS_DPP(double p0, double p1, struct S_DPP p2) { return p0; }
+EXPORT double f14_D_DDS_PII(double p0, double p1, struct S_PII p2) { return p0; }
+EXPORT double f14_D_DDS_PIF(double p0, double p1, struct S_PIF p2) { return p0; }
+EXPORT double f14_D_DDS_PID(double p0, double p1, struct S_PID p2) { return p0; }
+EXPORT double f14_D_DDS_PIP(double p0, double p1, struct S_PIP p2) { return p0; }
+EXPORT double f14_D_DDS_PFI(double p0, double p1, struct S_PFI p2) { return p0; }
+EXPORT double f14_D_DDS_PFF(double p0, double p1, struct S_PFF p2) { return p0; }
+EXPORT double f14_D_DDS_PFD(double p0, double p1, struct S_PFD p2) { return p0; }
+EXPORT double f14_D_DDS_PFP(double p0, double p1, struct S_PFP p2) { return p0; }
+EXPORT double f14_D_DDS_PDI(double p0, double p1, struct S_PDI p2) { return p0; }
+EXPORT double f14_D_DDS_PDF(double p0, double p1, struct S_PDF p2) { return p0; }
+EXPORT double f14_D_DDS_PDD(double p0, double p1, struct S_PDD p2) { return p0; }
+EXPORT double f14_D_DDS_PDP(double p0, double p1, struct S_PDP p2) { return p0; }
+EXPORT double f14_D_DDS_PPI(double p0, double p1, struct S_PPI p2) { return p0; }
+EXPORT double f14_D_DDS_PPF(double p0, double p1, struct S_PPF p2) { return p0; }
+EXPORT double f14_D_DDS_PPD(double p0, double p1, struct S_PPD p2) { return p0; }
+EXPORT double f14_D_DDS_PPP(double p0, double p1, struct S_PPP p2) { return p0; }
+EXPORT double f14_D_DPI_(double p0, void* p1, int p2) { return p0; }
+EXPORT double f14_D_DPF_(double p0, void* p1, float p2) { return p0; }
+EXPORT double f14_D_DPD_(double p0, void* p1, double p2) { return p0; }
+EXPORT double f14_D_DPP_(double p0, void* p1, void* p2) { return p0; }
+EXPORT double f14_D_DPS_I(double p0, void* p1, struct S_I p2) { return p0; }
+EXPORT double f14_D_DPS_F(double p0, void* p1, struct S_F p2) { return p0; }
+EXPORT double f14_D_DPS_D(double p0, void* p1, struct S_D p2) { return p0; }
+EXPORT double f14_D_DPS_P(double p0, void* p1, struct S_P p2) { return p0; }
+EXPORT double f14_D_DPS_II(double p0, void* p1, struct S_II p2) { return p0; }
+EXPORT double f14_D_DPS_IF(double p0, void* p1, struct S_IF p2) { return p0; }
+EXPORT double f14_D_DPS_ID(double p0, void* p1, struct S_ID p2) { return p0; }
+EXPORT double f14_D_DPS_IP(double p0, void* p1, struct S_IP p2) { return p0; }
+EXPORT double f14_D_DPS_FI(double p0, void* p1, struct S_FI p2) { return p0; }
+EXPORT double f14_D_DPS_FF(double p0, void* p1, struct S_FF p2) { return p0; }
+EXPORT double f14_D_DPS_FD(double p0, void* p1, struct S_FD p2) { return p0; }
+EXPORT double f14_D_DPS_FP(double p0, void* p1, struct S_FP p2) { return p0; }
+EXPORT double f14_D_DPS_DI(double p0, void* p1, struct S_DI p2) { return p0; }
+EXPORT double f14_D_DPS_DF(double p0, void* p1, struct S_DF p2) { return p0; }
+EXPORT double f14_D_DPS_DD(double p0, void* p1, struct S_DD p2) { return p0; }
+EXPORT double f14_D_DPS_DP(double p0, void* p1, struct S_DP p2) { return p0; }
+EXPORT double f14_D_DPS_PI(double p0, void* p1, struct S_PI p2) { return p0; }
+EXPORT double f14_D_DPS_PF(double p0, void* p1, struct S_PF p2) { return p0; }
+EXPORT double f14_D_DPS_PD(double p0, void* p1, struct S_PD p2) { return p0; }
+EXPORT double f14_D_DPS_PP(double p0, void* p1, struct S_PP p2) { return p0; }
+EXPORT double f14_D_DPS_III(double p0, void* p1, struct S_III p2) { return p0; }
+EXPORT double f14_D_DPS_IIF(double p0, void* p1, struct S_IIF p2) { return p0; }
+EXPORT double f14_D_DPS_IID(double p0, void* p1, struct S_IID p2) { return p0; }
+EXPORT double f14_D_DPS_IIP(double p0, void* p1, struct S_IIP p2) { return p0; }
+EXPORT double f14_D_DPS_IFI(double p0, void* p1, struct S_IFI p2) { return p0; }
+EXPORT double f14_D_DPS_IFF(double p0, void* p1, struct S_IFF p2) { return p0; }
+EXPORT double f14_D_DPS_IFD(double p0, void* p1, struct S_IFD p2) { return p0; }
+EXPORT double f14_D_DPS_IFP(double p0, void* p1, struct S_IFP p2) { return p0; }
+EXPORT double f14_D_DPS_IDI(double p0, void* p1, struct S_IDI p2) { return p0; }
+EXPORT double f14_D_DPS_IDF(double p0, void* p1, struct S_IDF p2) { return p0; }
+EXPORT double f14_D_DPS_IDD(double p0, void* p1, struct S_IDD p2) { return p0; }
+EXPORT double f14_D_DPS_IDP(double p0, void* p1, struct S_IDP p2) { return p0; }
+EXPORT double f14_D_DPS_IPI(double p0, void* p1, struct S_IPI p2) { return p0; }
+EXPORT double f14_D_DPS_IPF(double p0, void* p1, struct S_IPF p2) { return p0; }
+EXPORT double f14_D_DPS_IPD(double p0, void* p1, struct S_IPD p2) { return p0; }
+EXPORT double f14_D_DPS_IPP(double p0, void* p1, struct S_IPP p2) { return p0; }
+EXPORT double f14_D_DPS_FII(double p0, void* p1, struct S_FII p2) { return p0; }
+EXPORT double f14_D_DPS_FIF(double p0, void* p1, struct S_FIF p2) { return p0; }
+EXPORT double f14_D_DPS_FID(double p0, void* p1, struct S_FID p2) { return p0; }
+EXPORT double f14_D_DPS_FIP(double p0, void* p1, struct S_FIP p2) { return p0; }
+EXPORT double f14_D_DPS_FFI(double p0, void* p1, struct S_FFI p2) { return p0; }
+EXPORT double f14_D_DPS_FFF(double p0, void* p1, struct S_FFF p2) { return p0; }
+EXPORT double f14_D_DPS_FFD(double p0, void* p1, struct S_FFD p2) { return p0; }
+EXPORT double f14_D_DPS_FFP(double p0, void* p1, struct S_FFP p2) { return p0; }
+EXPORT double f14_D_DPS_FDI(double p0, void* p1, struct S_FDI p2) { return p0; }
+EXPORT double f14_D_DPS_FDF(double p0, void* p1, struct S_FDF p2) { return p0; }
+EXPORT double f14_D_DPS_FDD(double p0, void* p1, struct S_FDD p2) { return p0; }
+EXPORT double f14_D_DPS_FDP(double p0, void* p1, struct S_FDP p2) { return p0; }
+EXPORT double f14_D_DPS_FPI(double p0, void* p1, struct S_FPI p2) { return p0; }
+EXPORT double f14_D_DPS_FPF(double p0, void* p1, struct S_FPF p2) { return p0; }
+EXPORT double f14_D_DPS_FPD(double p0, void* p1, struct S_FPD p2) { return p0; }
+EXPORT double f14_D_DPS_FPP(double p0, void* p1, struct S_FPP p2) { return p0; }
+EXPORT double f14_D_DPS_DII(double p0, void* p1, struct S_DII p2) { return p0; }
+EXPORT double f14_D_DPS_DIF(double p0, void* p1, struct S_DIF p2) { return p0; }
+EXPORT double f14_D_DPS_DID(double p0, void* p1, struct S_DID p2) { return p0; }
+EXPORT double f14_D_DPS_DIP(double p0, void* p1, struct S_DIP p2) { return p0; }
+EXPORT double f14_D_DPS_DFI(double p0, void* p1, struct S_DFI p2) { return p0; }
+EXPORT double f14_D_DPS_DFF(double p0, void* p1, struct S_DFF p2) { return p0; }
+EXPORT double f14_D_DPS_DFD(double p0, void* p1, struct S_DFD p2) { return p0; }
+EXPORT double f14_D_DPS_DFP(double p0, void* p1, struct S_DFP p2) { return p0; }
+EXPORT double f14_D_DPS_DDI(double p0, void* p1, struct S_DDI p2) { return p0; }
+EXPORT double f14_D_DPS_DDF(double p0, void* p1, struct S_DDF p2) { return p0; }
+EXPORT double f14_D_DPS_DDD(double p0, void* p1, struct S_DDD p2) { return p0; }
+EXPORT double f14_D_DPS_DDP(double p0, void* p1, struct S_DDP p2) { return p0; }
+EXPORT double f14_D_DPS_DPI(double p0, void* p1, struct S_DPI p2) { return p0; }
+EXPORT double f14_D_DPS_DPF(double p0, void* p1, struct S_DPF p2) { return p0; }
+EXPORT double f14_D_DPS_DPD(double p0, void* p1, struct S_DPD p2) { return p0; }
+EXPORT double f14_D_DPS_DPP(double p0, void* p1, struct S_DPP p2) { return p0; }
+EXPORT double f14_D_DPS_PII(double p0, void* p1, struct S_PII p2) { return p0; }
+EXPORT double f14_D_DPS_PIF(double p0, void* p1, struct S_PIF p2) { return p0; }
+EXPORT double f14_D_DPS_PID(double p0, void* p1, struct S_PID p2) { return p0; }
+EXPORT double f14_D_DPS_PIP(double p0, void* p1, struct S_PIP p2) { return p0; }
+EXPORT double f14_D_DPS_PFI(double p0, void* p1, struct S_PFI p2) { return p0; }
+EXPORT double f14_D_DPS_PFF(double p0, void* p1, struct S_PFF p2) { return p0; }
+EXPORT double f14_D_DPS_PFD(double p0, void* p1, struct S_PFD p2) { return p0; }
+EXPORT double f14_D_DPS_PFP(double p0, void* p1, struct S_PFP p2) { return p0; }
+EXPORT double f14_D_DPS_PDI(double p0, void* p1, struct S_PDI p2) { return p0; }
+EXPORT double f14_D_DPS_PDF(double p0, void* p1, struct S_PDF p2) { return p0; }
+EXPORT double f14_D_DPS_PDD(double p0, void* p1, struct S_PDD p2) { return p0; }
+EXPORT double f14_D_DPS_PDP(double p0, void* p1, struct S_PDP p2) { return p0; }
+EXPORT double f14_D_DPS_PPI(double p0, void* p1, struct S_PPI p2) { return p0; }
+EXPORT double f14_D_DPS_PPF(double p0, void* p1, struct S_PPF p2) { return p0; }
+EXPORT double f14_D_DPS_PPD(double p0, void* p1, struct S_PPD p2) { return p0; }
+EXPORT double f14_D_DPS_PPP(double p0, void* p1, struct S_PPP p2) { return p0; }
+EXPORT double f14_D_DSI_I(double p0, struct S_I p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_F(double p0, struct S_F p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_D(double p0, struct S_D p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_P(double p0, struct S_P p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_II(double p0, struct S_II p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_IF(double p0, struct S_IF p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_ID(double p0, struct S_ID p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_IP(double p0, struct S_IP p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_FI(double p0, struct S_FI p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_FF(double p0, struct S_FF p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_FD(double p0, struct S_FD p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_FP(double p0, struct S_FP p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_DI(double p0, struct S_DI p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_DF(double p0, struct S_DF p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_DD(double p0, struct S_DD p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_DP(double p0, struct S_DP p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_PI(double p0, struct S_PI p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_PF(double p0, struct S_PF p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_PD(double p0, struct S_PD p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_PP(double p0, struct S_PP p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_III(double p0, struct S_III p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_IIF(double p0, struct S_IIF p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_IID(double p0, struct S_IID p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_IIP(double p0, struct S_IIP p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_IFI(double p0, struct S_IFI p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_IFF(double p0, struct S_IFF p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_IFD(double p0, struct S_IFD p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_IFP(double p0, struct S_IFP p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_IDI(double p0, struct S_IDI p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_IDF(double p0, struct S_IDF p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_IDD(double p0, struct S_IDD p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_IDP(double p0, struct S_IDP p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_IPI(double p0, struct S_IPI p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_IPF(double p0, struct S_IPF p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_IPD(double p0, struct S_IPD p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_IPP(double p0, struct S_IPP p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_FII(double p0, struct S_FII p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_FIF(double p0, struct S_FIF p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_FID(double p0, struct S_FID p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_FIP(double p0, struct S_FIP p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_FFI(double p0, struct S_FFI p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_FFF(double p0, struct S_FFF p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_FFD(double p0, struct S_FFD p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_FFP(double p0, struct S_FFP p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_FDI(double p0, struct S_FDI p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_FDF(double p0, struct S_FDF p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_FDD(double p0, struct S_FDD p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_FDP(double p0, struct S_FDP p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_FPI(double p0, struct S_FPI p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_FPF(double p0, struct S_FPF p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_FPD(double p0, struct S_FPD p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_FPP(double p0, struct S_FPP p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_DII(double p0, struct S_DII p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_DIF(double p0, struct S_DIF p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_DID(double p0, struct S_DID p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_DIP(double p0, struct S_DIP p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_DFI(double p0, struct S_DFI p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_DFF(double p0, struct S_DFF p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_DFD(double p0, struct S_DFD p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_DFP(double p0, struct S_DFP p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_DDI(double p0, struct S_DDI p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_DDF(double p0, struct S_DDF p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_DDD(double p0, struct S_DDD p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_DDP(double p0, struct S_DDP p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_DPI(double p0, struct S_DPI p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_DPF(double p0, struct S_DPF p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_DPD(double p0, struct S_DPD p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_DPP(double p0, struct S_DPP p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_PII(double p0, struct S_PII p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_PIF(double p0, struct S_PIF p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_PID(double p0, struct S_PID p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_PIP(double p0, struct S_PIP p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_PFI(double p0, struct S_PFI p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_PFF(double p0, struct S_PFF p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_PFD(double p0, struct S_PFD p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_PFP(double p0, struct S_PFP p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_PDI(double p0, struct S_PDI p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_PDF(double p0, struct S_PDF p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_PDD(double p0, struct S_PDD p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_PDP(double p0, struct S_PDP p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_PPI(double p0, struct S_PPI p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_PPF(double p0, struct S_PPF p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_PPD(double p0, struct S_PPD p1, int p2) { return p0; }
+EXPORT double f14_D_DSI_PPP(double p0, struct S_PPP p1, int p2) { return p0; }
+EXPORT double f14_D_DSF_I(double p0, struct S_I p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_F(double p0, struct S_F p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_D(double p0, struct S_D p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_P(double p0, struct S_P p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_II(double p0, struct S_II p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_IF(double p0, struct S_IF p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_ID(double p0, struct S_ID p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_IP(double p0, struct S_IP p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_FI(double p0, struct S_FI p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_FF(double p0, struct S_FF p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_FD(double p0, struct S_FD p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_FP(double p0, struct S_FP p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_DI(double p0, struct S_DI p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_DF(double p0, struct S_DF p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_DD(double p0, struct S_DD p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_DP(double p0, struct S_DP p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_PI(double p0, struct S_PI p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_PF(double p0, struct S_PF p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_PD(double p0, struct S_PD p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_PP(double p0, struct S_PP p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_III(double p0, struct S_III p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_IIF(double p0, struct S_IIF p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_IID(double p0, struct S_IID p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_IIP(double p0, struct S_IIP p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_IFI(double p0, struct S_IFI p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_IFF(double p0, struct S_IFF p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_IFD(double p0, struct S_IFD p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_IFP(double p0, struct S_IFP p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_IDI(double p0, struct S_IDI p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_IDF(double p0, struct S_IDF p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_IDD(double p0, struct S_IDD p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_IDP(double p0, struct S_IDP p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_IPI(double p0, struct S_IPI p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_IPF(double p0, struct S_IPF p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_IPD(double p0, struct S_IPD p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_IPP(double p0, struct S_IPP p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_FII(double p0, struct S_FII p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_FIF(double p0, struct S_FIF p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_FID(double p0, struct S_FID p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_FIP(double p0, struct S_FIP p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_FFI(double p0, struct S_FFI p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_FFF(double p0, struct S_FFF p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_FFD(double p0, struct S_FFD p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_FFP(double p0, struct S_FFP p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_FDI(double p0, struct S_FDI p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_FDF(double p0, struct S_FDF p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_FDD(double p0, struct S_FDD p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_FDP(double p0, struct S_FDP p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_FPI(double p0, struct S_FPI p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_FPF(double p0, struct S_FPF p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_FPD(double p0, struct S_FPD p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_FPP(double p0, struct S_FPP p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_DII(double p0, struct S_DII p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_DIF(double p0, struct S_DIF p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_DID(double p0, struct S_DID p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_DIP(double p0, struct S_DIP p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_DFI(double p0, struct S_DFI p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_DFF(double p0, struct S_DFF p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_DFD(double p0, struct S_DFD p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_DFP(double p0, struct S_DFP p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_DDI(double p0, struct S_DDI p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_DDF(double p0, struct S_DDF p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_DDD(double p0, struct S_DDD p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_DDP(double p0, struct S_DDP p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_DPI(double p0, struct S_DPI p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_DPF(double p0, struct S_DPF p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_DPD(double p0, struct S_DPD p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_DPP(double p0, struct S_DPP p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_PII(double p0, struct S_PII p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_PIF(double p0, struct S_PIF p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_PID(double p0, struct S_PID p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_PIP(double p0, struct S_PIP p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_PFI(double p0, struct S_PFI p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_PFF(double p0, struct S_PFF p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_PFD(double p0, struct S_PFD p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_PFP(double p0, struct S_PFP p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_PDI(double p0, struct S_PDI p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_PDF(double p0, struct S_PDF p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_PDD(double p0, struct S_PDD p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_PDP(double p0, struct S_PDP p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_PPI(double p0, struct S_PPI p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_PPF(double p0, struct S_PPF p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_PPD(double p0, struct S_PPD p1, float p2) { return p0; }
+EXPORT double f14_D_DSF_PPP(double p0, struct S_PPP p1, float p2) { return p0; }
+EXPORT double f14_D_DSD_I(double p0, struct S_I p1, double p2) { return p0; }
+EXPORT double f14_D_DSD_F(double p0, struct S_F p1, double p2) { return p0; }
+EXPORT double f14_D_DSD_D(double p0, struct S_D p1, double p2) { return p0; }
+EXPORT double f14_D_DSD_P(double p0, struct S_P p1, double p2) { return p0; }
+EXPORT double f14_D_DSD_II(double p0, struct S_II p1, double p2) { return p0; }
+EXPORT double f14_D_DSD_IF(double p0, struct S_IF p1, double p2) { return p0; }
+EXPORT double f14_D_DSD_ID(double p0, struct S_ID p1, double p2) { return p0; }
+EXPORT double f14_D_DSD_IP(double p0, struct S_IP p1, double p2) { return p0; }
+EXPORT double f14_D_DSD_FI(double p0, struct S_FI p1, double p2) { return p0; }
+EXPORT double f14_D_DSD_FF(double p0, struct S_FF p1, double p2) { return p0; }
+EXPORT double f14_D_DSD_FD(double p0, struct S_FD p1, double p2) { return p0; }
+EXPORT double f14_D_DSD_FP(double p0, struct S_FP p1, double p2) { return p0; }
+EXPORT double f14_D_DSD_DI(double p0, struct S_DI p1, double p2) { return p0; }
+EXPORT double f14_D_DSD_DF(double p0, struct S_DF p1, double p2) { return p0; }
+EXPORT double f14_D_DSD_DD(double p0, struct S_DD p1, double p2) { return p0; }
+EXPORT double f14_D_DSD_DP(double p0, struct S_DP p1, double p2) { return p0; }
+EXPORT double f14_D_DSD_PI(double p0, struct S_PI p1, double p2) { return p0; }
+EXPORT double f14_D_DSD_PF(double p0, struct S_PF p1, double p2) { return p0; }
+EXPORT double f14_D_DSD_PD(double p0, struct S_PD p1, double p2) { return p0; }
+EXPORT double f14_D_DSD_PP(double p0, struct S_PP p1, double p2) { return p0; }
+EXPORT double f14_D_DSD_III(double p0, struct S_III p1, double p2) { return p0; }
+EXPORT double f14_D_DSD_IIF(double p0, struct S_IIF p1, double p2) { return p0; }
+EXPORT double f14_D_DSD_IID(double p0, struct S_IID p1, double p2) { return p0; }
+EXPORT double f14_D_DSD_IIP(double p0, struct S_IIP p1, double p2) { return p0; }
+EXPORT double f14_D_DSD_IFI(double p0, struct S_IFI p1, double p2) { return p0; }
+EXPORT double f14_D_DSD_IFF(double p0, struct S_IFF p1, double p2) { return p0; }
+EXPORT double f14_D_DSD_IFD(double p0, struct S_IFD p1, double p2) { return p0; }
+EXPORT double f15_D_DSD_IFP(double p0, struct S_IFP p1, double p2) { return p0; }
+EXPORT double f15_D_DSD_IDI(double p0, struct S_IDI p1, double p2) { return p0; }
+EXPORT double f15_D_DSD_IDF(double p0, struct S_IDF p1, double p2) { return p0; }
+EXPORT double f15_D_DSD_IDD(double p0, struct S_IDD p1, double p2) { return p0; }
+EXPORT double f15_D_DSD_IDP(double p0, struct S_IDP p1, double p2) { return p0; }
+EXPORT double f15_D_DSD_IPI(double p0, struct S_IPI p1, double p2) { return p0; }
+EXPORT double f15_D_DSD_IPF(double p0, struct S_IPF p1, double p2) { return p0; }
+EXPORT double f15_D_DSD_IPD(double p0, struct S_IPD p1, double p2) { return p0; }
+EXPORT double f15_D_DSD_IPP(double p0, struct S_IPP p1, double p2) { return p0; }
+EXPORT double f15_D_DSD_FII(double p0, struct S_FII p1, double p2) { return p0; }
+EXPORT double f15_D_DSD_FIF(double p0, struct S_FIF p1, double p2) { return p0; }
+EXPORT double f15_D_DSD_FID(double p0, struct S_FID p1, double p2) { return p0; }
+EXPORT double f15_D_DSD_FIP(double p0, struct S_FIP p1, double p2) { return p0; }
+EXPORT double f15_D_DSD_FFI(double p0, struct S_FFI p1, double p2) { return p0; }
+EXPORT double f15_D_DSD_FFF(double p0, struct S_FFF p1, double p2) { return p0; }
+EXPORT double f15_D_DSD_FFD(double p0, struct S_FFD p1, double p2) { return p0; }
+EXPORT double f15_D_DSD_FFP(double p0, struct S_FFP p1, double p2) { return p0; }
+EXPORT double f15_D_DSD_FDI(double p0, struct S_FDI p1, double p2) { return p0; }
+EXPORT double f15_D_DSD_FDF(double p0, struct S_FDF p1, double p2) { return p0; }
+EXPORT double f15_D_DSD_FDD(double p0, struct S_FDD p1, double p2) { return p0; }
+EXPORT double f15_D_DSD_FDP(double p0, struct S_FDP p1, double p2) { return p0; }
+EXPORT double f15_D_DSD_FPI(double p0, struct S_FPI p1, double p2) { return p0; }
+EXPORT double f15_D_DSD_FPF(double p0, struct S_FPF p1, double p2) { return p0; }
+EXPORT double f15_D_DSD_FPD(double p0, struct S_FPD p1, double p2) { return p0; }
+EXPORT double f15_D_DSD_FPP(double p0, struct S_FPP p1, double p2) { return p0; }
+EXPORT double f15_D_DSD_DII(double p0, struct S_DII p1, double p2) { return p0; }
+EXPORT double f15_D_DSD_DIF(double p0, struct S_DIF p1, double p2) { return p0; }
+EXPORT double f15_D_DSD_DID(double p0, struct S_DID p1, double p2) { return p0; }
+EXPORT double f15_D_DSD_DIP(double p0, struct S_DIP p1, double p2) { return p0; }
+EXPORT double f15_D_DSD_DFI(double p0, struct S_DFI p1, double p2) { return p0; }
+EXPORT double f15_D_DSD_DFF(double p0, struct S_DFF p1, double p2) { return p0; }
+EXPORT double f15_D_DSD_DFD(double p0, struct S_DFD p1, double p2) { return p0; }
+EXPORT double f15_D_DSD_DFP(double p0, struct S_DFP p1, double p2) { return p0; }
+EXPORT double f15_D_DSD_DDI(double p0, struct S_DDI p1, double p2) { return p0; }
+EXPORT double f15_D_DSD_DDF(double p0, struct S_DDF p1, double p2) { return p0; }
+EXPORT double f15_D_DSD_DDD(double p0, struct S_DDD p1, double p2) { return p0; }
+EXPORT double f15_D_DSD_DDP(double p0, struct S_DDP p1, double p2) { return p0; }
+EXPORT double f15_D_DSD_DPI(double p0, struct S_DPI p1, double p2) { return p0; }
+EXPORT double f15_D_DSD_DPF(double p0, struct S_DPF p1, double p2) { return p0; }
+EXPORT double f15_D_DSD_DPD(double p0, struct S_DPD p1, double p2) { return p0; }
+EXPORT double f15_D_DSD_DPP(double p0, struct S_DPP p1, double p2) { return p0; }
+EXPORT double f15_D_DSD_PII(double p0, struct S_PII p1, double p2) { return p0; }
+EXPORT double f15_D_DSD_PIF(double p0, struct S_PIF p1, double p2) { return p0; }
+EXPORT double f15_D_DSD_PID(double p0, struct S_PID p1, double p2) { return p0; }
+EXPORT double f15_D_DSD_PIP(double p0, struct S_PIP p1, double p2) { return p0; }
+EXPORT double f15_D_DSD_PFI(double p0, struct S_PFI p1, double p2) { return p0; }
+EXPORT double f15_D_DSD_PFF(double p0, struct S_PFF p1, double p2) { return p0; }
+EXPORT double f15_D_DSD_PFD(double p0, struct S_PFD p1, double p2) { return p0; }
+EXPORT double f15_D_DSD_PFP(double p0, struct S_PFP p1, double p2) { return p0; }
+EXPORT double f15_D_DSD_PDI(double p0, struct S_PDI p1, double p2) { return p0; }
+EXPORT double f15_D_DSD_PDF(double p0, struct S_PDF p1, double p2) { return p0; }
+EXPORT double f15_D_DSD_PDD(double p0, struct S_PDD p1, double p2) { return p0; }
+EXPORT double f15_D_DSD_PDP(double p0, struct S_PDP p1, double p2) { return p0; }
+EXPORT double f15_D_DSD_PPI(double p0, struct S_PPI p1, double p2) { return p0; }
+EXPORT double f15_D_DSD_PPF(double p0, struct S_PPF p1, double p2) { return p0; }
+EXPORT double f15_D_DSD_PPD(double p0, struct S_PPD p1, double p2) { return p0; }
+EXPORT double f15_D_DSD_PPP(double p0, struct S_PPP p1, double p2) { return p0; }
+EXPORT double f15_D_DSP_I(double p0, struct S_I p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_F(double p0, struct S_F p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_D(double p0, struct S_D p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_P(double p0, struct S_P p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_II(double p0, struct S_II p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_IF(double p0, struct S_IF p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_ID(double p0, struct S_ID p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_IP(double p0, struct S_IP p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_FI(double p0, struct S_FI p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_FF(double p0, struct S_FF p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_FD(double p0, struct S_FD p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_FP(double p0, struct S_FP p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_DI(double p0, struct S_DI p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_DF(double p0, struct S_DF p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_DD(double p0, struct S_DD p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_DP(double p0, struct S_DP p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_PI(double p0, struct S_PI p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_PF(double p0, struct S_PF p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_PD(double p0, struct S_PD p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_PP(double p0, struct S_PP p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_III(double p0, struct S_III p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_IIF(double p0, struct S_IIF p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_IID(double p0, struct S_IID p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_IIP(double p0, struct S_IIP p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_IFI(double p0, struct S_IFI p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_IFF(double p0, struct S_IFF p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_IFD(double p0, struct S_IFD p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_IFP(double p0, struct S_IFP p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_IDI(double p0, struct S_IDI p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_IDF(double p0, struct S_IDF p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_IDD(double p0, struct S_IDD p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_IDP(double p0, struct S_IDP p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_IPI(double p0, struct S_IPI p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_IPF(double p0, struct S_IPF p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_IPD(double p0, struct S_IPD p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_IPP(double p0, struct S_IPP p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_FII(double p0, struct S_FII p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_FIF(double p0, struct S_FIF p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_FID(double p0, struct S_FID p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_FIP(double p0, struct S_FIP p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_FFI(double p0, struct S_FFI p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_FFF(double p0, struct S_FFF p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_FFD(double p0, struct S_FFD p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_FFP(double p0, struct S_FFP p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_FDI(double p0, struct S_FDI p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_FDF(double p0, struct S_FDF p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_FDD(double p0, struct S_FDD p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_FDP(double p0, struct S_FDP p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_FPI(double p0, struct S_FPI p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_FPF(double p0, struct S_FPF p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_FPD(double p0, struct S_FPD p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_FPP(double p0, struct S_FPP p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_DII(double p0, struct S_DII p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_DIF(double p0, struct S_DIF p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_DID(double p0, struct S_DID p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_DIP(double p0, struct S_DIP p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_DFI(double p0, struct S_DFI p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_DFF(double p0, struct S_DFF p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_DFD(double p0, struct S_DFD p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_DFP(double p0, struct S_DFP p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_DDI(double p0, struct S_DDI p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_DDF(double p0, struct S_DDF p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_DDD(double p0, struct S_DDD p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_DDP(double p0, struct S_DDP p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_DPI(double p0, struct S_DPI p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_DPF(double p0, struct S_DPF p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_DPD(double p0, struct S_DPD p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_DPP(double p0, struct S_DPP p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_PII(double p0, struct S_PII p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_PIF(double p0, struct S_PIF p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_PID(double p0, struct S_PID p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_PIP(double p0, struct S_PIP p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_PFI(double p0, struct S_PFI p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_PFF(double p0, struct S_PFF p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_PFD(double p0, struct S_PFD p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_PFP(double p0, struct S_PFP p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_PDI(double p0, struct S_PDI p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_PDF(double p0, struct S_PDF p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_PDD(double p0, struct S_PDD p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_PDP(double p0, struct S_PDP p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_PPI(double p0, struct S_PPI p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_PPF(double p0, struct S_PPF p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_PPD(double p0, struct S_PPD p1, void* p2) { return p0; }
+EXPORT double f15_D_DSP_PPP(double p0, struct S_PPP p1, void* p2) { return p0; }
+EXPORT double f15_D_DSS_I(double p0, struct S_I p1, struct S_I p2) { return p0; }
+EXPORT double f15_D_DSS_F(double p0, struct S_F p1, struct S_F p2) { return p0; }
+EXPORT double f15_D_DSS_D(double p0, struct S_D p1, struct S_D p2) { return p0; }
+EXPORT double f15_D_DSS_P(double p0, struct S_P p1, struct S_P p2) { return p0; }
+EXPORT double f15_D_DSS_II(double p0, struct S_II p1, struct S_II p2) { return p0; }
+EXPORT double f15_D_DSS_IF(double p0, struct S_IF p1, struct S_IF p2) { return p0; }
+EXPORT double f15_D_DSS_ID(double p0, struct S_ID p1, struct S_ID p2) { return p0; }
+EXPORT double f15_D_DSS_IP(double p0, struct S_IP p1, struct S_IP p2) { return p0; }
+EXPORT double f15_D_DSS_FI(double p0, struct S_FI p1, struct S_FI p2) { return p0; }
+EXPORT double f15_D_DSS_FF(double p0, struct S_FF p1, struct S_FF p2) { return p0; }
+EXPORT double f15_D_DSS_FD(double p0, struct S_FD p1, struct S_FD p2) { return p0; }
+EXPORT double f15_D_DSS_FP(double p0, struct S_FP p1, struct S_FP p2) { return p0; }
+EXPORT double f15_D_DSS_DI(double p0, struct S_DI p1, struct S_DI p2) { return p0; }
+EXPORT double f15_D_DSS_DF(double p0, struct S_DF p1, struct S_DF p2) { return p0; }
+EXPORT double f15_D_DSS_DD(double p0, struct S_DD p1, struct S_DD p2) { return p0; }
+EXPORT double f15_D_DSS_DP(double p0, struct S_DP p1, struct S_DP p2) { return p0; }
+EXPORT double f15_D_DSS_PI(double p0, struct S_PI p1, struct S_PI p2) { return p0; }
+EXPORT double f15_D_DSS_PF(double p0, struct S_PF p1, struct S_PF p2) { return p0; }
+EXPORT double f15_D_DSS_PD(double p0, struct S_PD p1, struct S_PD p2) { return p0; }
+EXPORT double f15_D_DSS_PP(double p0, struct S_PP p1, struct S_PP p2) { return p0; }
+EXPORT double f15_D_DSS_III(double p0, struct S_III p1, struct S_III p2) { return p0; }
+EXPORT double f15_D_DSS_IIF(double p0, struct S_IIF p1, struct S_IIF p2) { return p0; }
+EXPORT double f15_D_DSS_IID(double p0, struct S_IID p1, struct S_IID p2) { return p0; }
+EXPORT double f15_D_DSS_IIP(double p0, struct S_IIP p1, struct S_IIP p2) { return p0; }
+EXPORT double f15_D_DSS_IFI(double p0, struct S_IFI p1, struct S_IFI p2) { return p0; }
+EXPORT double f15_D_DSS_IFF(double p0, struct S_IFF p1, struct S_IFF p2) { return p0; }
+EXPORT double f15_D_DSS_IFD(double p0, struct S_IFD p1, struct S_IFD p2) { return p0; }
+EXPORT double f15_D_DSS_IFP(double p0, struct S_IFP p1, struct S_IFP p2) { return p0; }
+EXPORT double f15_D_DSS_IDI(double p0, struct S_IDI p1, struct S_IDI p2) { return p0; }
+EXPORT double f15_D_DSS_IDF(double p0, struct S_IDF p1, struct S_IDF p2) { return p0; }
+EXPORT double f15_D_DSS_IDD(double p0, struct S_IDD p1, struct S_IDD p2) { return p0; }
+EXPORT double f15_D_DSS_IDP(double p0, struct S_IDP p1, struct S_IDP p2) { return p0; }
+EXPORT double f15_D_DSS_IPI(double p0, struct S_IPI p1, struct S_IPI p2) { return p0; }
+EXPORT double f15_D_DSS_IPF(double p0, struct S_IPF p1, struct S_IPF p2) { return p0; }
+EXPORT double f15_D_DSS_IPD(double p0, struct S_IPD p1, struct S_IPD p2) { return p0; }
+EXPORT double f15_D_DSS_IPP(double p0, struct S_IPP p1, struct S_IPP p2) { return p0; }
+EXPORT double f15_D_DSS_FII(double p0, struct S_FII p1, struct S_FII p2) { return p0; }
+EXPORT double f15_D_DSS_FIF(double p0, struct S_FIF p1, struct S_FIF p2) { return p0; }
+EXPORT double f15_D_DSS_FID(double p0, struct S_FID p1, struct S_FID p2) { return p0; }
+EXPORT double f15_D_DSS_FIP(double p0, struct S_FIP p1, struct S_FIP p2) { return p0; }
+EXPORT double f15_D_DSS_FFI(double p0, struct S_FFI p1, struct S_FFI p2) { return p0; }
+EXPORT double f15_D_DSS_FFF(double p0, struct S_FFF p1, struct S_FFF p2) { return p0; }
+EXPORT double f15_D_DSS_FFD(double p0, struct S_FFD p1, struct S_FFD p2) { return p0; }
+EXPORT double f15_D_DSS_FFP(double p0, struct S_FFP p1, struct S_FFP p2) { return p0; }
+EXPORT double f15_D_DSS_FDI(double p0, struct S_FDI p1, struct S_FDI p2) { return p0; }
+EXPORT double f15_D_DSS_FDF(double p0, struct S_FDF p1, struct S_FDF p2) { return p0; }
+EXPORT double f15_D_DSS_FDD(double p0, struct S_FDD p1, struct S_FDD p2) { return p0; }
+EXPORT double f15_D_DSS_FDP(double p0, struct S_FDP p1, struct S_FDP p2) { return p0; }
+EXPORT double f15_D_DSS_FPI(double p0, struct S_FPI p1, struct S_FPI p2) { return p0; }
+EXPORT double f15_D_DSS_FPF(double p0, struct S_FPF p1, struct S_FPF p2) { return p0; }
+EXPORT double f15_D_DSS_FPD(double p0, struct S_FPD p1, struct S_FPD p2) { return p0; }
+EXPORT double f15_D_DSS_FPP(double p0, struct S_FPP p1, struct S_FPP p2) { return p0; }
+EXPORT double f15_D_DSS_DII(double p0, struct S_DII p1, struct S_DII p2) { return p0; }
+EXPORT double f15_D_DSS_DIF(double p0, struct S_DIF p1, struct S_DIF p2) { return p0; }
+EXPORT double f15_D_DSS_DID(double p0, struct S_DID p1, struct S_DID p2) { return p0; }
+EXPORT double f15_D_DSS_DIP(double p0, struct S_DIP p1, struct S_DIP p2) { return p0; }
+EXPORT double f15_D_DSS_DFI(double p0, struct S_DFI p1, struct S_DFI p2) { return p0; }
+EXPORT double f15_D_DSS_DFF(double p0, struct S_DFF p1, struct S_DFF p2) { return p0; }
+EXPORT double f15_D_DSS_DFD(double p0, struct S_DFD p1, struct S_DFD p2) { return p0; }
+EXPORT double f15_D_DSS_DFP(double p0, struct S_DFP p1, struct S_DFP p2) { return p0; }
+EXPORT double f15_D_DSS_DDI(double p0, struct S_DDI p1, struct S_DDI p2) { return p0; }
+EXPORT double f15_D_DSS_DDF(double p0, struct S_DDF p1, struct S_DDF p2) { return p0; }
+EXPORT double f15_D_DSS_DDD(double p0, struct S_DDD p1, struct S_DDD p2) { return p0; }
+EXPORT double f15_D_DSS_DDP(double p0, struct S_DDP p1, struct S_DDP p2) { return p0; }
+EXPORT double f15_D_DSS_DPI(double p0, struct S_DPI p1, struct S_DPI p2) { return p0; }
+EXPORT double f15_D_DSS_DPF(double p0, struct S_DPF p1, struct S_DPF p2) { return p0; }
+EXPORT double f15_D_DSS_DPD(double p0, struct S_DPD p1, struct S_DPD p2) { return p0; }
+EXPORT double f15_D_DSS_DPP(double p0, struct S_DPP p1, struct S_DPP p2) { return p0; }
+EXPORT double f15_D_DSS_PII(double p0, struct S_PII p1, struct S_PII p2) { return p0; }
+EXPORT double f15_D_DSS_PIF(double p0, struct S_PIF p1, struct S_PIF p2) { return p0; }
+EXPORT double f15_D_DSS_PID(double p0, struct S_PID p1, struct S_PID p2) { return p0; }
+EXPORT double f15_D_DSS_PIP(double p0, struct S_PIP p1, struct S_PIP p2) { return p0; }
+EXPORT double f15_D_DSS_PFI(double p0, struct S_PFI p1, struct S_PFI p2) { return p0; }
+EXPORT double f15_D_DSS_PFF(double p0, struct S_PFF p1, struct S_PFF p2) { return p0; }
+EXPORT double f15_D_DSS_PFD(double p0, struct S_PFD p1, struct S_PFD p2) { return p0; }
+EXPORT double f15_D_DSS_PFP(double p0, struct S_PFP p1, struct S_PFP p2) { return p0; }
+EXPORT double f15_D_DSS_PDI(double p0, struct S_PDI p1, struct S_PDI p2) { return p0; }
+EXPORT double f15_D_DSS_PDF(double p0, struct S_PDF p1, struct S_PDF p2) { return p0; }
+EXPORT double f15_D_DSS_PDD(double p0, struct S_PDD p1, struct S_PDD p2) { return p0; }
+EXPORT double f15_D_DSS_PDP(double p0, struct S_PDP p1, struct S_PDP p2) { return p0; }
+EXPORT double f15_D_DSS_PPI(double p0, struct S_PPI p1, struct S_PPI p2) { return p0; }
+EXPORT double f15_D_DSS_PPF(double p0, struct S_PPF p1, struct S_PPF p2) { return p0; }
+EXPORT double f15_D_DSS_PPD(double p0, struct S_PPD p1, struct S_PPD p2) { return p0; }
+EXPORT double f15_D_DSS_PPP(double p0, struct S_PPP p1, struct S_PPP p2) { return p0; }
+EXPORT void* f15_P_PII_(void* p0, int p1, int p2) { return p0; }
+EXPORT void* f15_P_PIF_(void* p0, int p1, float p2) { return p0; }
+EXPORT void* f15_P_PID_(void* p0, int p1, double p2) { return p0; }
+EXPORT void* f15_P_PIP_(void* p0, int p1, void* p2) { return p0; }
+EXPORT void* f15_P_PIS_I(void* p0, int p1, struct S_I p2) { return p0; }
+EXPORT void* f15_P_PIS_F(void* p0, int p1, struct S_F p2) { return p0; }
+EXPORT void* f15_P_PIS_D(void* p0, int p1, struct S_D p2) { return p0; }
+EXPORT void* f15_P_PIS_P(void* p0, int p1, struct S_P p2) { return p0; }
+EXPORT void* f15_P_PIS_II(void* p0, int p1, struct S_II p2) { return p0; }
+EXPORT void* f15_P_PIS_IF(void* p0, int p1, struct S_IF p2) { return p0; }
+EXPORT void* f15_P_PIS_ID(void* p0, int p1, struct S_ID p2) { return p0; }
+EXPORT void* f15_P_PIS_IP(void* p0, int p1, struct S_IP p2) { return p0; }
+EXPORT void* f15_P_PIS_FI(void* p0, int p1, struct S_FI p2) { return p0; }
+EXPORT void* f15_P_PIS_FF(void* p0, int p1, struct S_FF p2) { return p0; }
+EXPORT void* f15_P_PIS_FD(void* p0, int p1, struct S_FD p2) { return p0; }
+EXPORT void* f15_P_PIS_FP(void* p0, int p1, struct S_FP p2) { return p0; }
+EXPORT void* f15_P_PIS_DI(void* p0, int p1, struct S_DI p2) { return p0; }
+EXPORT void* f15_P_PIS_DF(void* p0, int p1, struct S_DF p2) { return p0; }
+EXPORT void* f15_P_PIS_DD(void* p0, int p1, struct S_DD p2) { return p0; }
+EXPORT void* f15_P_PIS_DP(void* p0, int p1, struct S_DP p2) { return p0; }
+EXPORT void* f15_P_PIS_PI(void* p0, int p1, struct S_PI p2) { return p0; }
+EXPORT void* f15_P_PIS_PF(void* p0, int p1, struct S_PF p2) { return p0; }
+EXPORT void* f15_P_PIS_PD(void* p0, int p1, struct S_PD p2) { return p0; }
+EXPORT void* f15_P_PIS_PP(void* p0, int p1, struct S_PP p2) { return p0; }
+EXPORT void* f15_P_PIS_III(void* p0, int p1, struct S_III p2) { return p0; }
+EXPORT void* f15_P_PIS_IIF(void* p0, int p1, struct S_IIF p2) { return p0; }
+EXPORT void* f15_P_PIS_IID(void* p0, int p1, struct S_IID p2) { return p0; }
+EXPORT void* f15_P_PIS_IIP(void* p0, int p1, struct S_IIP p2) { return p0; }
+EXPORT void* f15_P_PIS_IFI(void* p0, int p1, struct S_IFI p2) { return p0; }
+EXPORT void* f15_P_PIS_IFF(void* p0, int p1, struct S_IFF p2) { return p0; }
+EXPORT void* f15_P_PIS_IFD(void* p0, int p1, struct S_IFD p2) { return p0; }
+EXPORT void* f15_P_PIS_IFP(void* p0, int p1, struct S_IFP p2) { return p0; }
+EXPORT void* f15_P_PIS_IDI(void* p0, int p1, struct S_IDI p2) { return p0; }
+EXPORT void* f15_P_PIS_IDF(void* p0, int p1, struct S_IDF p2) { return p0; }
+EXPORT void* f15_P_PIS_IDD(void* p0, int p1, struct S_IDD p2) { return p0; }
+EXPORT void* f15_P_PIS_IDP(void* p0, int p1, struct S_IDP p2) { return p0; }
+EXPORT void* f15_P_PIS_IPI(void* p0, int p1, struct S_IPI p2) { return p0; }
+EXPORT void* f15_P_PIS_IPF(void* p0, int p1, struct S_IPF p2) { return p0; }
+EXPORT void* f15_P_PIS_IPD(void* p0, int p1, struct S_IPD p2) { return p0; }
+EXPORT void* f15_P_PIS_IPP(void* p0, int p1, struct S_IPP p2) { return p0; }
+EXPORT void* f15_P_PIS_FII(void* p0, int p1, struct S_FII p2) { return p0; }
+EXPORT void* f15_P_PIS_FIF(void* p0, int p1, struct S_FIF p2) { return p0; }
+EXPORT void* f15_P_PIS_FID(void* p0, int p1, struct S_FID p2) { return p0; }
+EXPORT void* f15_P_PIS_FIP(void* p0, int p1, struct S_FIP p2) { return p0; }
+EXPORT void* f15_P_PIS_FFI(void* p0, int p1, struct S_FFI p2) { return p0; }
+EXPORT void* f15_P_PIS_FFF(void* p0, int p1, struct S_FFF p2) { return p0; }
+EXPORT void* f15_P_PIS_FFD(void* p0, int p1, struct S_FFD p2) { return p0; }
+EXPORT void* f15_P_PIS_FFP(void* p0, int p1, struct S_FFP p2) { return p0; }
+EXPORT void* f15_P_PIS_FDI(void* p0, int p1, struct S_FDI p2) { return p0; }
+EXPORT void* f15_P_PIS_FDF(void* p0, int p1, struct S_FDF p2) { return p0; }
+EXPORT void* f15_P_PIS_FDD(void* p0, int p1, struct S_FDD p2) { return p0; }
+EXPORT void* f15_P_PIS_FDP(void* p0, int p1, struct S_FDP p2) { return p0; }
+EXPORT void* f15_P_PIS_FPI(void* p0, int p1, struct S_FPI p2) { return p0; }
+EXPORT void* f15_P_PIS_FPF(void* p0, int p1, struct S_FPF p2) { return p0; }
+EXPORT void* f15_P_PIS_FPD(void* p0, int p1, struct S_FPD p2) { return p0; }
+EXPORT void* f15_P_PIS_FPP(void* p0, int p1, struct S_FPP p2) { return p0; }
+EXPORT void* f15_P_PIS_DII(void* p0, int p1, struct S_DII p2) { return p0; }
+EXPORT void* f15_P_PIS_DIF(void* p0, int p1, struct S_DIF p2) { return p0; }
+EXPORT void* f15_P_PIS_DID(void* p0, int p1, struct S_DID p2) { return p0; }
+EXPORT void* f15_P_PIS_DIP(void* p0, int p1, struct S_DIP p2) { return p0; }
+EXPORT void* f15_P_PIS_DFI(void* p0, int p1, struct S_DFI p2) { return p0; }
+EXPORT void* f15_P_PIS_DFF(void* p0, int p1, struct S_DFF p2) { return p0; }
+EXPORT void* f15_P_PIS_DFD(void* p0, int p1, struct S_DFD p2) { return p0; }
+EXPORT void* f15_P_PIS_DFP(void* p0, int p1, struct S_DFP p2) { return p0; }
+EXPORT void* f15_P_PIS_DDI(void* p0, int p1, struct S_DDI p2) { return p0; }
+EXPORT void* f15_P_PIS_DDF(void* p0, int p1, struct S_DDF p2) { return p0; }
+EXPORT void* f15_P_PIS_DDD(void* p0, int p1, struct S_DDD p2) { return p0; }
+EXPORT void* f15_P_PIS_DDP(void* p0, int p1, struct S_DDP p2) { return p0; }
+EXPORT void* f15_P_PIS_DPI(void* p0, int p1, struct S_DPI p2) { return p0; }
+EXPORT void* f15_P_PIS_DPF(void* p0, int p1, struct S_DPF p2) { return p0; }
+EXPORT void* f15_P_PIS_DPD(void* p0, int p1, struct S_DPD p2) { return p0; }
+EXPORT void* f15_P_PIS_DPP(void* p0, int p1, struct S_DPP p2) { return p0; }
+EXPORT void* f15_P_PIS_PII(void* p0, int p1, struct S_PII p2) { return p0; }
+EXPORT void* f15_P_PIS_PIF(void* p0, int p1, struct S_PIF p2) { return p0; }
+EXPORT void* f15_P_PIS_PID(void* p0, int p1, struct S_PID p2) { return p0; }
+EXPORT void* f15_P_PIS_PIP(void* p0, int p1, struct S_PIP p2) { return p0; }
+EXPORT void* f15_P_PIS_PFI(void* p0, int p1, struct S_PFI p2) { return p0; }
+EXPORT void* f15_P_PIS_PFF(void* p0, int p1, struct S_PFF p2) { return p0; }
+EXPORT void* f15_P_PIS_PFD(void* p0, int p1, struct S_PFD p2) { return p0; }
+EXPORT void* f15_P_PIS_PFP(void* p0, int p1, struct S_PFP p2) { return p0; }
+EXPORT void* f15_P_PIS_PDI(void* p0, int p1, struct S_PDI p2) { return p0; }
+EXPORT void* f15_P_PIS_PDF(void* p0, int p1, struct S_PDF p2) { return p0; }
+EXPORT void* f15_P_PIS_PDD(void* p0, int p1, struct S_PDD p2) { return p0; }
+EXPORT void* f15_P_PIS_PDP(void* p0, int p1, struct S_PDP p2) { return p0; }
+EXPORT void* f15_P_PIS_PPI(void* p0, int p1, struct S_PPI p2) { return p0; }
+EXPORT void* f15_P_PIS_PPF(void* p0, int p1, struct S_PPF p2) { return p0; }
+EXPORT void* f15_P_PIS_PPD(void* p0, int p1, struct S_PPD p2) { return p0; }
+EXPORT void* f15_P_PIS_PPP(void* p0, int p1, struct S_PPP p2) { return p0; }
+EXPORT void* f15_P_PFI_(void* p0, float p1, int p2) { return p0; }
+EXPORT void* f15_P_PFF_(void* p0, float p1, float p2) { return p0; }
+EXPORT void* f15_P_PFD_(void* p0, float p1, double p2) { return p0; }
+EXPORT void* f15_P_PFP_(void* p0, float p1, void* p2) { return p0; }
+EXPORT void* f15_P_PFS_I(void* p0, float p1, struct S_I p2) { return p0; }
+EXPORT void* f15_P_PFS_F(void* p0, float p1, struct S_F p2) { return p0; }
+EXPORT void* f15_P_PFS_D(void* p0, float p1, struct S_D p2) { return p0; }
+EXPORT void* f15_P_PFS_P(void* p0, float p1, struct S_P p2) { return p0; }
+EXPORT void* f15_P_PFS_II(void* p0, float p1, struct S_II p2) { return p0; }
+EXPORT void* f15_P_PFS_IF(void* p0, float p1, struct S_IF p2) { return p0; }
+EXPORT void* f15_P_PFS_ID(void* p0, float p1, struct S_ID p2) { return p0; }
+EXPORT void* f15_P_PFS_IP(void* p0, float p1, struct S_IP p2) { return p0; }
+EXPORT void* f15_P_PFS_FI(void* p0, float p1, struct S_FI p2) { return p0; }
+EXPORT void* f15_P_PFS_FF(void* p0, float p1, struct S_FF p2) { return p0; }
+EXPORT void* f15_P_PFS_FD(void* p0, float p1, struct S_FD p2) { return p0; }
+EXPORT void* f15_P_PFS_FP(void* p0, float p1, struct S_FP p2) { return p0; }
+EXPORT void* f15_P_PFS_DI(void* p0, float p1, struct S_DI p2) { return p0; }
+EXPORT void* f15_P_PFS_DF(void* p0, float p1, struct S_DF p2) { return p0; }
+EXPORT void* f15_P_PFS_DD(void* p0, float p1, struct S_DD p2) { return p0; }
+EXPORT void* f15_P_PFS_DP(void* p0, float p1, struct S_DP p2) { return p0; }
+EXPORT void* f15_P_PFS_PI(void* p0, float p1, struct S_PI p2) { return p0; }
+EXPORT void* f15_P_PFS_PF(void* p0, float p1, struct S_PF p2) { return p0; }
+EXPORT void* f15_P_PFS_PD(void* p0, float p1, struct S_PD p2) { return p0; }
+EXPORT void* f15_P_PFS_PP(void* p0, float p1, struct S_PP p2) { return p0; }
+EXPORT void* f15_P_PFS_III(void* p0, float p1, struct S_III p2) { return p0; }
+EXPORT void* f15_P_PFS_IIF(void* p0, float p1, struct S_IIF p2) { return p0; }
+EXPORT void* f15_P_PFS_IID(void* p0, float p1, struct S_IID p2) { return p0; }
+EXPORT void* f15_P_PFS_IIP(void* p0, float p1, struct S_IIP p2) { return p0; }
+EXPORT void* f15_P_PFS_IFI(void* p0, float p1, struct S_IFI p2) { return p0; }
+EXPORT void* f15_P_PFS_IFF(void* p0, float p1, struct S_IFF p2) { return p0; }
+EXPORT void* f15_P_PFS_IFD(void* p0, float p1, struct S_IFD p2) { return p0; }
+EXPORT void* f15_P_PFS_IFP(void* p0, float p1, struct S_IFP p2) { return p0; }
+EXPORT void* f15_P_PFS_IDI(void* p0, float p1, struct S_IDI p2) { return p0; }
+EXPORT void* f15_P_PFS_IDF(void* p0, float p1, struct S_IDF p2) { return p0; }
+EXPORT void* f15_P_PFS_IDD(void* p0, float p1, struct S_IDD p2) { return p0; }
+EXPORT void* f15_P_PFS_IDP(void* p0, float p1, struct S_IDP p2) { return p0; }
+EXPORT void* f15_P_PFS_IPI(void* p0, float p1, struct S_IPI p2) { return p0; }
+EXPORT void* f15_P_PFS_IPF(void* p0, float p1, struct S_IPF p2) { return p0; }
+EXPORT void* f15_P_PFS_IPD(void* p0, float p1, struct S_IPD p2) { return p0; }
+EXPORT void* f15_P_PFS_IPP(void* p0, float p1, struct S_IPP p2) { return p0; }
+EXPORT void* f15_P_PFS_FII(void* p0, float p1, struct S_FII p2) { return p0; }
+EXPORT void* f15_P_PFS_FIF(void* p0, float p1, struct S_FIF p2) { return p0; }
+EXPORT void* f15_P_PFS_FID(void* p0, float p1, struct S_FID p2) { return p0; }
+EXPORT void* f15_P_PFS_FIP(void* p0, float p1, struct S_FIP p2) { return p0; }
+EXPORT void* f15_P_PFS_FFI(void* p0, float p1, struct S_FFI p2) { return p0; }
+EXPORT void* f15_P_PFS_FFF(void* p0, float p1, struct S_FFF p2) { return p0; }
+EXPORT void* f15_P_PFS_FFD(void* p0, float p1, struct S_FFD p2) { return p0; }
+EXPORT void* f15_P_PFS_FFP(void* p0, float p1, struct S_FFP p2) { return p0; }
+EXPORT void* f15_P_PFS_FDI(void* p0, float p1, struct S_FDI p2) { return p0; }
+EXPORT void* f15_P_PFS_FDF(void* p0, float p1, struct S_FDF p2) { return p0; }
+EXPORT void* f15_P_PFS_FDD(void* p0, float p1, struct S_FDD p2) { return p0; }
+EXPORT void* f15_P_PFS_FDP(void* p0, float p1, struct S_FDP p2) { return p0; }
+EXPORT void* f15_P_PFS_FPI(void* p0, float p1, struct S_FPI p2) { return p0; }
+EXPORT void* f15_P_PFS_FPF(void* p0, float p1, struct S_FPF p2) { return p0; }
+EXPORT void* f15_P_PFS_FPD(void* p0, float p1, struct S_FPD p2) { return p0; }
+EXPORT void* f15_P_PFS_FPP(void* p0, float p1, struct S_FPP p2) { return p0; }
+EXPORT void* f15_P_PFS_DII(void* p0, float p1, struct S_DII p2) { return p0; }
+EXPORT void* f15_P_PFS_DIF(void* p0, float p1, struct S_DIF p2) { return p0; }
+EXPORT void* f15_P_PFS_DID(void* p0, float p1, struct S_DID p2) { return p0; }
+EXPORT void* f15_P_PFS_DIP(void* p0, float p1, struct S_DIP p2) { return p0; }
+EXPORT void* f15_P_PFS_DFI(void* p0, float p1, struct S_DFI p2) { return p0; }
+EXPORT void* f15_P_PFS_DFF(void* p0, float p1, struct S_DFF p2) { return p0; }
+EXPORT void* f15_P_PFS_DFD(void* p0, float p1, struct S_DFD p2) { return p0; }
+EXPORT void* f15_P_PFS_DFP(void* p0, float p1, struct S_DFP p2) { return p0; }
+EXPORT void* f15_P_PFS_DDI(void* p0, float p1, struct S_DDI p2) { return p0; }
+EXPORT void* f15_P_PFS_DDF(void* p0, float p1, struct S_DDF p2) { return p0; }
+EXPORT void* f15_P_PFS_DDD(void* p0, float p1, struct S_DDD p2) { return p0; }
+EXPORT void* f15_P_PFS_DDP(void* p0, float p1, struct S_DDP p2) { return p0; }
+EXPORT void* f15_P_PFS_DPI(void* p0, float p1, struct S_DPI p2) { return p0; }
+EXPORT void* f15_P_PFS_DPF(void* p0, float p1, struct S_DPF p2) { return p0; }
+EXPORT void* f15_P_PFS_DPD(void* p0, float p1, struct S_DPD p2) { return p0; }
+EXPORT void* f15_P_PFS_DPP(void* p0, float p1, struct S_DPP p2) { return p0; }
+EXPORT void* f15_P_PFS_PII(void* p0, float p1, struct S_PII p2) { return p0; }
+EXPORT void* f15_P_PFS_PIF(void* p0, float p1, struct S_PIF p2) { return p0; }
+EXPORT void* f15_P_PFS_PID(void* p0, float p1, struct S_PID p2) { return p0; }
+EXPORT void* f15_P_PFS_PIP(void* p0, float p1, struct S_PIP p2) { return p0; }
+EXPORT void* f15_P_PFS_PFI(void* p0, float p1, struct S_PFI p2) { return p0; }
+EXPORT void* f15_P_PFS_PFF(void* p0, float p1, struct S_PFF p2) { return p0; }
+EXPORT void* f15_P_PFS_PFD(void* p0, float p1, struct S_PFD p2) { return p0; }
+EXPORT void* f15_P_PFS_PFP(void* p0, float p1, struct S_PFP p2) { return p0; }
+EXPORT void* f15_P_PFS_PDI(void* p0, float p1, struct S_PDI p2) { return p0; }
+EXPORT void* f15_P_PFS_PDF(void* p0, float p1, struct S_PDF p2) { return p0; }
+EXPORT void* f15_P_PFS_PDD(void* p0, float p1, struct S_PDD p2) { return p0; }
+EXPORT void* f15_P_PFS_PDP(void* p0, float p1, struct S_PDP p2) { return p0; }
+EXPORT void* f15_P_PFS_PPI(void* p0, float p1, struct S_PPI p2) { return p0; }
+EXPORT void* f15_P_PFS_PPF(void* p0, float p1, struct S_PPF p2) { return p0; }
+EXPORT void* f15_P_PFS_PPD(void* p0, float p1, struct S_PPD p2) { return p0; }
+EXPORT void* f15_P_PFS_PPP(void* p0, float p1, struct S_PPP p2) { return p0; }
+EXPORT void* f15_P_PDI_(void* p0, double p1, int p2) { return p0; }
+EXPORT void* f15_P_PDF_(void* p0, double p1, float p2) { return p0; }
+EXPORT void* f15_P_PDD_(void* p0, double p1, double p2) { return p0; }
+EXPORT void* f15_P_PDP_(void* p0, double p1, void* p2) { return p0; }
+EXPORT void* f15_P_PDS_I(void* p0, double p1, struct S_I p2) { return p0; }
+EXPORT void* f15_P_PDS_F(void* p0, double p1, struct S_F p2) { return p0; }
+EXPORT void* f15_P_PDS_D(void* p0, double p1, struct S_D p2) { return p0; }
+EXPORT void* f15_P_PDS_P(void* p0, double p1, struct S_P p2) { return p0; }
+EXPORT void* f15_P_PDS_II(void* p0, double p1, struct S_II p2) { return p0; }
+EXPORT void* f15_P_PDS_IF(void* p0, double p1, struct S_IF p2) { return p0; }
+EXPORT void* f15_P_PDS_ID(void* p0, double p1, struct S_ID p2) { return p0; }
+EXPORT void* f15_P_PDS_IP(void* p0, double p1, struct S_IP p2) { return p0; }
+EXPORT void* f15_P_PDS_FI(void* p0, double p1, struct S_FI p2) { return p0; }
+EXPORT void* f15_P_PDS_FF(void* p0, double p1, struct S_FF p2) { return p0; }
+EXPORT void* f15_P_PDS_FD(void* p0, double p1, struct S_FD p2) { return p0; }
+EXPORT void* f15_P_PDS_FP(void* p0, double p1, struct S_FP p2) { return p0; }
+EXPORT void* f15_P_PDS_DI(void* p0, double p1, struct S_DI p2) { return p0; }
+EXPORT void* f15_P_PDS_DF(void* p0, double p1, struct S_DF p2) { return p0; }
+EXPORT void* f15_P_PDS_DD(void* p0, double p1, struct S_DD p2) { return p0; }
+EXPORT void* f15_P_PDS_DP(void* p0, double p1, struct S_DP p2) { return p0; }
+EXPORT void* f15_P_PDS_PI(void* p0, double p1, struct S_PI p2) { return p0; }
+EXPORT void* f15_P_PDS_PF(void* p0, double p1, struct S_PF p2) { return p0; }
+EXPORT void* f15_P_PDS_PD(void* p0, double p1, struct S_PD p2) { return p0; }
+EXPORT void* f15_P_PDS_PP(void* p0, double p1, struct S_PP p2) { return p0; }
+EXPORT void* f15_P_PDS_III(void* p0, double p1, struct S_III p2) { return p0; }
+EXPORT void* f15_P_PDS_IIF(void* p0, double p1, struct S_IIF p2) { return p0; }
+EXPORT void* f15_P_PDS_IID(void* p0, double p1, struct S_IID p2) { return p0; }
+EXPORT void* f15_P_PDS_IIP(void* p0, double p1, struct S_IIP p2) { return p0; }
+EXPORT void* f15_P_PDS_IFI(void* p0, double p1, struct S_IFI p2) { return p0; }
+EXPORT void* f15_P_PDS_IFF(void* p0, double p1, struct S_IFF p2) { return p0; }
+EXPORT void* f15_P_PDS_IFD(void* p0, double p1, struct S_IFD p2) { return p0; }
+EXPORT void* f15_P_PDS_IFP(void* p0, double p1, struct S_IFP p2) { return p0; }
+EXPORT void* f15_P_PDS_IDI(void* p0, double p1, struct S_IDI p2) { return p0; }
+EXPORT void* f15_P_PDS_IDF(void* p0, double p1, struct S_IDF p2) { return p0; }
+EXPORT void* f15_P_PDS_IDD(void* p0, double p1, struct S_IDD p2) { return p0; }
+EXPORT void* f15_P_PDS_IDP(void* p0, double p1, struct S_IDP p2) { return p0; }
+EXPORT void* f15_P_PDS_IPI(void* p0, double p1, struct S_IPI p2) { return p0; }
+EXPORT void* f15_P_PDS_IPF(void* p0, double p1, struct S_IPF p2) { return p0; }
+EXPORT void* f15_P_PDS_IPD(void* p0, double p1, struct S_IPD p2) { return p0; }
+EXPORT void* f15_P_PDS_IPP(void* p0, double p1, struct S_IPP p2) { return p0; }
+EXPORT void* f15_P_PDS_FII(void* p0, double p1, struct S_FII p2) { return p0; }
+EXPORT void* f15_P_PDS_FIF(void* p0, double p1, struct S_FIF p2) { return p0; }
+EXPORT void* f15_P_PDS_FID(void* p0, double p1, struct S_FID p2) { return p0; }
+EXPORT void* f15_P_PDS_FIP(void* p0, double p1, struct S_FIP p2) { return p0; }
+EXPORT void* f15_P_PDS_FFI(void* p0, double p1, struct S_FFI p2) { return p0; }
+EXPORT void* f15_P_PDS_FFF(void* p0, double p1, struct S_FFF p2) { return p0; }
+EXPORT void* f15_P_PDS_FFD(void* p0, double p1, struct S_FFD p2) { return p0; }
+EXPORT void* f15_P_PDS_FFP(void* p0, double p1, struct S_FFP p2) { return p0; }
+EXPORT void* f15_P_PDS_FDI(void* p0, double p1, struct S_FDI p2) { return p0; }
+EXPORT void* f15_P_PDS_FDF(void* p0, double p1, struct S_FDF p2) { return p0; }
+EXPORT void* f15_P_PDS_FDD(void* p0, double p1, struct S_FDD p2) { return p0; }
+EXPORT void* f15_P_PDS_FDP(void* p0, double p1, struct S_FDP p2) { return p0; }
+EXPORT void* f15_P_PDS_FPI(void* p0, double p1, struct S_FPI p2) { return p0; }
+EXPORT void* f15_P_PDS_FPF(void* p0, double p1, struct S_FPF p2) { return p0; }
+EXPORT void* f15_P_PDS_FPD(void* p0, double p1, struct S_FPD p2) { return p0; }
+EXPORT void* f15_P_PDS_FPP(void* p0, double p1, struct S_FPP p2) { return p0; }
+EXPORT void* f15_P_PDS_DII(void* p0, double p1, struct S_DII p2) { return p0; }
+EXPORT void* f15_P_PDS_DIF(void* p0, double p1, struct S_DIF p2) { return p0; }
+EXPORT void* f15_P_PDS_DID(void* p0, double p1, struct S_DID p2) { return p0; }
+EXPORT void* f15_P_PDS_DIP(void* p0, double p1, struct S_DIP p2) { return p0; }
+EXPORT void* f15_P_PDS_DFI(void* p0, double p1, struct S_DFI p2) { return p0; }
+EXPORT void* f15_P_PDS_DFF(void* p0, double p1, struct S_DFF p2) { return p0; }
+EXPORT void* f15_P_PDS_DFD(void* p0, double p1, struct S_DFD p2) { return p0; }
+EXPORT void* f15_P_PDS_DFP(void* p0, double p1, struct S_DFP p2) { return p0; }
+EXPORT void* f15_P_PDS_DDI(void* p0, double p1, struct S_DDI p2) { return p0; }
+EXPORT void* f15_P_PDS_DDF(void* p0, double p1, struct S_DDF p2) { return p0; }
+EXPORT void* f15_P_PDS_DDD(void* p0, double p1, struct S_DDD p2) { return p0; }
+EXPORT void* f15_P_PDS_DDP(void* p0, double p1, struct S_DDP p2) { return p0; }
+EXPORT void* f15_P_PDS_DPI(void* p0, double p1, struct S_DPI p2) { return p0; }
+EXPORT void* f15_P_PDS_DPF(void* p0, double p1, struct S_DPF p2) { return p0; }
+EXPORT void* f15_P_PDS_DPD(void* p0, double p1, struct S_DPD p2) { return p0; }
+EXPORT void* f15_P_PDS_DPP(void* p0, double p1, struct S_DPP p2) { return p0; }
+EXPORT void* f15_P_PDS_PII(void* p0, double p1, struct S_PII p2) { return p0; }
+EXPORT void* f15_P_PDS_PIF(void* p0, double p1, struct S_PIF p2) { return p0; }
+EXPORT void* f15_P_PDS_PID(void* p0, double p1, struct S_PID p2) { return p0; }
+EXPORT void* f15_P_PDS_PIP(void* p0, double p1, struct S_PIP p2) { return p0; }
+EXPORT void* f15_P_PDS_PFI(void* p0, double p1, struct S_PFI p2) { return p0; }
+EXPORT void* f15_P_PDS_PFF(void* p0, double p1, struct S_PFF p2) { return p0; }
+EXPORT void* f15_P_PDS_PFD(void* p0, double p1, struct S_PFD p2) { return p0; }
+EXPORT void* f15_P_PDS_PFP(void* p0, double p1, struct S_PFP p2) { return p0; }
+EXPORT void* f15_P_PDS_PDI(void* p0, double p1, struct S_PDI p2) { return p0; }
+EXPORT void* f15_P_PDS_PDF(void* p0, double p1, struct S_PDF p2) { return p0; }
+EXPORT void* f15_P_PDS_PDD(void* p0, double p1, struct S_PDD p2) { return p0; }
+EXPORT void* f15_P_PDS_PDP(void* p0, double p1, struct S_PDP p2) { return p0; }
+EXPORT void* f15_P_PDS_PPI(void* p0, double p1, struct S_PPI p2) { return p0; }
+EXPORT void* f15_P_PDS_PPF(void* p0, double p1, struct S_PPF p2) { return p0; }
+EXPORT void* f15_P_PDS_PPD(void* p0, double p1, struct S_PPD p2) { return p0; }
+EXPORT void* f15_P_PDS_PPP(void* p0, double p1, struct S_PPP p2) { return p0; }
+EXPORT void* f15_P_PPI_(void* p0, void* p1, int p2) { return p0; }
+EXPORT void* f15_P_PPF_(void* p0, void* p1, float p2) { return p0; }
+EXPORT void* f15_P_PPD_(void* p0, void* p1, double p2) { return p0; }
+EXPORT void* f15_P_PPP_(void* p0, void* p1, void* p2) { return p0; }
+EXPORT void* f15_P_PPS_I(void* p0, void* p1, struct S_I p2) { return p0; }
+EXPORT void* f15_P_PPS_F(void* p0, void* p1, struct S_F p2) { return p0; }
+EXPORT void* f15_P_PPS_D(void* p0, void* p1, struct S_D p2) { return p0; }
+EXPORT void* f15_P_PPS_P(void* p0, void* p1, struct S_P p2) { return p0; }
+EXPORT void* f15_P_PPS_II(void* p0, void* p1, struct S_II p2) { return p0; }
+EXPORT void* f15_P_PPS_IF(void* p0, void* p1, struct S_IF p2) { return p0; }
+EXPORT void* f15_P_PPS_ID(void* p0, void* p1, struct S_ID p2) { return p0; }
+EXPORT void* f15_P_PPS_IP(void* p0, void* p1, struct S_IP p2) { return p0; }
+EXPORT void* f15_P_PPS_FI(void* p0, void* p1, struct S_FI p2) { return p0; }
+EXPORT void* f15_P_PPS_FF(void* p0, void* p1, struct S_FF p2) { return p0; }
+EXPORT void* f15_P_PPS_FD(void* p0, void* p1, struct S_FD p2) { return p0; }
+EXPORT void* f15_P_PPS_FP(void* p0, void* p1, struct S_FP p2) { return p0; }
+EXPORT void* f15_P_PPS_DI(void* p0, void* p1, struct S_DI p2) { return p0; }
+EXPORT void* f15_P_PPS_DF(void* p0, void* p1, struct S_DF p2) { return p0; }
+EXPORT void* f15_P_PPS_DD(void* p0, void* p1, struct S_DD p2) { return p0; }
+EXPORT void* f15_P_PPS_DP(void* p0, void* p1, struct S_DP p2) { return p0; }
+EXPORT void* f15_P_PPS_PI(void* p0, void* p1, struct S_PI p2) { return p0; }
+EXPORT void* f15_P_PPS_PF(void* p0, void* p1, struct S_PF p2) { return p0; }
+EXPORT void* f15_P_PPS_PD(void* p0, void* p1, struct S_PD p2) { return p0; }
+EXPORT void* f15_P_PPS_PP(void* p0, void* p1, struct S_PP p2) { return p0; }
+EXPORT void* f15_P_PPS_III(void* p0, void* p1, struct S_III p2) { return p0; }
+EXPORT void* f15_P_PPS_IIF(void* p0, void* p1, struct S_IIF p2) { return p0; }
+EXPORT void* f15_P_PPS_IID(void* p0, void* p1, struct S_IID p2) { return p0; }
+EXPORT void* f15_P_PPS_IIP(void* p0, void* p1, struct S_IIP p2) { return p0; }
+EXPORT void* f15_P_PPS_IFI(void* p0, void* p1, struct S_IFI p2) { return p0; }
+EXPORT void* f15_P_PPS_IFF(void* p0, void* p1, struct S_IFF p2) { return p0; }
+EXPORT void* f15_P_PPS_IFD(void* p0, void* p1, struct S_IFD p2) { return p0; }
+EXPORT void* f15_P_PPS_IFP(void* p0, void* p1, struct S_IFP p2) { return p0; }
+EXPORT void* f15_P_PPS_IDI(void* p0, void* p1, struct S_IDI p2) { return p0; }
+EXPORT void* f15_P_PPS_IDF(void* p0, void* p1, struct S_IDF p2) { return p0; }
+EXPORT void* f15_P_PPS_IDD(void* p0, void* p1, struct S_IDD p2) { return p0; }
+EXPORT void* f15_P_PPS_IDP(void* p0, void* p1, struct S_IDP p2) { return p0; }
+EXPORT void* f15_P_PPS_IPI(void* p0, void* p1, struct S_IPI p2) { return p0; }
+EXPORT void* f15_P_PPS_IPF(void* p0, void* p1, struct S_IPF p2) { return p0; }
+EXPORT void* f15_P_PPS_IPD(void* p0, void* p1, struct S_IPD p2) { return p0; }
+EXPORT void* f15_P_PPS_IPP(void* p0, void* p1, struct S_IPP p2) { return p0; }
+EXPORT void* f15_P_PPS_FII(void* p0, void* p1, struct S_FII p2) { return p0; }
+EXPORT void* f15_P_PPS_FIF(void* p0, void* p1, struct S_FIF p2) { return p0; }
+EXPORT void* f15_P_PPS_FID(void* p0, void* p1, struct S_FID p2) { return p0; }
+EXPORT void* f15_P_PPS_FIP(void* p0, void* p1, struct S_FIP p2) { return p0; }
+EXPORT void* f15_P_PPS_FFI(void* p0, void* p1, struct S_FFI p2) { return p0; }
+EXPORT void* f15_P_PPS_FFF(void* p0, void* p1, struct S_FFF p2) { return p0; }
+EXPORT void* f15_P_PPS_FFD(void* p0, void* p1, struct S_FFD p2) { return p0; }
+EXPORT void* f15_P_PPS_FFP(void* p0, void* p1, struct S_FFP p2) { return p0; }
+EXPORT void* f15_P_PPS_FDI(void* p0, void* p1, struct S_FDI p2) { return p0; }
+EXPORT void* f15_P_PPS_FDF(void* p0, void* p1, struct S_FDF p2) { return p0; }
+EXPORT void* f15_P_PPS_FDD(void* p0, void* p1, struct S_FDD p2) { return p0; }
+EXPORT void* f15_P_PPS_FDP(void* p0, void* p1, struct S_FDP p2) { return p0; }
+EXPORT void* f15_P_PPS_FPI(void* p0, void* p1, struct S_FPI p2) { return p0; }
+EXPORT void* f15_P_PPS_FPF(void* p0, void* p1, struct S_FPF p2) { return p0; }
+EXPORT void* f15_P_PPS_FPD(void* p0, void* p1, struct S_FPD p2) { return p0; }
+EXPORT void* f15_P_PPS_FPP(void* p0, void* p1, struct S_FPP p2) { return p0; }
+EXPORT void* f15_P_PPS_DII(void* p0, void* p1, struct S_DII p2) { return p0; }
+EXPORT void* f15_P_PPS_DIF(void* p0, void* p1, struct S_DIF p2) { return p0; }
+EXPORT void* f15_P_PPS_DID(void* p0, void* p1, struct S_DID p2) { return p0; }
+EXPORT void* f15_P_PPS_DIP(void* p0, void* p1, struct S_DIP p2) { return p0; }
+EXPORT void* f15_P_PPS_DFI(void* p0, void* p1, struct S_DFI p2) { return p0; }
+EXPORT void* f15_P_PPS_DFF(void* p0, void* p1, struct S_DFF p2) { return p0; }
+EXPORT void* f15_P_PPS_DFD(void* p0, void* p1, struct S_DFD p2) { return p0; }
+EXPORT void* f15_P_PPS_DFP(void* p0, void* p1, struct S_DFP p2) { return p0; }
+EXPORT void* f15_P_PPS_DDI(void* p0, void* p1, struct S_DDI p2) { return p0; }
+EXPORT void* f15_P_PPS_DDF(void* p0, void* p1, struct S_DDF p2) { return p0; }
+EXPORT void* f15_P_PPS_DDD(void* p0, void* p1, struct S_DDD p2) { return p0; }
+EXPORT void* f15_P_PPS_DDP(void* p0, void* p1, struct S_DDP p2) { return p0; }
+EXPORT void* f15_P_PPS_DPI(void* p0, void* p1, struct S_DPI p2) { return p0; }
+EXPORT void* f15_P_PPS_DPF(void* p0, void* p1, struct S_DPF p2) { return p0; }
+EXPORT void* f15_P_PPS_DPD(void* p0, void* p1, struct S_DPD p2) { return p0; }
+EXPORT void* f15_P_PPS_DPP(void* p0, void* p1, struct S_DPP p2) { return p0; }
+EXPORT void* f15_P_PPS_PII(void* p0, void* p1, struct S_PII p2) { return p0; }
+EXPORT void* f15_P_PPS_PIF(void* p0, void* p1, struct S_PIF p2) { return p0; }
+EXPORT void* f15_P_PPS_PID(void* p0, void* p1, struct S_PID p2) { return p0; }
+EXPORT void* f15_P_PPS_PIP(void* p0, void* p1, struct S_PIP p2) { return p0; }
+EXPORT void* f15_P_PPS_PFI(void* p0, void* p1, struct S_PFI p2) { return p0; }
+EXPORT void* f15_P_PPS_PFF(void* p0, void* p1, struct S_PFF p2) { return p0; }
+EXPORT void* f15_P_PPS_PFD(void* p0, void* p1, struct S_PFD p2) { return p0; }
+EXPORT void* f15_P_PPS_PFP(void* p0, void* p1, struct S_PFP p2) { return p0; }
+EXPORT void* f15_P_PPS_PDI(void* p0, void* p1, struct S_PDI p2) { return p0; }
+EXPORT void* f15_P_PPS_PDF(void* p0, void* p1, struct S_PDF p2) { return p0; }
+EXPORT void* f15_P_PPS_PDD(void* p0, void* p1, struct S_PDD p2) { return p0; }
+EXPORT void* f15_P_PPS_PDP(void* p0, void* p1, struct S_PDP p2) { return p0; }
+EXPORT void* f15_P_PPS_PPI(void* p0, void* p1, struct S_PPI p2) { return p0; }
+EXPORT void* f15_P_PPS_PPF(void* p0, void* p1, struct S_PPF p2) { return p0; }
+EXPORT void* f15_P_PPS_PPD(void* p0, void* p1, struct S_PPD p2) { return p0; }
+EXPORT void* f15_P_PPS_PPP(void* p0, void* p1, struct S_PPP p2) { return p0; }
+EXPORT void* f15_P_PSI_I(void* p0, struct S_I p1, int p2) { return p0; }
+EXPORT void* f15_P_PSI_F(void* p0, struct S_F p1, int p2) { return p0; }
+EXPORT void* f15_P_PSI_D(void* p0, struct S_D p1, int p2) { return p0; }
+EXPORT void* f15_P_PSI_P(void* p0, struct S_P p1, int p2) { return p0; }
+EXPORT void* f15_P_PSI_II(void* p0, struct S_II p1, int p2) { return p0; }
+EXPORT void* f15_P_PSI_IF(void* p0, struct S_IF p1, int p2) { return p0; }
+EXPORT void* f15_P_PSI_ID(void* p0, struct S_ID p1, int p2) { return p0; }
+EXPORT void* f15_P_PSI_IP(void* p0, struct S_IP p1, int p2) { return p0; }
+EXPORT void* f15_P_PSI_FI(void* p0, struct S_FI p1, int p2) { return p0; }
+EXPORT void* f15_P_PSI_FF(void* p0, struct S_FF p1, int p2) { return p0; }
+EXPORT void* f15_P_PSI_FD(void* p0, struct S_FD p1, int p2) { return p0; }
+EXPORT void* f15_P_PSI_FP(void* p0, struct S_FP p1, int p2) { return p0; }
+EXPORT void* f15_P_PSI_DI(void* p0, struct S_DI p1, int p2) { return p0; }
+EXPORT void* f15_P_PSI_DF(void* p0, struct S_DF p1, int p2) { return p0; }
+EXPORT void* f15_P_PSI_DD(void* p0, struct S_DD p1, int p2) { return p0; }
+EXPORT void* f15_P_PSI_DP(void* p0, struct S_DP p1, int p2) { return p0; }
+EXPORT void* f15_P_PSI_PI(void* p0, struct S_PI p1, int p2) { return p0; }
+EXPORT void* f15_P_PSI_PF(void* p0, struct S_PF p1, int p2) { return p0; }
+EXPORT void* f15_P_PSI_PD(void* p0, struct S_PD p1, int p2) { return p0; }
+EXPORT void* f15_P_PSI_PP(void* p0, struct S_PP p1, int p2) { return p0; }
+EXPORT void* f15_P_PSI_III(void* p0, struct S_III p1, int p2) { return p0; }
+EXPORT void* f15_P_PSI_IIF(void* p0, struct S_IIF p1, int p2) { return p0; }
+EXPORT void* f15_P_PSI_IID(void* p0, struct S_IID p1, int p2) { return p0; }
+EXPORT void* f16_P_PSI_IIP(void* p0, struct S_IIP p1, int p2) { return p0; }
+EXPORT void* f16_P_PSI_IFI(void* p0, struct S_IFI p1, int p2) { return p0; }
+EXPORT void* f16_P_PSI_IFF(void* p0, struct S_IFF p1, int p2) { return p0; }
+EXPORT void* f16_P_PSI_IFD(void* p0, struct S_IFD p1, int p2) { return p0; }
+EXPORT void* f16_P_PSI_IFP(void* p0, struct S_IFP p1, int p2) { return p0; }
+EXPORT void* f16_P_PSI_IDI(void* p0, struct S_IDI p1, int p2) { return p0; }
+EXPORT void* f16_P_PSI_IDF(void* p0, struct S_IDF p1, int p2) { return p0; }
+EXPORT void* f16_P_PSI_IDD(void* p0, struct S_IDD p1, int p2) { return p0; }
+EXPORT void* f16_P_PSI_IDP(void* p0, struct S_IDP p1, int p2) { return p0; }
+EXPORT void* f16_P_PSI_IPI(void* p0, struct S_IPI p1, int p2) { return p0; }
+EXPORT void* f16_P_PSI_IPF(void* p0, struct S_IPF p1, int p2) { return p0; }
+EXPORT void* f16_P_PSI_IPD(void* p0, struct S_IPD p1, int p2) { return p0; }
+EXPORT void* f16_P_PSI_IPP(void* p0, struct S_IPP p1, int p2) { return p0; }
+EXPORT void* f16_P_PSI_FII(void* p0, struct S_FII p1, int p2) { return p0; }
+EXPORT void* f16_P_PSI_FIF(void* p0, struct S_FIF p1, int p2) { return p0; }
+EXPORT void* f16_P_PSI_FID(void* p0, struct S_FID p1, int p2) { return p0; }
+EXPORT void* f16_P_PSI_FIP(void* p0, struct S_FIP p1, int p2) { return p0; }
+EXPORT void* f16_P_PSI_FFI(void* p0, struct S_FFI p1, int p2) { return p0; }
+EXPORT void* f16_P_PSI_FFF(void* p0, struct S_FFF p1, int p2) { return p0; }
+EXPORT void* f16_P_PSI_FFD(void* p0, struct S_FFD p1, int p2) { return p0; }
+EXPORT void* f16_P_PSI_FFP(void* p0, struct S_FFP p1, int p2) { return p0; }
+EXPORT void* f16_P_PSI_FDI(void* p0, struct S_FDI p1, int p2) { return p0; }
+EXPORT void* f16_P_PSI_FDF(void* p0, struct S_FDF p1, int p2) { return p0; }
+EXPORT void* f16_P_PSI_FDD(void* p0, struct S_FDD p1, int p2) { return p0; }
+EXPORT void* f16_P_PSI_FDP(void* p0, struct S_FDP p1, int p2) { return p0; }
+EXPORT void* f16_P_PSI_FPI(void* p0, struct S_FPI p1, int p2) { return p0; }
+EXPORT void* f16_P_PSI_FPF(void* p0, struct S_FPF p1, int p2) { return p0; }
+EXPORT void* f16_P_PSI_FPD(void* p0, struct S_FPD p1, int p2) { return p0; }
+EXPORT void* f16_P_PSI_FPP(void* p0, struct S_FPP p1, int p2) { return p0; }
+EXPORT void* f16_P_PSI_DII(void* p0, struct S_DII p1, int p2) { return p0; }
+EXPORT void* f16_P_PSI_DIF(void* p0, struct S_DIF p1, int p2) { return p0; }
+EXPORT void* f16_P_PSI_DID(void* p0, struct S_DID p1, int p2) { return p0; }
+EXPORT void* f16_P_PSI_DIP(void* p0, struct S_DIP p1, int p2) { return p0; }
+EXPORT void* f16_P_PSI_DFI(void* p0, struct S_DFI p1, int p2) { return p0; }
+EXPORT void* f16_P_PSI_DFF(void* p0, struct S_DFF p1, int p2) { return p0; }
+EXPORT void* f16_P_PSI_DFD(void* p0, struct S_DFD p1, int p2) { return p0; }
+EXPORT void* f16_P_PSI_DFP(void* p0, struct S_DFP p1, int p2) { return p0; }
+EXPORT void* f16_P_PSI_DDI(void* p0, struct S_DDI p1, int p2) { return p0; }
+EXPORT void* f16_P_PSI_DDF(void* p0, struct S_DDF p1, int p2) { return p0; }
+EXPORT void* f16_P_PSI_DDD(void* p0, struct S_DDD p1, int p2) { return p0; }
+EXPORT void* f16_P_PSI_DDP(void* p0, struct S_DDP p1, int p2) { return p0; }
+EXPORT void* f16_P_PSI_DPI(void* p0, struct S_DPI p1, int p2) { return p0; }
+EXPORT void* f16_P_PSI_DPF(void* p0, struct S_DPF p1, int p2) { return p0; }
+EXPORT void* f16_P_PSI_DPD(void* p0, struct S_DPD p1, int p2) { return p0; }
+EXPORT void* f16_P_PSI_DPP(void* p0, struct S_DPP p1, int p2) { return p0; }
+EXPORT void* f16_P_PSI_PII(void* p0, struct S_PII p1, int p2) { return p0; }
+EXPORT void* f16_P_PSI_PIF(void* p0, struct S_PIF p1, int p2) { return p0; }
+EXPORT void* f16_P_PSI_PID(void* p0, struct S_PID p1, int p2) { return p0; }
+EXPORT void* f16_P_PSI_PIP(void* p0, struct S_PIP p1, int p2) { return p0; }
+EXPORT void* f16_P_PSI_PFI(void* p0, struct S_PFI p1, int p2) { return p0; }
+EXPORT void* f16_P_PSI_PFF(void* p0, struct S_PFF p1, int p2) { return p0; }
+EXPORT void* f16_P_PSI_PFD(void* p0, struct S_PFD p1, int p2) { return p0; }
+EXPORT void* f16_P_PSI_PFP(void* p0, struct S_PFP p1, int p2) { return p0; }
+EXPORT void* f16_P_PSI_PDI(void* p0, struct S_PDI p1, int p2) { return p0; }
+EXPORT void* f16_P_PSI_PDF(void* p0, struct S_PDF p1, int p2) { return p0; }
+EXPORT void* f16_P_PSI_PDD(void* p0, struct S_PDD p1, int p2) { return p0; }
+EXPORT void* f16_P_PSI_PDP(void* p0, struct S_PDP p1, int p2) { return p0; }
+EXPORT void* f16_P_PSI_PPI(void* p0, struct S_PPI p1, int p2) { return p0; }
+EXPORT void* f16_P_PSI_PPF(void* p0, struct S_PPF p1, int p2) { return p0; }
+EXPORT void* f16_P_PSI_PPD(void* p0, struct S_PPD p1, int p2) { return p0; }
+EXPORT void* f16_P_PSI_PPP(void* p0, struct S_PPP p1, int p2) { return p0; }
+EXPORT void* f16_P_PSF_I(void* p0, struct S_I p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_F(void* p0, struct S_F p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_D(void* p0, struct S_D p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_P(void* p0, struct S_P p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_II(void* p0, struct S_II p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_IF(void* p0, struct S_IF p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_ID(void* p0, struct S_ID p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_IP(void* p0, struct S_IP p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_FI(void* p0, struct S_FI p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_FF(void* p0, struct S_FF p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_FD(void* p0, struct S_FD p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_FP(void* p0, struct S_FP p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_DI(void* p0, struct S_DI p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_DF(void* p0, struct S_DF p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_DD(void* p0, struct S_DD p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_DP(void* p0, struct S_DP p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_PI(void* p0, struct S_PI p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_PF(void* p0, struct S_PF p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_PD(void* p0, struct S_PD p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_PP(void* p0, struct S_PP p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_III(void* p0, struct S_III p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_IIF(void* p0, struct S_IIF p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_IID(void* p0, struct S_IID p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_IIP(void* p0, struct S_IIP p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_IFI(void* p0, struct S_IFI p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_IFF(void* p0, struct S_IFF p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_IFD(void* p0, struct S_IFD p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_IFP(void* p0, struct S_IFP p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_IDI(void* p0, struct S_IDI p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_IDF(void* p0, struct S_IDF p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_IDD(void* p0, struct S_IDD p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_IDP(void* p0, struct S_IDP p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_IPI(void* p0, struct S_IPI p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_IPF(void* p0, struct S_IPF p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_IPD(void* p0, struct S_IPD p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_IPP(void* p0, struct S_IPP p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_FII(void* p0, struct S_FII p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_FIF(void* p0, struct S_FIF p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_FID(void* p0, struct S_FID p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_FIP(void* p0, struct S_FIP p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_FFI(void* p0, struct S_FFI p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_FFF(void* p0, struct S_FFF p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_FFD(void* p0, struct S_FFD p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_FFP(void* p0, struct S_FFP p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_FDI(void* p0, struct S_FDI p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_FDF(void* p0, struct S_FDF p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_FDD(void* p0, struct S_FDD p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_FDP(void* p0, struct S_FDP p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_FPI(void* p0, struct S_FPI p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_FPF(void* p0, struct S_FPF p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_FPD(void* p0, struct S_FPD p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_FPP(void* p0, struct S_FPP p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_DII(void* p0, struct S_DII p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_DIF(void* p0, struct S_DIF p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_DID(void* p0, struct S_DID p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_DIP(void* p0, struct S_DIP p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_DFI(void* p0, struct S_DFI p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_DFF(void* p0, struct S_DFF p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_DFD(void* p0, struct S_DFD p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_DFP(void* p0, struct S_DFP p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_DDI(void* p0, struct S_DDI p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_DDF(void* p0, struct S_DDF p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_DDD(void* p0, struct S_DDD p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_DDP(void* p0, struct S_DDP p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_DPI(void* p0, struct S_DPI p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_DPF(void* p0, struct S_DPF p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_DPD(void* p0, struct S_DPD p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_DPP(void* p0, struct S_DPP p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_PII(void* p0, struct S_PII p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_PIF(void* p0, struct S_PIF p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_PID(void* p0, struct S_PID p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_PIP(void* p0, struct S_PIP p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_PFI(void* p0, struct S_PFI p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_PFF(void* p0, struct S_PFF p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_PFD(void* p0, struct S_PFD p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_PFP(void* p0, struct S_PFP p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_PDI(void* p0, struct S_PDI p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_PDF(void* p0, struct S_PDF p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_PDD(void* p0, struct S_PDD p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_PDP(void* p0, struct S_PDP p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_PPI(void* p0, struct S_PPI p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_PPF(void* p0, struct S_PPF p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_PPD(void* p0, struct S_PPD p1, float p2) { return p0; }
+EXPORT void* f16_P_PSF_PPP(void* p0, struct S_PPP p1, float p2) { return p0; }
+EXPORT void* f16_P_PSD_I(void* p0, struct S_I p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_F(void* p0, struct S_F p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_D(void* p0, struct S_D p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_P(void* p0, struct S_P p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_II(void* p0, struct S_II p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_IF(void* p0, struct S_IF p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_ID(void* p0, struct S_ID p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_IP(void* p0, struct S_IP p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_FI(void* p0, struct S_FI p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_FF(void* p0, struct S_FF p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_FD(void* p0, struct S_FD p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_FP(void* p0, struct S_FP p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_DI(void* p0, struct S_DI p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_DF(void* p0, struct S_DF p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_DD(void* p0, struct S_DD p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_DP(void* p0, struct S_DP p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_PI(void* p0, struct S_PI p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_PF(void* p0, struct S_PF p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_PD(void* p0, struct S_PD p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_PP(void* p0, struct S_PP p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_III(void* p0, struct S_III p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_IIF(void* p0, struct S_IIF p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_IID(void* p0, struct S_IID p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_IIP(void* p0, struct S_IIP p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_IFI(void* p0, struct S_IFI p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_IFF(void* p0, struct S_IFF p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_IFD(void* p0, struct S_IFD p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_IFP(void* p0, struct S_IFP p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_IDI(void* p0, struct S_IDI p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_IDF(void* p0, struct S_IDF p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_IDD(void* p0, struct S_IDD p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_IDP(void* p0, struct S_IDP p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_IPI(void* p0, struct S_IPI p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_IPF(void* p0, struct S_IPF p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_IPD(void* p0, struct S_IPD p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_IPP(void* p0, struct S_IPP p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_FII(void* p0, struct S_FII p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_FIF(void* p0, struct S_FIF p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_FID(void* p0, struct S_FID p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_FIP(void* p0, struct S_FIP p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_FFI(void* p0, struct S_FFI p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_FFF(void* p0, struct S_FFF p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_FFD(void* p0, struct S_FFD p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_FFP(void* p0, struct S_FFP p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_FDI(void* p0, struct S_FDI p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_FDF(void* p0, struct S_FDF p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_FDD(void* p0, struct S_FDD p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_FDP(void* p0, struct S_FDP p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_FPI(void* p0, struct S_FPI p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_FPF(void* p0, struct S_FPF p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_FPD(void* p0, struct S_FPD p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_FPP(void* p0, struct S_FPP p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_DII(void* p0, struct S_DII p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_DIF(void* p0, struct S_DIF p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_DID(void* p0, struct S_DID p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_DIP(void* p0, struct S_DIP p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_DFI(void* p0, struct S_DFI p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_DFF(void* p0, struct S_DFF p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_DFD(void* p0, struct S_DFD p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_DFP(void* p0, struct S_DFP p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_DDI(void* p0, struct S_DDI p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_DDF(void* p0, struct S_DDF p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_DDD(void* p0, struct S_DDD p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_DDP(void* p0, struct S_DDP p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_DPI(void* p0, struct S_DPI p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_DPF(void* p0, struct S_DPF p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_DPD(void* p0, struct S_DPD p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_DPP(void* p0, struct S_DPP p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_PII(void* p0, struct S_PII p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_PIF(void* p0, struct S_PIF p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_PID(void* p0, struct S_PID p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_PIP(void* p0, struct S_PIP p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_PFI(void* p0, struct S_PFI p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_PFF(void* p0, struct S_PFF p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_PFD(void* p0, struct S_PFD p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_PFP(void* p0, struct S_PFP p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_PDI(void* p0, struct S_PDI p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_PDF(void* p0, struct S_PDF p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_PDD(void* p0, struct S_PDD p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_PDP(void* p0, struct S_PDP p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_PPI(void* p0, struct S_PPI p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_PPF(void* p0, struct S_PPF p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_PPD(void* p0, struct S_PPD p1, double p2) { return p0; }
+EXPORT void* f16_P_PSD_PPP(void* p0, struct S_PPP p1, double p2) { return p0; }
+EXPORT void* f16_P_PSP_I(void* p0, struct S_I p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_F(void* p0, struct S_F p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_D(void* p0, struct S_D p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_P(void* p0, struct S_P p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_II(void* p0, struct S_II p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_IF(void* p0, struct S_IF p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_ID(void* p0, struct S_ID p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_IP(void* p0, struct S_IP p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_FI(void* p0, struct S_FI p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_FF(void* p0, struct S_FF p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_FD(void* p0, struct S_FD p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_FP(void* p0, struct S_FP p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_DI(void* p0, struct S_DI p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_DF(void* p0, struct S_DF p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_DD(void* p0, struct S_DD p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_DP(void* p0, struct S_DP p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_PI(void* p0, struct S_PI p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_PF(void* p0, struct S_PF p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_PD(void* p0, struct S_PD p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_PP(void* p0, struct S_PP p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_III(void* p0, struct S_III p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_IIF(void* p0, struct S_IIF p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_IID(void* p0, struct S_IID p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_IIP(void* p0, struct S_IIP p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_IFI(void* p0, struct S_IFI p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_IFF(void* p0, struct S_IFF p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_IFD(void* p0, struct S_IFD p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_IFP(void* p0, struct S_IFP p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_IDI(void* p0, struct S_IDI p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_IDF(void* p0, struct S_IDF p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_IDD(void* p0, struct S_IDD p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_IDP(void* p0, struct S_IDP p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_IPI(void* p0, struct S_IPI p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_IPF(void* p0, struct S_IPF p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_IPD(void* p0, struct S_IPD p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_IPP(void* p0, struct S_IPP p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_FII(void* p0, struct S_FII p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_FIF(void* p0, struct S_FIF p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_FID(void* p0, struct S_FID p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_FIP(void* p0, struct S_FIP p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_FFI(void* p0, struct S_FFI p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_FFF(void* p0, struct S_FFF p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_FFD(void* p0, struct S_FFD p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_FFP(void* p0, struct S_FFP p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_FDI(void* p0, struct S_FDI p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_FDF(void* p0, struct S_FDF p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_FDD(void* p0, struct S_FDD p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_FDP(void* p0, struct S_FDP p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_FPI(void* p0, struct S_FPI p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_FPF(void* p0, struct S_FPF p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_FPD(void* p0, struct S_FPD p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_FPP(void* p0, struct S_FPP p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_DII(void* p0, struct S_DII p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_DIF(void* p0, struct S_DIF p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_DID(void* p0, struct S_DID p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_DIP(void* p0, struct S_DIP p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_DFI(void* p0, struct S_DFI p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_DFF(void* p0, struct S_DFF p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_DFD(void* p0, struct S_DFD p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_DFP(void* p0, struct S_DFP p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_DDI(void* p0, struct S_DDI p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_DDF(void* p0, struct S_DDF p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_DDD(void* p0, struct S_DDD p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_DDP(void* p0, struct S_DDP p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_DPI(void* p0, struct S_DPI p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_DPF(void* p0, struct S_DPF p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_DPD(void* p0, struct S_DPD p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_DPP(void* p0, struct S_DPP p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_PII(void* p0, struct S_PII p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_PIF(void* p0, struct S_PIF p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_PID(void* p0, struct S_PID p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_PIP(void* p0, struct S_PIP p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_PFI(void* p0, struct S_PFI p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_PFF(void* p0, struct S_PFF p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_PFD(void* p0, struct S_PFD p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_PFP(void* p0, struct S_PFP p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_PDI(void* p0, struct S_PDI p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_PDF(void* p0, struct S_PDF p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_PDD(void* p0, struct S_PDD p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_PDP(void* p0, struct S_PDP p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_PPI(void* p0, struct S_PPI p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_PPF(void* p0, struct S_PPF p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_PPD(void* p0, struct S_PPD p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSP_PPP(void* p0, struct S_PPP p1, void* p2) { return p0; }
+EXPORT void* f16_P_PSS_I(void* p0, struct S_I p1, struct S_I p2) { return p0; }
+EXPORT void* f16_P_PSS_F(void* p0, struct S_F p1, struct S_F p2) { return p0; }
+EXPORT void* f16_P_PSS_D(void* p0, struct S_D p1, struct S_D p2) { return p0; }
+EXPORT void* f16_P_PSS_P(void* p0, struct S_P p1, struct S_P p2) { return p0; }
+EXPORT void* f16_P_PSS_II(void* p0, struct S_II p1, struct S_II p2) { return p0; }
+EXPORT void* f16_P_PSS_IF(void* p0, struct S_IF p1, struct S_IF p2) { return p0; }
+EXPORT void* f16_P_PSS_ID(void* p0, struct S_ID p1, struct S_ID p2) { return p0; }
+EXPORT void* f16_P_PSS_IP(void* p0, struct S_IP p1, struct S_IP p2) { return p0; }
+EXPORT void* f16_P_PSS_FI(void* p0, struct S_FI p1, struct S_FI p2) { return p0; }
+EXPORT void* f16_P_PSS_FF(void* p0, struct S_FF p1, struct S_FF p2) { return p0; }
+EXPORT void* f16_P_PSS_FD(void* p0, struct S_FD p1, struct S_FD p2) { return p0; }
+EXPORT void* f16_P_PSS_FP(void* p0, struct S_FP p1, struct S_FP p2) { return p0; }
+EXPORT void* f16_P_PSS_DI(void* p0, struct S_DI p1, struct S_DI p2) { return p0; }
+EXPORT void* f16_P_PSS_DF(void* p0, struct S_DF p1, struct S_DF p2) { return p0; }
+EXPORT void* f16_P_PSS_DD(void* p0, struct S_DD p1, struct S_DD p2) { return p0; }
+EXPORT void* f16_P_PSS_DP(void* p0, struct S_DP p1, struct S_DP p2) { return p0; }
+EXPORT void* f16_P_PSS_PI(void* p0, struct S_PI p1, struct S_PI p2) { return p0; }
+EXPORT void* f16_P_PSS_PF(void* p0, struct S_PF p1, struct S_PF p2) { return p0; }
+EXPORT void* f16_P_PSS_PD(void* p0, struct S_PD p1, struct S_PD p2) { return p0; }
+EXPORT void* f16_P_PSS_PP(void* p0, struct S_PP p1, struct S_PP p2) { return p0; }
+EXPORT void* f16_P_PSS_III(void* p0, struct S_III p1, struct S_III p2) { return p0; }
+EXPORT void* f16_P_PSS_IIF(void* p0, struct S_IIF p1, struct S_IIF p2) { return p0; }
+EXPORT void* f16_P_PSS_IID(void* p0, struct S_IID p1, struct S_IID p2) { return p0; }
+EXPORT void* f16_P_PSS_IIP(void* p0, struct S_IIP p1, struct S_IIP p2) { return p0; }
+EXPORT void* f16_P_PSS_IFI(void* p0, struct S_IFI p1, struct S_IFI p2) { return p0; }
+EXPORT void* f16_P_PSS_IFF(void* p0, struct S_IFF p1, struct S_IFF p2) { return p0; }
+EXPORT void* f16_P_PSS_IFD(void* p0, struct S_IFD p1, struct S_IFD p2) { return p0; }
+EXPORT void* f16_P_PSS_IFP(void* p0, struct S_IFP p1, struct S_IFP p2) { return p0; }
+EXPORT void* f16_P_PSS_IDI(void* p0, struct S_IDI p1, struct S_IDI p2) { return p0; }
+EXPORT void* f16_P_PSS_IDF(void* p0, struct S_IDF p1, struct S_IDF p2) { return p0; }
+EXPORT void* f16_P_PSS_IDD(void* p0, struct S_IDD p1, struct S_IDD p2) { return p0; }
+EXPORT void* f16_P_PSS_IDP(void* p0, struct S_IDP p1, struct S_IDP p2) { return p0; }
+EXPORT void* f16_P_PSS_IPI(void* p0, struct S_IPI p1, struct S_IPI p2) { return p0; }
+EXPORT void* f16_P_PSS_IPF(void* p0, struct S_IPF p1, struct S_IPF p2) { return p0; }
+EXPORT void* f16_P_PSS_IPD(void* p0, struct S_IPD p1, struct S_IPD p2) { return p0; }
+EXPORT void* f16_P_PSS_IPP(void* p0, struct S_IPP p1, struct S_IPP p2) { return p0; }
+EXPORT void* f16_P_PSS_FII(void* p0, struct S_FII p1, struct S_FII p2) { return p0; }
+EXPORT void* f16_P_PSS_FIF(void* p0, struct S_FIF p1, struct S_FIF p2) { return p0; }
+EXPORT void* f16_P_PSS_FID(void* p0, struct S_FID p1, struct S_FID p2) { return p0; }
+EXPORT void* f16_P_PSS_FIP(void* p0, struct S_FIP p1, struct S_FIP p2) { return p0; }
+EXPORT void* f16_P_PSS_FFI(void* p0, struct S_FFI p1, struct S_FFI p2) { return p0; }
+EXPORT void* f16_P_PSS_FFF(void* p0, struct S_FFF p1, struct S_FFF p2) { return p0; }
+EXPORT void* f16_P_PSS_FFD(void* p0, struct S_FFD p1, struct S_FFD p2) { return p0; }
+EXPORT void* f16_P_PSS_FFP(void* p0, struct S_FFP p1, struct S_FFP p2) { return p0; }
+EXPORT void* f16_P_PSS_FDI(void* p0, struct S_FDI p1, struct S_FDI p2) { return p0; }
+EXPORT void* f16_P_PSS_FDF(void* p0, struct S_FDF p1, struct S_FDF p2) { return p0; }
+EXPORT void* f16_P_PSS_FDD(void* p0, struct S_FDD p1, struct S_FDD p2) { return p0; }
+EXPORT void* f16_P_PSS_FDP(void* p0, struct S_FDP p1, struct S_FDP p2) { return p0; }
+EXPORT void* f16_P_PSS_FPI(void* p0, struct S_FPI p1, struct S_FPI p2) { return p0; }
+EXPORT void* f16_P_PSS_FPF(void* p0, struct S_FPF p1, struct S_FPF p2) { return p0; }
+EXPORT void* f16_P_PSS_FPD(void* p0, struct S_FPD p1, struct S_FPD p2) { return p0; }
+EXPORT void* f16_P_PSS_FPP(void* p0, struct S_FPP p1, struct S_FPP p2) { return p0; }
+EXPORT void* f16_P_PSS_DII(void* p0, struct S_DII p1, struct S_DII p2) { return p0; }
+EXPORT void* f16_P_PSS_DIF(void* p0, struct S_DIF p1, struct S_DIF p2) { return p0; }
+EXPORT void* f16_P_PSS_DID(void* p0, struct S_DID p1, struct S_DID p2) { return p0; }
+EXPORT void* f16_P_PSS_DIP(void* p0, struct S_DIP p1, struct S_DIP p2) { return p0; }
+EXPORT void* f16_P_PSS_DFI(void* p0, struct S_DFI p1, struct S_DFI p2) { return p0; }
+EXPORT void* f16_P_PSS_DFF(void* p0, struct S_DFF p1, struct S_DFF p2) { return p0; }
+EXPORT void* f16_P_PSS_DFD(void* p0, struct S_DFD p1, struct S_DFD p2) { return p0; }
+EXPORT void* f16_P_PSS_DFP(void* p0, struct S_DFP p1, struct S_DFP p2) { return p0; }
+EXPORT void* f16_P_PSS_DDI(void* p0, struct S_DDI p1, struct S_DDI p2) { return p0; }
+EXPORT void* f16_P_PSS_DDF(void* p0, struct S_DDF p1, struct S_DDF p2) { return p0; }
+EXPORT void* f16_P_PSS_DDD(void* p0, struct S_DDD p1, struct S_DDD p2) { return p0; }
+EXPORT void* f16_P_PSS_DDP(void* p0, struct S_DDP p1, struct S_DDP p2) { return p0; }
+EXPORT void* f16_P_PSS_DPI(void* p0, struct S_DPI p1, struct S_DPI p2) { return p0; }
+EXPORT void* f16_P_PSS_DPF(void* p0, struct S_DPF p1, struct S_DPF p2) { return p0; }
+EXPORT void* f16_P_PSS_DPD(void* p0, struct S_DPD p1, struct S_DPD p2) { return p0; }
+EXPORT void* f16_P_PSS_DPP(void* p0, struct S_DPP p1, struct S_DPP p2) { return p0; }
+EXPORT void* f16_P_PSS_PII(void* p0, struct S_PII p1, struct S_PII p2) { return p0; }
+EXPORT void* f16_P_PSS_PIF(void* p0, struct S_PIF p1, struct S_PIF p2) { return p0; }
+EXPORT void* f16_P_PSS_PID(void* p0, struct S_PID p1, struct S_PID p2) { return p0; }
+EXPORT void* f16_P_PSS_PIP(void* p0, struct S_PIP p1, struct S_PIP p2) { return p0; }
+EXPORT void* f16_P_PSS_PFI(void* p0, struct S_PFI p1, struct S_PFI p2) { return p0; }
+EXPORT void* f16_P_PSS_PFF(void* p0, struct S_PFF p1, struct S_PFF p2) { return p0; }
+EXPORT void* f16_P_PSS_PFD(void* p0, struct S_PFD p1, struct S_PFD p2) { return p0; }
+EXPORT void* f16_P_PSS_PFP(void* p0, struct S_PFP p1, struct S_PFP p2) { return p0; }
+EXPORT void* f16_P_PSS_PDI(void* p0, struct S_PDI p1, struct S_PDI p2) { return p0; }
+EXPORT void* f16_P_PSS_PDF(void* p0, struct S_PDF p1, struct S_PDF p2) { return p0; }
+EXPORT void* f16_P_PSS_PDD(void* p0, struct S_PDD p1, struct S_PDD p2) { return p0; }
+EXPORT void* f16_P_PSS_PDP(void* p0, struct S_PDP p1, struct S_PDP p2) { return p0; }
+EXPORT void* f16_P_PSS_PPI(void* p0, struct S_PPI p1, struct S_PPI p2) { return p0; }
+EXPORT void* f16_P_PSS_PPF(void* p0, struct S_PPF p1, struct S_PPF p2) { return p0; }
+EXPORT void* f16_P_PSS_PPD(void* p0, struct S_PPD p1, struct S_PPD p2) { return p0; }
+EXPORT void* f16_P_PSS_PPP(void* p0, struct S_PPP p1, struct S_PPP p2) { return p0; }
+EXPORT struct S_I f16_S_SII_I(struct S_I p0, int p1, int p2) { return p0; }
+EXPORT struct S_F f16_S_SII_F(struct S_F p0, int p1, int p2) { return p0; }
+EXPORT struct S_D f16_S_SII_D(struct S_D p0, int p1, int p2) { return p0; }
+EXPORT struct S_P f16_S_SII_P(struct S_P p0, int p1, int p2) { return p0; }
+EXPORT struct S_II f16_S_SII_II(struct S_II p0, int p1, int p2) { return p0; }
+EXPORT struct S_IF f16_S_SII_IF(struct S_IF p0, int p1, int p2) { return p0; }
+EXPORT struct S_ID f16_S_SII_ID(struct S_ID p0, int p1, int p2) { return p0; }
+EXPORT struct S_IP f16_S_SII_IP(struct S_IP p0, int p1, int p2) { return p0; }
+EXPORT struct S_FI f16_S_SII_FI(struct S_FI p0, int p1, int p2) { return p0; }
+EXPORT struct S_FF f16_S_SII_FF(struct S_FF p0, int p1, int p2) { return p0; }
+EXPORT struct S_FD f16_S_SII_FD(struct S_FD p0, int p1, int p2) { return p0; }
+EXPORT struct S_FP f16_S_SII_FP(struct S_FP p0, int p1, int p2) { return p0; }
+EXPORT struct S_DI f16_S_SII_DI(struct S_DI p0, int p1, int p2) { return p0; }
+EXPORT struct S_DF f16_S_SII_DF(struct S_DF p0, int p1, int p2) { return p0; }
+EXPORT struct S_DD f16_S_SII_DD(struct S_DD p0, int p1, int p2) { return p0; }
+EXPORT struct S_DP f16_S_SII_DP(struct S_DP p0, int p1, int p2) { return p0; }
+EXPORT struct S_PI f16_S_SII_PI(struct S_PI p0, int p1, int p2) { return p0; }
+EXPORT struct S_PF f16_S_SII_PF(struct S_PF p0, int p1, int p2) { return p0; }
+EXPORT struct S_PD f16_S_SII_PD(struct S_PD p0, int p1, int p2) { return p0; }
+EXPORT struct S_PP f16_S_SII_PP(struct S_PP p0, int p1, int p2) { return p0; }
+EXPORT struct S_III f16_S_SII_III(struct S_III p0, int p1, int p2) { return p0; }
+EXPORT struct S_IIF f16_S_SII_IIF(struct S_IIF p0, int p1, int p2) { return p0; }
+EXPORT struct S_IID f16_S_SII_IID(struct S_IID p0, int p1, int p2) { return p0; }
+EXPORT struct S_IIP f16_S_SII_IIP(struct S_IIP p0, int p1, int p2) { return p0; }
+EXPORT struct S_IFI f16_S_SII_IFI(struct S_IFI p0, int p1, int p2) { return p0; }
+EXPORT struct S_IFF f16_S_SII_IFF(struct S_IFF p0, int p1, int p2) { return p0; }
+EXPORT struct S_IFD f16_S_SII_IFD(struct S_IFD p0, int p1, int p2) { return p0; }
+EXPORT struct S_IFP f16_S_SII_IFP(struct S_IFP p0, int p1, int p2) { return p0; }
+EXPORT struct S_IDI f16_S_SII_IDI(struct S_IDI p0, int p1, int p2) { return p0; }
+EXPORT struct S_IDF f16_S_SII_IDF(struct S_IDF p0, int p1, int p2) { return p0; }
+EXPORT struct S_IDD f16_S_SII_IDD(struct S_IDD p0, int p1, int p2) { return p0; }
+EXPORT struct S_IDP f16_S_SII_IDP(struct S_IDP p0, int p1, int p2) { return p0; }
+EXPORT struct S_IPI f16_S_SII_IPI(struct S_IPI p0, int p1, int p2) { return p0; }
+EXPORT struct S_IPF f16_S_SII_IPF(struct S_IPF p0, int p1, int p2) { return p0; }
+EXPORT struct S_IPD f16_S_SII_IPD(struct S_IPD p0, int p1, int p2) { return p0; }
+EXPORT struct S_IPP f16_S_SII_IPP(struct S_IPP p0, int p1, int p2) { return p0; }
+EXPORT struct S_FII f16_S_SII_FII(struct S_FII p0, int p1, int p2) { return p0; }
+EXPORT struct S_FIF f16_S_SII_FIF(struct S_FIF p0, int p1, int p2) { return p0; }
+EXPORT struct S_FID f16_S_SII_FID(struct S_FID p0, int p1, int p2) { return p0; }
+EXPORT struct S_FIP f16_S_SII_FIP(struct S_FIP p0, int p1, int p2) { return p0; }
+EXPORT struct S_FFI f16_S_SII_FFI(struct S_FFI p0, int p1, int p2) { return p0; }
+EXPORT struct S_FFF f16_S_SII_FFF(struct S_FFF p0, int p1, int p2) { return p0; }
+EXPORT struct S_FFD f16_S_SII_FFD(struct S_FFD p0, int p1, int p2) { return p0; }
+EXPORT struct S_FFP f16_S_SII_FFP(struct S_FFP p0, int p1, int p2) { return p0; }
+EXPORT struct S_FDI f16_S_SII_FDI(struct S_FDI p0, int p1, int p2) { return p0; }
+EXPORT struct S_FDF f16_S_SII_FDF(struct S_FDF p0, int p1, int p2) { return p0; }
+EXPORT struct S_FDD f16_S_SII_FDD(struct S_FDD p0, int p1, int p2) { return p0; }
+EXPORT struct S_FDP f16_S_SII_FDP(struct S_FDP p0, int p1, int p2) { return p0; }
+EXPORT struct S_FPI f16_S_SII_FPI(struct S_FPI p0, int p1, int p2) { return p0; }
+EXPORT struct S_FPF f16_S_SII_FPF(struct S_FPF p0, int p1, int p2) { return p0; }
+EXPORT struct S_FPD f16_S_SII_FPD(struct S_FPD p0, int p1, int p2) { return p0; }
+EXPORT struct S_FPP f16_S_SII_FPP(struct S_FPP p0, int p1, int p2) { return p0; }
+EXPORT struct S_DII f16_S_SII_DII(struct S_DII p0, int p1, int p2) { return p0; }
+EXPORT struct S_DIF f16_S_SII_DIF(struct S_DIF p0, int p1, int p2) { return p0; }
+EXPORT struct S_DID f16_S_SII_DID(struct S_DID p0, int p1, int p2) { return p0; }
+EXPORT struct S_DIP f16_S_SII_DIP(struct S_DIP p0, int p1, int p2) { return p0; }
+EXPORT struct S_DFI f16_S_SII_DFI(struct S_DFI p0, int p1, int p2) { return p0; }
+EXPORT struct S_DFF f16_S_SII_DFF(struct S_DFF p0, int p1, int p2) { return p0; }
+EXPORT struct S_DFD f16_S_SII_DFD(struct S_DFD p0, int p1, int p2) { return p0; }
+EXPORT struct S_DFP f16_S_SII_DFP(struct S_DFP p0, int p1, int p2) { return p0; }
+EXPORT struct S_DDI f16_S_SII_DDI(struct S_DDI p0, int p1, int p2) { return p0; }
+EXPORT struct S_DDF f16_S_SII_DDF(struct S_DDF p0, int p1, int p2) { return p0; }
+EXPORT struct S_DDD f16_S_SII_DDD(struct S_DDD p0, int p1, int p2) { return p0; }
+EXPORT struct S_DDP f16_S_SII_DDP(struct S_DDP p0, int p1, int p2) { return p0; }
+EXPORT struct S_DPI f16_S_SII_DPI(struct S_DPI p0, int p1, int p2) { return p0; }
+EXPORT struct S_DPF f16_S_SII_DPF(struct S_DPF p0, int p1, int p2) { return p0; }
+EXPORT struct S_DPD f16_S_SII_DPD(struct S_DPD p0, int p1, int p2) { return p0; }
+EXPORT struct S_DPP f16_S_SII_DPP(struct S_DPP p0, int p1, int p2) { return p0; }
+EXPORT struct S_PII f16_S_SII_PII(struct S_PII p0, int p1, int p2) { return p0; }
+EXPORT struct S_PIF f16_S_SII_PIF(struct S_PIF p0, int p1, int p2) { return p0; }
+EXPORT struct S_PID f16_S_SII_PID(struct S_PID p0, int p1, int p2) { return p0; }
+EXPORT struct S_PIP f16_S_SII_PIP(struct S_PIP p0, int p1, int p2) { return p0; }
+EXPORT struct S_PFI f16_S_SII_PFI(struct S_PFI p0, int p1, int p2) { return p0; }
+EXPORT struct S_PFF f16_S_SII_PFF(struct S_PFF p0, int p1, int p2) { return p0; }
+EXPORT struct S_PFD f16_S_SII_PFD(struct S_PFD p0, int p1, int p2) { return p0; }
+EXPORT struct S_PFP f16_S_SII_PFP(struct S_PFP p0, int p1, int p2) { return p0; }
+EXPORT struct S_PDI f16_S_SII_PDI(struct S_PDI p0, int p1, int p2) { return p0; }
+EXPORT struct S_PDF f16_S_SII_PDF(struct S_PDF p0, int p1, int p2) { return p0; }
+EXPORT struct S_PDD f16_S_SII_PDD(struct S_PDD p0, int p1, int p2) { return p0; }
+EXPORT struct S_PDP f16_S_SII_PDP(struct S_PDP p0, int p1, int p2) { return p0; }
+EXPORT struct S_PPI f16_S_SII_PPI(struct S_PPI p0, int p1, int p2) { return p0; }
+EXPORT struct S_PPF f16_S_SII_PPF(struct S_PPF p0, int p1, int p2) { return p0; }
+EXPORT struct S_PPD f16_S_SII_PPD(struct S_PPD p0, int p1, int p2) { return p0; }
+EXPORT struct S_PPP f16_S_SII_PPP(struct S_PPP p0, int p1, int p2) { return p0; }
+EXPORT struct S_I f16_S_SIF_I(struct S_I p0, int p1, float p2) { return p0; }
+EXPORT struct S_F f16_S_SIF_F(struct S_F p0, int p1, float p2) { return p0; }
+EXPORT struct S_D f16_S_SIF_D(struct S_D p0, int p1, float p2) { return p0; }
+EXPORT struct S_P f16_S_SIF_P(struct S_P p0, int p1, float p2) { return p0; }
+EXPORT struct S_II f16_S_SIF_II(struct S_II p0, int p1, float p2) { return p0; }
+EXPORT struct S_IF f16_S_SIF_IF(struct S_IF p0, int p1, float p2) { return p0; }
+EXPORT struct S_ID f16_S_SIF_ID(struct S_ID p0, int p1, float p2) { return p0; }
+EXPORT struct S_IP f16_S_SIF_IP(struct S_IP p0, int p1, float p2) { return p0; }
+EXPORT struct S_FI f16_S_SIF_FI(struct S_FI p0, int p1, float p2) { return p0; }
+EXPORT struct S_FF f16_S_SIF_FF(struct S_FF p0, int p1, float p2) { return p0; }
+EXPORT struct S_FD f16_S_SIF_FD(struct S_FD p0, int p1, float p2) { return p0; }
+EXPORT struct S_FP f16_S_SIF_FP(struct S_FP p0, int p1, float p2) { return p0; }
+EXPORT struct S_DI f16_S_SIF_DI(struct S_DI p0, int p1, float p2) { return p0; }
+EXPORT struct S_DF f16_S_SIF_DF(struct S_DF p0, int p1, float p2) { return p0; }
+EXPORT struct S_DD f16_S_SIF_DD(struct S_DD p0, int p1, float p2) { return p0; }
+EXPORT struct S_DP f16_S_SIF_DP(struct S_DP p0, int p1, float p2) { return p0; }
+EXPORT struct S_PI f16_S_SIF_PI(struct S_PI p0, int p1, float p2) { return p0; }
+EXPORT struct S_PF f16_S_SIF_PF(struct S_PF p0, int p1, float p2) { return p0; }
+EXPORT struct S_PD f16_S_SIF_PD(struct S_PD p0, int p1, float p2) { return p0; }
+EXPORT struct S_PP f16_S_SIF_PP(struct S_PP p0, int p1, float p2) { return p0; }
+EXPORT struct S_III f16_S_SIF_III(struct S_III p0, int p1, float p2) { return p0; }
+EXPORT struct S_IIF f16_S_SIF_IIF(struct S_IIF p0, int p1, float p2) { return p0; }
+EXPORT struct S_IID f16_S_SIF_IID(struct S_IID p0, int p1, float p2) { return p0; }
+EXPORT struct S_IIP f16_S_SIF_IIP(struct S_IIP p0, int p1, float p2) { return p0; }
+EXPORT struct S_IFI f16_S_SIF_IFI(struct S_IFI p0, int p1, float p2) { return p0; }
+EXPORT struct S_IFF f16_S_SIF_IFF(struct S_IFF p0, int p1, float p2) { return p0; }
+EXPORT struct S_IFD f16_S_SIF_IFD(struct S_IFD p0, int p1, float p2) { return p0; }
+EXPORT struct S_IFP f16_S_SIF_IFP(struct S_IFP p0, int p1, float p2) { return p0; }
+EXPORT struct S_IDI f16_S_SIF_IDI(struct S_IDI p0, int p1, float p2) { return p0; }
+EXPORT struct S_IDF f16_S_SIF_IDF(struct S_IDF p0, int p1, float p2) { return p0; }
+EXPORT struct S_IDD f16_S_SIF_IDD(struct S_IDD p0, int p1, float p2) { return p0; }
+EXPORT struct S_IDP f16_S_SIF_IDP(struct S_IDP p0, int p1, float p2) { return p0; }
+EXPORT struct S_IPI f16_S_SIF_IPI(struct S_IPI p0, int p1, float p2) { return p0; }
+EXPORT struct S_IPF f16_S_SIF_IPF(struct S_IPF p0, int p1, float p2) { return p0; }
+EXPORT struct S_IPD f16_S_SIF_IPD(struct S_IPD p0, int p1, float p2) { return p0; }
+EXPORT struct S_IPP f16_S_SIF_IPP(struct S_IPP p0, int p1, float p2) { return p0; }
+EXPORT struct S_FII f16_S_SIF_FII(struct S_FII p0, int p1, float p2) { return p0; }
+EXPORT struct S_FIF f16_S_SIF_FIF(struct S_FIF p0, int p1, float p2) { return p0; }
+EXPORT struct S_FID f16_S_SIF_FID(struct S_FID p0, int p1, float p2) { return p0; }
+EXPORT struct S_FIP f16_S_SIF_FIP(struct S_FIP p0, int p1, float p2) { return p0; }
+EXPORT struct S_FFI f16_S_SIF_FFI(struct S_FFI p0, int p1, float p2) { return p0; }
+EXPORT struct S_FFF f16_S_SIF_FFF(struct S_FFF p0, int p1, float p2) { return p0; }
+EXPORT struct S_FFD f16_S_SIF_FFD(struct S_FFD p0, int p1, float p2) { return p0; }
+EXPORT struct S_FFP f16_S_SIF_FFP(struct S_FFP p0, int p1, float p2) { return p0; }
+EXPORT struct S_FDI f16_S_SIF_FDI(struct S_FDI p0, int p1, float p2) { return p0; }
+EXPORT struct S_FDF f16_S_SIF_FDF(struct S_FDF p0, int p1, float p2) { return p0; }
+EXPORT struct S_FDD f16_S_SIF_FDD(struct S_FDD p0, int p1, float p2) { return p0; }
+EXPORT struct S_FDP f16_S_SIF_FDP(struct S_FDP p0, int p1, float p2) { return p0; }
+EXPORT struct S_FPI f16_S_SIF_FPI(struct S_FPI p0, int p1, float p2) { return p0; }
+EXPORT struct S_FPF f16_S_SIF_FPF(struct S_FPF p0, int p1, float p2) { return p0; }
+EXPORT struct S_FPD f16_S_SIF_FPD(struct S_FPD p0, int p1, float p2) { return p0; }
+EXPORT struct S_FPP f16_S_SIF_FPP(struct S_FPP p0, int p1, float p2) { return p0; }
+EXPORT struct S_DII f16_S_SIF_DII(struct S_DII p0, int p1, float p2) { return p0; }
+EXPORT struct S_DIF f16_S_SIF_DIF(struct S_DIF p0, int p1, float p2) { return p0; }
+EXPORT struct S_DID f16_S_SIF_DID(struct S_DID p0, int p1, float p2) { return p0; }
+EXPORT struct S_DIP f16_S_SIF_DIP(struct S_DIP p0, int p1, float p2) { return p0; }
+EXPORT struct S_DFI f16_S_SIF_DFI(struct S_DFI p0, int p1, float p2) { return p0; }
+EXPORT struct S_DFF f16_S_SIF_DFF(struct S_DFF p0, int p1, float p2) { return p0; }
+EXPORT struct S_DFD f16_S_SIF_DFD(struct S_DFD p0, int p1, float p2) { return p0; }
+EXPORT struct S_DFP f16_S_SIF_DFP(struct S_DFP p0, int p1, float p2) { return p0; }
+EXPORT struct S_DDI f16_S_SIF_DDI(struct S_DDI p0, int p1, float p2) { return p0; }
+EXPORT struct S_DDF f16_S_SIF_DDF(struct S_DDF p0, int p1, float p2) { return p0; }
+EXPORT struct S_DDD f16_S_SIF_DDD(struct S_DDD p0, int p1, float p2) { return p0; }
+EXPORT struct S_DDP f16_S_SIF_DDP(struct S_DDP p0, int p1, float p2) { return p0; }
+EXPORT struct S_DPI f16_S_SIF_DPI(struct S_DPI p0, int p1, float p2) { return p0; }
+EXPORT struct S_DPF f16_S_SIF_DPF(struct S_DPF p0, int p1, float p2) { return p0; }
+EXPORT struct S_DPD f16_S_SIF_DPD(struct S_DPD p0, int p1, float p2) { return p0; }
+EXPORT struct S_DPP f16_S_SIF_DPP(struct S_DPP p0, int p1, float p2) { return p0; }
+EXPORT struct S_PII f16_S_SIF_PII(struct S_PII p0, int p1, float p2) { return p0; }
+EXPORT struct S_PIF f16_S_SIF_PIF(struct S_PIF p0, int p1, float p2) { return p0; }
+EXPORT struct S_PID f16_S_SIF_PID(struct S_PID p0, int p1, float p2) { return p0; }
+EXPORT struct S_PIP f16_S_SIF_PIP(struct S_PIP p0, int p1, float p2) { return p0; }
+EXPORT struct S_PFI f16_S_SIF_PFI(struct S_PFI p0, int p1, float p2) { return p0; }
+EXPORT struct S_PFF f16_S_SIF_PFF(struct S_PFF p0, int p1, float p2) { return p0; }
+EXPORT struct S_PFD f16_S_SIF_PFD(struct S_PFD p0, int p1, float p2) { return p0; }
+EXPORT struct S_PFP f16_S_SIF_PFP(struct S_PFP p0, int p1, float p2) { return p0; }
+EXPORT struct S_PDI f16_S_SIF_PDI(struct S_PDI p0, int p1, float p2) { return p0; }
+EXPORT struct S_PDF f16_S_SIF_PDF(struct S_PDF p0, int p1, float p2) { return p0; }
+EXPORT struct S_PDD f16_S_SIF_PDD(struct S_PDD p0, int p1, float p2) { return p0; }
+EXPORT struct S_PDP f16_S_SIF_PDP(struct S_PDP p0, int p1, float p2) { return p0; }
+EXPORT struct S_PPI f16_S_SIF_PPI(struct S_PPI p0, int p1, float p2) { return p0; }
+EXPORT struct S_PPF f16_S_SIF_PPF(struct S_PPF p0, int p1, float p2) { return p0; }
+EXPORT struct S_PPD f16_S_SIF_PPD(struct S_PPD p0, int p1, float p2) { return p0; }
+EXPORT struct S_PPP f16_S_SIF_PPP(struct S_PPP p0, int p1, float p2) { return p0; }
+EXPORT struct S_I f16_S_SID_I(struct S_I p0, int p1, double p2) { return p0; }
+EXPORT struct S_F f16_S_SID_F(struct S_F p0, int p1, double p2) { return p0; }
+EXPORT struct S_D f16_S_SID_D(struct S_D p0, int p1, double p2) { return p0; }
+EXPORT struct S_P f16_S_SID_P(struct S_P p0, int p1, double p2) { return p0; }
+EXPORT struct S_II f16_S_SID_II(struct S_II p0, int p1, double p2) { return p0; }
+EXPORT struct S_IF f16_S_SID_IF(struct S_IF p0, int p1, double p2) { return p0; }
+EXPORT struct S_ID f16_S_SID_ID(struct S_ID p0, int p1, double p2) { return p0; }
+EXPORT struct S_IP f16_S_SID_IP(struct S_IP p0, int p1, double p2) { return p0; }
+EXPORT struct S_FI f16_S_SID_FI(struct S_FI p0, int p1, double p2) { return p0; }
+EXPORT struct S_FF f16_S_SID_FF(struct S_FF p0, int p1, double p2) { return p0; }
+EXPORT struct S_FD f16_S_SID_FD(struct S_FD p0, int p1, double p2) { return p0; }
+EXPORT struct S_FP f16_S_SID_FP(struct S_FP p0, int p1, double p2) { return p0; }
+EXPORT struct S_DI f16_S_SID_DI(struct S_DI p0, int p1, double p2) { return p0; }
+EXPORT struct S_DF f16_S_SID_DF(struct S_DF p0, int p1, double p2) { return p0; }
+EXPORT struct S_DD f16_S_SID_DD(struct S_DD p0, int p1, double p2) { return p0; }
+EXPORT struct S_DP f16_S_SID_DP(struct S_DP p0, int p1, double p2) { return p0; }
+EXPORT struct S_PI f16_S_SID_PI(struct S_PI p0, int p1, double p2) { return p0; }
+EXPORT struct S_PF f16_S_SID_PF(struct S_PF p0, int p1, double p2) { return p0; }
+EXPORT struct S_PD f16_S_SID_PD(struct S_PD p0, int p1, double p2) { return p0; }
+EXPORT struct S_PP f16_S_SID_PP(struct S_PP p0, int p1, double p2) { return p0; }
+EXPORT struct S_III f16_S_SID_III(struct S_III p0, int p1, double p2) { return p0; }
+EXPORT struct S_IIF f16_S_SID_IIF(struct S_IIF p0, int p1, double p2) { return p0; }
+EXPORT struct S_IID f16_S_SID_IID(struct S_IID p0, int p1, double p2) { return p0; }
+EXPORT struct S_IIP f16_S_SID_IIP(struct S_IIP p0, int p1, double p2) { return p0; }
+EXPORT struct S_IFI f16_S_SID_IFI(struct S_IFI p0, int p1, double p2) { return p0; }
+EXPORT struct S_IFF f16_S_SID_IFF(struct S_IFF p0, int p1, double p2) { return p0; }
+EXPORT struct S_IFD f16_S_SID_IFD(struct S_IFD p0, int p1, double p2) { return p0; }
+EXPORT struct S_IFP f16_S_SID_IFP(struct S_IFP p0, int p1, double p2) { return p0; }
+EXPORT struct S_IDI f16_S_SID_IDI(struct S_IDI p0, int p1, double p2) { return p0; }
+EXPORT struct S_IDF f16_S_SID_IDF(struct S_IDF p0, int p1, double p2) { return p0; }
+EXPORT struct S_IDD f16_S_SID_IDD(struct S_IDD p0, int p1, double p2) { return p0; }
+EXPORT struct S_IDP f16_S_SID_IDP(struct S_IDP p0, int p1, double p2) { return p0; }
+EXPORT struct S_IPI f16_S_SID_IPI(struct S_IPI p0, int p1, double p2) { return p0; }
+EXPORT struct S_IPF f16_S_SID_IPF(struct S_IPF p0, int p1, double p2) { return p0; }
+EXPORT struct S_IPD f16_S_SID_IPD(struct S_IPD p0, int p1, double p2) { return p0; }
+EXPORT struct S_IPP f17_S_SID_IPP(struct S_IPP p0, int p1, double p2) { return p0; }
+EXPORT struct S_FII f17_S_SID_FII(struct S_FII p0, int p1, double p2) { return p0; }
+EXPORT struct S_FIF f17_S_SID_FIF(struct S_FIF p0, int p1, double p2) { return p0; }
+EXPORT struct S_FID f17_S_SID_FID(struct S_FID p0, int p1, double p2) { return p0; }
+EXPORT struct S_FIP f17_S_SID_FIP(struct S_FIP p0, int p1, double p2) { return p0; }
+EXPORT struct S_FFI f17_S_SID_FFI(struct S_FFI p0, int p1, double p2) { return p0; }
+EXPORT struct S_FFF f17_S_SID_FFF(struct S_FFF p0, int p1, double p2) { return p0; }
+EXPORT struct S_FFD f17_S_SID_FFD(struct S_FFD p0, int p1, double p2) { return p0; }
+EXPORT struct S_FFP f17_S_SID_FFP(struct S_FFP p0, int p1, double p2) { return p0; }
+EXPORT struct S_FDI f17_S_SID_FDI(struct S_FDI p0, int p1, double p2) { return p0; }
+EXPORT struct S_FDF f17_S_SID_FDF(struct S_FDF p0, int p1, double p2) { return p0; }
+EXPORT struct S_FDD f17_S_SID_FDD(struct S_FDD p0, int p1, double p2) { return p0; }
+EXPORT struct S_FDP f17_S_SID_FDP(struct S_FDP p0, int p1, double p2) { return p0; }
+EXPORT struct S_FPI f17_S_SID_FPI(struct S_FPI p0, int p1, double p2) { return p0; }
+EXPORT struct S_FPF f17_S_SID_FPF(struct S_FPF p0, int p1, double p2) { return p0; }
+EXPORT struct S_FPD f17_S_SID_FPD(struct S_FPD p0, int p1, double p2) { return p0; }
+EXPORT struct S_FPP f17_S_SID_FPP(struct S_FPP p0, int p1, double p2) { return p0; }
+EXPORT struct S_DII f17_S_SID_DII(struct S_DII p0, int p1, double p2) { return p0; }
+EXPORT struct S_DIF f17_S_SID_DIF(struct S_DIF p0, int p1, double p2) { return p0; }
+EXPORT struct S_DID f17_S_SID_DID(struct S_DID p0, int p1, double p2) { return p0; }
+EXPORT struct S_DIP f17_S_SID_DIP(struct S_DIP p0, int p1, double p2) { return p0; }
+EXPORT struct S_DFI f17_S_SID_DFI(struct S_DFI p0, int p1, double p2) { return p0; }
+EXPORT struct S_DFF f17_S_SID_DFF(struct S_DFF p0, int p1, double p2) { return p0; }
+EXPORT struct S_DFD f17_S_SID_DFD(struct S_DFD p0, int p1, double p2) { return p0; }
+EXPORT struct S_DFP f17_S_SID_DFP(struct S_DFP p0, int p1, double p2) { return p0; }
+EXPORT struct S_DDI f17_S_SID_DDI(struct S_DDI p0, int p1, double p2) { return p0; }
+EXPORT struct S_DDF f17_S_SID_DDF(struct S_DDF p0, int p1, double p2) { return p0; }
+EXPORT struct S_DDD f17_S_SID_DDD(struct S_DDD p0, int p1, double p2) { return p0; }
+EXPORT struct S_DDP f17_S_SID_DDP(struct S_DDP p0, int p1, double p2) { return p0; }
+EXPORT struct S_DPI f17_S_SID_DPI(struct S_DPI p0, int p1, double p2) { return p0; }
+EXPORT struct S_DPF f17_S_SID_DPF(struct S_DPF p0, int p1, double p2) { return p0; }
+EXPORT struct S_DPD f17_S_SID_DPD(struct S_DPD p0, int p1, double p2) { return p0; }
+EXPORT struct S_DPP f17_S_SID_DPP(struct S_DPP p0, int p1, double p2) { return p0; }
+EXPORT struct S_PII f17_S_SID_PII(struct S_PII p0, int p1, double p2) { return p0; }
+EXPORT struct S_PIF f17_S_SID_PIF(struct S_PIF p0, int p1, double p2) { return p0; }
+EXPORT struct S_PID f17_S_SID_PID(struct S_PID p0, int p1, double p2) { return p0; }
+EXPORT struct S_PIP f17_S_SID_PIP(struct S_PIP p0, int p1, double p2) { return p0; }
+EXPORT struct S_PFI f17_S_SID_PFI(struct S_PFI p0, int p1, double p2) { return p0; }
+EXPORT struct S_PFF f17_S_SID_PFF(struct S_PFF p0, int p1, double p2) { return p0; }
+EXPORT struct S_PFD f17_S_SID_PFD(struct S_PFD p0, int p1, double p2) { return p0; }
+EXPORT struct S_PFP f17_S_SID_PFP(struct S_PFP p0, int p1, double p2) { return p0; }
+EXPORT struct S_PDI f17_S_SID_PDI(struct S_PDI p0, int p1, double p2) { return p0; }
+EXPORT struct S_PDF f17_S_SID_PDF(struct S_PDF p0, int p1, double p2) { return p0; }
+EXPORT struct S_PDD f17_S_SID_PDD(struct S_PDD p0, int p1, double p2) { return p0; }
+EXPORT struct S_PDP f17_S_SID_PDP(struct S_PDP p0, int p1, double p2) { return p0; }
+EXPORT struct S_PPI f17_S_SID_PPI(struct S_PPI p0, int p1, double p2) { return p0; }
+EXPORT struct S_PPF f17_S_SID_PPF(struct S_PPF p0, int p1, double p2) { return p0; }
+EXPORT struct S_PPD f17_S_SID_PPD(struct S_PPD p0, int p1, double p2) { return p0; }
+EXPORT struct S_PPP f17_S_SID_PPP(struct S_PPP p0, int p1, double p2) { return p0; }
+EXPORT struct S_I f17_S_SIP_I(struct S_I p0, int p1, void* p2) { return p0; }
+EXPORT struct S_F f17_S_SIP_F(struct S_F p0, int p1, void* p2) { return p0; }
+EXPORT struct S_D f17_S_SIP_D(struct S_D p0, int p1, void* p2) { return p0; }
+EXPORT struct S_P f17_S_SIP_P(struct S_P p0, int p1, void* p2) { return p0; }
+EXPORT struct S_II f17_S_SIP_II(struct S_II p0, int p1, void* p2) { return p0; }
+EXPORT struct S_IF f17_S_SIP_IF(struct S_IF p0, int p1, void* p2) { return p0; }
+EXPORT struct S_ID f17_S_SIP_ID(struct S_ID p0, int p1, void* p2) { return p0; }
+EXPORT struct S_IP f17_S_SIP_IP(struct S_IP p0, int p1, void* p2) { return p0; }
+EXPORT struct S_FI f17_S_SIP_FI(struct S_FI p0, int p1, void* p2) { return p0; }
+EXPORT struct S_FF f17_S_SIP_FF(struct S_FF p0, int p1, void* p2) { return p0; }
+EXPORT struct S_FD f17_S_SIP_FD(struct S_FD p0, int p1, void* p2) { return p0; }
+EXPORT struct S_FP f17_S_SIP_FP(struct S_FP p0, int p1, void* p2) { return p0; }
+EXPORT struct S_DI f17_S_SIP_DI(struct S_DI p0, int p1, void* p2) { return p0; }
+EXPORT struct S_DF f17_S_SIP_DF(struct S_DF p0, int p1, void* p2) { return p0; }
+EXPORT struct S_DD f17_S_SIP_DD(struct S_DD p0, int p1, void* p2) { return p0; }
+EXPORT struct S_DP f17_S_SIP_DP(struct S_DP p0, int p1, void* p2) { return p0; }
+EXPORT struct S_PI f17_S_SIP_PI(struct S_PI p0, int p1, void* p2) { return p0; }
+EXPORT struct S_PF f17_S_SIP_PF(struct S_PF p0, int p1, void* p2) { return p0; }
+EXPORT struct S_PD f17_S_SIP_PD(struct S_PD p0, int p1, void* p2) { return p0; }
+EXPORT struct S_PP f17_S_SIP_PP(struct S_PP p0, int p1, void* p2) { return p0; }
+EXPORT struct S_III f17_S_SIP_III(struct S_III p0, int p1, void* p2) { return p0; }
+EXPORT struct S_IIF f17_S_SIP_IIF(struct S_IIF p0, int p1, void* p2) { return p0; }
+EXPORT struct S_IID f17_S_SIP_IID(struct S_IID p0, int p1, void* p2) { return p0; }
+EXPORT struct S_IIP f17_S_SIP_IIP(struct S_IIP p0, int p1, void* p2) { return p0; }
+EXPORT struct S_IFI f17_S_SIP_IFI(struct S_IFI p0, int p1, void* p2) { return p0; }
+EXPORT struct S_IFF f17_S_SIP_IFF(struct S_IFF p0, int p1, void* p2) { return p0; }
+EXPORT struct S_IFD f17_S_SIP_IFD(struct S_IFD p0, int p1, void* p2) { return p0; }
+EXPORT struct S_IFP f17_S_SIP_IFP(struct S_IFP p0, int p1, void* p2) { return p0; }
+EXPORT struct S_IDI f17_S_SIP_IDI(struct S_IDI p0, int p1, void* p2) { return p0; }
+EXPORT struct S_IDF f17_S_SIP_IDF(struct S_IDF p0, int p1, void* p2) { return p0; }
+EXPORT struct S_IDD f17_S_SIP_IDD(struct S_IDD p0, int p1, void* p2) { return p0; }
+EXPORT struct S_IDP f17_S_SIP_IDP(struct S_IDP p0, int p1, void* p2) { return p0; }
+EXPORT struct S_IPI f17_S_SIP_IPI(struct S_IPI p0, int p1, void* p2) { return p0; }
+EXPORT struct S_IPF f17_S_SIP_IPF(struct S_IPF p0, int p1, void* p2) { return p0; }
+EXPORT struct S_IPD f17_S_SIP_IPD(struct S_IPD p0, int p1, void* p2) { return p0; }
+EXPORT struct S_IPP f17_S_SIP_IPP(struct S_IPP p0, int p1, void* p2) { return p0; }
+EXPORT struct S_FII f17_S_SIP_FII(struct S_FII p0, int p1, void* p2) { return p0; }
+EXPORT struct S_FIF f17_S_SIP_FIF(struct S_FIF p0, int p1, void* p2) { return p0; }
+EXPORT struct S_FID f17_S_SIP_FID(struct S_FID p0, int p1, void* p2) { return p0; }
+EXPORT struct S_FIP f17_S_SIP_FIP(struct S_FIP p0, int p1, void* p2) { return p0; }
+EXPORT struct S_FFI f17_S_SIP_FFI(struct S_FFI p0, int p1, void* p2) { return p0; }
+EXPORT struct S_FFF f17_S_SIP_FFF(struct S_FFF p0, int p1, void* p2) { return p0; }
+EXPORT struct S_FFD f17_S_SIP_FFD(struct S_FFD p0, int p1, void* p2) { return p0; }
+EXPORT struct S_FFP f17_S_SIP_FFP(struct S_FFP p0, int p1, void* p2) { return p0; }
+EXPORT struct S_FDI f17_S_SIP_FDI(struct S_FDI p0, int p1, void* p2) { return p0; }
+EXPORT struct S_FDF f17_S_SIP_FDF(struct S_FDF p0, int p1, void* p2) { return p0; }
+EXPORT struct S_FDD f17_S_SIP_FDD(struct S_FDD p0, int p1, void* p2) { return p0; }
+EXPORT struct S_FDP f17_S_SIP_FDP(struct S_FDP p0, int p1, void* p2) { return p0; }
+EXPORT struct S_FPI f17_S_SIP_FPI(struct S_FPI p0, int p1, void* p2) { return p0; }
+EXPORT struct S_FPF f17_S_SIP_FPF(struct S_FPF p0, int p1, void* p2) { return p0; }
+EXPORT struct S_FPD f17_S_SIP_FPD(struct S_FPD p0, int p1, void* p2) { return p0; }
+EXPORT struct S_FPP f17_S_SIP_FPP(struct S_FPP p0, int p1, void* p2) { return p0; }
+EXPORT struct S_DII f17_S_SIP_DII(struct S_DII p0, int p1, void* p2) { return p0; }
+EXPORT struct S_DIF f17_S_SIP_DIF(struct S_DIF p0, int p1, void* p2) { return p0; }
+EXPORT struct S_DID f17_S_SIP_DID(struct S_DID p0, int p1, void* p2) { return p0; }
+EXPORT struct S_DIP f17_S_SIP_DIP(struct S_DIP p0, int p1, void* p2) { return p0; }
+EXPORT struct S_DFI f17_S_SIP_DFI(struct S_DFI p0, int p1, void* p2) { return p0; }
+EXPORT struct S_DFF f17_S_SIP_DFF(struct S_DFF p0, int p1, void* p2) { return p0; }
+EXPORT struct S_DFD f17_S_SIP_DFD(struct S_DFD p0, int p1, void* p2) { return p0; }
+EXPORT struct S_DFP f17_S_SIP_DFP(struct S_DFP p0, int p1, void* p2) { return p0; }
+EXPORT struct S_DDI f17_S_SIP_DDI(struct S_DDI p0, int p1, void* p2) { return p0; }
+EXPORT struct S_DDF f17_S_SIP_DDF(struct S_DDF p0, int p1, void* p2) { return p0; }
+EXPORT struct S_DDD f17_S_SIP_DDD(struct S_DDD p0, int p1, void* p2) { return p0; }
+EXPORT struct S_DDP f17_S_SIP_DDP(struct S_DDP p0, int p1, void* p2) { return p0; }
+EXPORT struct S_DPI f17_S_SIP_DPI(struct S_DPI p0, int p1, void* p2) { return p0; }
+EXPORT struct S_DPF f17_S_SIP_DPF(struct S_DPF p0, int p1, void* p2) { return p0; }
+EXPORT struct S_DPD f17_S_SIP_DPD(struct S_DPD p0, int p1, void* p2) { return p0; }
+EXPORT struct S_DPP f17_S_SIP_DPP(struct S_DPP p0, int p1, void* p2) { return p0; }
+EXPORT struct S_PII f17_S_SIP_PII(struct S_PII p0, int p1, void* p2) { return p0; }
+EXPORT struct S_PIF f17_S_SIP_PIF(struct S_PIF p0, int p1, void* p2) { return p0; }
+EXPORT struct S_PID f17_S_SIP_PID(struct S_PID p0, int p1, void* p2) { return p0; }
+EXPORT struct S_PIP f17_S_SIP_PIP(struct S_PIP p0, int p1, void* p2) { return p0; }
+EXPORT struct S_PFI f17_S_SIP_PFI(struct S_PFI p0, int p1, void* p2) { return p0; }
+EXPORT struct S_PFF f17_S_SIP_PFF(struct S_PFF p0, int p1, void* p2) { return p0; }
+EXPORT struct S_PFD f17_S_SIP_PFD(struct S_PFD p0, int p1, void* p2) { return p0; }
+EXPORT struct S_PFP f17_S_SIP_PFP(struct S_PFP p0, int p1, void* p2) { return p0; }
+EXPORT struct S_PDI f17_S_SIP_PDI(struct S_PDI p0, int p1, void* p2) { return p0; }
+EXPORT struct S_PDF f17_S_SIP_PDF(struct S_PDF p0, int p1, void* p2) { return p0; }
+EXPORT struct S_PDD f17_S_SIP_PDD(struct S_PDD p0, int p1, void* p2) { return p0; }
+EXPORT struct S_PDP f17_S_SIP_PDP(struct S_PDP p0, int p1, void* p2) { return p0; }
+EXPORT struct S_PPI f17_S_SIP_PPI(struct S_PPI p0, int p1, void* p2) { return p0; }
+EXPORT struct S_PPF f17_S_SIP_PPF(struct S_PPF p0, int p1, void* p2) { return p0; }
+EXPORT struct S_PPD f17_S_SIP_PPD(struct S_PPD p0, int p1, void* p2) { return p0; }
+EXPORT struct S_PPP f17_S_SIP_PPP(struct S_PPP p0, int p1, void* p2) { return p0; }
+EXPORT struct S_I f17_S_SIS_I(struct S_I p0, int p1, struct S_I p2) { return p0; }
+EXPORT struct S_F f17_S_SIS_F(struct S_F p0, int p1, struct S_F p2) { return p0; }
+EXPORT struct S_D f17_S_SIS_D(struct S_D p0, int p1, struct S_D p2) { return p0; }
+EXPORT struct S_P f17_S_SIS_P(struct S_P p0, int p1, struct S_P p2) { return p0; }
+EXPORT struct S_II f17_S_SIS_II(struct S_II p0, int p1, struct S_II p2) { return p0; }
+EXPORT struct S_IF f17_S_SIS_IF(struct S_IF p0, int p1, struct S_IF p2) { return p0; }
+EXPORT struct S_ID f17_S_SIS_ID(struct S_ID p0, int p1, struct S_ID p2) { return p0; }
+EXPORT struct S_IP f17_S_SIS_IP(struct S_IP p0, int p1, struct S_IP p2) { return p0; }
+EXPORT struct S_FI f17_S_SIS_FI(struct S_FI p0, int p1, struct S_FI p2) { return p0; }
+EXPORT struct S_FF f17_S_SIS_FF(struct S_FF p0, int p1, struct S_FF p2) { return p0; }
+EXPORT struct S_FD f17_S_SIS_FD(struct S_FD p0, int p1, struct S_FD p2) { return p0; }
+EXPORT struct S_FP f17_S_SIS_FP(struct S_FP p0, int p1, struct S_FP p2) { return p0; }
+EXPORT struct S_DI f17_S_SIS_DI(struct S_DI p0, int p1, struct S_DI p2) { return p0; }
+EXPORT struct S_DF f17_S_SIS_DF(struct S_DF p0, int p1, struct S_DF p2) { return p0; }
+EXPORT struct S_DD f17_S_SIS_DD(struct S_DD p0, int p1, struct S_DD p2) { return p0; }
+EXPORT struct S_DP f17_S_SIS_DP(struct S_DP p0, int p1, struct S_DP p2) { return p0; }
+EXPORT struct S_PI f17_S_SIS_PI(struct S_PI p0, int p1, struct S_PI p2) { return p0; }
+EXPORT struct S_PF f17_S_SIS_PF(struct S_PF p0, int p1, struct S_PF p2) { return p0; }
+EXPORT struct S_PD f17_S_SIS_PD(struct S_PD p0, int p1, struct S_PD p2) { return p0; }
+EXPORT struct S_PP f17_S_SIS_PP(struct S_PP p0, int p1, struct S_PP p2) { return p0; }
+EXPORT struct S_III f17_S_SIS_III(struct S_III p0, int p1, struct S_III p2) { return p0; }
+EXPORT struct S_IIF f17_S_SIS_IIF(struct S_IIF p0, int p1, struct S_IIF p2) { return p0; }
+EXPORT struct S_IID f17_S_SIS_IID(struct S_IID p0, int p1, struct S_IID p2) { return p0; }
+EXPORT struct S_IIP f17_S_SIS_IIP(struct S_IIP p0, int p1, struct S_IIP p2) { return p0; }
+EXPORT struct S_IFI f17_S_SIS_IFI(struct S_IFI p0, int p1, struct S_IFI p2) { return p0; }
+EXPORT struct S_IFF f17_S_SIS_IFF(struct S_IFF p0, int p1, struct S_IFF p2) { return p0; }
+EXPORT struct S_IFD f17_S_SIS_IFD(struct S_IFD p0, int p1, struct S_IFD p2) { return p0; }
+EXPORT struct S_IFP f17_S_SIS_IFP(struct S_IFP p0, int p1, struct S_IFP p2) { return p0; }
+EXPORT struct S_IDI f17_S_SIS_IDI(struct S_IDI p0, int p1, struct S_IDI p2) { return p0; }
+EXPORT struct S_IDF f17_S_SIS_IDF(struct S_IDF p0, int p1, struct S_IDF p2) { return p0; }
+EXPORT struct S_IDD f17_S_SIS_IDD(struct S_IDD p0, int p1, struct S_IDD p2) { return p0; }
+EXPORT struct S_IDP f17_S_SIS_IDP(struct S_IDP p0, int p1, struct S_IDP p2) { return p0; }
+EXPORT struct S_IPI f17_S_SIS_IPI(struct S_IPI p0, int p1, struct S_IPI p2) { return p0; }
+EXPORT struct S_IPF f17_S_SIS_IPF(struct S_IPF p0, int p1, struct S_IPF p2) { return p0; }
+EXPORT struct S_IPD f17_S_SIS_IPD(struct S_IPD p0, int p1, struct S_IPD p2) { return p0; }
+EXPORT struct S_IPP f17_S_SIS_IPP(struct S_IPP p0, int p1, struct S_IPP p2) { return p0; }
+EXPORT struct S_FII f17_S_SIS_FII(struct S_FII p0, int p1, struct S_FII p2) { return p0; }
+EXPORT struct S_FIF f17_S_SIS_FIF(struct S_FIF p0, int p1, struct S_FIF p2) { return p0; }
+EXPORT struct S_FID f17_S_SIS_FID(struct S_FID p0, int p1, struct S_FID p2) { return p0; }
+EXPORT struct S_FIP f17_S_SIS_FIP(struct S_FIP p0, int p1, struct S_FIP p2) { return p0; }
+EXPORT struct S_FFI f17_S_SIS_FFI(struct S_FFI p0, int p1, struct S_FFI p2) { return p0; }
+EXPORT struct S_FFF f17_S_SIS_FFF(struct S_FFF p0, int p1, struct S_FFF p2) { return p0; }
+EXPORT struct S_FFD f17_S_SIS_FFD(struct S_FFD p0, int p1, struct S_FFD p2) { return p0; }
+EXPORT struct S_FFP f17_S_SIS_FFP(struct S_FFP p0, int p1, struct S_FFP p2) { return p0; }
+EXPORT struct S_FDI f17_S_SIS_FDI(struct S_FDI p0, int p1, struct S_FDI p2) { return p0; }
+EXPORT struct S_FDF f17_S_SIS_FDF(struct S_FDF p0, int p1, struct S_FDF p2) { return p0; }
+EXPORT struct S_FDD f17_S_SIS_FDD(struct S_FDD p0, int p1, struct S_FDD p2) { return p0; }
+EXPORT struct S_FDP f17_S_SIS_FDP(struct S_FDP p0, int p1, struct S_FDP p2) { return p0; }
+EXPORT struct S_FPI f17_S_SIS_FPI(struct S_FPI p0, int p1, struct S_FPI p2) { return p0; }
+EXPORT struct S_FPF f17_S_SIS_FPF(struct S_FPF p0, int p1, struct S_FPF p2) { return p0; }
+EXPORT struct S_FPD f17_S_SIS_FPD(struct S_FPD p0, int p1, struct S_FPD p2) { return p0; }
+EXPORT struct S_FPP f17_S_SIS_FPP(struct S_FPP p0, int p1, struct S_FPP p2) { return p0; }
+EXPORT struct S_DII f17_S_SIS_DII(struct S_DII p0, int p1, struct S_DII p2) { return p0; }
+EXPORT struct S_DIF f17_S_SIS_DIF(struct S_DIF p0, int p1, struct S_DIF p2) { return p0; }
+EXPORT struct S_DID f17_S_SIS_DID(struct S_DID p0, int p1, struct S_DID p2) { return p0; }
+EXPORT struct S_DIP f17_S_SIS_DIP(struct S_DIP p0, int p1, struct S_DIP p2) { return p0; }
+EXPORT struct S_DFI f17_S_SIS_DFI(struct S_DFI p0, int p1, struct S_DFI p2) { return p0; }
+EXPORT struct S_DFF f17_S_SIS_DFF(struct S_DFF p0, int p1, struct S_DFF p2) { return p0; }
+EXPORT struct S_DFD f17_S_SIS_DFD(struct S_DFD p0, int p1, struct S_DFD p2) { return p0; }
+EXPORT struct S_DFP f17_S_SIS_DFP(struct S_DFP p0, int p1, struct S_DFP p2) { return p0; }
+EXPORT struct S_DDI f17_S_SIS_DDI(struct S_DDI p0, int p1, struct S_DDI p2) { return p0; }
+EXPORT struct S_DDF f17_S_SIS_DDF(struct S_DDF p0, int p1, struct S_DDF p2) { return p0; }
+EXPORT struct S_DDD f17_S_SIS_DDD(struct S_DDD p0, int p1, struct S_DDD p2) { return p0; }
+EXPORT struct S_DDP f17_S_SIS_DDP(struct S_DDP p0, int p1, struct S_DDP p2) { return p0; }
+EXPORT struct S_DPI f17_S_SIS_DPI(struct S_DPI p0, int p1, struct S_DPI p2) { return p0; }
+EXPORT struct S_DPF f17_S_SIS_DPF(struct S_DPF p0, int p1, struct S_DPF p2) { return p0; }
+EXPORT struct S_DPD f17_S_SIS_DPD(struct S_DPD p0, int p1, struct S_DPD p2) { return p0; }
+EXPORT struct S_DPP f17_S_SIS_DPP(struct S_DPP p0, int p1, struct S_DPP p2) { return p0; }
+EXPORT struct S_PII f17_S_SIS_PII(struct S_PII p0, int p1, struct S_PII p2) { return p0; }
+EXPORT struct S_PIF f17_S_SIS_PIF(struct S_PIF p0, int p1, struct S_PIF p2) { return p0; }
+EXPORT struct S_PID f17_S_SIS_PID(struct S_PID p0, int p1, struct S_PID p2) { return p0; }
+EXPORT struct S_PIP f17_S_SIS_PIP(struct S_PIP p0, int p1, struct S_PIP p2) { return p0; }
+EXPORT struct S_PFI f17_S_SIS_PFI(struct S_PFI p0, int p1, struct S_PFI p2) { return p0; }
+EXPORT struct S_PFF f17_S_SIS_PFF(struct S_PFF p0, int p1, struct S_PFF p2) { return p0; }
+EXPORT struct S_PFD f17_S_SIS_PFD(struct S_PFD p0, int p1, struct S_PFD p2) { return p0; }
+EXPORT struct S_PFP f17_S_SIS_PFP(struct S_PFP p0, int p1, struct S_PFP p2) { return p0; }
+EXPORT struct S_PDI f17_S_SIS_PDI(struct S_PDI p0, int p1, struct S_PDI p2) { return p0; }
+EXPORT struct S_PDF f17_S_SIS_PDF(struct S_PDF p0, int p1, struct S_PDF p2) { return p0; }
+EXPORT struct S_PDD f17_S_SIS_PDD(struct S_PDD p0, int p1, struct S_PDD p2) { return p0; }
+EXPORT struct S_PDP f17_S_SIS_PDP(struct S_PDP p0, int p1, struct S_PDP p2) { return p0; }
+EXPORT struct S_PPI f17_S_SIS_PPI(struct S_PPI p0, int p1, struct S_PPI p2) { return p0; }
+EXPORT struct S_PPF f17_S_SIS_PPF(struct S_PPF p0, int p1, struct S_PPF p2) { return p0; }
+EXPORT struct S_PPD f17_S_SIS_PPD(struct S_PPD p0, int p1, struct S_PPD p2) { return p0; }
+EXPORT struct S_PPP f17_S_SIS_PPP(struct S_PPP p0, int p1, struct S_PPP p2) { return p0; }
+EXPORT struct S_I f17_S_SFI_I(struct S_I p0, float p1, int p2) { return p0; }
+EXPORT struct S_F f17_S_SFI_F(struct S_F p0, float p1, int p2) { return p0; }
+EXPORT struct S_D f17_S_SFI_D(struct S_D p0, float p1, int p2) { return p0; }
+EXPORT struct S_P f17_S_SFI_P(struct S_P p0, float p1, int p2) { return p0; }
+EXPORT struct S_II f17_S_SFI_II(struct S_II p0, float p1, int p2) { return p0; }
+EXPORT struct S_IF f17_S_SFI_IF(struct S_IF p0, float p1, int p2) { return p0; }
+EXPORT struct S_ID f17_S_SFI_ID(struct S_ID p0, float p1, int p2) { return p0; }
+EXPORT struct S_IP f17_S_SFI_IP(struct S_IP p0, float p1, int p2) { return p0; }
+EXPORT struct S_FI f17_S_SFI_FI(struct S_FI p0, float p1, int p2) { return p0; }
+EXPORT struct S_FF f17_S_SFI_FF(struct S_FF p0, float p1, int p2) { return p0; }
+EXPORT struct S_FD f17_S_SFI_FD(struct S_FD p0, float p1, int p2) { return p0; }
+EXPORT struct S_FP f17_S_SFI_FP(struct S_FP p0, float p1, int p2) { return p0; }
+EXPORT struct S_DI f17_S_SFI_DI(struct S_DI p0, float p1, int p2) { return p0; }
+EXPORT struct S_DF f17_S_SFI_DF(struct S_DF p0, float p1, int p2) { return p0; }
+EXPORT struct S_DD f17_S_SFI_DD(struct S_DD p0, float p1, int p2) { return p0; }
+EXPORT struct S_DP f17_S_SFI_DP(struct S_DP p0, float p1, int p2) { return p0; }
+EXPORT struct S_PI f17_S_SFI_PI(struct S_PI p0, float p1, int p2) { return p0; }
+EXPORT struct S_PF f17_S_SFI_PF(struct S_PF p0, float p1, int p2) { return p0; }
+EXPORT struct S_PD f17_S_SFI_PD(struct S_PD p0, float p1, int p2) { return p0; }
+EXPORT struct S_PP f17_S_SFI_PP(struct S_PP p0, float p1, int p2) { return p0; }
+EXPORT struct S_III f17_S_SFI_III(struct S_III p0, float p1, int p2) { return p0; }
+EXPORT struct S_IIF f17_S_SFI_IIF(struct S_IIF p0, float p1, int p2) { return p0; }
+EXPORT struct S_IID f17_S_SFI_IID(struct S_IID p0, float p1, int p2) { return p0; }
+EXPORT struct S_IIP f17_S_SFI_IIP(struct S_IIP p0, float p1, int p2) { return p0; }
+EXPORT struct S_IFI f17_S_SFI_IFI(struct S_IFI p0, float p1, int p2) { return p0; }
+EXPORT struct S_IFF f17_S_SFI_IFF(struct S_IFF p0, float p1, int p2) { return p0; }
+EXPORT struct S_IFD f17_S_SFI_IFD(struct S_IFD p0, float p1, int p2) { return p0; }
+EXPORT struct S_IFP f17_S_SFI_IFP(struct S_IFP p0, float p1, int p2) { return p0; }
+EXPORT struct S_IDI f17_S_SFI_IDI(struct S_IDI p0, float p1, int p2) { return p0; }
+EXPORT struct S_IDF f17_S_SFI_IDF(struct S_IDF p0, float p1, int p2) { return p0; }
+EXPORT struct S_IDD f17_S_SFI_IDD(struct S_IDD p0, float p1, int p2) { return p0; }
+EXPORT struct S_IDP f17_S_SFI_IDP(struct S_IDP p0, float p1, int p2) { return p0; }
+EXPORT struct S_IPI f17_S_SFI_IPI(struct S_IPI p0, float p1, int p2) { return p0; }
+EXPORT struct S_IPF f17_S_SFI_IPF(struct S_IPF p0, float p1, int p2) { return p0; }
+EXPORT struct S_IPD f17_S_SFI_IPD(struct S_IPD p0, float p1, int p2) { return p0; }
+EXPORT struct S_IPP f17_S_SFI_IPP(struct S_IPP p0, float p1, int p2) { return p0; }
+EXPORT struct S_FII f17_S_SFI_FII(struct S_FII p0, float p1, int p2) { return p0; }
+EXPORT struct S_FIF f17_S_SFI_FIF(struct S_FIF p0, float p1, int p2) { return p0; }
+EXPORT struct S_FID f17_S_SFI_FID(struct S_FID p0, float p1, int p2) { return p0; }
+EXPORT struct S_FIP f17_S_SFI_FIP(struct S_FIP p0, float p1, int p2) { return p0; }
+EXPORT struct S_FFI f17_S_SFI_FFI(struct S_FFI p0, float p1, int p2) { return p0; }
+EXPORT struct S_FFF f17_S_SFI_FFF(struct S_FFF p0, float p1, int p2) { return p0; }
+EXPORT struct S_FFD f17_S_SFI_FFD(struct S_FFD p0, float p1, int p2) { return p0; }
+EXPORT struct S_FFP f17_S_SFI_FFP(struct S_FFP p0, float p1, int p2) { return p0; }
+EXPORT struct S_FDI f17_S_SFI_FDI(struct S_FDI p0, float p1, int p2) { return p0; }
+EXPORT struct S_FDF f17_S_SFI_FDF(struct S_FDF p0, float p1, int p2) { return p0; }
+EXPORT struct S_FDD f17_S_SFI_FDD(struct S_FDD p0, float p1, int p2) { return p0; }
+EXPORT struct S_FDP f17_S_SFI_FDP(struct S_FDP p0, float p1, int p2) { return p0; }
+EXPORT struct S_FPI f17_S_SFI_FPI(struct S_FPI p0, float p1, int p2) { return p0; }
+EXPORT struct S_FPF f17_S_SFI_FPF(struct S_FPF p0, float p1, int p2) { return p0; }
+EXPORT struct S_FPD f17_S_SFI_FPD(struct S_FPD p0, float p1, int p2) { return p0; }
+EXPORT struct S_FPP f17_S_SFI_FPP(struct S_FPP p0, float p1, int p2) { return p0; }
+EXPORT struct S_DII f17_S_SFI_DII(struct S_DII p0, float p1, int p2) { return p0; }
+EXPORT struct S_DIF f17_S_SFI_DIF(struct S_DIF p0, float p1, int p2) { return p0; }
+EXPORT struct S_DID f17_S_SFI_DID(struct S_DID p0, float p1, int p2) { return p0; }
+EXPORT struct S_DIP f17_S_SFI_DIP(struct S_DIP p0, float p1, int p2) { return p0; }
+EXPORT struct S_DFI f17_S_SFI_DFI(struct S_DFI p0, float p1, int p2) { return p0; }
+EXPORT struct S_DFF f17_S_SFI_DFF(struct S_DFF p0, float p1, int p2) { return p0; }
+EXPORT struct S_DFD f17_S_SFI_DFD(struct S_DFD p0, float p1, int p2) { return p0; }
+EXPORT struct S_DFP f17_S_SFI_DFP(struct S_DFP p0, float p1, int p2) { return p0; }
+EXPORT struct S_DDI f17_S_SFI_DDI(struct S_DDI p0, float p1, int p2) { return p0; }
+EXPORT struct S_DDF f17_S_SFI_DDF(struct S_DDF p0, float p1, int p2) { return p0; }
+EXPORT struct S_DDD f17_S_SFI_DDD(struct S_DDD p0, float p1, int p2) { return p0; }
+EXPORT struct S_DDP f17_S_SFI_DDP(struct S_DDP p0, float p1, int p2) { return p0; }
+EXPORT struct S_DPI f17_S_SFI_DPI(struct S_DPI p0, float p1, int p2) { return p0; }
+EXPORT struct S_DPF f17_S_SFI_DPF(struct S_DPF p0, float p1, int p2) { return p0; }
+EXPORT struct S_DPD f17_S_SFI_DPD(struct S_DPD p0, float p1, int p2) { return p0; }
+EXPORT struct S_DPP f17_S_SFI_DPP(struct S_DPP p0, float p1, int p2) { return p0; }
+EXPORT struct S_PII f17_S_SFI_PII(struct S_PII p0, float p1, int p2) { return p0; }
+EXPORT struct S_PIF f17_S_SFI_PIF(struct S_PIF p0, float p1, int p2) { return p0; }
+EXPORT struct S_PID f17_S_SFI_PID(struct S_PID p0, float p1, int p2) { return p0; }
+EXPORT struct S_PIP f17_S_SFI_PIP(struct S_PIP p0, float p1, int p2) { return p0; }
+EXPORT struct S_PFI f17_S_SFI_PFI(struct S_PFI p0, float p1, int p2) { return p0; }
+EXPORT struct S_PFF f17_S_SFI_PFF(struct S_PFF p0, float p1, int p2) { return p0; }
+EXPORT struct S_PFD f17_S_SFI_PFD(struct S_PFD p0, float p1, int p2) { return p0; }
+EXPORT struct S_PFP f17_S_SFI_PFP(struct S_PFP p0, float p1, int p2) { return p0; }
+EXPORT struct S_PDI f17_S_SFI_PDI(struct S_PDI p0, float p1, int p2) { return p0; }
+EXPORT struct S_PDF f17_S_SFI_PDF(struct S_PDF p0, float p1, int p2) { return p0; }
+EXPORT struct S_PDD f17_S_SFI_PDD(struct S_PDD p0, float p1, int p2) { return p0; }
+EXPORT struct S_PDP f17_S_SFI_PDP(struct S_PDP p0, float p1, int p2) { return p0; }
+EXPORT struct S_PPI f17_S_SFI_PPI(struct S_PPI p0, float p1, int p2) { return p0; }
+EXPORT struct S_PPF f17_S_SFI_PPF(struct S_PPF p0, float p1, int p2) { return p0; }
+EXPORT struct S_PPD f17_S_SFI_PPD(struct S_PPD p0, float p1, int p2) { return p0; }
+EXPORT struct S_PPP f17_S_SFI_PPP(struct S_PPP p0, float p1, int p2) { return p0; }
+EXPORT struct S_I f17_S_SFF_I(struct S_I p0, float p1, float p2) { return p0; }
+EXPORT struct S_F f17_S_SFF_F(struct S_F p0, float p1, float p2) { return p0; }
+EXPORT struct S_D f17_S_SFF_D(struct S_D p0, float p1, float p2) { return p0; }
+EXPORT struct S_P f17_S_SFF_P(struct S_P p0, float p1, float p2) { return p0; }
+EXPORT struct S_II f17_S_SFF_II(struct S_II p0, float p1, float p2) { return p0; }
+EXPORT struct S_IF f17_S_SFF_IF(struct S_IF p0, float p1, float p2) { return p0; }
+EXPORT struct S_ID f17_S_SFF_ID(struct S_ID p0, float p1, float p2) { return p0; }
+EXPORT struct S_IP f17_S_SFF_IP(struct S_IP p0, float p1, float p2) { return p0; }
+EXPORT struct S_FI f17_S_SFF_FI(struct S_FI p0, float p1, float p2) { return p0; }
+EXPORT struct S_FF f17_S_SFF_FF(struct S_FF p0, float p1, float p2) { return p0; }
+EXPORT struct S_FD f17_S_SFF_FD(struct S_FD p0, float p1, float p2) { return p0; }
+EXPORT struct S_FP f17_S_SFF_FP(struct S_FP p0, float p1, float p2) { return p0; }
+EXPORT struct S_DI f17_S_SFF_DI(struct S_DI p0, float p1, float p2) { return p0; }
+EXPORT struct S_DF f17_S_SFF_DF(struct S_DF p0, float p1, float p2) { return p0; }
+EXPORT struct S_DD f17_S_SFF_DD(struct S_DD p0, float p1, float p2) { return p0; }
+EXPORT struct S_DP f17_S_SFF_DP(struct S_DP p0, float p1, float p2) { return p0; }
+EXPORT struct S_PI f17_S_SFF_PI(struct S_PI p0, float p1, float p2) { return p0; }
+EXPORT struct S_PF f17_S_SFF_PF(struct S_PF p0, float p1, float p2) { return p0; }
+EXPORT struct S_PD f17_S_SFF_PD(struct S_PD p0, float p1, float p2) { return p0; }
+EXPORT struct S_PP f17_S_SFF_PP(struct S_PP p0, float p1, float p2) { return p0; }
+EXPORT struct S_III f17_S_SFF_III(struct S_III p0, float p1, float p2) { return p0; }
+EXPORT struct S_IIF f17_S_SFF_IIF(struct S_IIF p0, float p1, float p2) { return p0; }
+EXPORT struct S_IID f17_S_SFF_IID(struct S_IID p0, float p1, float p2) { return p0; }
+EXPORT struct S_IIP f17_S_SFF_IIP(struct S_IIP p0, float p1, float p2) { return p0; }
+EXPORT struct S_IFI f17_S_SFF_IFI(struct S_IFI p0, float p1, float p2) { return p0; }
+EXPORT struct S_IFF f17_S_SFF_IFF(struct S_IFF p0, float p1, float p2) { return p0; }
+EXPORT struct S_IFD f17_S_SFF_IFD(struct S_IFD p0, float p1, float p2) { return p0; }
+EXPORT struct S_IFP f17_S_SFF_IFP(struct S_IFP p0, float p1, float p2) { return p0; }
+EXPORT struct S_IDI f17_S_SFF_IDI(struct S_IDI p0, float p1, float p2) { return p0; }
+EXPORT struct S_IDF f17_S_SFF_IDF(struct S_IDF p0, float p1, float p2) { return p0; }
+EXPORT struct S_IDD f17_S_SFF_IDD(struct S_IDD p0, float p1, float p2) { return p0; }
+EXPORT struct S_IDP f17_S_SFF_IDP(struct S_IDP p0, float p1, float p2) { return p0; }
+EXPORT struct S_IPI f17_S_SFF_IPI(struct S_IPI p0, float p1, float p2) { return p0; }
+EXPORT struct S_IPF f17_S_SFF_IPF(struct S_IPF p0, float p1, float p2) { return p0; }
+EXPORT struct S_IPD f17_S_SFF_IPD(struct S_IPD p0, float p1, float p2) { return p0; }
+EXPORT struct S_IPP f17_S_SFF_IPP(struct S_IPP p0, float p1, float p2) { return p0; }
+EXPORT struct S_FII f17_S_SFF_FII(struct S_FII p0, float p1, float p2) { return p0; }
+EXPORT struct S_FIF f17_S_SFF_FIF(struct S_FIF p0, float p1, float p2) { return p0; }
+EXPORT struct S_FID f17_S_SFF_FID(struct S_FID p0, float p1, float p2) { return p0; }
+EXPORT struct S_FIP f17_S_SFF_FIP(struct S_FIP p0, float p1, float p2) { return p0; }
+EXPORT struct S_FFI f17_S_SFF_FFI(struct S_FFI p0, float p1, float p2) { return p0; }
+EXPORT struct S_FFF f17_S_SFF_FFF(struct S_FFF p0, float p1, float p2) { return p0; }
+EXPORT struct S_FFD f17_S_SFF_FFD(struct S_FFD p0, float p1, float p2) { return p0; }
+EXPORT struct S_FFP f17_S_SFF_FFP(struct S_FFP p0, float p1, float p2) { return p0; }
+EXPORT struct S_FDI f17_S_SFF_FDI(struct S_FDI p0, float p1, float p2) { return p0; }
+EXPORT struct S_FDF f17_S_SFF_FDF(struct S_FDF p0, float p1, float p2) { return p0; }
+EXPORT struct S_FDD f17_S_SFF_FDD(struct S_FDD p0, float p1, float p2) { return p0; }
+EXPORT struct S_FDP f17_S_SFF_FDP(struct S_FDP p0, float p1, float p2) { return p0; }
+EXPORT struct S_FPI f17_S_SFF_FPI(struct S_FPI p0, float p1, float p2) { return p0; }
+EXPORT struct S_FPF f17_S_SFF_FPF(struct S_FPF p0, float p1, float p2) { return p0; }
+EXPORT struct S_FPD f17_S_SFF_FPD(struct S_FPD p0, float p1, float p2) { return p0; }
+EXPORT struct S_FPP f17_S_SFF_FPP(struct S_FPP p0, float p1, float p2) { return p0; }
+EXPORT struct S_DII f17_S_SFF_DII(struct S_DII p0, float p1, float p2) { return p0; }
+EXPORT struct S_DIF f17_S_SFF_DIF(struct S_DIF p0, float p1, float p2) { return p0; }
+EXPORT struct S_DID f17_S_SFF_DID(struct S_DID p0, float p1, float p2) { return p0; }
+EXPORT struct S_DIP f17_S_SFF_DIP(struct S_DIP p0, float p1, float p2) { return p0; }
+EXPORT struct S_DFI f17_S_SFF_DFI(struct S_DFI p0, float p1, float p2) { return p0; }
+EXPORT struct S_DFF f17_S_SFF_DFF(struct S_DFF p0, float p1, float p2) { return p0; }
+EXPORT struct S_DFD f17_S_SFF_DFD(struct S_DFD p0, float p1, float p2) { return p0; }
+EXPORT struct S_DFP f17_S_SFF_DFP(struct S_DFP p0, float p1, float p2) { return p0; }
+EXPORT struct S_DDI f17_S_SFF_DDI(struct S_DDI p0, float p1, float p2) { return p0; }
+EXPORT struct S_DDF f17_S_SFF_DDF(struct S_DDF p0, float p1, float p2) { return p0; }
+EXPORT struct S_DDD f17_S_SFF_DDD(struct S_DDD p0, float p1, float p2) { return p0; }
+EXPORT struct S_DDP f17_S_SFF_DDP(struct S_DDP p0, float p1, float p2) { return p0; }
+EXPORT struct S_DPI f17_S_SFF_DPI(struct S_DPI p0, float p1, float p2) { return p0; }
+EXPORT struct S_DPF f17_S_SFF_DPF(struct S_DPF p0, float p1, float p2) { return p0; }
+EXPORT struct S_DPD f17_S_SFF_DPD(struct S_DPD p0, float p1, float p2) { return p0; }
+EXPORT struct S_DPP f17_S_SFF_DPP(struct S_DPP p0, float p1, float p2) { return p0; }
+EXPORT struct S_PII f17_S_SFF_PII(struct S_PII p0, float p1, float p2) { return p0; }
+EXPORT struct S_PIF f17_S_SFF_PIF(struct S_PIF p0, float p1, float p2) { return p0; }
+EXPORT struct S_PID f17_S_SFF_PID(struct S_PID p0, float p1, float p2) { return p0; }
+EXPORT struct S_PIP f17_S_SFF_PIP(struct S_PIP p0, float p1, float p2) { return p0; }
+EXPORT struct S_PFI f17_S_SFF_PFI(struct S_PFI p0, float p1, float p2) { return p0; }
+EXPORT struct S_PFF f17_S_SFF_PFF(struct S_PFF p0, float p1, float p2) { return p0; }
+EXPORT struct S_PFD f17_S_SFF_PFD(struct S_PFD p0, float p1, float p2) { return p0; }
+EXPORT struct S_PFP f17_S_SFF_PFP(struct S_PFP p0, float p1, float p2) { return p0; }
+EXPORT struct S_PDI f17_S_SFF_PDI(struct S_PDI p0, float p1, float p2) { return p0; }
+EXPORT struct S_PDF f17_S_SFF_PDF(struct S_PDF p0, float p1, float p2) { return p0; }
+EXPORT struct S_PDD f17_S_SFF_PDD(struct S_PDD p0, float p1, float p2) { return p0; }
+EXPORT struct S_PDP f17_S_SFF_PDP(struct S_PDP p0, float p1, float p2) { return p0; }
+EXPORT struct S_PPI f17_S_SFF_PPI(struct S_PPI p0, float p1, float p2) { return p0; }
+EXPORT struct S_PPF f17_S_SFF_PPF(struct S_PPF p0, float p1, float p2) { return p0; }
+EXPORT struct S_PPD f17_S_SFF_PPD(struct S_PPD p0, float p1, float p2) { return p0; }
+EXPORT struct S_PPP f17_S_SFF_PPP(struct S_PPP p0, float p1, float p2) { return p0; }
+EXPORT struct S_I f17_S_SFD_I(struct S_I p0, float p1, double p2) { return p0; }
+EXPORT struct S_F f17_S_SFD_F(struct S_F p0, float p1, double p2) { return p0; }
+EXPORT struct S_D f17_S_SFD_D(struct S_D p0, float p1, double p2) { return p0; }
+EXPORT struct S_P f17_S_SFD_P(struct S_P p0, float p1, double p2) { return p0; }
+EXPORT struct S_II f17_S_SFD_II(struct S_II p0, float p1, double p2) { return p0; }
+EXPORT struct S_IF f17_S_SFD_IF(struct S_IF p0, float p1, double p2) { return p0; }
+EXPORT struct S_ID f17_S_SFD_ID(struct S_ID p0, float p1, double p2) { return p0; }
+EXPORT struct S_IP f17_S_SFD_IP(struct S_IP p0, float p1, double p2) { return p0; }
+EXPORT struct S_FI f17_S_SFD_FI(struct S_FI p0, float p1, double p2) { return p0; }
+EXPORT struct S_FF f17_S_SFD_FF(struct S_FF p0, float p1, double p2) { return p0; }
+EXPORT struct S_FD f17_S_SFD_FD(struct S_FD p0, float p1, double p2) { return p0; }
+EXPORT struct S_FP f17_S_SFD_FP(struct S_FP p0, float p1, double p2) { return p0; }
+EXPORT struct S_DI f17_S_SFD_DI(struct S_DI p0, float p1, double p2) { return p0; }
+EXPORT struct S_DF f17_S_SFD_DF(struct S_DF p0, float p1, double p2) { return p0; }
+EXPORT struct S_DD f17_S_SFD_DD(struct S_DD p0, float p1, double p2) { return p0; }
+EXPORT struct S_DP f17_S_SFD_DP(struct S_DP p0, float p1, double p2) { return p0; }
+EXPORT struct S_PI f17_S_SFD_PI(struct S_PI p0, float p1, double p2) { return p0; }
+EXPORT struct S_PF f17_S_SFD_PF(struct S_PF p0, float p1, double p2) { return p0; }
+EXPORT struct S_PD f17_S_SFD_PD(struct S_PD p0, float p1, double p2) { return p0; }
+EXPORT struct S_PP f17_S_SFD_PP(struct S_PP p0, float p1, double p2) { return p0; }
+EXPORT struct S_III f17_S_SFD_III(struct S_III p0, float p1, double p2) { return p0; }
+EXPORT struct S_IIF f17_S_SFD_IIF(struct S_IIF p0, float p1, double p2) { return p0; }
+EXPORT struct S_IID f17_S_SFD_IID(struct S_IID p0, float p1, double p2) { return p0; }
+EXPORT struct S_IIP f17_S_SFD_IIP(struct S_IIP p0, float p1, double p2) { return p0; }
+EXPORT struct S_IFI f17_S_SFD_IFI(struct S_IFI p0, float p1, double p2) { return p0; }
+EXPORT struct S_IFF f17_S_SFD_IFF(struct S_IFF p0, float p1, double p2) { return p0; }
+EXPORT struct S_IFD f17_S_SFD_IFD(struct S_IFD p0, float p1, double p2) { return p0; }
+EXPORT struct S_IFP f17_S_SFD_IFP(struct S_IFP p0, float p1, double p2) { return p0; }
+EXPORT struct S_IDI f17_S_SFD_IDI(struct S_IDI p0, float p1, double p2) { return p0; }
+EXPORT struct S_IDF f17_S_SFD_IDF(struct S_IDF p0, float p1, double p2) { return p0; }
+EXPORT struct S_IDD f17_S_SFD_IDD(struct S_IDD p0, float p1, double p2) { return p0; }
+EXPORT struct S_IDP f17_S_SFD_IDP(struct S_IDP p0, float p1, double p2) { return p0; }
+EXPORT struct S_IPI f17_S_SFD_IPI(struct S_IPI p0, float p1, double p2) { return p0; }
+EXPORT struct S_IPF f17_S_SFD_IPF(struct S_IPF p0, float p1, double p2) { return p0; }
+EXPORT struct S_IPD f17_S_SFD_IPD(struct S_IPD p0, float p1, double p2) { return p0; }
+EXPORT struct S_IPP f17_S_SFD_IPP(struct S_IPP p0, float p1, double p2) { return p0; }
+EXPORT struct S_FII f17_S_SFD_FII(struct S_FII p0, float p1, double p2) { return p0; }
+EXPORT struct S_FIF f17_S_SFD_FIF(struct S_FIF p0, float p1, double p2) { return p0; }
+EXPORT struct S_FID f17_S_SFD_FID(struct S_FID p0, float p1, double p2) { return p0; }
+EXPORT struct S_FIP f17_S_SFD_FIP(struct S_FIP p0, float p1, double p2) { return p0; }
+EXPORT struct S_FFI f17_S_SFD_FFI(struct S_FFI p0, float p1, double p2) { return p0; }
+EXPORT struct S_FFF f17_S_SFD_FFF(struct S_FFF p0, float p1, double p2) { return p0; }
+EXPORT struct S_FFD f17_S_SFD_FFD(struct S_FFD p0, float p1, double p2) { return p0; }
+EXPORT struct S_FFP f17_S_SFD_FFP(struct S_FFP p0, float p1, double p2) { return p0; }
+EXPORT struct S_FDI f17_S_SFD_FDI(struct S_FDI p0, float p1, double p2) { return p0; }
+EXPORT struct S_FDF f17_S_SFD_FDF(struct S_FDF p0, float p1, double p2) { return p0; }
+EXPORT struct S_FDD f17_S_SFD_FDD(struct S_FDD p0, float p1, double p2) { return p0; }
+EXPORT struct S_FDP f17_S_SFD_FDP(struct S_FDP p0, float p1, double p2) { return p0; }
+EXPORT struct S_FPI f17_S_SFD_FPI(struct S_FPI p0, float p1, double p2) { return p0; }
+EXPORT struct S_FPF f17_S_SFD_FPF(struct S_FPF p0, float p1, double p2) { return p0; }
+EXPORT struct S_FPD f17_S_SFD_FPD(struct S_FPD p0, float p1, double p2) { return p0; }
+EXPORT struct S_FPP f17_S_SFD_FPP(struct S_FPP p0, float p1, double p2) { return p0; }
+EXPORT struct S_DII f17_S_SFD_DII(struct S_DII p0, float p1, double p2) { return p0; }
+EXPORT struct S_DIF f17_S_SFD_DIF(struct S_DIF p0, float p1, double p2) { return p0; }
+EXPORT struct S_DID f17_S_SFD_DID(struct S_DID p0, float p1, double p2) { return p0; }
+EXPORT struct S_DIP f17_S_SFD_DIP(struct S_DIP p0, float p1, double p2) { return p0; }
+EXPORT struct S_DFI f17_S_SFD_DFI(struct S_DFI p0, float p1, double p2) { return p0; }
+EXPORT struct S_DFF f17_S_SFD_DFF(struct S_DFF p0, float p1, double p2) { return p0; }
+EXPORT struct S_DFD f17_S_SFD_DFD(struct S_DFD p0, float p1, double p2) { return p0; }
+EXPORT struct S_DFP f17_S_SFD_DFP(struct S_DFP p0, float p1, double p2) { return p0; }
+EXPORT struct S_DDI f17_S_SFD_DDI(struct S_DDI p0, float p1, double p2) { return p0; }
+EXPORT struct S_DDF f17_S_SFD_DDF(struct S_DDF p0, float p1, double p2) { return p0; }
+EXPORT struct S_DDD f17_S_SFD_DDD(struct S_DDD p0, float p1, double p2) { return p0; }
+EXPORT struct S_DDP f17_S_SFD_DDP(struct S_DDP p0, float p1, double p2) { return p0; }
+EXPORT struct S_DPI f17_S_SFD_DPI(struct S_DPI p0, float p1, double p2) { return p0; }
+EXPORT struct S_DPF f17_S_SFD_DPF(struct S_DPF p0, float p1, double p2) { return p0; }
+EXPORT struct S_DPD f17_S_SFD_DPD(struct S_DPD p0, float p1, double p2) { return p0; }
+EXPORT struct S_DPP f17_S_SFD_DPP(struct S_DPP p0, float p1, double p2) { return p0; }
+EXPORT struct S_PII f17_S_SFD_PII(struct S_PII p0, float p1, double p2) { return p0; }
+EXPORT struct S_PIF f17_S_SFD_PIF(struct S_PIF p0, float p1, double p2) { return p0; }
+EXPORT struct S_PID f17_S_SFD_PID(struct S_PID p0, float p1, double p2) { return p0; }
+EXPORT struct S_PIP f17_S_SFD_PIP(struct S_PIP p0, float p1, double p2) { return p0; }
+EXPORT struct S_PFI f17_S_SFD_PFI(struct S_PFI p0, float p1, double p2) { return p0; }
+EXPORT struct S_PFF f17_S_SFD_PFF(struct S_PFF p0, float p1, double p2) { return p0; }
+EXPORT struct S_PFD f17_S_SFD_PFD(struct S_PFD p0, float p1, double p2) { return p0; }
+EXPORT struct S_PFP f17_S_SFD_PFP(struct S_PFP p0, float p1, double p2) { return p0; }
+EXPORT struct S_PDI f17_S_SFD_PDI(struct S_PDI p0, float p1, double p2) { return p0; }
+EXPORT struct S_PDF f17_S_SFD_PDF(struct S_PDF p0, float p1, double p2) { return p0; }
+EXPORT struct S_PDD f17_S_SFD_PDD(struct S_PDD p0, float p1, double p2) { return p0; }
+EXPORT struct S_PDP f17_S_SFD_PDP(struct S_PDP p0, float p1, double p2) { return p0; }
+EXPORT struct S_PPI f17_S_SFD_PPI(struct S_PPI p0, float p1, double p2) { return p0; }
+EXPORT struct S_PPF f17_S_SFD_PPF(struct S_PPF p0, float p1, double p2) { return p0; }
+EXPORT struct S_PPD f17_S_SFD_PPD(struct S_PPD p0, float p1, double p2) { return p0; }
+EXPORT struct S_PPP f17_S_SFD_PPP(struct S_PPP p0, float p1, double p2) { return p0; }
+EXPORT struct S_I f17_S_SFP_I(struct S_I p0, float p1, void* p2) { return p0; }
+EXPORT struct S_F f17_S_SFP_F(struct S_F p0, float p1, void* p2) { return p0; }
+EXPORT struct S_D f17_S_SFP_D(struct S_D p0, float p1, void* p2) { return p0; }
+EXPORT struct S_P f17_S_SFP_P(struct S_P p0, float p1, void* p2) { return p0; }
+EXPORT struct S_II f17_S_SFP_II(struct S_II p0, float p1, void* p2) { return p0; }
+EXPORT struct S_IF f17_S_SFP_IF(struct S_IF p0, float p1, void* p2) { return p0; }
+EXPORT struct S_ID f17_S_SFP_ID(struct S_ID p0, float p1, void* p2) { return p0; }
+EXPORT struct S_IP f17_S_SFP_IP(struct S_IP p0, float p1, void* p2) { return p0; }
+EXPORT struct S_FI f17_S_SFP_FI(struct S_FI p0, float p1, void* p2) { return p0; }
+EXPORT struct S_FF f17_S_SFP_FF(struct S_FF p0, float p1, void* p2) { return p0; }
+EXPORT struct S_FD f17_S_SFP_FD(struct S_FD p0, float p1, void* p2) { return p0; }
+EXPORT struct S_FP f17_S_SFP_FP(struct S_FP p0, float p1, void* p2) { return p0; }
+EXPORT struct S_DI f17_S_SFP_DI(struct S_DI p0, float p1, void* p2) { return p0; }
+EXPORT struct S_DF f17_S_SFP_DF(struct S_DF p0, float p1, void* p2) { return p0; }
+EXPORT struct S_DD f17_S_SFP_DD(struct S_DD p0, float p1, void* p2) { return p0; }
+EXPORT struct S_DP f17_S_SFP_DP(struct S_DP p0, float p1, void* p2) { return p0; }
+EXPORT struct S_PI f17_S_SFP_PI(struct S_PI p0, float p1, void* p2) { return p0; }
+EXPORT struct S_PF f17_S_SFP_PF(struct S_PF p0, float p1, void* p2) { return p0; }
+EXPORT struct S_PD f17_S_SFP_PD(struct S_PD p0, float p1, void* p2) { return p0; }
+EXPORT struct S_PP f17_S_SFP_PP(struct S_PP p0, float p1, void* p2) { return p0; }
+EXPORT struct S_III f17_S_SFP_III(struct S_III p0, float p1, void* p2) { return p0; }
+EXPORT struct S_IIF f17_S_SFP_IIF(struct S_IIF p0, float p1, void* p2) { return p0; }
+EXPORT struct S_IID f17_S_SFP_IID(struct S_IID p0, float p1, void* p2) { return p0; }
+EXPORT struct S_IIP f17_S_SFP_IIP(struct S_IIP p0, float p1, void* p2) { return p0; }
+EXPORT struct S_IFI f17_S_SFP_IFI(struct S_IFI p0, float p1, void* p2) { return p0; }
+EXPORT struct S_IFF f17_S_SFP_IFF(struct S_IFF p0, float p1, void* p2) { return p0; }
+EXPORT struct S_IFD f17_S_SFP_IFD(struct S_IFD p0, float p1, void* p2) { return p0; }
+EXPORT struct S_IFP f17_S_SFP_IFP(struct S_IFP p0, float p1, void* p2) { return p0; }
+EXPORT struct S_IDI f17_S_SFP_IDI(struct S_IDI p0, float p1, void* p2) { return p0; }
+EXPORT struct S_IDF f17_S_SFP_IDF(struct S_IDF p0, float p1, void* p2) { return p0; }
+EXPORT struct S_IDD f17_S_SFP_IDD(struct S_IDD p0, float p1, void* p2) { return p0; }
+EXPORT struct S_IDP f17_S_SFP_IDP(struct S_IDP p0, float p1, void* p2) { return p0; }
+EXPORT struct S_IPI f17_S_SFP_IPI(struct S_IPI p0, float p1, void* p2) { return p0; }
+EXPORT struct S_IPF f17_S_SFP_IPF(struct S_IPF p0, float p1, void* p2) { return p0; }
+EXPORT struct S_IPD f17_S_SFP_IPD(struct S_IPD p0, float p1, void* p2) { return p0; }
+EXPORT struct S_IPP f17_S_SFP_IPP(struct S_IPP p0, float p1, void* p2) { return p0; }
+EXPORT struct S_FII f17_S_SFP_FII(struct S_FII p0, float p1, void* p2) { return p0; }
+EXPORT struct S_FIF f17_S_SFP_FIF(struct S_FIF p0, float p1, void* p2) { return p0; }
+EXPORT struct S_FID f17_S_SFP_FID(struct S_FID p0, float p1, void* p2) { return p0; }
+EXPORT struct S_FIP f17_S_SFP_FIP(struct S_FIP p0, float p1, void* p2) { return p0; }
+EXPORT struct S_FFI f17_S_SFP_FFI(struct S_FFI p0, float p1, void* p2) { return p0; }
+EXPORT struct S_FFF f17_S_SFP_FFF(struct S_FFF p0, float p1, void* p2) { return p0; }
+EXPORT struct S_FFD f17_S_SFP_FFD(struct S_FFD p0, float p1, void* p2) { return p0; }
+EXPORT struct S_FFP f17_S_SFP_FFP(struct S_FFP p0, float p1, void* p2) { return p0; }
+EXPORT struct S_FDI f17_S_SFP_FDI(struct S_FDI p0, float p1, void* p2) { return p0; }
+EXPORT struct S_FDF f17_S_SFP_FDF(struct S_FDF p0, float p1, void* p2) { return p0; }
+EXPORT struct S_FDD f17_S_SFP_FDD(struct S_FDD p0, float p1, void* p2) { return p0; }
+EXPORT struct S_FDP f17_S_SFP_FDP(struct S_FDP p0, float p1, void* p2) { return p0; }
+EXPORT struct S_FPI f17_S_SFP_FPI(struct S_FPI p0, float p1, void* p2) { return p0; }
+EXPORT struct S_FPF f17_S_SFP_FPF(struct S_FPF p0, float p1, void* p2) { return p0; }
+EXPORT struct S_FPD f17_S_SFP_FPD(struct S_FPD p0, float p1, void* p2) { return p0; }
+EXPORT struct S_FPP f17_S_SFP_FPP(struct S_FPP p0, float p1, void* p2) { return p0; }
+EXPORT struct S_DII f17_S_SFP_DII(struct S_DII p0, float p1, void* p2) { return p0; }
+EXPORT struct S_DIF f17_S_SFP_DIF(struct S_DIF p0, float p1, void* p2) { return p0; }
+EXPORT struct S_DID f17_S_SFP_DID(struct S_DID p0, float p1, void* p2) { return p0; }
+EXPORT struct S_DIP f17_S_SFP_DIP(struct S_DIP p0, float p1, void* p2) { return p0; }
+EXPORT struct S_DFI f17_S_SFP_DFI(struct S_DFI p0, float p1, void* p2) { return p0; }
+EXPORT struct S_DFF f17_S_SFP_DFF(struct S_DFF p0, float p1, void* p2) { return p0; }
+EXPORT struct S_DFD f17_S_SFP_DFD(struct S_DFD p0, float p1, void* p2) { return p0; }
+EXPORT struct S_DFP f17_S_SFP_DFP(struct S_DFP p0, float p1, void* p2) { return p0; }
+EXPORT struct S_DDI f17_S_SFP_DDI(struct S_DDI p0, float p1, void* p2) { return p0; }
+EXPORT struct S_DDF f17_S_SFP_DDF(struct S_DDF p0, float p1, void* p2) { return p0; }
+EXPORT struct S_DDD f17_S_SFP_DDD(struct S_DDD p0, float p1, void* p2) { return p0; }
+EXPORT struct S_DDP f17_S_SFP_DDP(struct S_DDP p0, float p1, void* p2) { return p0; }
+EXPORT struct S_DPI f17_S_SFP_DPI(struct S_DPI p0, float p1, void* p2) { return p0; }
+EXPORT struct S_DPF f17_S_SFP_DPF(struct S_DPF p0, float p1, void* p2) { return p0; }
+EXPORT struct S_DPD f17_S_SFP_DPD(struct S_DPD p0, float p1, void* p2) { return p0; }
+EXPORT struct S_DPP f17_S_SFP_DPP(struct S_DPP p0, float p1, void* p2) { return p0; }
+EXPORT struct S_PII f17_S_SFP_PII(struct S_PII p0, float p1, void* p2) { return p0; }
+EXPORT struct S_PIF f17_S_SFP_PIF(struct S_PIF p0, float p1, void* p2) { return p0; }
+EXPORT struct S_PID f17_S_SFP_PID(struct S_PID p0, float p1, void* p2) { return p0; }
+EXPORT struct S_PIP f17_S_SFP_PIP(struct S_PIP p0, float p1, void* p2) { return p0; }
+EXPORT struct S_PFI f17_S_SFP_PFI(struct S_PFI p0, float p1, void* p2) { return p0; }
+EXPORT struct S_PFF f17_S_SFP_PFF(struct S_PFF p0, float p1, void* p2) { return p0; }
+EXPORT struct S_PFD f17_S_SFP_PFD(struct S_PFD p0, float p1, void* p2) { return p0; }
+EXPORT struct S_PFP f17_S_SFP_PFP(struct S_PFP p0, float p1, void* p2) { return p0; }
+EXPORT struct S_PDI f17_S_SFP_PDI(struct S_PDI p0, float p1, void* p2) { return p0; }
+EXPORT struct S_PDF f17_S_SFP_PDF(struct S_PDF p0, float p1, void* p2) { return p0; }
+EXPORT struct S_PDD f17_S_SFP_PDD(struct S_PDD p0, float p1, void* p2) { return p0; }
+EXPORT struct S_PDP f17_S_SFP_PDP(struct S_PDP p0, float p1, void* p2) { return p0; }
+EXPORT struct S_PPI f17_S_SFP_PPI(struct S_PPI p0, float p1, void* p2) { return p0; }
+EXPORT struct S_PPF f17_S_SFP_PPF(struct S_PPF p0, float p1, void* p2) { return p0; }
+EXPORT struct S_PPD f17_S_SFP_PPD(struct S_PPD p0, float p1, void* p2) { return p0; }
+EXPORT struct S_PPP f17_S_SFP_PPP(struct S_PPP p0, float p1, void* p2) { return p0; }
+EXPORT struct S_I f17_S_SFS_I(struct S_I p0, float p1, struct S_I p2) { return p0; }
+EXPORT struct S_F f17_S_SFS_F(struct S_F p0, float p1, struct S_F p2) { return p0; }
+EXPORT struct S_D f17_S_SFS_D(struct S_D p0, float p1, struct S_D p2) { return p0; }
+EXPORT struct S_P f17_S_SFS_P(struct S_P p0, float p1, struct S_P p2) { return p0; }
+EXPORT struct S_II f17_S_SFS_II(struct S_II p0, float p1, struct S_II p2) { return p0; }
+EXPORT struct S_IF f17_S_SFS_IF(struct S_IF p0, float p1, struct S_IF p2) { return p0; }
+EXPORT struct S_ID f17_S_SFS_ID(struct S_ID p0, float p1, struct S_ID p2) { return p0; }
+EXPORT struct S_IP f17_S_SFS_IP(struct S_IP p0, float p1, struct S_IP p2) { return p0; }
+EXPORT struct S_FI f17_S_SFS_FI(struct S_FI p0, float p1, struct S_FI p2) { return p0; }
+EXPORT struct S_FF f17_S_SFS_FF(struct S_FF p0, float p1, struct S_FF p2) { return p0; }
+EXPORT struct S_FD f17_S_SFS_FD(struct S_FD p0, float p1, struct S_FD p2) { return p0; }
+EXPORT struct S_FP f17_S_SFS_FP(struct S_FP p0, float p1, struct S_FP p2) { return p0; }
+EXPORT struct S_DI f17_S_SFS_DI(struct S_DI p0, float p1, struct S_DI p2) { return p0; }
+EXPORT struct S_DF f17_S_SFS_DF(struct S_DF p0, float p1, struct S_DF p2) { return p0; }
+EXPORT struct S_DD f17_S_SFS_DD(struct S_DD p0, float p1, struct S_DD p2) { return p0; }
+EXPORT struct S_DP f17_S_SFS_DP(struct S_DP p0, float p1, struct S_DP p2) { return p0; }
+EXPORT struct S_PI f17_S_SFS_PI(struct S_PI p0, float p1, struct S_PI p2) { return p0; }
+EXPORT struct S_PF f17_S_SFS_PF(struct S_PF p0, float p1, struct S_PF p2) { return p0; }
+EXPORT struct S_PD f17_S_SFS_PD(struct S_PD p0, float p1, struct S_PD p2) { return p0; }
+EXPORT struct S_PP f17_S_SFS_PP(struct S_PP p0, float p1, struct S_PP p2) { return p0; }
+EXPORT struct S_III f17_S_SFS_III(struct S_III p0, float p1, struct S_III p2) { return p0; }
+EXPORT struct S_IIF f17_S_SFS_IIF(struct S_IIF p0, float p1, struct S_IIF p2) { return p0; }
+EXPORT struct S_IID f17_S_SFS_IID(struct S_IID p0, float p1, struct S_IID p2) { return p0; }
+EXPORT struct S_IIP f17_S_SFS_IIP(struct S_IIP p0, float p1, struct S_IIP p2) { return p0; }
+EXPORT struct S_IFI f17_S_SFS_IFI(struct S_IFI p0, float p1, struct S_IFI p2) { return p0; }
+EXPORT struct S_IFF f17_S_SFS_IFF(struct S_IFF p0, float p1, struct S_IFF p2) { return p0; }
+EXPORT struct S_IFD f17_S_SFS_IFD(struct S_IFD p0, float p1, struct S_IFD p2) { return p0; }
+EXPORT struct S_IFP f17_S_SFS_IFP(struct S_IFP p0, float p1, struct S_IFP p2) { return p0; }
+EXPORT struct S_IDI f17_S_SFS_IDI(struct S_IDI p0, float p1, struct S_IDI p2) { return p0; }
+EXPORT struct S_IDF f17_S_SFS_IDF(struct S_IDF p0, float p1, struct S_IDF p2) { return p0; }
+EXPORT struct S_IDD f17_S_SFS_IDD(struct S_IDD p0, float p1, struct S_IDD p2) { return p0; }
+EXPORT struct S_IDP f17_S_SFS_IDP(struct S_IDP p0, float p1, struct S_IDP p2) { return p0; }
+EXPORT struct S_IPI f17_S_SFS_IPI(struct S_IPI p0, float p1, struct S_IPI p2) { return p0; }
+EXPORT struct S_IPF f17_S_SFS_IPF(struct S_IPF p0, float p1, struct S_IPF p2) { return p0; }
+EXPORT struct S_IPD f17_S_SFS_IPD(struct S_IPD p0, float p1, struct S_IPD p2) { return p0; }
+EXPORT struct S_IPP f17_S_SFS_IPP(struct S_IPP p0, float p1, struct S_IPP p2) { return p0; }
+EXPORT struct S_FII f17_S_SFS_FII(struct S_FII p0, float p1, struct S_FII p2) { return p0; }
+EXPORT struct S_FIF f17_S_SFS_FIF(struct S_FIF p0, float p1, struct S_FIF p2) { return p0; }
+EXPORT struct S_FID f17_S_SFS_FID(struct S_FID p0, float p1, struct S_FID p2) { return p0; }
+EXPORT struct S_FIP f17_S_SFS_FIP(struct S_FIP p0, float p1, struct S_FIP p2) { return p0; }
+EXPORT struct S_FFI f17_S_SFS_FFI(struct S_FFI p0, float p1, struct S_FFI p2) { return p0; }
+EXPORT struct S_FFF f17_S_SFS_FFF(struct S_FFF p0, float p1, struct S_FFF p2) { return p0; }
+EXPORT struct S_FFD f17_S_SFS_FFD(struct S_FFD p0, float p1, struct S_FFD p2) { return p0; }
+EXPORT struct S_FFP f17_S_SFS_FFP(struct S_FFP p0, float p1, struct S_FFP p2) { return p0; }
+EXPORT struct S_FDI f17_S_SFS_FDI(struct S_FDI p0, float p1, struct S_FDI p2) { return p0; }
+EXPORT struct S_FDF f17_S_SFS_FDF(struct S_FDF p0, float p1, struct S_FDF p2) { return p0; }
+EXPORT struct S_FDD f17_S_SFS_FDD(struct S_FDD p0, float p1, struct S_FDD p2) { return p0; }
+EXPORT struct S_FDP f18_S_SFS_FDP(struct S_FDP p0, float p1, struct S_FDP p2) { return p0; }
+EXPORT struct S_FPI f18_S_SFS_FPI(struct S_FPI p0, float p1, struct S_FPI p2) { return p0; }
+EXPORT struct S_FPF f18_S_SFS_FPF(struct S_FPF p0, float p1, struct S_FPF p2) { return p0; }
+EXPORT struct S_FPD f18_S_SFS_FPD(struct S_FPD p0, float p1, struct S_FPD p2) { return p0; }
+EXPORT struct S_FPP f18_S_SFS_FPP(struct S_FPP p0, float p1, struct S_FPP p2) { return p0; }
+EXPORT struct S_DII f18_S_SFS_DII(struct S_DII p0, float p1, struct S_DII p2) { return p0; }
+EXPORT struct S_DIF f18_S_SFS_DIF(struct S_DIF p0, float p1, struct S_DIF p2) { return p0; }
+EXPORT struct S_DID f18_S_SFS_DID(struct S_DID p0, float p1, struct S_DID p2) { return p0; }
+EXPORT struct S_DIP f18_S_SFS_DIP(struct S_DIP p0, float p1, struct S_DIP p2) { return p0; }
+EXPORT struct S_DFI f18_S_SFS_DFI(struct S_DFI p0, float p1, struct S_DFI p2) { return p0; }
+EXPORT struct S_DFF f18_S_SFS_DFF(struct S_DFF p0, float p1, struct S_DFF p2) { return p0; }
+EXPORT struct S_DFD f18_S_SFS_DFD(struct S_DFD p0, float p1, struct S_DFD p2) { return p0; }
+EXPORT struct S_DFP f18_S_SFS_DFP(struct S_DFP p0, float p1, struct S_DFP p2) { return p0; }
+EXPORT struct S_DDI f18_S_SFS_DDI(struct S_DDI p0, float p1, struct S_DDI p2) { return p0; }
+EXPORT struct S_DDF f18_S_SFS_DDF(struct S_DDF p0, float p1, struct S_DDF p2) { return p0; }
+EXPORT struct S_DDD f18_S_SFS_DDD(struct S_DDD p0, float p1, struct S_DDD p2) { return p0; }
+EXPORT struct S_DDP f18_S_SFS_DDP(struct S_DDP p0, float p1, struct S_DDP p2) { return p0; }
+EXPORT struct S_DPI f18_S_SFS_DPI(struct S_DPI p0, float p1, struct S_DPI p2) { return p0; }
+EXPORT struct S_DPF f18_S_SFS_DPF(struct S_DPF p0, float p1, struct S_DPF p2) { return p0; }
+EXPORT struct S_DPD f18_S_SFS_DPD(struct S_DPD p0, float p1, struct S_DPD p2) { return p0; }
+EXPORT struct S_DPP f18_S_SFS_DPP(struct S_DPP p0, float p1, struct S_DPP p2) { return p0; }
+EXPORT struct S_PII f18_S_SFS_PII(struct S_PII p0, float p1, struct S_PII p2) { return p0; }
+EXPORT struct S_PIF f18_S_SFS_PIF(struct S_PIF p0, float p1, struct S_PIF p2) { return p0; }
+EXPORT struct S_PID f18_S_SFS_PID(struct S_PID p0, float p1, struct S_PID p2) { return p0; }
+EXPORT struct S_PIP f18_S_SFS_PIP(struct S_PIP p0, float p1, struct S_PIP p2) { return p0; }
+EXPORT struct S_PFI f18_S_SFS_PFI(struct S_PFI p0, float p1, struct S_PFI p2) { return p0; }
+EXPORT struct S_PFF f18_S_SFS_PFF(struct S_PFF p0, float p1, struct S_PFF p2) { return p0; }
+EXPORT struct S_PFD f18_S_SFS_PFD(struct S_PFD p0, float p1, struct S_PFD p2) { return p0; }
+EXPORT struct S_PFP f18_S_SFS_PFP(struct S_PFP p0, float p1, struct S_PFP p2) { return p0; }
+EXPORT struct S_PDI f18_S_SFS_PDI(struct S_PDI p0, float p1, struct S_PDI p2) { return p0; }
+EXPORT struct S_PDF f18_S_SFS_PDF(struct S_PDF p0, float p1, struct S_PDF p2) { return p0; }
+EXPORT struct S_PDD f18_S_SFS_PDD(struct S_PDD p0, float p1, struct S_PDD p2) { return p0; }
+EXPORT struct S_PDP f18_S_SFS_PDP(struct S_PDP p0, float p1, struct S_PDP p2) { return p0; }
+EXPORT struct S_PPI f18_S_SFS_PPI(struct S_PPI p0, float p1, struct S_PPI p2) { return p0; }
+EXPORT struct S_PPF f18_S_SFS_PPF(struct S_PPF p0, float p1, struct S_PPF p2) { return p0; }
+EXPORT struct S_PPD f18_S_SFS_PPD(struct S_PPD p0, float p1, struct S_PPD p2) { return p0; }
+EXPORT struct S_PPP f18_S_SFS_PPP(struct S_PPP p0, float p1, struct S_PPP p2) { return p0; }
+EXPORT struct S_I f18_S_SDI_I(struct S_I p0, double p1, int p2) { return p0; }
+EXPORT struct S_F f18_S_SDI_F(struct S_F p0, double p1, int p2) { return p0; }
+EXPORT struct S_D f18_S_SDI_D(struct S_D p0, double p1, int p2) { return p0; }
+EXPORT struct S_P f18_S_SDI_P(struct S_P p0, double p1, int p2) { return p0; }
+EXPORT struct S_II f18_S_SDI_II(struct S_II p0, double p1, int p2) { return p0; }
+EXPORT struct S_IF f18_S_SDI_IF(struct S_IF p0, double p1, int p2) { return p0; }
+EXPORT struct S_ID f18_S_SDI_ID(struct S_ID p0, double p1, int p2) { return p0; }
+EXPORT struct S_IP f18_S_SDI_IP(struct S_IP p0, double p1, int p2) { return p0; }
+EXPORT struct S_FI f18_S_SDI_FI(struct S_FI p0, double p1, int p2) { return p0; }
+EXPORT struct S_FF f18_S_SDI_FF(struct S_FF p0, double p1, int p2) { return p0; }
+EXPORT struct S_FD f18_S_SDI_FD(struct S_FD p0, double p1, int p2) { return p0; }
+EXPORT struct S_FP f18_S_SDI_FP(struct S_FP p0, double p1, int p2) { return p0; }
+EXPORT struct S_DI f18_S_SDI_DI(struct S_DI p0, double p1, int p2) { return p0; }
+EXPORT struct S_DF f18_S_SDI_DF(struct S_DF p0, double p1, int p2) { return p0; }
+EXPORT struct S_DD f18_S_SDI_DD(struct S_DD p0, double p1, int p2) { return p0; }
+EXPORT struct S_DP f18_S_SDI_DP(struct S_DP p0, double p1, int p2) { return p0; }
+EXPORT struct S_PI f18_S_SDI_PI(struct S_PI p0, double p1, int p2) { return p0; }
+EXPORT struct S_PF f18_S_SDI_PF(struct S_PF p0, double p1, int p2) { return p0; }
+EXPORT struct S_PD f18_S_SDI_PD(struct S_PD p0, double p1, int p2) { return p0; }
+EXPORT struct S_PP f18_S_SDI_PP(struct S_PP p0, double p1, int p2) { return p0; }
+EXPORT struct S_III f18_S_SDI_III(struct S_III p0, double p1, int p2) { return p0; }
+EXPORT struct S_IIF f18_S_SDI_IIF(struct S_IIF p0, double p1, int p2) { return p0; }
+EXPORT struct S_IID f18_S_SDI_IID(struct S_IID p0, double p1, int p2) { return p0; }
+EXPORT struct S_IIP f18_S_SDI_IIP(struct S_IIP p0, double p1, int p2) { return p0; }
+EXPORT struct S_IFI f18_S_SDI_IFI(struct S_IFI p0, double p1, int p2) { return p0; }
+EXPORT struct S_IFF f18_S_SDI_IFF(struct S_IFF p0, double p1, int p2) { return p0; }
+EXPORT struct S_IFD f18_S_SDI_IFD(struct S_IFD p0, double p1, int p2) { return p0; }
+EXPORT struct S_IFP f18_S_SDI_IFP(struct S_IFP p0, double p1, int p2) { return p0; }
+EXPORT struct S_IDI f18_S_SDI_IDI(struct S_IDI p0, double p1, int p2) { return p0; }
+EXPORT struct S_IDF f18_S_SDI_IDF(struct S_IDF p0, double p1, int p2) { return p0; }
+EXPORT struct S_IDD f18_S_SDI_IDD(struct S_IDD p0, double p1, int p2) { return p0; }
+EXPORT struct S_IDP f18_S_SDI_IDP(struct S_IDP p0, double p1, int p2) { return p0; }
+EXPORT struct S_IPI f18_S_SDI_IPI(struct S_IPI p0, double p1, int p2) { return p0; }
+EXPORT struct S_IPF f18_S_SDI_IPF(struct S_IPF p0, double p1, int p2) { return p0; }
+EXPORT struct S_IPD f18_S_SDI_IPD(struct S_IPD p0, double p1, int p2) { return p0; }
+EXPORT struct S_IPP f18_S_SDI_IPP(struct S_IPP p0, double p1, int p2) { return p0; }
+EXPORT struct S_FII f18_S_SDI_FII(struct S_FII p0, double p1, int p2) { return p0; }
+EXPORT struct S_FIF f18_S_SDI_FIF(struct S_FIF p0, double p1, int p2) { return p0; }
+EXPORT struct S_FID f18_S_SDI_FID(struct S_FID p0, double p1, int p2) { return p0; }
+EXPORT struct S_FIP f18_S_SDI_FIP(struct S_FIP p0, double p1, int p2) { return p0; }
+EXPORT struct S_FFI f18_S_SDI_FFI(struct S_FFI p0, double p1, int p2) { return p0; }
+EXPORT struct S_FFF f18_S_SDI_FFF(struct S_FFF p0, double p1, int p2) { return p0; }
+EXPORT struct S_FFD f18_S_SDI_FFD(struct S_FFD p0, double p1, int p2) { return p0; }
+EXPORT struct S_FFP f18_S_SDI_FFP(struct S_FFP p0, double p1, int p2) { return p0; }
+EXPORT struct S_FDI f18_S_SDI_FDI(struct S_FDI p0, double p1, int p2) { return p0; }
+EXPORT struct S_FDF f18_S_SDI_FDF(struct S_FDF p0, double p1, int p2) { return p0; }
+EXPORT struct S_FDD f18_S_SDI_FDD(struct S_FDD p0, double p1, int p2) { return p0; }
+EXPORT struct S_FDP f18_S_SDI_FDP(struct S_FDP p0, double p1, int p2) { return p0; }
+EXPORT struct S_FPI f18_S_SDI_FPI(struct S_FPI p0, double p1, int p2) { return p0; }
+EXPORT struct S_FPF f18_S_SDI_FPF(struct S_FPF p0, double p1, int p2) { return p0; }
+EXPORT struct S_FPD f18_S_SDI_FPD(struct S_FPD p0, double p1, int p2) { return p0; }
+EXPORT struct S_FPP f18_S_SDI_FPP(struct S_FPP p0, double p1, int p2) { return p0; }
+EXPORT struct S_DII f18_S_SDI_DII(struct S_DII p0, double p1, int p2) { return p0; }
+EXPORT struct S_DIF f18_S_SDI_DIF(struct S_DIF p0, double p1, int p2) { return p0; }
+EXPORT struct S_DID f18_S_SDI_DID(struct S_DID p0, double p1, int p2) { return p0; }
+EXPORT struct S_DIP f18_S_SDI_DIP(struct S_DIP p0, double p1, int p2) { return p0; }
+EXPORT struct S_DFI f18_S_SDI_DFI(struct S_DFI p0, double p1, int p2) { return p0; }
+EXPORT struct S_DFF f18_S_SDI_DFF(struct S_DFF p0, double p1, int p2) { return p0; }
+EXPORT struct S_DFD f18_S_SDI_DFD(struct S_DFD p0, double p1, int p2) { return p0; }
+EXPORT struct S_DFP f18_S_SDI_DFP(struct S_DFP p0, double p1, int p2) { return p0; }
+EXPORT struct S_DDI f18_S_SDI_DDI(struct S_DDI p0, double p1, int p2) { return p0; }
+EXPORT struct S_DDF f18_S_SDI_DDF(struct S_DDF p0, double p1, int p2) { return p0; }
+EXPORT struct S_DDD f18_S_SDI_DDD(struct S_DDD p0, double p1, int p2) { return p0; }
+EXPORT struct S_DDP f18_S_SDI_DDP(struct S_DDP p0, double p1, int p2) { return p0; }
+EXPORT struct S_DPI f18_S_SDI_DPI(struct S_DPI p0, double p1, int p2) { return p0; }
+EXPORT struct S_DPF f18_S_SDI_DPF(struct S_DPF p0, double p1, int p2) { return p0; }
+EXPORT struct S_DPD f18_S_SDI_DPD(struct S_DPD p0, double p1, int p2) { return p0; }
+EXPORT struct S_DPP f18_S_SDI_DPP(struct S_DPP p0, double p1, int p2) { return p0; }
+EXPORT struct S_PII f18_S_SDI_PII(struct S_PII p0, double p1, int p2) { return p0; }
+EXPORT struct S_PIF f18_S_SDI_PIF(struct S_PIF p0, double p1, int p2) { return p0; }
+EXPORT struct S_PID f18_S_SDI_PID(struct S_PID p0, double p1, int p2) { return p0; }
+EXPORT struct S_PIP f18_S_SDI_PIP(struct S_PIP p0, double p1, int p2) { return p0; }
+EXPORT struct S_PFI f18_S_SDI_PFI(struct S_PFI p0, double p1, int p2) { return p0; }
+EXPORT struct S_PFF f18_S_SDI_PFF(struct S_PFF p0, double p1, int p2) { return p0; }
+EXPORT struct S_PFD f18_S_SDI_PFD(struct S_PFD p0, double p1, int p2) { return p0; }
+EXPORT struct S_PFP f18_S_SDI_PFP(struct S_PFP p0, double p1, int p2) { return p0; }
+EXPORT struct S_PDI f18_S_SDI_PDI(struct S_PDI p0, double p1, int p2) { return p0; }
+EXPORT struct S_PDF f18_S_SDI_PDF(struct S_PDF p0, double p1, int p2) { return p0; }
+EXPORT struct S_PDD f18_S_SDI_PDD(struct S_PDD p0, double p1, int p2) { return p0; }
+EXPORT struct S_PDP f18_S_SDI_PDP(struct S_PDP p0, double p1, int p2) { return p0; }
+EXPORT struct S_PPI f18_S_SDI_PPI(struct S_PPI p0, double p1, int p2) { return p0; }
+EXPORT struct S_PPF f18_S_SDI_PPF(struct S_PPF p0, double p1, int p2) { return p0; }
+EXPORT struct S_PPD f18_S_SDI_PPD(struct S_PPD p0, double p1, int p2) { return p0; }
+EXPORT struct S_PPP f18_S_SDI_PPP(struct S_PPP p0, double p1, int p2) { return p0; }
+EXPORT struct S_I f18_S_SDF_I(struct S_I p0, double p1, float p2) { return p0; }
+EXPORT struct S_F f18_S_SDF_F(struct S_F p0, double p1, float p2) { return p0; }
+EXPORT struct S_D f18_S_SDF_D(struct S_D p0, double p1, float p2) { return p0; }
+EXPORT struct S_P f18_S_SDF_P(struct S_P p0, double p1, float p2) { return p0; }
+EXPORT struct S_II f18_S_SDF_II(struct S_II p0, double p1, float p2) { return p0; }
+EXPORT struct S_IF f18_S_SDF_IF(struct S_IF p0, double p1, float p2) { return p0; }
+EXPORT struct S_ID f18_S_SDF_ID(struct S_ID p0, double p1, float p2) { return p0; }
+EXPORT struct S_IP f18_S_SDF_IP(struct S_IP p0, double p1, float p2) { return p0; }
+EXPORT struct S_FI f18_S_SDF_FI(struct S_FI p0, double p1, float p2) { return p0; }
+EXPORT struct S_FF f18_S_SDF_FF(struct S_FF p0, double p1, float p2) { return p0; }
+EXPORT struct S_FD f18_S_SDF_FD(struct S_FD p0, double p1, float p2) { return p0; }
+EXPORT struct S_FP f18_S_SDF_FP(struct S_FP p0, double p1, float p2) { return p0; }
+EXPORT struct S_DI f18_S_SDF_DI(struct S_DI p0, double p1, float p2) { return p0; }
+EXPORT struct S_DF f18_S_SDF_DF(struct S_DF p0, double p1, float p2) { return p0; }
+EXPORT struct S_DD f18_S_SDF_DD(struct S_DD p0, double p1, float p2) { return p0; }
+EXPORT struct S_DP f18_S_SDF_DP(struct S_DP p0, double p1, float p2) { return p0; }
+EXPORT struct S_PI f18_S_SDF_PI(struct S_PI p0, double p1, float p2) { return p0; }
+EXPORT struct S_PF f18_S_SDF_PF(struct S_PF p0, double p1, float p2) { return p0; }
+EXPORT struct S_PD f18_S_SDF_PD(struct S_PD p0, double p1, float p2) { return p0; }
+EXPORT struct S_PP f18_S_SDF_PP(struct S_PP p0, double p1, float p2) { return p0; }
+EXPORT struct S_III f18_S_SDF_III(struct S_III p0, double p1, float p2) { return p0; }
+EXPORT struct S_IIF f18_S_SDF_IIF(struct S_IIF p0, double p1, float p2) { return p0; }
+EXPORT struct S_IID f18_S_SDF_IID(struct S_IID p0, double p1, float p2) { return p0; }
+EXPORT struct S_IIP f18_S_SDF_IIP(struct S_IIP p0, double p1, float p2) { return p0; }
+EXPORT struct S_IFI f18_S_SDF_IFI(struct S_IFI p0, double p1, float p2) { return p0; }
+EXPORT struct S_IFF f18_S_SDF_IFF(struct S_IFF p0, double p1, float p2) { return p0; }
+EXPORT struct S_IFD f18_S_SDF_IFD(struct S_IFD p0, double p1, float p2) { return p0; }
+EXPORT struct S_IFP f18_S_SDF_IFP(struct S_IFP p0, double p1, float p2) { return p0; }
+EXPORT struct S_IDI f18_S_SDF_IDI(struct S_IDI p0, double p1, float p2) { return p0; }
+EXPORT struct S_IDF f18_S_SDF_IDF(struct S_IDF p0, double p1, float p2) { return p0; }
+EXPORT struct S_IDD f18_S_SDF_IDD(struct S_IDD p0, double p1, float p2) { return p0; }
+EXPORT struct S_IDP f18_S_SDF_IDP(struct S_IDP p0, double p1, float p2) { return p0; }
+EXPORT struct S_IPI f18_S_SDF_IPI(struct S_IPI p0, double p1, float p2) { return p0; }
+EXPORT struct S_IPF f18_S_SDF_IPF(struct S_IPF p0, double p1, float p2) { return p0; }
+EXPORT struct S_IPD f18_S_SDF_IPD(struct S_IPD p0, double p1, float p2) { return p0; }
+EXPORT struct S_IPP f18_S_SDF_IPP(struct S_IPP p0, double p1, float p2) { return p0; }
+EXPORT struct S_FII f18_S_SDF_FII(struct S_FII p0, double p1, float p2) { return p0; }
+EXPORT struct S_FIF f18_S_SDF_FIF(struct S_FIF p0, double p1, float p2) { return p0; }
+EXPORT struct S_FID f18_S_SDF_FID(struct S_FID p0, double p1, float p2) { return p0; }
+EXPORT struct S_FIP f18_S_SDF_FIP(struct S_FIP p0, double p1, float p2) { return p0; }
+EXPORT struct S_FFI f18_S_SDF_FFI(struct S_FFI p0, double p1, float p2) { return p0; }
+EXPORT struct S_FFF f18_S_SDF_FFF(struct S_FFF p0, double p1, float p2) { return p0; }
+EXPORT struct S_FFD f18_S_SDF_FFD(struct S_FFD p0, double p1, float p2) { return p0; }
+EXPORT struct S_FFP f18_S_SDF_FFP(struct S_FFP p0, double p1, float p2) { return p0; }
+EXPORT struct S_FDI f18_S_SDF_FDI(struct S_FDI p0, double p1, float p2) { return p0; }
+EXPORT struct S_FDF f18_S_SDF_FDF(struct S_FDF p0, double p1, float p2) { return p0; }
+EXPORT struct S_FDD f18_S_SDF_FDD(struct S_FDD p0, double p1, float p2) { return p0; }
+EXPORT struct S_FDP f18_S_SDF_FDP(struct S_FDP p0, double p1, float p2) { return p0; }
+EXPORT struct S_FPI f18_S_SDF_FPI(struct S_FPI p0, double p1, float p2) { return p0; }
+EXPORT struct S_FPF f18_S_SDF_FPF(struct S_FPF p0, double p1, float p2) { return p0; }
+EXPORT struct S_FPD f18_S_SDF_FPD(struct S_FPD p0, double p1, float p2) { return p0; }
+EXPORT struct S_FPP f18_S_SDF_FPP(struct S_FPP p0, double p1, float p2) { return p0; }
+EXPORT struct S_DII f18_S_SDF_DII(struct S_DII p0, double p1, float p2) { return p0; }
+EXPORT struct S_DIF f18_S_SDF_DIF(struct S_DIF p0, double p1, float p2) { return p0; }
+EXPORT struct S_DID f18_S_SDF_DID(struct S_DID p0, double p1, float p2) { return p0; }
+EXPORT struct S_DIP f18_S_SDF_DIP(struct S_DIP p0, double p1, float p2) { return p0; }
+EXPORT struct S_DFI f18_S_SDF_DFI(struct S_DFI p0, double p1, float p2) { return p0; }
+EXPORT struct S_DFF f18_S_SDF_DFF(struct S_DFF p0, double p1, float p2) { return p0; }
+EXPORT struct S_DFD f18_S_SDF_DFD(struct S_DFD p0, double p1, float p2) { return p0; }
+EXPORT struct S_DFP f18_S_SDF_DFP(struct S_DFP p0, double p1, float p2) { return p0; }
+EXPORT struct S_DDI f18_S_SDF_DDI(struct S_DDI p0, double p1, float p2) { return p0; }
+EXPORT struct S_DDF f18_S_SDF_DDF(struct S_DDF p0, double p1, float p2) { return p0; }
+EXPORT struct S_DDD f18_S_SDF_DDD(struct S_DDD p0, double p1, float p2) { return p0; }
+EXPORT struct S_DDP f18_S_SDF_DDP(struct S_DDP p0, double p1, float p2) { return p0; }
+EXPORT struct S_DPI f18_S_SDF_DPI(struct S_DPI p0, double p1, float p2) { return p0; }
+EXPORT struct S_DPF f18_S_SDF_DPF(struct S_DPF p0, double p1, float p2) { return p0; }
+EXPORT struct S_DPD f18_S_SDF_DPD(struct S_DPD p0, double p1, float p2) { return p0; }
+EXPORT struct S_DPP f18_S_SDF_DPP(struct S_DPP p0, double p1, float p2) { return p0; }
+EXPORT struct S_PII f18_S_SDF_PII(struct S_PII p0, double p1, float p2) { return p0; }
+EXPORT struct S_PIF f18_S_SDF_PIF(struct S_PIF p0, double p1, float p2) { return p0; }
+EXPORT struct S_PID f18_S_SDF_PID(struct S_PID p0, double p1, float p2) { return p0; }
+EXPORT struct S_PIP f18_S_SDF_PIP(struct S_PIP p0, double p1, float p2) { return p0; }
+EXPORT struct S_PFI f18_S_SDF_PFI(struct S_PFI p0, double p1, float p2) { return p0; }
+EXPORT struct S_PFF f18_S_SDF_PFF(struct S_PFF p0, double p1, float p2) { return p0; }
+EXPORT struct S_PFD f18_S_SDF_PFD(struct S_PFD p0, double p1, float p2) { return p0; }
+EXPORT struct S_PFP f18_S_SDF_PFP(struct S_PFP p0, double p1, float p2) { return p0; }
+EXPORT struct S_PDI f18_S_SDF_PDI(struct S_PDI p0, double p1, float p2) { return p0; }
+EXPORT struct S_PDF f18_S_SDF_PDF(struct S_PDF p0, double p1, float p2) { return p0; }
+EXPORT struct S_PDD f18_S_SDF_PDD(struct S_PDD p0, double p1, float p2) { return p0; }
+EXPORT struct S_PDP f18_S_SDF_PDP(struct S_PDP p0, double p1, float p2) { return p0; }
+EXPORT struct S_PPI f18_S_SDF_PPI(struct S_PPI p0, double p1, float p2) { return p0; }
+EXPORT struct S_PPF f18_S_SDF_PPF(struct S_PPF p0, double p1, float p2) { return p0; }
+EXPORT struct S_PPD f18_S_SDF_PPD(struct S_PPD p0, double p1, float p2) { return p0; }
+EXPORT struct S_PPP f18_S_SDF_PPP(struct S_PPP p0, double p1, float p2) { return p0; }
+EXPORT struct S_I f18_S_SDD_I(struct S_I p0, double p1, double p2) { return p0; }
+EXPORT struct S_F f18_S_SDD_F(struct S_F p0, double p1, double p2) { return p0; }
+EXPORT struct S_D f18_S_SDD_D(struct S_D p0, double p1, double p2) { return p0; }
+EXPORT struct S_P f18_S_SDD_P(struct S_P p0, double p1, double p2) { return p0; }
+EXPORT struct S_II f18_S_SDD_II(struct S_II p0, double p1, double p2) { return p0; }
+EXPORT struct S_IF f18_S_SDD_IF(struct S_IF p0, double p1, double p2) { return p0; }
+EXPORT struct S_ID f18_S_SDD_ID(struct S_ID p0, double p1, double p2) { return p0; }
+EXPORT struct S_IP f18_S_SDD_IP(struct S_IP p0, double p1, double p2) { return p0; }
+EXPORT struct S_FI f18_S_SDD_FI(struct S_FI p0, double p1, double p2) { return p0; }
+EXPORT struct S_FF f18_S_SDD_FF(struct S_FF p0, double p1, double p2) { return p0; }
+EXPORT struct S_FD f18_S_SDD_FD(struct S_FD p0, double p1, double p2) { return p0; }
+EXPORT struct S_FP f18_S_SDD_FP(struct S_FP p0, double p1, double p2) { return p0; }
+EXPORT struct S_DI f18_S_SDD_DI(struct S_DI p0, double p1, double p2) { return p0; }
+EXPORT struct S_DF f18_S_SDD_DF(struct S_DF p0, double p1, double p2) { return p0; }
+EXPORT struct S_DD f18_S_SDD_DD(struct S_DD p0, double p1, double p2) { return p0; }
+EXPORT struct S_DP f18_S_SDD_DP(struct S_DP p0, double p1, double p2) { return p0; }
+EXPORT struct S_PI f18_S_SDD_PI(struct S_PI p0, double p1, double p2) { return p0; }
+EXPORT struct S_PF f18_S_SDD_PF(struct S_PF p0, double p1, double p2) { return p0; }
+EXPORT struct S_PD f18_S_SDD_PD(struct S_PD p0, double p1, double p2) { return p0; }
+EXPORT struct S_PP f18_S_SDD_PP(struct S_PP p0, double p1, double p2) { return p0; }
+EXPORT struct S_III f18_S_SDD_III(struct S_III p0, double p1, double p2) { return p0; }
+EXPORT struct S_IIF f18_S_SDD_IIF(struct S_IIF p0, double p1, double p2) { return p0; }
+EXPORT struct S_IID f18_S_SDD_IID(struct S_IID p0, double p1, double p2) { return p0; }
+EXPORT struct S_IIP f18_S_SDD_IIP(struct S_IIP p0, double p1, double p2) { return p0; }
+EXPORT struct S_IFI f18_S_SDD_IFI(struct S_IFI p0, double p1, double p2) { return p0; }
+EXPORT struct S_IFF f18_S_SDD_IFF(struct S_IFF p0, double p1, double p2) { return p0; }
+EXPORT struct S_IFD f18_S_SDD_IFD(struct S_IFD p0, double p1, double p2) { return p0; }
+EXPORT struct S_IFP f18_S_SDD_IFP(struct S_IFP p0, double p1, double p2) { return p0; }
+EXPORT struct S_IDI f18_S_SDD_IDI(struct S_IDI p0, double p1, double p2) { return p0; }
+EXPORT struct S_IDF f18_S_SDD_IDF(struct S_IDF p0, double p1, double p2) { return p0; }
+EXPORT struct S_IDD f18_S_SDD_IDD(struct S_IDD p0, double p1, double p2) { return p0; }
+EXPORT struct S_IDP f18_S_SDD_IDP(struct S_IDP p0, double p1, double p2) { return p0; }
+EXPORT struct S_IPI f18_S_SDD_IPI(struct S_IPI p0, double p1, double p2) { return p0; }
+EXPORT struct S_IPF f18_S_SDD_IPF(struct S_IPF p0, double p1, double p2) { return p0; }
+EXPORT struct S_IPD f18_S_SDD_IPD(struct S_IPD p0, double p1, double p2) { return p0; }
+EXPORT struct S_IPP f18_S_SDD_IPP(struct S_IPP p0, double p1, double p2) { return p0; }
+EXPORT struct S_FII f18_S_SDD_FII(struct S_FII p0, double p1, double p2) { return p0; }
+EXPORT struct S_FIF f18_S_SDD_FIF(struct S_FIF p0, double p1, double p2) { return p0; }
+EXPORT struct S_FID f18_S_SDD_FID(struct S_FID p0, double p1, double p2) { return p0; }
+EXPORT struct S_FIP f18_S_SDD_FIP(struct S_FIP p0, double p1, double p2) { return p0; }
+EXPORT struct S_FFI f18_S_SDD_FFI(struct S_FFI p0, double p1, double p2) { return p0; }
+EXPORT struct S_FFF f18_S_SDD_FFF(struct S_FFF p0, double p1, double p2) { return p0; }
+EXPORT struct S_FFD f18_S_SDD_FFD(struct S_FFD p0, double p1, double p2) { return p0; }
+EXPORT struct S_FFP f18_S_SDD_FFP(struct S_FFP p0, double p1, double p2) { return p0; }
+EXPORT struct S_FDI f18_S_SDD_FDI(struct S_FDI p0, double p1, double p2) { return p0; }
+EXPORT struct S_FDF f18_S_SDD_FDF(struct S_FDF p0, double p1, double p2) { return p0; }
+EXPORT struct S_FDD f18_S_SDD_FDD(struct S_FDD p0, double p1, double p2) { return p0; }
+EXPORT struct S_FDP f18_S_SDD_FDP(struct S_FDP p0, double p1, double p2) { return p0; }
+EXPORT struct S_FPI f18_S_SDD_FPI(struct S_FPI p0, double p1, double p2) { return p0; }
+EXPORT struct S_FPF f18_S_SDD_FPF(struct S_FPF p0, double p1, double p2) { return p0; }
+EXPORT struct S_FPD f18_S_SDD_FPD(struct S_FPD p0, double p1, double p2) { return p0; }
+EXPORT struct S_FPP f18_S_SDD_FPP(struct S_FPP p0, double p1, double p2) { return p0; }
+EXPORT struct S_DII f18_S_SDD_DII(struct S_DII p0, double p1, double p2) { return p0; }
+EXPORT struct S_DIF f18_S_SDD_DIF(struct S_DIF p0, double p1, double p2) { return p0; }
+EXPORT struct S_DID f18_S_SDD_DID(struct S_DID p0, double p1, double p2) { return p0; }
+EXPORT struct S_DIP f18_S_SDD_DIP(struct S_DIP p0, double p1, double p2) { return p0; }
+EXPORT struct S_DFI f18_S_SDD_DFI(struct S_DFI p0, double p1, double p2) { return p0; }
+EXPORT struct S_DFF f18_S_SDD_DFF(struct S_DFF p0, double p1, double p2) { return p0; }
+EXPORT struct S_DFD f18_S_SDD_DFD(struct S_DFD p0, double p1, double p2) { return p0; }
+EXPORT struct S_DFP f18_S_SDD_DFP(struct S_DFP p0, double p1, double p2) { return p0; }
+EXPORT struct S_DDI f18_S_SDD_DDI(struct S_DDI p0, double p1, double p2) { return p0; }
+EXPORT struct S_DDF f18_S_SDD_DDF(struct S_DDF p0, double p1, double p2) { return p0; }
+EXPORT struct S_DDD f18_S_SDD_DDD(struct S_DDD p0, double p1, double p2) { return p0; }
+EXPORT struct S_DDP f18_S_SDD_DDP(struct S_DDP p0, double p1, double p2) { return p0; }
+EXPORT struct S_DPI f18_S_SDD_DPI(struct S_DPI p0, double p1, double p2) { return p0; }
+EXPORT struct S_DPF f18_S_SDD_DPF(struct S_DPF p0, double p1, double p2) { return p0; }
+EXPORT struct S_DPD f18_S_SDD_DPD(struct S_DPD p0, double p1, double p2) { return p0; }
+EXPORT struct S_DPP f18_S_SDD_DPP(struct S_DPP p0, double p1, double p2) { return p0; }
+EXPORT struct S_PII f18_S_SDD_PII(struct S_PII p0, double p1, double p2) { return p0; }
+EXPORT struct S_PIF f18_S_SDD_PIF(struct S_PIF p0, double p1, double p2) { return p0; }
+EXPORT struct S_PID f18_S_SDD_PID(struct S_PID p0, double p1, double p2) { return p0; }
+EXPORT struct S_PIP f18_S_SDD_PIP(struct S_PIP p0, double p1, double p2) { return p0; }
+EXPORT struct S_PFI f18_S_SDD_PFI(struct S_PFI p0, double p1, double p2) { return p0; }
+EXPORT struct S_PFF f18_S_SDD_PFF(struct S_PFF p0, double p1, double p2) { return p0; }
+EXPORT struct S_PFD f18_S_SDD_PFD(struct S_PFD p0, double p1, double p2) { return p0; }
+EXPORT struct S_PFP f18_S_SDD_PFP(struct S_PFP p0, double p1, double p2) { return p0; }
+EXPORT struct S_PDI f18_S_SDD_PDI(struct S_PDI p0, double p1, double p2) { return p0; }
+EXPORT struct S_PDF f18_S_SDD_PDF(struct S_PDF p0, double p1, double p2) { return p0; }
+EXPORT struct S_PDD f18_S_SDD_PDD(struct S_PDD p0, double p1, double p2) { return p0; }
+EXPORT struct S_PDP f18_S_SDD_PDP(struct S_PDP p0, double p1, double p2) { return p0; }
+EXPORT struct S_PPI f18_S_SDD_PPI(struct S_PPI p0, double p1, double p2) { return p0; }
+EXPORT struct S_PPF f18_S_SDD_PPF(struct S_PPF p0, double p1, double p2) { return p0; }
+EXPORT struct S_PPD f18_S_SDD_PPD(struct S_PPD p0, double p1, double p2) { return p0; }
+EXPORT struct S_PPP f18_S_SDD_PPP(struct S_PPP p0, double p1, double p2) { return p0; }
+EXPORT struct S_I f18_S_SDP_I(struct S_I p0, double p1, void* p2) { return p0; }
+EXPORT struct S_F f18_S_SDP_F(struct S_F p0, double p1, void* p2) { return p0; }
+EXPORT struct S_D f18_S_SDP_D(struct S_D p0, double p1, void* p2) { return p0; }
+EXPORT struct S_P f18_S_SDP_P(struct S_P p0, double p1, void* p2) { return p0; }
+EXPORT struct S_II f18_S_SDP_II(struct S_II p0, double p1, void* p2) { return p0; }
+EXPORT struct S_IF f18_S_SDP_IF(struct S_IF p0, double p1, void* p2) { return p0; }
+EXPORT struct S_ID f18_S_SDP_ID(struct S_ID p0, double p1, void* p2) { return p0; }
+EXPORT struct S_IP f18_S_SDP_IP(struct S_IP p0, double p1, void* p2) { return p0; }
+EXPORT struct S_FI f18_S_SDP_FI(struct S_FI p0, double p1, void* p2) { return p0; }
+EXPORT struct S_FF f18_S_SDP_FF(struct S_FF p0, double p1, void* p2) { return p0; }
+EXPORT struct S_FD f18_S_SDP_FD(struct S_FD p0, double p1, void* p2) { return p0; }
+EXPORT struct S_FP f18_S_SDP_FP(struct S_FP p0, double p1, void* p2) { return p0; }
+EXPORT struct S_DI f18_S_SDP_DI(struct S_DI p0, double p1, void* p2) { return p0; }
+EXPORT struct S_DF f18_S_SDP_DF(struct S_DF p0, double p1, void* p2) { return p0; }
+EXPORT struct S_DD f18_S_SDP_DD(struct S_DD p0, double p1, void* p2) { return p0; }
+EXPORT struct S_DP f18_S_SDP_DP(struct S_DP p0, double p1, void* p2) { return p0; }
+EXPORT struct S_PI f18_S_SDP_PI(struct S_PI p0, double p1, void* p2) { return p0; }
+EXPORT struct S_PF f18_S_SDP_PF(struct S_PF p0, double p1, void* p2) { return p0; }
+EXPORT struct S_PD f18_S_SDP_PD(struct S_PD p0, double p1, void* p2) { return p0; }
+EXPORT struct S_PP f18_S_SDP_PP(struct S_PP p0, double p1, void* p2) { return p0; }
+EXPORT struct S_III f18_S_SDP_III(struct S_III p0, double p1, void* p2) { return p0; }
+EXPORT struct S_IIF f18_S_SDP_IIF(struct S_IIF p0, double p1, void* p2) { return p0; }
+EXPORT struct S_IID f18_S_SDP_IID(struct S_IID p0, double p1, void* p2) { return p0; }
+EXPORT struct S_IIP f18_S_SDP_IIP(struct S_IIP p0, double p1, void* p2) { return p0; }
+EXPORT struct S_IFI f18_S_SDP_IFI(struct S_IFI p0, double p1, void* p2) { return p0; }
+EXPORT struct S_IFF f18_S_SDP_IFF(struct S_IFF p0, double p1, void* p2) { return p0; }
+EXPORT struct S_IFD f18_S_SDP_IFD(struct S_IFD p0, double p1, void* p2) { return p0; }
+EXPORT struct S_IFP f18_S_SDP_IFP(struct S_IFP p0, double p1, void* p2) { return p0; }
+EXPORT struct S_IDI f18_S_SDP_IDI(struct S_IDI p0, double p1, void* p2) { return p0; }
+EXPORT struct S_IDF f18_S_SDP_IDF(struct S_IDF p0, double p1, void* p2) { return p0; }
+EXPORT struct S_IDD f18_S_SDP_IDD(struct S_IDD p0, double p1, void* p2) { return p0; }
+EXPORT struct S_IDP f18_S_SDP_IDP(struct S_IDP p0, double p1, void* p2) { return p0; }
+EXPORT struct S_IPI f18_S_SDP_IPI(struct S_IPI p0, double p1, void* p2) { return p0; }
+EXPORT struct S_IPF f18_S_SDP_IPF(struct S_IPF p0, double p1, void* p2) { return p0; }
+EXPORT struct S_IPD f18_S_SDP_IPD(struct S_IPD p0, double p1, void* p2) { return p0; }
+EXPORT struct S_IPP f18_S_SDP_IPP(struct S_IPP p0, double p1, void* p2) { return p0; }
+EXPORT struct S_FII f18_S_SDP_FII(struct S_FII p0, double p1, void* p2) { return p0; }
+EXPORT struct S_FIF f18_S_SDP_FIF(struct S_FIF p0, double p1, void* p2) { return p0; }
+EXPORT struct S_FID f18_S_SDP_FID(struct S_FID p0, double p1, void* p2) { return p0; }
+EXPORT struct S_FIP f18_S_SDP_FIP(struct S_FIP p0, double p1, void* p2) { return p0; }
+EXPORT struct S_FFI f18_S_SDP_FFI(struct S_FFI p0, double p1, void* p2) { return p0; }
+EXPORT struct S_FFF f18_S_SDP_FFF(struct S_FFF p0, double p1, void* p2) { return p0; }
+EXPORT struct S_FFD f18_S_SDP_FFD(struct S_FFD p0, double p1, void* p2) { return p0; }
+EXPORT struct S_FFP f18_S_SDP_FFP(struct S_FFP p0, double p1, void* p2) { return p0; }
+EXPORT struct S_FDI f18_S_SDP_FDI(struct S_FDI p0, double p1, void* p2) { return p0; }
+EXPORT struct S_FDF f18_S_SDP_FDF(struct S_FDF p0, double p1, void* p2) { return p0; }
+EXPORT struct S_FDD f18_S_SDP_FDD(struct S_FDD p0, double p1, void* p2) { return p0; }
+EXPORT struct S_FDP f18_S_SDP_FDP(struct S_FDP p0, double p1, void* p2) { return p0; }
+EXPORT struct S_FPI f18_S_SDP_FPI(struct S_FPI p0, double p1, void* p2) { return p0; }
+EXPORT struct S_FPF f18_S_SDP_FPF(struct S_FPF p0, double p1, void* p2) { return p0; }
+EXPORT struct S_FPD f18_S_SDP_FPD(struct S_FPD p0, double p1, void* p2) { return p0; }
+EXPORT struct S_FPP f18_S_SDP_FPP(struct S_FPP p0, double p1, void* p2) { return p0; }
+EXPORT struct S_DII f18_S_SDP_DII(struct S_DII p0, double p1, void* p2) { return p0; }
+EXPORT struct S_DIF f18_S_SDP_DIF(struct S_DIF p0, double p1, void* p2) { return p0; }
+EXPORT struct S_DID f18_S_SDP_DID(struct S_DID p0, double p1, void* p2) { return p0; }
+EXPORT struct S_DIP f18_S_SDP_DIP(struct S_DIP p0, double p1, void* p2) { return p0; }
+EXPORT struct S_DFI f18_S_SDP_DFI(struct S_DFI p0, double p1, void* p2) { return p0; }
+EXPORT struct S_DFF f18_S_SDP_DFF(struct S_DFF p0, double p1, void* p2) { return p0; }
+EXPORT struct S_DFD f18_S_SDP_DFD(struct S_DFD p0, double p1, void* p2) { return p0; }
+EXPORT struct S_DFP f18_S_SDP_DFP(struct S_DFP p0, double p1, void* p2) { return p0; }
+EXPORT struct S_DDI f18_S_SDP_DDI(struct S_DDI p0, double p1, void* p2) { return p0; }
+EXPORT struct S_DDF f18_S_SDP_DDF(struct S_DDF p0, double p1, void* p2) { return p0; }
+EXPORT struct S_DDD f18_S_SDP_DDD(struct S_DDD p0, double p1, void* p2) { return p0; }
+EXPORT struct S_DDP f18_S_SDP_DDP(struct S_DDP p0, double p1, void* p2) { return p0; }
+EXPORT struct S_DPI f18_S_SDP_DPI(struct S_DPI p0, double p1, void* p2) { return p0; }
+EXPORT struct S_DPF f18_S_SDP_DPF(struct S_DPF p0, double p1, void* p2) { return p0; }
+EXPORT struct S_DPD f18_S_SDP_DPD(struct S_DPD p0, double p1, void* p2) { return p0; }
+EXPORT struct S_DPP f18_S_SDP_DPP(struct S_DPP p0, double p1, void* p2) { return p0; }
+EXPORT struct S_PII f18_S_SDP_PII(struct S_PII p0, double p1, void* p2) { return p0; }
+EXPORT struct S_PIF f18_S_SDP_PIF(struct S_PIF p0, double p1, void* p2) { return p0; }
+EXPORT struct S_PID f18_S_SDP_PID(struct S_PID p0, double p1, void* p2) { return p0; }
+EXPORT struct S_PIP f18_S_SDP_PIP(struct S_PIP p0, double p1, void* p2) { return p0; }
+EXPORT struct S_PFI f18_S_SDP_PFI(struct S_PFI p0, double p1, void* p2) { return p0; }
+EXPORT struct S_PFF f18_S_SDP_PFF(struct S_PFF p0, double p1, void* p2) { return p0; }
+EXPORT struct S_PFD f18_S_SDP_PFD(struct S_PFD p0, double p1, void* p2) { return p0; }
+EXPORT struct S_PFP f18_S_SDP_PFP(struct S_PFP p0, double p1, void* p2) { return p0; }
+EXPORT struct S_PDI f18_S_SDP_PDI(struct S_PDI p0, double p1, void* p2) { return p0; }
+EXPORT struct S_PDF f18_S_SDP_PDF(struct S_PDF p0, double p1, void* p2) { return p0; }
+EXPORT struct S_PDD f18_S_SDP_PDD(struct S_PDD p0, double p1, void* p2) { return p0; }
+EXPORT struct S_PDP f18_S_SDP_PDP(struct S_PDP p0, double p1, void* p2) { return p0; }
+EXPORT struct S_PPI f18_S_SDP_PPI(struct S_PPI p0, double p1, void* p2) { return p0; }
+EXPORT struct S_PPF f18_S_SDP_PPF(struct S_PPF p0, double p1, void* p2) { return p0; }
+EXPORT struct S_PPD f18_S_SDP_PPD(struct S_PPD p0, double p1, void* p2) { return p0; }
+EXPORT struct S_PPP f18_S_SDP_PPP(struct S_PPP p0, double p1, void* p2) { return p0; }
+EXPORT struct S_I f18_S_SDS_I(struct S_I p0, double p1, struct S_I p2) { return p0; }
+EXPORT struct S_F f18_S_SDS_F(struct S_F p0, double p1, struct S_F p2) { return p0; }
+EXPORT struct S_D f18_S_SDS_D(struct S_D p0, double p1, struct S_D p2) { return p0; }
+EXPORT struct S_P f18_S_SDS_P(struct S_P p0, double p1, struct S_P p2) { return p0; }
+EXPORT struct S_II f18_S_SDS_II(struct S_II p0, double p1, struct S_II p2) { return p0; }
+EXPORT struct S_IF f18_S_SDS_IF(struct S_IF p0, double p1, struct S_IF p2) { return p0; }
+EXPORT struct S_ID f18_S_SDS_ID(struct S_ID p0, double p1, struct S_ID p2) { return p0; }
+EXPORT struct S_IP f18_S_SDS_IP(struct S_IP p0, double p1, struct S_IP p2) { return p0; }
+EXPORT struct S_FI f18_S_SDS_FI(struct S_FI p0, double p1, struct S_FI p2) { return p0; }
+EXPORT struct S_FF f18_S_SDS_FF(struct S_FF p0, double p1, struct S_FF p2) { return p0; }
+EXPORT struct S_FD f18_S_SDS_FD(struct S_FD p0, double p1, struct S_FD p2) { return p0; }
+EXPORT struct S_FP f18_S_SDS_FP(struct S_FP p0, double p1, struct S_FP p2) { return p0; }
+EXPORT struct S_DI f18_S_SDS_DI(struct S_DI p0, double p1, struct S_DI p2) { return p0; }
+EXPORT struct S_DF f18_S_SDS_DF(struct S_DF p0, double p1, struct S_DF p2) { return p0; }
+EXPORT struct S_DD f18_S_SDS_DD(struct S_DD p0, double p1, struct S_DD p2) { return p0; }
+EXPORT struct S_DP f18_S_SDS_DP(struct S_DP p0, double p1, struct S_DP p2) { return p0; }
+EXPORT struct S_PI f18_S_SDS_PI(struct S_PI p0, double p1, struct S_PI p2) { return p0; }
+EXPORT struct S_PF f18_S_SDS_PF(struct S_PF p0, double p1, struct S_PF p2) { return p0; }
+EXPORT struct S_PD f18_S_SDS_PD(struct S_PD p0, double p1, struct S_PD p2) { return p0; }
+EXPORT struct S_PP f18_S_SDS_PP(struct S_PP p0, double p1, struct S_PP p2) { return p0; }
+EXPORT struct S_III f18_S_SDS_III(struct S_III p0, double p1, struct S_III p2) { return p0; }
+EXPORT struct S_IIF f18_S_SDS_IIF(struct S_IIF p0, double p1, struct S_IIF p2) { return p0; }
+EXPORT struct S_IID f18_S_SDS_IID(struct S_IID p0, double p1, struct S_IID p2) { return p0; }
+EXPORT struct S_IIP f18_S_SDS_IIP(struct S_IIP p0, double p1, struct S_IIP p2) { return p0; }
+EXPORT struct S_IFI f18_S_SDS_IFI(struct S_IFI p0, double p1, struct S_IFI p2) { return p0; }
+EXPORT struct S_IFF f18_S_SDS_IFF(struct S_IFF p0, double p1, struct S_IFF p2) { return p0; }
+EXPORT struct S_IFD f18_S_SDS_IFD(struct S_IFD p0, double p1, struct S_IFD p2) { return p0; }
+EXPORT struct S_IFP f18_S_SDS_IFP(struct S_IFP p0, double p1, struct S_IFP p2) { return p0; }
+EXPORT struct S_IDI f18_S_SDS_IDI(struct S_IDI p0, double p1, struct S_IDI p2) { return p0; }
+EXPORT struct S_IDF f18_S_SDS_IDF(struct S_IDF p0, double p1, struct S_IDF p2) { return p0; }
+EXPORT struct S_IDD f18_S_SDS_IDD(struct S_IDD p0, double p1, struct S_IDD p2) { return p0; }
+EXPORT struct S_IDP f18_S_SDS_IDP(struct S_IDP p0, double p1, struct S_IDP p2) { return p0; }
+EXPORT struct S_IPI f18_S_SDS_IPI(struct S_IPI p0, double p1, struct S_IPI p2) { return p0; }
+EXPORT struct S_IPF f18_S_SDS_IPF(struct S_IPF p0, double p1, struct S_IPF p2) { return p0; }
+EXPORT struct S_IPD f18_S_SDS_IPD(struct S_IPD p0, double p1, struct S_IPD p2) { return p0; }
+EXPORT struct S_IPP f18_S_SDS_IPP(struct S_IPP p0, double p1, struct S_IPP p2) { return p0; }
+EXPORT struct S_FII f18_S_SDS_FII(struct S_FII p0, double p1, struct S_FII p2) { return p0; }
+EXPORT struct S_FIF f18_S_SDS_FIF(struct S_FIF p0, double p1, struct S_FIF p2) { return p0; }
+EXPORT struct S_FID f18_S_SDS_FID(struct S_FID p0, double p1, struct S_FID p2) { return p0; }
+EXPORT struct S_FIP f18_S_SDS_FIP(struct S_FIP p0, double p1, struct S_FIP p2) { return p0; }
+EXPORT struct S_FFI f18_S_SDS_FFI(struct S_FFI p0, double p1, struct S_FFI p2) { return p0; }
+EXPORT struct S_FFF f18_S_SDS_FFF(struct S_FFF p0, double p1, struct S_FFF p2) { return p0; }
+EXPORT struct S_FFD f18_S_SDS_FFD(struct S_FFD p0, double p1, struct S_FFD p2) { return p0; }
+EXPORT struct S_FFP f18_S_SDS_FFP(struct S_FFP p0, double p1, struct S_FFP p2) { return p0; }
+EXPORT struct S_FDI f18_S_SDS_FDI(struct S_FDI p0, double p1, struct S_FDI p2) { return p0; }
+EXPORT struct S_FDF f18_S_SDS_FDF(struct S_FDF p0, double p1, struct S_FDF p2) { return p0; }
+EXPORT struct S_FDD f18_S_SDS_FDD(struct S_FDD p0, double p1, struct S_FDD p2) { return p0; }
+EXPORT struct S_FDP f18_S_SDS_FDP(struct S_FDP p0, double p1, struct S_FDP p2) { return p0; }
+EXPORT struct S_FPI f18_S_SDS_FPI(struct S_FPI p0, double p1, struct S_FPI p2) { return p0; }
+EXPORT struct S_FPF f18_S_SDS_FPF(struct S_FPF p0, double p1, struct S_FPF p2) { return p0; }
+EXPORT struct S_FPD f18_S_SDS_FPD(struct S_FPD p0, double p1, struct S_FPD p2) { return p0; }
+EXPORT struct S_FPP f18_S_SDS_FPP(struct S_FPP p0, double p1, struct S_FPP p2) { return p0; }
+EXPORT struct S_DII f18_S_SDS_DII(struct S_DII p0, double p1, struct S_DII p2) { return p0; }
+EXPORT struct S_DIF f18_S_SDS_DIF(struct S_DIF p0, double p1, struct S_DIF p2) { return p0; }
+EXPORT struct S_DID f18_S_SDS_DID(struct S_DID p0, double p1, struct S_DID p2) { return p0; }
+EXPORT struct S_DIP f18_S_SDS_DIP(struct S_DIP p0, double p1, struct S_DIP p2) { return p0; }
+EXPORT struct S_DFI f18_S_SDS_DFI(struct S_DFI p0, double p1, struct S_DFI p2) { return p0; }
+EXPORT struct S_DFF f18_S_SDS_DFF(struct S_DFF p0, double p1, struct S_DFF p2) { return p0; }
+EXPORT struct S_DFD f18_S_SDS_DFD(struct S_DFD p0, double p1, struct S_DFD p2) { return p0; }
+EXPORT struct S_DFP f18_S_SDS_DFP(struct S_DFP p0, double p1, struct S_DFP p2) { return p0; }
+EXPORT struct S_DDI f18_S_SDS_DDI(struct S_DDI p0, double p1, struct S_DDI p2) { return p0; }
+EXPORT struct S_DDF f18_S_SDS_DDF(struct S_DDF p0, double p1, struct S_DDF p2) { return p0; }
+EXPORT struct S_DDD f18_S_SDS_DDD(struct S_DDD p0, double p1, struct S_DDD p2) { return p0; }
+EXPORT struct S_DDP f18_S_SDS_DDP(struct S_DDP p0, double p1, struct S_DDP p2) { return p0; }
+EXPORT struct S_DPI f18_S_SDS_DPI(struct S_DPI p0, double p1, struct S_DPI p2) { return p0; }
+EXPORT struct S_DPF f18_S_SDS_DPF(struct S_DPF p0, double p1, struct S_DPF p2) { return p0; }
+EXPORT struct S_DPD f18_S_SDS_DPD(struct S_DPD p0, double p1, struct S_DPD p2) { return p0; }
+EXPORT struct S_DPP f18_S_SDS_DPP(struct S_DPP p0, double p1, struct S_DPP p2) { return p0; }
+EXPORT struct S_PII f18_S_SDS_PII(struct S_PII p0, double p1, struct S_PII p2) { return p0; }
+EXPORT struct S_PIF f18_S_SDS_PIF(struct S_PIF p0, double p1, struct S_PIF p2) { return p0; }
+EXPORT struct S_PID f18_S_SDS_PID(struct S_PID p0, double p1, struct S_PID p2) { return p0; }
+EXPORT struct S_PIP f18_S_SDS_PIP(struct S_PIP p0, double p1, struct S_PIP p2) { return p0; }
+EXPORT struct S_PFI f18_S_SDS_PFI(struct S_PFI p0, double p1, struct S_PFI p2) { return p0; }
+EXPORT struct S_PFF f18_S_SDS_PFF(struct S_PFF p0, double p1, struct S_PFF p2) { return p0; }
+EXPORT struct S_PFD f18_S_SDS_PFD(struct S_PFD p0, double p1, struct S_PFD p2) { return p0; }
+EXPORT struct S_PFP f18_S_SDS_PFP(struct S_PFP p0, double p1, struct S_PFP p2) { return p0; }
+EXPORT struct S_PDI f18_S_SDS_PDI(struct S_PDI p0, double p1, struct S_PDI p2) { return p0; }
+EXPORT struct S_PDF f18_S_SDS_PDF(struct S_PDF p0, double p1, struct S_PDF p2) { return p0; }
+EXPORT struct S_PDD f18_S_SDS_PDD(struct S_PDD p0, double p1, struct S_PDD p2) { return p0; }
+EXPORT struct S_PDP f18_S_SDS_PDP(struct S_PDP p0, double p1, struct S_PDP p2) { return p0; }
+EXPORT struct S_PPI f18_S_SDS_PPI(struct S_PPI p0, double p1, struct S_PPI p2) { return p0; }
+EXPORT struct S_PPF f18_S_SDS_PPF(struct S_PPF p0, double p1, struct S_PPF p2) { return p0; }
+EXPORT struct S_PPD f18_S_SDS_PPD(struct S_PPD p0, double p1, struct S_PPD p2) { return p0; }
+EXPORT struct S_PPP f18_S_SDS_PPP(struct S_PPP p0, double p1, struct S_PPP p2) { return p0; }
+EXPORT struct S_I f18_S_SPI_I(struct S_I p0, void* p1, int p2) { return p0; }
+EXPORT struct S_F f18_S_SPI_F(struct S_F p0, void* p1, int p2) { return p0; }
+EXPORT struct S_D f18_S_SPI_D(struct S_D p0, void* p1, int p2) { return p0; }
+EXPORT struct S_P f18_S_SPI_P(struct S_P p0, void* p1, int p2) { return p0; }
+EXPORT struct S_II f18_S_SPI_II(struct S_II p0, void* p1, int p2) { return p0; }
+EXPORT struct S_IF f18_S_SPI_IF(struct S_IF p0, void* p1, int p2) { return p0; }
+EXPORT struct S_ID f18_S_SPI_ID(struct S_ID p0, void* p1, int p2) { return p0; }
+EXPORT struct S_IP f18_S_SPI_IP(struct S_IP p0, void* p1, int p2) { return p0; }
+EXPORT struct S_FI f18_S_SPI_FI(struct S_FI p0, void* p1, int p2) { return p0; }
+EXPORT struct S_FF f18_S_SPI_FF(struct S_FF p0, void* p1, int p2) { return p0; }
+EXPORT struct S_FD f18_S_SPI_FD(struct S_FD p0, void* p1, int p2) { return p0; }
+EXPORT struct S_FP f18_S_SPI_FP(struct S_FP p0, void* p1, int p2) { return p0; }
+EXPORT struct S_DI f18_S_SPI_DI(struct S_DI p0, void* p1, int p2) { return p0; }
+EXPORT struct S_DF f18_S_SPI_DF(struct S_DF p0, void* p1, int p2) { return p0; }
+EXPORT struct S_DD f18_S_SPI_DD(struct S_DD p0, void* p1, int p2) { return p0; }
+EXPORT struct S_DP f18_S_SPI_DP(struct S_DP p0, void* p1, int p2) { return p0; }
+EXPORT struct S_PI f18_S_SPI_PI(struct S_PI p0, void* p1, int p2) { return p0; }
+EXPORT struct S_PF f18_S_SPI_PF(struct S_PF p0, void* p1, int p2) { return p0; }
+EXPORT struct S_PD f18_S_SPI_PD(struct S_PD p0, void* p1, int p2) { return p0; }
+EXPORT struct S_PP f18_S_SPI_PP(struct S_PP p0, void* p1, int p2) { return p0; }
+EXPORT struct S_III f18_S_SPI_III(struct S_III p0, void* p1, int p2) { return p0; }
+EXPORT struct S_IIF f18_S_SPI_IIF(struct S_IIF p0, void* p1, int p2) { return p0; }
+EXPORT struct S_IID f18_S_SPI_IID(struct S_IID p0, void* p1, int p2) { return p0; }
+EXPORT struct S_IIP f18_S_SPI_IIP(struct S_IIP p0, void* p1, int p2) { return p0; }
+EXPORT struct S_IFI f18_S_SPI_IFI(struct S_IFI p0, void* p1, int p2) { return p0; }
+EXPORT struct S_IFF f18_S_SPI_IFF(struct S_IFF p0, void* p1, int p2) { return p0; }
+EXPORT struct S_IFD f18_S_SPI_IFD(struct S_IFD p0, void* p1, int p2) { return p0; }
+EXPORT struct S_IFP f18_S_SPI_IFP(struct S_IFP p0, void* p1, int p2) { return p0; }
+EXPORT struct S_IDI f18_S_SPI_IDI(struct S_IDI p0, void* p1, int p2) { return p0; }
+EXPORT struct S_IDF f18_S_SPI_IDF(struct S_IDF p0, void* p1, int p2) { return p0; }
+EXPORT struct S_IDD f18_S_SPI_IDD(struct S_IDD p0, void* p1, int p2) { return p0; }
+EXPORT struct S_IDP f18_S_SPI_IDP(struct S_IDP p0, void* p1, int p2) { return p0; }
+EXPORT struct S_IPI f18_S_SPI_IPI(struct S_IPI p0, void* p1, int p2) { return p0; }
+EXPORT struct S_IPF f18_S_SPI_IPF(struct S_IPF p0, void* p1, int p2) { return p0; }
+EXPORT struct S_IPD f18_S_SPI_IPD(struct S_IPD p0, void* p1, int p2) { return p0; }
+EXPORT struct S_IPP f18_S_SPI_IPP(struct S_IPP p0, void* p1, int p2) { return p0; }
+EXPORT struct S_FII f18_S_SPI_FII(struct S_FII p0, void* p1, int p2) { return p0; }
+EXPORT struct S_FIF f18_S_SPI_FIF(struct S_FIF p0, void* p1, int p2) { return p0; }
+EXPORT struct S_FID f18_S_SPI_FID(struct S_FID p0, void* p1, int p2) { return p0; }
+EXPORT struct S_FIP f18_S_SPI_FIP(struct S_FIP p0, void* p1, int p2) { return p0; }
+EXPORT struct S_FFI f18_S_SPI_FFI(struct S_FFI p0, void* p1, int p2) { return p0; }
+EXPORT struct S_FFF f18_S_SPI_FFF(struct S_FFF p0, void* p1, int p2) { return p0; }
+EXPORT struct S_FFD f18_S_SPI_FFD(struct S_FFD p0, void* p1, int p2) { return p0; }
+EXPORT struct S_FFP f18_S_SPI_FFP(struct S_FFP p0, void* p1, int p2) { return p0; }
+EXPORT struct S_FDI f18_S_SPI_FDI(struct S_FDI p0, void* p1, int p2) { return p0; }
+EXPORT struct S_FDF f18_S_SPI_FDF(struct S_FDF p0, void* p1, int p2) { return p0; }
+EXPORT struct S_FDD f18_S_SPI_FDD(struct S_FDD p0, void* p1, int p2) { return p0; }
+EXPORT struct S_FDP f18_S_SPI_FDP(struct S_FDP p0, void* p1, int p2) { return p0; }
+EXPORT struct S_FPI f18_S_SPI_FPI(struct S_FPI p0, void* p1, int p2) { return p0; }
+EXPORT struct S_FPF f18_S_SPI_FPF(struct S_FPF p0, void* p1, int p2) { return p0; }
+EXPORT struct S_FPD f18_S_SPI_FPD(struct S_FPD p0, void* p1, int p2) { return p0; }
+EXPORT struct S_FPP f18_S_SPI_FPP(struct S_FPP p0, void* p1, int p2) { return p0; }
+EXPORT struct S_DII f18_S_SPI_DII(struct S_DII p0, void* p1, int p2) { return p0; }
+EXPORT struct S_DIF f18_S_SPI_DIF(struct S_DIF p0, void* p1, int p2) { return p0; }
+EXPORT struct S_DID f18_S_SPI_DID(struct S_DID p0, void* p1, int p2) { return p0; }
+EXPORT struct S_DIP f18_S_SPI_DIP(struct S_DIP p0, void* p1, int p2) { return p0; }
+EXPORT struct S_DFI f18_S_SPI_DFI(struct S_DFI p0, void* p1, int p2) { return p0; }
+EXPORT struct S_DFF f18_S_SPI_DFF(struct S_DFF p0, void* p1, int p2) { return p0; }
+EXPORT struct S_DFD f18_S_SPI_DFD(struct S_DFD p0, void* p1, int p2) { return p0; }
+EXPORT struct S_DFP f18_S_SPI_DFP(struct S_DFP p0, void* p1, int p2) { return p0; }
+EXPORT struct S_DDI f18_S_SPI_DDI(struct S_DDI p0, void* p1, int p2) { return p0; }
+EXPORT struct S_DDF f18_S_SPI_DDF(struct S_DDF p0, void* p1, int p2) { return p0; }
+EXPORT struct S_DDD f18_S_SPI_DDD(struct S_DDD p0, void* p1, int p2) { return p0; }
+EXPORT struct S_DDP f18_S_SPI_DDP(struct S_DDP p0, void* p1, int p2) { return p0; }
+EXPORT struct S_DPI f18_S_SPI_DPI(struct S_DPI p0, void* p1, int p2) { return p0; }
+EXPORT struct S_DPF f18_S_SPI_DPF(struct S_DPF p0, void* p1, int p2) { return p0; }
+EXPORT struct S_DPD f18_S_SPI_DPD(struct S_DPD p0, void* p1, int p2) { return p0; }
+EXPORT struct S_DPP f18_S_SPI_DPP(struct S_DPP p0, void* p1, int p2) { return p0; }
+EXPORT struct S_PII f18_S_SPI_PII(struct S_PII p0, void* p1, int p2) { return p0; }
+EXPORT struct S_PIF f18_S_SPI_PIF(struct S_PIF p0, void* p1, int p2) { return p0; }
+EXPORT struct S_PID f18_S_SPI_PID(struct S_PID p0, void* p1, int p2) { return p0; }
+EXPORT struct S_PIP f18_S_SPI_PIP(struct S_PIP p0, void* p1, int p2) { return p0; }
+EXPORT struct S_PFI f18_S_SPI_PFI(struct S_PFI p0, void* p1, int p2) { return p0; }
+EXPORT struct S_PFF f18_S_SPI_PFF(struct S_PFF p0, void* p1, int p2) { return p0; }
+EXPORT struct S_PFD f18_S_SPI_PFD(struct S_PFD p0, void* p1, int p2) { return p0; }
+EXPORT struct S_PFP f18_S_SPI_PFP(struct S_PFP p0, void* p1, int p2) { return p0; }
+EXPORT struct S_PDI f18_S_SPI_PDI(struct S_PDI p0, void* p1, int p2) { return p0; }
+EXPORT struct S_PDF f18_S_SPI_PDF(struct S_PDF p0, void* p1, int p2) { return p0; }
+EXPORT struct S_PDD f18_S_SPI_PDD(struct S_PDD p0, void* p1, int p2) { return p0; }
+EXPORT struct S_PDP f18_S_SPI_PDP(struct S_PDP p0, void* p1, int p2) { return p0; }
+EXPORT struct S_PPI f18_S_SPI_PPI(struct S_PPI p0, void* p1, int p2) { return p0; }
+EXPORT struct S_PPF f18_S_SPI_PPF(struct S_PPF p0, void* p1, int p2) { return p0; }
+EXPORT struct S_PPD f18_S_SPI_PPD(struct S_PPD p0, void* p1, int p2) { return p0; }
+EXPORT struct S_PPP f18_S_SPI_PPP(struct S_PPP p0, void* p1, int p2) { return p0; }
+EXPORT struct S_I f18_S_SPF_I(struct S_I p0, void* p1, float p2) { return p0; }
+EXPORT struct S_F f18_S_SPF_F(struct S_F p0, void* p1, float p2) { return p0; }
+EXPORT struct S_D f18_S_SPF_D(struct S_D p0, void* p1, float p2) { return p0; }
+EXPORT struct S_P f18_S_SPF_P(struct S_P p0, void* p1, float p2) { return p0; }
+EXPORT struct S_II f18_S_SPF_II(struct S_II p0, void* p1, float p2) { return p0; }
+EXPORT struct S_IF f18_S_SPF_IF(struct S_IF p0, void* p1, float p2) { return p0; }
+EXPORT struct S_ID f18_S_SPF_ID(struct S_ID p0, void* p1, float p2) { return p0; }
+EXPORT struct S_IP f18_S_SPF_IP(struct S_IP p0, void* p1, float p2) { return p0; }
+EXPORT struct S_FI f18_S_SPF_FI(struct S_FI p0, void* p1, float p2) { return p0; }
+EXPORT struct S_FF f18_S_SPF_FF(struct S_FF p0, void* p1, float p2) { return p0; }
+EXPORT struct S_FD f18_S_SPF_FD(struct S_FD p0, void* p1, float p2) { return p0; }
+EXPORT struct S_FP f18_S_SPF_FP(struct S_FP p0, void* p1, float p2) { return p0; }
+EXPORT struct S_DI f18_S_SPF_DI(struct S_DI p0, void* p1, float p2) { return p0; }
+EXPORT struct S_DF f18_S_SPF_DF(struct S_DF p0, void* p1, float p2) { return p0; }
+EXPORT struct S_DD f18_S_SPF_DD(struct S_DD p0, void* p1, float p2) { return p0; }
+EXPORT struct S_DP f18_S_SPF_DP(struct S_DP p0, void* p1, float p2) { return p0; }
+EXPORT struct S_PI f18_S_SPF_PI(struct S_PI p0, void* p1, float p2) { return p0; }
+EXPORT struct S_PF f18_S_SPF_PF(struct S_PF p0, void* p1, float p2) { return p0; }
+EXPORT struct S_PD f18_S_SPF_PD(struct S_PD p0, void* p1, float p2) { return p0; }
+EXPORT struct S_PP f18_S_SPF_PP(struct S_PP p0, void* p1, float p2) { return p0; }
+EXPORT struct S_III f18_S_SPF_III(struct S_III p0, void* p1, float p2) { return p0; }
+EXPORT struct S_IIF f18_S_SPF_IIF(struct S_IIF p0, void* p1, float p2) { return p0; }
+EXPORT struct S_IID f18_S_SPF_IID(struct S_IID p0, void* p1, float p2) { return p0; }
+EXPORT struct S_IIP f18_S_SPF_IIP(struct S_IIP p0, void* p1, float p2) { return p0; }
+EXPORT struct S_IFI f18_S_SPF_IFI(struct S_IFI p0, void* p1, float p2) { return p0; }
+EXPORT struct S_IFF f18_S_SPF_IFF(struct S_IFF p0, void* p1, float p2) { return p0; }
+EXPORT struct S_IFD f18_S_SPF_IFD(struct S_IFD p0, void* p1, float p2) { return p0; }
+EXPORT struct S_IFP f18_S_SPF_IFP(struct S_IFP p0, void* p1, float p2) { return p0; }
+EXPORT struct S_IDI f18_S_SPF_IDI(struct S_IDI p0, void* p1, float p2) { return p0; }
+EXPORT struct S_IDF f18_S_SPF_IDF(struct S_IDF p0, void* p1, float p2) { return p0; }
+EXPORT struct S_IDD f18_S_SPF_IDD(struct S_IDD p0, void* p1, float p2) { return p0; }
+EXPORT struct S_IDP f18_S_SPF_IDP(struct S_IDP p0, void* p1, float p2) { return p0; }
+EXPORT struct S_IPI f18_S_SPF_IPI(struct S_IPI p0, void* p1, float p2) { return p0; }
+EXPORT struct S_IPF f18_S_SPF_IPF(struct S_IPF p0, void* p1, float p2) { return p0; }
+EXPORT struct S_IPD f18_S_SPF_IPD(struct S_IPD p0, void* p1, float p2) { return p0; }
+EXPORT struct S_IPP f18_S_SPF_IPP(struct S_IPP p0, void* p1, float p2) { return p0; }
+EXPORT struct S_FII f18_S_SPF_FII(struct S_FII p0, void* p1, float p2) { return p0; }
+EXPORT struct S_FIF f18_S_SPF_FIF(struct S_FIF p0, void* p1, float p2) { return p0; }
+EXPORT struct S_FID f18_S_SPF_FID(struct S_FID p0, void* p1, float p2) { return p0; }
+EXPORT struct S_FIP f18_S_SPF_FIP(struct S_FIP p0, void* p1, float p2) { return p0; }
+EXPORT struct S_FFI f18_S_SPF_FFI(struct S_FFI p0, void* p1, float p2) { return p0; }
+EXPORT struct S_FFF f18_S_SPF_FFF(struct S_FFF p0, void* p1, float p2) { return p0; }
+EXPORT struct S_FFD f18_S_SPF_FFD(struct S_FFD p0, void* p1, float p2) { return p0; }
+EXPORT struct S_FFP f18_S_SPF_FFP(struct S_FFP p0, void* p1, float p2) { return p0; }
+EXPORT struct S_FDI f18_S_SPF_FDI(struct S_FDI p0, void* p1, float p2) { return p0; }
+EXPORT struct S_FDF f18_S_SPF_FDF(struct S_FDF p0, void* p1, float p2) { return p0; }
+EXPORT struct S_FDD f18_S_SPF_FDD(struct S_FDD p0, void* p1, float p2) { return p0; }
+EXPORT struct S_FDP f18_S_SPF_FDP(struct S_FDP p0, void* p1, float p2) { return p0; }
+EXPORT struct S_FPI f18_S_SPF_FPI(struct S_FPI p0, void* p1, float p2) { return p0; }
+EXPORT struct S_FPF f18_S_SPF_FPF(struct S_FPF p0, void* p1, float p2) { return p0; }
+EXPORT struct S_FPD f18_S_SPF_FPD(struct S_FPD p0, void* p1, float p2) { return p0; }
+EXPORT struct S_FPP f18_S_SPF_FPP(struct S_FPP p0, void* p1, float p2) { return p0; }
+EXPORT struct S_DII f18_S_SPF_DII(struct S_DII p0, void* p1, float p2) { return p0; }
+EXPORT struct S_DIF f18_S_SPF_DIF(struct S_DIF p0, void* p1, float p2) { return p0; }
+EXPORT struct S_DID f18_S_SPF_DID(struct S_DID p0, void* p1, float p2) { return p0; }
+EXPORT struct S_DIP f18_S_SPF_DIP(struct S_DIP p0, void* p1, float p2) { return p0; }
+EXPORT struct S_DFI f18_S_SPF_DFI(struct S_DFI p0, void* p1, float p2) { return p0; }
+EXPORT struct S_DFF f18_S_SPF_DFF(struct S_DFF p0, void* p1, float p2) { return p0; }
+EXPORT struct S_DFD f18_S_SPF_DFD(struct S_DFD p0, void* p1, float p2) { return p0; }
+EXPORT struct S_DFP f19_S_SPF_DFP(struct S_DFP p0, void* p1, float p2) { return p0; }
+EXPORT struct S_DDI f19_S_SPF_DDI(struct S_DDI p0, void* p1, float p2) { return p0; }
+EXPORT struct S_DDF f19_S_SPF_DDF(struct S_DDF p0, void* p1, float p2) { return p0; }
+EXPORT struct S_DDD f19_S_SPF_DDD(struct S_DDD p0, void* p1, float p2) { return p0; }
+EXPORT struct S_DDP f19_S_SPF_DDP(struct S_DDP p0, void* p1, float p2) { return p0; }
+EXPORT struct S_DPI f19_S_SPF_DPI(struct S_DPI p0, void* p1, float p2) { return p0; }
+EXPORT struct S_DPF f19_S_SPF_DPF(struct S_DPF p0, void* p1, float p2) { return p0; }
+EXPORT struct S_DPD f19_S_SPF_DPD(struct S_DPD p0, void* p1, float p2) { return p0; }
+EXPORT struct S_DPP f19_S_SPF_DPP(struct S_DPP p0, void* p1, float p2) { return p0; }
+EXPORT struct S_PII f19_S_SPF_PII(struct S_PII p0, void* p1, float p2) { return p0; }
+EXPORT struct S_PIF f19_S_SPF_PIF(struct S_PIF p0, void* p1, float p2) { return p0; }
+EXPORT struct S_PID f19_S_SPF_PID(struct S_PID p0, void* p1, float p2) { return p0; }
+EXPORT struct S_PIP f19_S_SPF_PIP(struct S_PIP p0, void* p1, float p2) { return p0; }
+EXPORT struct S_PFI f19_S_SPF_PFI(struct S_PFI p0, void* p1, float p2) { return p0; }
+EXPORT struct S_PFF f19_S_SPF_PFF(struct S_PFF p0, void* p1, float p2) { return p0; }
+EXPORT struct S_PFD f19_S_SPF_PFD(struct S_PFD p0, void* p1, float p2) { return p0; }
+EXPORT struct S_PFP f19_S_SPF_PFP(struct S_PFP p0, void* p1, float p2) { return p0; }
+EXPORT struct S_PDI f19_S_SPF_PDI(struct S_PDI p0, void* p1, float p2) { return p0; }
+EXPORT struct S_PDF f19_S_SPF_PDF(struct S_PDF p0, void* p1, float p2) { return p0; }
+EXPORT struct S_PDD f19_S_SPF_PDD(struct S_PDD p0, void* p1, float p2) { return p0; }
+EXPORT struct S_PDP f19_S_SPF_PDP(struct S_PDP p0, void* p1, float p2) { return p0; }
+EXPORT struct S_PPI f19_S_SPF_PPI(struct S_PPI p0, void* p1, float p2) { return p0; }
+EXPORT struct S_PPF f19_S_SPF_PPF(struct S_PPF p0, void* p1, float p2) { return p0; }
+EXPORT struct S_PPD f19_S_SPF_PPD(struct S_PPD p0, void* p1, float p2) { return p0; }
+EXPORT struct S_PPP f19_S_SPF_PPP(struct S_PPP p0, void* p1, float p2) { return p0; }
+EXPORT struct S_I f19_S_SPD_I(struct S_I p0, void* p1, double p2) { return p0; }
+EXPORT struct S_F f19_S_SPD_F(struct S_F p0, void* p1, double p2) { return p0; }
+EXPORT struct S_D f19_S_SPD_D(struct S_D p0, void* p1, double p2) { return p0; }
+EXPORT struct S_P f19_S_SPD_P(struct S_P p0, void* p1, double p2) { return p0; }
+EXPORT struct S_II f19_S_SPD_II(struct S_II p0, void* p1, double p2) { return p0; }
+EXPORT struct S_IF f19_S_SPD_IF(struct S_IF p0, void* p1, double p2) { return p0; }
+EXPORT struct S_ID f19_S_SPD_ID(struct S_ID p0, void* p1, double p2) { return p0; }
+EXPORT struct S_IP f19_S_SPD_IP(struct S_IP p0, void* p1, double p2) { return p0; }
+EXPORT struct S_FI f19_S_SPD_FI(struct S_FI p0, void* p1, double p2) { return p0; }
+EXPORT struct S_FF f19_S_SPD_FF(struct S_FF p0, void* p1, double p2) { return p0; }
+EXPORT struct S_FD f19_S_SPD_FD(struct S_FD p0, void* p1, double p2) { return p0; }
+EXPORT struct S_FP f19_S_SPD_FP(struct S_FP p0, void* p1, double p2) { return p0; }
+EXPORT struct S_DI f19_S_SPD_DI(struct S_DI p0, void* p1, double p2) { return p0; }
+EXPORT struct S_DF f19_S_SPD_DF(struct S_DF p0, void* p1, double p2) { return p0; }
+EXPORT struct S_DD f19_S_SPD_DD(struct S_DD p0, void* p1, double p2) { return p0; }
+EXPORT struct S_DP f19_S_SPD_DP(struct S_DP p0, void* p1, double p2) { return p0; }
+EXPORT struct S_PI f19_S_SPD_PI(struct S_PI p0, void* p1, double p2) { return p0; }
+EXPORT struct S_PF f19_S_SPD_PF(struct S_PF p0, void* p1, double p2) { return p0; }
+EXPORT struct S_PD f19_S_SPD_PD(struct S_PD p0, void* p1, double p2) { return p0; }
+EXPORT struct S_PP f19_S_SPD_PP(struct S_PP p0, void* p1, double p2) { return p0; }
+EXPORT struct S_III f19_S_SPD_III(struct S_III p0, void* p1, double p2) { return p0; }
+EXPORT struct S_IIF f19_S_SPD_IIF(struct S_IIF p0, void* p1, double p2) { return p0; }
+EXPORT struct S_IID f19_S_SPD_IID(struct S_IID p0, void* p1, double p2) { return p0; }
+EXPORT struct S_IIP f19_S_SPD_IIP(struct S_IIP p0, void* p1, double p2) { return p0; }
+EXPORT struct S_IFI f19_S_SPD_IFI(struct S_IFI p0, void* p1, double p2) { return p0; }
+EXPORT struct S_IFF f19_S_SPD_IFF(struct S_IFF p0, void* p1, double p2) { return p0; }
+EXPORT struct S_IFD f19_S_SPD_IFD(struct S_IFD p0, void* p1, double p2) { return p0; }
+EXPORT struct S_IFP f19_S_SPD_IFP(struct S_IFP p0, void* p1, double p2) { return p0; }
+EXPORT struct S_IDI f19_S_SPD_IDI(struct S_IDI p0, void* p1, double p2) { return p0; }
+EXPORT struct S_IDF f19_S_SPD_IDF(struct S_IDF p0, void* p1, double p2) { return p0; }
+EXPORT struct S_IDD f19_S_SPD_IDD(struct S_IDD p0, void* p1, double p2) { return p0; }
+EXPORT struct S_IDP f19_S_SPD_IDP(struct S_IDP p0, void* p1, double p2) { return p0; }
+EXPORT struct S_IPI f19_S_SPD_IPI(struct S_IPI p0, void* p1, double p2) { return p0; }
+EXPORT struct S_IPF f19_S_SPD_IPF(struct S_IPF p0, void* p1, double p2) { return p0; }
+EXPORT struct S_IPD f19_S_SPD_IPD(struct S_IPD p0, void* p1, double p2) { return p0; }
+EXPORT struct S_IPP f19_S_SPD_IPP(struct S_IPP p0, void* p1, double p2) { return p0; }
+EXPORT struct S_FII f19_S_SPD_FII(struct S_FII p0, void* p1, double p2) { return p0; }
+EXPORT struct S_FIF f19_S_SPD_FIF(struct S_FIF p0, void* p1, double p2) { return p0; }
+EXPORT struct S_FID f19_S_SPD_FID(struct S_FID p0, void* p1, double p2) { return p0; }
+EXPORT struct S_FIP f19_S_SPD_FIP(struct S_FIP p0, void* p1, double p2) { return p0; }
+EXPORT struct S_FFI f19_S_SPD_FFI(struct S_FFI p0, void* p1, double p2) { return p0; }
+EXPORT struct S_FFF f19_S_SPD_FFF(struct S_FFF p0, void* p1, double p2) { return p0; }
+EXPORT struct S_FFD f19_S_SPD_FFD(struct S_FFD p0, void* p1, double p2) { return p0; }
+EXPORT struct S_FFP f19_S_SPD_FFP(struct S_FFP p0, void* p1, double p2) { return p0; }
+EXPORT struct S_FDI f19_S_SPD_FDI(struct S_FDI p0, void* p1, double p2) { return p0; }
+EXPORT struct S_FDF f19_S_SPD_FDF(struct S_FDF p0, void* p1, double p2) { return p0; }
+EXPORT struct S_FDD f19_S_SPD_FDD(struct S_FDD p0, void* p1, double p2) { return p0; }
+EXPORT struct S_FDP f19_S_SPD_FDP(struct S_FDP p0, void* p1, double p2) { return p0; }
+EXPORT struct S_FPI f19_S_SPD_FPI(struct S_FPI p0, void* p1, double p2) { return p0; }
+EXPORT struct S_FPF f19_S_SPD_FPF(struct S_FPF p0, void* p1, double p2) { return p0; }
+EXPORT struct S_FPD f19_S_SPD_FPD(struct S_FPD p0, void* p1, double p2) { return p0; }
+EXPORT struct S_FPP f19_S_SPD_FPP(struct S_FPP p0, void* p1, double p2) { return p0; }
+EXPORT struct S_DII f19_S_SPD_DII(struct S_DII p0, void* p1, double p2) { return p0; }
+EXPORT struct S_DIF f19_S_SPD_DIF(struct S_DIF p0, void* p1, double p2) { return p0; }
+EXPORT struct S_DID f19_S_SPD_DID(struct S_DID p0, void* p1, double p2) { return p0; }
+EXPORT struct S_DIP f19_S_SPD_DIP(struct S_DIP p0, void* p1, double p2) { return p0; }
+EXPORT struct S_DFI f19_S_SPD_DFI(struct S_DFI p0, void* p1, double p2) { return p0; }
+EXPORT struct S_DFF f19_S_SPD_DFF(struct S_DFF p0, void* p1, double p2) { return p0; }
+EXPORT struct S_DFD f19_S_SPD_DFD(struct S_DFD p0, void* p1, double p2) { return p0; }
+EXPORT struct S_DFP f19_S_SPD_DFP(struct S_DFP p0, void* p1, double p2) { return p0; }
+EXPORT struct S_DDI f19_S_SPD_DDI(struct S_DDI p0, void* p1, double p2) { return p0; }
+EXPORT struct S_DDF f19_S_SPD_DDF(struct S_DDF p0, void* p1, double p2) { return p0; }
+EXPORT struct S_DDD f19_S_SPD_DDD(struct S_DDD p0, void* p1, double p2) { return p0; }
+EXPORT struct S_DDP f19_S_SPD_DDP(struct S_DDP p0, void* p1, double p2) { return p0; }
+EXPORT struct S_DPI f19_S_SPD_DPI(struct S_DPI p0, void* p1, double p2) { return p0; }
+EXPORT struct S_DPF f19_S_SPD_DPF(struct S_DPF p0, void* p1, double p2) { return p0; }
+EXPORT struct S_DPD f19_S_SPD_DPD(struct S_DPD p0, void* p1, double p2) { return p0; }
+EXPORT struct S_DPP f19_S_SPD_DPP(struct S_DPP p0, void* p1, double p2) { return p0; }
+EXPORT struct S_PII f19_S_SPD_PII(struct S_PII p0, void* p1, double p2) { return p0; }
+EXPORT struct S_PIF f19_S_SPD_PIF(struct S_PIF p0, void* p1, double p2) { return p0; }
+EXPORT struct S_PID f19_S_SPD_PID(struct S_PID p0, void* p1, double p2) { return p0; }
+EXPORT struct S_PIP f19_S_SPD_PIP(struct S_PIP p0, void* p1, double p2) { return p0; }
+EXPORT struct S_PFI f19_S_SPD_PFI(struct S_PFI p0, void* p1, double p2) { return p0; }
+EXPORT struct S_PFF f19_S_SPD_PFF(struct S_PFF p0, void* p1, double p2) { return p0; }
+EXPORT struct S_PFD f19_S_SPD_PFD(struct S_PFD p0, void* p1, double p2) { return p0; }
+EXPORT struct S_PFP f19_S_SPD_PFP(struct S_PFP p0, void* p1, double p2) { return p0; }
+EXPORT struct S_PDI f19_S_SPD_PDI(struct S_PDI p0, void* p1, double p2) { return p0; }
+EXPORT struct S_PDF f19_S_SPD_PDF(struct S_PDF p0, void* p1, double p2) { return p0; }
+EXPORT struct S_PDD f19_S_SPD_PDD(struct S_PDD p0, void* p1, double p2) { return p0; }
+EXPORT struct S_PDP f19_S_SPD_PDP(struct S_PDP p0, void* p1, double p2) { return p0; }
+EXPORT struct S_PPI f19_S_SPD_PPI(struct S_PPI p0, void* p1, double p2) { return p0; }
+EXPORT struct S_PPF f19_S_SPD_PPF(struct S_PPF p0, void* p1, double p2) { return p0; }
+EXPORT struct S_PPD f19_S_SPD_PPD(struct S_PPD p0, void* p1, double p2) { return p0; }
+EXPORT struct S_PPP f19_S_SPD_PPP(struct S_PPP p0, void* p1, double p2) { return p0; }
+EXPORT struct S_I f19_S_SPP_I(struct S_I p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_F f19_S_SPP_F(struct S_F p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_D f19_S_SPP_D(struct S_D p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_P f19_S_SPP_P(struct S_P p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_II f19_S_SPP_II(struct S_II p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_IF f19_S_SPP_IF(struct S_IF p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_ID f19_S_SPP_ID(struct S_ID p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_IP f19_S_SPP_IP(struct S_IP p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_FI f19_S_SPP_FI(struct S_FI p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_FF f19_S_SPP_FF(struct S_FF p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_FD f19_S_SPP_FD(struct S_FD p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_FP f19_S_SPP_FP(struct S_FP p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_DI f19_S_SPP_DI(struct S_DI p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_DF f19_S_SPP_DF(struct S_DF p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_DD f19_S_SPP_DD(struct S_DD p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_DP f19_S_SPP_DP(struct S_DP p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_PI f19_S_SPP_PI(struct S_PI p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_PF f19_S_SPP_PF(struct S_PF p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_PD f19_S_SPP_PD(struct S_PD p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_PP f19_S_SPP_PP(struct S_PP p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_III f19_S_SPP_III(struct S_III p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_IIF f19_S_SPP_IIF(struct S_IIF p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_IID f19_S_SPP_IID(struct S_IID p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_IIP f19_S_SPP_IIP(struct S_IIP p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_IFI f19_S_SPP_IFI(struct S_IFI p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_IFF f19_S_SPP_IFF(struct S_IFF p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_IFD f19_S_SPP_IFD(struct S_IFD p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_IFP f19_S_SPP_IFP(struct S_IFP p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_IDI f19_S_SPP_IDI(struct S_IDI p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_IDF f19_S_SPP_IDF(struct S_IDF p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_IDD f19_S_SPP_IDD(struct S_IDD p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_IDP f19_S_SPP_IDP(struct S_IDP p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_IPI f19_S_SPP_IPI(struct S_IPI p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_IPF f19_S_SPP_IPF(struct S_IPF p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_IPD f19_S_SPP_IPD(struct S_IPD p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_IPP f19_S_SPP_IPP(struct S_IPP p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_FII f19_S_SPP_FII(struct S_FII p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_FIF f19_S_SPP_FIF(struct S_FIF p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_FID f19_S_SPP_FID(struct S_FID p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_FIP f19_S_SPP_FIP(struct S_FIP p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_FFI f19_S_SPP_FFI(struct S_FFI p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_FFF f19_S_SPP_FFF(struct S_FFF p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_FFD f19_S_SPP_FFD(struct S_FFD p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_FFP f19_S_SPP_FFP(struct S_FFP p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_FDI f19_S_SPP_FDI(struct S_FDI p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_FDF f19_S_SPP_FDF(struct S_FDF p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_FDD f19_S_SPP_FDD(struct S_FDD p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_FDP f19_S_SPP_FDP(struct S_FDP p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_FPI f19_S_SPP_FPI(struct S_FPI p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_FPF f19_S_SPP_FPF(struct S_FPF p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_FPD f19_S_SPP_FPD(struct S_FPD p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_FPP f19_S_SPP_FPP(struct S_FPP p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_DII f19_S_SPP_DII(struct S_DII p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_DIF f19_S_SPP_DIF(struct S_DIF p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_DID f19_S_SPP_DID(struct S_DID p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_DIP f19_S_SPP_DIP(struct S_DIP p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_DFI f19_S_SPP_DFI(struct S_DFI p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_DFF f19_S_SPP_DFF(struct S_DFF p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_DFD f19_S_SPP_DFD(struct S_DFD p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_DFP f19_S_SPP_DFP(struct S_DFP p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_DDI f19_S_SPP_DDI(struct S_DDI p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_DDF f19_S_SPP_DDF(struct S_DDF p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_DDD f19_S_SPP_DDD(struct S_DDD p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_DDP f19_S_SPP_DDP(struct S_DDP p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_DPI f19_S_SPP_DPI(struct S_DPI p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_DPF f19_S_SPP_DPF(struct S_DPF p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_DPD f19_S_SPP_DPD(struct S_DPD p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_DPP f19_S_SPP_DPP(struct S_DPP p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_PII f19_S_SPP_PII(struct S_PII p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_PIF f19_S_SPP_PIF(struct S_PIF p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_PID f19_S_SPP_PID(struct S_PID p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_PIP f19_S_SPP_PIP(struct S_PIP p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_PFI f19_S_SPP_PFI(struct S_PFI p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_PFF f19_S_SPP_PFF(struct S_PFF p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_PFD f19_S_SPP_PFD(struct S_PFD p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_PFP f19_S_SPP_PFP(struct S_PFP p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_PDI f19_S_SPP_PDI(struct S_PDI p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_PDF f19_S_SPP_PDF(struct S_PDF p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_PDD f19_S_SPP_PDD(struct S_PDD p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_PDP f19_S_SPP_PDP(struct S_PDP p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_PPI f19_S_SPP_PPI(struct S_PPI p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_PPF f19_S_SPP_PPF(struct S_PPF p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_PPD f19_S_SPP_PPD(struct S_PPD p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_PPP f19_S_SPP_PPP(struct S_PPP p0, void* p1, void* p2) { return p0; }
+EXPORT struct S_I f19_S_SPS_I(struct S_I p0, void* p1, struct S_I p2) { return p0; }
+EXPORT struct S_F f19_S_SPS_F(struct S_F p0, void* p1, struct S_F p2) { return p0; }
+EXPORT struct S_D f19_S_SPS_D(struct S_D p0, void* p1, struct S_D p2) { return p0; }
+EXPORT struct S_P f19_S_SPS_P(struct S_P p0, void* p1, struct S_P p2) { return p0; }
+EXPORT struct S_II f19_S_SPS_II(struct S_II p0, void* p1, struct S_II p2) { return p0; }
+EXPORT struct S_IF f19_S_SPS_IF(struct S_IF p0, void* p1, struct S_IF p2) { return p0; }
+EXPORT struct S_ID f19_S_SPS_ID(struct S_ID p0, void* p1, struct S_ID p2) { return p0; }
+EXPORT struct S_IP f19_S_SPS_IP(struct S_IP p0, void* p1, struct S_IP p2) { return p0; }
+EXPORT struct S_FI f19_S_SPS_FI(struct S_FI p0, void* p1, struct S_FI p2) { return p0; }
+EXPORT struct S_FF f19_S_SPS_FF(struct S_FF p0, void* p1, struct S_FF p2) { return p0; }
+EXPORT struct S_FD f19_S_SPS_FD(struct S_FD p0, void* p1, struct S_FD p2) { return p0; }
+EXPORT struct S_FP f19_S_SPS_FP(struct S_FP p0, void* p1, struct S_FP p2) { return p0; }
+EXPORT struct S_DI f19_S_SPS_DI(struct S_DI p0, void* p1, struct S_DI p2) { return p0; }
+EXPORT struct S_DF f19_S_SPS_DF(struct S_DF p0, void* p1, struct S_DF p2) { return p0; }
+EXPORT struct S_DD f19_S_SPS_DD(struct S_DD p0, void* p1, struct S_DD p2) { return p0; }
+EXPORT struct S_DP f19_S_SPS_DP(struct S_DP p0, void* p1, struct S_DP p2) { return p0; }
+EXPORT struct S_PI f19_S_SPS_PI(struct S_PI p0, void* p1, struct S_PI p2) { return p0; }
+EXPORT struct S_PF f19_S_SPS_PF(struct S_PF p0, void* p1, struct S_PF p2) { return p0; }
+EXPORT struct S_PD f19_S_SPS_PD(struct S_PD p0, void* p1, struct S_PD p2) { return p0; }
+EXPORT struct S_PP f19_S_SPS_PP(struct S_PP p0, void* p1, struct S_PP p2) { return p0; }
+EXPORT struct S_III f19_S_SPS_III(struct S_III p0, void* p1, struct S_III p2) { return p0; }
+EXPORT struct S_IIF f19_S_SPS_IIF(struct S_IIF p0, void* p1, struct S_IIF p2) { return p0; }
+EXPORT struct S_IID f19_S_SPS_IID(struct S_IID p0, void* p1, struct S_IID p2) { return p0; }
+EXPORT struct S_IIP f19_S_SPS_IIP(struct S_IIP p0, void* p1, struct S_IIP p2) { return p0; }
+EXPORT struct S_IFI f19_S_SPS_IFI(struct S_IFI p0, void* p1, struct S_IFI p2) { return p0; }
+EXPORT struct S_IFF f19_S_SPS_IFF(struct S_IFF p0, void* p1, struct S_IFF p2) { return p0; }
+EXPORT struct S_IFD f19_S_SPS_IFD(struct S_IFD p0, void* p1, struct S_IFD p2) { return p0; }
+EXPORT struct S_IFP f19_S_SPS_IFP(struct S_IFP p0, void* p1, struct S_IFP p2) { return p0; }
+EXPORT struct S_IDI f19_S_SPS_IDI(struct S_IDI p0, void* p1, struct S_IDI p2) { return p0; }
+EXPORT struct S_IDF f19_S_SPS_IDF(struct S_IDF p0, void* p1, struct S_IDF p2) { return p0; }
+EXPORT struct S_IDD f19_S_SPS_IDD(struct S_IDD p0, void* p1, struct S_IDD p2) { return p0; }
+EXPORT struct S_IDP f19_S_SPS_IDP(struct S_IDP p0, void* p1, struct S_IDP p2) { return p0; }
+EXPORT struct S_IPI f19_S_SPS_IPI(struct S_IPI p0, void* p1, struct S_IPI p2) { return p0; }
+EXPORT struct S_IPF f19_S_SPS_IPF(struct S_IPF p0, void* p1, struct S_IPF p2) { return p0; }
+EXPORT struct S_IPD f19_S_SPS_IPD(struct S_IPD p0, void* p1, struct S_IPD p2) { return p0; }
+EXPORT struct S_IPP f19_S_SPS_IPP(struct S_IPP p0, void* p1, struct S_IPP p2) { return p0; }
+EXPORT struct S_FII f19_S_SPS_FII(struct S_FII p0, void* p1, struct S_FII p2) { return p0; }
+EXPORT struct S_FIF f19_S_SPS_FIF(struct S_FIF p0, void* p1, struct S_FIF p2) { return p0; }
+EXPORT struct S_FID f19_S_SPS_FID(struct S_FID p0, void* p1, struct S_FID p2) { return p0; }
+EXPORT struct S_FIP f19_S_SPS_FIP(struct S_FIP p0, void* p1, struct S_FIP p2) { return p0; }
+EXPORT struct S_FFI f19_S_SPS_FFI(struct S_FFI p0, void* p1, struct S_FFI p2) { return p0; }
+EXPORT struct S_FFF f19_S_SPS_FFF(struct S_FFF p0, void* p1, struct S_FFF p2) { return p0; }
+EXPORT struct S_FFD f19_S_SPS_FFD(struct S_FFD p0, void* p1, struct S_FFD p2) { return p0; }
+EXPORT struct S_FFP f19_S_SPS_FFP(struct S_FFP p0, void* p1, struct S_FFP p2) { return p0; }
+EXPORT struct S_FDI f19_S_SPS_FDI(struct S_FDI p0, void* p1, struct S_FDI p2) { return p0; }
+EXPORT struct S_FDF f19_S_SPS_FDF(struct S_FDF p0, void* p1, struct S_FDF p2) { return p0; }
+EXPORT struct S_FDD f19_S_SPS_FDD(struct S_FDD p0, void* p1, struct S_FDD p2) { return p0; }
+EXPORT struct S_FDP f19_S_SPS_FDP(struct S_FDP p0, void* p1, struct S_FDP p2) { return p0; }
+EXPORT struct S_FPI f19_S_SPS_FPI(struct S_FPI p0, void* p1, struct S_FPI p2) { return p0; }
+EXPORT struct S_FPF f19_S_SPS_FPF(struct S_FPF p0, void* p1, struct S_FPF p2) { return p0; }
+EXPORT struct S_FPD f19_S_SPS_FPD(struct S_FPD p0, void* p1, struct S_FPD p2) { return p0; }
+EXPORT struct S_FPP f19_S_SPS_FPP(struct S_FPP p0, void* p1, struct S_FPP p2) { return p0; }
+EXPORT struct S_DII f19_S_SPS_DII(struct S_DII p0, void* p1, struct S_DII p2) { return p0; }
+EXPORT struct S_DIF f19_S_SPS_DIF(struct S_DIF p0, void* p1, struct S_DIF p2) { return p0; }
+EXPORT struct S_DID f19_S_SPS_DID(struct S_DID p0, void* p1, struct S_DID p2) { return p0; }
+EXPORT struct S_DIP f19_S_SPS_DIP(struct S_DIP p0, void* p1, struct S_DIP p2) { return p0; }
+EXPORT struct S_DFI f19_S_SPS_DFI(struct S_DFI p0, void* p1, struct S_DFI p2) { return p0; }
+EXPORT struct S_DFF f19_S_SPS_DFF(struct S_DFF p0, void* p1, struct S_DFF p2) { return p0; }
+EXPORT struct S_DFD f19_S_SPS_DFD(struct S_DFD p0, void* p1, struct S_DFD p2) { return p0; }
+EXPORT struct S_DFP f19_S_SPS_DFP(struct S_DFP p0, void* p1, struct S_DFP p2) { return p0; }
+EXPORT struct S_DDI f19_S_SPS_DDI(struct S_DDI p0, void* p1, struct S_DDI p2) { return p0; }
+EXPORT struct S_DDF f19_S_SPS_DDF(struct S_DDF p0, void* p1, struct S_DDF p2) { return p0; }
+EXPORT struct S_DDD f19_S_SPS_DDD(struct S_DDD p0, void* p1, struct S_DDD p2) { return p0; }
+EXPORT struct S_DDP f19_S_SPS_DDP(struct S_DDP p0, void* p1, struct S_DDP p2) { return p0; }
+EXPORT struct S_DPI f19_S_SPS_DPI(struct S_DPI p0, void* p1, struct S_DPI p2) { return p0; }
+EXPORT struct S_DPF f19_S_SPS_DPF(struct S_DPF p0, void* p1, struct S_DPF p2) { return p0; }
+EXPORT struct S_DPD f19_S_SPS_DPD(struct S_DPD p0, void* p1, struct S_DPD p2) { return p0; }
+EXPORT struct S_DPP f19_S_SPS_DPP(struct S_DPP p0, void* p1, struct S_DPP p2) { return p0; }
+EXPORT struct S_PII f19_S_SPS_PII(struct S_PII p0, void* p1, struct S_PII p2) { return p0; }
+EXPORT struct S_PIF f19_S_SPS_PIF(struct S_PIF p0, void* p1, struct S_PIF p2) { return p0; }
+EXPORT struct S_PID f19_S_SPS_PID(struct S_PID p0, void* p1, struct S_PID p2) { return p0; }
+EXPORT struct S_PIP f19_S_SPS_PIP(struct S_PIP p0, void* p1, struct S_PIP p2) { return p0; }
+EXPORT struct S_PFI f19_S_SPS_PFI(struct S_PFI p0, void* p1, struct S_PFI p2) { return p0; }
+EXPORT struct S_PFF f19_S_SPS_PFF(struct S_PFF p0, void* p1, struct S_PFF p2) { return p0; }
+EXPORT struct S_PFD f19_S_SPS_PFD(struct S_PFD p0, void* p1, struct S_PFD p2) { return p0; }
+EXPORT struct S_PFP f19_S_SPS_PFP(struct S_PFP p0, void* p1, struct S_PFP p2) { return p0; }
+EXPORT struct S_PDI f19_S_SPS_PDI(struct S_PDI p0, void* p1, struct S_PDI p2) { return p0; }
+EXPORT struct S_PDF f19_S_SPS_PDF(struct S_PDF p0, void* p1, struct S_PDF p2) { return p0; }
+EXPORT struct S_PDD f19_S_SPS_PDD(struct S_PDD p0, void* p1, struct S_PDD p2) { return p0; }
+EXPORT struct S_PDP f19_S_SPS_PDP(struct S_PDP p0, void* p1, struct S_PDP p2) { return p0; }
+EXPORT struct S_PPI f19_S_SPS_PPI(struct S_PPI p0, void* p1, struct S_PPI p2) { return p0; }
+EXPORT struct S_PPF f19_S_SPS_PPF(struct S_PPF p0, void* p1, struct S_PPF p2) { return p0; }
+EXPORT struct S_PPD f19_S_SPS_PPD(struct S_PPD p0, void* p1, struct S_PPD p2) { return p0; }
+EXPORT struct S_PPP f19_S_SPS_PPP(struct S_PPP p0, void* p1, struct S_PPP p2) { return p0; }
+EXPORT struct S_I f19_S_SSI_I(struct S_I p0, struct S_I p1, int p2) { return p0; }
+EXPORT struct S_F f19_S_SSI_F(struct S_F p0, struct S_F p1, int p2) { return p0; }
+EXPORT struct S_D f19_S_SSI_D(struct S_D p0, struct S_D p1, int p2) { return p0; }
+EXPORT struct S_P f19_S_SSI_P(struct S_P p0, struct S_P p1, int p2) { return p0; }
+EXPORT struct S_II f19_S_SSI_II(struct S_II p0, struct S_II p1, int p2) { return p0; }
+EXPORT struct S_IF f19_S_SSI_IF(struct S_IF p0, struct S_IF p1, int p2) { return p0; }
+EXPORT struct S_ID f19_S_SSI_ID(struct S_ID p0, struct S_ID p1, int p2) { return p0; }
+EXPORT struct S_IP f19_S_SSI_IP(struct S_IP p0, struct S_IP p1, int p2) { return p0; }
+EXPORT struct S_FI f19_S_SSI_FI(struct S_FI p0, struct S_FI p1, int p2) { return p0; }
+EXPORT struct S_FF f19_S_SSI_FF(struct S_FF p0, struct S_FF p1, int p2) { return p0; }
+EXPORT struct S_FD f19_S_SSI_FD(struct S_FD p0, struct S_FD p1, int p2) { return p0; }
+EXPORT struct S_FP f19_S_SSI_FP(struct S_FP p0, struct S_FP p1, int p2) { return p0; }
+EXPORT struct S_DI f19_S_SSI_DI(struct S_DI p0, struct S_DI p1, int p2) { return p0; }
+EXPORT struct S_DF f19_S_SSI_DF(struct S_DF p0, struct S_DF p1, int p2) { return p0; }
+EXPORT struct S_DD f19_S_SSI_DD(struct S_DD p0, struct S_DD p1, int p2) { return p0; }
+EXPORT struct S_DP f19_S_SSI_DP(struct S_DP p0, struct S_DP p1, int p2) { return p0; }
+EXPORT struct S_PI f19_S_SSI_PI(struct S_PI p0, struct S_PI p1, int p2) { return p0; }
+EXPORT struct S_PF f19_S_SSI_PF(struct S_PF p0, struct S_PF p1, int p2) { return p0; }
+EXPORT struct S_PD f19_S_SSI_PD(struct S_PD p0, struct S_PD p1, int p2) { return p0; }
+EXPORT struct S_PP f19_S_SSI_PP(struct S_PP p0, struct S_PP p1, int p2) { return p0; }
+EXPORT struct S_III f19_S_SSI_III(struct S_III p0, struct S_III p1, int p2) { return p0; }
+EXPORT struct S_IIF f19_S_SSI_IIF(struct S_IIF p0, struct S_IIF p1, int p2) { return p0; }
+EXPORT struct S_IID f19_S_SSI_IID(struct S_IID p0, struct S_IID p1, int p2) { return p0; }
+EXPORT struct S_IIP f19_S_SSI_IIP(struct S_IIP p0, struct S_IIP p1, int p2) { return p0; }
+EXPORT struct S_IFI f19_S_SSI_IFI(struct S_IFI p0, struct S_IFI p1, int p2) { return p0; }
+EXPORT struct S_IFF f19_S_SSI_IFF(struct S_IFF p0, struct S_IFF p1, int p2) { return p0; }
+EXPORT struct S_IFD f19_S_SSI_IFD(struct S_IFD p0, struct S_IFD p1, int p2) { return p0; }
+EXPORT struct S_IFP f19_S_SSI_IFP(struct S_IFP p0, struct S_IFP p1, int p2) { return p0; }
+EXPORT struct S_IDI f19_S_SSI_IDI(struct S_IDI p0, struct S_IDI p1, int p2) { return p0; }
+EXPORT struct S_IDF f19_S_SSI_IDF(struct S_IDF p0, struct S_IDF p1, int p2) { return p0; }
+EXPORT struct S_IDD f19_S_SSI_IDD(struct S_IDD p0, struct S_IDD p1, int p2) { return p0; }
+EXPORT struct S_IDP f19_S_SSI_IDP(struct S_IDP p0, struct S_IDP p1, int p2) { return p0; }
+EXPORT struct S_IPI f19_S_SSI_IPI(struct S_IPI p0, struct S_IPI p1, int p2) { return p0; }
+EXPORT struct S_IPF f19_S_SSI_IPF(struct S_IPF p0, struct S_IPF p1, int p2) { return p0; }
+EXPORT struct S_IPD f19_S_SSI_IPD(struct S_IPD p0, struct S_IPD p1, int p2) { return p0; }
+EXPORT struct S_IPP f19_S_SSI_IPP(struct S_IPP p0, struct S_IPP p1, int p2) { return p0; }
+EXPORT struct S_FII f19_S_SSI_FII(struct S_FII p0, struct S_FII p1, int p2) { return p0; }
+EXPORT struct S_FIF f19_S_SSI_FIF(struct S_FIF p0, struct S_FIF p1, int p2) { return p0; }
+EXPORT struct S_FID f19_S_SSI_FID(struct S_FID p0, struct S_FID p1, int p2) { return p0; }
+EXPORT struct S_FIP f19_S_SSI_FIP(struct S_FIP p0, struct S_FIP p1, int p2) { return p0; }
+EXPORT struct S_FFI f19_S_SSI_FFI(struct S_FFI p0, struct S_FFI p1, int p2) { return p0; }
+EXPORT struct S_FFF f19_S_SSI_FFF(struct S_FFF p0, struct S_FFF p1, int p2) { return p0; }
+EXPORT struct S_FFD f19_S_SSI_FFD(struct S_FFD p0, struct S_FFD p1, int p2) { return p0; }
+EXPORT struct S_FFP f19_S_SSI_FFP(struct S_FFP p0, struct S_FFP p1, int p2) { return p0; }
+EXPORT struct S_FDI f19_S_SSI_FDI(struct S_FDI p0, struct S_FDI p1, int p2) { return p0; }
+EXPORT struct S_FDF f19_S_SSI_FDF(struct S_FDF p0, struct S_FDF p1, int p2) { return p0; }
+EXPORT struct S_FDD f19_S_SSI_FDD(struct S_FDD p0, struct S_FDD p1, int p2) { return p0; }
+EXPORT struct S_FDP f19_S_SSI_FDP(struct S_FDP p0, struct S_FDP p1, int p2) { return p0; }
+EXPORT struct S_FPI f19_S_SSI_FPI(struct S_FPI p0, struct S_FPI p1, int p2) { return p0; }
+EXPORT struct S_FPF f19_S_SSI_FPF(struct S_FPF p0, struct S_FPF p1, int p2) { return p0; }
+EXPORT struct S_FPD f19_S_SSI_FPD(struct S_FPD p0, struct S_FPD p1, int p2) { return p0; }
+EXPORT struct S_FPP f19_S_SSI_FPP(struct S_FPP p0, struct S_FPP p1, int p2) { return p0; }
+EXPORT struct S_DII f19_S_SSI_DII(struct S_DII p0, struct S_DII p1, int p2) { return p0; }
+EXPORT struct S_DIF f19_S_SSI_DIF(struct S_DIF p0, struct S_DIF p1, int p2) { return p0; }
+EXPORT struct S_DID f19_S_SSI_DID(struct S_DID p0, struct S_DID p1, int p2) { return p0; }
+EXPORT struct S_DIP f19_S_SSI_DIP(struct S_DIP p0, struct S_DIP p1, int p2) { return p0; }
+EXPORT struct S_DFI f19_S_SSI_DFI(struct S_DFI p0, struct S_DFI p1, int p2) { return p0; }
+EXPORT struct S_DFF f19_S_SSI_DFF(struct S_DFF p0, struct S_DFF p1, int p2) { return p0; }
+EXPORT struct S_DFD f19_S_SSI_DFD(struct S_DFD p0, struct S_DFD p1, int p2) { return p0; }
+EXPORT struct S_DFP f19_S_SSI_DFP(struct S_DFP p0, struct S_DFP p1, int p2) { return p0; }
+EXPORT struct S_DDI f19_S_SSI_DDI(struct S_DDI p0, struct S_DDI p1, int p2) { return p0; }
+EXPORT struct S_DDF f19_S_SSI_DDF(struct S_DDF p0, struct S_DDF p1, int p2) { return p0; }
+EXPORT struct S_DDD f19_S_SSI_DDD(struct S_DDD p0, struct S_DDD p1, int p2) { return p0; }
+EXPORT struct S_DDP f19_S_SSI_DDP(struct S_DDP p0, struct S_DDP p1, int p2) { return p0; }
+EXPORT struct S_DPI f19_S_SSI_DPI(struct S_DPI p0, struct S_DPI p1, int p2) { return p0; }
+EXPORT struct S_DPF f19_S_SSI_DPF(struct S_DPF p0, struct S_DPF p1, int p2) { return p0; }
+EXPORT struct S_DPD f19_S_SSI_DPD(struct S_DPD p0, struct S_DPD p1, int p2) { return p0; }
+EXPORT struct S_DPP f19_S_SSI_DPP(struct S_DPP p0, struct S_DPP p1, int p2) { return p0; }
+EXPORT struct S_PII f19_S_SSI_PII(struct S_PII p0, struct S_PII p1, int p2) { return p0; }
+EXPORT struct S_PIF f19_S_SSI_PIF(struct S_PIF p0, struct S_PIF p1, int p2) { return p0; }
+EXPORT struct S_PID f19_S_SSI_PID(struct S_PID p0, struct S_PID p1, int p2) { return p0; }
+EXPORT struct S_PIP f19_S_SSI_PIP(struct S_PIP p0, struct S_PIP p1, int p2) { return p0; }
+EXPORT struct S_PFI f19_S_SSI_PFI(struct S_PFI p0, struct S_PFI p1, int p2) { return p0; }
+EXPORT struct S_PFF f19_S_SSI_PFF(struct S_PFF p0, struct S_PFF p1, int p2) { return p0; }
+EXPORT struct S_PFD f19_S_SSI_PFD(struct S_PFD p0, struct S_PFD p1, int p2) { return p0; }
+EXPORT struct S_PFP f19_S_SSI_PFP(struct S_PFP p0, struct S_PFP p1, int p2) { return p0; }
+EXPORT struct S_PDI f19_S_SSI_PDI(struct S_PDI p0, struct S_PDI p1, int p2) { return p0; }
+EXPORT struct S_PDF f19_S_SSI_PDF(struct S_PDF p0, struct S_PDF p1, int p2) { return p0; }
+EXPORT struct S_PDD f19_S_SSI_PDD(struct S_PDD p0, struct S_PDD p1, int p2) { return p0; }
+EXPORT struct S_PDP f19_S_SSI_PDP(struct S_PDP p0, struct S_PDP p1, int p2) { return p0; }
+EXPORT struct S_PPI f19_S_SSI_PPI(struct S_PPI p0, struct S_PPI p1, int p2) { return p0; }
+EXPORT struct S_PPF f19_S_SSI_PPF(struct S_PPF p0, struct S_PPF p1, int p2) { return p0; }
+EXPORT struct S_PPD f19_S_SSI_PPD(struct S_PPD p0, struct S_PPD p1, int p2) { return p0; }
+EXPORT struct S_PPP f19_S_SSI_PPP(struct S_PPP p0, struct S_PPP p1, int p2) { return p0; }
+EXPORT struct S_I f19_S_SSF_I(struct S_I p0, struct S_I p1, float p2) { return p0; }
+EXPORT struct S_F f19_S_SSF_F(struct S_F p0, struct S_F p1, float p2) { return p0; }
+EXPORT struct S_D f19_S_SSF_D(struct S_D p0, struct S_D p1, float p2) { return p0; }
+EXPORT struct S_P f19_S_SSF_P(struct S_P p0, struct S_P p1, float p2) { return p0; }
+EXPORT struct S_II f19_S_SSF_II(struct S_II p0, struct S_II p1, float p2) { return p0; }
+EXPORT struct S_IF f19_S_SSF_IF(struct S_IF p0, struct S_IF p1, float p2) { return p0; }
+EXPORT struct S_ID f19_S_SSF_ID(struct S_ID p0, struct S_ID p1, float p2) { return p0; }
+EXPORT struct S_IP f19_S_SSF_IP(struct S_IP p0, struct S_IP p1, float p2) { return p0; }
+EXPORT struct S_FI f19_S_SSF_FI(struct S_FI p0, struct S_FI p1, float p2) { return p0; }
+EXPORT struct S_FF f19_S_SSF_FF(struct S_FF p0, struct S_FF p1, float p2) { return p0; }
+EXPORT struct S_FD f19_S_SSF_FD(struct S_FD p0, struct S_FD p1, float p2) { return p0; }
+EXPORT struct S_FP f19_S_SSF_FP(struct S_FP p0, struct S_FP p1, float p2) { return p0; }
+EXPORT struct S_DI f19_S_SSF_DI(struct S_DI p0, struct S_DI p1, float p2) { return p0; }
+EXPORT struct S_DF f19_S_SSF_DF(struct S_DF p0, struct S_DF p1, float p2) { return p0; }
+EXPORT struct S_DD f19_S_SSF_DD(struct S_DD p0, struct S_DD p1, float p2) { return p0; }
+EXPORT struct S_DP f19_S_SSF_DP(struct S_DP p0, struct S_DP p1, float p2) { return p0; }
+EXPORT struct S_PI f19_S_SSF_PI(struct S_PI p0, struct S_PI p1, float p2) { return p0; }
+EXPORT struct S_PF f19_S_SSF_PF(struct S_PF p0, struct S_PF p1, float p2) { return p0; }
+EXPORT struct S_PD f19_S_SSF_PD(struct S_PD p0, struct S_PD p1, float p2) { return p0; }
+EXPORT struct S_PP f19_S_SSF_PP(struct S_PP p0, struct S_PP p1, float p2) { return p0; }
+EXPORT struct S_III f19_S_SSF_III(struct S_III p0, struct S_III p1, float p2) { return p0; }
+EXPORT struct S_IIF f19_S_SSF_IIF(struct S_IIF p0, struct S_IIF p1, float p2) { return p0; }
+EXPORT struct S_IID f19_S_SSF_IID(struct S_IID p0, struct S_IID p1, float p2) { return p0; }
+EXPORT struct S_IIP f19_S_SSF_IIP(struct S_IIP p0, struct S_IIP p1, float p2) { return p0; }
+EXPORT struct S_IFI f19_S_SSF_IFI(struct S_IFI p0, struct S_IFI p1, float p2) { return p0; }
+EXPORT struct S_IFF f19_S_SSF_IFF(struct S_IFF p0, struct S_IFF p1, float p2) { return p0; }
+EXPORT struct S_IFD f19_S_SSF_IFD(struct S_IFD p0, struct S_IFD p1, float p2) { return p0; }
+EXPORT struct S_IFP f19_S_SSF_IFP(struct S_IFP p0, struct S_IFP p1, float p2) { return p0; }
+EXPORT struct S_IDI f19_S_SSF_IDI(struct S_IDI p0, struct S_IDI p1, float p2) { return p0; }
+EXPORT struct S_IDF f19_S_SSF_IDF(struct S_IDF p0, struct S_IDF p1, float p2) { return p0; }
+EXPORT struct S_IDD f19_S_SSF_IDD(struct S_IDD p0, struct S_IDD p1, float p2) { return p0; }
+EXPORT struct S_IDP f19_S_SSF_IDP(struct S_IDP p0, struct S_IDP p1, float p2) { return p0; }
+EXPORT struct S_IPI f19_S_SSF_IPI(struct S_IPI p0, struct S_IPI p1, float p2) { return p0; }
+EXPORT struct S_IPF f19_S_SSF_IPF(struct S_IPF p0, struct S_IPF p1, float p2) { return p0; }
+EXPORT struct S_IPD f19_S_SSF_IPD(struct S_IPD p0, struct S_IPD p1, float p2) { return p0; }
+EXPORT struct S_IPP f19_S_SSF_IPP(struct S_IPP p0, struct S_IPP p1, float p2) { return p0; }
+EXPORT struct S_FII f19_S_SSF_FII(struct S_FII p0, struct S_FII p1, float p2) { return p0; }
+EXPORT struct S_FIF f19_S_SSF_FIF(struct S_FIF p0, struct S_FIF p1, float p2) { return p0; }
+EXPORT struct S_FID f19_S_SSF_FID(struct S_FID p0, struct S_FID p1, float p2) { return p0; }
+EXPORT struct S_FIP f19_S_SSF_FIP(struct S_FIP p0, struct S_FIP p1, float p2) { return p0; }
+EXPORT struct S_FFI f19_S_SSF_FFI(struct S_FFI p0, struct S_FFI p1, float p2) { return p0; }
+EXPORT struct S_FFF f19_S_SSF_FFF(struct S_FFF p0, struct S_FFF p1, float p2) { return p0; }
+EXPORT struct S_FFD f19_S_SSF_FFD(struct S_FFD p0, struct S_FFD p1, float p2) { return p0; }
+EXPORT struct S_FFP f19_S_SSF_FFP(struct S_FFP p0, struct S_FFP p1, float p2) { return p0; }
+EXPORT struct S_FDI f19_S_SSF_FDI(struct S_FDI p0, struct S_FDI p1, float p2) { return p0; }
+EXPORT struct S_FDF f19_S_SSF_FDF(struct S_FDF p0, struct S_FDF p1, float p2) { return p0; }
+EXPORT struct S_FDD f19_S_SSF_FDD(struct S_FDD p0, struct S_FDD p1, float p2) { return p0; }
+EXPORT struct S_FDP f19_S_SSF_FDP(struct S_FDP p0, struct S_FDP p1, float p2) { return p0; }
+EXPORT struct S_FPI f19_S_SSF_FPI(struct S_FPI p0, struct S_FPI p1, float p2) { return p0; }
+EXPORT struct S_FPF f19_S_SSF_FPF(struct S_FPF p0, struct S_FPF p1, float p2) { return p0; }
+EXPORT struct S_FPD f19_S_SSF_FPD(struct S_FPD p0, struct S_FPD p1, float p2) { return p0; }
+EXPORT struct S_FPP f19_S_SSF_FPP(struct S_FPP p0, struct S_FPP p1, float p2) { return p0; }
+EXPORT struct S_DII f19_S_SSF_DII(struct S_DII p0, struct S_DII p1, float p2) { return p0; }
+EXPORT struct S_DIF f19_S_SSF_DIF(struct S_DIF p0, struct S_DIF p1, float p2) { return p0; }
+EXPORT struct S_DID f19_S_SSF_DID(struct S_DID p0, struct S_DID p1, float p2) { return p0; }
+EXPORT struct S_DIP f19_S_SSF_DIP(struct S_DIP p0, struct S_DIP p1, float p2) { return p0; }
+EXPORT struct S_DFI f19_S_SSF_DFI(struct S_DFI p0, struct S_DFI p1, float p2) { return p0; }
+EXPORT struct S_DFF f19_S_SSF_DFF(struct S_DFF p0, struct S_DFF p1, float p2) { return p0; }
+EXPORT struct S_DFD f19_S_SSF_DFD(struct S_DFD p0, struct S_DFD p1, float p2) { return p0; }
+EXPORT struct S_DFP f19_S_SSF_DFP(struct S_DFP p0, struct S_DFP p1, float p2) { return p0; }
+EXPORT struct S_DDI f19_S_SSF_DDI(struct S_DDI p0, struct S_DDI p1, float p2) { return p0; }
+EXPORT struct S_DDF f19_S_SSF_DDF(struct S_DDF p0, struct S_DDF p1, float p2) { return p0; }
+EXPORT struct S_DDD f19_S_SSF_DDD(struct S_DDD p0, struct S_DDD p1, float p2) { return p0; }
+EXPORT struct S_DDP f19_S_SSF_DDP(struct S_DDP p0, struct S_DDP p1, float p2) { return p0; }
+EXPORT struct S_DPI f19_S_SSF_DPI(struct S_DPI p0, struct S_DPI p1, float p2) { return p0; }
+EXPORT struct S_DPF f19_S_SSF_DPF(struct S_DPF p0, struct S_DPF p1, float p2) { return p0; }
+EXPORT struct S_DPD f19_S_SSF_DPD(struct S_DPD p0, struct S_DPD p1, float p2) { return p0; }
+EXPORT struct S_DPP f19_S_SSF_DPP(struct S_DPP p0, struct S_DPP p1, float p2) { return p0; }
+EXPORT struct S_PII f19_S_SSF_PII(struct S_PII p0, struct S_PII p1, float p2) { return p0; }
+EXPORT struct S_PIF f19_S_SSF_PIF(struct S_PIF p0, struct S_PIF p1, float p2) { return p0; }
+EXPORT struct S_PID f19_S_SSF_PID(struct S_PID p0, struct S_PID p1, float p2) { return p0; }
+EXPORT struct S_PIP f19_S_SSF_PIP(struct S_PIP p0, struct S_PIP p1, float p2) { return p0; }
+EXPORT struct S_PFI f19_S_SSF_PFI(struct S_PFI p0, struct S_PFI p1, float p2) { return p0; }
+EXPORT struct S_PFF f19_S_SSF_PFF(struct S_PFF p0, struct S_PFF p1, float p2) { return p0; }
+EXPORT struct S_PFD f19_S_SSF_PFD(struct S_PFD p0, struct S_PFD p1, float p2) { return p0; }
+EXPORT struct S_PFP f19_S_SSF_PFP(struct S_PFP p0, struct S_PFP p1, float p2) { return p0; }
+EXPORT struct S_PDI f19_S_SSF_PDI(struct S_PDI p0, struct S_PDI p1, float p2) { return p0; }
+EXPORT struct S_PDF f19_S_SSF_PDF(struct S_PDF p0, struct S_PDF p1, float p2) { return p0; }
+EXPORT struct S_PDD f19_S_SSF_PDD(struct S_PDD p0, struct S_PDD p1, float p2) { return p0; }
+EXPORT struct S_PDP f19_S_SSF_PDP(struct S_PDP p0, struct S_PDP p1, float p2) { return p0; }
+EXPORT struct S_PPI f19_S_SSF_PPI(struct S_PPI p0, struct S_PPI p1, float p2) { return p0; }
+EXPORT struct S_PPF f19_S_SSF_PPF(struct S_PPF p0, struct S_PPF p1, float p2) { return p0; }
+EXPORT struct S_PPD f19_S_SSF_PPD(struct S_PPD p0, struct S_PPD p1, float p2) { return p0; }
+EXPORT struct S_PPP f19_S_SSF_PPP(struct S_PPP p0, struct S_PPP p1, float p2) { return p0; }
+EXPORT struct S_I f19_S_SSD_I(struct S_I p0, struct S_I p1, double p2) { return p0; }
+EXPORT struct S_F f19_S_SSD_F(struct S_F p0, struct S_F p1, double p2) { return p0; }
+EXPORT struct S_D f19_S_SSD_D(struct S_D p0, struct S_D p1, double p2) { return p0; }
+EXPORT struct S_P f19_S_SSD_P(struct S_P p0, struct S_P p1, double p2) { return p0; }
+EXPORT struct S_II f19_S_SSD_II(struct S_II p0, struct S_II p1, double p2) { return p0; }
+EXPORT struct S_IF f19_S_SSD_IF(struct S_IF p0, struct S_IF p1, double p2) { return p0; }
+EXPORT struct S_ID f19_S_SSD_ID(struct S_ID p0, struct S_ID p1, double p2) { return p0; }
+EXPORT struct S_IP f19_S_SSD_IP(struct S_IP p0, struct S_IP p1, double p2) { return p0; }
+EXPORT struct S_FI f19_S_SSD_FI(struct S_FI p0, struct S_FI p1, double p2) { return p0; }
+EXPORT struct S_FF f19_S_SSD_FF(struct S_FF p0, struct S_FF p1, double p2) { return p0; }
+EXPORT struct S_FD f19_S_SSD_FD(struct S_FD p0, struct S_FD p1, double p2) { return p0; }
+EXPORT struct S_FP f19_S_SSD_FP(struct S_FP p0, struct S_FP p1, double p2) { return p0; }
+EXPORT struct S_DI f19_S_SSD_DI(struct S_DI p0, struct S_DI p1, double p2) { return p0; }
+EXPORT struct S_DF f19_S_SSD_DF(struct S_DF p0, struct S_DF p1, double p2) { return p0; }
+EXPORT struct S_DD f19_S_SSD_DD(struct S_DD p0, struct S_DD p1, double p2) { return p0; }
+EXPORT struct S_DP f19_S_SSD_DP(struct S_DP p0, struct S_DP p1, double p2) { return p0; }
+EXPORT struct S_PI f19_S_SSD_PI(struct S_PI p0, struct S_PI p1, double p2) { return p0; }
+EXPORT struct S_PF f19_S_SSD_PF(struct S_PF p0, struct S_PF p1, double p2) { return p0; }
+EXPORT struct S_PD f19_S_SSD_PD(struct S_PD p0, struct S_PD p1, double p2) { return p0; }
+EXPORT struct S_PP f19_S_SSD_PP(struct S_PP p0, struct S_PP p1, double p2) { return p0; }
+EXPORT struct S_III f19_S_SSD_III(struct S_III p0, struct S_III p1, double p2) { return p0; }
+EXPORT struct S_IIF f19_S_SSD_IIF(struct S_IIF p0, struct S_IIF p1, double p2) { return p0; }
+EXPORT struct S_IID f19_S_SSD_IID(struct S_IID p0, struct S_IID p1, double p2) { return p0; }
+EXPORT struct S_IIP f19_S_SSD_IIP(struct S_IIP p0, struct S_IIP p1, double p2) { return p0; }
+EXPORT struct S_IFI f19_S_SSD_IFI(struct S_IFI p0, struct S_IFI p1, double p2) { return p0; }
+EXPORT struct S_IFF f19_S_SSD_IFF(struct S_IFF p0, struct S_IFF p1, double p2) { return p0; }
+EXPORT struct S_IFD f19_S_SSD_IFD(struct S_IFD p0, struct S_IFD p1, double p2) { return p0; }
+EXPORT struct S_IFP f19_S_SSD_IFP(struct S_IFP p0, struct S_IFP p1, double p2) { return p0; }
+EXPORT struct S_IDI f19_S_SSD_IDI(struct S_IDI p0, struct S_IDI p1, double p2) { return p0; }
+EXPORT struct S_IDF f19_S_SSD_IDF(struct S_IDF p0, struct S_IDF p1, double p2) { return p0; }
+EXPORT struct S_IDD f19_S_SSD_IDD(struct S_IDD p0, struct S_IDD p1, double p2) { return p0; }
+EXPORT struct S_IDP f19_S_SSD_IDP(struct S_IDP p0, struct S_IDP p1, double p2) { return p0; }
+EXPORT struct S_IPI f19_S_SSD_IPI(struct S_IPI p0, struct S_IPI p1, double p2) { return p0; }
+EXPORT struct S_IPF f19_S_SSD_IPF(struct S_IPF p0, struct S_IPF p1, double p2) { return p0; }
+EXPORT struct S_IPD f19_S_SSD_IPD(struct S_IPD p0, struct S_IPD p1, double p2) { return p0; }
+EXPORT struct S_IPP f19_S_SSD_IPP(struct S_IPP p0, struct S_IPP p1, double p2) { return p0; }
+EXPORT struct S_FII f19_S_SSD_FII(struct S_FII p0, struct S_FII p1, double p2) { return p0; }
+EXPORT struct S_FIF f19_S_SSD_FIF(struct S_FIF p0, struct S_FIF p1, double p2) { return p0; }
+EXPORT struct S_FID f19_S_SSD_FID(struct S_FID p0, struct S_FID p1, double p2) { return p0; }
+EXPORT struct S_FIP f19_S_SSD_FIP(struct S_FIP p0, struct S_FIP p1, double p2) { return p0; }
+EXPORT struct S_FFI f19_S_SSD_FFI(struct S_FFI p0, struct S_FFI p1, double p2) { return p0; }
+EXPORT struct S_FFF f19_S_SSD_FFF(struct S_FFF p0, struct S_FFF p1, double p2) { return p0; }
+EXPORT struct S_FFD f19_S_SSD_FFD(struct S_FFD p0, struct S_FFD p1, double p2) { return p0; }
+EXPORT struct S_FFP f19_S_SSD_FFP(struct S_FFP p0, struct S_FFP p1, double p2) { return p0; }
+EXPORT struct S_FDI f19_S_SSD_FDI(struct S_FDI p0, struct S_FDI p1, double p2) { return p0; }
+EXPORT struct S_FDF f19_S_SSD_FDF(struct S_FDF p0, struct S_FDF p1, double p2) { return p0; }
+EXPORT struct S_FDD f19_S_SSD_FDD(struct S_FDD p0, struct S_FDD p1, double p2) { return p0; }
+EXPORT struct S_FDP f19_S_SSD_FDP(struct S_FDP p0, struct S_FDP p1, double p2) { return p0; }
+EXPORT struct S_FPI f19_S_SSD_FPI(struct S_FPI p0, struct S_FPI p1, double p2) { return p0; }
+EXPORT struct S_FPF f19_S_SSD_FPF(struct S_FPF p0, struct S_FPF p1, double p2) { return p0; }
+EXPORT struct S_FPD f19_S_SSD_FPD(struct S_FPD p0, struct S_FPD p1, double p2) { return p0; }
+EXPORT struct S_FPP f19_S_SSD_FPP(struct S_FPP p0, struct S_FPP p1, double p2) { return p0; }
+EXPORT struct S_DII f19_S_SSD_DII(struct S_DII p0, struct S_DII p1, double p2) { return p0; }
+EXPORT struct S_DIF f19_S_SSD_DIF(struct S_DIF p0, struct S_DIF p1, double p2) { return p0; }
+EXPORT struct S_DID f19_S_SSD_DID(struct S_DID p0, struct S_DID p1, double p2) { return p0; }
+EXPORT struct S_DIP f19_S_SSD_DIP(struct S_DIP p0, struct S_DIP p1, double p2) { return p0; }
+EXPORT struct S_DFI f19_S_SSD_DFI(struct S_DFI p0, struct S_DFI p1, double p2) { return p0; }
+EXPORT struct S_DFF f19_S_SSD_DFF(struct S_DFF p0, struct S_DFF p1, double p2) { return p0; }
+EXPORT struct S_DFD f19_S_SSD_DFD(struct S_DFD p0, struct S_DFD p1, double p2) { return p0; }
+EXPORT struct S_DFP f19_S_SSD_DFP(struct S_DFP p0, struct S_DFP p1, double p2) { return p0; }
+EXPORT struct S_DDI f19_S_SSD_DDI(struct S_DDI p0, struct S_DDI p1, double p2) { return p0; }
+EXPORT struct S_DDF f19_S_SSD_DDF(struct S_DDF p0, struct S_DDF p1, double p2) { return p0; }
+EXPORT struct S_DDD f19_S_SSD_DDD(struct S_DDD p0, struct S_DDD p1, double p2) { return p0; }
+EXPORT struct S_DDP f19_S_SSD_DDP(struct S_DDP p0, struct S_DDP p1, double p2) { return p0; }
+EXPORT struct S_DPI f19_S_SSD_DPI(struct S_DPI p0, struct S_DPI p1, double p2) { return p0; }
+EXPORT struct S_DPF f19_S_SSD_DPF(struct S_DPF p0, struct S_DPF p1, double p2) { return p0; }
+EXPORT struct S_DPD f19_S_SSD_DPD(struct S_DPD p0, struct S_DPD p1, double p2) { return p0; }
+EXPORT struct S_DPP f19_S_SSD_DPP(struct S_DPP p0, struct S_DPP p1, double p2) { return p0; }
+EXPORT struct S_PII f19_S_SSD_PII(struct S_PII p0, struct S_PII p1, double p2) { return p0; }
+EXPORT struct S_PIF f19_S_SSD_PIF(struct S_PIF p0, struct S_PIF p1, double p2) { return p0; }
+EXPORT struct S_PID f19_S_SSD_PID(struct S_PID p0, struct S_PID p1, double p2) { return p0; }
+EXPORT struct S_PIP f19_S_SSD_PIP(struct S_PIP p0, struct S_PIP p1, double p2) { return p0; }
+EXPORT struct S_PFI f19_S_SSD_PFI(struct S_PFI p0, struct S_PFI p1, double p2) { return p0; }
+EXPORT struct S_PFF f19_S_SSD_PFF(struct S_PFF p0, struct S_PFF p1, double p2) { return p0; }
+EXPORT struct S_PFD f19_S_SSD_PFD(struct S_PFD p0, struct S_PFD p1, double p2) { return p0; }
+EXPORT struct S_PFP f19_S_SSD_PFP(struct S_PFP p0, struct S_PFP p1, double p2) { return p0; }
+EXPORT struct S_PDI f19_S_SSD_PDI(struct S_PDI p0, struct S_PDI p1, double p2) { return p0; }
+EXPORT struct S_PDF f19_S_SSD_PDF(struct S_PDF p0, struct S_PDF p1, double p2) { return p0; }
+EXPORT struct S_PDD f19_S_SSD_PDD(struct S_PDD p0, struct S_PDD p1, double p2) { return p0; }
+EXPORT struct S_PDP f19_S_SSD_PDP(struct S_PDP p0, struct S_PDP p1, double p2) { return p0; }
+EXPORT struct S_PPI f19_S_SSD_PPI(struct S_PPI p0, struct S_PPI p1, double p2) { return p0; }
+EXPORT struct S_PPF f19_S_SSD_PPF(struct S_PPF p0, struct S_PPF p1, double p2) { return p0; }
+EXPORT struct S_PPD f19_S_SSD_PPD(struct S_PPD p0, struct S_PPD p1, double p2) { return p0; }
+EXPORT struct S_PPP f19_S_SSD_PPP(struct S_PPP p0, struct S_PPP p1, double p2) { return p0; }
+EXPORT struct S_I f19_S_SSP_I(struct S_I p0, struct S_I p1, void* p2) { return p0; }
+EXPORT struct S_F f19_S_SSP_F(struct S_F p0, struct S_F p1, void* p2) { return p0; }
+EXPORT struct S_D f19_S_SSP_D(struct S_D p0, struct S_D p1, void* p2) { return p0; }
+EXPORT struct S_P f19_S_SSP_P(struct S_P p0, struct S_P p1, void* p2) { return p0; }
+EXPORT struct S_II f19_S_SSP_II(struct S_II p0, struct S_II p1, void* p2) { return p0; }
+EXPORT struct S_IF f19_S_SSP_IF(struct S_IF p0, struct S_IF p1, void* p2) { return p0; }
+EXPORT struct S_ID f19_S_SSP_ID(struct S_ID p0, struct S_ID p1, void* p2) { return p0; }
+EXPORT struct S_IP f19_S_SSP_IP(struct S_IP p0, struct S_IP p1, void* p2) { return p0; }
+EXPORT struct S_FI f19_S_SSP_FI(struct S_FI p0, struct S_FI p1, void* p2) { return p0; }
+EXPORT struct S_FF f19_S_SSP_FF(struct S_FF p0, struct S_FF p1, void* p2) { return p0; }
+EXPORT struct S_FD f19_S_SSP_FD(struct S_FD p0, struct S_FD p1, void* p2) { return p0; }
+EXPORT struct S_FP f19_S_SSP_FP(struct S_FP p0, struct S_FP p1, void* p2) { return p0; }
+EXPORT struct S_DI f19_S_SSP_DI(struct S_DI p0, struct S_DI p1, void* p2) { return p0; }
+EXPORT struct S_DF f19_S_SSP_DF(struct S_DF p0, struct S_DF p1, void* p2) { return p0; }
+EXPORT struct S_DD f19_S_SSP_DD(struct S_DD p0, struct S_DD p1, void* p2) { return p0; }
+EXPORT struct S_DP f19_S_SSP_DP(struct S_DP p0, struct S_DP p1, void* p2) { return p0; }
+EXPORT struct S_PI f19_S_SSP_PI(struct S_PI p0, struct S_PI p1, void* p2) { return p0; }
+EXPORT struct S_PF f19_S_SSP_PF(struct S_PF p0, struct S_PF p1, void* p2) { return p0; }
+EXPORT struct S_PD f19_S_SSP_PD(struct S_PD p0, struct S_PD p1, void* p2) { return p0; }
+EXPORT struct S_PP f19_S_SSP_PP(struct S_PP p0, struct S_PP p1, void* p2) { return p0; }
+EXPORT struct S_III f19_S_SSP_III(struct S_III p0, struct S_III p1, void* p2) { return p0; }
+EXPORT struct S_IIF f19_S_SSP_IIF(struct S_IIF p0, struct S_IIF p1, void* p2) { return p0; }
+EXPORT struct S_IID f19_S_SSP_IID(struct S_IID p0, struct S_IID p1, void* p2) { return p0; }
+EXPORT struct S_IIP f19_S_SSP_IIP(struct S_IIP p0, struct S_IIP p1, void* p2) { return p0; }
+EXPORT struct S_IFI f19_S_SSP_IFI(struct S_IFI p0, struct S_IFI p1, void* p2) { return p0; }
+EXPORT struct S_IFF f19_S_SSP_IFF(struct S_IFF p0, struct S_IFF p1, void* p2) { return p0; }
+EXPORT struct S_IFD f19_S_SSP_IFD(struct S_IFD p0, struct S_IFD p1, void* p2) { return p0; }
+EXPORT struct S_IFP f19_S_SSP_IFP(struct S_IFP p0, struct S_IFP p1, void* p2) { return p0; }
+EXPORT struct S_IDI f19_S_SSP_IDI(struct S_IDI p0, struct S_IDI p1, void* p2) { return p0; }
+EXPORT struct S_IDF f19_S_SSP_IDF(struct S_IDF p0, struct S_IDF p1, void* p2) { return p0; }
+EXPORT struct S_IDD f19_S_SSP_IDD(struct S_IDD p0, struct S_IDD p1, void* p2) { return p0; }
+EXPORT struct S_IDP f19_S_SSP_IDP(struct S_IDP p0, struct S_IDP p1, void* p2) { return p0; }
+EXPORT struct S_IPI f19_S_SSP_IPI(struct S_IPI p0, struct S_IPI p1, void* p2) { return p0; }
+EXPORT struct S_IPF f19_S_SSP_IPF(struct S_IPF p0, struct S_IPF p1, void* p2) { return p0; }
+EXPORT struct S_IPD f19_S_SSP_IPD(struct S_IPD p0, struct S_IPD p1, void* p2) { return p0; }
+EXPORT struct S_IPP f19_S_SSP_IPP(struct S_IPP p0, struct S_IPP p1, void* p2) { return p0; }
+EXPORT struct S_FII f19_S_SSP_FII(struct S_FII p0, struct S_FII p1, void* p2) { return p0; }
+EXPORT struct S_FIF f19_S_SSP_FIF(struct S_FIF p0, struct S_FIF p1, void* p2) { return p0; }
+EXPORT struct S_FID f19_S_SSP_FID(struct S_FID p0, struct S_FID p1, void* p2) { return p0; }
+EXPORT struct S_FIP f19_S_SSP_FIP(struct S_FIP p0, struct S_FIP p1, void* p2) { return p0; }
+EXPORT struct S_FFI f19_S_SSP_FFI(struct S_FFI p0, struct S_FFI p1, void* p2) { return p0; }
+EXPORT struct S_FFF f19_S_SSP_FFF(struct S_FFF p0, struct S_FFF p1, void* p2) { return p0; }
+EXPORT struct S_FFD f19_S_SSP_FFD(struct S_FFD p0, struct S_FFD p1, void* p2) { return p0; }
+EXPORT struct S_FFP f19_S_SSP_FFP(struct S_FFP p0, struct S_FFP p1, void* p2) { return p0; }
+EXPORT struct S_FDI f19_S_SSP_FDI(struct S_FDI p0, struct S_FDI p1, void* p2) { return p0; }
+EXPORT struct S_FDF f19_S_SSP_FDF(struct S_FDF p0, struct S_FDF p1, void* p2) { return p0; }
+EXPORT struct S_FDD f19_S_SSP_FDD(struct S_FDD p0, struct S_FDD p1, void* p2) { return p0; }
+EXPORT struct S_FDP f19_S_SSP_FDP(struct S_FDP p0, struct S_FDP p1, void* p2) { return p0; }
+EXPORT struct S_FPI f19_S_SSP_FPI(struct S_FPI p0, struct S_FPI p1, void* p2) { return p0; }
+EXPORT struct S_FPF f19_S_SSP_FPF(struct S_FPF p0, struct S_FPF p1, void* p2) { return p0; }
+EXPORT struct S_FPD f19_S_SSP_FPD(struct S_FPD p0, struct S_FPD p1, void* p2) { return p0; }
+EXPORT struct S_FPP f19_S_SSP_FPP(struct S_FPP p0, struct S_FPP p1, void* p2) { return p0; }
+EXPORT struct S_DII f19_S_SSP_DII(struct S_DII p0, struct S_DII p1, void* p2) { return p0; }
+EXPORT struct S_DIF f19_S_SSP_DIF(struct S_DIF p0, struct S_DIF p1, void* p2) { return p0; }
+EXPORT struct S_DID f19_S_SSP_DID(struct S_DID p0, struct S_DID p1, void* p2) { return p0; }
+EXPORT struct S_DIP f19_S_SSP_DIP(struct S_DIP p0, struct S_DIP p1, void* p2) { return p0; }
+EXPORT struct S_DFI f19_S_SSP_DFI(struct S_DFI p0, struct S_DFI p1, void* p2) { return p0; }
+EXPORT struct S_DFF f19_S_SSP_DFF(struct S_DFF p0, struct S_DFF p1, void* p2) { return p0; }
+EXPORT struct S_DFD f19_S_SSP_DFD(struct S_DFD p0, struct S_DFD p1, void* p2) { return p0; }
+EXPORT struct S_DFP f19_S_SSP_DFP(struct S_DFP p0, struct S_DFP p1, void* p2) { return p0; }
+EXPORT struct S_DDI f19_S_SSP_DDI(struct S_DDI p0, struct S_DDI p1, void* p2) { return p0; }
+EXPORT struct S_DDF f19_S_SSP_DDF(struct S_DDF p0, struct S_DDF p1, void* p2) { return p0; }
+EXPORT struct S_DDD f19_S_SSP_DDD(struct S_DDD p0, struct S_DDD p1, void* p2) { return p0; }
+EXPORT struct S_DDP f19_S_SSP_DDP(struct S_DDP p0, struct S_DDP p1, void* p2) { return p0; }
+EXPORT struct S_DPI f19_S_SSP_DPI(struct S_DPI p0, struct S_DPI p1, void* p2) { return p0; }
+EXPORT struct S_DPF f19_S_SSP_DPF(struct S_DPF p0, struct S_DPF p1, void* p2) { return p0; }
+EXPORT struct S_DPD f19_S_SSP_DPD(struct S_DPD p0, struct S_DPD p1, void* p2) { return p0; }
+EXPORT struct S_DPP f19_S_SSP_DPP(struct S_DPP p0, struct S_DPP p1, void* p2) { return p0; }
+EXPORT struct S_PII f19_S_SSP_PII(struct S_PII p0, struct S_PII p1, void* p2) { return p0; }
+EXPORT struct S_PIF f19_S_SSP_PIF(struct S_PIF p0, struct S_PIF p1, void* p2) { return p0; }
+EXPORT struct S_PID f19_S_SSP_PID(struct S_PID p0, struct S_PID p1, void* p2) { return p0; }
+EXPORT struct S_PIP f20_S_SSP_PIP(struct S_PIP p0, struct S_PIP p1, void* p2) { return p0; }
+EXPORT struct S_PFI f20_S_SSP_PFI(struct S_PFI p0, struct S_PFI p1, void* p2) { return p0; }
+EXPORT struct S_PFF f20_S_SSP_PFF(struct S_PFF p0, struct S_PFF p1, void* p2) { return p0; }
+EXPORT struct S_PFD f20_S_SSP_PFD(struct S_PFD p0, struct S_PFD p1, void* p2) { return p0; }
+EXPORT struct S_PFP f20_S_SSP_PFP(struct S_PFP p0, struct S_PFP p1, void* p2) { return p0; }
+EXPORT struct S_PDI f20_S_SSP_PDI(struct S_PDI p0, struct S_PDI p1, void* p2) { return p0; }
+EXPORT struct S_PDF f20_S_SSP_PDF(struct S_PDF p0, struct S_PDF p1, void* p2) { return p0; }
+EXPORT struct S_PDD f20_S_SSP_PDD(struct S_PDD p0, struct S_PDD p1, void* p2) { return p0; }
+EXPORT struct S_PDP f20_S_SSP_PDP(struct S_PDP p0, struct S_PDP p1, void* p2) { return p0; }
+EXPORT struct S_PPI f20_S_SSP_PPI(struct S_PPI p0, struct S_PPI p1, void* p2) { return p0; }
+EXPORT struct S_PPF f20_S_SSP_PPF(struct S_PPF p0, struct S_PPF p1, void* p2) { return p0; }
+EXPORT struct S_PPD f20_S_SSP_PPD(struct S_PPD p0, struct S_PPD p1, void* p2) { return p0; }
+EXPORT struct S_PPP f20_S_SSP_PPP(struct S_PPP p0, struct S_PPP p1, void* p2) { return p0; }
+EXPORT struct S_I f20_S_SSS_I(struct S_I p0, struct S_I p1, struct S_I p2) { return p0; }
+EXPORT struct S_F f20_S_SSS_F(struct S_F p0, struct S_F p1, struct S_F p2) { return p0; }
+EXPORT struct S_D f20_S_SSS_D(struct S_D p0, struct S_D p1, struct S_D p2) { return p0; }
+EXPORT struct S_P f20_S_SSS_P(struct S_P p0, struct S_P p1, struct S_P p2) { return p0; }
+EXPORT struct S_II f20_S_SSS_II(struct S_II p0, struct S_II p1, struct S_II p2) { return p0; }
+EXPORT struct S_IF f20_S_SSS_IF(struct S_IF p0, struct S_IF p1, struct S_IF p2) { return p0; }
+EXPORT struct S_ID f20_S_SSS_ID(struct S_ID p0, struct S_ID p1, struct S_ID p2) { return p0; }
+EXPORT struct S_IP f20_S_SSS_IP(struct S_IP p0, struct S_IP p1, struct S_IP p2) { return p0; }
+EXPORT struct S_FI f20_S_SSS_FI(struct S_FI p0, struct S_FI p1, struct S_FI p2) { return p0; }
+EXPORT struct S_FF f20_S_SSS_FF(struct S_FF p0, struct S_FF p1, struct S_FF p2) { return p0; }
+EXPORT struct S_FD f20_S_SSS_FD(struct S_FD p0, struct S_FD p1, struct S_FD p2) { return p0; }
+EXPORT struct S_FP f20_S_SSS_FP(struct S_FP p0, struct S_FP p1, struct S_FP p2) { return p0; }
+EXPORT struct S_DI f20_S_SSS_DI(struct S_DI p0, struct S_DI p1, struct S_DI p2) { return p0; }
+EXPORT struct S_DF f20_S_SSS_DF(struct S_DF p0, struct S_DF p1, struct S_DF p2) { return p0; }
+EXPORT struct S_DD f20_S_SSS_DD(struct S_DD p0, struct S_DD p1, struct S_DD p2) { return p0; }
+EXPORT struct S_DP f20_S_SSS_DP(struct S_DP p0, struct S_DP p1, struct S_DP p2) { return p0; }
+EXPORT struct S_PI f20_S_SSS_PI(struct S_PI p0, struct S_PI p1, struct S_PI p2) { return p0; }
+EXPORT struct S_PF f20_S_SSS_PF(struct S_PF p0, struct S_PF p1, struct S_PF p2) { return p0; }
+EXPORT struct S_PD f20_S_SSS_PD(struct S_PD p0, struct S_PD p1, struct S_PD p2) { return p0; }
+EXPORT struct S_PP f20_S_SSS_PP(struct S_PP p0, struct S_PP p1, struct S_PP p2) { return p0; }
+EXPORT struct S_III f20_S_SSS_III(struct S_III p0, struct S_III p1, struct S_III p2) { return p0; }
+EXPORT struct S_IIF f20_S_SSS_IIF(struct S_IIF p0, struct S_IIF p1, struct S_IIF p2) { return p0; }
+EXPORT struct S_IID f20_S_SSS_IID(struct S_IID p0, struct S_IID p1, struct S_IID p2) { return p0; }
+EXPORT struct S_IIP f20_S_SSS_IIP(struct S_IIP p0, struct S_IIP p1, struct S_IIP p2) { return p0; }
+EXPORT struct S_IFI f20_S_SSS_IFI(struct S_IFI p0, struct S_IFI p1, struct S_IFI p2) { return p0; }
+EXPORT struct S_IFF f20_S_SSS_IFF(struct S_IFF p0, struct S_IFF p1, struct S_IFF p2) { return p0; }
+EXPORT struct S_IFD f20_S_SSS_IFD(struct S_IFD p0, struct S_IFD p1, struct S_IFD p2) { return p0; }
+EXPORT struct S_IFP f20_S_SSS_IFP(struct S_IFP p0, struct S_IFP p1, struct S_IFP p2) { return p0; }
+EXPORT struct S_IDI f20_S_SSS_IDI(struct S_IDI p0, struct S_IDI p1, struct S_IDI p2) { return p0; }
+EXPORT struct S_IDF f20_S_SSS_IDF(struct S_IDF p0, struct S_IDF p1, struct S_IDF p2) { return p0; }
+EXPORT struct S_IDD f20_S_SSS_IDD(struct S_IDD p0, struct S_IDD p1, struct S_IDD p2) { return p0; }
+EXPORT struct S_IDP f20_S_SSS_IDP(struct S_IDP p0, struct S_IDP p1, struct S_IDP p2) { return p0; }
+EXPORT struct S_IPI f20_S_SSS_IPI(struct S_IPI p0, struct S_IPI p1, struct S_IPI p2) { return p0; }
+EXPORT struct S_IPF f20_S_SSS_IPF(struct S_IPF p0, struct S_IPF p1, struct S_IPF p2) { return p0; }
+EXPORT struct S_IPD f20_S_SSS_IPD(struct S_IPD p0, struct S_IPD p1, struct S_IPD p2) { return p0; }
+EXPORT struct S_IPP f20_S_SSS_IPP(struct S_IPP p0, struct S_IPP p1, struct S_IPP p2) { return p0; }
+EXPORT struct S_FII f20_S_SSS_FII(struct S_FII p0, struct S_FII p1, struct S_FII p2) { return p0; }
+EXPORT struct S_FIF f20_S_SSS_FIF(struct S_FIF p0, struct S_FIF p1, struct S_FIF p2) { return p0; }
+EXPORT struct S_FID f20_S_SSS_FID(struct S_FID p0, struct S_FID p1, struct S_FID p2) { return p0; }
+EXPORT struct S_FIP f20_S_SSS_FIP(struct S_FIP p0, struct S_FIP p1, struct S_FIP p2) { return p0; }
+EXPORT struct S_FFI f20_S_SSS_FFI(struct S_FFI p0, struct S_FFI p1, struct S_FFI p2) { return p0; }
+EXPORT struct S_FFF f20_S_SSS_FFF(struct S_FFF p0, struct S_FFF p1, struct S_FFF p2) { return p0; }
+EXPORT struct S_FFD f20_S_SSS_FFD(struct S_FFD p0, struct S_FFD p1, struct S_FFD p2) { return p0; }
+EXPORT struct S_FFP f20_S_SSS_FFP(struct S_FFP p0, struct S_FFP p1, struct S_FFP p2) { return p0; }
+EXPORT struct S_FDI f20_S_SSS_FDI(struct S_FDI p0, struct S_FDI p1, struct S_FDI p2) { return p0; }
+EXPORT struct S_FDF f20_S_SSS_FDF(struct S_FDF p0, struct S_FDF p1, struct S_FDF p2) { return p0; }
+EXPORT struct S_FDD f20_S_SSS_FDD(struct S_FDD p0, struct S_FDD p1, struct S_FDD p2) { return p0; }
+EXPORT struct S_FDP f20_S_SSS_FDP(struct S_FDP p0, struct S_FDP p1, struct S_FDP p2) { return p0; }
+EXPORT struct S_FPI f20_S_SSS_FPI(struct S_FPI p0, struct S_FPI p1, struct S_FPI p2) { return p0; }
+EXPORT struct S_FPF f20_S_SSS_FPF(struct S_FPF p0, struct S_FPF p1, struct S_FPF p2) { return p0; }
+EXPORT struct S_FPD f20_S_SSS_FPD(struct S_FPD p0, struct S_FPD p1, struct S_FPD p2) { return p0; }
+EXPORT struct S_FPP f20_S_SSS_FPP(struct S_FPP p0, struct S_FPP p1, struct S_FPP p2) { return p0; }
+EXPORT struct S_DII f20_S_SSS_DII(struct S_DII p0, struct S_DII p1, struct S_DII p2) { return p0; }
+EXPORT struct S_DIF f20_S_SSS_DIF(struct S_DIF p0, struct S_DIF p1, struct S_DIF p2) { return p0; }
+EXPORT struct S_DID f20_S_SSS_DID(struct S_DID p0, struct S_DID p1, struct S_DID p2) { return p0; }
+EXPORT struct S_DIP f20_S_SSS_DIP(struct S_DIP p0, struct S_DIP p1, struct S_DIP p2) { return p0; }
+EXPORT struct S_DFI f20_S_SSS_DFI(struct S_DFI p0, struct S_DFI p1, struct S_DFI p2) { return p0; }
+EXPORT struct S_DFF f20_S_SSS_DFF(struct S_DFF p0, struct S_DFF p1, struct S_DFF p2) { return p0; }
+EXPORT struct S_DFD f20_S_SSS_DFD(struct S_DFD p0, struct S_DFD p1, struct S_DFD p2) { return p0; }
+EXPORT struct S_DFP f20_S_SSS_DFP(struct S_DFP p0, struct S_DFP p1, struct S_DFP p2) { return p0; }
+EXPORT struct S_DDI f20_S_SSS_DDI(struct S_DDI p0, struct S_DDI p1, struct S_DDI p2) { return p0; }
+EXPORT struct S_DDF f20_S_SSS_DDF(struct S_DDF p0, struct S_DDF p1, struct S_DDF p2) { return p0; }
+EXPORT struct S_DDD f20_S_SSS_DDD(struct S_DDD p0, struct S_DDD p1, struct S_DDD p2) { return p0; }
+EXPORT struct S_DDP f20_S_SSS_DDP(struct S_DDP p0, struct S_DDP p1, struct S_DDP p2) { return p0; }
+EXPORT struct S_DPI f20_S_SSS_DPI(struct S_DPI p0, struct S_DPI p1, struct S_DPI p2) { return p0; }
+EXPORT struct S_DPF f20_S_SSS_DPF(struct S_DPF p0, struct S_DPF p1, struct S_DPF p2) { return p0; }
+EXPORT struct S_DPD f20_S_SSS_DPD(struct S_DPD p0, struct S_DPD p1, struct S_DPD p2) { return p0; }
+EXPORT struct S_DPP f20_S_SSS_DPP(struct S_DPP p0, struct S_DPP p1, struct S_DPP p2) { return p0; }
+EXPORT struct S_PII f20_S_SSS_PII(struct S_PII p0, struct S_PII p1, struct S_PII p2) { return p0; }
+EXPORT struct S_PIF f20_S_SSS_PIF(struct S_PIF p0, struct S_PIF p1, struct S_PIF p2) { return p0; }
+EXPORT struct S_PID f20_S_SSS_PID(struct S_PID p0, struct S_PID p1, struct S_PID p2) { return p0; }
+EXPORT struct S_PIP f20_S_SSS_PIP(struct S_PIP p0, struct S_PIP p1, struct S_PIP p2) { return p0; }
+EXPORT struct S_PFI f20_S_SSS_PFI(struct S_PFI p0, struct S_PFI p1, struct S_PFI p2) { return p0; }
+EXPORT struct S_PFF f20_S_SSS_PFF(struct S_PFF p0, struct S_PFF p1, struct S_PFF p2) { return p0; }
+EXPORT struct S_PFD f20_S_SSS_PFD(struct S_PFD p0, struct S_PFD p1, struct S_PFD p2) { return p0; }
+EXPORT struct S_PFP f20_S_SSS_PFP(struct S_PFP p0, struct S_PFP p1, struct S_PFP p2) { return p0; }
+EXPORT struct S_PDI f20_S_SSS_PDI(struct S_PDI p0, struct S_PDI p1, struct S_PDI p2) { return p0; }
+EXPORT struct S_PDF f20_S_SSS_PDF(struct S_PDF p0, struct S_PDF p1, struct S_PDF p2) { return p0; }
+EXPORT struct S_PDD f20_S_SSS_PDD(struct S_PDD p0, struct S_PDD p1, struct S_PDD p2) { return p0; }
+EXPORT struct S_PDP f20_S_SSS_PDP(struct S_PDP p0, struct S_PDP p1, struct S_PDP p2) { return p0; }
+EXPORT struct S_PPI f20_S_SSS_PPI(struct S_PPI p0, struct S_PPI p1, struct S_PPI p2) { return p0; }
+EXPORT struct S_PPF f20_S_SSS_PPF(struct S_PPF p0, struct S_PPF p1, struct S_PPF p2) { return p0; }
+EXPORT struct S_PPD f20_S_SSS_PPD(struct S_PPD p0, struct S_PPD p1, struct S_PPD p2) { return p0; }
+EXPORT struct S_PPP f20_S_SSS_PPP(struct S_PPP p0, struct S_PPP p1, struct S_PPP p2) { return p0; }
diff --git a/test/jdk/java/foreign/libTestDowncall.h b/test/jdk/java/foreign/libTestDowncall.h
new file mode 100644
index 0000000000000..4a69ae41772fa
--- /dev/null
+++ b/test/jdk/java/foreign/libTestDowncall.h
@@ -0,0 +1,12210 @@
+/*
+ * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+#ifdef _WIN64
+#define EXPORT __declspec(dllexport)
+#else
+#define EXPORT
+#endif
+
+struct S_I { int p0; };
+struct S_F { float p0; };
+struct S_D { double p0; };
+struct S_P { void* p0; };
+struct S_II { int p0; int p1; };
+struct S_IF { int p0; float p1; };
+struct S_ID { int p0; double p1; };
+struct S_IP { int p0; void* p1; };
+struct S_FI { float p0; int p1; };
+struct S_FF { float p0; float p1; };
+struct S_FD { float p0; double p1; };
+struct S_FP { float p0; void* p1; };
+struct S_DI { double p0; int p1; };
+struct S_DF { double p0; float p1; };
+struct S_DD { double p0; double p1; };
+struct S_DP { double p0; void* p1; };
+struct S_PI { void* p0; int p1; };
+struct S_PF { void* p0; float p1; };
+struct S_PD { void* p0; double p1; };
+struct S_PP { void* p0; void* p1; };
+struct S_III { int p0; int p1; int p2; };
+struct S_IIF { int p0; int p1; float p2; };
+struct S_IID { int p0; int p1; double p2; };
+struct S_IIP { int p0; int p1; void* p2; };
+struct S_IFI { int p0; float p1; int p2; };
+struct S_IFF { int p0; float p1; float p2; };
+struct S_IFD { int p0; float p1; double p2; };
+struct S_IFP { int p0; float p1; void* p2; };
+struct S_IDI { int p0; double p1; int p2; };
+struct S_IDF { int p0; double p1; float p2; };
+struct S_IDD { int p0; double p1; double p2; };
+struct S_IDP { int p0; double p1; void* p2; };
+struct S_IPI { int p0; void* p1; int p2; };
+struct S_IPF { int p0; void* p1; float p2; };
+struct S_IPD { int p0; void* p1; double p2; };
+struct S_IPP { int p0; void* p1; void* p2; };
+struct S_FII { float p0; int p1; int p2; };
+struct S_FIF { float p0; int p1; float p2; };
+struct S_FID { float p0; int p1; double p2; };
+struct S_FIP { float p0; int p1; void* p2; };
+struct S_FFI { float p0; float p1; int p2; };
+struct S_FFF { float p0; float p1; float p2; };
+struct S_FFD { float p0; float p1; double p2; };
+struct S_FFP { float p0; float p1; void* p2; };
+struct S_FDI { float p0; double p1; int p2; };
+struct S_FDF { float p0; double p1; float p2; };
+struct S_FDD { float p0; double p1; double p2; };
+struct S_FDP { float p0; double p1; void* p2; };
+struct S_FPI { float p0; void* p1; int p2; };
+struct S_FPF { float p0; void* p1; float p2; };
+struct S_FPD { float p0; void* p1; double p2; };
+struct S_FPP { float p0; void* p1; void* p2; };
+struct S_DII { double p0; int p1; int p2; };
+struct S_DIF { double p0; int p1; float p2; };
+struct S_DID { double p0; int p1; double p2; };
+struct S_DIP { double p0; int p1; void* p2; };
+struct S_DFI { double p0; float p1; int p2; };
+struct S_DFF { double p0; float p1; float p2; };
+struct S_DFD { double p0; float p1; double p2; };
+struct S_DFP { double p0; float p1; void* p2; };
+struct S_DDI { double p0; double p1; int p2; };
+struct S_DDF { double p0; double p1; float p2; };
+struct S_DDD { double p0; double p1; double p2; };
+struct S_DDP { double p0; double p1; void* p2; };
+struct S_DPI { double p0; void* p1; int p2; };
+struct S_DPF { double p0; void* p1; float p2; };
+struct S_DPD { double p0; void* p1; double p2; };
+struct S_DPP { double p0; void* p1; void* p2; };
+struct S_PII { void* p0; int p1; int p2; };
+struct S_PIF { void* p0; int p1; float p2; };
+struct S_PID { void* p0; int p1; double p2; };
+struct S_PIP { void* p0; int p1; void* p2; };
+struct S_PFI { void* p0; float p1; int p2; };
+struct S_PFF { void* p0; float p1; float p2; };
+struct S_PFD { void* p0; float p1; double p2; };
+struct S_PFP { void* p0; float p1; void* p2; };
+struct S_PDI { void* p0; double p1; int p2; };
+struct S_PDF { void* p0; double p1; float p2; };
+struct S_PDD { void* p0; double p1; double p2; };
+struct S_PDP { void* p0; double p1; void* p2; };
+struct S_PPI { void* p0; void* p1; int p2; };
+struct S_PPF { void* p0; void* p1; float p2; };
+struct S_PPD { void* p0; void* p1; double p2; };
+struct S_PPP { void* p0; void* p1; void* p2; };
+EXPORT void f0_V__(void) ;
+EXPORT void f0_V_I_(int p0) ;
+EXPORT void f0_V_F_(float p0) ;
+EXPORT void f0_V_D_(double p0) ;
+EXPORT void f0_V_P_(void* p0) ;
+EXPORT void f0_V_S_I(struct S_I p0) ;
+EXPORT void f0_V_S_F(struct S_F p0) ;
+EXPORT void f0_V_S_D(struct S_D p0) ;
+EXPORT void f0_V_S_P(struct S_P p0) ;
+EXPORT void f0_V_S_II(struct S_II p0) ;
+EXPORT void f0_V_S_IF(struct S_IF p0) ;
+EXPORT void f0_V_S_ID(struct S_ID p0) ;
+EXPORT void f0_V_S_IP(struct S_IP p0) ;
+EXPORT void f0_V_S_FI(struct S_FI p0) ;
+EXPORT void f0_V_S_FF(struct S_FF p0) ;
+EXPORT void f0_V_S_FD(struct S_FD p0) ;
+EXPORT void f0_V_S_FP(struct S_FP p0) ;
+EXPORT void f0_V_S_DI(struct S_DI p0) ;
+EXPORT void f0_V_S_DF(struct S_DF p0) ;
+EXPORT void f0_V_S_DD(struct S_DD p0) ;
+EXPORT void f0_V_S_DP(struct S_DP p0) ;
+EXPORT void f0_V_S_PI(struct S_PI p0) ;
+EXPORT void f0_V_S_PF(struct S_PF p0) ;
+EXPORT void f0_V_S_PD(struct S_PD p0) ;
+EXPORT void f0_V_S_PP(struct S_PP p0) ;
+EXPORT void f0_V_S_III(struct S_III p0) ;
+EXPORT void f0_V_S_IIF(struct S_IIF p0) ;
+EXPORT void f0_V_S_IID(struct S_IID p0) ;
+EXPORT void f0_V_S_IIP(struct S_IIP p0) ;
+EXPORT void f0_V_S_IFI(struct S_IFI p0) ;
+EXPORT void f0_V_S_IFF(struct S_IFF p0) ;
+EXPORT void f0_V_S_IFD(struct S_IFD p0) ;
+EXPORT void f0_V_S_IFP(struct S_IFP p0) ;
+EXPORT void f0_V_S_IDI(struct S_IDI p0) ;
+EXPORT void f0_V_S_IDF(struct S_IDF p0) ;
+EXPORT void f0_V_S_IDD(struct S_IDD p0) ;
+EXPORT void f0_V_S_IDP(struct S_IDP p0) ;
+EXPORT void f0_V_S_IPI(struct S_IPI p0) ;
+EXPORT void f0_V_S_IPF(struct S_IPF p0) ;
+EXPORT void f0_V_S_IPD(struct S_IPD p0) ;
+EXPORT void f0_V_S_IPP(struct S_IPP p0) ;
+EXPORT void f0_V_S_FII(struct S_FII p0) ;
+EXPORT void f0_V_S_FIF(struct S_FIF p0) ;
+EXPORT void f0_V_S_FID(struct S_FID p0) ;
+EXPORT void f0_V_S_FIP(struct S_FIP p0) ;
+EXPORT void f0_V_S_FFI(struct S_FFI p0) ;
+EXPORT void f0_V_S_FFF(struct S_FFF p0) ;
+EXPORT void f0_V_S_FFD(struct S_FFD p0) ;
+EXPORT void f0_V_S_FFP(struct S_FFP p0) ;
+EXPORT void f0_V_S_FDI(struct S_FDI p0) ;
+EXPORT void f0_V_S_FDF(struct S_FDF p0) ;
+EXPORT void f0_V_S_FDD(struct S_FDD p0) ;
+EXPORT void f0_V_S_FDP(struct S_FDP p0) ;
+EXPORT void f0_V_S_FPI(struct S_FPI p0) ;
+EXPORT void f0_V_S_FPF(struct S_FPF p0) ;
+EXPORT void f0_V_S_FPD(struct S_FPD p0) ;
+EXPORT void f0_V_S_FPP(struct S_FPP p0) ;
+EXPORT void f0_V_S_DII(struct S_DII p0) ;
+EXPORT void f0_V_S_DIF(struct S_DIF p0) ;
+EXPORT void f0_V_S_DID(struct S_DID p0) ;
+EXPORT void f0_V_S_DIP(struct S_DIP p0) ;
+EXPORT void f0_V_S_DFI(struct S_DFI p0) ;
+EXPORT void f0_V_S_DFF(struct S_DFF p0) ;
+EXPORT void f0_V_S_DFD(struct S_DFD p0) ;
+EXPORT void f0_V_S_DFP(struct S_DFP p0) ;
+EXPORT void f0_V_S_DDI(struct S_DDI p0) ;
+EXPORT void f0_V_S_DDF(struct S_DDF p0) ;
+EXPORT void f0_V_S_DDD(struct S_DDD p0) ;
+EXPORT void f0_V_S_DDP(struct S_DDP p0) ;
+EXPORT void f0_V_S_DPI(struct S_DPI p0) ;
+EXPORT void f0_V_S_DPF(struct S_DPF p0) ;
+EXPORT void f0_V_S_DPD(struct S_DPD p0) ;
+EXPORT void f0_V_S_DPP(struct S_DPP p0) ;
+EXPORT void f0_V_S_PII(struct S_PII p0) ;
+EXPORT void f0_V_S_PIF(struct S_PIF p0) ;
+EXPORT void f0_V_S_PID(struct S_PID p0) ;
+EXPORT void f0_V_S_PIP(struct S_PIP p0) ;
+EXPORT void f0_V_S_PFI(struct S_PFI p0) ;
+EXPORT void f0_V_S_PFF(struct S_PFF p0) ;
+EXPORT void f0_V_S_PFD(struct S_PFD p0) ;
+EXPORT void f0_V_S_PFP(struct S_PFP p0) ;
+EXPORT void f0_V_S_PDI(struct S_PDI p0) ;
+EXPORT void f0_V_S_PDF(struct S_PDF p0) ;
+EXPORT void f0_V_S_PDD(struct S_PDD p0) ;
+EXPORT void f0_V_S_PDP(struct S_PDP p0) ;
+EXPORT void f0_V_S_PPI(struct S_PPI p0) ;
+EXPORT void f0_V_S_PPF(struct S_PPF p0) ;
+EXPORT void f0_V_S_PPD(struct S_PPD p0) ;
+EXPORT void f0_V_S_PPP(struct S_PPP p0) ;
+EXPORT void f0_V_II_(int p0, int p1) ;
+EXPORT void f0_V_IF_(int p0, float p1) ;
+EXPORT void f0_V_ID_(int p0, double p1) ;
+EXPORT void f0_V_IP_(int p0, void* p1) ;
+EXPORT void f0_V_IS_I(int p0, struct S_I p1) ;
+EXPORT void f0_V_IS_F(int p0, struct S_F p1) ;
+EXPORT void f0_V_IS_D(int p0, struct S_D p1) ;
+EXPORT void f0_V_IS_P(int p0, struct S_P p1) ;
+EXPORT void f0_V_IS_II(int p0, struct S_II p1) ;
+EXPORT void f0_V_IS_IF(int p0, struct S_IF p1) ;
+EXPORT void f0_V_IS_ID(int p0, struct S_ID p1) ;
+EXPORT void f0_V_IS_IP(int p0, struct S_IP p1) ;
+EXPORT void f0_V_IS_FI(int p0, struct S_FI p1) ;
+EXPORT void f0_V_IS_FF(int p0, struct S_FF p1) ;
+EXPORT void f0_V_IS_FD(int p0, struct S_FD p1) ;
+EXPORT void f0_V_IS_FP(int p0, struct S_FP p1) ;
+EXPORT void f0_V_IS_DI(int p0, struct S_DI p1) ;
+EXPORT void f0_V_IS_DF(int p0, struct S_DF p1) ;
+EXPORT void f0_V_IS_DD(int p0, struct S_DD p1) ;
+EXPORT void f0_V_IS_DP(int p0, struct S_DP p1) ;
+EXPORT void f0_V_IS_PI(int p0, struct S_PI p1) ;
+EXPORT void f0_V_IS_PF(int p0, struct S_PF p1) ;
+EXPORT void f0_V_IS_PD(int p0, struct S_PD p1) ;
+EXPORT void f0_V_IS_PP(int p0, struct S_PP p1) ;
+EXPORT void f0_V_IS_III(int p0, struct S_III p1) ;
+EXPORT void f0_V_IS_IIF(int p0, struct S_IIF p1) ;
+EXPORT void f0_V_IS_IID(int p0, struct S_IID p1) ;
+EXPORT void f0_V_IS_IIP(int p0, struct S_IIP p1) ;
+EXPORT void f0_V_IS_IFI(int p0, struct S_IFI p1) ;
+EXPORT void f0_V_IS_IFF(int p0, struct S_IFF p1) ;
+EXPORT void f0_V_IS_IFD(int p0, struct S_IFD p1) ;
+EXPORT void f0_V_IS_IFP(int p0, struct S_IFP p1) ;
+EXPORT void f0_V_IS_IDI(int p0, struct S_IDI p1) ;
+EXPORT void f0_V_IS_IDF(int p0, struct S_IDF p1) ;
+EXPORT void f0_V_IS_IDD(int p0, struct S_IDD p1) ;
+EXPORT void f0_V_IS_IDP(int p0, struct S_IDP p1) ;
+EXPORT void f0_V_IS_IPI(int p0, struct S_IPI p1) ;
+EXPORT void f0_V_IS_IPF(int p0, struct S_IPF p1) ;
+EXPORT void f0_V_IS_IPD(int p0, struct S_IPD p1) ;
+EXPORT void f0_V_IS_IPP(int p0, struct S_IPP p1) ;
+EXPORT void f0_V_IS_FII(int p0, struct S_FII p1) ;
+EXPORT void f0_V_IS_FIF(int p0, struct S_FIF p1) ;
+EXPORT void f0_V_IS_FID(int p0, struct S_FID p1) ;
+EXPORT void f0_V_IS_FIP(int p0, struct S_FIP p1) ;
+EXPORT void f0_V_IS_FFI(int p0, struct S_FFI p1) ;
+EXPORT void f0_V_IS_FFF(int p0, struct S_FFF p1) ;
+EXPORT void f0_V_IS_FFD(int p0, struct S_FFD p1) ;
+EXPORT void f0_V_IS_FFP(int p0, struct S_FFP p1) ;
+EXPORT void f0_V_IS_FDI(int p0, struct S_FDI p1) ;
+EXPORT void f0_V_IS_FDF(int p0, struct S_FDF p1) ;
+EXPORT void f0_V_IS_FDD(int p0, struct S_FDD p1) ;
+EXPORT void f0_V_IS_FDP(int p0, struct S_FDP p1) ;
+EXPORT void f0_V_IS_FPI(int p0, struct S_FPI p1) ;
+EXPORT void f0_V_IS_FPF(int p0, struct S_FPF p1) ;
+EXPORT void f0_V_IS_FPD(int p0, struct S_FPD p1) ;
+EXPORT void f0_V_IS_FPP(int p0, struct S_FPP p1) ;
+EXPORT void f0_V_IS_DII(int p0, struct S_DII p1) ;
+EXPORT void f0_V_IS_DIF(int p0, struct S_DIF p1) ;
+EXPORT void f0_V_IS_DID(int p0, struct S_DID p1) ;
+EXPORT void f0_V_IS_DIP(int p0, struct S_DIP p1) ;
+EXPORT void f0_V_IS_DFI(int p0, struct S_DFI p1) ;
+EXPORT void f0_V_IS_DFF(int p0, struct S_DFF p1) ;
+EXPORT void f0_V_IS_DFD(int p0, struct S_DFD p1) ;
+EXPORT void f0_V_IS_DFP(int p0, struct S_DFP p1) ;
+EXPORT void f0_V_IS_DDI(int p0, struct S_DDI p1) ;
+EXPORT void f0_V_IS_DDF(int p0, struct S_DDF p1) ;
+EXPORT void f0_V_IS_DDD(int p0, struct S_DDD p1) ;
+EXPORT void f0_V_IS_DDP(int p0, struct S_DDP p1) ;
+EXPORT void f0_V_IS_DPI(int p0, struct S_DPI p1) ;
+EXPORT void f0_V_IS_DPF(int p0, struct S_DPF p1) ;
+EXPORT void f0_V_IS_DPD(int p0, struct S_DPD p1) ;
+EXPORT void f0_V_IS_DPP(int p0, struct S_DPP p1) ;
+EXPORT void f0_V_IS_PII(int p0, struct S_PII p1) ;
+EXPORT void f0_V_IS_PIF(int p0, struct S_PIF p1) ;
+EXPORT void f0_V_IS_PID(int p0, struct S_PID p1) ;
+EXPORT void f0_V_IS_PIP(int p0, struct S_PIP p1) ;
+EXPORT void f0_V_IS_PFI(int p0, struct S_PFI p1) ;
+EXPORT void f0_V_IS_PFF(int p0, struct S_PFF p1) ;
+EXPORT void f0_V_IS_PFD(int p0, struct S_PFD p1) ;
+EXPORT void f0_V_IS_PFP(int p0, struct S_PFP p1) ;
+EXPORT void f0_V_IS_PDI(int p0, struct S_PDI p1) ;
+EXPORT void f0_V_IS_PDF(int p0, struct S_PDF p1) ;
+EXPORT void f0_V_IS_PDD(int p0, struct S_PDD p1) ;
+EXPORT void f0_V_IS_PDP(int p0, struct S_PDP p1) ;
+EXPORT void f0_V_IS_PPI(int p0, struct S_PPI p1) ;
+EXPORT void f0_V_IS_PPF(int p0, struct S_PPF p1) ;
+EXPORT void f0_V_IS_PPD(int p0, struct S_PPD p1) ;
+EXPORT void f0_V_IS_PPP(int p0, struct S_PPP p1) ;
+EXPORT void f0_V_FI_(float p0, int p1) ;
+EXPORT void f0_V_FF_(float p0, float p1) ;
+EXPORT void f0_V_FD_(float p0, double p1) ;
+EXPORT void f0_V_FP_(float p0, void* p1) ;
+EXPORT void f0_V_FS_I(float p0, struct S_I p1) ;
+EXPORT void f0_V_FS_F(float p0, struct S_F p1) ;
+EXPORT void f0_V_FS_D(float p0, struct S_D p1) ;
+EXPORT void f0_V_FS_P(float p0, struct S_P p1) ;
+EXPORT void f0_V_FS_II(float p0, struct S_II p1) ;
+EXPORT void f0_V_FS_IF(float p0, struct S_IF p1) ;
+EXPORT void f0_V_FS_ID(float p0, struct S_ID p1) ;
+EXPORT void f0_V_FS_IP(float p0, struct S_IP p1) ;
+EXPORT void f0_V_FS_FI(float p0, struct S_FI p1) ;
+EXPORT void f0_V_FS_FF(float p0, struct S_FF p1) ;
+EXPORT void f0_V_FS_FD(float p0, struct S_FD p1) ;
+EXPORT void f0_V_FS_FP(float p0, struct S_FP p1) ;
+EXPORT void f0_V_FS_DI(float p0, struct S_DI p1) ;
+EXPORT void f0_V_FS_DF(float p0, struct S_DF p1) ;
+EXPORT void f0_V_FS_DD(float p0, struct S_DD p1) ;
+EXPORT void f0_V_FS_DP(float p0, struct S_DP p1) ;
+EXPORT void f0_V_FS_PI(float p0, struct S_PI p1) ;
+EXPORT void f0_V_FS_PF(float p0, struct S_PF p1) ;
+EXPORT void f0_V_FS_PD(float p0, struct S_PD p1) ;
+EXPORT void f0_V_FS_PP(float p0, struct S_PP p1) ;
+EXPORT void f0_V_FS_III(float p0, struct S_III p1) ;
+EXPORT void f0_V_FS_IIF(float p0, struct S_IIF p1) ;
+EXPORT void f0_V_FS_IID(float p0, struct S_IID p1) ;
+EXPORT void f0_V_FS_IIP(float p0, struct S_IIP p1) ;
+EXPORT void f0_V_FS_IFI(float p0, struct S_IFI p1) ;
+EXPORT void f0_V_FS_IFF(float p0, struct S_IFF p1) ;
+EXPORT void f0_V_FS_IFD(float p0, struct S_IFD p1) ;
+EXPORT void f0_V_FS_IFP(float p0, struct S_IFP p1) ;
+EXPORT void f0_V_FS_IDI(float p0, struct S_IDI p1) ;
+EXPORT void f0_V_FS_IDF(float p0, struct S_IDF p1) ;
+EXPORT void f0_V_FS_IDD(float p0, struct S_IDD p1) ;
+EXPORT void f0_V_FS_IDP(float p0, struct S_IDP p1) ;
+EXPORT void f0_V_FS_IPI(float p0, struct S_IPI p1) ;
+EXPORT void f0_V_FS_IPF(float p0, struct S_IPF p1) ;
+EXPORT void f0_V_FS_IPD(float p0, struct S_IPD p1) ;
+EXPORT void f0_V_FS_IPP(float p0, struct S_IPP p1) ;
+EXPORT void f0_V_FS_FII(float p0, struct S_FII p1) ;
+EXPORT void f0_V_FS_FIF(float p0, struct S_FIF p1) ;
+EXPORT void f0_V_FS_FID(float p0, struct S_FID p1) ;
+EXPORT void f0_V_FS_FIP(float p0, struct S_FIP p1) ;
+EXPORT void f0_V_FS_FFI(float p0, struct S_FFI p1) ;
+EXPORT void f0_V_FS_FFF(float p0, struct S_FFF p1) ;
+EXPORT void f0_V_FS_FFD(float p0, struct S_FFD p1) ;
+EXPORT void f0_V_FS_FFP(float p0, struct S_FFP p1) ;
+EXPORT void f0_V_FS_FDI(float p0, struct S_FDI p1) ;
+EXPORT void f0_V_FS_FDF(float p0, struct S_FDF p1) ;
+EXPORT void f0_V_FS_FDD(float p0, struct S_FDD p1) ;
+EXPORT void f0_V_FS_FDP(float p0, struct S_FDP p1) ;
+EXPORT void f0_V_FS_FPI(float p0, struct S_FPI p1) ;
+EXPORT void f0_V_FS_FPF(float p0, struct S_FPF p1) ;
+EXPORT void f0_V_FS_FPD(float p0, struct S_FPD p1) ;
+EXPORT void f0_V_FS_FPP(float p0, struct S_FPP p1) ;
+EXPORT void f0_V_FS_DII(float p0, struct S_DII p1) ;
+EXPORT void f0_V_FS_DIF(float p0, struct S_DIF p1) ;
+EXPORT void f0_V_FS_DID(float p0, struct S_DID p1) ;
+EXPORT void f0_V_FS_DIP(float p0, struct S_DIP p1) ;
+EXPORT void f0_V_FS_DFI(float p0, struct S_DFI p1) ;
+EXPORT void f0_V_FS_DFF(float p0, struct S_DFF p1) ;
+EXPORT void f0_V_FS_DFD(float p0, struct S_DFD p1) ;
+EXPORT void f0_V_FS_DFP(float p0, struct S_DFP p1) ;
+EXPORT void f0_V_FS_DDI(float p0, struct S_DDI p1) ;
+EXPORT void f0_V_FS_DDF(float p0, struct S_DDF p1) ;
+EXPORT void f0_V_FS_DDD(float p0, struct S_DDD p1) ;
+EXPORT void f0_V_FS_DDP(float p0, struct S_DDP p1) ;
+EXPORT void f0_V_FS_DPI(float p0, struct S_DPI p1) ;
+EXPORT void f0_V_FS_DPF(float p0, struct S_DPF p1) ;
+EXPORT void f0_V_FS_DPD(float p0, struct S_DPD p1) ;
+EXPORT void f0_V_FS_DPP(float p0, struct S_DPP p1) ;
+EXPORT void f0_V_FS_PII(float p0, struct S_PII p1) ;
+EXPORT void f0_V_FS_PIF(float p0, struct S_PIF p1) ;
+EXPORT void f0_V_FS_PID(float p0, struct S_PID p1) ;
+EXPORT void f0_V_FS_PIP(float p0, struct S_PIP p1) ;
+EXPORT void f0_V_FS_PFI(float p0, struct S_PFI p1) ;
+EXPORT void f0_V_FS_PFF(float p0, struct S_PFF p1) ;
+EXPORT void f0_V_FS_PFD(float p0, struct S_PFD p1) ;
+EXPORT void f0_V_FS_PFP(float p0, struct S_PFP p1) ;
+EXPORT void f0_V_FS_PDI(float p0, struct S_PDI p1) ;
+EXPORT void f0_V_FS_PDF(float p0, struct S_PDF p1) ;
+EXPORT void f0_V_FS_PDD(float p0, struct S_PDD p1) ;
+EXPORT void f0_V_FS_PDP(float p0, struct S_PDP p1) ;
+EXPORT void f0_V_FS_PPI(float p0, struct S_PPI p1) ;
+EXPORT void f0_V_FS_PPF(float p0, struct S_PPF p1) ;
+EXPORT void f0_V_FS_PPD(float p0, struct S_PPD p1) ;
+EXPORT void f0_V_FS_PPP(float p0, struct S_PPP p1) ;
+EXPORT void f0_V_DI_(double p0, int p1) ;
+EXPORT void f0_V_DF_(double p0, float p1) ;
+EXPORT void f0_V_DD_(double p0, double p1) ;
+EXPORT void f0_V_DP_(double p0, void* p1) ;
+EXPORT void f0_V_DS_I(double p0, struct S_I p1) ;
+EXPORT void f0_V_DS_F(double p0, struct S_F p1) ;
+EXPORT void f0_V_DS_D(double p0, struct S_D p1) ;
+EXPORT void f0_V_DS_P(double p0, struct S_P p1) ;
+EXPORT void f0_V_DS_II(double p0, struct S_II p1) ;
+EXPORT void f0_V_DS_IF(double p0, struct S_IF p1) ;
+EXPORT void f0_V_DS_ID(double p0, struct S_ID p1) ;
+EXPORT void f0_V_DS_IP(double p0, struct S_IP p1) ;
+EXPORT void f0_V_DS_FI(double p0, struct S_FI p1) ;
+EXPORT void f0_V_DS_FF(double p0, struct S_FF p1) ;
+EXPORT void f0_V_DS_FD(double p0, struct S_FD p1) ;
+EXPORT void f0_V_DS_FP(double p0, struct S_FP p1) ;
+EXPORT void f0_V_DS_DI(double p0, struct S_DI p1) ;
+EXPORT void f0_V_DS_DF(double p0, struct S_DF p1) ;
+EXPORT void f0_V_DS_DD(double p0, struct S_DD p1) ;
+EXPORT void f0_V_DS_DP(double p0, struct S_DP p1) ;
+EXPORT void f0_V_DS_PI(double p0, struct S_PI p1) ;
+EXPORT void f0_V_DS_PF(double p0, struct S_PF p1) ;
+EXPORT void f0_V_DS_PD(double p0, struct S_PD p1) ;
+EXPORT void f0_V_DS_PP(double p0, struct S_PP p1) ;
+EXPORT void f0_V_DS_III(double p0, struct S_III p1) ;
+EXPORT void f0_V_DS_IIF(double p0, struct S_IIF p1) ;
+EXPORT void f0_V_DS_IID(double p0, struct S_IID p1) ;
+EXPORT void f0_V_DS_IIP(double p0, struct S_IIP p1) ;
+EXPORT void f0_V_DS_IFI(double p0, struct S_IFI p1) ;
+EXPORT void f0_V_DS_IFF(double p0, struct S_IFF p1) ;
+EXPORT void f0_V_DS_IFD(double p0, struct S_IFD p1) ;
+EXPORT void f0_V_DS_IFP(double p0, struct S_IFP p1) ;
+EXPORT void f0_V_DS_IDI(double p0, struct S_IDI p1) ;
+EXPORT void f0_V_DS_IDF(double p0, struct S_IDF p1) ;
+EXPORT void f0_V_DS_IDD(double p0, struct S_IDD p1) ;
+EXPORT void f0_V_DS_IDP(double p0, struct S_IDP p1) ;
+EXPORT void f0_V_DS_IPI(double p0, struct S_IPI p1) ;
+EXPORT void f0_V_DS_IPF(double p0, struct S_IPF p1) ;
+EXPORT void f0_V_DS_IPD(double p0, struct S_IPD p1) ;
+EXPORT void f0_V_DS_IPP(double p0, struct S_IPP p1) ;
+EXPORT void f0_V_DS_FII(double p0, struct S_FII p1) ;
+EXPORT void f0_V_DS_FIF(double p0, struct S_FIF p1) ;
+EXPORT void f0_V_DS_FID(double p0, struct S_FID p1) ;
+EXPORT void f0_V_DS_FIP(double p0, struct S_FIP p1) ;
+EXPORT void f0_V_DS_FFI(double p0, struct S_FFI p1) ;
+EXPORT void f0_V_DS_FFF(double p0, struct S_FFF p1) ;
+EXPORT void f0_V_DS_FFD(double p0, struct S_FFD p1) ;
+EXPORT void f0_V_DS_FFP(double p0, struct S_FFP p1) ;
+EXPORT void f0_V_DS_FDI(double p0, struct S_FDI p1) ;
+EXPORT void f0_V_DS_FDF(double p0, struct S_FDF p1) ;
+EXPORT void f0_V_DS_FDD(double p0, struct S_FDD p1) ;
+EXPORT void f0_V_DS_FDP(double p0, struct S_FDP p1) ;
+EXPORT void f0_V_DS_FPI(double p0, struct S_FPI p1) ;
+EXPORT void f0_V_DS_FPF(double p0, struct S_FPF p1) ;
+EXPORT void f0_V_DS_FPD(double p0, struct S_FPD p1) ;
+EXPORT void f0_V_DS_FPP(double p0, struct S_FPP p1) ;
+EXPORT void f0_V_DS_DII(double p0, struct S_DII p1) ;
+EXPORT void f0_V_DS_DIF(double p0, struct S_DIF p1) ;
+EXPORT void f0_V_DS_DID(double p0, struct S_DID p1) ;
+EXPORT void f0_V_DS_DIP(double p0, struct S_DIP p1) ;
+EXPORT void f0_V_DS_DFI(double p0, struct S_DFI p1) ;
+EXPORT void f0_V_DS_DFF(double p0, struct S_DFF p1) ;
+EXPORT void f0_V_DS_DFD(double p0, struct S_DFD p1) ;
+EXPORT void f0_V_DS_DFP(double p0, struct S_DFP p1) ;
+EXPORT void f0_V_DS_DDI(double p0, struct S_DDI p1) ;
+EXPORT void f0_V_DS_DDF(double p0, struct S_DDF p1) ;
+EXPORT void f0_V_DS_DDD(double p0, struct S_DDD p1) ;
+EXPORT void f0_V_DS_DDP(double p0, struct S_DDP p1) ;
+EXPORT void f0_V_DS_DPI(double p0, struct S_DPI p1) ;
+EXPORT void f0_V_DS_DPF(double p0, struct S_DPF p1) ;
+EXPORT void f0_V_DS_DPD(double p0, struct S_DPD p1) ;
+EXPORT void f0_V_DS_DPP(double p0, struct S_DPP p1) ;
+EXPORT void f0_V_DS_PII(double p0, struct S_PII p1) ;
+EXPORT void f0_V_DS_PIF(double p0, struct S_PIF p1) ;
+EXPORT void f0_V_DS_PID(double p0, struct S_PID p1) ;
+EXPORT void f0_V_DS_PIP(double p0, struct S_PIP p1) ;
+EXPORT void f0_V_DS_PFI(double p0, struct S_PFI p1) ;
+EXPORT void f0_V_DS_PFF(double p0, struct S_PFF p1) ;
+EXPORT void f0_V_DS_PFD(double p0, struct S_PFD p1) ;
+EXPORT void f0_V_DS_PFP(double p0, struct S_PFP p1) ;
+EXPORT void f0_V_DS_PDI(double p0, struct S_PDI p1) ;
+EXPORT void f0_V_DS_PDF(double p0, struct S_PDF p1) ;
+EXPORT void f0_V_DS_PDD(double p0, struct S_PDD p1) ;
+EXPORT void f0_V_DS_PDP(double p0, struct S_PDP p1) ;
+EXPORT void f0_V_DS_PPI(double p0, struct S_PPI p1) ;
+EXPORT void f0_V_DS_PPF(double p0, struct S_PPF p1) ;
+EXPORT void f0_V_DS_PPD(double p0, struct S_PPD p1) ;
+EXPORT void f0_V_DS_PPP(double p0, struct S_PPP p1) ;
+EXPORT void f0_V_PI_(void* p0, int p1) ;
+EXPORT void f0_V_PF_(void* p0, float p1) ;
+EXPORT void f0_V_PD_(void* p0, double p1) ;
+EXPORT void f0_V_PP_(void* p0, void* p1) ;
+EXPORT void f0_V_PS_I(void* p0, struct S_I p1) ;
+EXPORT void f0_V_PS_F(void* p0, struct S_F p1) ;
+EXPORT void f0_V_PS_D(void* p0, struct S_D p1) ;
+EXPORT void f0_V_PS_P(void* p0, struct S_P p1) ;
+EXPORT void f0_V_PS_II(void* p0, struct S_II p1) ;
+EXPORT void f0_V_PS_IF(void* p0, struct S_IF p1) ;
+EXPORT void f0_V_PS_ID(void* p0, struct S_ID p1) ;
+EXPORT void f0_V_PS_IP(void* p0, struct S_IP p1) ;
+EXPORT void f0_V_PS_FI(void* p0, struct S_FI p1) ;
+EXPORT void f0_V_PS_FF(void* p0, struct S_FF p1) ;
+EXPORT void f0_V_PS_FD(void* p0, struct S_FD p1) ;
+EXPORT void f0_V_PS_FP(void* p0, struct S_FP p1) ;
+EXPORT void f0_V_PS_DI(void* p0, struct S_DI p1) ;
+EXPORT void f0_V_PS_DF(void* p0, struct S_DF p1) ;
+EXPORT void f0_V_PS_DD(void* p0, struct S_DD p1) ;
+EXPORT void f0_V_PS_DP(void* p0, struct S_DP p1) ;
+EXPORT void f0_V_PS_PI(void* p0, struct S_PI p1) ;
+EXPORT void f0_V_PS_PF(void* p0, struct S_PF p1) ;
+EXPORT void f0_V_PS_PD(void* p0, struct S_PD p1) ;
+EXPORT void f0_V_PS_PP(void* p0, struct S_PP p1) ;
+EXPORT void f0_V_PS_III(void* p0, struct S_III p1) ;
+EXPORT void f0_V_PS_IIF(void* p0, struct S_IIF p1) ;
+EXPORT void f0_V_PS_IID(void* p0, struct S_IID p1) ;
+EXPORT void f0_V_PS_IIP(void* p0, struct S_IIP p1) ;
+EXPORT void f0_V_PS_IFI(void* p0, struct S_IFI p1) ;
+EXPORT void f0_V_PS_IFF(void* p0, struct S_IFF p1) ;
+EXPORT void f0_V_PS_IFD(void* p0, struct S_IFD p1) ;
+EXPORT void f0_V_PS_IFP(void* p0, struct S_IFP p1) ;
+EXPORT void f0_V_PS_IDI(void* p0, struct S_IDI p1) ;
+EXPORT void f0_V_PS_IDF(void* p0, struct S_IDF p1) ;
+EXPORT void f0_V_PS_IDD(void* p0, struct S_IDD p1) ;
+EXPORT void f0_V_PS_IDP(void* p0, struct S_IDP p1) ;
+EXPORT void f0_V_PS_IPI(void* p0, struct S_IPI p1) ;
+EXPORT void f0_V_PS_IPF(void* p0, struct S_IPF p1) ;
+EXPORT void f0_V_PS_IPD(void* p0, struct S_IPD p1) ;
+EXPORT void f0_V_PS_IPP(void* p0, struct S_IPP p1) ;
+EXPORT void f0_V_PS_FII(void* p0, struct S_FII p1) ;
+EXPORT void f0_V_PS_FIF(void* p0, struct S_FIF p1) ;
+EXPORT void f0_V_PS_FID(void* p0, struct S_FID p1) ;
+EXPORT void f0_V_PS_FIP(void* p0, struct S_FIP p1) ;
+EXPORT void f0_V_PS_FFI(void* p0, struct S_FFI p1) ;
+EXPORT void f0_V_PS_FFF(void* p0, struct S_FFF p1) ;
+EXPORT void f0_V_PS_FFD(void* p0, struct S_FFD p1) ;
+EXPORT void f0_V_PS_FFP(void* p0, struct S_FFP p1) ;
+EXPORT void f0_V_PS_FDI(void* p0, struct S_FDI p1) ;
+EXPORT void f0_V_PS_FDF(void* p0, struct S_FDF p1) ;
+EXPORT void f0_V_PS_FDD(void* p0, struct S_FDD p1) ;
+EXPORT void f0_V_PS_FDP(void* p0, struct S_FDP p1) ;
+EXPORT void f0_V_PS_FPI(void* p0, struct S_FPI p1) ;
+EXPORT void f0_V_PS_FPF(void* p0, struct S_FPF p1) ;
+EXPORT void f0_V_PS_FPD(void* p0, struct S_FPD p1) ;
+EXPORT void f0_V_PS_FPP(void* p0, struct S_FPP p1) ;
+EXPORT void f0_V_PS_DII(void* p0, struct S_DII p1) ;
+EXPORT void f0_V_PS_DIF(void* p0, struct S_DIF p1) ;
+EXPORT void f0_V_PS_DID(void* p0, struct S_DID p1) ;
+EXPORT void f0_V_PS_DIP(void* p0, struct S_DIP p1) ;
+EXPORT void f0_V_PS_DFI(void* p0, struct S_DFI p1) ;
+EXPORT void f0_V_PS_DFF(void* p0, struct S_DFF p1) ;
+EXPORT void f0_V_PS_DFD(void* p0, struct S_DFD p1) ;
+EXPORT void f0_V_PS_DFP(void* p0, struct S_DFP p1) ;
+EXPORT void f0_V_PS_DDI(void* p0, struct S_DDI p1) ;
+EXPORT void f0_V_PS_DDF(void* p0, struct S_DDF p1) ;
+EXPORT void f0_V_PS_DDD(void* p0, struct S_DDD p1) ;
+EXPORT void f0_V_PS_DDP(void* p0, struct S_DDP p1) ;
+EXPORT void f0_V_PS_DPI(void* p0, struct S_DPI p1) ;
+EXPORT void f0_V_PS_DPF(void* p0, struct S_DPF p1) ;
+EXPORT void f0_V_PS_DPD(void* p0, struct S_DPD p1) ;
+EXPORT void f0_V_PS_DPP(void* p0, struct S_DPP p1) ;
+EXPORT void f0_V_PS_PII(void* p0, struct S_PII p1) ;
+EXPORT void f0_V_PS_PIF(void* p0, struct S_PIF p1) ;
+EXPORT void f0_V_PS_PID(void* p0, struct S_PID p1) ;
+EXPORT void f0_V_PS_PIP(void* p0, struct S_PIP p1) ;
+EXPORT void f0_V_PS_PFI(void* p0, struct S_PFI p1) ;
+EXPORT void f0_V_PS_PFF(void* p0, struct S_PFF p1) ;
+EXPORT void f0_V_PS_PFD(void* p0, struct S_PFD p1) ;
+EXPORT void f0_V_PS_PFP(void* p0, struct S_PFP p1) ;
+EXPORT void f0_V_PS_PDI(void* p0, struct S_PDI p1) ;
+EXPORT void f0_V_PS_PDF(void* p0, struct S_PDF p1) ;
+EXPORT void f0_V_PS_PDD(void* p0, struct S_PDD p1) ;
+EXPORT void f0_V_PS_PDP(void* p0, struct S_PDP p1) ;
+EXPORT void f0_V_PS_PPI(void* p0, struct S_PPI p1) ;
+EXPORT void f0_V_PS_PPF(void* p0, struct S_PPF p1) ;
+EXPORT void f0_V_PS_PPD(void* p0, struct S_PPD p1) ;
+EXPORT void f0_V_PS_PPP(void* p0, struct S_PPP p1) ;
+EXPORT void f0_V_SI_I(struct S_I p0, int p1) ;
+EXPORT void f0_V_SI_F(struct S_F p0, int p1) ;
+EXPORT void f0_V_SI_D(struct S_D p0, int p1) ;
+EXPORT void f0_V_SI_P(struct S_P p0, int p1) ;
+EXPORT void f0_V_SI_II(struct S_II p0, int p1) ;
+EXPORT void f0_V_SI_IF(struct S_IF p0, int p1) ;
+EXPORT void f0_V_SI_ID(struct S_ID p0, int p1) ;
+EXPORT void f0_V_SI_IP(struct S_IP p0, int p1) ;
+EXPORT void f0_V_SI_FI(struct S_FI p0, int p1) ;
+EXPORT void f0_V_SI_FF(struct S_FF p0, int p1) ;
+EXPORT void f0_V_SI_FD(struct S_FD p0, int p1) ;
+EXPORT void f0_V_SI_FP(struct S_FP p0, int p1) ;
+EXPORT void f0_V_SI_DI(struct S_DI p0, int p1) ;
+EXPORT void f0_V_SI_DF(struct S_DF p0, int p1) ;
+EXPORT void f0_V_SI_DD(struct S_DD p0, int p1) ;
+EXPORT void f0_V_SI_DP(struct S_DP p0, int p1) ;
+EXPORT void f0_V_SI_PI(struct S_PI p0, int p1) ;
+EXPORT void f0_V_SI_PF(struct S_PF p0, int p1) ;
+EXPORT void f0_V_SI_PD(struct S_PD p0, int p1) ;
+EXPORT void f0_V_SI_PP(struct S_PP p0, int p1) ;
+EXPORT void f0_V_SI_III(struct S_III p0, int p1) ;
+EXPORT void f0_V_SI_IIF(struct S_IIF p0, int p1) ;
+EXPORT void f0_V_SI_IID(struct S_IID p0, int p1) ;
+EXPORT void f0_V_SI_IIP(struct S_IIP p0, int p1) ;
+EXPORT void f0_V_SI_IFI(struct S_IFI p0, int p1) ;
+EXPORT void f0_V_SI_IFF(struct S_IFF p0, int p1) ;
+EXPORT void f0_V_SI_IFD(struct S_IFD p0, int p1) ;
+EXPORT void f0_V_SI_IFP(struct S_IFP p0, int p1) ;
+EXPORT void f0_V_SI_IDI(struct S_IDI p0, int p1) ;
+EXPORT void f0_V_SI_IDF(struct S_IDF p0, int p1) ;
+EXPORT void f0_V_SI_IDD(struct S_IDD p0, int p1) ;
+EXPORT void f0_V_SI_IDP(struct S_IDP p0, int p1) ;
+EXPORT void f0_V_SI_IPI(struct S_IPI p0, int p1) ;
+EXPORT void f0_V_SI_IPF(struct S_IPF p0, int p1) ;
+EXPORT void f0_V_SI_IPD(struct S_IPD p0, int p1) ;
+EXPORT void f0_V_SI_IPP(struct S_IPP p0, int p1) ;
+EXPORT void f0_V_SI_FII(struct S_FII p0, int p1) ;
+EXPORT void f0_V_SI_FIF(struct S_FIF p0, int p1) ;
+EXPORT void f0_V_SI_FID(struct S_FID p0, int p1) ;
+EXPORT void f0_V_SI_FIP(struct S_FIP p0, int p1) ;
+EXPORT void f0_V_SI_FFI(struct S_FFI p0, int p1) ;
+EXPORT void f0_V_SI_FFF(struct S_FFF p0, int p1) ;
+EXPORT void f0_V_SI_FFD(struct S_FFD p0, int p1) ;
+EXPORT void f0_V_SI_FFP(struct S_FFP p0, int p1) ;
+EXPORT void f0_V_SI_FDI(struct S_FDI p0, int p1) ;
+EXPORT void f0_V_SI_FDF(struct S_FDF p0, int p1) ;
+EXPORT void f0_V_SI_FDD(struct S_FDD p0, int p1) ;
+EXPORT void f0_V_SI_FDP(struct S_FDP p0, int p1) ;
+EXPORT void f0_V_SI_FPI(struct S_FPI p0, int p1) ;
+EXPORT void f0_V_SI_FPF(struct S_FPF p0, int p1) ;
+EXPORT void f0_V_SI_FPD(struct S_FPD p0, int p1) ;
+EXPORT void f0_V_SI_FPP(struct S_FPP p0, int p1) ;
+EXPORT void f0_V_SI_DII(struct S_DII p0, int p1) ;
+EXPORT void f0_V_SI_DIF(struct S_DIF p0, int p1) ;
+EXPORT void f0_V_SI_DID(struct S_DID p0, int p1) ;
+EXPORT void f0_V_SI_DIP(struct S_DIP p0, int p1) ;
+EXPORT void f0_V_SI_DFI(struct S_DFI p0, int p1) ;
+EXPORT void f0_V_SI_DFF(struct S_DFF p0, int p1) ;
+EXPORT void f0_V_SI_DFD(struct S_DFD p0, int p1) ;
+EXPORT void f0_V_SI_DFP(struct S_DFP p0, int p1) ;
+EXPORT void f0_V_SI_DDI(struct S_DDI p0, int p1) ;
+EXPORT void f0_V_SI_DDF(struct S_DDF p0, int p1) ;
+EXPORT void f0_V_SI_DDD(struct S_DDD p0, int p1) ;
+EXPORT void f0_V_SI_DDP(struct S_DDP p0, int p1) ;
+EXPORT void f0_V_SI_DPI(struct S_DPI p0, int p1) ;
+EXPORT void f0_V_SI_DPF(struct S_DPF p0, int p1) ;
+EXPORT void f0_V_SI_DPD(struct S_DPD p0, int p1) ;
+EXPORT void f0_V_SI_DPP(struct S_DPP p0, int p1) ;
+EXPORT void f0_V_SI_PII(struct S_PII p0, int p1) ;
+EXPORT void f0_V_SI_PIF(struct S_PIF p0, int p1) ;
+EXPORT void f0_V_SI_PID(struct S_PID p0, int p1) ;
+EXPORT void f0_V_SI_PIP(struct S_PIP p0, int p1) ;
+EXPORT void f0_V_SI_PFI(struct S_PFI p0, int p1) ;
+EXPORT void f0_V_SI_PFF(struct S_PFF p0, int p1) ;
+EXPORT void f0_V_SI_PFD(struct S_PFD p0, int p1) ;
+EXPORT void f0_V_SI_PFP(struct S_PFP p0, int p1) ;
+EXPORT void f0_V_SI_PDI(struct S_PDI p0, int p1) ;
+EXPORT void f0_V_SI_PDF(struct S_PDF p0, int p1) ;
+EXPORT void f0_V_SI_PDD(struct S_PDD p0, int p1) ;
+EXPORT void f0_V_SI_PDP(struct S_PDP p0, int p1) ;
+EXPORT void f0_V_SI_PPI(struct S_PPI p0, int p1) ;
+EXPORT void f0_V_SI_PPF(struct S_PPF p0, int p1) ;
+EXPORT void f0_V_SI_PPD(struct S_PPD p0, int p1) ;
+EXPORT void f0_V_SI_PPP(struct S_PPP p0, int p1) ;
+EXPORT void f0_V_SF_I(struct S_I p0, float p1) ;
+EXPORT void f0_V_SF_F(struct S_F p0, float p1) ;
+EXPORT void f0_V_SF_D(struct S_D p0, float p1) ;
+EXPORT void f0_V_SF_P(struct S_P p0, float p1) ;
+EXPORT void f0_V_SF_II(struct S_II p0, float p1) ;
+EXPORT void f0_V_SF_IF(struct S_IF p0, float p1) ;
+EXPORT void f0_V_SF_ID(struct S_ID p0, float p1) ;
+EXPORT void f0_V_SF_IP(struct S_IP p0, float p1) ;
+EXPORT void f0_V_SF_FI(struct S_FI p0, float p1) ;
+EXPORT void f0_V_SF_FF(struct S_FF p0, float p1) ;
+EXPORT void f0_V_SF_FD(struct S_FD p0, float p1) ;
+EXPORT void f0_V_SF_FP(struct S_FP p0, float p1) ;
+EXPORT void f0_V_SF_DI(struct S_DI p0, float p1) ;
+EXPORT void f0_V_SF_DF(struct S_DF p0, float p1) ;
+EXPORT void f0_V_SF_DD(struct S_DD p0, float p1) ;
+EXPORT void f0_V_SF_DP(struct S_DP p0, float p1) ;
+EXPORT void f0_V_SF_PI(struct S_PI p0, float p1) ;
+EXPORT void f0_V_SF_PF(struct S_PF p0, float p1) ;
+EXPORT void f0_V_SF_PD(struct S_PD p0, float p1) ;
+EXPORT void f0_V_SF_PP(struct S_PP p0, float p1) ;
+EXPORT void f0_V_SF_III(struct S_III p0, float p1) ;
+EXPORT void f0_V_SF_IIF(struct S_IIF p0, float p1) ;
+EXPORT void f0_V_SF_IID(struct S_IID p0, float p1) ;
+EXPORT void f0_V_SF_IIP(struct S_IIP p0, float p1) ;
+EXPORT void f0_V_SF_IFI(struct S_IFI p0, float p1) ;
+EXPORT void f0_V_SF_IFF(struct S_IFF p0, float p1) ;
+EXPORT void f0_V_SF_IFD(struct S_IFD p0, float p1) ;
+EXPORT void f0_V_SF_IFP(struct S_IFP p0, float p1) ;
+EXPORT void f0_V_SF_IDI(struct S_IDI p0, float p1) ;
+EXPORT void f0_V_SF_IDF(struct S_IDF p0, float p1) ;
+EXPORT void f0_V_SF_IDD(struct S_IDD p0, float p1) ;
+EXPORT void f0_V_SF_IDP(struct S_IDP p0, float p1) ;
+EXPORT void f0_V_SF_IPI(struct S_IPI p0, float p1) ;
+EXPORT void f0_V_SF_IPF(struct S_IPF p0, float p1) ;
+EXPORT void f0_V_SF_IPD(struct S_IPD p0, float p1) ;
+EXPORT void f0_V_SF_IPP(struct S_IPP p0, float p1) ;
+EXPORT void f0_V_SF_FII(struct S_FII p0, float p1) ;
+EXPORT void f0_V_SF_FIF(struct S_FIF p0, float p1) ;
+EXPORT void f0_V_SF_FID(struct S_FID p0, float p1) ;
+EXPORT void f0_V_SF_FIP(struct S_FIP p0, float p1) ;
+EXPORT void f0_V_SF_FFI(struct S_FFI p0, float p1) ;
+EXPORT void f0_V_SF_FFF(struct S_FFF p0, float p1) ;
+EXPORT void f0_V_SF_FFD(struct S_FFD p0, float p1) ;
+EXPORT void f0_V_SF_FFP(struct S_FFP p0, float p1) ;
+EXPORT void f0_V_SF_FDI(struct S_FDI p0, float p1) ;
+EXPORT void f0_V_SF_FDF(struct S_FDF p0, float p1) ;
+EXPORT void f0_V_SF_FDD(struct S_FDD p0, float p1) ;
+EXPORT void f0_V_SF_FDP(struct S_FDP p0, float p1) ;
+EXPORT void f0_V_SF_FPI(struct S_FPI p0, float p1) ;
+EXPORT void f0_V_SF_FPF(struct S_FPF p0, float p1) ;
+EXPORT void f0_V_SF_FPD(struct S_FPD p0, float p1) ;
+EXPORT void f0_V_SF_FPP(struct S_FPP p0, float p1) ;
+EXPORT void f0_V_SF_DII(struct S_DII p0, float p1) ;
+EXPORT void f0_V_SF_DIF(struct S_DIF p0, float p1) ;
+EXPORT void f0_V_SF_DID(struct S_DID p0, float p1) ;
+EXPORT void f0_V_SF_DIP(struct S_DIP p0, float p1) ;
+EXPORT void f0_V_SF_DFI(struct S_DFI p0, float p1) ;
+EXPORT void f0_V_SF_DFF(struct S_DFF p0, float p1) ;
+EXPORT void f0_V_SF_DFD(struct S_DFD p0, float p1) ;
+EXPORT void f0_V_SF_DFP(struct S_DFP p0, float p1) ;
+EXPORT void f0_V_SF_DDI(struct S_DDI p0, float p1) ;
+EXPORT void f0_V_SF_DDF(struct S_DDF p0, float p1) ;
+EXPORT void f0_V_SF_DDD(struct S_DDD p0, float p1) ;
+EXPORT void f0_V_SF_DDP(struct S_DDP p0, float p1) ;
+EXPORT void f0_V_SF_DPI(struct S_DPI p0, float p1) ;
+EXPORT void f0_V_SF_DPF(struct S_DPF p0, float p1) ;
+EXPORT void f0_V_SF_DPD(struct S_DPD p0, float p1) ;
+EXPORT void f0_V_SF_DPP(struct S_DPP p0, float p1) ;
+EXPORT void f0_V_SF_PII(struct S_PII p0, float p1) ;
+EXPORT void f0_V_SF_PIF(struct S_PIF p0, float p1) ;
+EXPORT void f0_V_SF_PID(struct S_PID p0, float p1) ;
+EXPORT void f0_V_SF_PIP(struct S_PIP p0, float p1) ;
+EXPORT void f0_V_SF_PFI(struct S_PFI p0, float p1) ;
+EXPORT void f0_V_SF_PFF(struct S_PFF p0, float p1) ;
+EXPORT void f0_V_SF_PFD(struct S_PFD p0, float p1) ;
+EXPORT void f1_V_SF_PFP(struct S_PFP p0, float p1) ;
+EXPORT void f1_V_SF_PDI(struct S_PDI p0, float p1) ;
+EXPORT void f1_V_SF_PDF(struct S_PDF p0, float p1) ;
+EXPORT void f1_V_SF_PDD(struct S_PDD p0, float p1) ;
+EXPORT void f1_V_SF_PDP(struct S_PDP p0, float p1) ;
+EXPORT void f1_V_SF_PPI(struct S_PPI p0, float p1) ;
+EXPORT void f1_V_SF_PPF(struct S_PPF p0, float p1) ;
+EXPORT void f1_V_SF_PPD(struct S_PPD p0, float p1) ;
+EXPORT void f1_V_SF_PPP(struct S_PPP p0, float p1) ;
+EXPORT void f1_V_SD_I(struct S_I p0, double p1) ;
+EXPORT void f1_V_SD_F(struct S_F p0, double p1) ;
+EXPORT void f1_V_SD_D(struct S_D p0, double p1) ;
+EXPORT void f1_V_SD_P(struct S_P p0, double p1) ;
+EXPORT void f1_V_SD_II(struct S_II p0, double p1) ;
+EXPORT void f1_V_SD_IF(struct S_IF p0, double p1) ;
+EXPORT void f1_V_SD_ID(struct S_ID p0, double p1) ;
+EXPORT void f1_V_SD_IP(struct S_IP p0, double p1) ;
+EXPORT void f1_V_SD_FI(struct S_FI p0, double p1) ;
+EXPORT void f1_V_SD_FF(struct S_FF p0, double p1) ;
+EXPORT void f1_V_SD_FD(struct S_FD p0, double p1) ;
+EXPORT void f1_V_SD_FP(struct S_FP p0, double p1) ;
+EXPORT void f1_V_SD_DI(struct S_DI p0, double p1) ;
+EXPORT void f1_V_SD_DF(struct S_DF p0, double p1) ;
+EXPORT void f1_V_SD_DD(struct S_DD p0, double p1) ;
+EXPORT void f1_V_SD_DP(struct S_DP p0, double p1) ;
+EXPORT void f1_V_SD_PI(struct S_PI p0, double p1) ;
+EXPORT void f1_V_SD_PF(struct S_PF p0, double p1) ;
+EXPORT void f1_V_SD_PD(struct S_PD p0, double p1) ;
+EXPORT void f1_V_SD_PP(struct S_PP p0, double p1) ;
+EXPORT void f1_V_SD_III(struct S_III p0, double p1) ;
+EXPORT void f1_V_SD_IIF(struct S_IIF p0, double p1) ;
+EXPORT void f1_V_SD_IID(struct S_IID p0, double p1) ;
+EXPORT void f1_V_SD_IIP(struct S_IIP p0, double p1) ;
+EXPORT void f1_V_SD_IFI(struct S_IFI p0, double p1) ;
+EXPORT void f1_V_SD_IFF(struct S_IFF p0, double p1) ;
+EXPORT void f1_V_SD_IFD(struct S_IFD p0, double p1) ;
+EXPORT void f1_V_SD_IFP(struct S_IFP p0, double p1) ;
+EXPORT void f1_V_SD_IDI(struct S_IDI p0, double p1) ;
+EXPORT void f1_V_SD_IDF(struct S_IDF p0, double p1) ;
+EXPORT void f1_V_SD_IDD(struct S_IDD p0, double p1) ;
+EXPORT void f1_V_SD_IDP(struct S_IDP p0, double p1) ;
+EXPORT void f1_V_SD_IPI(struct S_IPI p0, double p1) ;
+EXPORT void f1_V_SD_IPF(struct S_IPF p0, double p1) ;
+EXPORT void f1_V_SD_IPD(struct S_IPD p0, double p1) ;
+EXPORT void f1_V_SD_IPP(struct S_IPP p0, double p1) ;
+EXPORT void f1_V_SD_FII(struct S_FII p0, double p1) ;
+EXPORT void f1_V_SD_FIF(struct S_FIF p0, double p1) ;
+EXPORT void f1_V_SD_FID(struct S_FID p0, double p1) ;
+EXPORT void f1_V_SD_FIP(struct S_FIP p0, double p1) ;
+EXPORT void f1_V_SD_FFI(struct S_FFI p0, double p1) ;
+EXPORT void f1_V_SD_FFF(struct S_FFF p0, double p1) ;
+EXPORT void f1_V_SD_FFD(struct S_FFD p0, double p1) ;
+EXPORT void f1_V_SD_FFP(struct S_FFP p0, double p1) ;
+EXPORT void f1_V_SD_FDI(struct S_FDI p0, double p1) ;
+EXPORT void f1_V_SD_FDF(struct S_FDF p0, double p1) ;
+EXPORT void f1_V_SD_FDD(struct S_FDD p0, double p1) ;
+EXPORT void f1_V_SD_FDP(struct S_FDP p0, double p1) ;
+EXPORT void f1_V_SD_FPI(struct S_FPI p0, double p1) ;
+EXPORT void f1_V_SD_FPF(struct S_FPF p0, double p1) ;
+EXPORT void f1_V_SD_FPD(struct S_FPD p0, double p1) ;
+EXPORT void f1_V_SD_FPP(struct S_FPP p0, double p1) ;
+EXPORT void f1_V_SD_DII(struct S_DII p0, double p1) ;
+EXPORT void f1_V_SD_DIF(struct S_DIF p0, double p1) ;
+EXPORT void f1_V_SD_DID(struct S_DID p0, double p1) ;
+EXPORT void f1_V_SD_DIP(struct S_DIP p0, double p1) ;
+EXPORT void f1_V_SD_DFI(struct S_DFI p0, double p1) ;
+EXPORT void f1_V_SD_DFF(struct S_DFF p0, double p1) ;
+EXPORT void f1_V_SD_DFD(struct S_DFD p0, double p1) ;
+EXPORT void f1_V_SD_DFP(struct S_DFP p0, double p1) ;
+EXPORT void f1_V_SD_DDI(struct S_DDI p0, double p1) ;
+EXPORT void f1_V_SD_DDF(struct S_DDF p0, double p1) ;
+EXPORT void f1_V_SD_DDD(struct S_DDD p0, double p1) ;
+EXPORT void f1_V_SD_DDP(struct S_DDP p0, double p1) ;
+EXPORT void f1_V_SD_DPI(struct S_DPI p0, double p1) ;
+EXPORT void f1_V_SD_DPF(struct S_DPF p0, double p1) ;
+EXPORT void f1_V_SD_DPD(struct S_DPD p0, double p1) ;
+EXPORT void f1_V_SD_DPP(struct S_DPP p0, double p1) ;
+EXPORT void f1_V_SD_PII(struct S_PII p0, double p1) ;
+EXPORT void f1_V_SD_PIF(struct S_PIF p0, double p1) ;
+EXPORT void f1_V_SD_PID(struct S_PID p0, double p1) ;
+EXPORT void f1_V_SD_PIP(struct S_PIP p0, double p1) ;
+EXPORT void f1_V_SD_PFI(struct S_PFI p0, double p1) ;
+EXPORT void f1_V_SD_PFF(struct S_PFF p0, double p1) ;
+EXPORT void f1_V_SD_PFD(struct S_PFD p0, double p1) ;
+EXPORT void f1_V_SD_PFP(struct S_PFP p0, double p1) ;
+EXPORT void f1_V_SD_PDI(struct S_PDI p0, double p1) ;
+EXPORT void f1_V_SD_PDF(struct S_PDF p0, double p1) ;
+EXPORT void f1_V_SD_PDD(struct S_PDD p0, double p1) ;
+EXPORT void f1_V_SD_PDP(struct S_PDP p0, double p1) ;
+EXPORT void f1_V_SD_PPI(struct S_PPI p0, double p1) ;
+EXPORT void f1_V_SD_PPF(struct S_PPF p0, double p1) ;
+EXPORT void f1_V_SD_PPD(struct S_PPD p0, double p1) ;
+EXPORT void f1_V_SD_PPP(struct S_PPP p0, double p1) ;
+EXPORT void f1_V_SP_I(struct S_I p0, void* p1) ;
+EXPORT void f1_V_SP_F(struct S_F p0, void* p1) ;
+EXPORT void f1_V_SP_D(struct S_D p0, void* p1) ;
+EXPORT void f1_V_SP_P(struct S_P p0, void* p1) ;
+EXPORT void f1_V_SP_II(struct S_II p0, void* p1) ;
+EXPORT void f1_V_SP_IF(struct S_IF p0, void* p1) ;
+EXPORT void f1_V_SP_ID(struct S_ID p0, void* p1) ;
+EXPORT void f1_V_SP_IP(struct S_IP p0, void* p1) ;
+EXPORT void f1_V_SP_FI(struct S_FI p0, void* p1) ;
+EXPORT void f1_V_SP_FF(struct S_FF p0, void* p1) ;
+EXPORT void f1_V_SP_FD(struct S_FD p0, void* p1) ;
+EXPORT void f1_V_SP_FP(struct S_FP p0, void* p1) ;
+EXPORT void f1_V_SP_DI(struct S_DI p0, void* p1) ;
+EXPORT void f1_V_SP_DF(struct S_DF p0, void* p1) ;
+EXPORT void f1_V_SP_DD(struct S_DD p0, void* p1) ;
+EXPORT void f1_V_SP_DP(struct S_DP p0, void* p1) ;
+EXPORT void f1_V_SP_PI(struct S_PI p0, void* p1) ;
+EXPORT void f1_V_SP_PF(struct S_PF p0, void* p1) ;
+EXPORT void f1_V_SP_PD(struct S_PD p0, void* p1) ;
+EXPORT void f1_V_SP_PP(struct S_PP p0, void* p1) ;
+EXPORT void f1_V_SP_III(struct S_III p0, void* p1) ;
+EXPORT void f1_V_SP_IIF(struct S_IIF p0, void* p1) ;
+EXPORT void f1_V_SP_IID(struct S_IID p0, void* p1) ;
+EXPORT void f1_V_SP_IIP(struct S_IIP p0, void* p1) ;
+EXPORT void f1_V_SP_IFI(struct S_IFI p0, void* p1) ;
+EXPORT void f1_V_SP_IFF(struct S_IFF p0, void* p1) ;
+EXPORT void f1_V_SP_IFD(struct S_IFD p0, void* p1) ;
+EXPORT void f1_V_SP_IFP(struct S_IFP p0, void* p1) ;
+EXPORT void f1_V_SP_IDI(struct S_IDI p0, void* p1) ;
+EXPORT void f1_V_SP_IDF(struct S_IDF p0, void* p1) ;
+EXPORT void f1_V_SP_IDD(struct S_IDD p0, void* p1) ;
+EXPORT void f1_V_SP_IDP(struct S_IDP p0, void* p1) ;
+EXPORT void f1_V_SP_IPI(struct S_IPI p0, void* p1) ;
+EXPORT void f1_V_SP_IPF(struct S_IPF p0, void* p1) ;
+EXPORT void f1_V_SP_IPD(struct S_IPD p0, void* p1) ;
+EXPORT void f1_V_SP_IPP(struct S_IPP p0, void* p1) ;
+EXPORT void f1_V_SP_FII(struct S_FII p0, void* p1) ;
+EXPORT void f1_V_SP_FIF(struct S_FIF p0, void* p1) ;
+EXPORT void f1_V_SP_FID(struct S_FID p0, void* p1) ;
+EXPORT void f1_V_SP_FIP(struct S_FIP p0, void* p1) ;
+EXPORT void f1_V_SP_FFI(struct S_FFI p0, void* p1) ;
+EXPORT void f1_V_SP_FFF(struct S_FFF p0, void* p1) ;
+EXPORT void f1_V_SP_FFD(struct S_FFD p0, void* p1) ;
+EXPORT void f1_V_SP_FFP(struct S_FFP p0, void* p1) ;
+EXPORT void f1_V_SP_FDI(struct S_FDI p0, void* p1) ;
+EXPORT void f1_V_SP_FDF(struct S_FDF p0, void* p1) ;
+EXPORT void f1_V_SP_FDD(struct S_FDD p0, void* p1) ;
+EXPORT void f1_V_SP_FDP(struct S_FDP p0, void* p1) ;
+EXPORT void f1_V_SP_FPI(struct S_FPI p0, void* p1) ;
+EXPORT void f1_V_SP_FPF(struct S_FPF p0, void* p1) ;
+EXPORT void f1_V_SP_FPD(struct S_FPD p0, void* p1) ;
+EXPORT void f1_V_SP_FPP(struct S_FPP p0, void* p1) ;
+EXPORT void f1_V_SP_DII(struct S_DII p0, void* p1) ;
+EXPORT void f1_V_SP_DIF(struct S_DIF p0, void* p1) ;
+EXPORT void f1_V_SP_DID(struct S_DID p0, void* p1) ;
+EXPORT void f1_V_SP_DIP(struct S_DIP p0, void* p1) ;
+EXPORT void f1_V_SP_DFI(struct S_DFI p0, void* p1) ;
+EXPORT void f1_V_SP_DFF(struct S_DFF p0, void* p1) ;
+EXPORT void f1_V_SP_DFD(struct S_DFD p0, void* p1) ;
+EXPORT void f1_V_SP_DFP(struct S_DFP p0, void* p1) ;
+EXPORT void f1_V_SP_DDI(struct S_DDI p0, void* p1) ;
+EXPORT void f1_V_SP_DDF(struct S_DDF p0, void* p1) ;
+EXPORT void f1_V_SP_DDD(struct S_DDD p0, void* p1) ;
+EXPORT void f1_V_SP_DDP(struct S_DDP p0, void* p1) ;
+EXPORT void f1_V_SP_DPI(struct S_DPI p0, void* p1) ;
+EXPORT void f1_V_SP_DPF(struct S_DPF p0, void* p1) ;
+EXPORT void f1_V_SP_DPD(struct S_DPD p0, void* p1) ;
+EXPORT void f1_V_SP_DPP(struct S_DPP p0, void* p1) ;
+EXPORT void f1_V_SP_PII(struct S_PII p0, void* p1) ;
+EXPORT void f1_V_SP_PIF(struct S_PIF p0, void* p1) ;
+EXPORT void f1_V_SP_PID(struct S_PID p0, void* p1) ;
+EXPORT void f1_V_SP_PIP(struct S_PIP p0, void* p1) ;
+EXPORT void f1_V_SP_PFI(struct S_PFI p0, void* p1) ;
+EXPORT void f1_V_SP_PFF(struct S_PFF p0, void* p1) ;
+EXPORT void f1_V_SP_PFD(struct S_PFD p0, void* p1) ;
+EXPORT void f1_V_SP_PFP(struct S_PFP p0, void* p1) ;
+EXPORT void f1_V_SP_PDI(struct S_PDI p0, void* p1) ;
+EXPORT void f1_V_SP_PDF(struct S_PDF p0, void* p1) ;
+EXPORT void f1_V_SP_PDD(struct S_PDD p0, void* p1) ;
+EXPORT void f1_V_SP_PDP(struct S_PDP p0, void* p1) ;
+EXPORT void f1_V_SP_PPI(struct S_PPI p0, void* p1) ;
+EXPORT void f1_V_SP_PPF(struct S_PPF p0, void* p1) ;
+EXPORT void f1_V_SP_PPD(struct S_PPD p0, void* p1) ;
+EXPORT void f1_V_SP_PPP(struct S_PPP p0, void* p1) ;
+EXPORT void f1_V_SS_I(struct S_I p0, struct S_I p1) ;
+EXPORT void f1_V_SS_F(struct S_F p0, struct S_F p1) ;
+EXPORT void f1_V_SS_D(struct S_D p0, struct S_D p1) ;
+EXPORT void f1_V_SS_P(struct S_P p0, struct S_P p1) ;
+EXPORT void f1_V_SS_II(struct S_II p0, struct S_II p1) ;
+EXPORT void f1_V_SS_IF(struct S_IF p0, struct S_IF p1) ;
+EXPORT void f1_V_SS_ID(struct S_ID p0, struct S_ID p1) ;
+EXPORT void f1_V_SS_IP(struct S_IP p0, struct S_IP p1) ;
+EXPORT void f1_V_SS_FI(struct S_FI p0, struct S_FI p1) ;
+EXPORT void f1_V_SS_FF(struct S_FF p0, struct S_FF p1) ;
+EXPORT void f1_V_SS_FD(struct S_FD p0, struct S_FD p1) ;
+EXPORT void f1_V_SS_FP(struct S_FP p0, struct S_FP p1) ;
+EXPORT void f1_V_SS_DI(struct S_DI p0, struct S_DI p1) ;
+EXPORT void f1_V_SS_DF(struct S_DF p0, struct S_DF p1) ;
+EXPORT void f1_V_SS_DD(struct S_DD p0, struct S_DD p1) ;
+EXPORT void f1_V_SS_DP(struct S_DP p0, struct S_DP p1) ;
+EXPORT void f1_V_SS_PI(struct S_PI p0, struct S_PI p1) ;
+EXPORT void f1_V_SS_PF(struct S_PF p0, struct S_PF p1) ;
+EXPORT void f1_V_SS_PD(struct S_PD p0, struct S_PD p1) ;
+EXPORT void f1_V_SS_PP(struct S_PP p0, struct S_PP p1) ;
+EXPORT void f1_V_SS_III(struct S_III p0, struct S_III p1) ;
+EXPORT void f1_V_SS_IIF(struct S_IIF p0, struct S_IIF p1) ;
+EXPORT void f1_V_SS_IID(struct S_IID p0, struct S_IID p1) ;
+EXPORT void f1_V_SS_IIP(struct S_IIP p0, struct S_IIP p1) ;
+EXPORT void f1_V_SS_IFI(struct S_IFI p0, struct S_IFI p1) ;
+EXPORT void f1_V_SS_IFF(struct S_IFF p0, struct S_IFF p1) ;
+EXPORT void f1_V_SS_IFD(struct S_IFD p0, struct S_IFD p1) ;
+EXPORT void f1_V_SS_IFP(struct S_IFP p0, struct S_IFP p1) ;
+EXPORT void f1_V_SS_IDI(struct S_IDI p0, struct S_IDI p1) ;
+EXPORT void f1_V_SS_IDF(struct S_IDF p0, struct S_IDF p1) ;
+EXPORT void f1_V_SS_IDD(struct S_IDD p0, struct S_IDD p1) ;
+EXPORT void f1_V_SS_IDP(struct S_IDP p0, struct S_IDP p1) ;
+EXPORT void f1_V_SS_IPI(struct S_IPI p0, struct S_IPI p1) ;
+EXPORT void f1_V_SS_IPF(struct S_IPF p0, struct S_IPF p1) ;
+EXPORT void f1_V_SS_IPD(struct S_IPD p0, struct S_IPD p1) ;
+EXPORT void f1_V_SS_IPP(struct S_IPP p0, struct S_IPP p1) ;
+EXPORT void f1_V_SS_FII(struct S_FII p0, struct S_FII p1) ;
+EXPORT void f1_V_SS_FIF(struct S_FIF p0, struct S_FIF p1) ;
+EXPORT void f1_V_SS_FID(struct S_FID p0, struct S_FID p1) ;
+EXPORT void f1_V_SS_FIP(struct S_FIP p0, struct S_FIP p1) ;
+EXPORT void f1_V_SS_FFI(struct S_FFI p0, struct S_FFI p1) ;
+EXPORT void f1_V_SS_FFF(struct S_FFF p0, struct S_FFF p1) ;
+EXPORT void f1_V_SS_FFD(struct S_FFD p0, struct S_FFD p1) ;
+EXPORT void f1_V_SS_FFP(struct S_FFP p0, struct S_FFP p1) ;
+EXPORT void f1_V_SS_FDI(struct S_FDI p0, struct S_FDI p1) ;
+EXPORT void f1_V_SS_FDF(struct S_FDF p0, struct S_FDF p1) ;
+EXPORT void f1_V_SS_FDD(struct S_FDD p0, struct S_FDD p1) ;
+EXPORT void f1_V_SS_FDP(struct S_FDP p0, struct S_FDP p1) ;
+EXPORT void f1_V_SS_FPI(struct S_FPI p0, struct S_FPI p1) ;
+EXPORT void f1_V_SS_FPF(struct S_FPF p0, struct S_FPF p1) ;
+EXPORT void f1_V_SS_FPD(struct S_FPD p0, struct S_FPD p1) ;
+EXPORT void f1_V_SS_FPP(struct S_FPP p0, struct S_FPP p1) ;
+EXPORT void f1_V_SS_DII(struct S_DII p0, struct S_DII p1) ;
+EXPORT void f1_V_SS_DIF(struct S_DIF p0, struct S_DIF p1) ;
+EXPORT void f1_V_SS_DID(struct S_DID p0, struct S_DID p1) ;
+EXPORT void f1_V_SS_DIP(struct S_DIP p0, struct S_DIP p1) ;
+EXPORT void f1_V_SS_DFI(struct S_DFI p0, struct S_DFI p1) ;
+EXPORT void f1_V_SS_DFF(struct S_DFF p0, struct S_DFF p1) ;
+EXPORT void f1_V_SS_DFD(struct S_DFD p0, struct S_DFD p1) ;
+EXPORT void f1_V_SS_DFP(struct S_DFP p0, struct S_DFP p1) ;
+EXPORT void f1_V_SS_DDI(struct S_DDI p0, struct S_DDI p1) ;
+EXPORT void f1_V_SS_DDF(struct S_DDF p0, struct S_DDF p1) ;
+EXPORT void f1_V_SS_DDD(struct S_DDD p0, struct S_DDD p1) ;
+EXPORT void f1_V_SS_DDP(struct S_DDP p0, struct S_DDP p1) ;
+EXPORT void f1_V_SS_DPI(struct S_DPI p0, struct S_DPI p1) ;
+EXPORT void f1_V_SS_DPF(struct S_DPF p0, struct S_DPF p1) ;
+EXPORT void f1_V_SS_DPD(struct S_DPD p0, struct S_DPD p1) ;
+EXPORT void f1_V_SS_DPP(struct S_DPP p0, struct S_DPP p1) ;
+EXPORT void f1_V_SS_PII(struct S_PII p0, struct S_PII p1) ;
+EXPORT void f1_V_SS_PIF(struct S_PIF p0, struct S_PIF p1) ;
+EXPORT void f1_V_SS_PID(struct S_PID p0, struct S_PID p1) ;
+EXPORT void f1_V_SS_PIP(struct S_PIP p0, struct S_PIP p1) ;
+EXPORT void f1_V_SS_PFI(struct S_PFI p0, struct S_PFI p1) ;
+EXPORT void f1_V_SS_PFF(struct S_PFF p0, struct S_PFF p1) ;
+EXPORT void f1_V_SS_PFD(struct S_PFD p0, struct S_PFD p1) ;
+EXPORT void f1_V_SS_PFP(struct S_PFP p0, struct S_PFP p1) ;
+EXPORT void f1_V_SS_PDI(struct S_PDI p0, struct S_PDI p1) ;
+EXPORT void f1_V_SS_PDF(struct S_PDF p0, struct S_PDF p1) ;
+EXPORT void f1_V_SS_PDD(struct S_PDD p0, struct S_PDD p1) ;
+EXPORT void f1_V_SS_PDP(struct S_PDP p0, struct S_PDP p1) ;
+EXPORT void f1_V_SS_PPI(struct S_PPI p0, struct S_PPI p1) ;
+EXPORT void f1_V_SS_PPF(struct S_PPF p0, struct S_PPF p1) ;
+EXPORT void f1_V_SS_PPD(struct S_PPD p0, struct S_PPD p1) ;
+EXPORT void f1_V_SS_PPP(struct S_PPP p0, struct S_PPP p1) ;
+EXPORT void f1_V_III_(int p0, int p1, int p2) ;
+EXPORT void f1_V_IIF_(int p0, int p1, float p2) ;
+EXPORT void f1_V_IID_(int p0, int p1, double p2) ;
+EXPORT void f1_V_IIP_(int p0, int p1, void* p2) ;
+EXPORT void f1_V_IIS_I(int p0, int p1, struct S_I p2) ;
+EXPORT void f1_V_IIS_F(int p0, int p1, struct S_F p2) ;
+EXPORT void f1_V_IIS_D(int p0, int p1, struct S_D p2) ;
+EXPORT void f1_V_IIS_P(int p0, int p1, struct S_P p2) ;
+EXPORT void f1_V_IIS_II(int p0, int p1, struct S_II p2) ;
+EXPORT void f1_V_IIS_IF(int p0, int p1, struct S_IF p2) ;
+EXPORT void f1_V_IIS_ID(int p0, int p1, struct S_ID p2) ;
+EXPORT void f1_V_IIS_IP(int p0, int p1, struct S_IP p2) ;
+EXPORT void f1_V_IIS_FI(int p0, int p1, struct S_FI p2) ;
+EXPORT void f1_V_IIS_FF(int p0, int p1, struct S_FF p2) ;
+EXPORT void f1_V_IIS_FD(int p0, int p1, struct S_FD p2) ;
+EXPORT void f1_V_IIS_FP(int p0, int p1, struct S_FP p2) ;
+EXPORT void f1_V_IIS_DI(int p0, int p1, struct S_DI p2) ;
+EXPORT void f1_V_IIS_DF(int p0, int p1, struct S_DF p2) ;
+EXPORT void f1_V_IIS_DD(int p0, int p1, struct S_DD p2) ;
+EXPORT void f1_V_IIS_DP(int p0, int p1, struct S_DP p2) ;
+EXPORT void f1_V_IIS_PI(int p0, int p1, struct S_PI p2) ;
+EXPORT void f1_V_IIS_PF(int p0, int p1, struct S_PF p2) ;
+EXPORT void f1_V_IIS_PD(int p0, int p1, struct S_PD p2) ;
+EXPORT void f1_V_IIS_PP(int p0, int p1, struct S_PP p2) ;
+EXPORT void f1_V_IIS_III(int p0, int p1, struct S_III p2) ;
+EXPORT void f1_V_IIS_IIF(int p0, int p1, struct S_IIF p2) ;
+EXPORT void f1_V_IIS_IID(int p0, int p1, struct S_IID p2) ;
+EXPORT void f1_V_IIS_IIP(int p0, int p1, struct S_IIP p2) ;
+EXPORT void f1_V_IIS_IFI(int p0, int p1, struct S_IFI p2) ;
+EXPORT void f1_V_IIS_IFF(int p0, int p1, struct S_IFF p2) ;
+EXPORT void f1_V_IIS_IFD(int p0, int p1, struct S_IFD p2) ;
+EXPORT void f1_V_IIS_IFP(int p0, int p1, struct S_IFP p2) ;
+EXPORT void f1_V_IIS_IDI(int p0, int p1, struct S_IDI p2) ;
+EXPORT void f1_V_IIS_IDF(int p0, int p1, struct S_IDF p2) ;
+EXPORT void f1_V_IIS_IDD(int p0, int p1, struct S_IDD p2) ;
+EXPORT void f1_V_IIS_IDP(int p0, int p1, struct S_IDP p2) ;
+EXPORT void f1_V_IIS_IPI(int p0, int p1, struct S_IPI p2) ;
+EXPORT void f1_V_IIS_IPF(int p0, int p1, struct S_IPF p2) ;
+EXPORT void f1_V_IIS_IPD(int p0, int p1, struct S_IPD p2) ;
+EXPORT void f1_V_IIS_IPP(int p0, int p1, struct S_IPP p2) ;
+EXPORT void f1_V_IIS_FII(int p0, int p1, struct S_FII p2) ;
+EXPORT void f1_V_IIS_FIF(int p0, int p1, struct S_FIF p2) ;
+EXPORT void f1_V_IIS_FID(int p0, int p1, struct S_FID p2) ;
+EXPORT void f1_V_IIS_FIP(int p0, int p1, struct S_FIP p2) ;
+EXPORT void f1_V_IIS_FFI(int p0, int p1, struct S_FFI p2) ;
+EXPORT void f1_V_IIS_FFF(int p0, int p1, struct S_FFF p2) ;
+EXPORT void f1_V_IIS_FFD(int p0, int p1, struct S_FFD p2) ;
+EXPORT void f1_V_IIS_FFP(int p0, int p1, struct S_FFP p2) ;
+EXPORT void f1_V_IIS_FDI(int p0, int p1, struct S_FDI p2) ;
+EXPORT void f1_V_IIS_FDF(int p0, int p1, struct S_FDF p2) ;
+EXPORT void f1_V_IIS_FDD(int p0, int p1, struct S_FDD p2) ;
+EXPORT void f1_V_IIS_FDP(int p0, int p1, struct S_FDP p2) ;
+EXPORT void f1_V_IIS_FPI(int p0, int p1, struct S_FPI p2) ;
+EXPORT void f1_V_IIS_FPF(int p0, int p1, struct S_FPF p2) ;
+EXPORT void f1_V_IIS_FPD(int p0, int p1, struct S_FPD p2) ;
+EXPORT void f1_V_IIS_FPP(int p0, int p1, struct S_FPP p2) ;
+EXPORT void f1_V_IIS_DII(int p0, int p1, struct S_DII p2) ;
+EXPORT void f1_V_IIS_DIF(int p0, int p1, struct S_DIF p2) ;
+EXPORT void f1_V_IIS_DID(int p0, int p1, struct S_DID p2) ;
+EXPORT void f1_V_IIS_DIP(int p0, int p1, struct S_DIP p2) ;
+EXPORT void f1_V_IIS_DFI(int p0, int p1, struct S_DFI p2) ;
+EXPORT void f1_V_IIS_DFF(int p0, int p1, struct S_DFF p2) ;
+EXPORT void f1_V_IIS_DFD(int p0, int p1, struct S_DFD p2) ;
+EXPORT void f1_V_IIS_DFP(int p0, int p1, struct S_DFP p2) ;
+EXPORT void f1_V_IIS_DDI(int p0, int p1, struct S_DDI p2) ;
+EXPORT void f1_V_IIS_DDF(int p0, int p1, struct S_DDF p2) ;
+EXPORT void f1_V_IIS_DDD(int p0, int p1, struct S_DDD p2) ;
+EXPORT void f1_V_IIS_DDP(int p0, int p1, struct S_DDP p2) ;
+EXPORT void f1_V_IIS_DPI(int p0, int p1, struct S_DPI p2) ;
+EXPORT void f1_V_IIS_DPF(int p0, int p1, struct S_DPF p2) ;
+EXPORT void f1_V_IIS_DPD(int p0, int p1, struct S_DPD p2) ;
+EXPORT void f1_V_IIS_DPP(int p0, int p1, struct S_DPP p2) ;
+EXPORT void f1_V_IIS_PII(int p0, int p1, struct S_PII p2) ;
+EXPORT void f1_V_IIS_PIF(int p0, int p1, struct S_PIF p2) ;
+EXPORT void f1_V_IIS_PID(int p0, int p1, struct S_PID p2) ;
+EXPORT void f1_V_IIS_PIP(int p0, int p1, struct S_PIP p2) ;
+EXPORT void f1_V_IIS_PFI(int p0, int p1, struct S_PFI p2) ;
+EXPORT void f1_V_IIS_PFF(int p0, int p1, struct S_PFF p2) ;
+EXPORT void f1_V_IIS_PFD(int p0, int p1, struct S_PFD p2) ;
+EXPORT void f1_V_IIS_PFP(int p0, int p1, struct S_PFP p2) ;
+EXPORT void f1_V_IIS_PDI(int p0, int p1, struct S_PDI p2) ;
+EXPORT void f1_V_IIS_PDF(int p0, int p1, struct S_PDF p2) ;
+EXPORT void f1_V_IIS_PDD(int p0, int p1, struct S_PDD p2) ;
+EXPORT void f1_V_IIS_PDP(int p0, int p1, struct S_PDP p2) ;
+EXPORT void f1_V_IIS_PPI(int p0, int p1, struct S_PPI p2) ;
+EXPORT void f1_V_IIS_PPF(int p0, int p1, struct S_PPF p2) ;
+EXPORT void f1_V_IIS_PPD(int p0, int p1, struct S_PPD p2) ;
+EXPORT void f1_V_IIS_PPP(int p0, int p1, struct S_PPP p2) ;
+EXPORT void f1_V_IFI_(int p0, float p1, int p2) ;
+EXPORT void f1_V_IFF_(int p0, float p1, float p2) ;
+EXPORT void f1_V_IFD_(int p0, float p1, double p2) ;
+EXPORT void f1_V_IFP_(int p0, float p1, void* p2) ;
+EXPORT void f1_V_IFS_I(int p0, float p1, struct S_I p2) ;
+EXPORT void f1_V_IFS_F(int p0, float p1, struct S_F p2) ;
+EXPORT void f1_V_IFS_D(int p0, float p1, struct S_D p2) ;
+EXPORT void f1_V_IFS_P(int p0, float p1, struct S_P p2) ;
+EXPORT void f1_V_IFS_II(int p0, float p1, struct S_II p2) ;
+EXPORT void f1_V_IFS_IF(int p0, float p1, struct S_IF p2) ;
+EXPORT void f1_V_IFS_ID(int p0, float p1, struct S_ID p2) ;
+EXPORT void f1_V_IFS_IP(int p0, float p1, struct S_IP p2) ;
+EXPORT void f1_V_IFS_FI(int p0, float p1, struct S_FI p2) ;
+EXPORT void f1_V_IFS_FF(int p0, float p1, struct S_FF p2) ;
+EXPORT void f1_V_IFS_FD(int p0, float p1, struct S_FD p2) ;
+EXPORT void f1_V_IFS_FP(int p0, float p1, struct S_FP p2) ;
+EXPORT void f1_V_IFS_DI(int p0, float p1, struct S_DI p2) ;
+EXPORT void f1_V_IFS_DF(int p0, float p1, struct S_DF p2) ;
+EXPORT void f1_V_IFS_DD(int p0, float p1, struct S_DD p2) ;
+EXPORT void f1_V_IFS_DP(int p0, float p1, struct S_DP p2) ;
+EXPORT void f1_V_IFS_PI(int p0, float p1, struct S_PI p2) ;
+EXPORT void f1_V_IFS_PF(int p0, float p1, struct S_PF p2) ;
+EXPORT void f1_V_IFS_PD(int p0, float p1, struct S_PD p2) ;
+EXPORT void f1_V_IFS_PP(int p0, float p1, struct S_PP p2) ;
+EXPORT void f1_V_IFS_III(int p0, float p1, struct S_III p2) ;
+EXPORT void f1_V_IFS_IIF(int p0, float p1, struct S_IIF p2) ;
+EXPORT void f1_V_IFS_IID(int p0, float p1, struct S_IID p2) ;
+EXPORT void f1_V_IFS_IIP(int p0, float p1, struct S_IIP p2) ;
+EXPORT void f1_V_IFS_IFI(int p0, float p1, struct S_IFI p2) ;
+EXPORT void f1_V_IFS_IFF(int p0, float p1, struct S_IFF p2) ;
+EXPORT void f1_V_IFS_IFD(int p0, float p1, struct S_IFD p2) ;
+EXPORT void f1_V_IFS_IFP(int p0, float p1, struct S_IFP p2) ;
+EXPORT void f1_V_IFS_IDI(int p0, float p1, struct S_IDI p2) ;
+EXPORT void f1_V_IFS_IDF(int p0, float p1, struct S_IDF p2) ;
+EXPORT void f1_V_IFS_IDD(int p0, float p1, struct S_IDD p2) ;
+EXPORT void f1_V_IFS_IDP(int p0, float p1, struct S_IDP p2) ;
+EXPORT void f1_V_IFS_IPI(int p0, float p1, struct S_IPI p2) ;
+EXPORT void f1_V_IFS_IPF(int p0, float p1, struct S_IPF p2) ;
+EXPORT void f1_V_IFS_IPD(int p0, float p1, struct S_IPD p2) ;
+EXPORT void f1_V_IFS_IPP(int p0, float p1, struct S_IPP p2) ;
+EXPORT void f1_V_IFS_FII(int p0, float p1, struct S_FII p2) ;
+EXPORT void f1_V_IFS_FIF(int p0, float p1, struct S_FIF p2) ;
+EXPORT void f1_V_IFS_FID(int p0, float p1, struct S_FID p2) ;
+EXPORT void f1_V_IFS_FIP(int p0, float p1, struct S_FIP p2) ;
+EXPORT void f1_V_IFS_FFI(int p0, float p1, struct S_FFI p2) ;
+EXPORT void f1_V_IFS_FFF(int p0, float p1, struct S_FFF p2) ;
+EXPORT void f1_V_IFS_FFD(int p0, float p1, struct S_FFD p2) ;
+EXPORT void f1_V_IFS_FFP(int p0, float p1, struct S_FFP p2) ;
+EXPORT void f1_V_IFS_FDI(int p0, float p1, struct S_FDI p2) ;
+EXPORT void f1_V_IFS_FDF(int p0, float p1, struct S_FDF p2) ;
+EXPORT void f1_V_IFS_FDD(int p0, float p1, struct S_FDD p2) ;
+EXPORT void f1_V_IFS_FDP(int p0, float p1, struct S_FDP p2) ;
+EXPORT void f1_V_IFS_FPI(int p0, float p1, struct S_FPI p2) ;
+EXPORT void f1_V_IFS_FPF(int p0, float p1, struct S_FPF p2) ;
+EXPORT void f1_V_IFS_FPD(int p0, float p1, struct S_FPD p2) ;
+EXPORT void f1_V_IFS_FPP(int p0, float p1, struct S_FPP p2) ;
+EXPORT void f1_V_IFS_DII(int p0, float p1, struct S_DII p2) ;
+EXPORT void f1_V_IFS_DIF(int p0, float p1, struct S_DIF p2) ;
+EXPORT void f1_V_IFS_DID(int p0, float p1, struct S_DID p2) ;
+EXPORT void f1_V_IFS_DIP(int p0, float p1, struct S_DIP p2) ;
+EXPORT void f1_V_IFS_DFI(int p0, float p1, struct S_DFI p2) ;
+EXPORT void f1_V_IFS_DFF(int p0, float p1, struct S_DFF p2) ;
+EXPORT void f1_V_IFS_DFD(int p0, float p1, struct S_DFD p2) ;
+EXPORT void f1_V_IFS_DFP(int p0, float p1, struct S_DFP p2) ;
+EXPORT void f1_V_IFS_DDI(int p0, float p1, struct S_DDI p2) ;
+EXPORT void f1_V_IFS_DDF(int p0, float p1, struct S_DDF p2) ;
+EXPORT void f1_V_IFS_DDD(int p0, float p1, struct S_DDD p2) ;
+EXPORT void f1_V_IFS_DDP(int p0, float p1, struct S_DDP p2) ;
+EXPORT void f1_V_IFS_DPI(int p0, float p1, struct S_DPI p2) ;
+EXPORT void f1_V_IFS_DPF(int p0, float p1, struct S_DPF p2) ;
+EXPORT void f1_V_IFS_DPD(int p0, float p1, struct S_DPD p2) ;
+EXPORT void f1_V_IFS_DPP(int p0, float p1, struct S_DPP p2) ;
+EXPORT void f1_V_IFS_PII(int p0, float p1, struct S_PII p2) ;
+EXPORT void f1_V_IFS_PIF(int p0, float p1, struct S_PIF p2) ;
+EXPORT void f1_V_IFS_PID(int p0, float p1, struct S_PID p2) ;
+EXPORT void f1_V_IFS_PIP(int p0, float p1, struct S_PIP p2) ;
+EXPORT void f1_V_IFS_PFI(int p0, float p1, struct S_PFI p2) ;
+EXPORT void f1_V_IFS_PFF(int p0, float p1, struct S_PFF p2) ;
+EXPORT void f1_V_IFS_PFD(int p0, float p1, struct S_PFD p2) ;
+EXPORT void f1_V_IFS_PFP(int p0, float p1, struct S_PFP p2) ;
+EXPORT void f1_V_IFS_PDI(int p0, float p1, struct S_PDI p2) ;
+EXPORT void f1_V_IFS_PDF(int p0, float p1, struct S_PDF p2) ;
+EXPORT void f1_V_IFS_PDD(int p0, float p1, struct S_PDD p2) ;
+EXPORT void f1_V_IFS_PDP(int p0, float p1, struct S_PDP p2) ;
+EXPORT void f1_V_IFS_PPI(int p0, float p1, struct S_PPI p2) ;
+EXPORT void f1_V_IFS_PPF(int p0, float p1, struct S_PPF p2) ;
+EXPORT void f1_V_IFS_PPD(int p0, float p1, struct S_PPD p2) ;
+EXPORT void f1_V_IFS_PPP(int p0, float p1, struct S_PPP p2) ;
+EXPORT void f1_V_IDI_(int p0, double p1, int p2) ;
+EXPORT void f1_V_IDF_(int p0, double p1, float p2) ;
+EXPORT void f1_V_IDD_(int p0, double p1, double p2) ;
+EXPORT void f1_V_IDP_(int p0, double p1, void* p2) ;
+EXPORT void f1_V_IDS_I(int p0, double p1, struct S_I p2) ;
+EXPORT void f1_V_IDS_F(int p0, double p1, struct S_F p2) ;
+EXPORT void f1_V_IDS_D(int p0, double p1, struct S_D p2) ;
+EXPORT void f1_V_IDS_P(int p0, double p1, struct S_P p2) ;
+EXPORT void f1_V_IDS_II(int p0, double p1, struct S_II p2) ;
+EXPORT void f1_V_IDS_IF(int p0, double p1, struct S_IF p2) ;
+EXPORT void f1_V_IDS_ID(int p0, double p1, struct S_ID p2) ;
+EXPORT void f1_V_IDS_IP(int p0, double p1, struct S_IP p2) ;
+EXPORT void f1_V_IDS_FI(int p0, double p1, struct S_FI p2) ;
+EXPORT void f1_V_IDS_FF(int p0, double p1, struct S_FF p2) ;
+EXPORT void f1_V_IDS_FD(int p0, double p1, struct S_FD p2) ;
+EXPORT void f1_V_IDS_FP(int p0, double p1, struct S_FP p2) ;
+EXPORT void f1_V_IDS_DI(int p0, double p1, struct S_DI p2) ;
+EXPORT void f1_V_IDS_DF(int p0, double p1, struct S_DF p2) ;
+EXPORT void f1_V_IDS_DD(int p0, double p1, struct S_DD p2) ;
+EXPORT void f1_V_IDS_DP(int p0, double p1, struct S_DP p2) ;
+EXPORT void f1_V_IDS_PI(int p0, double p1, struct S_PI p2) ;
+EXPORT void f1_V_IDS_PF(int p0, double p1, struct S_PF p2) ;
+EXPORT void f1_V_IDS_PD(int p0, double p1, struct S_PD p2) ;
+EXPORT void f1_V_IDS_PP(int p0, double p1, struct S_PP p2) ;
+EXPORT void f1_V_IDS_III(int p0, double p1, struct S_III p2) ;
+EXPORT void f1_V_IDS_IIF(int p0, double p1, struct S_IIF p2) ;
+EXPORT void f1_V_IDS_IID(int p0, double p1, struct S_IID p2) ;
+EXPORT void f1_V_IDS_IIP(int p0, double p1, struct S_IIP p2) ;
+EXPORT void f1_V_IDS_IFI(int p0, double p1, struct S_IFI p2) ;
+EXPORT void f1_V_IDS_IFF(int p0, double p1, struct S_IFF p2) ;
+EXPORT void f1_V_IDS_IFD(int p0, double p1, struct S_IFD p2) ;
+EXPORT void f1_V_IDS_IFP(int p0, double p1, struct S_IFP p2) ;
+EXPORT void f1_V_IDS_IDI(int p0, double p1, struct S_IDI p2) ;
+EXPORT void f1_V_IDS_IDF(int p0, double p1, struct S_IDF p2) ;
+EXPORT void f1_V_IDS_IDD(int p0, double p1, struct S_IDD p2) ;
+EXPORT void f1_V_IDS_IDP(int p0, double p1, struct S_IDP p2) ;
+EXPORT void f1_V_IDS_IPI(int p0, double p1, struct S_IPI p2) ;
+EXPORT void f1_V_IDS_IPF(int p0, double p1, struct S_IPF p2) ;
+EXPORT void f1_V_IDS_IPD(int p0, double p1, struct S_IPD p2) ;
+EXPORT void f1_V_IDS_IPP(int p0, double p1, struct S_IPP p2) ;
+EXPORT void f1_V_IDS_FII(int p0, double p1, struct S_FII p2) ;
+EXPORT void f1_V_IDS_FIF(int p0, double p1, struct S_FIF p2) ;
+EXPORT void f1_V_IDS_FID(int p0, double p1, struct S_FID p2) ;
+EXPORT void f1_V_IDS_FIP(int p0, double p1, struct S_FIP p2) ;
+EXPORT void f1_V_IDS_FFI(int p0, double p1, struct S_FFI p2) ;
+EXPORT void f1_V_IDS_FFF(int p0, double p1, struct S_FFF p2) ;
+EXPORT void f1_V_IDS_FFD(int p0, double p1, struct S_FFD p2) ;
+EXPORT void f1_V_IDS_FFP(int p0, double p1, struct S_FFP p2) ;
+EXPORT void f1_V_IDS_FDI(int p0, double p1, struct S_FDI p2) ;
+EXPORT void f1_V_IDS_FDF(int p0, double p1, struct S_FDF p2) ;
+EXPORT void f1_V_IDS_FDD(int p0, double p1, struct S_FDD p2) ;
+EXPORT void f1_V_IDS_FDP(int p0, double p1, struct S_FDP p2) ;
+EXPORT void f1_V_IDS_FPI(int p0, double p1, struct S_FPI p2) ;
+EXPORT void f1_V_IDS_FPF(int p0, double p1, struct S_FPF p2) ;
+EXPORT void f1_V_IDS_FPD(int p0, double p1, struct S_FPD p2) ;
+EXPORT void f1_V_IDS_FPP(int p0, double p1, struct S_FPP p2) ;
+EXPORT void f1_V_IDS_DII(int p0, double p1, struct S_DII p2) ;
+EXPORT void f1_V_IDS_DIF(int p0, double p1, struct S_DIF p2) ;
+EXPORT void f1_V_IDS_DID(int p0, double p1, struct S_DID p2) ;
+EXPORT void f1_V_IDS_DIP(int p0, double p1, struct S_DIP p2) ;
+EXPORT void f1_V_IDS_DFI(int p0, double p1, struct S_DFI p2) ;
+EXPORT void f1_V_IDS_DFF(int p0, double p1, struct S_DFF p2) ;
+EXPORT void f1_V_IDS_DFD(int p0, double p1, struct S_DFD p2) ;
+EXPORT void f1_V_IDS_DFP(int p0, double p1, struct S_DFP p2) ;
+EXPORT void f1_V_IDS_DDI(int p0, double p1, struct S_DDI p2) ;
+EXPORT void f1_V_IDS_DDF(int p0, double p1, struct S_DDF p2) ;
+EXPORT void f1_V_IDS_DDD(int p0, double p1, struct S_DDD p2) ;
+EXPORT void f1_V_IDS_DDP(int p0, double p1, struct S_DDP p2) ;
+EXPORT void f1_V_IDS_DPI(int p0, double p1, struct S_DPI p2) ;
+EXPORT void f1_V_IDS_DPF(int p0, double p1, struct S_DPF p2) ;
+EXPORT void f1_V_IDS_DPD(int p0, double p1, struct S_DPD p2) ;
+EXPORT void f1_V_IDS_DPP(int p0, double p1, struct S_DPP p2) ;
+EXPORT void f1_V_IDS_PII(int p0, double p1, struct S_PII p2) ;
+EXPORT void f1_V_IDS_PIF(int p0, double p1, struct S_PIF p2) ;
+EXPORT void f1_V_IDS_PID(int p0, double p1, struct S_PID p2) ;
+EXPORT void f1_V_IDS_PIP(int p0, double p1, struct S_PIP p2) ;
+EXPORT void f1_V_IDS_PFI(int p0, double p1, struct S_PFI p2) ;
+EXPORT void f1_V_IDS_PFF(int p0, double p1, struct S_PFF p2) ;
+EXPORT void f1_V_IDS_PFD(int p0, double p1, struct S_PFD p2) ;
+EXPORT void f1_V_IDS_PFP(int p0, double p1, struct S_PFP p2) ;
+EXPORT void f1_V_IDS_PDI(int p0, double p1, struct S_PDI p2) ;
+EXPORT void f1_V_IDS_PDF(int p0, double p1, struct S_PDF p2) ;
+EXPORT void f1_V_IDS_PDD(int p0, double p1, struct S_PDD p2) ;
+EXPORT void f1_V_IDS_PDP(int p0, double p1, struct S_PDP p2) ;
+EXPORT void f1_V_IDS_PPI(int p0, double p1, struct S_PPI p2) ;
+EXPORT void f1_V_IDS_PPF(int p0, double p1, struct S_PPF p2) ;
+EXPORT void f1_V_IDS_PPD(int p0, double p1, struct S_PPD p2) ;
+EXPORT void f1_V_IDS_PPP(int p0, double p1, struct S_PPP p2) ;
+EXPORT void f1_V_IPI_(int p0, void* p1, int p2) ;
+EXPORT void f1_V_IPF_(int p0, void* p1, float p2) ;
+EXPORT void f1_V_IPD_(int p0, void* p1, double p2) ;
+EXPORT void f1_V_IPP_(int p0, void* p1, void* p2) ;
+EXPORT void f1_V_IPS_I(int p0, void* p1, struct S_I p2) ;
+EXPORT void f1_V_IPS_F(int p0, void* p1, struct S_F p2) ;
+EXPORT void f1_V_IPS_D(int p0, void* p1, struct S_D p2) ;
+EXPORT void f1_V_IPS_P(int p0, void* p1, struct S_P p2) ;
+EXPORT void f1_V_IPS_II(int p0, void* p1, struct S_II p2) ;
+EXPORT void f1_V_IPS_IF(int p0, void* p1, struct S_IF p2) ;
+EXPORT void f1_V_IPS_ID(int p0, void* p1, struct S_ID p2) ;
+EXPORT void f1_V_IPS_IP(int p0, void* p1, struct S_IP p2) ;
+EXPORT void f1_V_IPS_FI(int p0, void* p1, struct S_FI p2) ;
+EXPORT void f1_V_IPS_FF(int p0, void* p1, struct S_FF p2) ;
+EXPORT void f1_V_IPS_FD(int p0, void* p1, struct S_FD p2) ;
+EXPORT void f1_V_IPS_FP(int p0, void* p1, struct S_FP p2) ;
+EXPORT void f1_V_IPS_DI(int p0, void* p1, struct S_DI p2) ;
+EXPORT void f1_V_IPS_DF(int p0, void* p1, struct S_DF p2) ;
+EXPORT void f1_V_IPS_DD(int p0, void* p1, struct S_DD p2) ;
+EXPORT void f1_V_IPS_DP(int p0, void* p1, struct S_DP p2) ;
+EXPORT void f1_V_IPS_PI(int p0, void* p1, struct S_PI p2) ;
+EXPORT void f1_V_IPS_PF(int p0, void* p1, struct S_PF p2) ;
+EXPORT void f1_V_IPS_PD(int p0, void* p1, struct S_PD p2) ;
+EXPORT void f1_V_IPS_PP(int p0, void* p1, struct S_PP p2) ;
+EXPORT void f1_V_IPS_III(int p0, void* p1, struct S_III p2) ;
+EXPORT void f1_V_IPS_IIF(int p0, void* p1, struct S_IIF p2) ;
+EXPORT void f1_V_IPS_IID(int p0, void* p1, struct S_IID p2) ;
+EXPORT void f1_V_IPS_IIP(int p0, void* p1, struct S_IIP p2) ;
+EXPORT void f1_V_IPS_IFI(int p0, void* p1, struct S_IFI p2) ;
+EXPORT void f1_V_IPS_IFF(int p0, void* p1, struct S_IFF p2) ;
+EXPORT void f1_V_IPS_IFD(int p0, void* p1, struct S_IFD p2) ;
+EXPORT void f1_V_IPS_IFP(int p0, void* p1, struct S_IFP p2) ;
+EXPORT void f1_V_IPS_IDI(int p0, void* p1, struct S_IDI p2) ;
+EXPORT void f1_V_IPS_IDF(int p0, void* p1, struct S_IDF p2) ;
+EXPORT void f1_V_IPS_IDD(int p0, void* p1, struct S_IDD p2) ;
+EXPORT void f1_V_IPS_IDP(int p0, void* p1, struct S_IDP p2) ;
+EXPORT void f1_V_IPS_IPI(int p0, void* p1, struct S_IPI p2) ;
+EXPORT void f1_V_IPS_IPF(int p0, void* p1, struct S_IPF p2) ;
+EXPORT void f1_V_IPS_IPD(int p0, void* p1, struct S_IPD p2) ;
+EXPORT void f1_V_IPS_IPP(int p0, void* p1, struct S_IPP p2) ;
+EXPORT void f1_V_IPS_FII(int p0, void* p1, struct S_FII p2) ;
+EXPORT void f1_V_IPS_FIF(int p0, void* p1, struct S_FIF p2) ;
+EXPORT void f1_V_IPS_FID(int p0, void* p1, struct S_FID p2) ;
+EXPORT void f1_V_IPS_FIP(int p0, void* p1, struct S_FIP p2) ;
+EXPORT void f1_V_IPS_FFI(int p0, void* p1, struct S_FFI p2) ;
+EXPORT void f1_V_IPS_FFF(int p0, void* p1, struct S_FFF p2) ;
+EXPORT void f1_V_IPS_FFD(int p0, void* p1, struct S_FFD p2) ;
+EXPORT void f1_V_IPS_FFP(int p0, void* p1, struct S_FFP p2) ;
+EXPORT void f1_V_IPS_FDI(int p0, void* p1, struct S_FDI p2) ;
+EXPORT void f1_V_IPS_FDF(int p0, void* p1, struct S_FDF p2) ;
+EXPORT void f1_V_IPS_FDD(int p0, void* p1, struct S_FDD p2) ;
+EXPORT void f1_V_IPS_FDP(int p0, void* p1, struct S_FDP p2) ;
+EXPORT void f1_V_IPS_FPI(int p0, void* p1, struct S_FPI p2) ;
+EXPORT void f1_V_IPS_FPF(int p0, void* p1, struct S_FPF p2) ;
+EXPORT void f1_V_IPS_FPD(int p0, void* p1, struct S_FPD p2) ;
+EXPORT void f1_V_IPS_FPP(int p0, void* p1, struct S_FPP p2) ;
+EXPORT void f1_V_IPS_DII(int p0, void* p1, struct S_DII p2) ;
+EXPORT void f1_V_IPS_DIF(int p0, void* p1, struct S_DIF p2) ;
+EXPORT void f1_V_IPS_DID(int p0, void* p1, struct S_DID p2) ;
+EXPORT void f1_V_IPS_DIP(int p0, void* p1, struct S_DIP p2) ;
+EXPORT void f1_V_IPS_DFI(int p0, void* p1, struct S_DFI p2) ;
+EXPORT void f1_V_IPS_DFF(int p0, void* p1, struct S_DFF p2) ;
+EXPORT void f1_V_IPS_DFD(int p0, void* p1, struct S_DFD p2) ;
+EXPORT void f1_V_IPS_DFP(int p0, void* p1, struct S_DFP p2) ;
+EXPORT void f1_V_IPS_DDI(int p0, void* p1, struct S_DDI p2) ;
+EXPORT void f1_V_IPS_DDF(int p0, void* p1, struct S_DDF p2) ;
+EXPORT void f1_V_IPS_DDD(int p0, void* p1, struct S_DDD p2) ;
+EXPORT void f1_V_IPS_DDP(int p0, void* p1, struct S_DDP p2) ;
+EXPORT void f1_V_IPS_DPI(int p0, void* p1, struct S_DPI p2) ;
+EXPORT void f1_V_IPS_DPF(int p0, void* p1, struct S_DPF p2) ;
+EXPORT void f1_V_IPS_DPD(int p0, void* p1, struct S_DPD p2) ;
+EXPORT void f1_V_IPS_DPP(int p0, void* p1, struct S_DPP p2) ;
+EXPORT void f1_V_IPS_PII(int p0, void* p1, struct S_PII p2) ;
+EXPORT void f1_V_IPS_PIF(int p0, void* p1, struct S_PIF p2) ;
+EXPORT void f1_V_IPS_PID(int p0, void* p1, struct S_PID p2) ;
+EXPORT void f2_V_IPS_PIP(int p0, void* p1, struct S_PIP p2) ;
+EXPORT void f2_V_IPS_PFI(int p0, void* p1, struct S_PFI p2) ;
+EXPORT void f2_V_IPS_PFF(int p0, void* p1, struct S_PFF p2) ;
+EXPORT void f2_V_IPS_PFD(int p0, void* p1, struct S_PFD p2) ;
+EXPORT void f2_V_IPS_PFP(int p0, void* p1, struct S_PFP p2) ;
+EXPORT void f2_V_IPS_PDI(int p0, void* p1, struct S_PDI p2) ;
+EXPORT void f2_V_IPS_PDF(int p0, void* p1, struct S_PDF p2) ;
+EXPORT void f2_V_IPS_PDD(int p0, void* p1, struct S_PDD p2) ;
+EXPORT void f2_V_IPS_PDP(int p0, void* p1, struct S_PDP p2) ;
+EXPORT void f2_V_IPS_PPI(int p0, void* p1, struct S_PPI p2) ;
+EXPORT void f2_V_IPS_PPF(int p0, void* p1, struct S_PPF p2) ;
+EXPORT void f2_V_IPS_PPD(int p0, void* p1, struct S_PPD p2) ;
+EXPORT void f2_V_IPS_PPP(int p0, void* p1, struct S_PPP p2) ;
+EXPORT void f2_V_ISI_I(int p0, struct S_I p1, int p2) ;
+EXPORT void f2_V_ISI_F(int p0, struct S_F p1, int p2) ;
+EXPORT void f2_V_ISI_D(int p0, struct S_D p1, int p2) ;
+EXPORT void f2_V_ISI_P(int p0, struct S_P p1, int p2) ;
+EXPORT void f2_V_ISI_II(int p0, struct S_II p1, int p2) ;
+EXPORT void f2_V_ISI_IF(int p0, struct S_IF p1, int p2) ;
+EXPORT void f2_V_ISI_ID(int p0, struct S_ID p1, int p2) ;
+EXPORT void f2_V_ISI_IP(int p0, struct S_IP p1, int p2) ;
+EXPORT void f2_V_ISI_FI(int p0, struct S_FI p1, int p2) ;
+EXPORT void f2_V_ISI_FF(int p0, struct S_FF p1, int p2) ;
+EXPORT void f2_V_ISI_FD(int p0, struct S_FD p1, int p2) ;
+EXPORT void f2_V_ISI_FP(int p0, struct S_FP p1, int p2) ;
+EXPORT void f2_V_ISI_DI(int p0, struct S_DI p1, int p2) ;
+EXPORT void f2_V_ISI_DF(int p0, struct S_DF p1, int p2) ;
+EXPORT void f2_V_ISI_DD(int p0, struct S_DD p1, int p2) ;
+EXPORT void f2_V_ISI_DP(int p0, struct S_DP p1, int p2) ;
+EXPORT void f2_V_ISI_PI(int p0, struct S_PI p1, int p2) ;
+EXPORT void f2_V_ISI_PF(int p0, struct S_PF p1, int p2) ;
+EXPORT void f2_V_ISI_PD(int p0, struct S_PD p1, int p2) ;
+EXPORT void f2_V_ISI_PP(int p0, struct S_PP p1, int p2) ;
+EXPORT void f2_V_ISI_III(int p0, struct S_III p1, int p2) ;
+EXPORT void f2_V_ISI_IIF(int p0, struct S_IIF p1, int p2) ;
+EXPORT void f2_V_ISI_IID(int p0, struct S_IID p1, int p2) ;
+EXPORT void f2_V_ISI_IIP(int p0, struct S_IIP p1, int p2) ;
+EXPORT void f2_V_ISI_IFI(int p0, struct S_IFI p1, int p2) ;
+EXPORT void f2_V_ISI_IFF(int p0, struct S_IFF p1, int p2) ;
+EXPORT void f2_V_ISI_IFD(int p0, struct S_IFD p1, int p2) ;
+EXPORT void f2_V_ISI_IFP(int p0, struct S_IFP p1, int p2) ;
+EXPORT void f2_V_ISI_IDI(int p0, struct S_IDI p1, int p2) ;
+EXPORT void f2_V_ISI_IDF(int p0, struct S_IDF p1, int p2) ;
+EXPORT void f2_V_ISI_IDD(int p0, struct S_IDD p1, int p2) ;
+EXPORT void f2_V_ISI_IDP(int p0, struct S_IDP p1, int p2) ;
+EXPORT void f2_V_ISI_IPI(int p0, struct S_IPI p1, int p2) ;
+EXPORT void f2_V_ISI_IPF(int p0, struct S_IPF p1, int p2) ;
+EXPORT void f2_V_ISI_IPD(int p0, struct S_IPD p1, int p2) ;
+EXPORT void f2_V_ISI_IPP(int p0, struct S_IPP p1, int p2) ;
+EXPORT void f2_V_ISI_FII(int p0, struct S_FII p1, int p2) ;
+EXPORT void f2_V_ISI_FIF(int p0, struct S_FIF p1, int p2) ;
+EXPORT void f2_V_ISI_FID(int p0, struct S_FID p1, int p2) ;
+EXPORT void f2_V_ISI_FIP(int p0, struct S_FIP p1, int p2) ;
+EXPORT void f2_V_ISI_FFI(int p0, struct S_FFI p1, int p2) ;
+EXPORT void f2_V_ISI_FFF(int p0, struct S_FFF p1, int p2) ;
+EXPORT void f2_V_ISI_FFD(int p0, struct S_FFD p1, int p2) ;
+EXPORT void f2_V_ISI_FFP(int p0, struct S_FFP p1, int p2) ;
+EXPORT void f2_V_ISI_FDI(int p0, struct S_FDI p1, int p2) ;
+EXPORT void f2_V_ISI_FDF(int p0, struct S_FDF p1, int p2) ;
+EXPORT void f2_V_ISI_FDD(int p0, struct S_FDD p1, int p2) ;
+EXPORT void f2_V_ISI_FDP(int p0, struct S_FDP p1, int p2) ;
+EXPORT void f2_V_ISI_FPI(int p0, struct S_FPI p1, int p2) ;
+EXPORT void f2_V_ISI_FPF(int p0, struct S_FPF p1, int p2) ;
+EXPORT void f2_V_ISI_FPD(int p0, struct S_FPD p1, int p2) ;
+EXPORT void f2_V_ISI_FPP(int p0, struct S_FPP p1, int p2) ;
+EXPORT void f2_V_ISI_DII(int p0, struct S_DII p1, int p2) ;
+EXPORT void f2_V_ISI_DIF(int p0, struct S_DIF p1, int p2) ;
+EXPORT void f2_V_ISI_DID(int p0, struct S_DID p1, int p2) ;
+EXPORT void f2_V_ISI_DIP(int p0, struct S_DIP p1, int p2) ;
+EXPORT void f2_V_ISI_DFI(int p0, struct S_DFI p1, int p2) ;
+EXPORT void f2_V_ISI_DFF(int p0, struct S_DFF p1, int p2) ;
+EXPORT void f2_V_ISI_DFD(int p0, struct S_DFD p1, int p2) ;
+EXPORT void f2_V_ISI_DFP(int p0, struct S_DFP p1, int p2) ;
+EXPORT void f2_V_ISI_DDI(int p0, struct S_DDI p1, int p2) ;
+EXPORT void f2_V_ISI_DDF(int p0, struct S_DDF p1, int p2) ;
+EXPORT void f2_V_ISI_DDD(int p0, struct S_DDD p1, int p2) ;
+EXPORT void f2_V_ISI_DDP(int p0, struct S_DDP p1, int p2) ;
+EXPORT void f2_V_ISI_DPI(int p0, struct S_DPI p1, int p2) ;
+EXPORT void f2_V_ISI_DPF(int p0, struct S_DPF p1, int p2) ;
+EXPORT void f2_V_ISI_DPD(int p0, struct S_DPD p1, int p2) ;
+EXPORT void f2_V_ISI_DPP(int p0, struct S_DPP p1, int p2) ;
+EXPORT void f2_V_ISI_PII(int p0, struct S_PII p1, int p2) ;
+EXPORT void f2_V_ISI_PIF(int p0, struct S_PIF p1, int p2) ;
+EXPORT void f2_V_ISI_PID(int p0, struct S_PID p1, int p2) ;
+EXPORT void f2_V_ISI_PIP(int p0, struct S_PIP p1, int p2) ;
+EXPORT void f2_V_ISI_PFI(int p0, struct S_PFI p1, int p2) ;
+EXPORT void f2_V_ISI_PFF(int p0, struct S_PFF p1, int p2) ;
+EXPORT void f2_V_ISI_PFD(int p0, struct S_PFD p1, int p2) ;
+EXPORT void f2_V_ISI_PFP(int p0, struct S_PFP p1, int p2) ;
+EXPORT void f2_V_ISI_PDI(int p0, struct S_PDI p1, int p2) ;
+EXPORT void f2_V_ISI_PDF(int p0, struct S_PDF p1, int p2) ;
+EXPORT void f2_V_ISI_PDD(int p0, struct S_PDD p1, int p2) ;
+EXPORT void f2_V_ISI_PDP(int p0, struct S_PDP p1, int p2) ;
+EXPORT void f2_V_ISI_PPI(int p0, struct S_PPI p1, int p2) ;
+EXPORT void f2_V_ISI_PPF(int p0, struct S_PPF p1, int p2) ;
+EXPORT void f2_V_ISI_PPD(int p0, struct S_PPD p1, int p2) ;
+EXPORT void f2_V_ISI_PPP(int p0, struct S_PPP p1, int p2) ;
+EXPORT void f2_V_ISF_I(int p0, struct S_I p1, float p2) ;
+EXPORT void f2_V_ISF_F(int p0, struct S_F p1, float p2) ;
+EXPORT void f2_V_ISF_D(int p0, struct S_D p1, float p2) ;
+EXPORT void f2_V_ISF_P(int p0, struct S_P p1, float p2) ;
+EXPORT void f2_V_ISF_II(int p0, struct S_II p1, float p2) ;
+EXPORT void f2_V_ISF_IF(int p0, struct S_IF p1, float p2) ;
+EXPORT void f2_V_ISF_ID(int p0, struct S_ID p1, float p2) ;
+EXPORT void f2_V_ISF_IP(int p0, struct S_IP p1, float p2) ;
+EXPORT void f2_V_ISF_FI(int p0, struct S_FI p1, float p2) ;
+EXPORT void f2_V_ISF_FF(int p0, struct S_FF p1, float p2) ;
+EXPORT void f2_V_ISF_FD(int p0, struct S_FD p1, float p2) ;
+EXPORT void f2_V_ISF_FP(int p0, struct S_FP p1, float p2) ;
+EXPORT void f2_V_ISF_DI(int p0, struct S_DI p1, float p2) ;
+EXPORT void f2_V_ISF_DF(int p0, struct S_DF p1, float p2) ;
+EXPORT void f2_V_ISF_DD(int p0, struct S_DD p1, float p2) ;
+EXPORT void f2_V_ISF_DP(int p0, struct S_DP p1, float p2) ;
+EXPORT void f2_V_ISF_PI(int p0, struct S_PI p1, float p2) ;
+EXPORT void f2_V_ISF_PF(int p0, struct S_PF p1, float p2) ;
+EXPORT void f2_V_ISF_PD(int p0, struct S_PD p1, float p2) ;
+EXPORT void f2_V_ISF_PP(int p0, struct S_PP p1, float p2) ;
+EXPORT void f2_V_ISF_III(int p0, struct S_III p1, float p2) ;
+EXPORT void f2_V_ISF_IIF(int p0, struct S_IIF p1, float p2) ;
+EXPORT void f2_V_ISF_IID(int p0, struct S_IID p1, float p2) ;
+EXPORT void f2_V_ISF_IIP(int p0, struct S_IIP p1, float p2) ;
+EXPORT void f2_V_ISF_IFI(int p0, struct S_IFI p1, float p2) ;
+EXPORT void f2_V_ISF_IFF(int p0, struct S_IFF p1, float p2) ;
+EXPORT void f2_V_ISF_IFD(int p0, struct S_IFD p1, float p2) ;
+EXPORT void f2_V_ISF_IFP(int p0, struct S_IFP p1, float p2) ;
+EXPORT void f2_V_ISF_IDI(int p0, struct S_IDI p1, float p2) ;
+EXPORT void f2_V_ISF_IDF(int p0, struct S_IDF p1, float p2) ;
+EXPORT void f2_V_ISF_IDD(int p0, struct S_IDD p1, float p2) ;
+EXPORT void f2_V_ISF_IDP(int p0, struct S_IDP p1, float p2) ;
+EXPORT void f2_V_ISF_IPI(int p0, struct S_IPI p1, float p2) ;
+EXPORT void f2_V_ISF_IPF(int p0, struct S_IPF p1, float p2) ;
+EXPORT void f2_V_ISF_IPD(int p0, struct S_IPD p1, float p2) ;
+EXPORT void f2_V_ISF_IPP(int p0, struct S_IPP p1, float p2) ;
+EXPORT void f2_V_ISF_FII(int p0, struct S_FII p1, float p2) ;
+EXPORT void f2_V_ISF_FIF(int p0, struct S_FIF p1, float p2) ;
+EXPORT void f2_V_ISF_FID(int p0, struct S_FID p1, float p2) ;
+EXPORT void f2_V_ISF_FIP(int p0, struct S_FIP p1, float p2) ;
+EXPORT void f2_V_ISF_FFI(int p0, struct S_FFI p1, float p2) ;
+EXPORT void f2_V_ISF_FFF(int p0, struct S_FFF p1, float p2) ;
+EXPORT void f2_V_ISF_FFD(int p0, struct S_FFD p1, float p2) ;
+EXPORT void f2_V_ISF_FFP(int p0, struct S_FFP p1, float p2) ;
+EXPORT void f2_V_ISF_FDI(int p0, struct S_FDI p1, float p2) ;
+EXPORT void f2_V_ISF_FDF(int p0, struct S_FDF p1, float p2) ;
+EXPORT void f2_V_ISF_FDD(int p0, struct S_FDD p1, float p2) ;
+EXPORT void f2_V_ISF_FDP(int p0, struct S_FDP p1, float p2) ;
+EXPORT void f2_V_ISF_FPI(int p0, struct S_FPI p1, float p2) ;
+EXPORT void f2_V_ISF_FPF(int p0, struct S_FPF p1, float p2) ;
+EXPORT void f2_V_ISF_FPD(int p0, struct S_FPD p1, float p2) ;
+EXPORT void f2_V_ISF_FPP(int p0, struct S_FPP p1, float p2) ;
+EXPORT void f2_V_ISF_DII(int p0, struct S_DII p1, float p2) ;
+EXPORT void f2_V_ISF_DIF(int p0, struct S_DIF p1, float p2) ;
+EXPORT void f2_V_ISF_DID(int p0, struct S_DID p1, float p2) ;
+EXPORT void f2_V_ISF_DIP(int p0, struct S_DIP p1, float p2) ;
+EXPORT void f2_V_ISF_DFI(int p0, struct S_DFI p1, float p2) ;
+EXPORT void f2_V_ISF_DFF(int p0, struct S_DFF p1, float p2) ;
+EXPORT void f2_V_ISF_DFD(int p0, struct S_DFD p1, float p2) ;
+EXPORT void f2_V_ISF_DFP(int p0, struct S_DFP p1, float p2) ;
+EXPORT void f2_V_ISF_DDI(int p0, struct S_DDI p1, float p2) ;
+EXPORT void f2_V_ISF_DDF(int p0, struct S_DDF p1, float p2) ;
+EXPORT void f2_V_ISF_DDD(int p0, struct S_DDD p1, float p2) ;
+EXPORT void f2_V_ISF_DDP(int p0, struct S_DDP p1, float p2) ;
+EXPORT void f2_V_ISF_DPI(int p0, struct S_DPI p1, float p2) ;
+EXPORT void f2_V_ISF_DPF(int p0, struct S_DPF p1, float p2) ;
+EXPORT void f2_V_ISF_DPD(int p0, struct S_DPD p1, float p2) ;
+EXPORT void f2_V_ISF_DPP(int p0, struct S_DPP p1, float p2) ;
+EXPORT void f2_V_ISF_PII(int p0, struct S_PII p1, float p2) ;
+EXPORT void f2_V_ISF_PIF(int p0, struct S_PIF p1, float p2) ;
+EXPORT void f2_V_ISF_PID(int p0, struct S_PID p1, float p2) ;
+EXPORT void f2_V_ISF_PIP(int p0, struct S_PIP p1, float p2) ;
+EXPORT void f2_V_ISF_PFI(int p0, struct S_PFI p1, float p2) ;
+EXPORT void f2_V_ISF_PFF(int p0, struct S_PFF p1, float p2) ;
+EXPORT void f2_V_ISF_PFD(int p0, struct S_PFD p1, float p2) ;
+EXPORT void f2_V_ISF_PFP(int p0, struct S_PFP p1, float p2) ;
+EXPORT void f2_V_ISF_PDI(int p0, struct S_PDI p1, float p2) ;
+EXPORT void f2_V_ISF_PDF(int p0, struct S_PDF p1, float p2) ;
+EXPORT void f2_V_ISF_PDD(int p0, struct S_PDD p1, float p2) ;
+EXPORT void f2_V_ISF_PDP(int p0, struct S_PDP p1, float p2) ;
+EXPORT void f2_V_ISF_PPI(int p0, struct S_PPI p1, float p2) ;
+EXPORT void f2_V_ISF_PPF(int p0, struct S_PPF p1, float p2) ;
+EXPORT void f2_V_ISF_PPD(int p0, struct S_PPD p1, float p2) ;
+EXPORT void f2_V_ISF_PPP(int p0, struct S_PPP p1, float p2) ;
+EXPORT void f2_V_ISD_I(int p0, struct S_I p1, double p2) ;
+EXPORT void f2_V_ISD_F(int p0, struct S_F p1, double p2) ;
+EXPORT void f2_V_ISD_D(int p0, struct S_D p1, double p2) ;
+EXPORT void f2_V_ISD_P(int p0, struct S_P p1, double p2) ;
+EXPORT void f2_V_ISD_II(int p0, struct S_II p1, double p2) ;
+EXPORT void f2_V_ISD_IF(int p0, struct S_IF p1, double p2) ;
+EXPORT void f2_V_ISD_ID(int p0, struct S_ID p1, double p2) ;
+EXPORT void f2_V_ISD_IP(int p0, struct S_IP p1, double p2) ;
+EXPORT void f2_V_ISD_FI(int p0, struct S_FI p1, double p2) ;
+EXPORT void f2_V_ISD_FF(int p0, struct S_FF p1, double p2) ;
+EXPORT void f2_V_ISD_FD(int p0, struct S_FD p1, double p2) ;
+EXPORT void f2_V_ISD_FP(int p0, struct S_FP p1, double p2) ;
+EXPORT void f2_V_ISD_DI(int p0, struct S_DI p1, double p2) ;
+EXPORT void f2_V_ISD_DF(int p0, struct S_DF p1, double p2) ;
+EXPORT void f2_V_ISD_DD(int p0, struct S_DD p1, double p2) ;
+EXPORT void f2_V_ISD_DP(int p0, struct S_DP p1, double p2) ;
+EXPORT void f2_V_ISD_PI(int p0, struct S_PI p1, double p2) ;
+EXPORT void f2_V_ISD_PF(int p0, struct S_PF p1, double p2) ;
+EXPORT void f2_V_ISD_PD(int p0, struct S_PD p1, double p2) ;
+EXPORT void f2_V_ISD_PP(int p0, struct S_PP p1, double p2) ;
+EXPORT void f2_V_ISD_III(int p0, struct S_III p1, double p2) ;
+EXPORT void f2_V_ISD_IIF(int p0, struct S_IIF p1, double p2) ;
+EXPORT void f2_V_ISD_IID(int p0, struct S_IID p1, double p2) ;
+EXPORT void f2_V_ISD_IIP(int p0, struct S_IIP p1, double p2) ;
+EXPORT void f2_V_ISD_IFI(int p0, struct S_IFI p1, double p2) ;
+EXPORT void f2_V_ISD_IFF(int p0, struct S_IFF p1, double p2) ;
+EXPORT void f2_V_ISD_IFD(int p0, struct S_IFD p1, double p2) ;
+EXPORT void f2_V_ISD_IFP(int p0, struct S_IFP p1, double p2) ;
+EXPORT void f2_V_ISD_IDI(int p0, struct S_IDI p1, double p2) ;
+EXPORT void f2_V_ISD_IDF(int p0, struct S_IDF p1, double p2) ;
+EXPORT void f2_V_ISD_IDD(int p0, struct S_IDD p1, double p2) ;
+EXPORT void f2_V_ISD_IDP(int p0, struct S_IDP p1, double p2) ;
+EXPORT void f2_V_ISD_IPI(int p0, struct S_IPI p1, double p2) ;
+EXPORT void f2_V_ISD_IPF(int p0, struct S_IPF p1, double p2) ;
+EXPORT void f2_V_ISD_IPD(int p0, struct S_IPD p1, double p2) ;
+EXPORT void f2_V_ISD_IPP(int p0, struct S_IPP p1, double p2) ;
+EXPORT void f2_V_ISD_FII(int p0, struct S_FII p1, double p2) ;
+EXPORT void f2_V_ISD_FIF(int p0, struct S_FIF p1, double p2) ;
+EXPORT void f2_V_ISD_FID(int p0, struct S_FID p1, double p2) ;
+EXPORT void f2_V_ISD_FIP(int p0, struct S_FIP p1, double p2) ;
+EXPORT void f2_V_ISD_FFI(int p0, struct S_FFI p1, double p2) ;
+EXPORT void f2_V_ISD_FFF(int p0, struct S_FFF p1, double p2) ;
+EXPORT void f2_V_ISD_FFD(int p0, struct S_FFD p1, double p2) ;
+EXPORT void f2_V_ISD_FFP(int p0, struct S_FFP p1, double p2) ;
+EXPORT void f2_V_ISD_FDI(int p0, struct S_FDI p1, double p2) ;
+EXPORT void f2_V_ISD_FDF(int p0, struct S_FDF p1, double p2) ;
+EXPORT void f2_V_ISD_FDD(int p0, struct S_FDD p1, double p2) ;
+EXPORT void f2_V_ISD_FDP(int p0, struct S_FDP p1, double p2) ;
+EXPORT void f2_V_ISD_FPI(int p0, struct S_FPI p1, double p2) ;
+EXPORT void f2_V_ISD_FPF(int p0, struct S_FPF p1, double p2) ;
+EXPORT void f2_V_ISD_FPD(int p0, struct S_FPD p1, double p2) ;
+EXPORT void f2_V_ISD_FPP(int p0, struct S_FPP p1, double p2) ;
+EXPORT void f2_V_ISD_DII(int p0, struct S_DII p1, double p2) ;
+EXPORT void f2_V_ISD_DIF(int p0, struct S_DIF p1, double p2) ;
+EXPORT void f2_V_ISD_DID(int p0, struct S_DID p1, double p2) ;
+EXPORT void f2_V_ISD_DIP(int p0, struct S_DIP p1, double p2) ;
+EXPORT void f2_V_ISD_DFI(int p0, struct S_DFI p1, double p2) ;
+EXPORT void f2_V_ISD_DFF(int p0, struct S_DFF p1, double p2) ;
+EXPORT void f2_V_ISD_DFD(int p0, struct S_DFD p1, double p2) ;
+EXPORT void f2_V_ISD_DFP(int p0, struct S_DFP p1, double p2) ;
+EXPORT void f2_V_ISD_DDI(int p0, struct S_DDI p1, double p2) ;
+EXPORT void f2_V_ISD_DDF(int p0, struct S_DDF p1, double p2) ;
+EXPORT void f2_V_ISD_DDD(int p0, struct S_DDD p1, double p2) ;
+EXPORT void f2_V_ISD_DDP(int p0, struct S_DDP p1, double p2) ;
+EXPORT void f2_V_ISD_DPI(int p0, struct S_DPI p1, double p2) ;
+EXPORT void f2_V_ISD_DPF(int p0, struct S_DPF p1, double p2) ;
+EXPORT void f2_V_ISD_DPD(int p0, struct S_DPD p1, double p2) ;
+EXPORT void f2_V_ISD_DPP(int p0, struct S_DPP p1, double p2) ;
+EXPORT void f2_V_ISD_PII(int p0, struct S_PII p1, double p2) ;
+EXPORT void f2_V_ISD_PIF(int p0, struct S_PIF p1, double p2) ;
+EXPORT void f2_V_ISD_PID(int p0, struct S_PID p1, double p2) ;
+EXPORT void f2_V_ISD_PIP(int p0, struct S_PIP p1, double p2) ;
+EXPORT void f2_V_ISD_PFI(int p0, struct S_PFI p1, double p2) ;
+EXPORT void f2_V_ISD_PFF(int p0, struct S_PFF p1, double p2) ;
+EXPORT void f2_V_ISD_PFD(int p0, struct S_PFD p1, double p2) ;
+EXPORT void f2_V_ISD_PFP(int p0, struct S_PFP p1, double p2) ;
+EXPORT void f2_V_ISD_PDI(int p0, struct S_PDI p1, double p2) ;
+EXPORT void f2_V_ISD_PDF(int p0, struct S_PDF p1, double p2) ;
+EXPORT void f2_V_ISD_PDD(int p0, struct S_PDD p1, double p2) ;
+EXPORT void f2_V_ISD_PDP(int p0, struct S_PDP p1, double p2) ;
+EXPORT void f2_V_ISD_PPI(int p0, struct S_PPI p1, double p2) ;
+EXPORT void f2_V_ISD_PPF(int p0, struct S_PPF p1, double p2) ;
+EXPORT void f2_V_ISD_PPD(int p0, struct S_PPD p1, double p2) ;
+EXPORT void f2_V_ISD_PPP(int p0, struct S_PPP p1, double p2) ;
+EXPORT void f2_V_ISP_I(int p0, struct S_I p1, void* p2) ;
+EXPORT void f2_V_ISP_F(int p0, struct S_F p1, void* p2) ;
+EXPORT void f2_V_ISP_D(int p0, struct S_D p1, void* p2) ;
+EXPORT void f2_V_ISP_P(int p0, struct S_P p1, void* p2) ;
+EXPORT void f2_V_ISP_II(int p0, struct S_II p1, void* p2) ;
+EXPORT void f2_V_ISP_IF(int p0, struct S_IF p1, void* p2) ;
+EXPORT void f2_V_ISP_ID(int p0, struct S_ID p1, void* p2) ;
+EXPORT void f2_V_ISP_IP(int p0, struct S_IP p1, void* p2) ;
+EXPORT void f2_V_ISP_FI(int p0, struct S_FI p1, void* p2) ;
+EXPORT void f2_V_ISP_FF(int p0, struct S_FF p1, void* p2) ;
+EXPORT void f2_V_ISP_FD(int p0, struct S_FD p1, void* p2) ;
+EXPORT void f2_V_ISP_FP(int p0, struct S_FP p1, void* p2) ;
+EXPORT void f2_V_ISP_DI(int p0, struct S_DI p1, void* p2) ;
+EXPORT void f2_V_ISP_DF(int p0, struct S_DF p1, void* p2) ;
+EXPORT void f2_V_ISP_DD(int p0, struct S_DD p1, void* p2) ;
+EXPORT void f2_V_ISP_DP(int p0, struct S_DP p1, void* p2) ;
+EXPORT void f2_V_ISP_PI(int p0, struct S_PI p1, void* p2) ;
+EXPORT void f2_V_ISP_PF(int p0, struct S_PF p1, void* p2) ;
+EXPORT void f2_V_ISP_PD(int p0, struct S_PD p1, void* p2) ;
+EXPORT void f2_V_ISP_PP(int p0, struct S_PP p1, void* p2) ;
+EXPORT void f2_V_ISP_III(int p0, struct S_III p1, void* p2) ;
+EXPORT void f2_V_ISP_IIF(int p0, struct S_IIF p1, void* p2) ;
+EXPORT void f2_V_ISP_IID(int p0, struct S_IID p1, void* p2) ;
+EXPORT void f2_V_ISP_IIP(int p0, struct S_IIP p1, void* p2) ;
+EXPORT void f2_V_ISP_IFI(int p0, struct S_IFI p1, void* p2) ;
+EXPORT void f2_V_ISP_IFF(int p0, struct S_IFF p1, void* p2) ;
+EXPORT void f2_V_ISP_IFD(int p0, struct S_IFD p1, void* p2) ;
+EXPORT void f2_V_ISP_IFP(int p0, struct S_IFP p1, void* p2) ;
+EXPORT void f2_V_ISP_IDI(int p0, struct S_IDI p1, void* p2) ;
+EXPORT void f2_V_ISP_IDF(int p0, struct S_IDF p1, void* p2) ;
+EXPORT void f2_V_ISP_IDD(int p0, struct S_IDD p1, void* p2) ;
+EXPORT void f2_V_ISP_IDP(int p0, struct S_IDP p1, void* p2) ;
+EXPORT void f2_V_ISP_IPI(int p0, struct S_IPI p1, void* p2) ;
+EXPORT void f2_V_ISP_IPF(int p0, struct S_IPF p1, void* p2) ;
+EXPORT void f2_V_ISP_IPD(int p0, struct S_IPD p1, void* p2) ;
+EXPORT void f2_V_ISP_IPP(int p0, struct S_IPP p1, void* p2) ;
+EXPORT void f2_V_ISP_FII(int p0, struct S_FII p1, void* p2) ;
+EXPORT void f2_V_ISP_FIF(int p0, struct S_FIF p1, void* p2) ;
+EXPORT void f2_V_ISP_FID(int p0, struct S_FID p1, void* p2) ;
+EXPORT void f2_V_ISP_FIP(int p0, struct S_FIP p1, void* p2) ;
+EXPORT void f2_V_ISP_FFI(int p0, struct S_FFI p1, void* p2) ;
+EXPORT void f2_V_ISP_FFF(int p0, struct S_FFF p1, void* p2) ;
+EXPORT void f2_V_ISP_FFD(int p0, struct S_FFD p1, void* p2) ;
+EXPORT void f2_V_ISP_FFP(int p0, struct S_FFP p1, void* p2) ;
+EXPORT void f2_V_ISP_FDI(int p0, struct S_FDI p1, void* p2) ;
+EXPORT void f2_V_ISP_FDF(int p0, struct S_FDF p1, void* p2) ;
+EXPORT void f2_V_ISP_FDD(int p0, struct S_FDD p1, void* p2) ;
+EXPORT void f2_V_ISP_FDP(int p0, struct S_FDP p1, void* p2) ;
+EXPORT void f2_V_ISP_FPI(int p0, struct S_FPI p1, void* p2) ;
+EXPORT void f2_V_ISP_FPF(int p0, struct S_FPF p1, void* p2) ;
+EXPORT void f2_V_ISP_FPD(int p0, struct S_FPD p1, void* p2) ;
+EXPORT void f2_V_ISP_FPP(int p0, struct S_FPP p1, void* p2) ;
+EXPORT void f2_V_ISP_DII(int p0, struct S_DII p1, void* p2) ;
+EXPORT void f2_V_ISP_DIF(int p0, struct S_DIF p1, void* p2) ;
+EXPORT void f2_V_ISP_DID(int p0, struct S_DID p1, void* p2) ;
+EXPORT void f2_V_ISP_DIP(int p0, struct S_DIP p1, void* p2) ;
+EXPORT void f2_V_ISP_DFI(int p0, struct S_DFI p1, void* p2) ;
+EXPORT void f2_V_ISP_DFF(int p0, struct S_DFF p1, void* p2) ;
+EXPORT void f2_V_ISP_DFD(int p0, struct S_DFD p1, void* p2) ;
+EXPORT void f2_V_ISP_DFP(int p0, struct S_DFP p1, void* p2) ;
+EXPORT void f2_V_ISP_DDI(int p0, struct S_DDI p1, void* p2) ;
+EXPORT void f2_V_ISP_DDF(int p0, struct S_DDF p1, void* p2) ;
+EXPORT void f2_V_ISP_DDD(int p0, struct S_DDD p1, void* p2) ;
+EXPORT void f2_V_ISP_DDP(int p0, struct S_DDP p1, void* p2) ;
+EXPORT void f2_V_ISP_DPI(int p0, struct S_DPI p1, void* p2) ;
+EXPORT void f2_V_ISP_DPF(int p0, struct S_DPF p1, void* p2) ;
+EXPORT void f2_V_ISP_DPD(int p0, struct S_DPD p1, void* p2) ;
+EXPORT void f2_V_ISP_DPP(int p0, struct S_DPP p1, void* p2) ;
+EXPORT void f2_V_ISP_PII(int p0, struct S_PII p1, void* p2) ;
+EXPORT void f2_V_ISP_PIF(int p0, struct S_PIF p1, void* p2) ;
+EXPORT void f2_V_ISP_PID(int p0, struct S_PID p1, void* p2) ;
+EXPORT void f2_V_ISP_PIP(int p0, struct S_PIP p1, void* p2) ;
+EXPORT void f2_V_ISP_PFI(int p0, struct S_PFI p1, void* p2) ;
+EXPORT void f2_V_ISP_PFF(int p0, struct S_PFF p1, void* p2) ;
+EXPORT void f2_V_ISP_PFD(int p0, struct S_PFD p1, void* p2) ;
+EXPORT void f2_V_ISP_PFP(int p0, struct S_PFP p1, void* p2) ;
+EXPORT void f2_V_ISP_PDI(int p0, struct S_PDI p1, void* p2) ;
+EXPORT void f2_V_ISP_PDF(int p0, struct S_PDF p1, void* p2) ;
+EXPORT void f2_V_ISP_PDD(int p0, struct S_PDD p1, void* p2) ;
+EXPORT void f2_V_ISP_PDP(int p0, struct S_PDP p1, void* p2) ;
+EXPORT void f2_V_ISP_PPI(int p0, struct S_PPI p1, void* p2) ;
+EXPORT void f2_V_ISP_PPF(int p0, struct S_PPF p1, void* p2) ;
+EXPORT void f2_V_ISP_PPD(int p0, struct S_PPD p1, void* p2) ;
+EXPORT void f2_V_ISP_PPP(int p0, struct S_PPP p1, void* p2) ;
+EXPORT void f2_V_ISS_I(int p0, struct S_I p1, struct S_I p2) ;
+EXPORT void f2_V_ISS_F(int p0, struct S_F p1, struct S_F p2) ;
+EXPORT void f2_V_ISS_D(int p0, struct S_D p1, struct S_D p2) ;
+EXPORT void f2_V_ISS_P(int p0, struct S_P p1, struct S_P p2) ;
+EXPORT void f2_V_ISS_II(int p0, struct S_II p1, struct S_II p2) ;
+EXPORT void f2_V_ISS_IF(int p0, struct S_IF p1, struct S_IF p2) ;
+EXPORT void f2_V_ISS_ID(int p0, struct S_ID p1, struct S_ID p2) ;
+EXPORT void f2_V_ISS_IP(int p0, struct S_IP p1, struct S_IP p2) ;
+EXPORT void f2_V_ISS_FI(int p0, struct S_FI p1, struct S_FI p2) ;
+EXPORT void f2_V_ISS_FF(int p0, struct S_FF p1, struct S_FF p2) ;
+EXPORT void f2_V_ISS_FD(int p0, struct S_FD p1, struct S_FD p2) ;
+EXPORT void f2_V_ISS_FP(int p0, struct S_FP p1, struct S_FP p2) ;
+EXPORT void f2_V_ISS_DI(int p0, struct S_DI p1, struct S_DI p2) ;
+EXPORT void f2_V_ISS_DF(int p0, struct S_DF p1, struct S_DF p2) ;
+EXPORT void f2_V_ISS_DD(int p0, struct S_DD p1, struct S_DD p2) ;
+EXPORT void f2_V_ISS_DP(int p0, struct S_DP p1, struct S_DP p2) ;
+EXPORT void f2_V_ISS_PI(int p0, struct S_PI p1, struct S_PI p2) ;
+EXPORT void f2_V_ISS_PF(int p0, struct S_PF p1, struct S_PF p2) ;
+EXPORT void f2_V_ISS_PD(int p0, struct S_PD p1, struct S_PD p2) ;
+EXPORT void f2_V_ISS_PP(int p0, struct S_PP p1, struct S_PP p2) ;
+EXPORT void f2_V_ISS_III(int p0, struct S_III p1, struct S_III p2) ;
+EXPORT void f2_V_ISS_IIF(int p0, struct S_IIF p1, struct S_IIF p2) ;
+EXPORT void f2_V_ISS_IID(int p0, struct S_IID p1, struct S_IID p2) ;
+EXPORT void f2_V_ISS_IIP(int p0, struct S_IIP p1, struct S_IIP p2) ;
+EXPORT void f2_V_ISS_IFI(int p0, struct S_IFI p1, struct S_IFI p2) ;
+EXPORT void f2_V_ISS_IFF(int p0, struct S_IFF p1, struct S_IFF p2) ;
+EXPORT void f2_V_ISS_IFD(int p0, struct S_IFD p1, struct S_IFD p2) ;
+EXPORT void f2_V_ISS_IFP(int p0, struct S_IFP p1, struct S_IFP p2) ;
+EXPORT void f2_V_ISS_IDI(int p0, struct S_IDI p1, struct S_IDI p2) ;
+EXPORT void f2_V_ISS_IDF(int p0, struct S_IDF p1, struct S_IDF p2) ;
+EXPORT void f2_V_ISS_IDD(int p0, struct S_IDD p1, struct S_IDD p2) ;
+EXPORT void f2_V_ISS_IDP(int p0, struct S_IDP p1, struct S_IDP p2) ;
+EXPORT void f2_V_ISS_IPI(int p0, struct S_IPI p1, struct S_IPI p2) ;
+EXPORT void f2_V_ISS_IPF(int p0, struct S_IPF p1, struct S_IPF p2) ;
+EXPORT void f2_V_ISS_IPD(int p0, struct S_IPD p1, struct S_IPD p2) ;
+EXPORT void f2_V_ISS_IPP(int p0, struct S_IPP p1, struct S_IPP p2) ;
+EXPORT void f2_V_ISS_FII(int p0, struct S_FII p1, struct S_FII p2) ;
+EXPORT void f2_V_ISS_FIF(int p0, struct S_FIF p1, struct S_FIF p2) ;
+EXPORT void f2_V_ISS_FID(int p0, struct S_FID p1, struct S_FID p2) ;
+EXPORT void f2_V_ISS_FIP(int p0, struct S_FIP p1, struct S_FIP p2) ;
+EXPORT void f2_V_ISS_FFI(int p0, struct S_FFI p1, struct S_FFI p2) ;
+EXPORT void f2_V_ISS_FFF(int p0, struct S_FFF p1, struct S_FFF p2) ;
+EXPORT void f2_V_ISS_FFD(int p0, struct S_FFD p1, struct S_FFD p2) ;
+EXPORT void f2_V_ISS_FFP(int p0, struct S_FFP p1, struct S_FFP p2) ;
+EXPORT void f2_V_ISS_FDI(int p0, struct S_FDI p1, struct S_FDI p2) ;
+EXPORT void f2_V_ISS_FDF(int p0, struct S_FDF p1, struct S_FDF p2) ;
+EXPORT void f2_V_ISS_FDD(int p0, struct S_FDD p1, struct S_FDD p2) ;
+EXPORT void f2_V_ISS_FDP(int p0, struct S_FDP p1, struct S_FDP p2) ;
+EXPORT void f2_V_ISS_FPI(int p0, struct S_FPI p1, struct S_FPI p2) ;
+EXPORT void f2_V_ISS_FPF(int p0, struct S_FPF p1, struct S_FPF p2) ;
+EXPORT void f2_V_ISS_FPD(int p0, struct S_FPD p1, struct S_FPD p2) ;
+EXPORT void f2_V_ISS_FPP(int p0, struct S_FPP p1, struct S_FPP p2) ;
+EXPORT void f2_V_ISS_DII(int p0, struct S_DII p1, struct S_DII p2) ;
+EXPORT void f2_V_ISS_DIF(int p0, struct S_DIF p1, struct S_DIF p2) ;
+EXPORT void f2_V_ISS_DID(int p0, struct S_DID p1, struct S_DID p2) ;
+EXPORT void f2_V_ISS_DIP(int p0, struct S_DIP p1, struct S_DIP p2) ;
+EXPORT void f2_V_ISS_DFI(int p0, struct S_DFI p1, struct S_DFI p2) ;
+EXPORT void f2_V_ISS_DFF(int p0, struct S_DFF p1, struct S_DFF p2) ;
+EXPORT void f2_V_ISS_DFD(int p0, struct S_DFD p1, struct S_DFD p2) ;
+EXPORT void f2_V_ISS_DFP(int p0, struct S_DFP p1, struct S_DFP p2) ;
+EXPORT void f2_V_ISS_DDI(int p0, struct S_DDI p1, struct S_DDI p2) ;
+EXPORT void f2_V_ISS_DDF(int p0, struct S_DDF p1, struct S_DDF p2) ;
+EXPORT void f2_V_ISS_DDD(int p0, struct S_DDD p1, struct S_DDD p2) ;
+EXPORT void f2_V_ISS_DDP(int p0, struct S_DDP p1, struct S_DDP p2) ;
+EXPORT void f2_V_ISS_DPI(int p0, struct S_DPI p1, struct S_DPI p2) ;
+EXPORT void f2_V_ISS_DPF(int p0, struct S_DPF p1, struct S_DPF p2) ;
+EXPORT void f2_V_ISS_DPD(int p0, struct S_DPD p1, struct S_DPD p2) ;
+EXPORT void f2_V_ISS_DPP(int p0, struct S_DPP p1, struct S_DPP p2) ;
+EXPORT void f2_V_ISS_PII(int p0, struct S_PII p1, struct S_PII p2) ;
+EXPORT void f2_V_ISS_PIF(int p0, struct S_PIF p1, struct S_PIF p2) ;
+EXPORT void f2_V_ISS_PID(int p0, struct S_PID p1, struct S_PID p2) ;
+EXPORT void f2_V_ISS_PIP(int p0, struct S_PIP p1, struct S_PIP p2) ;
+EXPORT void f2_V_ISS_PFI(int p0, struct S_PFI p1, struct S_PFI p2) ;
+EXPORT void f2_V_ISS_PFF(int p0, struct S_PFF p1, struct S_PFF p2) ;
+EXPORT void f2_V_ISS_PFD(int p0, struct S_PFD p1, struct S_PFD p2) ;
+EXPORT void f2_V_ISS_PFP(int p0, struct S_PFP p1, struct S_PFP p2) ;
+EXPORT void f2_V_ISS_PDI(int p0, struct S_PDI p1, struct S_PDI p2) ;
+EXPORT void f2_V_ISS_PDF(int p0, struct S_PDF p1, struct S_PDF p2) ;
+EXPORT void f2_V_ISS_PDD(int p0, struct S_PDD p1, struct S_PDD p2) ;
+EXPORT void f2_V_ISS_PDP(int p0, struct S_PDP p1, struct S_PDP p2) ;
+EXPORT void f2_V_ISS_PPI(int p0, struct S_PPI p1, struct S_PPI p2) ;
+EXPORT void f2_V_ISS_PPF(int p0, struct S_PPF p1, struct S_PPF p2) ;
+EXPORT void f2_V_ISS_PPD(int p0, struct S_PPD p1, struct S_PPD p2) ;
+EXPORT void f2_V_ISS_PPP(int p0, struct S_PPP p1, struct S_PPP p2) ;
+EXPORT void f2_V_FII_(float p0, int p1, int p2) ;
+EXPORT void f2_V_FIF_(float p0, int p1, float p2) ;
+EXPORT void f2_V_FID_(float p0, int p1, double p2) ;
+EXPORT void f2_V_FIP_(float p0, int p1, void* p2) ;
+EXPORT void f2_V_FIS_I(float p0, int p1, struct S_I p2) ;
+EXPORT void f2_V_FIS_F(float p0, int p1, struct S_F p2) ;
+EXPORT void f2_V_FIS_D(float p0, int p1, struct S_D p2) ;
+EXPORT void f2_V_FIS_P(float p0, int p1, struct S_P p2) ;
+EXPORT void f2_V_FIS_II(float p0, int p1, struct S_II p2) ;
+EXPORT void f2_V_FIS_IF(float p0, int p1, struct S_IF p2) ;
+EXPORT void f2_V_FIS_ID(float p0, int p1, struct S_ID p2) ;
+EXPORT void f2_V_FIS_IP(float p0, int p1, struct S_IP p2) ;
+EXPORT void f2_V_FIS_FI(float p0, int p1, struct S_FI p2) ;
+EXPORT void f2_V_FIS_FF(float p0, int p1, struct S_FF p2) ;
+EXPORT void f2_V_FIS_FD(float p0, int p1, struct S_FD p2) ;
+EXPORT void f2_V_FIS_FP(float p0, int p1, struct S_FP p2) ;
+EXPORT void f2_V_FIS_DI(float p0, int p1, struct S_DI p2) ;
+EXPORT void f2_V_FIS_DF(float p0, int p1, struct S_DF p2) ;
+EXPORT void f2_V_FIS_DD(float p0, int p1, struct S_DD p2) ;
+EXPORT void f2_V_FIS_DP(float p0, int p1, struct S_DP p2) ;
+EXPORT void f2_V_FIS_PI(float p0, int p1, struct S_PI p2) ;
+EXPORT void f2_V_FIS_PF(float p0, int p1, struct S_PF p2) ;
+EXPORT void f2_V_FIS_PD(float p0, int p1, struct S_PD p2) ;
+EXPORT void f2_V_FIS_PP(float p0, int p1, struct S_PP p2) ;
+EXPORT void f2_V_FIS_III(float p0, int p1, struct S_III p2) ;
+EXPORT void f2_V_FIS_IIF(float p0, int p1, struct S_IIF p2) ;
+EXPORT void f2_V_FIS_IID(float p0, int p1, struct S_IID p2) ;
+EXPORT void f2_V_FIS_IIP(float p0, int p1, struct S_IIP p2) ;
+EXPORT void f2_V_FIS_IFI(float p0, int p1, struct S_IFI p2) ;
+EXPORT void f2_V_FIS_IFF(float p0, int p1, struct S_IFF p2) ;
+EXPORT void f2_V_FIS_IFD(float p0, int p1, struct S_IFD p2) ;
+EXPORT void f2_V_FIS_IFP(float p0, int p1, struct S_IFP p2) ;
+EXPORT void f2_V_FIS_IDI(float p0, int p1, struct S_IDI p2) ;
+EXPORT void f2_V_FIS_IDF(float p0, int p1, struct S_IDF p2) ;
+EXPORT void f2_V_FIS_IDD(float p0, int p1, struct S_IDD p2) ;
+EXPORT void f2_V_FIS_IDP(float p0, int p1, struct S_IDP p2) ;
+EXPORT void f2_V_FIS_IPI(float p0, int p1, struct S_IPI p2) ;
+EXPORT void f2_V_FIS_IPF(float p0, int p1, struct S_IPF p2) ;
+EXPORT void f2_V_FIS_IPD(float p0, int p1, struct S_IPD p2) ;
+EXPORT void f2_V_FIS_IPP(float p0, int p1, struct S_IPP p2) ;
+EXPORT void f2_V_FIS_FII(float p0, int p1, struct S_FII p2) ;
+EXPORT void f2_V_FIS_FIF(float p0, int p1, struct S_FIF p2) ;
+EXPORT void f2_V_FIS_FID(float p0, int p1, struct S_FID p2) ;
+EXPORT void f2_V_FIS_FIP(float p0, int p1, struct S_FIP p2) ;
+EXPORT void f2_V_FIS_FFI(float p0, int p1, struct S_FFI p2) ;
+EXPORT void f2_V_FIS_FFF(float p0, int p1, struct S_FFF p2) ;
+EXPORT void f2_V_FIS_FFD(float p0, int p1, struct S_FFD p2) ;
+EXPORT void f2_V_FIS_FFP(float p0, int p1, struct S_FFP p2) ;
+EXPORT void f2_V_FIS_FDI(float p0, int p1, struct S_FDI p2) ;
+EXPORT void f2_V_FIS_FDF(float p0, int p1, struct S_FDF p2) ;
+EXPORT void f2_V_FIS_FDD(float p0, int p1, struct S_FDD p2) ;
+EXPORT void f2_V_FIS_FDP(float p0, int p1, struct S_FDP p2) ;
+EXPORT void f2_V_FIS_FPI(float p0, int p1, struct S_FPI p2) ;
+EXPORT void f2_V_FIS_FPF(float p0, int p1, struct S_FPF p2) ;
+EXPORT void f2_V_FIS_FPD(float p0, int p1, struct S_FPD p2) ;
+EXPORT void f2_V_FIS_FPP(float p0, int p1, struct S_FPP p2) ;
+EXPORT void f2_V_FIS_DII(float p0, int p1, struct S_DII p2) ;
+EXPORT void f2_V_FIS_DIF(float p0, int p1, struct S_DIF p2) ;
+EXPORT void f2_V_FIS_DID(float p0, int p1, struct S_DID p2) ;
+EXPORT void f2_V_FIS_DIP(float p0, int p1, struct S_DIP p2) ;
+EXPORT void f2_V_FIS_DFI(float p0, int p1, struct S_DFI p2) ;
+EXPORT void f2_V_FIS_DFF(float p0, int p1, struct S_DFF p2) ;
+EXPORT void f2_V_FIS_DFD(float p0, int p1, struct S_DFD p2) ;
+EXPORT void f2_V_FIS_DFP(float p0, int p1, struct S_DFP p2) ;
+EXPORT void f2_V_FIS_DDI(float p0, int p1, struct S_DDI p2) ;
+EXPORT void f2_V_FIS_DDF(float p0, int p1, struct S_DDF p2) ;
+EXPORT void f2_V_FIS_DDD(float p0, int p1, struct S_DDD p2) ;
+EXPORT void f2_V_FIS_DDP(float p0, int p1, struct S_DDP p2) ;
+EXPORT void f2_V_FIS_DPI(float p0, int p1, struct S_DPI p2) ;
+EXPORT void f2_V_FIS_DPF(float p0, int p1, struct S_DPF p2) ;
+EXPORT void f2_V_FIS_DPD(float p0, int p1, struct S_DPD p2) ;
+EXPORT void f2_V_FIS_DPP(float p0, int p1, struct S_DPP p2) ;
+EXPORT void f2_V_FIS_PII(float p0, int p1, struct S_PII p2) ;
+EXPORT void f2_V_FIS_PIF(float p0, int p1, struct S_PIF p2) ;
+EXPORT void f2_V_FIS_PID(float p0, int p1, struct S_PID p2) ;
+EXPORT void f2_V_FIS_PIP(float p0, int p1, struct S_PIP p2) ;
+EXPORT void f2_V_FIS_PFI(float p0, int p1, struct S_PFI p2) ;
+EXPORT void f2_V_FIS_PFF(float p0, int p1, struct S_PFF p2) ;
+EXPORT void f2_V_FIS_PFD(float p0, int p1, struct S_PFD p2) ;
+EXPORT void f2_V_FIS_PFP(float p0, int p1, struct S_PFP p2) ;
+EXPORT void f2_V_FIS_PDI(float p0, int p1, struct S_PDI p2) ;
+EXPORT void f2_V_FIS_PDF(float p0, int p1, struct S_PDF p2) ;
+EXPORT void f2_V_FIS_PDD(float p0, int p1, struct S_PDD p2) ;
+EXPORT void f2_V_FIS_PDP(float p0, int p1, struct S_PDP p2) ;
+EXPORT void f2_V_FIS_PPI(float p0, int p1, struct S_PPI p2) ;
+EXPORT void f2_V_FIS_PPF(float p0, int p1, struct S_PPF p2) ;
+EXPORT void f2_V_FIS_PPD(float p0, int p1, struct S_PPD p2) ;
+EXPORT void f2_V_FIS_PPP(float p0, int p1, struct S_PPP p2) ;
+EXPORT void f2_V_FFI_(float p0, float p1, int p2) ;
+EXPORT void f2_V_FFF_(float p0, float p1, float p2) ;
+EXPORT void f2_V_FFD_(float p0, float p1, double p2) ;
+EXPORT void f2_V_FFP_(float p0, float p1, void* p2) ;
+EXPORT void f2_V_FFS_I(float p0, float p1, struct S_I p2) ;
+EXPORT void f2_V_FFS_F(float p0, float p1, struct S_F p2) ;
+EXPORT void f2_V_FFS_D(float p0, float p1, struct S_D p2) ;
+EXPORT void f2_V_FFS_P(float p0, float p1, struct S_P p2) ;
+EXPORT void f2_V_FFS_II(float p0, float p1, struct S_II p2) ;
+EXPORT void f2_V_FFS_IF(float p0, float p1, struct S_IF p2) ;
+EXPORT void f2_V_FFS_ID(float p0, float p1, struct S_ID p2) ;
+EXPORT void f2_V_FFS_IP(float p0, float p1, struct S_IP p2) ;
+EXPORT void f2_V_FFS_FI(float p0, float p1, struct S_FI p2) ;
+EXPORT void f2_V_FFS_FF(float p0, float p1, struct S_FF p2) ;
+EXPORT void f2_V_FFS_FD(float p0, float p1, struct S_FD p2) ;
+EXPORT void f2_V_FFS_FP(float p0, float p1, struct S_FP p2) ;
+EXPORT void f2_V_FFS_DI(float p0, float p1, struct S_DI p2) ;
+EXPORT void f2_V_FFS_DF(float p0, float p1, struct S_DF p2) ;
+EXPORT void f2_V_FFS_DD(float p0, float p1, struct S_DD p2) ;
+EXPORT void f2_V_FFS_DP(float p0, float p1, struct S_DP p2) ;
+EXPORT void f2_V_FFS_PI(float p0, float p1, struct S_PI p2) ;
+EXPORT void f2_V_FFS_PF(float p0, float p1, struct S_PF p2) ;
+EXPORT void f2_V_FFS_PD(float p0, float p1, struct S_PD p2) ;
+EXPORT void f2_V_FFS_PP(float p0, float p1, struct S_PP p2) ;
+EXPORT void f2_V_FFS_III(float p0, float p1, struct S_III p2) ;
+EXPORT void f2_V_FFS_IIF(float p0, float p1, struct S_IIF p2) ;
+EXPORT void f2_V_FFS_IID(float p0, float p1, struct S_IID p2) ;
+EXPORT void f2_V_FFS_IIP(float p0, float p1, struct S_IIP p2) ;
+EXPORT void f2_V_FFS_IFI(float p0, float p1, struct S_IFI p2) ;
+EXPORT void f2_V_FFS_IFF(float p0, float p1, struct S_IFF p2) ;
+EXPORT void f2_V_FFS_IFD(float p0, float p1, struct S_IFD p2) ;
+EXPORT void f2_V_FFS_IFP(float p0, float p1, struct S_IFP p2) ;
+EXPORT void f2_V_FFS_IDI(float p0, float p1, struct S_IDI p2) ;
+EXPORT void f2_V_FFS_IDF(float p0, float p1, struct S_IDF p2) ;
+EXPORT void f2_V_FFS_IDD(float p0, float p1, struct S_IDD p2) ;
+EXPORT void f2_V_FFS_IDP(float p0, float p1, struct S_IDP p2) ;
+EXPORT void f2_V_FFS_IPI(float p0, float p1, struct S_IPI p2) ;
+EXPORT void f2_V_FFS_IPF(float p0, float p1, struct S_IPF p2) ;
+EXPORT void f2_V_FFS_IPD(float p0, float p1, struct S_IPD p2) ;
+EXPORT void f2_V_FFS_IPP(float p0, float p1, struct S_IPP p2) ;
+EXPORT void f2_V_FFS_FII(float p0, float p1, struct S_FII p2) ;
+EXPORT void f2_V_FFS_FIF(float p0, float p1, struct S_FIF p2) ;
+EXPORT void f2_V_FFS_FID(float p0, float p1, struct S_FID p2) ;
+EXPORT void f2_V_FFS_FIP(float p0, float p1, struct S_FIP p2) ;
+EXPORT void f2_V_FFS_FFI(float p0, float p1, struct S_FFI p2) ;
+EXPORT void f2_V_FFS_FFF(float p0, float p1, struct S_FFF p2) ;
+EXPORT void f2_V_FFS_FFD(float p0, float p1, struct S_FFD p2) ;
+EXPORT void f2_V_FFS_FFP(float p0, float p1, struct S_FFP p2) ;
+EXPORT void f2_V_FFS_FDI(float p0, float p1, struct S_FDI p2) ;
+EXPORT void f2_V_FFS_FDF(float p0, float p1, struct S_FDF p2) ;
+EXPORT void f2_V_FFS_FDD(float p0, float p1, struct S_FDD p2) ;
+EXPORT void f2_V_FFS_FDP(float p0, float p1, struct S_FDP p2) ;
+EXPORT void f2_V_FFS_FPI(float p0, float p1, struct S_FPI p2) ;
+EXPORT void f2_V_FFS_FPF(float p0, float p1, struct S_FPF p2) ;
+EXPORT void f2_V_FFS_FPD(float p0, float p1, struct S_FPD p2) ;
+EXPORT void f2_V_FFS_FPP(float p0, float p1, struct S_FPP p2) ;
+EXPORT void f2_V_FFS_DII(float p0, float p1, struct S_DII p2) ;
+EXPORT void f2_V_FFS_DIF(float p0, float p1, struct S_DIF p2) ;
+EXPORT void f2_V_FFS_DID(float p0, float p1, struct S_DID p2) ;
+EXPORT void f2_V_FFS_DIP(float p0, float p1, struct S_DIP p2) ;
+EXPORT void f2_V_FFS_DFI(float p0, float p1, struct S_DFI p2) ;
+EXPORT void f2_V_FFS_DFF(float p0, float p1, struct S_DFF p2) ;
+EXPORT void f2_V_FFS_DFD(float p0, float p1, struct S_DFD p2) ;
+EXPORT void f2_V_FFS_DFP(float p0, float p1, struct S_DFP p2) ;
+EXPORT void f2_V_FFS_DDI(float p0, float p1, struct S_DDI p2) ;
+EXPORT void f2_V_FFS_DDF(float p0, float p1, struct S_DDF p2) ;
+EXPORT void f2_V_FFS_DDD(float p0, float p1, struct S_DDD p2) ;
+EXPORT void f2_V_FFS_DDP(float p0, float p1, struct S_DDP p2) ;
+EXPORT void f2_V_FFS_DPI(float p0, float p1, struct S_DPI p2) ;
+EXPORT void f2_V_FFS_DPF(float p0, float p1, struct S_DPF p2) ;
+EXPORT void f2_V_FFS_DPD(float p0, float p1, struct S_DPD p2) ;
+EXPORT void f2_V_FFS_DPP(float p0, float p1, struct S_DPP p2) ;
+EXPORT void f2_V_FFS_PII(float p0, float p1, struct S_PII p2) ;
+EXPORT void f2_V_FFS_PIF(float p0, float p1, struct S_PIF p2) ;
+EXPORT void f2_V_FFS_PID(float p0, float p1, struct S_PID p2) ;
+EXPORT void f2_V_FFS_PIP(float p0, float p1, struct S_PIP p2) ;
+EXPORT void f2_V_FFS_PFI(float p0, float p1, struct S_PFI p2) ;
+EXPORT void f2_V_FFS_PFF(float p0, float p1, struct S_PFF p2) ;
+EXPORT void f2_V_FFS_PFD(float p0, float p1, struct S_PFD p2) ;
+EXPORT void f3_V_FFS_PFP(float p0, float p1, struct S_PFP p2) ;
+EXPORT void f3_V_FFS_PDI(float p0, float p1, struct S_PDI p2) ;
+EXPORT void f3_V_FFS_PDF(float p0, float p1, struct S_PDF p2) ;
+EXPORT void f3_V_FFS_PDD(float p0, float p1, struct S_PDD p2) ;
+EXPORT void f3_V_FFS_PDP(float p0, float p1, struct S_PDP p2) ;
+EXPORT void f3_V_FFS_PPI(float p0, float p1, struct S_PPI p2) ;
+EXPORT void f3_V_FFS_PPF(float p0, float p1, struct S_PPF p2) ;
+EXPORT void f3_V_FFS_PPD(float p0, float p1, struct S_PPD p2) ;
+EXPORT void f3_V_FFS_PPP(float p0, float p1, struct S_PPP p2) ;
+EXPORT void f3_V_FDI_(float p0, double p1, int p2) ;
+EXPORT void f3_V_FDF_(float p0, double p1, float p2) ;
+EXPORT void f3_V_FDD_(float p0, double p1, double p2) ;
+EXPORT void f3_V_FDP_(float p0, double p1, void* p2) ;
+EXPORT void f3_V_FDS_I(float p0, double p1, struct S_I p2) ;
+EXPORT void f3_V_FDS_F(float p0, double p1, struct S_F p2) ;
+EXPORT void f3_V_FDS_D(float p0, double p1, struct S_D p2) ;
+EXPORT void f3_V_FDS_P(float p0, double p1, struct S_P p2) ;
+EXPORT void f3_V_FDS_II(float p0, double p1, struct S_II p2) ;
+EXPORT void f3_V_FDS_IF(float p0, double p1, struct S_IF p2) ;
+EXPORT void f3_V_FDS_ID(float p0, double p1, struct S_ID p2) ;
+EXPORT void f3_V_FDS_IP(float p0, double p1, struct S_IP p2) ;
+EXPORT void f3_V_FDS_FI(float p0, double p1, struct S_FI p2) ;
+EXPORT void f3_V_FDS_FF(float p0, double p1, struct S_FF p2) ;
+EXPORT void f3_V_FDS_FD(float p0, double p1, struct S_FD p2) ;
+EXPORT void f3_V_FDS_FP(float p0, double p1, struct S_FP p2) ;
+EXPORT void f3_V_FDS_DI(float p0, double p1, struct S_DI p2) ;
+EXPORT void f3_V_FDS_DF(float p0, double p1, struct S_DF p2) ;
+EXPORT void f3_V_FDS_DD(float p0, double p1, struct S_DD p2) ;
+EXPORT void f3_V_FDS_DP(float p0, double p1, struct S_DP p2) ;
+EXPORT void f3_V_FDS_PI(float p0, double p1, struct S_PI p2) ;
+EXPORT void f3_V_FDS_PF(float p0, double p1, struct S_PF p2) ;
+EXPORT void f3_V_FDS_PD(float p0, double p1, struct S_PD p2) ;
+EXPORT void f3_V_FDS_PP(float p0, double p1, struct S_PP p2) ;
+EXPORT void f3_V_FDS_III(float p0, double p1, struct S_III p2) ;
+EXPORT void f3_V_FDS_IIF(float p0, double p1, struct S_IIF p2) ;
+EXPORT void f3_V_FDS_IID(float p0, double p1, struct S_IID p2) ;
+EXPORT void f3_V_FDS_IIP(float p0, double p1, struct S_IIP p2) ;
+EXPORT void f3_V_FDS_IFI(float p0, double p1, struct S_IFI p2) ;
+EXPORT void f3_V_FDS_IFF(float p0, double p1, struct S_IFF p2) ;
+EXPORT void f3_V_FDS_IFD(float p0, double p1, struct S_IFD p2) ;
+EXPORT void f3_V_FDS_IFP(float p0, double p1, struct S_IFP p2) ;
+EXPORT void f3_V_FDS_IDI(float p0, double p1, struct S_IDI p2) ;
+EXPORT void f3_V_FDS_IDF(float p0, double p1, struct S_IDF p2) ;
+EXPORT void f3_V_FDS_IDD(float p0, double p1, struct S_IDD p2) ;
+EXPORT void f3_V_FDS_IDP(float p0, double p1, struct S_IDP p2) ;
+EXPORT void f3_V_FDS_IPI(float p0, double p1, struct S_IPI p2) ;
+EXPORT void f3_V_FDS_IPF(float p0, double p1, struct S_IPF p2) ;
+EXPORT void f3_V_FDS_IPD(float p0, double p1, struct S_IPD p2) ;
+EXPORT void f3_V_FDS_IPP(float p0, double p1, struct S_IPP p2) ;
+EXPORT void f3_V_FDS_FII(float p0, double p1, struct S_FII p2) ;
+EXPORT void f3_V_FDS_FIF(float p0, double p1, struct S_FIF p2) ;
+EXPORT void f3_V_FDS_FID(float p0, double p1, struct S_FID p2) ;
+EXPORT void f3_V_FDS_FIP(float p0, double p1, struct S_FIP p2) ;
+EXPORT void f3_V_FDS_FFI(float p0, double p1, struct S_FFI p2) ;
+EXPORT void f3_V_FDS_FFF(float p0, double p1, struct S_FFF p2) ;
+EXPORT void f3_V_FDS_FFD(float p0, double p1, struct S_FFD p2) ;
+EXPORT void f3_V_FDS_FFP(float p0, double p1, struct S_FFP p2) ;
+EXPORT void f3_V_FDS_FDI(float p0, double p1, struct S_FDI p2) ;
+EXPORT void f3_V_FDS_FDF(float p0, double p1, struct S_FDF p2) ;
+EXPORT void f3_V_FDS_FDD(float p0, double p1, struct S_FDD p2) ;
+EXPORT void f3_V_FDS_FDP(float p0, double p1, struct S_FDP p2) ;
+EXPORT void f3_V_FDS_FPI(float p0, double p1, struct S_FPI p2) ;
+EXPORT void f3_V_FDS_FPF(float p0, double p1, struct S_FPF p2) ;
+EXPORT void f3_V_FDS_FPD(float p0, double p1, struct S_FPD p2) ;
+EXPORT void f3_V_FDS_FPP(float p0, double p1, struct S_FPP p2) ;
+EXPORT void f3_V_FDS_DII(float p0, double p1, struct S_DII p2) ;
+EXPORT void f3_V_FDS_DIF(float p0, double p1, struct S_DIF p2) ;
+EXPORT void f3_V_FDS_DID(float p0, double p1, struct S_DID p2) ;
+EXPORT void f3_V_FDS_DIP(float p0, double p1, struct S_DIP p2) ;
+EXPORT void f3_V_FDS_DFI(float p0, double p1, struct S_DFI p2) ;
+EXPORT void f3_V_FDS_DFF(float p0, double p1, struct S_DFF p2) ;
+EXPORT void f3_V_FDS_DFD(float p0, double p1, struct S_DFD p2) ;
+EXPORT void f3_V_FDS_DFP(float p0, double p1, struct S_DFP p2) ;
+EXPORT void f3_V_FDS_DDI(float p0, double p1, struct S_DDI p2) ;
+EXPORT void f3_V_FDS_DDF(float p0, double p1, struct S_DDF p2) ;
+EXPORT void f3_V_FDS_DDD(float p0, double p1, struct S_DDD p2) ;
+EXPORT void f3_V_FDS_DDP(float p0, double p1, struct S_DDP p2) ;
+EXPORT void f3_V_FDS_DPI(float p0, double p1, struct S_DPI p2) ;
+EXPORT void f3_V_FDS_DPF(float p0, double p1, struct S_DPF p2) ;
+EXPORT void f3_V_FDS_DPD(float p0, double p1, struct S_DPD p2) ;
+EXPORT void f3_V_FDS_DPP(float p0, double p1, struct S_DPP p2) ;
+EXPORT void f3_V_FDS_PII(float p0, double p1, struct S_PII p2) ;
+EXPORT void f3_V_FDS_PIF(float p0, double p1, struct S_PIF p2) ;
+EXPORT void f3_V_FDS_PID(float p0, double p1, struct S_PID p2) ;
+EXPORT void f3_V_FDS_PIP(float p0, double p1, struct S_PIP p2) ;
+EXPORT void f3_V_FDS_PFI(float p0, double p1, struct S_PFI p2) ;
+EXPORT void f3_V_FDS_PFF(float p0, double p1, struct S_PFF p2) ;
+EXPORT void f3_V_FDS_PFD(float p0, double p1, struct S_PFD p2) ;
+EXPORT void f3_V_FDS_PFP(float p0, double p1, struct S_PFP p2) ;
+EXPORT void f3_V_FDS_PDI(float p0, double p1, struct S_PDI p2) ;
+EXPORT void f3_V_FDS_PDF(float p0, double p1, struct S_PDF p2) ;
+EXPORT void f3_V_FDS_PDD(float p0, double p1, struct S_PDD p2) ;
+EXPORT void f3_V_FDS_PDP(float p0, double p1, struct S_PDP p2) ;
+EXPORT void f3_V_FDS_PPI(float p0, double p1, struct S_PPI p2) ;
+EXPORT void f3_V_FDS_PPF(float p0, double p1, struct S_PPF p2) ;
+EXPORT void f3_V_FDS_PPD(float p0, double p1, struct S_PPD p2) ;
+EXPORT void f3_V_FDS_PPP(float p0, double p1, struct S_PPP p2) ;
+EXPORT void f3_V_FPI_(float p0, void* p1, int p2) ;
+EXPORT void f3_V_FPF_(float p0, void* p1, float p2) ;
+EXPORT void f3_V_FPD_(float p0, void* p1, double p2) ;
+EXPORT void f3_V_FPP_(float p0, void* p1, void* p2) ;
+EXPORT void f3_V_FPS_I(float p0, void* p1, struct S_I p2) ;
+EXPORT void f3_V_FPS_F(float p0, void* p1, struct S_F p2) ;
+EXPORT void f3_V_FPS_D(float p0, void* p1, struct S_D p2) ;
+EXPORT void f3_V_FPS_P(float p0, void* p1, struct S_P p2) ;
+EXPORT void f3_V_FPS_II(float p0, void* p1, struct S_II p2) ;
+EXPORT void f3_V_FPS_IF(float p0, void* p1, struct S_IF p2) ;
+EXPORT void f3_V_FPS_ID(float p0, void* p1, struct S_ID p2) ;
+EXPORT void f3_V_FPS_IP(float p0, void* p1, struct S_IP p2) ;
+EXPORT void f3_V_FPS_FI(float p0, void* p1, struct S_FI p2) ;
+EXPORT void f3_V_FPS_FF(float p0, void* p1, struct S_FF p2) ;
+EXPORT void f3_V_FPS_FD(float p0, void* p1, struct S_FD p2) ;
+EXPORT void f3_V_FPS_FP(float p0, void* p1, struct S_FP p2) ;
+EXPORT void f3_V_FPS_DI(float p0, void* p1, struct S_DI p2) ;
+EXPORT void f3_V_FPS_DF(float p0, void* p1, struct S_DF p2) ;
+EXPORT void f3_V_FPS_DD(float p0, void* p1, struct S_DD p2) ;
+EXPORT void f3_V_FPS_DP(float p0, void* p1, struct S_DP p2) ;
+EXPORT void f3_V_FPS_PI(float p0, void* p1, struct S_PI p2) ;
+EXPORT void f3_V_FPS_PF(float p0, void* p1, struct S_PF p2) ;
+EXPORT void f3_V_FPS_PD(float p0, void* p1, struct S_PD p2) ;
+EXPORT void f3_V_FPS_PP(float p0, void* p1, struct S_PP p2) ;
+EXPORT void f3_V_FPS_III(float p0, void* p1, struct S_III p2) ;
+EXPORT void f3_V_FPS_IIF(float p0, void* p1, struct S_IIF p2) ;
+EXPORT void f3_V_FPS_IID(float p0, void* p1, struct S_IID p2) ;
+EXPORT void f3_V_FPS_IIP(float p0, void* p1, struct S_IIP p2) ;
+EXPORT void f3_V_FPS_IFI(float p0, void* p1, struct S_IFI p2) ;
+EXPORT void f3_V_FPS_IFF(float p0, void* p1, struct S_IFF p2) ;
+EXPORT void f3_V_FPS_IFD(float p0, void* p1, struct S_IFD p2) ;
+EXPORT void f3_V_FPS_IFP(float p0, void* p1, struct S_IFP p2) ;
+EXPORT void f3_V_FPS_IDI(float p0, void* p1, struct S_IDI p2) ;
+EXPORT void f3_V_FPS_IDF(float p0, void* p1, struct S_IDF p2) ;
+EXPORT void f3_V_FPS_IDD(float p0, void* p1, struct S_IDD p2) ;
+EXPORT void f3_V_FPS_IDP(float p0, void* p1, struct S_IDP p2) ;
+EXPORT void f3_V_FPS_IPI(float p0, void* p1, struct S_IPI p2) ;
+EXPORT void f3_V_FPS_IPF(float p0, void* p1, struct S_IPF p2) ;
+EXPORT void f3_V_FPS_IPD(float p0, void* p1, struct S_IPD p2) ;
+EXPORT void f3_V_FPS_IPP(float p0, void* p1, struct S_IPP p2) ;
+EXPORT void f3_V_FPS_FII(float p0, void* p1, struct S_FII p2) ;
+EXPORT void f3_V_FPS_FIF(float p0, void* p1, struct S_FIF p2) ;
+EXPORT void f3_V_FPS_FID(float p0, void* p1, struct S_FID p2) ;
+EXPORT void f3_V_FPS_FIP(float p0, void* p1, struct S_FIP p2) ;
+EXPORT void f3_V_FPS_FFI(float p0, void* p1, struct S_FFI p2) ;
+EXPORT void f3_V_FPS_FFF(float p0, void* p1, struct S_FFF p2) ;
+EXPORT void f3_V_FPS_FFD(float p0, void* p1, struct S_FFD p2) ;
+EXPORT void f3_V_FPS_FFP(float p0, void* p1, struct S_FFP p2) ;
+EXPORT void f3_V_FPS_FDI(float p0, void* p1, struct S_FDI p2) ;
+EXPORT void f3_V_FPS_FDF(float p0, void* p1, struct S_FDF p2) ;
+EXPORT void f3_V_FPS_FDD(float p0, void* p1, struct S_FDD p2) ;
+EXPORT void f3_V_FPS_FDP(float p0, void* p1, struct S_FDP p2) ;
+EXPORT void f3_V_FPS_FPI(float p0, void* p1, struct S_FPI p2) ;
+EXPORT void f3_V_FPS_FPF(float p0, void* p1, struct S_FPF p2) ;
+EXPORT void f3_V_FPS_FPD(float p0, void* p1, struct S_FPD p2) ;
+EXPORT void f3_V_FPS_FPP(float p0, void* p1, struct S_FPP p2) ;
+EXPORT void f3_V_FPS_DII(float p0, void* p1, struct S_DII p2) ;
+EXPORT void f3_V_FPS_DIF(float p0, void* p1, struct S_DIF p2) ;
+EXPORT void f3_V_FPS_DID(float p0, void* p1, struct S_DID p2) ;
+EXPORT void f3_V_FPS_DIP(float p0, void* p1, struct S_DIP p2) ;
+EXPORT void f3_V_FPS_DFI(float p0, void* p1, struct S_DFI p2) ;
+EXPORT void f3_V_FPS_DFF(float p0, void* p1, struct S_DFF p2) ;
+EXPORT void f3_V_FPS_DFD(float p0, void* p1, struct S_DFD p2) ;
+EXPORT void f3_V_FPS_DFP(float p0, void* p1, struct S_DFP p2) ;
+EXPORT void f3_V_FPS_DDI(float p0, void* p1, struct S_DDI p2) ;
+EXPORT void f3_V_FPS_DDF(float p0, void* p1, struct S_DDF p2) ;
+EXPORT void f3_V_FPS_DDD(float p0, void* p1, struct S_DDD p2) ;
+EXPORT void f3_V_FPS_DDP(float p0, void* p1, struct S_DDP p2) ;
+EXPORT void f3_V_FPS_DPI(float p0, void* p1, struct S_DPI p2) ;
+EXPORT void f3_V_FPS_DPF(float p0, void* p1, struct S_DPF p2) ;
+EXPORT void f3_V_FPS_DPD(float p0, void* p1, struct S_DPD p2) ;
+EXPORT void f3_V_FPS_DPP(float p0, void* p1, struct S_DPP p2) ;
+EXPORT void f3_V_FPS_PII(float p0, void* p1, struct S_PII p2) ;
+EXPORT void f3_V_FPS_PIF(float p0, void* p1, struct S_PIF p2) ;
+EXPORT void f3_V_FPS_PID(float p0, void* p1, struct S_PID p2) ;
+EXPORT void f3_V_FPS_PIP(float p0, void* p1, struct S_PIP p2) ;
+EXPORT void f3_V_FPS_PFI(float p0, void* p1, struct S_PFI p2) ;
+EXPORT void f3_V_FPS_PFF(float p0, void* p1, struct S_PFF p2) ;
+EXPORT void f3_V_FPS_PFD(float p0, void* p1, struct S_PFD p2) ;
+EXPORT void f3_V_FPS_PFP(float p0, void* p1, struct S_PFP p2) ;
+EXPORT void f3_V_FPS_PDI(float p0, void* p1, struct S_PDI p2) ;
+EXPORT void f3_V_FPS_PDF(float p0, void* p1, struct S_PDF p2) ;
+EXPORT void f3_V_FPS_PDD(float p0, void* p1, struct S_PDD p2) ;
+EXPORT void f3_V_FPS_PDP(float p0, void* p1, struct S_PDP p2) ;
+EXPORT void f3_V_FPS_PPI(float p0, void* p1, struct S_PPI p2) ;
+EXPORT void f3_V_FPS_PPF(float p0, void* p1, struct S_PPF p2) ;
+EXPORT void f3_V_FPS_PPD(float p0, void* p1, struct S_PPD p2) ;
+EXPORT void f3_V_FPS_PPP(float p0, void* p1, struct S_PPP p2) ;
+EXPORT void f3_V_FSI_I(float p0, struct S_I p1, int p2) ;
+EXPORT void f3_V_FSI_F(float p0, struct S_F p1, int p2) ;
+EXPORT void f3_V_FSI_D(float p0, struct S_D p1, int p2) ;
+EXPORT void f3_V_FSI_P(float p0, struct S_P p1, int p2) ;
+EXPORT void f3_V_FSI_II(float p0, struct S_II p1, int p2) ;
+EXPORT void f3_V_FSI_IF(float p0, struct S_IF p1, int p2) ;
+EXPORT void f3_V_FSI_ID(float p0, struct S_ID p1, int p2) ;
+EXPORT void f3_V_FSI_IP(float p0, struct S_IP p1, int p2) ;
+EXPORT void f3_V_FSI_FI(float p0, struct S_FI p1, int p2) ;
+EXPORT void f3_V_FSI_FF(float p0, struct S_FF p1, int p2) ;
+EXPORT void f3_V_FSI_FD(float p0, struct S_FD p1, int p2) ;
+EXPORT void f3_V_FSI_FP(float p0, struct S_FP p1, int p2) ;
+EXPORT void f3_V_FSI_DI(float p0, struct S_DI p1, int p2) ;
+EXPORT void f3_V_FSI_DF(float p0, struct S_DF p1, int p2) ;
+EXPORT void f3_V_FSI_DD(float p0, struct S_DD p1, int p2) ;
+EXPORT void f3_V_FSI_DP(float p0, struct S_DP p1, int p2) ;
+EXPORT void f3_V_FSI_PI(float p0, struct S_PI p1, int p2) ;
+EXPORT void f3_V_FSI_PF(float p0, struct S_PF p1, int p2) ;
+EXPORT void f3_V_FSI_PD(float p0, struct S_PD p1, int p2) ;
+EXPORT void f3_V_FSI_PP(float p0, struct S_PP p1, int p2) ;
+EXPORT void f3_V_FSI_III(float p0, struct S_III p1, int p2) ;
+EXPORT void f3_V_FSI_IIF(float p0, struct S_IIF p1, int p2) ;
+EXPORT void f3_V_FSI_IID(float p0, struct S_IID p1, int p2) ;
+EXPORT void f3_V_FSI_IIP(float p0, struct S_IIP p1, int p2) ;
+EXPORT void f3_V_FSI_IFI(float p0, struct S_IFI p1, int p2) ;
+EXPORT void f3_V_FSI_IFF(float p0, struct S_IFF p1, int p2) ;
+EXPORT void f3_V_FSI_IFD(float p0, struct S_IFD p1, int p2) ;
+EXPORT void f3_V_FSI_IFP(float p0, struct S_IFP p1, int p2) ;
+EXPORT void f3_V_FSI_IDI(float p0, struct S_IDI p1, int p2) ;
+EXPORT void f3_V_FSI_IDF(float p0, struct S_IDF p1, int p2) ;
+EXPORT void f3_V_FSI_IDD(float p0, struct S_IDD p1, int p2) ;
+EXPORT void f3_V_FSI_IDP(float p0, struct S_IDP p1, int p2) ;
+EXPORT void f3_V_FSI_IPI(float p0, struct S_IPI p1, int p2) ;
+EXPORT void f3_V_FSI_IPF(float p0, struct S_IPF p1, int p2) ;
+EXPORT void f3_V_FSI_IPD(float p0, struct S_IPD p1, int p2) ;
+EXPORT void f3_V_FSI_IPP(float p0, struct S_IPP p1, int p2) ;
+EXPORT void f3_V_FSI_FII(float p0, struct S_FII p1, int p2) ;
+EXPORT void f3_V_FSI_FIF(float p0, struct S_FIF p1, int p2) ;
+EXPORT void f3_V_FSI_FID(float p0, struct S_FID p1, int p2) ;
+EXPORT void f3_V_FSI_FIP(float p0, struct S_FIP p1, int p2) ;
+EXPORT void f3_V_FSI_FFI(float p0, struct S_FFI p1, int p2) ;
+EXPORT void f3_V_FSI_FFF(float p0, struct S_FFF p1, int p2) ;
+EXPORT void f3_V_FSI_FFD(float p0, struct S_FFD p1, int p2) ;
+EXPORT void f3_V_FSI_FFP(float p0, struct S_FFP p1, int p2) ;
+EXPORT void f3_V_FSI_FDI(float p0, struct S_FDI p1, int p2) ;
+EXPORT void f3_V_FSI_FDF(float p0, struct S_FDF p1, int p2) ;
+EXPORT void f3_V_FSI_FDD(float p0, struct S_FDD p1, int p2) ;
+EXPORT void f3_V_FSI_FDP(float p0, struct S_FDP p1, int p2) ;
+EXPORT void f3_V_FSI_FPI(float p0, struct S_FPI p1, int p2) ;
+EXPORT void f3_V_FSI_FPF(float p0, struct S_FPF p1, int p2) ;
+EXPORT void f3_V_FSI_FPD(float p0, struct S_FPD p1, int p2) ;
+EXPORT void f3_V_FSI_FPP(float p0, struct S_FPP p1, int p2) ;
+EXPORT void f3_V_FSI_DII(float p0, struct S_DII p1, int p2) ;
+EXPORT void f3_V_FSI_DIF(float p0, struct S_DIF p1, int p2) ;
+EXPORT void f3_V_FSI_DID(float p0, struct S_DID p1, int p2) ;
+EXPORT void f3_V_FSI_DIP(float p0, struct S_DIP p1, int p2) ;
+EXPORT void f3_V_FSI_DFI(float p0, struct S_DFI p1, int p2) ;
+EXPORT void f3_V_FSI_DFF(float p0, struct S_DFF p1, int p2) ;
+EXPORT void f3_V_FSI_DFD(float p0, struct S_DFD p1, int p2) ;
+EXPORT void f3_V_FSI_DFP(float p0, struct S_DFP p1, int p2) ;
+EXPORT void f3_V_FSI_DDI(float p0, struct S_DDI p1, int p2) ;
+EXPORT void f3_V_FSI_DDF(float p0, struct S_DDF p1, int p2) ;
+EXPORT void f3_V_FSI_DDD(float p0, struct S_DDD p1, int p2) ;
+EXPORT void f3_V_FSI_DDP(float p0, struct S_DDP p1, int p2) ;
+EXPORT void f3_V_FSI_DPI(float p0, struct S_DPI p1, int p2) ;
+EXPORT void f3_V_FSI_DPF(float p0, struct S_DPF p1, int p2) ;
+EXPORT void f3_V_FSI_DPD(float p0, struct S_DPD p1, int p2) ;
+EXPORT void f3_V_FSI_DPP(float p0, struct S_DPP p1, int p2) ;
+EXPORT void f3_V_FSI_PII(float p0, struct S_PII p1, int p2) ;
+EXPORT void f3_V_FSI_PIF(float p0, struct S_PIF p1, int p2) ;
+EXPORT void f3_V_FSI_PID(float p0, struct S_PID p1, int p2) ;
+EXPORT void f3_V_FSI_PIP(float p0, struct S_PIP p1, int p2) ;
+EXPORT void f3_V_FSI_PFI(float p0, struct S_PFI p1, int p2) ;
+EXPORT void f3_V_FSI_PFF(float p0, struct S_PFF p1, int p2) ;
+EXPORT void f3_V_FSI_PFD(float p0, struct S_PFD p1, int p2) ;
+EXPORT void f3_V_FSI_PFP(float p0, struct S_PFP p1, int p2) ;
+EXPORT void f3_V_FSI_PDI(float p0, struct S_PDI p1, int p2) ;
+EXPORT void f3_V_FSI_PDF(float p0, struct S_PDF p1, int p2) ;
+EXPORT void f3_V_FSI_PDD(float p0, struct S_PDD p1, int p2) ;
+EXPORT void f3_V_FSI_PDP(float p0, struct S_PDP p1, int p2) ;
+EXPORT void f3_V_FSI_PPI(float p0, struct S_PPI p1, int p2) ;
+EXPORT void f3_V_FSI_PPF(float p0, struct S_PPF p1, int p2) ;
+EXPORT void f3_V_FSI_PPD(float p0, struct S_PPD p1, int p2) ;
+EXPORT void f3_V_FSI_PPP(float p0, struct S_PPP p1, int p2) ;
+EXPORT void f3_V_FSF_I(float p0, struct S_I p1, float p2) ;
+EXPORT void f3_V_FSF_F(float p0, struct S_F p1, float p2) ;
+EXPORT void f3_V_FSF_D(float p0, struct S_D p1, float p2) ;
+EXPORT void f3_V_FSF_P(float p0, struct S_P p1, float p2) ;
+EXPORT void f3_V_FSF_II(float p0, struct S_II p1, float p2) ;
+EXPORT void f3_V_FSF_IF(float p0, struct S_IF p1, float p2) ;
+EXPORT void f3_V_FSF_ID(float p0, struct S_ID p1, float p2) ;
+EXPORT void f3_V_FSF_IP(float p0, struct S_IP p1, float p2) ;
+EXPORT void f3_V_FSF_FI(float p0, struct S_FI p1, float p2) ;
+EXPORT void f3_V_FSF_FF(float p0, struct S_FF p1, float p2) ;
+EXPORT void f3_V_FSF_FD(float p0, struct S_FD p1, float p2) ;
+EXPORT void f3_V_FSF_FP(float p0, struct S_FP p1, float p2) ;
+EXPORT void f3_V_FSF_DI(float p0, struct S_DI p1, float p2) ;
+EXPORT void f3_V_FSF_DF(float p0, struct S_DF p1, float p2) ;
+EXPORT void f3_V_FSF_DD(float p0, struct S_DD p1, float p2) ;
+EXPORT void f3_V_FSF_DP(float p0, struct S_DP p1, float p2) ;
+EXPORT void f3_V_FSF_PI(float p0, struct S_PI p1, float p2) ;
+EXPORT void f3_V_FSF_PF(float p0, struct S_PF p1, float p2) ;
+EXPORT void f3_V_FSF_PD(float p0, struct S_PD p1, float p2) ;
+EXPORT void f3_V_FSF_PP(float p0, struct S_PP p1, float p2) ;
+EXPORT void f3_V_FSF_III(float p0, struct S_III p1, float p2) ;
+EXPORT void f3_V_FSF_IIF(float p0, struct S_IIF p1, float p2) ;
+EXPORT void f3_V_FSF_IID(float p0, struct S_IID p1, float p2) ;
+EXPORT void f3_V_FSF_IIP(float p0, struct S_IIP p1, float p2) ;
+EXPORT void f3_V_FSF_IFI(float p0, struct S_IFI p1, float p2) ;
+EXPORT void f3_V_FSF_IFF(float p0, struct S_IFF p1, float p2) ;
+EXPORT void f3_V_FSF_IFD(float p0, struct S_IFD p1, float p2) ;
+EXPORT void f3_V_FSF_IFP(float p0, struct S_IFP p1, float p2) ;
+EXPORT void f3_V_FSF_IDI(float p0, struct S_IDI p1, float p2) ;
+EXPORT void f3_V_FSF_IDF(float p0, struct S_IDF p1, float p2) ;
+EXPORT void f3_V_FSF_IDD(float p0, struct S_IDD p1, float p2) ;
+EXPORT void f3_V_FSF_IDP(float p0, struct S_IDP p1, float p2) ;
+EXPORT void f3_V_FSF_IPI(float p0, struct S_IPI p1, float p2) ;
+EXPORT void f3_V_FSF_IPF(float p0, struct S_IPF p1, float p2) ;
+EXPORT void f3_V_FSF_IPD(float p0, struct S_IPD p1, float p2) ;
+EXPORT void f3_V_FSF_IPP(float p0, struct S_IPP p1, float p2) ;
+EXPORT void f3_V_FSF_FII(float p0, struct S_FII p1, float p2) ;
+EXPORT void f3_V_FSF_FIF(float p0, struct S_FIF p1, float p2) ;
+EXPORT void f3_V_FSF_FID(float p0, struct S_FID p1, float p2) ;
+EXPORT void f3_V_FSF_FIP(float p0, struct S_FIP p1, float p2) ;
+EXPORT void f3_V_FSF_FFI(float p0, struct S_FFI p1, float p2) ;
+EXPORT void f3_V_FSF_FFF(float p0, struct S_FFF p1, float p2) ;
+EXPORT void f3_V_FSF_FFD(float p0, struct S_FFD p1, float p2) ;
+EXPORT void f3_V_FSF_FFP(float p0, struct S_FFP p1, float p2) ;
+EXPORT void f3_V_FSF_FDI(float p0, struct S_FDI p1, float p2) ;
+EXPORT void f3_V_FSF_FDF(float p0, struct S_FDF p1, float p2) ;
+EXPORT void f3_V_FSF_FDD(float p0, struct S_FDD p1, float p2) ;
+EXPORT void f3_V_FSF_FDP(float p0, struct S_FDP p1, float p2) ;
+EXPORT void f3_V_FSF_FPI(float p0, struct S_FPI p1, float p2) ;
+EXPORT void f3_V_FSF_FPF(float p0, struct S_FPF p1, float p2) ;
+EXPORT void f3_V_FSF_FPD(float p0, struct S_FPD p1, float p2) ;
+EXPORT void f3_V_FSF_FPP(float p0, struct S_FPP p1, float p2) ;
+EXPORT void f3_V_FSF_DII(float p0, struct S_DII p1, float p2) ;
+EXPORT void f3_V_FSF_DIF(float p0, struct S_DIF p1, float p2) ;
+EXPORT void f3_V_FSF_DID(float p0, struct S_DID p1, float p2) ;
+EXPORT void f3_V_FSF_DIP(float p0, struct S_DIP p1, float p2) ;
+EXPORT void f3_V_FSF_DFI(float p0, struct S_DFI p1, float p2) ;
+EXPORT void f3_V_FSF_DFF(float p0, struct S_DFF p1, float p2) ;
+EXPORT void f3_V_FSF_DFD(float p0, struct S_DFD p1, float p2) ;
+EXPORT void f3_V_FSF_DFP(float p0, struct S_DFP p1, float p2) ;
+EXPORT void f3_V_FSF_DDI(float p0, struct S_DDI p1, float p2) ;
+EXPORT void f3_V_FSF_DDF(float p0, struct S_DDF p1, float p2) ;
+EXPORT void f3_V_FSF_DDD(float p0, struct S_DDD p1, float p2) ;
+EXPORT void f3_V_FSF_DDP(float p0, struct S_DDP p1, float p2) ;
+EXPORT void f3_V_FSF_DPI(float p0, struct S_DPI p1, float p2) ;
+EXPORT void f3_V_FSF_DPF(float p0, struct S_DPF p1, float p2) ;
+EXPORT void f3_V_FSF_DPD(float p0, struct S_DPD p1, float p2) ;
+EXPORT void f3_V_FSF_DPP(float p0, struct S_DPP p1, float p2) ;
+EXPORT void f3_V_FSF_PII(float p0, struct S_PII p1, float p2) ;
+EXPORT void f3_V_FSF_PIF(float p0, struct S_PIF p1, float p2) ;
+EXPORT void f3_V_FSF_PID(float p0, struct S_PID p1, float p2) ;
+EXPORT void f3_V_FSF_PIP(float p0, struct S_PIP p1, float p2) ;
+EXPORT void f3_V_FSF_PFI(float p0, struct S_PFI p1, float p2) ;
+EXPORT void f3_V_FSF_PFF(float p0, struct S_PFF p1, float p2) ;
+EXPORT void f3_V_FSF_PFD(float p0, struct S_PFD p1, float p2) ;
+EXPORT void f3_V_FSF_PFP(float p0, struct S_PFP p1, float p2) ;
+EXPORT void f3_V_FSF_PDI(float p0, struct S_PDI p1, float p2) ;
+EXPORT void f3_V_FSF_PDF(float p0, struct S_PDF p1, float p2) ;
+EXPORT void f3_V_FSF_PDD(float p0, struct S_PDD p1, float p2) ;
+EXPORT void f3_V_FSF_PDP(float p0, struct S_PDP p1, float p2) ;
+EXPORT void f3_V_FSF_PPI(float p0, struct S_PPI p1, float p2) ;
+EXPORT void f3_V_FSF_PPF(float p0, struct S_PPF p1, float p2) ;
+EXPORT void f3_V_FSF_PPD(float p0, struct S_PPD p1, float p2) ;
+EXPORT void f3_V_FSF_PPP(float p0, struct S_PPP p1, float p2) ;
+EXPORT void f3_V_FSD_I(float p0, struct S_I p1, double p2) ;
+EXPORT void f3_V_FSD_F(float p0, struct S_F p1, double p2) ;
+EXPORT void f3_V_FSD_D(float p0, struct S_D p1, double p2) ;
+EXPORT void f3_V_FSD_P(float p0, struct S_P p1, double p2) ;
+EXPORT void f3_V_FSD_II(float p0, struct S_II p1, double p2) ;
+EXPORT void f3_V_FSD_IF(float p0, struct S_IF p1, double p2) ;
+EXPORT void f3_V_FSD_ID(float p0, struct S_ID p1, double p2) ;
+EXPORT void f3_V_FSD_IP(float p0, struct S_IP p1, double p2) ;
+EXPORT void f3_V_FSD_FI(float p0, struct S_FI p1, double p2) ;
+EXPORT void f3_V_FSD_FF(float p0, struct S_FF p1, double p2) ;
+EXPORT void f3_V_FSD_FD(float p0, struct S_FD p1, double p2) ;
+EXPORT void f3_V_FSD_FP(float p0, struct S_FP p1, double p2) ;
+EXPORT void f3_V_FSD_DI(float p0, struct S_DI p1, double p2) ;
+EXPORT void f3_V_FSD_DF(float p0, struct S_DF p1, double p2) ;
+EXPORT void f3_V_FSD_DD(float p0, struct S_DD p1, double p2) ;
+EXPORT void f3_V_FSD_DP(float p0, struct S_DP p1, double p2) ;
+EXPORT void f3_V_FSD_PI(float p0, struct S_PI p1, double p2) ;
+EXPORT void f3_V_FSD_PF(float p0, struct S_PF p1, double p2) ;
+EXPORT void f3_V_FSD_PD(float p0, struct S_PD p1, double p2) ;
+EXPORT void f3_V_FSD_PP(float p0, struct S_PP p1, double p2) ;
+EXPORT void f3_V_FSD_III(float p0, struct S_III p1, double p2) ;
+EXPORT void f3_V_FSD_IIF(float p0, struct S_IIF p1, double p2) ;
+EXPORT void f3_V_FSD_IID(float p0, struct S_IID p1, double p2) ;
+EXPORT void f3_V_FSD_IIP(float p0, struct S_IIP p1, double p2) ;
+EXPORT void f3_V_FSD_IFI(float p0, struct S_IFI p1, double p2) ;
+EXPORT void f3_V_FSD_IFF(float p0, struct S_IFF p1, double p2) ;
+EXPORT void f3_V_FSD_IFD(float p0, struct S_IFD p1, double p2) ;
+EXPORT void f3_V_FSD_IFP(float p0, struct S_IFP p1, double p2) ;
+EXPORT void f3_V_FSD_IDI(float p0, struct S_IDI p1, double p2) ;
+EXPORT void f3_V_FSD_IDF(float p0, struct S_IDF p1, double p2) ;
+EXPORT void f3_V_FSD_IDD(float p0, struct S_IDD p1, double p2) ;
+EXPORT void f3_V_FSD_IDP(float p0, struct S_IDP p1, double p2) ;
+EXPORT void f3_V_FSD_IPI(float p0, struct S_IPI p1, double p2) ;
+EXPORT void f3_V_FSD_IPF(float p0, struct S_IPF p1, double p2) ;
+EXPORT void f3_V_FSD_IPD(float p0, struct S_IPD p1, double p2) ;
+EXPORT void f3_V_FSD_IPP(float p0, struct S_IPP p1, double p2) ;
+EXPORT void f3_V_FSD_FII(float p0, struct S_FII p1, double p2) ;
+EXPORT void f3_V_FSD_FIF(float p0, struct S_FIF p1, double p2) ;
+EXPORT void f3_V_FSD_FID(float p0, struct S_FID p1, double p2) ;
+EXPORT void f3_V_FSD_FIP(float p0, struct S_FIP p1, double p2) ;
+EXPORT void f3_V_FSD_FFI(float p0, struct S_FFI p1, double p2) ;
+EXPORT void f3_V_FSD_FFF(float p0, struct S_FFF p1, double p2) ;
+EXPORT void f3_V_FSD_FFD(float p0, struct S_FFD p1, double p2) ;
+EXPORT void f3_V_FSD_FFP(float p0, struct S_FFP p1, double p2) ;
+EXPORT void f3_V_FSD_FDI(float p0, struct S_FDI p1, double p2) ;
+EXPORT void f3_V_FSD_FDF(float p0, struct S_FDF p1, double p2) ;
+EXPORT void f3_V_FSD_FDD(float p0, struct S_FDD p1, double p2) ;
+EXPORT void f3_V_FSD_FDP(float p0, struct S_FDP p1, double p2) ;
+EXPORT void f3_V_FSD_FPI(float p0, struct S_FPI p1, double p2) ;
+EXPORT void f3_V_FSD_FPF(float p0, struct S_FPF p1, double p2) ;
+EXPORT void f3_V_FSD_FPD(float p0, struct S_FPD p1, double p2) ;
+EXPORT void f3_V_FSD_FPP(float p0, struct S_FPP p1, double p2) ;
+EXPORT void f3_V_FSD_DII(float p0, struct S_DII p1, double p2) ;
+EXPORT void f3_V_FSD_DIF(float p0, struct S_DIF p1, double p2) ;
+EXPORT void f3_V_FSD_DID(float p0, struct S_DID p1, double p2) ;
+EXPORT void f3_V_FSD_DIP(float p0, struct S_DIP p1, double p2) ;
+EXPORT void f3_V_FSD_DFI(float p0, struct S_DFI p1, double p2) ;
+EXPORT void f3_V_FSD_DFF(float p0, struct S_DFF p1, double p2) ;
+EXPORT void f3_V_FSD_DFD(float p0, struct S_DFD p1, double p2) ;
+EXPORT void f3_V_FSD_DFP(float p0, struct S_DFP p1, double p2) ;
+EXPORT void f3_V_FSD_DDI(float p0, struct S_DDI p1, double p2) ;
+EXPORT void f3_V_FSD_DDF(float p0, struct S_DDF p1, double p2) ;
+EXPORT void f3_V_FSD_DDD(float p0, struct S_DDD p1, double p2) ;
+EXPORT void f3_V_FSD_DDP(float p0, struct S_DDP p1, double p2) ;
+EXPORT void f3_V_FSD_DPI(float p0, struct S_DPI p1, double p2) ;
+EXPORT void f3_V_FSD_DPF(float p0, struct S_DPF p1, double p2) ;
+EXPORT void f3_V_FSD_DPD(float p0, struct S_DPD p1, double p2) ;
+EXPORT void f3_V_FSD_DPP(float p0, struct S_DPP p1, double p2) ;
+EXPORT void f3_V_FSD_PII(float p0, struct S_PII p1, double p2) ;
+EXPORT void f3_V_FSD_PIF(float p0, struct S_PIF p1, double p2) ;
+EXPORT void f3_V_FSD_PID(float p0, struct S_PID p1, double p2) ;
+EXPORT void f3_V_FSD_PIP(float p0, struct S_PIP p1, double p2) ;
+EXPORT void f3_V_FSD_PFI(float p0, struct S_PFI p1, double p2) ;
+EXPORT void f3_V_FSD_PFF(float p0, struct S_PFF p1, double p2) ;
+EXPORT void f3_V_FSD_PFD(float p0, struct S_PFD p1, double p2) ;
+EXPORT void f3_V_FSD_PFP(float p0, struct S_PFP p1, double p2) ;
+EXPORT void f3_V_FSD_PDI(float p0, struct S_PDI p1, double p2) ;
+EXPORT void f3_V_FSD_PDF(float p0, struct S_PDF p1, double p2) ;
+EXPORT void f3_V_FSD_PDD(float p0, struct S_PDD p1, double p2) ;
+EXPORT void f3_V_FSD_PDP(float p0, struct S_PDP p1, double p2) ;
+EXPORT void f3_V_FSD_PPI(float p0, struct S_PPI p1, double p2) ;
+EXPORT void f3_V_FSD_PPF(float p0, struct S_PPF p1, double p2) ;
+EXPORT void f3_V_FSD_PPD(float p0, struct S_PPD p1, double p2) ;
+EXPORT void f3_V_FSD_PPP(float p0, struct S_PPP p1, double p2) ;
+EXPORT void f3_V_FSP_I(float p0, struct S_I p1, void* p2) ;
+EXPORT void f3_V_FSP_F(float p0, struct S_F p1, void* p2) ;
+EXPORT void f3_V_FSP_D(float p0, struct S_D p1, void* p2) ;
+EXPORT void f3_V_FSP_P(float p0, struct S_P p1, void* p2) ;
+EXPORT void f3_V_FSP_II(float p0, struct S_II p1, void* p2) ;
+EXPORT void f3_V_FSP_IF(float p0, struct S_IF p1, void* p2) ;
+EXPORT void f3_V_FSP_ID(float p0, struct S_ID p1, void* p2) ;
+EXPORT void f3_V_FSP_IP(float p0, struct S_IP p1, void* p2) ;
+EXPORT void f3_V_FSP_FI(float p0, struct S_FI p1, void* p2) ;
+EXPORT void f3_V_FSP_FF(float p0, struct S_FF p1, void* p2) ;
+EXPORT void f3_V_FSP_FD(float p0, struct S_FD p1, void* p2) ;
+EXPORT void f3_V_FSP_FP(float p0, struct S_FP p1, void* p2) ;
+EXPORT void f3_V_FSP_DI(float p0, struct S_DI p1, void* p2) ;
+EXPORT void f3_V_FSP_DF(float p0, struct S_DF p1, void* p2) ;
+EXPORT void f3_V_FSP_DD(float p0, struct S_DD p1, void* p2) ;
+EXPORT void f3_V_FSP_DP(float p0, struct S_DP p1, void* p2) ;
+EXPORT void f3_V_FSP_PI(float p0, struct S_PI p1, void* p2) ;
+EXPORT void f3_V_FSP_PF(float p0, struct S_PF p1, void* p2) ;
+EXPORT void f3_V_FSP_PD(float p0, struct S_PD p1, void* p2) ;
+EXPORT void f3_V_FSP_PP(float p0, struct S_PP p1, void* p2) ;
+EXPORT void f3_V_FSP_III(float p0, struct S_III p1, void* p2) ;
+EXPORT void f3_V_FSP_IIF(float p0, struct S_IIF p1, void* p2) ;
+EXPORT void f3_V_FSP_IID(float p0, struct S_IID p1, void* p2) ;
+EXPORT void f3_V_FSP_IIP(float p0, struct S_IIP p1, void* p2) ;
+EXPORT void f3_V_FSP_IFI(float p0, struct S_IFI p1, void* p2) ;
+EXPORT void f3_V_FSP_IFF(float p0, struct S_IFF p1, void* p2) ;
+EXPORT void f3_V_FSP_IFD(float p0, struct S_IFD p1, void* p2) ;
+EXPORT void f3_V_FSP_IFP(float p0, struct S_IFP p1, void* p2) ;
+EXPORT void f3_V_FSP_IDI(float p0, struct S_IDI p1, void* p2) ;
+EXPORT void f3_V_FSP_IDF(float p0, struct S_IDF p1, void* p2) ;
+EXPORT void f3_V_FSP_IDD(float p0, struct S_IDD p1, void* p2) ;
+EXPORT void f3_V_FSP_IDP(float p0, struct S_IDP p1, void* p2) ;
+EXPORT void f3_V_FSP_IPI(float p0, struct S_IPI p1, void* p2) ;
+EXPORT void f3_V_FSP_IPF(float p0, struct S_IPF p1, void* p2) ;
+EXPORT void f3_V_FSP_IPD(float p0, struct S_IPD p1, void* p2) ;
+EXPORT void f3_V_FSP_IPP(float p0, struct S_IPP p1, void* p2) ;
+EXPORT void f3_V_FSP_FII(float p0, struct S_FII p1, void* p2) ;
+EXPORT void f3_V_FSP_FIF(float p0, struct S_FIF p1, void* p2) ;
+EXPORT void f3_V_FSP_FID(float p0, struct S_FID p1, void* p2) ;
+EXPORT void f3_V_FSP_FIP(float p0, struct S_FIP p1, void* p2) ;
+EXPORT void f3_V_FSP_FFI(float p0, struct S_FFI p1, void* p2) ;
+EXPORT void f3_V_FSP_FFF(float p0, struct S_FFF p1, void* p2) ;
+EXPORT void f3_V_FSP_FFD(float p0, struct S_FFD p1, void* p2) ;
+EXPORT void f3_V_FSP_FFP(float p0, struct S_FFP p1, void* p2) ;
+EXPORT void f3_V_FSP_FDI(float p0, struct S_FDI p1, void* p2) ;
+EXPORT void f3_V_FSP_FDF(float p0, struct S_FDF p1, void* p2) ;
+EXPORT void f3_V_FSP_FDD(float p0, struct S_FDD p1, void* p2) ;
+EXPORT void f3_V_FSP_FDP(float p0, struct S_FDP p1, void* p2) ;
+EXPORT void f3_V_FSP_FPI(float p0, struct S_FPI p1, void* p2) ;
+EXPORT void f3_V_FSP_FPF(float p0, struct S_FPF p1, void* p2) ;
+EXPORT void f3_V_FSP_FPD(float p0, struct S_FPD p1, void* p2) ;
+EXPORT void f3_V_FSP_FPP(float p0, struct S_FPP p1, void* p2) ;
+EXPORT void f3_V_FSP_DII(float p0, struct S_DII p1, void* p2) ;
+EXPORT void f3_V_FSP_DIF(float p0, struct S_DIF p1, void* p2) ;
+EXPORT void f3_V_FSP_DID(float p0, struct S_DID p1, void* p2) ;
+EXPORT void f3_V_FSP_DIP(float p0, struct S_DIP p1, void* p2) ;
+EXPORT void f3_V_FSP_DFI(float p0, struct S_DFI p1, void* p2) ;
+EXPORT void f3_V_FSP_DFF(float p0, struct S_DFF p1, void* p2) ;
+EXPORT void f3_V_FSP_DFD(float p0, struct S_DFD p1, void* p2) ;
+EXPORT void f3_V_FSP_DFP(float p0, struct S_DFP p1, void* p2) ;
+EXPORT void f3_V_FSP_DDI(float p0, struct S_DDI p1, void* p2) ;
+EXPORT void f3_V_FSP_DDF(float p0, struct S_DDF p1, void* p2) ;
+EXPORT void f3_V_FSP_DDD(float p0, struct S_DDD p1, void* p2) ;
+EXPORT void f3_V_FSP_DDP(float p0, struct S_DDP p1, void* p2) ;
+EXPORT void f3_V_FSP_DPI(float p0, struct S_DPI p1, void* p2) ;
+EXPORT void f3_V_FSP_DPF(float p0, struct S_DPF p1, void* p2) ;
+EXPORT void f3_V_FSP_DPD(float p0, struct S_DPD p1, void* p2) ;
+EXPORT void f3_V_FSP_DPP(float p0, struct S_DPP p1, void* p2) ;
+EXPORT void f3_V_FSP_PII(float p0, struct S_PII p1, void* p2) ;
+EXPORT void f3_V_FSP_PIF(float p0, struct S_PIF p1, void* p2) ;
+EXPORT void f3_V_FSP_PID(float p0, struct S_PID p1, void* p2) ;
+EXPORT void f3_V_FSP_PIP(float p0, struct S_PIP p1, void* p2) ;
+EXPORT void f3_V_FSP_PFI(float p0, struct S_PFI p1, void* p2) ;
+EXPORT void f3_V_FSP_PFF(float p0, struct S_PFF p1, void* p2) ;
+EXPORT void f3_V_FSP_PFD(float p0, struct S_PFD p1, void* p2) ;
+EXPORT void f3_V_FSP_PFP(float p0, struct S_PFP p1, void* p2) ;
+EXPORT void f3_V_FSP_PDI(float p0, struct S_PDI p1, void* p2) ;
+EXPORT void f3_V_FSP_PDF(float p0, struct S_PDF p1, void* p2) ;
+EXPORT void f3_V_FSP_PDD(float p0, struct S_PDD p1, void* p2) ;
+EXPORT void f3_V_FSP_PDP(float p0, struct S_PDP p1, void* p2) ;
+EXPORT void f3_V_FSP_PPI(float p0, struct S_PPI p1, void* p2) ;
+EXPORT void f3_V_FSP_PPF(float p0, struct S_PPF p1, void* p2) ;
+EXPORT void f3_V_FSP_PPD(float p0, struct S_PPD p1, void* p2) ;
+EXPORT void f3_V_FSP_PPP(float p0, struct S_PPP p1, void* p2) ;
+EXPORT void f3_V_FSS_I(float p0, struct S_I p1, struct S_I p2) ;
+EXPORT void f3_V_FSS_F(float p0, struct S_F p1, struct S_F p2) ;
+EXPORT void f3_V_FSS_D(float p0, struct S_D p1, struct S_D p2) ;
+EXPORT void f3_V_FSS_P(float p0, struct S_P p1, struct S_P p2) ;
+EXPORT void f3_V_FSS_II(float p0, struct S_II p1, struct S_II p2) ;
+EXPORT void f3_V_FSS_IF(float p0, struct S_IF p1, struct S_IF p2) ;
+EXPORT void f3_V_FSS_ID(float p0, struct S_ID p1, struct S_ID p2) ;
+EXPORT void f3_V_FSS_IP(float p0, struct S_IP p1, struct S_IP p2) ;
+EXPORT void f3_V_FSS_FI(float p0, struct S_FI p1, struct S_FI p2) ;
+EXPORT void f3_V_FSS_FF(float p0, struct S_FF p1, struct S_FF p2) ;
+EXPORT void f3_V_FSS_FD(float p0, struct S_FD p1, struct S_FD p2) ;
+EXPORT void f3_V_FSS_FP(float p0, struct S_FP p1, struct S_FP p2) ;
+EXPORT void f3_V_FSS_DI(float p0, struct S_DI p1, struct S_DI p2) ;
+EXPORT void f3_V_FSS_DF(float p0, struct S_DF p1, struct S_DF p2) ;
+EXPORT void f3_V_FSS_DD(float p0, struct S_DD p1, struct S_DD p2) ;
+EXPORT void f3_V_FSS_DP(float p0, struct S_DP p1, struct S_DP p2) ;
+EXPORT void f3_V_FSS_PI(float p0, struct S_PI p1, struct S_PI p2) ;
+EXPORT void f3_V_FSS_PF(float p0, struct S_PF p1, struct S_PF p2) ;
+EXPORT void f3_V_FSS_PD(float p0, struct S_PD p1, struct S_PD p2) ;
+EXPORT void f3_V_FSS_PP(float p0, struct S_PP p1, struct S_PP p2) ;
+EXPORT void f3_V_FSS_III(float p0, struct S_III p1, struct S_III p2) ;
+EXPORT void f3_V_FSS_IIF(float p0, struct S_IIF p1, struct S_IIF p2) ;
+EXPORT void f3_V_FSS_IID(float p0, struct S_IID p1, struct S_IID p2) ;
+EXPORT void f3_V_FSS_IIP(float p0, struct S_IIP p1, struct S_IIP p2) ;
+EXPORT void f3_V_FSS_IFI(float p0, struct S_IFI p1, struct S_IFI p2) ;
+EXPORT void f3_V_FSS_IFF(float p0, struct S_IFF p1, struct S_IFF p2) ;
+EXPORT void f3_V_FSS_IFD(float p0, struct S_IFD p1, struct S_IFD p2) ;
+EXPORT void f3_V_FSS_IFP(float p0, struct S_IFP p1, struct S_IFP p2) ;
+EXPORT void f3_V_FSS_IDI(float p0, struct S_IDI p1, struct S_IDI p2) ;
+EXPORT void f3_V_FSS_IDF(float p0, struct S_IDF p1, struct S_IDF p2) ;
+EXPORT void f3_V_FSS_IDD(float p0, struct S_IDD p1, struct S_IDD p2) ;
+EXPORT void f3_V_FSS_IDP(float p0, struct S_IDP p1, struct S_IDP p2) ;
+EXPORT void f3_V_FSS_IPI(float p0, struct S_IPI p1, struct S_IPI p2) ;
+EXPORT void f3_V_FSS_IPF(float p0, struct S_IPF p1, struct S_IPF p2) ;
+EXPORT void f3_V_FSS_IPD(float p0, struct S_IPD p1, struct S_IPD p2) ;
+EXPORT void f3_V_FSS_IPP(float p0, struct S_IPP p1, struct S_IPP p2) ;
+EXPORT void f3_V_FSS_FII(float p0, struct S_FII p1, struct S_FII p2) ;
+EXPORT void f3_V_FSS_FIF(float p0, struct S_FIF p1, struct S_FIF p2) ;
+EXPORT void f3_V_FSS_FID(float p0, struct S_FID p1, struct S_FID p2) ;
+EXPORT void f3_V_FSS_FIP(float p0, struct S_FIP p1, struct S_FIP p2) ;
+EXPORT void f3_V_FSS_FFI(float p0, struct S_FFI p1, struct S_FFI p2) ;
+EXPORT void f3_V_FSS_FFF(float p0, struct S_FFF p1, struct S_FFF p2) ;
+EXPORT void f3_V_FSS_FFD(float p0, struct S_FFD p1, struct S_FFD p2) ;
+EXPORT void f3_V_FSS_FFP(float p0, struct S_FFP p1, struct S_FFP p2) ;
+EXPORT void f3_V_FSS_FDI(float p0, struct S_FDI p1, struct S_FDI p2) ;
+EXPORT void f3_V_FSS_FDF(float p0, struct S_FDF p1, struct S_FDF p2) ;
+EXPORT void f3_V_FSS_FDD(float p0, struct S_FDD p1, struct S_FDD p2) ;
+EXPORT void f3_V_FSS_FDP(float p0, struct S_FDP p1, struct S_FDP p2) ;
+EXPORT void f3_V_FSS_FPI(float p0, struct S_FPI p1, struct S_FPI p2) ;
+EXPORT void f3_V_FSS_FPF(float p0, struct S_FPF p1, struct S_FPF p2) ;
+EXPORT void f3_V_FSS_FPD(float p0, struct S_FPD p1, struct S_FPD p2) ;
+EXPORT void f3_V_FSS_FPP(float p0, struct S_FPP p1, struct S_FPP p2) ;
+EXPORT void f3_V_FSS_DII(float p0, struct S_DII p1, struct S_DII p2) ;
+EXPORT void f3_V_FSS_DIF(float p0, struct S_DIF p1, struct S_DIF p2) ;
+EXPORT void f3_V_FSS_DID(float p0, struct S_DID p1, struct S_DID p2) ;
+EXPORT void f3_V_FSS_DIP(float p0, struct S_DIP p1, struct S_DIP p2) ;
+EXPORT void f3_V_FSS_DFI(float p0, struct S_DFI p1, struct S_DFI p2) ;
+EXPORT void f3_V_FSS_DFF(float p0, struct S_DFF p1, struct S_DFF p2) ;
+EXPORT void f3_V_FSS_DFD(float p0, struct S_DFD p1, struct S_DFD p2) ;
+EXPORT void f3_V_FSS_DFP(float p0, struct S_DFP p1, struct S_DFP p2) ;
+EXPORT void f3_V_FSS_DDI(float p0, struct S_DDI p1, struct S_DDI p2) ;
+EXPORT void f3_V_FSS_DDF(float p0, struct S_DDF p1, struct S_DDF p2) ;
+EXPORT void f3_V_FSS_DDD(float p0, struct S_DDD p1, struct S_DDD p2) ;
+EXPORT void f3_V_FSS_DDP(float p0, struct S_DDP p1, struct S_DDP p2) ;
+EXPORT void f3_V_FSS_DPI(float p0, struct S_DPI p1, struct S_DPI p2) ;
+EXPORT void f3_V_FSS_DPF(float p0, struct S_DPF p1, struct S_DPF p2) ;
+EXPORT void f3_V_FSS_DPD(float p0, struct S_DPD p1, struct S_DPD p2) ;
+EXPORT void f3_V_FSS_DPP(float p0, struct S_DPP p1, struct S_DPP p2) ;
+EXPORT void f3_V_FSS_PII(float p0, struct S_PII p1, struct S_PII p2) ;
+EXPORT void f3_V_FSS_PIF(float p0, struct S_PIF p1, struct S_PIF p2) ;
+EXPORT void f3_V_FSS_PID(float p0, struct S_PID p1, struct S_PID p2) ;
+EXPORT void f3_V_FSS_PIP(float p0, struct S_PIP p1, struct S_PIP p2) ;
+EXPORT void f3_V_FSS_PFI(float p0, struct S_PFI p1, struct S_PFI p2) ;
+EXPORT void f3_V_FSS_PFF(float p0, struct S_PFF p1, struct S_PFF p2) ;
+EXPORT void f3_V_FSS_PFD(float p0, struct S_PFD p1, struct S_PFD p2) ;
+EXPORT void f3_V_FSS_PFP(float p0, struct S_PFP p1, struct S_PFP p2) ;
+EXPORT void f3_V_FSS_PDI(float p0, struct S_PDI p1, struct S_PDI p2) ;
+EXPORT void f3_V_FSS_PDF(float p0, struct S_PDF p1, struct S_PDF p2) ;
+EXPORT void f3_V_FSS_PDD(float p0, struct S_PDD p1, struct S_PDD p2) ;
+EXPORT void f4_V_FSS_PDP(float p0, struct S_PDP p1, struct S_PDP p2) ;
+EXPORT void f4_V_FSS_PPI(float p0, struct S_PPI p1, struct S_PPI p2) ;
+EXPORT void f4_V_FSS_PPF(float p0, struct S_PPF p1, struct S_PPF p2) ;
+EXPORT void f4_V_FSS_PPD(float p0, struct S_PPD p1, struct S_PPD p2) ;
+EXPORT void f4_V_FSS_PPP(float p0, struct S_PPP p1, struct S_PPP p2) ;
+EXPORT void f4_V_DII_(double p0, int p1, int p2) ;
+EXPORT void f4_V_DIF_(double p0, int p1, float p2) ;
+EXPORT void f4_V_DID_(double p0, int p1, double p2) ;
+EXPORT void f4_V_DIP_(double p0, int p1, void* p2) ;
+EXPORT void f4_V_DIS_I(double p0, int p1, struct S_I p2) ;
+EXPORT void f4_V_DIS_F(double p0, int p1, struct S_F p2) ;
+EXPORT void f4_V_DIS_D(double p0, int p1, struct S_D p2) ;
+EXPORT void f4_V_DIS_P(double p0, int p1, struct S_P p2) ;
+EXPORT void f4_V_DIS_II(double p0, int p1, struct S_II p2) ;
+EXPORT void f4_V_DIS_IF(double p0, int p1, struct S_IF p2) ;
+EXPORT void f4_V_DIS_ID(double p0, int p1, struct S_ID p2) ;
+EXPORT void f4_V_DIS_IP(double p0, int p1, struct S_IP p2) ;
+EXPORT void f4_V_DIS_FI(double p0, int p1, struct S_FI p2) ;
+EXPORT void f4_V_DIS_FF(double p0, int p1, struct S_FF p2) ;
+EXPORT void f4_V_DIS_FD(double p0, int p1, struct S_FD p2) ;
+EXPORT void f4_V_DIS_FP(double p0, int p1, struct S_FP p2) ;
+EXPORT void f4_V_DIS_DI(double p0, int p1, struct S_DI p2) ;
+EXPORT void f4_V_DIS_DF(double p0, int p1, struct S_DF p2) ;
+EXPORT void f4_V_DIS_DD(double p0, int p1, struct S_DD p2) ;
+EXPORT void f4_V_DIS_DP(double p0, int p1, struct S_DP p2) ;
+EXPORT void f4_V_DIS_PI(double p0, int p1, struct S_PI p2) ;
+EXPORT void f4_V_DIS_PF(double p0, int p1, struct S_PF p2) ;
+EXPORT void f4_V_DIS_PD(double p0, int p1, struct S_PD p2) ;
+EXPORT void f4_V_DIS_PP(double p0, int p1, struct S_PP p2) ;
+EXPORT void f4_V_DIS_III(double p0, int p1, struct S_III p2) ;
+EXPORT void f4_V_DIS_IIF(double p0, int p1, struct S_IIF p2) ;
+EXPORT void f4_V_DIS_IID(double p0, int p1, struct S_IID p2) ;
+EXPORT void f4_V_DIS_IIP(double p0, int p1, struct S_IIP p2) ;
+EXPORT void f4_V_DIS_IFI(double p0, int p1, struct S_IFI p2) ;
+EXPORT void f4_V_DIS_IFF(double p0, int p1, struct S_IFF p2) ;
+EXPORT void f4_V_DIS_IFD(double p0, int p1, struct S_IFD p2) ;
+EXPORT void f4_V_DIS_IFP(double p0, int p1, struct S_IFP p2) ;
+EXPORT void f4_V_DIS_IDI(double p0, int p1, struct S_IDI p2) ;
+EXPORT void f4_V_DIS_IDF(double p0, int p1, struct S_IDF p2) ;
+EXPORT void f4_V_DIS_IDD(double p0, int p1, struct S_IDD p2) ;
+EXPORT void f4_V_DIS_IDP(double p0, int p1, struct S_IDP p2) ;
+EXPORT void f4_V_DIS_IPI(double p0, int p1, struct S_IPI p2) ;
+EXPORT void f4_V_DIS_IPF(double p0, int p1, struct S_IPF p2) ;
+EXPORT void f4_V_DIS_IPD(double p0, int p1, struct S_IPD p2) ;
+EXPORT void f4_V_DIS_IPP(double p0, int p1, struct S_IPP p2) ;
+EXPORT void f4_V_DIS_FII(double p0, int p1, struct S_FII p2) ;
+EXPORT void f4_V_DIS_FIF(double p0, int p1, struct S_FIF p2) ;
+EXPORT void f4_V_DIS_FID(double p0, int p1, struct S_FID p2) ;
+EXPORT void f4_V_DIS_FIP(double p0, int p1, struct S_FIP p2) ;
+EXPORT void f4_V_DIS_FFI(double p0, int p1, struct S_FFI p2) ;
+EXPORT void f4_V_DIS_FFF(double p0, int p1, struct S_FFF p2) ;
+EXPORT void f4_V_DIS_FFD(double p0, int p1, struct S_FFD p2) ;
+EXPORT void f4_V_DIS_FFP(double p0, int p1, struct S_FFP p2) ;
+EXPORT void f4_V_DIS_FDI(double p0, int p1, struct S_FDI p2) ;
+EXPORT void f4_V_DIS_FDF(double p0, int p1, struct S_FDF p2) ;
+EXPORT void f4_V_DIS_FDD(double p0, int p1, struct S_FDD p2) ;
+EXPORT void f4_V_DIS_FDP(double p0, int p1, struct S_FDP p2) ;
+EXPORT void f4_V_DIS_FPI(double p0, int p1, struct S_FPI p2) ;
+EXPORT void f4_V_DIS_FPF(double p0, int p1, struct S_FPF p2) ;
+EXPORT void f4_V_DIS_FPD(double p0, int p1, struct S_FPD p2) ;
+EXPORT void f4_V_DIS_FPP(double p0, int p1, struct S_FPP p2) ;
+EXPORT void f4_V_DIS_DII(double p0, int p1, struct S_DII p2) ;
+EXPORT void f4_V_DIS_DIF(double p0, int p1, struct S_DIF p2) ;
+EXPORT void f4_V_DIS_DID(double p0, int p1, struct S_DID p2) ;
+EXPORT void f4_V_DIS_DIP(double p0, int p1, struct S_DIP p2) ;
+EXPORT void f4_V_DIS_DFI(double p0, int p1, struct S_DFI p2) ;
+EXPORT void f4_V_DIS_DFF(double p0, int p1, struct S_DFF p2) ;
+EXPORT void f4_V_DIS_DFD(double p0, int p1, struct S_DFD p2) ;
+EXPORT void f4_V_DIS_DFP(double p0, int p1, struct S_DFP p2) ;
+EXPORT void f4_V_DIS_DDI(double p0, int p1, struct S_DDI p2) ;
+EXPORT void f4_V_DIS_DDF(double p0, int p1, struct S_DDF p2) ;
+EXPORT void f4_V_DIS_DDD(double p0, int p1, struct S_DDD p2) ;
+EXPORT void f4_V_DIS_DDP(double p0, int p1, struct S_DDP p2) ;
+EXPORT void f4_V_DIS_DPI(double p0, int p1, struct S_DPI p2) ;
+EXPORT void f4_V_DIS_DPF(double p0, int p1, struct S_DPF p2) ;
+EXPORT void f4_V_DIS_DPD(double p0, int p1, struct S_DPD p2) ;
+EXPORT void f4_V_DIS_DPP(double p0, int p1, struct S_DPP p2) ;
+EXPORT void f4_V_DIS_PII(double p0, int p1, struct S_PII p2) ;
+EXPORT void f4_V_DIS_PIF(double p0, int p1, struct S_PIF p2) ;
+EXPORT void f4_V_DIS_PID(double p0, int p1, struct S_PID p2) ;
+EXPORT void f4_V_DIS_PIP(double p0, int p1, struct S_PIP p2) ;
+EXPORT void f4_V_DIS_PFI(double p0, int p1, struct S_PFI p2) ;
+EXPORT void f4_V_DIS_PFF(double p0, int p1, struct S_PFF p2) ;
+EXPORT void f4_V_DIS_PFD(double p0, int p1, struct S_PFD p2) ;
+EXPORT void f4_V_DIS_PFP(double p0, int p1, struct S_PFP p2) ;
+EXPORT void f4_V_DIS_PDI(double p0, int p1, struct S_PDI p2) ;
+EXPORT void f4_V_DIS_PDF(double p0, int p1, struct S_PDF p2) ;
+EXPORT void f4_V_DIS_PDD(double p0, int p1, struct S_PDD p2) ;
+EXPORT void f4_V_DIS_PDP(double p0, int p1, struct S_PDP p2) ;
+EXPORT void f4_V_DIS_PPI(double p0, int p1, struct S_PPI p2) ;
+EXPORT void f4_V_DIS_PPF(double p0, int p1, struct S_PPF p2) ;
+EXPORT void f4_V_DIS_PPD(double p0, int p1, struct S_PPD p2) ;
+EXPORT void f4_V_DIS_PPP(double p0, int p1, struct S_PPP p2) ;
+EXPORT void f4_V_DFI_(double p0, float p1, int p2) ;
+EXPORT void f4_V_DFF_(double p0, float p1, float p2) ;
+EXPORT void f4_V_DFD_(double p0, float p1, double p2) ;
+EXPORT void f4_V_DFP_(double p0, float p1, void* p2) ;
+EXPORT void f4_V_DFS_I(double p0, float p1, struct S_I p2) ;
+EXPORT void f4_V_DFS_F(double p0, float p1, struct S_F p2) ;
+EXPORT void f4_V_DFS_D(double p0, float p1, struct S_D p2) ;
+EXPORT void f4_V_DFS_P(double p0, float p1, struct S_P p2) ;
+EXPORT void f4_V_DFS_II(double p0, float p1, struct S_II p2) ;
+EXPORT void f4_V_DFS_IF(double p0, float p1, struct S_IF p2) ;
+EXPORT void f4_V_DFS_ID(double p0, float p1, struct S_ID p2) ;
+EXPORT void f4_V_DFS_IP(double p0, float p1, struct S_IP p2) ;
+EXPORT void f4_V_DFS_FI(double p0, float p1, struct S_FI p2) ;
+EXPORT void f4_V_DFS_FF(double p0, float p1, struct S_FF p2) ;
+EXPORT void f4_V_DFS_FD(double p0, float p1, struct S_FD p2) ;
+EXPORT void f4_V_DFS_FP(double p0, float p1, struct S_FP p2) ;
+EXPORT void f4_V_DFS_DI(double p0, float p1, struct S_DI p2) ;
+EXPORT void f4_V_DFS_DF(double p0, float p1, struct S_DF p2) ;
+EXPORT void f4_V_DFS_DD(double p0, float p1, struct S_DD p2) ;
+EXPORT void f4_V_DFS_DP(double p0, float p1, struct S_DP p2) ;
+EXPORT void f4_V_DFS_PI(double p0, float p1, struct S_PI p2) ;
+EXPORT void f4_V_DFS_PF(double p0, float p1, struct S_PF p2) ;
+EXPORT void f4_V_DFS_PD(double p0, float p1, struct S_PD p2) ;
+EXPORT void f4_V_DFS_PP(double p0, float p1, struct S_PP p2) ;
+EXPORT void f4_V_DFS_III(double p0, float p1, struct S_III p2) ;
+EXPORT void f4_V_DFS_IIF(double p0, float p1, struct S_IIF p2) ;
+EXPORT void f4_V_DFS_IID(double p0, float p1, struct S_IID p2) ;
+EXPORT void f4_V_DFS_IIP(double p0, float p1, struct S_IIP p2) ;
+EXPORT void f4_V_DFS_IFI(double p0, float p1, struct S_IFI p2) ;
+EXPORT void f4_V_DFS_IFF(double p0, float p1, struct S_IFF p2) ;
+EXPORT void f4_V_DFS_IFD(double p0, float p1, struct S_IFD p2) ;
+EXPORT void f4_V_DFS_IFP(double p0, float p1, struct S_IFP p2) ;
+EXPORT void f4_V_DFS_IDI(double p0, float p1, struct S_IDI p2) ;
+EXPORT void f4_V_DFS_IDF(double p0, float p1, struct S_IDF p2) ;
+EXPORT void f4_V_DFS_IDD(double p0, float p1, struct S_IDD p2) ;
+EXPORT void f4_V_DFS_IDP(double p0, float p1, struct S_IDP p2) ;
+EXPORT void f4_V_DFS_IPI(double p0, float p1, struct S_IPI p2) ;
+EXPORT void f4_V_DFS_IPF(double p0, float p1, struct S_IPF p2) ;
+EXPORT void f4_V_DFS_IPD(double p0, float p1, struct S_IPD p2) ;
+EXPORT void f4_V_DFS_IPP(double p0, float p1, struct S_IPP p2) ;
+EXPORT void f4_V_DFS_FII(double p0, float p1, struct S_FII p2) ;
+EXPORT void f4_V_DFS_FIF(double p0, float p1, struct S_FIF p2) ;
+EXPORT void f4_V_DFS_FID(double p0, float p1, struct S_FID p2) ;
+EXPORT void f4_V_DFS_FIP(double p0, float p1, struct S_FIP p2) ;
+EXPORT void f4_V_DFS_FFI(double p0, float p1, struct S_FFI p2) ;
+EXPORT void f4_V_DFS_FFF(double p0, float p1, struct S_FFF p2) ;
+EXPORT void f4_V_DFS_FFD(double p0, float p1, struct S_FFD p2) ;
+EXPORT void f4_V_DFS_FFP(double p0, float p1, struct S_FFP p2) ;
+EXPORT void f4_V_DFS_FDI(double p0, float p1, struct S_FDI p2) ;
+EXPORT void f4_V_DFS_FDF(double p0, float p1, struct S_FDF p2) ;
+EXPORT void f4_V_DFS_FDD(double p0, float p1, struct S_FDD p2) ;
+EXPORT void f4_V_DFS_FDP(double p0, float p1, struct S_FDP p2) ;
+EXPORT void f4_V_DFS_FPI(double p0, float p1, struct S_FPI p2) ;
+EXPORT void f4_V_DFS_FPF(double p0, float p1, struct S_FPF p2) ;
+EXPORT void f4_V_DFS_FPD(double p0, float p1, struct S_FPD p2) ;
+EXPORT void f4_V_DFS_FPP(double p0, float p1, struct S_FPP p2) ;
+EXPORT void f4_V_DFS_DII(double p0, float p1, struct S_DII p2) ;
+EXPORT void f4_V_DFS_DIF(double p0, float p1, struct S_DIF p2) ;
+EXPORT void f4_V_DFS_DID(double p0, float p1, struct S_DID p2) ;
+EXPORT void f4_V_DFS_DIP(double p0, float p1, struct S_DIP p2) ;
+EXPORT void f4_V_DFS_DFI(double p0, float p1, struct S_DFI p2) ;
+EXPORT void f4_V_DFS_DFF(double p0, float p1, struct S_DFF p2) ;
+EXPORT void f4_V_DFS_DFD(double p0, float p1, struct S_DFD p2) ;
+EXPORT void f4_V_DFS_DFP(double p0, float p1, struct S_DFP p2) ;
+EXPORT void f4_V_DFS_DDI(double p0, float p1, struct S_DDI p2) ;
+EXPORT void f4_V_DFS_DDF(double p0, float p1, struct S_DDF p2) ;
+EXPORT void f4_V_DFS_DDD(double p0, float p1, struct S_DDD p2) ;
+EXPORT void f4_V_DFS_DDP(double p0, float p1, struct S_DDP p2) ;
+EXPORT void f4_V_DFS_DPI(double p0, float p1, struct S_DPI p2) ;
+EXPORT void f4_V_DFS_DPF(double p0, float p1, struct S_DPF p2) ;
+EXPORT void f4_V_DFS_DPD(double p0, float p1, struct S_DPD p2) ;
+EXPORT void f4_V_DFS_DPP(double p0, float p1, struct S_DPP p2) ;
+EXPORT void f4_V_DFS_PII(double p0, float p1, struct S_PII p2) ;
+EXPORT void f4_V_DFS_PIF(double p0, float p1, struct S_PIF p2) ;
+EXPORT void f4_V_DFS_PID(double p0, float p1, struct S_PID p2) ;
+EXPORT void f4_V_DFS_PIP(double p0, float p1, struct S_PIP p2) ;
+EXPORT void f4_V_DFS_PFI(double p0, float p1, struct S_PFI p2) ;
+EXPORT void f4_V_DFS_PFF(double p0, float p1, struct S_PFF p2) ;
+EXPORT void f4_V_DFS_PFD(double p0, float p1, struct S_PFD p2) ;
+EXPORT void f4_V_DFS_PFP(double p0, float p1, struct S_PFP p2) ;
+EXPORT void f4_V_DFS_PDI(double p0, float p1, struct S_PDI p2) ;
+EXPORT void f4_V_DFS_PDF(double p0, float p1, struct S_PDF p2) ;
+EXPORT void f4_V_DFS_PDD(double p0, float p1, struct S_PDD p2) ;
+EXPORT void f4_V_DFS_PDP(double p0, float p1, struct S_PDP p2) ;
+EXPORT void f4_V_DFS_PPI(double p0, float p1, struct S_PPI p2) ;
+EXPORT void f4_V_DFS_PPF(double p0, float p1, struct S_PPF p2) ;
+EXPORT void f4_V_DFS_PPD(double p0, float p1, struct S_PPD p2) ;
+EXPORT void f4_V_DFS_PPP(double p0, float p1, struct S_PPP p2) ;
+EXPORT void f4_V_DDI_(double p0, double p1, int p2) ;
+EXPORT void f4_V_DDF_(double p0, double p1, float p2) ;
+EXPORT void f4_V_DDD_(double p0, double p1, double p2) ;
+EXPORT void f4_V_DDP_(double p0, double p1, void* p2) ;
+EXPORT void f4_V_DDS_I(double p0, double p1, struct S_I p2) ;
+EXPORT void f4_V_DDS_F(double p0, double p1, struct S_F p2) ;
+EXPORT void f4_V_DDS_D(double p0, double p1, struct S_D p2) ;
+EXPORT void f4_V_DDS_P(double p0, double p1, struct S_P p2) ;
+EXPORT void f4_V_DDS_II(double p0, double p1, struct S_II p2) ;
+EXPORT void f4_V_DDS_IF(double p0, double p1, struct S_IF p2) ;
+EXPORT void f4_V_DDS_ID(double p0, double p1, struct S_ID p2) ;
+EXPORT void f4_V_DDS_IP(double p0, double p1, struct S_IP p2) ;
+EXPORT void f4_V_DDS_FI(double p0, double p1, struct S_FI p2) ;
+EXPORT void f4_V_DDS_FF(double p0, double p1, struct S_FF p2) ;
+EXPORT void f4_V_DDS_FD(double p0, double p1, struct S_FD p2) ;
+EXPORT void f4_V_DDS_FP(double p0, double p1, struct S_FP p2) ;
+EXPORT void f4_V_DDS_DI(double p0, double p1, struct S_DI p2) ;
+EXPORT void f4_V_DDS_DF(double p0, double p1, struct S_DF p2) ;
+EXPORT void f4_V_DDS_DD(double p0, double p1, struct S_DD p2) ;
+EXPORT void f4_V_DDS_DP(double p0, double p1, struct S_DP p2) ;
+EXPORT void f4_V_DDS_PI(double p0, double p1, struct S_PI p2) ;
+EXPORT void f4_V_DDS_PF(double p0, double p1, struct S_PF p2) ;
+EXPORT void f4_V_DDS_PD(double p0, double p1, struct S_PD p2) ;
+EXPORT void f4_V_DDS_PP(double p0, double p1, struct S_PP p2) ;
+EXPORT void f4_V_DDS_III(double p0, double p1, struct S_III p2) ;
+EXPORT void f4_V_DDS_IIF(double p0, double p1, struct S_IIF p2) ;
+EXPORT void f4_V_DDS_IID(double p0, double p1, struct S_IID p2) ;
+EXPORT void f4_V_DDS_IIP(double p0, double p1, struct S_IIP p2) ;
+EXPORT void f4_V_DDS_IFI(double p0, double p1, struct S_IFI p2) ;
+EXPORT void f4_V_DDS_IFF(double p0, double p1, struct S_IFF p2) ;
+EXPORT void f4_V_DDS_IFD(double p0, double p1, struct S_IFD p2) ;
+EXPORT void f4_V_DDS_IFP(double p0, double p1, struct S_IFP p2) ;
+EXPORT void f4_V_DDS_IDI(double p0, double p1, struct S_IDI p2) ;
+EXPORT void f4_V_DDS_IDF(double p0, double p1, struct S_IDF p2) ;
+EXPORT void f4_V_DDS_IDD(double p0, double p1, struct S_IDD p2) ;
+EXPORT void f4_V_DDS_IDP(double p0, double p1, struct S_IDP p2) ;
+EXPORT void f4_V_DDS_IPI(double p0, double p1, struct S_IPI p2) ;
+EXPORT void f4_V_DDS_IPF(double p0, double p1, struct S_IPF p2) ;
+EXPORT void f4_V_DDS_IPD(double p0, double p1, struct S_IPD p2) ;
+EXPORT void f4_V_DDS_IPP(double p0, double p1, struct S_IPP p2) ;
+EXPORT void f4_V_DDS_FII(double p0, double p1, struct S_FII p2) ;
+EXPORT void f4_V_DDS_FIF(double p0, double p1, struct S_FIF p2) ;
+EXPORT void f4_V_DDS_FID(double p0, double p1, struct S_FID p2) ;
+EXPORT void f4_V_DDS_FIP(double p0, double p1, struct S_FIP p2) ;
+EXPORT void f4_V_DDS_FFI(double p0, double p1, struct S_FFI p2) ;
+EXPORT void f4_V_DDS_FFF(double p0, double p1, struct S_FFF p2) ;
+EXPORT void f4_V_DDS_FFD(double p0, double p1, struct S_FFD p2) ;
+EXPORT void f4_V_DDS_FFP(double p0, double p1, struct S_FFP p2) ;
+EXPORT void f4_V_DDS_FDI(double p0, double p1, struct S_FDI p2) ;
+EXPORT void f4_V_DDS_FDF(double p0, double p1, struct S_FDF p2) ;
+EXPORT void f4_V_DDS_FDD(double p0, double p1, struct S_FDD p2) ;
+EXPORT void f4_V_DDS_FDP(double p0, double p1, struct S_FDP p2) ;
+EXPORT void f4_V_DDS_FPI(double p0, double p1, struct S_FPI p2) ;
+EXPORT void f4_V_DDS_FPF(double p0, double p1, struct S_FPF p2) ;
+EXPORT void f4_V_DDS_FPD(double p0, double p1, struct S_FPD p2) ;
+EXPORT void f4_V_DDS_FPP(double p0, double p1, struct S_FPP p2) ;
+EXPORT void f4_V_DDS_DII(double p0, double p1, struct S_DII p2) ;
+EXPORT void f4_V_DDS_DIF(double p0, double p1, struct S_DIF p2) ;
+EXPORT void f4_V_DDS_DID(double p0, double p1, struct S_DID p2) ;
+EXPORT void f4_V_DDS_DIP(double p0, double p1, struct S_DIP p2) ;
+EXPORT void f4_V_DDS_DFI(double p0, double p1, struct S_DFI p2) ;
+EXPORT void f4_V_DDS_DFF(double p0, double p1, struct S_DFF p2) ;
+EXPORT void f4_V_DDS_DFD(double p0, double p1, struct S_DFD p2) ;
+EXPORT void f4_V_DDS_DFP(double p0, double p1, struct S_DFP p2) ;
+EXPORT void f4_V_DDS_DDI(double p0, double p1, struct S_DDI p2) ;
+EXPORT void f4_V_DDS_DDF(double p0, double p1, struct S_DDF p2) ;
+EXPORT void f4_V_DDS_DDD(double p0, double p1, struct S_DDD p2) ;
+EXPORT void f4_V_DDS_DDP(double p0, double p1, struct S_DDP p2) ;
+EXPORT void f4_V_DDS_DPI(double p0, double p1, struct S_DPI p2) ;
+EXPORT void f4_V_DDS_DPF(double p0, double p1, struct S_DPF p2) ;
+EXPORT void f4_V_DDS_DPD(double p0, double p1, struct S_DPD p2) ;
+EXPORT void f4_V_DDS_DPP(double p0, double p1, struct S_DPP p2) ;
+EXPORT void f4_V_DDS_PII(double p0, double p1, struct S_PII p2) ;
+EXPORT void f4_V_DDS_PIF(double p0, double p1, struct S_PIF p2) ;
+EXPORT void f4_V_DDS_PID(double p0, double p1, struct S_PID p2) ;
+EXPORT void f4_V_DDS_PIP(double p0, double p1, struct S_PIP p2) ;
+EXPORT void f4_V_DDS_PFI(double p0, double p1, struct S_PFI p2) ;
+EXPORT void f4_V_DDS_PFF(double p0, double p1, struct S_PFF p2) ;
+EXPORT void f4_V_DDS_PFD(double p0, double p1, struct S_PFD p2) ;
+EXPORT void f4_V_DDS_PFP(double p0, double p1, struct S_PFP p2) ;
+EXPORT void f4_V_DDS_PDI(double p0, double p1, struct S_PDI p2) ;
+EXPORT void f4_V_DDS_PDF(double p0, double p1, struct S_PDF p2) ;
+EXPORT void f4_V_DDS_PDD(double p0, double p1, struct S_PDD p2) ;
+EXPORT void f4_V_DDS_PDP(double p0, double p1, struct S_PDP p2) ;
+EXPORT void f4_V_DDS_PPI(double p0, double p1, struct S_PPI p2) ;
+EXPORT void f4_V_DDS_PPF(double p0, double p1, struct S_PPF p2) ;
+EXPORT void f4_V_DDS_PPD(double p0, double p1, struct S_PPD p2) ;
+EXPORT void f4_V_DDS_PPP(double p0, double p1, struct S_PPP p2) ;
+EXPORT void f4_V_DPI_(double p0, void* p1, int p2) ;
+EXPORT void f4_V_DPF_(double p0, void* p1, float p2) ;
+EXPORT void f4_V_DPD_(double p0, void* p1, double p2) ;
+EXPORT void f4_V_DPP_(double p0, void* p1, void* p2) ;
+EXPORT void f4_V_DPS_I(double p0, void* p1, struct S_I p2) ;
+EXPORT void f4_V_DPS_F(double p0, void* p1, struct S_F p2) ;
+EXPORT void f4_V_DPS_D(double p0, void* p1, struct S_D p2) ;
+EXPORT void f4_V_DPS_P(double p0, void* p1, struct S_P p2) ;
+EXPORT void f4_V_DPS_II(double p0, void* p1, struct S_II p2) ;
+EXPORT void f4_V_DPS_IF(double p0, void* p1, struct S_IF p2) ;
+EXPORT void f4_V_DPS_ID(double p0, void* p1, struct S_ID p2) ;
+EXPORT void f4_V_DPS_IP(double p0, void* p1, struct S_IP p2) ;
+EXPORT void f4_V_DPS_FI(double p0, void* p1, struct S_FI p2) ;
+EXPORT void f4_V_DPS_FF(double p0, void* p1, struct S_FF p2) ;
+EXPORT void f4_V_DPS_FD(double p0, void* p1, struct S_FD p2) ;
+EXPORT void f4_V_DPS_FP(double p0, void* p1, struct S_FP p2) ;
+EXPORT void f4_V_DPS_DI(double p0, void* p1, struct S_DI p2) ;
+EXPORT void f4_V_DPS_DF(double p0, void* p1, struct S_DF p2) ;
+EXPORT void f4_V_DPS_DD(double p0, void* p1, struct S_DD p2) ;
+EXPORT void f4_V_DPS_DP(double p0, void* p1, struct S_DP p2) ;
+EXPORT void f4_V_DPS_PI(double p0, void* p1, struct S_PI p2) ;
+EXPORT void f4_V_DPS_PF(double p0, void* p1, struct S_PF p2) ;
+EXPORT void f4_V_DPS_PD(double p0, void* p1, struct S_PD p2) ;
+EXPORT void f4_V_DPS_PP(double p0, void* p1, struct S_PP p2) ;
+EXPORT void f4_V_DPS_III(double p0, void* p1, struct S_III p2) ;
+EXPORT void f4_V_DPS_IIF(double p0, void* p1, struct S_IIF p2) ;
+EXPORT void f4_V_DPS_IID(double p0, void* p1, struct S_IID p2) ;
+EXPORT void f4_V_DPS_IIP(double p0, void* p1, struct S_IIP p2) ;
+EXPORT void f4_V_DPS_IFI(double p0, void* p1, struct S_IFI p2) ;
+EXPORT void f4_V_DPS_IFF(double p0, void* p1, struct S_IFF p2) ;
+EXPORT void f4_V_DPS_IFD(double p0, void* p1, struct S_IFD p2) ;
+EXPORT void f4_V_DPS_IFP(double p0, void* p1, struct S_IFP p2) ;
+EXPORT void f4_V_DPS_IDI(double p0, void* p1, struct S_IDI p2) ;
+EXPORT void f4_V_DPS_IDF(double p0, void* p1, struct S_IDF p2) ;
+EXPORT void f4_V_DPS_IDD(double p0, void* p1, struct S_IDD p2) ;
+EXPORT void f4_V_DPS_IDP(double p0, void* p1, struct S_IDP p2) ;
+EXPORT void f4_V_DPS_IPI(double p0, void* p1, struct S_IPI p2) ;
+EXPORT void f4_V_DPS_IPF(double p0, void* p1, struct S_IPF p2) ;
+EXPORT void f4_V_DPS_IPD(double p0, void* p1, struct S_IPD p2) ;
+EXPORT void f4_V_DPS_IPP(double p0, void* p1, struct S_IPP p2) ;
+EXPORT void f4_V_DPS_FII(double p0, void* p1, struct S_FII p2) ;
+EXPORT void f4_V_DPS_FIF(double p0, void* p1, struct S_FIF p2) ;
+EXPORT void f4_V_DPS_FID(double p0, void* p1, struct S_FID p2) ;
+EXPORT void f4_V_DPS_FIP(double p0, void* p1, struct S_FIP p2) ;
+EXPORT void f4_V_DPS_FFI(double p0, void* p1, struct S_FFI p2) ;
+EXPORT void f4_V_DPS_FFF(double p0, void* p1, struct S_FFF p2) ;
+EXPORT void f4_V_DPS_FFD(double p0, void* p1, struct S_FFD p2) ;
+EXPORT void f4_V_DPS_FFP(double p0, void* p1, struct S_FFP p2) ;
+EXPORT void f4_V_DPS_FDI(double p0, void* p1, struct S_FDI p2) ;
+EXPORT void f4_V_DPS_FDF(double p0, void* p1, struct S_FDF p2) ;
+EXPORT void f4_V_DPS_FDD(double p0, void* p1, struct S_FDD p2) ;
+EXPORT void f4_V_DPS_FDP(double p0, void* p1, struct S_FDP p2) ;
+EXPORT void f4_V_DPS_FPI(double p0, void* p1, struct S_FPI p2) ;
+EXPORT void f4_V_DPS_FPF(double p0, void* p1, struct S_FPF p2) ;
+EXPORT void f4_V_DPS_FPD(double p0, void* p1, struct S_FPD p2) ;
+EXPORT void f4_V_DPS_FPP(double p0, void* p1, struct S_FPP p2) ;
+EXPORT void f4_V_DPS_DII(double p0, void* p1, struct S_DII p2) ;
+EXPORT void f4_V_DPS_DIF(double p0, void* p1, struct S_DIF p2) ;
+EXPORT void f4_V_DPS_DID(double p0, void* p1, struct S_DID p2) ;
+EXPORT void f4_V_DPS_DIP(double p0, void* p1, struct S_DIP p2) ;
+EXPORT void f4_V_DPS_DFI(double p0, void* p1, struct S_DFI p2) ;
+EXPORT void f4_V_DPS_DFF(double p0, void* p1, struct S_DFF p2) ;
+EXPORT void f4_V_DPS_DFD(double p0, void* p1, struct S_DFD p2) ;
+EXPORT void f4_V_DPS_DFP(double p0, void* p1, struct S_DFP p2) ;
+EXPORT void f4_V_DPS_DDI(double p0, void* p1, struct S_DDI p2) ;
+EXPORT void f4_V_DPS_DDF(double p0, void* p1, struct S_DDF p2) ;
+EXPORT void f4_V_DPS_DDD(double p0, void* p1, struct S_DDD p2) ;
+EXPORT void f4_V_DPS_DDP(double p0, void* p1, struct S_DDP p2) ;
+EXPORT void f4_V_DPS_DPI(double p0, void* p1, struct S_DPI p2) ;
+EXPORT void f4_V_DPS_DPF(double p0, void* p1, struct S_DPF p2) ;
+EXPORT void f4_V_DPS_DPD(double p0, void* p1, struct S_DPD p2) ;
+EXPORT void f4_V_DPS_DPP(double p0, void* p1, struct S_DPP p2) ;
+EXPORT void f4_V_DPS_PII(double p0, void* p1, struct S_PII p2) ;
+EXPORT void f4_V_DPS_PIF(double p0, void* p1, struct S_PIF p2) ;
+EXPORT void f4_V_DPS_PID(double p0, void* p1, struct S_PID p2) ;
+EXPORT void f4_V_DPS_PIP(double p0, void* p1, struct S_PIP p2) ;
+EXPORT void f4_V_DPS_PFI(double p0, void* p1, struct S_PFI p2) ;
+EXPORT void f4_V_DPS_PFF(double p0, void* p1, struct S_PFF p2) ;
+EXPORT void f4_V_DPS_PFD(double p0, void* p1, struct S_PFD p2) ;
+EXPORT void f4_V_DPS_PFP(double p0, void* p1, struct S_PFP p2) ;
+EXPORT void f4_V_DPS_PDI(double p0, void* p1, struct S_PDI p2) ;
+EXPORT void f4_V_DPS_PDF(double p0, void* p1, struct S_PDF p2) ;
+EXPORT void f4_V_DPS_PDD(double p0, void* p1, struct S_PDD p2) ;
+EXPORT void f4_V_DPS_PDP(double p0, void* p1, struct S_PDP p2) ;
+EXPORT void f4_V_DPS_PPI(double p0, void* p1, struct S_PPI p2) ;
+EXPORT void f4_V_DPS_PPF(double p0, void* p1, struct S_PPF p2) ;
+EXPORT void f4_V_DPS_PPD(double p0, void* p1, struct S_PPD p2) ;
+EXPORT void f4_V_DPS_PPP(double p0, void* p1, struct S_PPP p2) ;
+EXPORT void f4_V_DSI_I(double p0, struct S_I p1, int p2) ;
+EXPORT void f4_V_DSI_F(double p0, struct S_F p1, int p2) ;
+EXPORT void f4_V_DSI_D(double p0, struct S_D p1, int p2) ;
+EXPORT void f4_V_DSI_P(double p0, struct S_P p1, int p2) ;
+EXPORT void f4_V_DSI_II(double p0, struct S_II p1, int p2) ;
+EXPORT void f4_V_DSI_IF(double p0, struct S_IF p1, int p2) ;
+EXPORT void f4_V_DSI_ID(double p0, struct S_ID p1, int p2) ;
+EXPORT void f4_V_DSI_IP(double p0, struct S_IP p1, int p2) ;
+EXPORT void f4_V_DSI_FI(double p0, struct S_FI p1, int p2) ;
+EXPORT void f4_V_DSI_FF(double p0, struct S_FF p1, int p2) ;
+EXPORT void f4_V_DSI_FD(double p0, struct S_FD p1, int p2) ;
+EXPORT void f4_V_DSI_FP(double p0, struct S_FP p1, int p2) ;
+EXPORT void f4_V_DSI_DI(double p0, struct S_DI p1, int p2) ;
+EXPORT void f4_V_DSI_DF(double p0, struct S_DF p1, int p2) ;
+EXPORT void f4_V_DSI_DD(double p0, struct S_DD p1, int p2) ;
+EXPORT void f4_V_DSI_DP(double p0, struct S_DP p1, int p2) ;
+EXPORT void f4_V_DSI_PI(double p0, struct S_PI p1, int p2) ;
+EXPORT void f4_V_DSI_PF(double p0, struct S_PF p1, int p2) ;
+EXPORT void f4_V_DSI_PD(double p0, struct S_PD p1, int p2) ;
+EXPORT void f4_V_DSI_PP(double p0, struct S_PP p1, int p2) ;
+EXPORT void f4_V_DSI_III(double p0, struct S_III p1, int p2) ;
+EXPORT void f4_V_DSI_IIF(double p0, struct S_IIF p1, int p2) ;
+EXPORT void f4_V_DSI_IID(double p0, struct S_IID p1, int p2) ;
+EXPORT void f4_V_DSI_IIP(double p0, struct S_IIP p1, int p2) ;
+EXPORT void f4_V_DSI_IFI(double p0, struct S_IFI p1, int p2) ;
+EXPORT void f4_V_DSI_IFF(double p0, struct S_IFF p1, int p2) ;
+EXPORT void f4_V_DSI_IFD(double p0, struct S_IFD p1, int p2) ;
+EXPORT void f4_V_DSI_IFP(double p0, struct S_IFP p1, int p2) ;
+EXPORT void f4_V_DSI_IDI(double p0, struct S_IDI p1, int p2) ;
+EXPORT void f4_V_DSI_IDF(double p0, struct S_IDF p1, int p2) ;
+EXPORT void f4_V_DSI_IDD(double p0, struct S_IDD p1, int p2) ;
+EXPORT void f4_V_DSI_IDP(double p0, struct S_IDP p1, int p2) ;
+EXPORT void f4_V_DSI_IPI(double p0, struct S_IPI p1, int p2) ;
+EXPORT void f4_V_DSI_IPF(double p0, struct S_IPF p1, int p2) ;
+EXPORT void f4_V_DSI_IPD(double p0, struct S_IPD p1, int p2) ;
+EXPORT void f4_V_DSI_IPP(double p0, struct S_IPP p1, int p2) ;
+EXPORT void f4_V_DSI_FII(double p0, struct S_FII p1, int p2) ;
+EXPORT void f4_V_DSI_FIF(double p0, struct S_FIF p1, int p2) ;
+EXPORT void f4_V_DSI_FID(double p0, struct S_FID p1, int p2) ;
+EXPORT void f4_V_DSI_FIP(double p0, struct S_FIP p1, int p2) ;
+EXPORT void f4_V_DSI_FFI(double p0, struct S_FFI p1, int p2) ;
+EXPORT void f4_V_DSI_FFF(double p0, struct S_FFF p1, int p2) ;
+EXPORT void f4_V_DSI_FFD(double p0, struct S_FFD p1, int p2) ;
+EXPORT void f4_V_DSI_FFP(double p0, struct S_FFP p1, int p2) ;
+EXPORT void f4_V_DSI_FDI(double p0, struct S_FDI p1, int p2) ;
+EXPORT void f4_V_DSI_FDF(double p0, struct S_FDF p1, int p2) ;
+EXPORT void f4_V_DSI_FDD(double p0, struct S_FDD p1, int p2) ;
+EXPORT void f4_V_DSI_FDP(double p0, struct S_FDP p1, int p2) ;
+EXPORT void f4_V_DSI_FPI(double p0, struct S_FPI p1, int p2) ;
+EXPORT void f4_V_DSI_FPF(double p0, struct S_FPF p1, int p2) ;
+EXPORT void f4_V_DSI_FPD(double p0, struct S_FPD p1, int p2) ;
+EXPORT void f4_V_DSI_FPP(double p0, struct S_FPP p1, int p2) ;
+EXPORT void f4_V_DSI_DII(double p0, struct S_DII p1, int p2) ;
+EXPORT void f4_V_DSI_DIF(double p0, struct S_DIF p1, int p2) ;
+EXPORT void f4_V_DSI_DID(double p0, struct S_DID p1, int p2) ;
+EXPORT void f4_V_DSI_DIP(double p0, struct S_DIP p1, int p2) ;
+EXPORT void f4_V_DSI_DFI(double p0, struct S_DFI p1, int p2) ;
+EXPORT void f4_V_DSI_DFF(double p0, struct S_DFF p1, int p2) ;
+EXPORT void f4_V_DSI_DFD(double p0, struct S_DFD p1, int p2) ;
+EXPORT void f4_V_DSI_DFP(double p0, struct S_DFP p1, int p2) ;
+EXPORT void f4_V_DSI_DDI(double p0, struct S_DDI p1, int p2) ;
+EXPORT void f4_V_DSI_DDF(double p0, struct S_DDF p1, int p2) ;
+EXPORT void f4_V_DSI_DDD(double p0, struct S_DDD p1, int p2) ;
+EXPORT void f4_V_DSI_DDP(double p0, struct S_DDP p1, int p2) ;
+EXPORT void f4_V_DSI_DPI(double p0, struct S_DPI p1, int p2) ;
+EXPORT void f4_V_DSI_DPF(double p0, struct S_DPF p1, int p2) ;
+EXPORT void f4_V_DSI_DPD(double p0, struct S_DPD p1, int p2) ;
+EXPORT void f4_V_DSI_DPP(double p0, struct S_DPP p1, int p2) ;
+EXPORT void f4_V_DSI_PII(double p0, struct S_PII p1, int p2) ;
+EXPORT void f4_V_DSI_PIF(double p0, struct S_PIF p1, int p2) ;
+EXPORT void f4_V_DSI_PID(double p0, struct S_PID p1, int p2) ;
+EXPORT void f4_V_DSI_PIP(double p0, struct S_PIP p1, int p2) ;
+EXPORT void f4_V_DSI_PFI(double p0, struct S_PFI p1, int p2) ;
+EXPORT void f4_V_DSI_PFF(double p0, struct S_PFF p1, int p2) ;
+EXPORT void f4_V_DSI_PFD(double p0, struct S_PFD p1, int p2) ;
+EXPORT void f4_V_DSI_PFP(double p0, struct S_PFP p1, int p2) ;
+EXPORT void f4_V_DSI_PDI(double p0, struct S_PDI p1, int p2) ;
+EXPORT void f4_V_DSI_PDF(double p0, struct S_PDF p1, int p2) ;
+EXPORT void f4_V_DSI_PDD(double p0, struct S_PDD p1, int p2) ;
+EXPORT void f4_V_DSI_PDP(double p0, struct S_PDP p1, int p2) ;
+EXPORT void f4_V_DSI_PPI(double p0, struct S_PPI p1, int p2) ;
+EXPORT void f4_V_DSI_PPF(double p0, struct S_PPF p1, int p2) ;
+EXPORT void f4_V_DSI_PPD(double p0, struct S_PPD p1, int p2) ;
+EXPORT void f4_V_DSI_PPP(double p0, struct S_PPP p1, int p2) ;
+EXPORT void f4_V_DSF_I(double p0, struct S_I p1, float p2) ;
+EXPORT void f4_V_DSF_F(double p0, struct S_F p1, float p2) ;
+EXPORT void f4_V_DSF_D(double p0, struct S_D p1, float p2) ;
+EXPORT void f4_V_DSF_P(double p0, struct S_P p1, float p2) ;
+EXPORT void f4_V_DSF_II(double p0, struct S_II p1, float p2) ;
+EXPORT void f4_V_DSF_IF(double p0, struct S_IF p1, float p2) ;
+EXPORT void f4_V_DSF_ID(double p0, struct S_ID p1, float p2) ;
+EXPORT void f4_V_DSF_IP(double p0, struct S_IP p1, float p2) ;
+EXPORT void f4_V_DSF_FI(double p0, struct S_FI p1, float p2) ;
+EXPORT void f4_V_DSF_FF(double p0, struct S_FF p1, float p2) ;
+EXPORT void f4_V_DSF_FD(double p0, struct S_FD p1, float p2) ;
+EXPORT void f4_V_DSF_FP(double p0, struct S_FP p1, float p2) ;
+EXPORT void f4_V_DSF_DI(double p0, struct S_DI p1, float p2) ;
+EXPORT void f4_V_DSF_DF(double p0, struct S_DF p1, float p2) ;
+EXPORT void f4_V_DSF_DD(double p0, struct S_DD p1, float p2) ;
+EXPORT void f4_V_DSF_DP(double p0, struct S_DP p1, float p2) ;
+EXPORT void f4_V_DSF_PI(double p0, struct S_PI p1, float p2) ;
+EXPORT void f4_V_DSF_PF(double p0, struct S_PF p1, float p2) ;
+EXPORT void f4_V_DSF_PD(double p0, struct S_PD p1, float p2) ;
+EXPORT void f4_V_DSF_PP(double p0, struct S_PP p1, float p2) ;
+EXPORT void f4_V_DSF_III(double p0, struct S_III p1, float p2) ;
+EXPORT void f4_V_DSF_IIF(double p0, struct S_IIF p1, float p2) ;
+EXPORT void f4_V_DSF_IID(double p0, struct S_IID p1, float p2) ;
+EXPORT void f4_V_DSF_IIP(double p0, struct S_IIP p1, float p2) ;
+EXPORT void f4_V_DSF_IFI(double p0, struct S_IFI p1, float p2) ;
+EXPORT void f4_V_DSF_IFF(double p0, struct S_IFF p1, float p2) ;
+EXPORT void f4_V_DSF_IFD(double p0, struct S_IFD p1, float p2) ;
+EXPORT void f4_V_DSF_IFP(double p0, struct S_IFP p1, float p2) ;
+EXPORT void f4_V_DSF_IDI(double p0, struct S_IDI p1, float p2) ;
+EXPORT void f4_V_DSF_IDF(double p0, struct S_IDF p1, float p2) ;
+EXPORT void f4_V_DSF_IDD(double p0, struct S_IDD p1, float p2) ;
+EXPORT void f4_V_DSF_IDP(double p0, struct S_IDP p1, float p2) ;
+EXPORT void f4_V_DSF_IPI(double p0, struct S_IPI p1, float p2) ;
+EXPORT void f4_V_DSF_IPF(double p0, struct S_IPF p1, float p2) ;
+EXPORT void f4_V_DSF_IPD(double p0, struct S_IPD p1, float p2) ;
+EXPORT void f4_V_DSF_IPP(double p0, struct S_IPP p1, float p2) ;
+EXPORT void f4_V_DSF_FII(double p0, struct S_FII p1, float p2) ;
+EXPORT void f4_V_DSF_FIF(double p0, struct S_FIF p1, float p2) ;
+EXPORT void f4_V_DSF_FID(double p0, struct S_FID p1, float p2) ;
+EXPORT void f4_V_DSF_FIP(double p0, struct S_FIP p1, float p2) ;
+EXPORT void f4_V_DSF_FFI(double p0, struct S_FFI p1, float p2) ;
+EXPORT void f4_V_DSF_FFF(double p0, struct S_FFF p1, float p2) ;
+EXPORT void f4_V_DSF_FFD(double p0, struct S_FFD p1, float p2) ;
+EXPORT void f4_V_DSF_FFP(double p0, struct S_FFP p1, float p2) ;
+EXPORT void f4_V_DSF_FDI(double p0, struct S_FDI p1, float p2) ;
+EXPORT void f4_V_DSF_FDF(double p0, struct S_FDF p1, float p2) ;
+EXPORT void f4_V_DSF_FDD(double p0, struct S_FDD p1, float p2) ;
+EXPORT void f4_V_DSF_FDP(double p0, struct S_FDP p1, float p2) ;
+EXPORT void f4_V_DSF_FPI(double p0, struct S_FPI p1, float p2) ;
+EXPORT void f4_V_DSF_FPF(double p0, struct S_FPF p1, float p2) ;
+EXPORT void f4_V_DSF_FPD(double p0, struct S_FPD p1, float p2) ;
+EXPORT void f4_V_DSF_FPP(double p0, struct S_FPP p1, float p2) ;
+EXPORT void f4_V_DSF_DII(double p0, struct S_DII p1, float p2) ;
+EXPORT void f4_V_DSF_DIF(double p0, struct S_DIF p1, float p2) ;
+EXPORT void f4_V_DSF_DID(double p0, struct S_DID p1, float p2) ;
+EXPORT void f4_V_DSF_DIP(double p0, struct S_DIP p1, float p2) ;
+EXPORT void f4_V_DSF_DFI(double p0, struct S_DFI p1, float p2) ;
+EXPORT void f4_V_DSF_DFF(double p0, struct S_DFF p1, float p2) ;
+EXPORT void f4_V_DSF_DFD(double p0, struct S_DFD p1, float p2) ;
+EXPORT void f4_V_DSF_DFP(double p0, struct S_DFP p1, float p2) ;
+EXPORT void f4_V_DSF_DDI(double p0, struct S_DDI p1, float p2) ;
+EXPORT void f4_V_DSF_DDF(double p0, struct S_DDF p1, float p2) ;
+EXPORT void f4_V_DSF_DDD(double p0, struct S_DDD p1, float p2) ;
+EXPORT void f4_V_DSF_DDP(double p0, struct S_DDP p1, float p2) ;
+EXPORT void f4_V_DSF_DPI(double p0, struct S_DPI p1, float p2) ;
+EXPORT void f4_V_DSF_DPF(double p0, struct S_DPF p1, float p2) ;
+EXPORT void f4_V_DSF_DPD(double p0, struct S_DPD p1, float p2) ;
+EXPORT void f4_V_DSF_DPP(double p0, struct S_DPP p1, float p2) ;
+EXPORT void f4_V_DSF_PII(double p0, struct S_PII p1, float p2) ;
+EXPORT void f4_V_DSF_PIF(double p0, struct S_PIF p1, float p2) ;
+EXPORT void f4_V_DSF_PID(double p0, struct S_PID p1, float p2) ;
+EXPORT void f4_V_DSF_PIP(double p0, struct S_PIP p1, float p2) ;
+EXPORT void f4_V_DSF_PFI(double p0, struct S_PFI p1, float p2) ;
+EXPORT void f4_V_DSF_PFF(double p0, struct S_PFF p1, float p2) ;
+EXPORT void f4_V_DSF_PFD(double p0, struct S_PFD p1, float p2) ;
+EXPORT void f4_V_DSF_PFP(double p0, struct S_PFP p1, float p2) ;
+EXPORT void f4_V_DSF_PDI(double p0, struct S_PDI p1, float p2) ;
+EXPORT void f4_V_DSF_PDF(double p0, struct S_PDF p1, float p2) ;
+EXPORT void f4_V_DSF_PDD(double p0, struct S_PDD p1, float p2) ;
+EXPORT void f4_V_DSF_PDP(double p0, struct S_PDP p1, float p2) ;
+EXPORT void f4_V_DSF_PPI(double p0, struct S_PPI p1, float p2) ;
+EXPORT void f4_V_DSF_PPF(double p0, struct S_PPF p1, float p2) ;
+EXPORT void f4_V_DSF_PPD(double p0, struct S_PPD p1, float p2) ;
+EXPORT void f4_V_DSF_PPP(double p0, struct S_PPP p1, float p2) ;
+EXPORT void f4_V_DSD_I(double p0, struct S_I p1, double p2) ;
+EXPORT void f4_V_DSD_F(double p0, struct S_F p1, double p2) ;
+EXPORT void f4_V_DSD_D(double p0, struct S_D p1, double p2) ;
+EXPORT void f4_V_DSD_P(double p0, struct S_P p1, double p2) ;
+EXPORT void f4_V_DSD_II(double p0, struct S_II p1, double p2) ;
+EXPORT void f4_V_DSD_IF(double p0, struct S_IF p1, double p2) ;
+EXPORT void f4_V_DSD_ID(double p0, struct S_ID p1, double p2) ;
+EXPORT void f4_V_DSD_IP(double p0, struct S_IP p1, double p2) ;
+EXPORT void f4_V_DSD_FI(double p0, struct S_FI p1, double p2) ;
+EXPORT void f4_V_DSD_FF(double p0, struct S_FF p1, double p2) ;
+EXPORT void f4_V_DSD_FD(double p0, struct S_FD p1, double p2) ;
+EXPORT void f4_V_DSD_FP(double p0, struct S_FP p1, double p2) ;
+EXPORT void f4_V_DSD_DI(double p0, struct S_DI p1, double p2) ;
+EXPORT void f4_V_DSD_DF(double p0, struct S_DF p1, double p2) ;
+EXPORT void f4_V_DSD_DD(double p0, struct S_DD p1, double p2) ;
+EXPORT void f4_V_DSD_DP(double p0, struct S_DP p1, double p2) ;
+EXPORT void f4_V_DSD_PI(double p0, struct S_PI p1, double p2) ;
+EXPORT void f4_V_DSD_PF(double p0, struct S_PF p1, double p2) ;
+EXPORT void f4_V_DSD_PD(double p0, struct S_PD p1, double p2) ;
+EXPORT void f4_V_DSD_PP(double p0, struct S_PP p1, double p2) ;
+EXPORT void f4_V_DSD_III(double p0, struct S_III p1, double p2) ;
+EXPORT void f4_V_DSD_IIF(double p0, struct S_IIF p1, double p2) ;
+EXPORT void f4_V_DSD_IID(double p0, struct S_IID p1, double p2) ;
+EXPORT void f4_V_DSD_IIP(double p0, struct S_IIP p1, double p2) ;
+EXPORT void f4_V_DSD_IFI(double p0, struct S_IFI p1, double p2) ;
+EXPORT void f4_V_DSD_IFF(double p0, struct S_IFF p1, double p2) ;
+EXPORT void f4_V_DSD_IFD(double p0, struct S_IFD p1, double p2) ;
+EXPORT void f4_V_DSD_IFP(double p0, struct S_IFP p1, double p2) ;
+EXPORT void f4_V_DSD_IDI(double p0, struct S_IDI p1, double p2) ;
+EXPORT void f4_V_DSD_IDF(double p0, struct S_IDF p1, double p2) ;
+EXPORT void f4_V_DSD_IDD(double p0, struct S_IDD p1, double p2) ;
+EXPORT void f4_V_DSD_IDP(double p0, struct S_IDP p1, double p2) ;
+EXPORT void f4_V_DSD_IPI(double p0, struct S_IPI p1, double p2) ;
+EXPORT void f4_V_DSD_IPF(double p0, struct S_IPF p1, double p2) ;
+EXPORT void f4_V_DSD_IPD(double p0, struct S_IPD p1, double p2) ;
+EXPORT void f4_V_DSD_IPP(double p0, struct S_IPP p1, double p2) ;
+EXPORT void f4_V_DSD_FII(double p0, struct S_FII p1, double p2) ;
+EXPORT void f4_V_DSD_FIF(double p0, struct S_FIF p1, double p2) ;
+EXPORT void f4_V_DSD_FID(double p0, struct S_FID p1, double p2) ;
+EXPORT void f4_V_DSD_FIP(double p0, struct S_FIP p1, double p2) ;
+EXPORT void f4_V_DSD_FFI(double p0, struct S_FFI p1, double p2) ;
+EXPORT void f4_V_DSD_FFF(double p0, struct S_FFF p1, double p2) ;
+EXPORT void f4_V_DSD_FFD(double p0, struct S_FFD p1, double p2) ;
+EXPORT void f4_V_DSD_FFP(double p0, struct S_FFP p1, double p2) ;
+EXPORT void f4_V_DSD_FDI(double p0, struct S_FDI p1, double p2) ;
+EXPORT void f4_V_DSD_FDF(double p0, struct S_FDF p1, double p2) ;
+EXPORT void f4_V_DSD_FDD(double p0, struct S_FDD p1, double p2) ;
+EXPORT void f4_V_DSD_FDP(double p0, struct S_FDP p1, double p2) ;
+EXPORT void f4_V_DSD_FPI(double p0, struct S_FPI p1, double p2) ;
+EXPORT void f4_V_DSD_FPF(double p0, struct S_FPF p1, double p2) ;
+EXPORT void f4_V_DSD_FPD(double p0, struct S_FPD p1, double p2) ;
+EXPORT void f4_V_DSD_FPP(double p0, struct S_FPP p1, double p2) ;
+EXPORT void f4_V_DSD_DII(double p0, struct S_DII p1, double p2) ;
+EXPORT void f4_V_DSD_DIF(double p0, struct S_DIF p1, double p2) ;
+EXPORT void f4_V_DSD_DID(double p0, struct S_DID p1, double p2) ;
+EXPORT void f4_V_DSD_DIP(double p0, struct S_DIP p1, double p2) ;
+EXPORT void f4_V_DSD_DFI(double p0, struct S_DFI p1, double p2) ;
+EXPORT void f4_V_DSD_DFF(double p0, struct S_DFF p1, double p2) ;
+EXPORT void f4_V_DSD_DFD(double p0, struct S_DFD p1, double p2) ;
+EXPORT void f4_V_DSD_DFP(double p0, struct S_DFP p1, double p2) ;
+EXPORT void f4_V_DSD_DDI(double p0, struct S_DDI p1, double p2) ;
+EXPORT void f4_V_DSD_DDF(double p0, struct S_DDF p1, double p2) ;
+EXPORT void f4_V_DSD_DDD(double p0, struct S_DDD p1, double p2) ;
+EXPORT void f4_V_DSD_DDP(double p0, struct S_DDP p1, double p2) ;
+EXPORT void f4_V_DSD_DPI(double p0, struct S_DPI p1, double p2) ;
+EXPORT void f4_V_DSD_DPF(double p0, struct S_DPF p1, double p2) ;
+EXPORT void f4_V_DSD_DPD(double p0, struct S_DPD p1, double p2) ;
+EXPORT void f4_V_DSD_DPP(double p0, struct S_DPP p1, double p2) ;
+EXPORT void f4_V_DSD_PII(double p0, struct S_PII p1, double p2) ;
+EXPORT void f4_V_DSD_PIF(double p0, struct S_PIF p1, double p2) ;
+EXPORT void f4_V_DSD_PID(double p0, struct S_PID p1, double p2) ;
+EXPORT void f4_V_DSD_PIP(double p0, struct S_PIP p1, double p2) ;
+EXPORT void f4_V_DSD_PFI(double p0, struct S_PFI p1, double p2) ;
+EXPORT void f4_V_DSD_PFF(double p0, struct S_PFF p1, double p2) ;
+EXPORT void f4_V_DSD_PFD(double p0, struct S_PFD p1, double p2) ;
+EXPORT void f5_V_DSD_PFP(double p0, struct S_PFP p1, double p2) ;
+EXPORT void f5_V_DSD_PDI(double p0, struct S_PDI p1, double p2) ;
+EXPORT void f5_V_DSD_PDF(double p0, struct S_PDF p1, double p2) ;
+EXPORT void f5_V_DSD_PDD(double p0, struct S_PDD p1, double p2) ;
+EXPORT void f5_V_DSD_PDP(double p0, struct S_PDP p1, double p2) ;
+EXPORT void f5_V_DSD_PPI(double p0, struct S_PPI p1, double p2) ;
+EXPORT void f5_V_DSD_PPF(double p0, struct S_PPF p1, double p2) ;
+EXPORT void f5_V_DSD_PPD(double p0, struct S_PPD p1, double p2) ;
+EXPORT void f5_V_DSD_PPP(double p0, struct S_PPP p1, double p2) ;
+EXPORT void f5_V_DSP_I(double p0, struct S_I p1, void* p2) ;
+EXPORT void f5_V_DSP_F(double p0, struct S_F p1, void* p2) ;
+EXPORT void f5_V_DSP_D(double p0, struct S_D p1, void* p2) ;
+EXPORT void f5_V_DSP_P(double p0, struct S_P p1, void* p2) ;
+EXPORT void f5_V_DSP_II(double p0, struct S_II p1, void* p2) ;
+EXPORT void f5_V_DSP_IF(double p0, struct S_IF p1, void* p2) ;
+EXPORT void f5_V_DSP_ID(double p0, struct S_ID p1, void* p2) ;
+EXPORT void f5_V_DSP_IP(double p0, struct S_IP p1, void* p2) ;
+EXPORT void f5_V_DSP_FI(double p0, struct S_FI p1, void* p2) ;
+EXPORT void f5_V_DSP_FF(double p0, struct S_FF p1, void* p2) ;
+EXPORT void f5_V_DSP_FD(double p0, struct S_FD p1, void* p2) ;
+EXPORT void f5_V_DSP_FP(double p0, struct S_FP p1, void* p2) ;
+EXPORT void f5_V_DSP_DI(double p0, struct S_DI p1, void* p2) ;
+EXPORT void f5_V_DSP_DF(double p0, struct S_DF p1, void* p2) ;
+EXPORT void f5_V_DSP_DD(double p0, struct S_DD p1, void* p2) ;
+EXPORT void f5_V_DSP_DP(double p0, struct S_DP p1, void* p2) ;
+EXPORT void f5_V_DSP_PI(double p0, struct S_PI p1, void* p2) ;
+EXPORT void f5_V_DSP_PF(double p0, struct S_PF p1, void* p2) ;
+EXPORT void f5_V_DSP_PD(double p0, struct S_PD p1, void* p2) ;
+EXPORT void f5_V_DSP_PP(double p0, struct S_PP p1, void* p2) ;
+EXPORT void f5_V_DSP_III(double p0, struct S_III p1, void* p2) ;
+EXPORT void f5_V_DSP_IIF(double p0, struct S_IIF p1, void* p2) ;
+EXPORT void f5_V_DSP_IID(double p0, struct S_IID p1, void* p2) ;
+EXPORT void f5_V_DSP_IIP(double p0, struct S_IIP p1, void* p2) ;
+EXPORT void f5_V_DSP_IFI(double p0, struct S_IFI p1, void* p2) ;
+EXPORT void f5_V_DSP_IFF(double p0, struct S_IFF p1, void* p2) ;
+EXPORT void f5_V_DSP_IFD(double p0, struct S_IFD p1, void* p2) ;
+EXPORT void f5_V_DSP_IFP(double p0, struct S_IFP p1, void* p2) ;
+EXPORT void f5_V_DSP_IDI(double p0, struct S_IDI p1, void* p2) ;
+EXPORT void f5_V_DSP_IDF(double p0, struct S_IDF p1, void* p2) ;
+EXPORT void f5_V_DSP_IDD(double p0, struct S_IDD p1, void* p2) ;
+EXPORT void f5_V_DSP_IDP(double p0, struct S_IDP p1, void* p2) ;
+EXPORT void f5_V_DSP_IPI(double p0, struct S_IPI p1, void* p2) ;
+EXPORT void f5_V_DSP_IPF(double p0, struct S_IPF p1, void* p2) ;
+EXPORT void f5_V_DSP_IPD(double p0, struct S_IPD p1, void* p2) ;
+EXPORT void f5_V_DSP_IPP(double p0, struct S_IPP p1, void* p2) ;
+EXPORT void f5_V_DSP_FII(double p0, struct S_FII p1, void* p2) ;
+EXPORT void f5_V_DSP_FIF(double p0, struct S_FIF p1, void* p2) ;
+EXPORT void f5_V_DSP_FID(double p0, struct S_FID p1, void* p2) ;
+EXPORT void f5_V_DSP_FIP(double p0, struct S_FIP p1, void* p2) ;
+EXPORT void f5_V_DSP_FFI(double p0, struct S_FFI p1, void* p2) ;
+EXPORT void f5_V_DSP_FFF(double p0, struct S_FFF p1, void* p2) ;
+EXPORT void f5_V_DSP_FFD(double p0, struct S_FFD p1, void* p2) ;
+EXPORT void f5_V_DSP_FFP(double p0, struct S_FFP p1, void* p2) ;
+EXPORT void f5_V_DSP_FDI(double p0, struct S_FDI p1, void* p2) ;
+EXPORT void f5_V_DSP_FDF(double p0, struct S_FDF p1, void* p2) ;
+EXPORT void f5_V_DSP_FDD(double p0, struct S_FDD p1, void* p2) ;
+EXPORT void f5_V_DSP_FDP(double p0, struct S_FDP p1, void* p2) ;
+EXPORT void f5_V_DSP_FPI(double p0, struct S_FPI p1, void* p2) ;
+EXPORT void f5_V_DSP_FPF(double p0, struct S_FPF p1, void* p2) ;
+EXPORT void f5_V_DSP_FPD(double p0, struct S_FPD p1, void* p2) ;
+EXPORT void f5_V_DSP_FPP(double p0, struct S_FPP p1, void* p2) ;
+EXPORT void f5_V_DSP_DII(double p0, struct S_DII p1, void* p2) ;
+EXPORT void f5_V_DSP_DIF(double p0, struct S_DIF p1, void* p2) ;
+EXPORT void f5_V_DSP_DID(double p0, struct S_DID p1, void* p2) ;
+EXPORT void f5_V_DSP_DIP(double p0, struct S_DIP p1, void* p2) ;
+EXPORT void f5_V_DSP_DFI(double p0, struct S_DFI p1, void* p2) ;
+EXPORT void f5_V_DSP_DFF(double p0, struct S_DFF p1, void* p2) ;
+EXPORT void f5_V_DSP_DFD(double p0, struct S_DFD p1, void* p2) ;
+EXPORT void f5_V_DSP_DFP(double p0, struct S_DFP p1, void* p2) ;
+EXPORT void f5_V_DSP_DDI(double p0, struct S_DDI p1, void* p2) ;
+EXPORT void f5_V_DSP_DDF(double p0, struct S_DDF p1, void* p2) ;
+EXPORT void f5_V_DSP_DDD(double p0, struct S_DDD p1, void* p2) ;
+EXPORT void f5_V_DSP_DDP(double p0, struct S_DDP p1, void* p2) ;
+EXPORT void f5_V_DSP_DPI(double p0, struct S_DPI p1, void* p2) ;
+EXPORT void f5_V_DSP_DPF(double p0, struct S_DPF p1, void* p2) ;
+EXPORT void f5_V_DSP_DPD(double p0, struct S_DPD p1, void* p2) ;
+EXPORT void f5_V_DSP_DPP(double p0, struct S_DPP p1, void* p2) ;
+EXPORT void f5_V_DSP_PII(double p0, struct S_PII p1, void* p2) ;
+EXPORT void f5_V_DSP_PIF(double p0, struct S_PIF p1, void* p2) ;
+EXPORT void f5_V_DSP_PID(double p0, struct S_PID p1, void* p2) ;
+EXPORT void f5_V_DSP_PIP(double p0, struct S_PIP p1, void* p2) ;
+EXPORT void f5_V_DSP_PFI(double p0, struct S_PFI p1, void* p2) ;
+EXPORT void f5_V_DSP_PFF(double p0, struct S_PFF p1, void* p2) ;
+EXPORT void f5_V_DSP_PFD(double p0, struct S_PFD p1, void* p2) ;
+EXPORT void f5_V_DSP_PFP(double p0, struct S_PFP p1, void* p2) ;
+EXPORT void f5_V_DSP_PDI(double p0, struct S_PDI p1, void* p2) ;
+EXPORT void f5_V_DSP_PDF(double p0, struct S_PDF p1, void* p2) ;
+EXPORT void f5_V_DSP_PDD(double p0, struct S_PDD p1, void* p2) ;
+EXPORT void f5_V_DSP_PDP(double p0, struct S_PDP p1, void* p2) ;
+EXPORT void f5_V_DSP_PPI(double p0, struct S_PPI p1, void* p2) ;
+EXPORT void f5_V_DSP_PPF(double p0, struct S_PPF p1, void* p2) ;
+EXPORT void f5_V_DSP_PPD(double p0, struct S_PPD p1, void* p2) ;
+EXPORT void f5_V_DSP_PPP(double p0, struct S_PPP p1, void* p2) ;
+EXPORT void f5_V_DSS_I(double p0, struct S_I p1, struct S_I p2) ;
+EXPORT void f5_V_DSS_F(double p0, struct S_F p1, struct S_F p2) ;
+EXPORT void f5_V_DSS_D(double p0, struct S_D p1, struct S_D p2) ;
+EXPORT void f5_V_DSS_P(double p0, struct S_P p1, struct S_P p2) ;
+EXPORT void f5_V_DSS_II(double p0, struct S_II p1, struct S_II p2) ;
+EXPORT void f5_V_DSS_IF(double p0, struct S_IF p1, struct S_IF p2) ;
+EXPORT void f5_V_DSS_ID(double p0, struct S_ID p1, struct S_ID p2) ;
+EXPORT void f5_V_DSS_IP(double p0, struct S_IP p1, struct S_IP p2) ;
+EXPORT void f5_V_DSS_FI(double p0, struct S_FI p1, struct S_FI p2) ;
+EXPORT void f5_V_DSS_FF(double p0, struct S_FF p1, struct S_FF p2) ;
+EXPORT void f5_V_DSS_FD(double p0, struct S_FD p1, struct S_FD p2) ;
+EXPORT void f5_V_DSS_FP(double p0, struct S_FP p1, struct S_FP p2) ;
+EXPORT void f5_V_DSS_DI(double p0, struct S_DI p1, struct S_DI p2) ;
+EXPORT void f5_V_DSS_DF(double p0, struct S_DF p1, struct S_DF p2) ;
+EXPORT void f5_V_DSS_DD(double p0, struct S_DD p1, struct S_DD p2) ;
+EXPORT void f5_V_DSS_DP(double p0, struct S_DP p1, struct S_DP p2) ;
+EXPORT void f5_V_DSS_PI(double p0, struct S_PI p1, struct S_PI p2) ;
+EXPORT void f5_V_DSS_PF(double p0, struct S_PF p1, struct S_PF p2) ;
+EXPORT void f5_V_DSS_PD(double p0, struct S_PD p1, struct S_PD p2) ;
+EXPORT void f5_V_DSS_PP(double p0, struct S_PP p1, struct S_PP p2) ;
+EXPORT void f5_V_DSS_III(double p0, struct S_III p1, struct S_III p2) ;
+EXPORT void f5_V_DSS_IIF(double p0, struct S_IIF p1, struct S_IIF p2) ;
+EXPORT void f5_V_DSS_IID(double p0, struct S_IID p1, struct S_IID p2) ;
+EXPORT void f5_V_DSS_IIP(double p0, struct S_IIP p1, struct S_IIP p2) ;
+EXPORT void f5_V_DSS_IFI(double p0, struct S_IFI p1, struct S_IFI p2) ;
+EXPORT void f5_V_DSS_IFF(double p0, struct S_IFF p1, struct S_IFF p2) ;
+EXPORT void f5_V_DSS_IFD(double p0, struct S_IFD p1, struct S_IFD p2) ;
+EXPORT void f5_V_DSS_IFP(double p0, struct S_IFP p1, struct S_IFP p2) ;
+EXPORT void f5_V_DSS_IDI(double p0, struct S_IDI p1, struct S_IDI p2) ;
+EXPORT void f5_V_DSS_IDF(double p0, struct S_IDF p1, struct S_IDF p2) ;
+EXPORT void f5_V_DSS_IDD(double p0, struct S_IDD p1, struct S_IDD p2) ;
+EXPORT void f5_V_DSS_IDP(double p0, struct S_IDP p1, struct S_IDP p2) ;
+EXPORT void f5_V_DSS_IPI(double p0, struct S_IPI p1, struct S_IPI p2) ;
+EXPORT void f5_V_DSS_IPF(double p0, struct S_IPF p1, struct S_IPF p2) ;
+EXPORT void f5_V_DSS_IPD(double p0, struct S_IPD p1, struct S_IPD p2) ;
+EXPORT void f5_V_DSS_IPP(double p0, struct S_IPP p1, struct S_IPP p2) ;
+EXPORT void f5_V_DSS_FII(double p0, struct S_FII p1, struct S_FII p2) ;
+EXPORT void f5_V_DSS_FIF(double p0, struct S_FIF p1, struct S_FIF p2) ;
+EXPORT void f5_V_DSS_FID(double p0, struct S_FID p1, struct S_FID p2) ;
+EXPORT void f5_V_DSS_FIP(double p0, struct S_FIP p1, struct S_FIP p2) ;
+EXPORT void f5_V_DSS_FFI(double p0, struct S_FFI p1, struct S_FFI p2) ;
+EXPORT void f5_V_DSS_FFF(double p0, struct S_FFF p1, struct S_FFF p2) ;
+EXPORT void f5_V_DSS_FFD(double p0, struct S_FFD p1, struct S_FFD p2) ;
+EXPORT void f5_V_DSS_FFP(double p0, struct S_FFP p1, struct S_FFP p2) ;
+EXPORT void f5_V_DSS_FDI(double p0, struct S_FDI p1, struct S_FDI p2) ;
+EXPORT void f5_V_DSS_FDF(double p0, struct S_FDF p1, struct S_FDF p2) ;
+EXPORT void f5_V_DSS_FDD(double p0, struct S_FDD p1, struct S_FDD p2) ;
+EXPORT void f5_V_DSS_FDP(double p0, struct S_FDP p1, struct S_FDP p2) ;
+EXPORT void f5_V_DSS_FPI(double p0, struct S_FPI p1, struct S_FPI p2) ;
+EXPORT void f5_V_DSS_FPF(double p0, struct S_FPF p1, struct S_FPF p2) ;
+EXPORT void f5_V_DSS_FPD(double p0, struct S_FPD p1, struct S_FPD p2) ;
+EXPORT void f5_V_DSS_FPP(double p0, struct S_FPP p1, struct S_FPP p2) ;
+EXPORT void f5_V_DSS_DII(double p0, struct S_DII p1, struct S_DII p2) ;
+EXPORT void f5_V_DSS_DIF(double p0, struct S_DIF p1, struct S_DIF p2) ;
+EXPORT void f5_V_DSS_DID(double p0, struct S_DID p1, struct S_DID p2) ;
+EXPORT void f5_V_DSS_DIP(double p0, struct S_DIP p1, struct S_DIP p2) ;
+EXPORT void f5_V_DSS_DFI(double p0, struct S_DFI p1, struct S_DFI p2) ;
+EXPORT void f5_V_DSS_DFF(double p0, struct S_DFF p1, struct S_DFF p2) ;
+EXPORT void f5_V_DSS_DFD(double p0, struct S_DFD p1, struct S_DFD p2) ;
+EXPORT void f5_V_DSS_DFP(double p0, struct S_DFP p1, struct S_DFP p2) ;
+EXPORT void f5_V_DSS_DDI(double p0, struct S_DDI p1, struct S_DDI p2) ;
+EXPORT void f5_V_DSS_DDF(double p0, struct S_DDF p1, struct S_DDF p2) ;
+EXPORT void f5_V_DSS_DDD(double p0, struct S_DDD p1, struct S_DDD p2) ;
+EXPORT void f5_V_DSS_DDP(double p0, struct S_DDP p1, struct S_DDP p2) ;
+EXPORT void f5_V_DSS_DPI(double p0, struct S_DPI p1, struct S_DPI p2) ;
+EXPORT void f5_V_DSS_DPF(double p0, struct S_DPF p1, struct S_DPF p2) ;
+EXPORT void f5_V_DSS_DPD(double p0, struct S_DPD p1, struct S_DPD p2) ;
+EXPORT void f5_V_DSS_DPP(double p0, struct S_DPP p1, struct S_DPP p2) ;
+EXPORT void f5_V_DSS_PII(double p0, struct S_PII p1, struct S_PII p2) ;
+EXPORT void f5_V_DSS_PIF(double p0, struct S_PIF p1, struct S_PIF p2) ;
+EXPORT void f5_V_DSS_PID(double p0, struct S_PID p1, struct S_PID p2) ;
+EXPORT void f5_V_DSS_PIP(double p0, struct S_PIP p1, struct S_PIP p2) ;
+EXPORT void f5_V_DSS_PFI(double p0, struct S_PFI p1, struct S_PFI p2) ;
+EXPORT void f5_V_DSS_PFF(double p0, struct S_PFF p1, struct S_PFF p2) ;
+EXPORT void f5_V_DSS_PFD(double p0, struct S_PFD p1, struct S_PFD p2) ;
+EXPORT void f5_V_DSS_PFP(double p0, struct S_PFP p1, struct S_PFP p2) ;
+EXPORT void f5_V_DSS_PDI(double p0, struct S_PDI p1, struct S_PDI p2) ;
+EXPORT void f5_V_DSS_PDF(double p0, struct S_PDF p1, struct S_PDF p2) ;
+EXPORT void f5_V_DSS_PDD(double p0, struct S_PDD p1, struct S_PDD p2) ;
+EXPORT void f5_V_DSS_PDP(double p0, struct S_PDP p1, struct S_PDP p2) ;
+EXPORT void f5_V_DSS_PPI(double p0, struct S_PPI p1, struct S_PPI p2) ;
+EXPORT void f5_V_DSS_PPF(double p0, struct S_PPF p1, struct S_PPF p2) ;
+EXPORT void f5_V_DSS_PPD(double p0, struct S_PPD p1, struct S_PPD p2) ;
+EXPORT void f5_V_DSS_PPP(double p0, struct S_PPP p1, struct S_PPP p2) ;
+EXPORT void f5_V_PII_(void* p0, int p1, int p2) ;
+EXPORT void f5_V_PIF_(void* p0, int p1, float p2) ;
+EXPORT void f5_V_PID_(void* p0, int p1, double p2) ;
+EXPORT void f5_V_PIP_(void* p0, int p1, void* p2) ;
+EXPORT void f5_V_PIS_I(void* p0, int p1, struct S_I p2) ;
+EXPORT void f5_V_PIS_F(void* p0, int p1, struct S_F p2) ;
+EXPORT void f5_V_PIS_D(void* p0, int p1, struct S_D p2) ;
+EXPORT void f5_V_PIS_P(void* p0, int p1, struct S_P p2) ;
+EXPORT void f5_V_PIS_II(void* p0, int p1, struct S_II p2) ;
+EXPORT void f5_V_PIS_IF(void* p0, int p1, struct S_IF p2) ;
+EXPORT void f5_V_PIS_ID(void* p0, int p1, struct S_ID p2) ;
+EXPORT void f5_V_PIS_IP(void* p0, int p1, struct S_IP p2) ;
+EXPORT void f5_V_PIS_FI(void* p0, int p1, struct S_FI p2) ;
+EXPORT void f5_V_PIS_FF(void* p0, int p1, struct S_FF p2) ;
+EXPORT void f5_V_PIS_FD(void* p0, int p1, struct S_FD p2) ;
+EXPORT void f5_V_PIS_FP(void* p0, int p1, struct S_FP p2) ;
+EXPORT void f5_V_PIS_DI(void* p0, int p1, struct S_DI p2) ;
+EXPORT void f5_V_PIS_DF(void* p0, int p1, struct S_DF p2) ;
+EXPORT void f5_V_PIS_DD(void* p0, int p1, struct S_DD p2) ;
+EXPORT void f5_V_PIS_DP(void* p0, int p1, struct S_DP p2) ;
+EXPORT void f5_V_PIS_PI(void* p0, int p1, struct S_PI p2) ;
+EXPORT void f5_V_PIS_PF(void* p0, int p1, struct S_PF p2) ;
+EXPORT void f5_V_PIS_PD(void* p0, int p1, struct S_PD p2) ;
+EXPORT void f5_V_PIS_PP(void* p0, int p1, struct S_PP p2) ;
+EXPORT void f5_V_PIS_III(void* p0, int p1, struct S_III p2) ;
+EXPORT void f5_V_PIS_IIF(void* p0, int p1, struct S_IIF p2) ;
+EXPORT void f5_V_PIS_IID(void* p0, int p1, struct S_IID p2) ;
+EXPORT void f5_V_PIS_IIP(void* p0, int p1, struct S_IIP p2) ;
+EXPORT void f5_V_PIS_IFI(void* p0, int p1, struct S_IFI p2) ;
+EXPORT void f5_V_PIS_IFF(void* p0, int p1, struct S_IFF p2) ;
+EXPORT void f5_V_PIS_IFD(void* p0, int p1, struct S_IFD p2) ;
+EXPORT void f5_V_PIS_IFP(void* p0, int p1, struct S_IFP p2) ;
+EXPORT void f5_V_PIS_IDI(void* p0, int p1, struct S_IDI p2) ;
+EXPORT void f5_V_PIS_IDF(void* p0, int p1, struct S_IDF p2) ;
+EXPORT void f5_V_PIS_IDD(void* p0, int p1, struct S_IDD p2) ;
+EXPORT void f5_V_PIS_IDP(void* p0, int p1, struct S_IDP p2) ;
+EXPORT void f5_V_PIS_IPI(void* p0, int p1, struct S_IPI p2) ;
+EXPORT void f5_V_PIS_IPF(void* p0, int p1, struct S_IPF p2) ;
+EXPORT void f5_V_PIS_IPD(void* p0, int p1, struct S_IPD p2) ;
+EXPORT void f5_V_PIS_IPP(void* p0, int p1, struct S_IPP p2) ;
+EXPORT void f5_V_PIS_FII(void* p0, int p1, struct S_FII p2) ;
+EXPORT void f5_V_PIS_FIF(void* p0, int p1, struct S_FIF p2) ;
+EXPORT void f5_V_PIS_FID(void* p0, int p1, struct S_FID p2) ;
+EXPORT void f5_V_PIS_FIP(void* p0, int p1, struct S_FIP p2) ;
+EXPORT void f5_V_PIS_FFI(void* p0, int p1, struct S_FFI p2) ;
+EXPORT void f5_V_PIS_FFF(void* p0, int p1, struct S_FFF p2) ;
+EXPORT void f5_V_PIS_FFD(void* p0, int p1, struct S_FFD p2) ;
+EXPORT void f5_V_PIS_FFP(void* p0, int p1, struct S_FFP p2) ;
+EXPORT void f5_V_PIS_FDI(void* p0, int p1, struct S_FDI p2) ;
+EXPORT void f5_V_PIS_FDF(void* p0, int p1, struct S_FDF p2) ;
+EXPORT void f5_V_PIS_FDD(void* p0, int p1, struct S_FDD p2) ;
+EXPORT void f5_V_PIS_FDP(void* p0, int p1, struct S_FDP p2) ;
+EXPORT void f5_V_PIS_FPI(void* p0, int p1, struct S_FPI p2) ;
+EXPORT void f5_V_PIS_FPF(void* p0, int p1, struct S_FPF p2) ;
+EXPORT void f5_V_PIS_FPD(void* p0, int p1, struct S_FPD p2) ;
+EXPORT void f5_V_PIS_FPP(void* p0, int p1, struct S_FPP p2) ;
+EXPORT void f5_V_PIS_DII(void* p0, int p1, struct S_DII p2) ;
+EXPORT void f5_V_PIS_DIF(void* p0, int p1, struct S_DIF p2) ;
+EXPORT void f5_V_PIS_DID(void* p0, int p1, struct S_DID p2) ;
+EXPORT void f5_V_PIS_DIP(void* p0, int p1, struct S_DIP p2) ;
+EXPORT void f5_V_PIS_DFI(void* p0, int p1, struct S_DFI p2) ;
+EXPORT void f5_V_PIS_DFF(void* p0, int p1, struct S_DFF p2) ;
+EXPORT void f5_V_PIS_DFD(void* p0, int p1, struct S_DFD p2) ;
+EXPORT void f5_V_PIS_DFP(void* p0, int p1, struct S_DFP p2) ;
+EXPORT void f5_V_PIS_DDI(void* p0, int p1, struct S_DDI p2) ;
+EXPORT void f5_V_PIS_DDF(void* p0, int p1, struct S_DDF p2) ;
+EXPORT void f5_V_PIS_DDD(void* p0, int p1, struct S_DDD p2) ;
+EXPORT void f5_V_PIS_DDP(void* p0, int p1, struct S_DDP p2) ;
+EXPORT void f5_V_PIS_DPI(void* p0, int p1, struct S_DPI p2) ;
+EXPORT void f5_V_PIS_DPF(void* p0, int p1, struct S_DPF p2) ;
+EXPORT void f5_V_PIS_DPD(void* p0, int p1, struct S_DPD p2) ;
+EXPORT void f5_V_PIS_DPP(void* p0, int p1, struct S_DPP p2) ;
+EXPORT void f5_V_PIS_PII(void* p0, int p1, struct S_PII p2) ;
+EXPORT void f5_V_PIS_PIF(void* p0, int p1, struct S_PIF p2) ;
+EXPORT void f5_V_PIS_PID(void* p0, int p1, struct S_PID p2) ;
+EXPORT void f5_V_PIS_PIP(void* p0, int p1, struct S_PIP p2) ;
+EXPORT void f5_V_PIS_PFI(void* p0, int p1, struct S_PFI p2) ;
+EXPORT void f5_V_PIS_PFF(void* p0, int p1, struct S_PFF p2) ;
+EXPORT void f5_V_PIS_PFD(void* p0, int p1, struct S_PFD p2) ;
+EXPORT void f5_V_PIS_PFP(void* p0, int p1, struct S_PFP p2) ;
+EXPORT void f5_V_PIS_PDI(void* p0, int p1, struct S_PDI p2) ;
+EXPORT void f5_V_PIS_PDF(void* p0, int p1, struct S_PDF p2) ;
+EXPORT void f5_V_PIS_PDD(void* p0, int p1, struct S_PDD p2) ;
+EXPORT void f5_V_PIS_PDP(void* p0, int p1, struct S_PDP p2) ;
+EXPORT void f5_V_PIS_PPI(void* p0, int p1, struct S_PPI p2) ;
+EXPORT void f5_V_PIS_PPF(void* p0, int p1, struct S_PPF p2) ;
+EXPORT void f5_V_PIS_PPD(void* p0, int p1, struct S_PPD p2) ;
+EXPORT void f5_V_PIS_PPP(void* p0, int p1, struct S_PPP p2) ;
+EXPORT void f5_V_PFI_(void* p0, float p1, int p2) ;
+EXPORT void f5_V_PFF_(void* p0, float p1, float p2) ;
+EXPORT void f5_V_PFD_(void* p0, float p1, double p2) ;
+EXPORT void f5_V_PFP_(void* p0, float p1, void* p2) ;
+EXPORT void f5_V_PFS_I(void* p0, float p1, struct S_I p2) ;
+EXPORT void f5_V_PFS_F(void* p0, float p1, struct S_F p2) ;
+EXPORT void f5_V_PFS_D(void* p0, float p1, struct S_D p2) ;
+EXPORT void f5_V_PFS_P(void* p0, float p1, struct S_P p2) ;
+EXPORT void f5_V_PFS_II(void* p0, float p1, struct S_II p2) ;
+EXPORT void f5_V_PFS_IF(void* p0, float p1, struct S_IF p2) ;
+EXPORT void f5_V_PFS_ID(void* p0, float p1, struct S_ID p2) ;
+EXPORT void f5_V_PFS_IP(void* p0, float p1, struct S_IP p2) ;
+EXPORT void f5_V_PFS_FI(void* p0, float p1, struct S_FI p2) ;
+EXPORT void f5_V_PFS_FF(void* p0, float p1, struct S_FF p2) ;
+EXPORT void f5_V_PFS_FD(void* p0, float p1, struct S_FD p2) ;
+EXPORT void f5_V_PFS_FP(void* p0, float p1, struct S_FP p2) ;
+EXPORT void f5_V_PFS_DI(void* p0, float p1, struct S_DI p2) ;
+EXPORT void f5_V_PFS_DF(void* p0, float p1, struct S_DF p2) ;
+EXPORT void f5_V_PFS_DD(void* p0, float p1, struct S_DD p2) ;
+EXPORT void f5_V_PFS_DP(void* p0, float p1, struct S_DP p2) ;
+EXPORT void f5_V_PFS_PI(void* p0, float p1, struct S_PI p2) ;
+EXPORT void f5_V_PFS_PF(void* p0, float p1, struct S_PF p2) ;
+EXPORT void f5_V_PFS_PD(void* p0, float p1, struct S_PD p2) ;
+EXPORT void f5_V_PFS_PP(void* p0, float p1, struct S_PP p2) ;
+EXPORT void f5_V_PFS_III(void* p0, float p1, struct S_III p2) ;
+EXPORT void f5_V_PFS_IIF(void* p0, float p1, struct S_IIF p2) ;
+EXPORT void f5_V_PFS_IID(void* p0, float p1, struct S_IID p2) ;
+EXPORT void f5_V_PFS_IIP(void* p0, float p1, struct S_IIP p2) ;
+EXPORT void f5_V_PFS_IFI(void* p0, float p1, struct S_IFI p2) ;
+EXPORT void f5_V_PFS_IFF(void* p0, float p1, struct S_IFF p2) ;
+EXPORT void f5_V_PFS_IFD(void* p0, float p1, struct S_IFD p2) ;
+EXPORT void f5_V_PFS_IFP(void* p0, float p1, struct S_IFP p2) ;
+EXPORT void f5_V_PFS_IDI(void* p0, float p1, struct S_IDI p2) ;
+EXPORT void f5_V_PFS_IDF(void* p0, float p1, struct S_IDF p2) ;
+EXPORT void f5_V_PFS_IDD(void* p0, float p1, struct S_IDD p2) ;
+EXPORT void f5_V_PFS_IDP(void* p0, float p1, struct S_IDP p2) ;
+EXPORT void f5_V_PFS_IPI(void* p0, float p1, struct S_IPI p2) ;
+EXPORT void f5_V_PFS_IPF(void* p0, float p1, struct S_IPF p2) ;
+EXPORT void f5_V_PFS_IPD(void* p0, float p1, struct S_IPD p2) ;
+EXPORT void f5_V_PFS_IPP(void* p0, float p1, struct S_IPP p2) ;
+EXPORT void f5_V_PFS_FII(void* p0, float p1, struct S_FII p2) ;
+EXPORT void f5_V_PFS_FIF(void* p0, float p1, struct S_FIF p2) ;
+EXPORT void f5_V_PFS_FID(void* p0, float p1, struct S_FID p2) ;
+EXPORT void f5_V_PFS_FIP(void* p0, float p1, struct S_FIP p2) ;
+EXPORT void f5_V_PFS_FFI(void* p0, float p1, struct S_FFI p2) ;
+EXPORT void f5_V_PFS_FFF(void* p0, float p1, struct S_FFF p2) ;
+EXPORT void f5_V_PFS_FFD(void* p0, float p1, struct S_FFD p2) ;
+EXPORT void f5_V_PFS_FFP(void* p0, float p1, struct S_FFP p2) ;
+EXPORT void f5_V_PFS_FDI(void* p0, float p1, struct S_FDI p2) ;
+EXPORT void f5_V_PFS_FDF(void* p0, float p1, struct S_FDF p2) ;
+EXPORT void f5_V_PFS_FDD(void* p0, float p1, struct S_FDD p2) ;
+EXPORT void f5_V_PFS_FDP(void* p0, float p1, struct S_FDP p2) ;
+EXPORT void f5_V_PFS_FPI(void* p0, float p1, struct S_FPI p2) ;
+EXPORT void f5_V_PFS_FPF(void* p0, float p1, struct S_FPF p2) ;
+EXPORT void f5_V_PFS_FPD(void* p0, float p1, struct S_FPD p2) ;
+EXPORT void f5_V_PFS_FPP(void* p0, float p1, struct S_FPP p2) ;
+EXPORT void f5_V_PFS_DII(void* p0, float p1, struct S_DII p2) ;
+EXPORT void f5_V_PFS_DIF(void* p0, float p1, struct S_DIF p2) ;
+EXPORT void f5_V_PFS_DID(void* p0, float p1, struct S_DID p2) ;
+EXPORT void f5_V_PFS_DIP(void* p0, float p1, struct S_DIP p2) ;
+EXPORT void f5_V_PFS_DFI(void* p0, float p1, struct S_DFI p2) ;
+EXPORT void f5_V_PFS_DFF(void* p0, float p1, struct S_DFF p2) ;
+EXPORT void f5_V_PFS_DFD(void* p0, float p1, struct S_DFD p2) ;
+EXPORT void f5_V_PFS_DFP(void* p0, float p1, struct S_DFP p2) ;
+EXPORT void f5_V_PFS_DDI(void* p0, float p1, struct S_DDI p2) ;
+EXPORT void f5_V_PFS_DDF(void* p0, float p1, struct S_DDF p2) ;
+EXPORT void f5_V_PFS_DDD(void* p0, float p1, struct S_DDD p2) ;
+EXPORT void f5_V_PFS_DDP(void* p0, float p1, struct S_DDP p2) ;
+EXPORT void f5_V_PFS_DPI(void* p0, float p1, struct S_DPI p2) ;
+EXPORT void f5_V_PFS_DPF(void* p0, float p1, struct S_DPF p2) ;
+EXPORT void f5_V_PFS_DPD(void* p0, float p1, struct S_DPD p2) ;
+EXPORT void f5_V_PFS_DPP(void* p0, float p1, struct S_DPP p2) ;
+EXPORT void f5_V_PFS_PII(void* p0, float p1, struct S_PII p2) ;
+EXPORT void f5_V_PFS_PIF(void* p0, float p1, struct S_PIF p2) ;
+EXPORT void f5_V_PFS_PID(void* p0, float p1, struct S_PID p2) ;
+EXPORT void f5_V_PFS_PIP(void* p0, float p1, struct S_PIP p2) ;
+EXPORT void f5_V_PFS_PFI(void* p0, float p1, struct S_PFI p2) ;
+EXPORT void f5_V_PFS_PFF(void* p0, float p1, struct S_PFF p2) ;
+EXPORT void f5_V_PFS_PFD(void* p0, float p1, struct S_PFD p2) ;
+EXPORT void f5_V_PFS_PFP(void* p0, float p1, struct S_PFP p2) ;
+EXPORT void f5_V_PFS_PDI(void* p0, float p1, struct S_PDI p2) ;
+EXPORT void f5_V_PFS_PDF(void* p0, float p1, struct S_PDF p2) ;
+EXPORT void f5_V_PFS_PDD(void* p0, float p1, struct S_PDD p2) ;
+EXPORT void f5_V_PFS_PDP(void* p0, float p1, struct S_PDP p2) ;
+EXPORT void f5_V_PFS_PPI(void* p0, float p1, struct S_PPI p2) ;
+EXPORT void f5_V_PFS_PPF(void* p0, float p1, struct S_PPF p2) ;
+EXPORT void f5_V_PFS_PPD(void* p0, float p1, struct S_PPD p2) ;
+EXPORT void f5_V_PFS_PPP(void* p0, float p1, struct S_PPP p2) ;
+EXPORT void f5_V_PDI_(void* p0, double p1, int p2) ;
+EXPORT void f5_V_PDF_(void* p0, double p1, float p2) ;
+EXPORT void f5_V_PDD_(void* p0, double p1, double p2) ;
+EXPORT void f5_V_PDP_(void* p0, double p1, void* p2) ;
+EXPORT void f5_V_PDS_I(void* p0, double p1, struct S_I p2) ;
+EXPORT void f5_V_PDS_F(void* p0, double p1, struct S_F p2) ;
+EXPORT void f5_V_PDS_D(void* p0, double p1, struct S_D p2) ;
+EXPORT void f5_V_PDS_P(void* p0, double p1, struct S_P p2) ;
+EXPORT void f5_V_PDS_II(void* p0, double p1, struct S_II p2) ;
+EXPORT void f5_V_PDS_IF(void* p0, double p1, struct S_IF p2) ;
+EXPORT void f5_V_PDS_ID(void* p0, double p1, struct S_ID p2) ;
+EXPORT void f5_V_PDS_IP(void* p0, double p1, struct S_IP p2) ;
+EXPORT void f5_V_PDS_FI(void* p0, double p1, struct S_FI p2) ;
+EXPORT void f5_V_PDS_FF(void* p0, double p1, struct S_FF p2) ;
+EXPORT void f5_V_PDS_FD(void* p0, double p1, struct S_FD p2) ;
+EXPORT void f5_V_PDS_FP(void* p0, double p1, struct S_FP p2) ;
+EXPORT void f5_V_PDS_DI(void* p0, double p1, struct S_DI p2) ;
+EXPORT void f5_V_PDS_DF(void* p0, double p1, struct S_DF p2) ;
+EXPORT void f5_V_PDS_DD(void* p0, double p1, struct S_DD p2) ;
+EXPORT void f5_V_PDS_DP(void* p0, double p1, struct S_DP p2) ;
+EXPORT void f5_V_PDS_PI(void* p0, double p1, struct S_PI p2) ;
+EXPORT void f5_V_PDS_PF(void* p0, double p1, struct S_PF p2) ;
+EXPORT void f5_V_PDS_PD(void* p0, double p1, struct S_PD p2) ;
+EXPORT void f5_V_PDS_PP(void* p0, double p1, struct S_PP p2) ;
+EXPORT void f5_V_PDS_III(void* p0, double p1, struct S_III p2) ;
+EXPORT void f5_V_PDS_IIF(void* p0, double p1, struct S_IIF p2) ;
+EXPORT void f5_V_PDS_IID(void* p0, double p1, struct S_IID p2) ;
+EXPORT void f5_V_PDS_IIP(void* p0, double p1, struct S_IIP p2) ;
+EXPORT void f5_V_PDS_IFI(void* p0, double p1, struct S_IFI p2) ;
+EXPORT void f5_V_PDS_IFF(void* p0, double p1, struct S_IFF p2) ;
+EXPORT void f5_V_PDS_IFD(void* p0, double p1, struct S_IFD p2) ;
+EXPORT void f5_V_PDS_IFP(void* p0, double p1, struct S_IFP p2) ;
+EXPORT void f5_V_PDS_IDI(void* p0, double p1, struct S_IDI p2) ;
+EXPORT void f5_V_PDS_IDF(void* p0, double p1, struct S_IDF p2) ;
+EXPORT void f5_V_PDS_IDD(void* p0, double p1, struct S_IDD p2) ;
+EXPORT void f5_V_PDS_IDP(void* p0, double p1, struct S_IDP p2) ;
+EXPORT void f5_V_PDS_IPI(void* p0, double p1, struct S_IPI p2) ;
+EXPORT void f5_V_PDS_IPF(void* p0, double p1, struct S_IPF p2) ;
+EXPORT void f5_V_PDS_IPD(void* p0, double p1, struct S_IPD p2) ;
+EXPORT void f5_V_PDS_IPP(void* p0, double p1, struct S_IPP p2) ;
+EXPORT void f5_V_PDS_FII(void* p0, double p1, struct S_FII p2) ;
+EXPORT void f5_V_PDS_FIF(void* p0, double p1, struct S_FIF p2) ;
+EXPORT void f5_V_PDS_FID(void* p0, double p1, struct S_FID p2) ;
+EXPORT void f5_V_PDS_FIP(void* p0, double p1, struct S_FIP p2) ;
+EXPORT void f5_V_PDS_FFI(void* p0, double p1, struct S_FFI p2) ;
+EXPORT void f5_V_PDS_FFF(void* p0, double p1, struct S_FFF p2) ;
+EXPORT void f5_V_PDS_FFD(void* p0, double p1, struct S_FFD p2) ;
+EXPORT void f5_V_PDS_FFP(void* p0, double p1, struct S_FFP p2) ;
+EXPORT void f5_V_PDS_FDI(void* p0, double p1, struct S_FDI p2) ;
+EXPORT void f5_V_PDS_FDF(void* p0, double p1, struct S_FDF p2) ;
+EXPORT void f5_V_PDS_FDD(void* p0, double p1, struct S_FDD p2) ;
+EXPORT void f5_V_PDS_FDP(void* p0, double p1, struct S_FDP p2) ;
+EXPORT void f5_V_PDS_FPI(void* p0, double p1, struct S_FPI p2) ;
+EXPORT void f5_V_PDS_FPF(void* p0, double p1, struct S_FPF p2) ;
+EXPORT void f5_V_PDS_FPD(void* p0, double p1, struct S_FPD p2) ;
+EXPORT void f5_V_PDS_FPP(void* p0, double p1, struct S_FPP p2) ;
+EXPORT void f5_V_PDS_DII(void* p0, double p1, struct S_DII p2) ;
+EXPORT void f5_V_PDS_DIF(void* p0, double p1, struct S_DIF p2) ;
+EXPORT void f5_V_PDS_DID(void* p0, double p1, struct S_DID p2) ;
+EXPORT void f5_V_PDS_DIP(void* p0, double p1, struct S_DIP p2) ;
+EXPORT void f5_V_PDS_DFI(void* p0, double p1, struct S_DFI p2) ;
+EXPORT void f5_V_PDS_DFF(void* p0, double p1, struct S_DFF p2) ;
+EXPORT void f5_V_PDS_DFD(void* p0, double p1, struct S_DFD p2) ;
+EXPORT void f5_V_PDS_DFP(void* p0, double p1, struct S_DFP p2) ;
+EXPORT void f5_V_PDS_DDI(void* p0, double p1, struct S_DDI p2) ;
+EXPORT void f5_V_PDS_DDF(void* p0, double p1, struct S_DDF p2) ;
+EXPORT void f5_V_PDS_DDD(void* p0, double p1, struct S_DDD p2) ;
+EXPORT void f5_V_PDS_DDP(void* p0, double p1, struct S_DDP p2) ;
+EXPORT void f5_V_PDS_DPI(void* p0, double p1, struct S_DPI p2) ;
+EXPORT void f5_V_PDS_DPF(void* p0, double p1, struct S_DPF p2) ;
+EXPORT void f5_V_PDS_DPD(void* p0, double p1, struct S_DPD p2) ;
+EXPORT void f5_V_PDS_DPP(void* p0, double p1, struct S_DPP p2) ;
+EXPORT void f5_V_PDS_PII(void* p0, double p1, struct S_PII p2) ;
+EXPORT void f5_V_PDS_PIF(void* p0, double p1, struct S_PIF p2) ;
+EXPORT void f5_V_PDS_PID(void* p0, double p1, struct S_PID p2) ;
+EXPORT void f5_V_PDS_PIP(void* p0, double p1, struct S_PIP p2) ;
+EXPORT void f5_V_PDS_PFI(void* p0, double p1, struct S_PFI p2) ;
+EXPORT void f5_V_PDS_PFF(void* p0, double p1, struct S_PFF p2) ;
+EXPORT void f5_V_PDS_PFD(void* p0, double p1, struct S_PFD p2) ;
+EXPORT void f5_V_PDS_PFP(void* p0, double p1, struct S_PFP p2) ;
+EXPORT void f5_V_PDS_PDI(void* p0, double p1, struct S_PDI p2) ;
+EXPORT void f5_V_PDS_PDF(void* p0, double p1, struct S_PDF p2) ;
+EXPORT void f5_V_PDS_PDD(void* p0, double p1, struct S_PDD p2) ;
+EXPORT void f5_V_PDS_PDP(void* p0, double p1, struct S_PDP p2) ;
+EXPORT void f5_V_PDS_PPI(void* p0, double p1, struct S_PPI p2) ;
+EXPORT void f5_V_PDS_PPF(void* p0, double p1, struct S_PPF p2) ;
+EXPORT void f5_V_PDS_PPD(void* p0, double p1, struct S_PPD p2) ;
+EXPORT void f5_V_PDS_PPP(void* p0, double p1, struct S_PPP p2) ;
+EXPORT void f5_V_PPI_(void* p0, void* p1, int p2) ;
+EXPORT void f5_V_PPF_(void* p0, void* p1, float p2) ;
+EXPORT void f5_V_PPD_(void* p0, void* p1, double p2) ;
+EXPORT void f5_V_PPP_(void* p0, void* p1, void* p2) ;
+EXPORT void f5_V_PPS_I(void* p0, void* p1, struct S_I p2) ;
+EXPORT void f5_V_PPS_F(void* p0, void* p1, struct S_F p2) ;
+EXPORT void f5_V_PPS_D(void* p0, void* p1, struct S_D p2) ;
+EXPORT void f5_V_PPS_P(void* p0, void* p1, struct S_P p2) ;
+EXPORT void f5_V_PPS_II(void* p0, void* p1, struct S_II p2) ;
+EXPORT void f5_V_PPS_IF(void* p0, void* p1, struct S_IF p2) ;
+EXPORT void f5_V_PPS_ID(void* p0, void* p1, struct S_ID p2) ;
+EXPORT void f5_V_PPS_IP(void* p0, void* p1, struct S_IP p2) ;
+EXPORT void f5_V_PPS_FI(void* p0, void* p1, struct S_FI p2) ;
+EXPORT void f5_V_PPS_FF(void* p0, void* p1, struct S_FF p2) ;
+EXPORT void f5_V_PPS_FD(void* p0, void* p1, struct S_FD p2) ;
+EXPORT void f5_V_PPS_FP(void* p0, void* p1, struct S_FP p2) ;
+EXPORT void f5_V_PPS_DI(void* p0, void* p1, struct S_DI p2) ;
+EXPORT void f5_V_PPS_DF(void* p0, void* p1, struct S_DF p2) ;
+EXPORT void f5_V_PPS_DD(void* p0, void* p1, struct S_DD p2) ;
+EXPORT void f5_V_PPS_DP(void* p0, void* p1, struct S_DP p2) ;
+EXPORT void f5_V_PPS_PI(void* p0, void* p1, struct S_PI p2) ;
+EXPORT void f5_V_PPS_PF(void* p0, void* p1, struct S_PF p2) ;
+EXPORT void f5_V_PPS_PD(void* p0, void* p1, struct S_PD p2) ;
+EXPORT void f5_V_PPS_PP(void* p0, void* p1, struct S_PP p2) ;
+EXPORT void f5_V_PPS_III(void* p0, void* p1, struct S_III p2) ;
+EXPORT void f5_V_PPS_IIF(void* p0, void* p1, struct S_IIF p2) ;
+EXPORT void f5_V_PPS_IID(void* p0, void* p1, struct S_IID p2) ;
+EXPORT void f5_V_PPS_IIP(void* p0, void* p1, struct S_IIP p2) ;
+EXPORT void f5_V_PPS_IFI(void* p0, void* p1, struct S_IFI p2) ;
+EXPORT void f5_V_PPS_IFF(void* p0, void* p1, struct S_IFF p2) ;
+EXPORT void f5_V_PPS_IFD(void* p0, void* p1, struct S_IFD p2) ;
+EXPORT void f5_V_PPS_IFP(void* p0, void* p1, struct S_IFP p2) ;
+EXPORT void f5_V_PPS_IDI(void* p0, void* p1, struct S_IDI p2) ;
+EXPORT void f5_V_PPS_IDF(void* p0, void* p1, struct S_IDF p2) ;
+EXPORT void f5_V_PPS_IDD(void* p0, void* p1, struct S_IDD p2) ;
+EXPORT void f5_V_PPS_IDP(void* p0, void* p1, struct S_IDP p2) ;
+EXPORT void f5_V_PPS_IPI(void* p0, void* p1, struct S_IPI p2) ;
+EXPORT void f5_V_PPS_IPF(void* p0, void* p1, struct S_IPF p2) ;
+EXPORT void f5_V_PPS_IPD(void* p0, void* p1, struct S_IPD p2) ;
+EXPORT void f5_V_PPS_IPP(void* p0, void* p1, struct S_IPP p2) ;
+EXPORT void f5_V_PPS_FII(void* p0, void* p1, struct S_FII p2) ;
+EXPORT void f5_V_PPS_FIF(void* p0, void* p1, struct S_FIF p2) ;
+EXPORT void f5_V_PPS_FID(void* p0, void* p1, struct S_FID p2) ;
+EXPORT void f5_V_PPS_FIP(void* p0, void* p1, struct S_FIP p2) ;
+EXPORT void f5_V_PPS_FFI(void* p0, void* p1, struct S_FFI p2) ;
+EXPORT void f5_V_PPS_FFF(void* p0, void* p1, struct S_FFF p2) ;
+EXPORT void f5_V_PPS_FFD(void* p0, void* p1, struct S_FFD p2) ;
+EXPORT void f5_V_PPS_FFP(void* p0, void* p1, struct S_FFP p2) ;
+EXPORT void f5_V_PPS_FDI(void* p0, void* p1, struct S_FDI p2) ;
+EXPORT void f5_V_PPS_FDF(void* p0, void* p1, struct S_FDF p2) ;
+EXPORT void f5_V_PPS_FDD(void* p0, void* p1, struct S_FDD p2) ;
+EXPORT void f5_V_PPS_FDP(void* p0, void* p1, struct S_FDP p2) ;
+EXPORT void f5_V_PPS_FPI(void* p0, void* p1, struct S_FPI p2) ;
+EXPORT void f5_V_PPS_FPF(void* p0, void* p1, struct S_FPF p2) ;
+EXPORT void f5_V_PPS_FPD(void* p0, void* p1, struct S_FPD p2) ;
+EXPORT void f5_V_PPS_FPP(void* p0, void* p1, struct S_FPP p2) ;
+EXPORT void f5_V_PPS_DII(void* p0, void* p1, struct S_DII p2) ;
+EXPORT void f5_V_PPS_DIF(void* p0, void* p1, struct S_DIF p2) ;
+EXPORT void f5_V_PPS_DID(void* p0, void* p1, struct S_DID p2) ;
+EXPORT void f5_V_PPS_DIP(void* p0, void* p1, struct S_DIP p2) ;
+EXPORT void f5_V_PPS_DFI(void* p0, void* p1, struct S_DFI p2) ;
+EXPORT void f5_V_PPS_DFF(void* p0, void* p1, struct S_DFF p2) ;
+EXPORT void f5_V_PPS_DFD(void* p0, void* p1, struct S_DFD p2) ;
+EXPORT void f5_V_PPS_DFP(void* p0, void* p1, struct S_DFP p2) ;
+EXPORT void f5_V_PPS_DDI(void* p0, void* p1, struct S_DDI p2) ;
+EXPORT void f5_V_PPS_DDF(void* p0, void* p1, struct S_DDF p2) ;
+EXPORT void f5_V_PPS_DDD(void* p0, void* p1, struct S_DDD p2) ;
+EXPORT void f5_V_PPS_DDP(void* p0, void* p1, struct S_DDP p2) ;
+EXPORT void f5_V_PPS_DPI(void* p0, void* p1, struct S_DPI p2) ;
+EXPORT void f5_V_PPS_DPF(void* p0, void* p1, struct S_DPF p2) ;
+EXPORT void f5_V_PPS_DPD(void* p0, void* p1, struct S_DPD p2) ;
+EXPORT void f5_V_PPS_DPP(void* p0, void* p1, struct S_DPP p2) ;
+EXPORT void f5_V_PPS_PII(void* p0, void* p1, struct S_PII p2) ;
+EXPORT void f5_V_PPS_PIF(void* p0, void* p1, struct S_PIF p2) ;
+EXPORT void f5_V_PPS_PID(void* p0, void* p1, struct S_PID p2) ;
+EXPORT void f5_V_PPS_PIP(void* p0, void* p1, struct S_PIP p2) ;
+EXPORT void f5_V_PPS_PFI(void* p0, void* p1, struct S_PFI p2) ;
+EXPORT void f5_V_PPS_PFF(void* p0, void* p1, struct S_PFF p2) ;
+EXPORT void f5_V_PPS_PFD(void* p0, void* p1, struct S_PFD p2) ;
+EXPORT void f5_V_PPS_PFP(void* p0, void* p1, struct S_PFP p2) ;
+EXPORT void f5_V_PPS_PDI(void* p0, void* p1, struct S_PDI p2) ;
+EXPORT void f5_V_PPS_PDF(void* p0, void* p1, struct S_PDF p2) ;
+EXPORT void f5_V_PPS_PDD(void* p0, void* p1, struct S_PDD p2) ;
+EXPORT void f5_V_PPS_PDP(void* p0, void* p1, struct S_PDP p2) ;
+EXPORT void f5_V_PPS_PPI(void* p0, void* p1, struct S_PPI p2) ;
+EXPORT void f5_V_PPS_PPF(void* p0, void* p1, struct S_PPF p2) ;
+EXPORT void f5_V_PPS_PPD(void* p0, void* p1, struct S_PPD p2) ;
+EXPORT void f5_V_PPS_PPP(void* p0, void* p1, struct S_PPP p2) ;
+EXPORT void f5_V_PSI_I(void* p0, struct S_I p1, int p2) ;
+EXPORT void f5_V_PSI_F(void* p0, struct S_F p1, int p2) ;
+EXPORT void f5_V_PSI_D(void* p0, struct S_D p1, int p2) ;
+EXPORT void f5_V_PSI_P(void* p0, struct S_P p1, int p2) ;
+EXPORT void f5_V_PSI_II(void* p0, struct S_II p1, int p2) ;
+EXPORT void f5_V_PSI_IF(void* p0, struct S_IF p1, int p2) ;
+EXPORT void f5_V_PSI_ID(void* p0, struct S_ID p1, int p2) ;
+EXPORT void f5_V_PSI_IP(void* p0, struct S_IP p1, int p2) ;
+EXPORT void f5_V_PSI_FI(void* p0, struct S_FI p1, int p2) ;
+EXPORT void f5_V_PSI_FF(void* p0, struct S_FF p1, int p2) ;
+EXPORT void f5_V_PSI_FD(void* p0, struct S_FD p1, int p2) ;
+EXPORT void f5_V_PSI_FP(void* p0, struct S_FP p1, int p2) ;
+EXPORT void f5_V_PSI_DI(void* p0, struct S_DI p1, int p2) ;
+EXPORT void f5_V_PSI_DF(void* p0, struct S_DF p1, int p2) ;
+EXPORT void f5_V_PSI_DD(void* p0, struct S_DD p1, int p2) ;
+EXPORT void f5_V_PSI_DP(void* p0, struct S_DP p1, int p2) ;
+EXPORT void f5_V_PSI_PI(void* p0, struct S_PI p1, int p2) ;
+EXPORT void f5_V_PSI_PF(void* p0, struct S_PF p1, int p2) ;
+EXPORT void f5_V_PSI_PD(void* p0, struct S_PD p1, int p2) ;
+EXPORT void f5_V_PSI_PP(void* p0, struct S_PP p1, int p2) ;
+EXPORT void f5_V_PSI_III(void* p0, struct S_III p1, int p2) ;
+EXPORT void f5_V_PSI_IIF(void* p0, struct S_IIF p1, int p2) ;
+EXPORT void f5_V_PSI_IID(void* p0, struct S_IID p1, int p2) ;
+EXPORT void f5_V_PSI_IIP(void* p0, struct S_IIP p1, int p2) ;
+EXPORT void f5_V_PSI_IFI(void* p0, struct S_IFI p1, int p2) ;
+EXPORT void f5_V_PSI_IFF(void* p0, struct S_IFF p1, int p2) ;
+EXPORT void f5_V_PSI_IFD(void* p0, struct S_IFD p1, int p2) ;
+EXPORT void f5_V_PSI_IFP(void* p0, struct S_IFP p1, int p2) ;
+EXPORT void f5_V_PSI_IDI(void* p0, struct S_IDI p1, int p2) ;
+EXPORT void f5_V_PSI_IDF(void* p0, struct S_IDF p1, int p2) ;
+EXPORT void f5_V_PSI_IDD(void* p0, struct S_IDD p1, int p2) ;
+EXPORT void f5_V_PSI_IDP(void* p0, struct S_IDP p1, int p2) ;
+EXPORT void f5_V_PSI_IPI(void* p0, struct S_IPI p1, int p2) ;
+EXPORT void f5_V_PSI_IPF(void* p0, struct S_IPF p1, int p2) ;
+EXPORT void f5_V_PSI_IPD(void* p0, struct S_IPD p1, int p2) ;
+EXPORT void f5_V_PSI_IPP(void* p0, struct S_IPP p1, int p2) ;
+EXPORT void f5_V_PSI_FII(void* p0, struct S_FII p1, int p2) ;
+EXPORT void f5_V_PSI_FIF(void* p0, struct S_FIF p1, int p2) ;
+EXPORT void f5_V_PSI_FID(void* p0, struct S_FID p1, int p2) ;
+EXPORT void f5_V_PSI_FIP(void* p0, struct S_FIP p1, int p2) ;
+EXPORT void f5_V_PSI_FFI(void* p0, struct S_FFI p1, int p2) ;
+EXPORT void f5_V_PSI_FFF(void* p0, struct S_FFF p1, int p2) ;
+EXPORT void f5_V_PSI_FFD(void* p0, struct S_FFD p1, int p2) ;
+EXPORT void f5_V_PSI_FFP(void* p0, struct S_FFP p1, int p2) ;
+EXPORT void f5_V_PSI_FDI(void* p0, struct S_FDI p1, int p2) ;
+EXPORT void f5_V_PSI_FDF(void* p0, struct S_FDF p1, int p2) ;
+EXPORT void f5_V_PSI_FDD(void* p0, struct S_FDD p1, int p2) ;
+EXPORT void f5_V_PSI_FDP(void* p0, struct S_FDP p1, int p2) ;
+EXPORT void f5_V_PSI_FPI(void* p0, struct S_FPI p1, int p2) ;
+EXPORT void f5_V_PSI_FPF(void* p0, struct S_FPF p1, int p2) ;
+EXPORT void f5_V_PSI_FPD(void* p0, struct S_FPD p1, int p2) ;
+EXPORT void f5_V_PSI_FPP(void* p0, struct S_FPP p1, int p2) ;
+EXPORT void f5_V_PSI_DII(void* p0, struct S_DII p1, int p2) ;
+EXPORT void f5_V_PSI_DIF(void* p0, struct S_DIF p1, int p2) ;
+EXPORT void f5_V_PSI_DID(void* p0, struct S_DID p1, int p2) ;
+EXPORT void f5_V_PSI_DIP(void* p0, struct S_DIP p1, int p2) ;
+EXPORT void f5_V_PSI_DFI(void* p0, struct S_DFI p1, int p2) ;
+EXPORT void f5_V_PSI_DFF(void* p0, struct S_DFF p1, int p2) ;
+EXPORT void f5_V_PSI_DFD(void* p0, struct S_DFD p1, int p2) ;
+EXPORT void f5_V_PSI_DFP(void* p0, struct S_DFP p1, int p2) ;
+EXPORT void f5_V_PSI_DDI(void* p0, struct S_DDI p1, int p2) ;
+EXPORT void f5_V_PSI_DDF(void* p0, struct S_DDF p1, int p2) ;
+EXPORT void f5_V_PSI_DDD(void* p0, struct S_DDD p1, int p2) ;
+EXPORT void f5_V_PSI_DDP(void* p0, struct S_DDP p1, int p2) ;
+EXPORT void f5_V_PSI_DPI(void* p0, struct S_DPI p1, int p2) ;
+EXPORT void f5_V_PSI_DPF(void* p0, struct S_DPF p1, int p2) ;
+EXPORT void f5_V_PSI_DPD(void* p0, struct S_DPD p1, int p2) ;
+EXPORT void f5_V_PSI_DPP(void* p0, struct S_DPP p1, int p2) ;
+EXPORT void f5_V_PSI_PII(void* p0, struct S_PII p1, int p2) ;
+EXPORT void f5_V_PSI_PIF(void* p0, struct S_PIF p1, int p2) ;
+EXPORT void f5_V_PSI_PID(void* p0, struct S_PID p1, int p2) ;
+EXPORT void f6_V_PSI_PIP(void* p0, struct S_PIP p1, int p2) ;
+EXPORT void f6_V_PSI_PFI(void* p0, struct S_PFI p1, int p2) ;
+EXPORT void f6_V_PSI_PFF(void* p0, struct S_PFF p1, int p2) ;
+EXPORT void f6_V_PSI_PFD(void* p0, struct S_PFD p1, int p2) ;
+EXPORT void f6_V_PSI_PFP(void* p0, struct S_PFP p1, int p2) ;
+EXPORT void f6_V_PSI_PDI(void* p0, struct S_PDI p1, int p2) ;
+EXPORT void f6_V_PSI_PDF(void* p0, struct S_PDF p1, int p2) ;
+EXPORT void f6_V_PSI_PDD(void* p0, struct S_PDD p1, int p2) ;
+EXPORT void f6_V_PSI_PDP(void* p0, struct S_PDP p1, int p2) ;
+EXPORT void f6_V_PSI_PPI(void* p0, struct S_PPI p1, int p2) ;
+EXPORT void f6_V_PSI_PPF(void* p0, struct S_PPF p1, int p2) ;
+EXPORT void f6_V_PSI_PPD(void* p0, struct S_PPD p1, int p2) ;
+EXPORT void f6_V_PSI_PPP(void* p0, struct S_PPP p1, int p2) ;
+EXPORT void f6_V_PSF_I(void* p0, struct S_I p1, float p2) ;
+EXPORT void f6_V_PSF_F(void* p0, struct S_F p1, float p2) ;
+EXPORT void f6_V_PSF_D(void* p0, struct S_D p1, float p2) ;
+EXPORT void f6_V_PSF_P(void* p0, struct S_P p1, float p2) ;
+EXPORT void f6_V_PSF_II(void* p0, struct S_II p1, float p2) ;
+EXPORT void f6_V_PSF_IF(void* p0, struct S_IF p1, float p2) ;
+EXPORT void f6_V_PSF_ID(void* p0, struct S_ID p1, float p2) ;
+EXPORT void f6_V_PSF_IP(void* p0, struct S_IP p1, float p2) ;
+EXPORT void f6_V_PSF_FI(void* p0, struct S_FI p1, float p2) ;
+EXPORT void f6_V_PSF_FF(void* p0, struct S_FF p1, float p2) ;
+EXPORT void f6_V_PSF_FD(void* p0, struct S_FD p1, float p2) ;
+EXPORT void f6_V_PSF_FP(void* p0, struct S_FP p1, float p2) ;
+EXPORT void f6_V_PSF_DI(void* p0, struct S_DI p1, float p2) ;
+EXPORT void f6_V_PSF_DF(void* p0, struct S_DF p1, float p2) ;
+EXPORT void f6_V_PSF_DD(void* p0, struct S_DD p1, float p2) ;
+EXPORT void f6_V_PSF_DP(void* p0, struct S_DP p1, float p2) ;
+EXPORT void f6_V_PSF_PI(void* p0, struct S_PI p1, float p2) ;
+EXPORT void f6_V_PSF_PF(void* p0, struct S_PF p1, float p2) ;
+EXPORT void f6_V_PSF_PD(void* p0, struct S_PD p1, float p2) ;
+EXPORT void f6_V_PSF_PP(void* p0, struct S_PP p1, float p2) ;
+EXPORT void f6_V_PSF_III(void* p0, struct S_III p1, float p2) ;
+EXPORT void f6_V_PSF_IIF(void* p0, struct S_IIF p1, float p2) ;
+EXPORT void f6_V_PSF_IID(void* p0, struct S_IID p1, float p2) ;
+EXPORT void f6_V_PSF_IIP(void* p0, struct S_IIP p1, float p2) ;
+EXPORT void f6_V_PSF_IFI(void* p0, struct S_IFI p1, float p2) ;
+EXPORT void f6_V_PSF_IFF(void* p0, struct S_IFF p1, float p2) ;
+EXPORT void f6_V_PSF_IFD(void* p0, struct S_IFD p1, float p2) ;
+EXPORT void f6_V_PSF_IFP(void* p0, struct S_IFP p1, float p2) ;
+EXPORT void f6_V_PSF_IDI(void* p0, struct S_IDI p1, float p2) ;
+EXPORT void f6_V_PSF_IDF(void* p0, struct S_IDF p1, float p2) ;
+EXPORT void f6_V_PSF_IDD(void* p0, struct S_IDD p1, float p2) ;
+EXPORT void f6_V_PSF_IDP(void* p0, struct S_IDP p1, float p2) ;
+EXPORT void f6_V_PSF_IPI(void* p0, struct S_IPI p1, float p2) ;
+EXPORT void f6_V_PSF_IPF(void* p0, struct S_IPF p1, float p2) ;
+EXPORT void f6_V_PSF_IPD(void* p0, struct S_IPD p1, float p2) ;
+EXPORT void f6_V_PSF_IPP(void* p0, struct S_IPP p1, float p2) ;
+EXPORT void f6_V_PSF_FII(void* p0, struct S_FII p1, float p2) ;
+EXPORT void f6_V_PSF_FIF(void* p0, struct S_FIF p1, float p2) ;
+EXPORT void f6_V_PSF_FID(void* p0, struct S_FID p1, float p2) ;
+EXPORT void f6_V_PSF_FIP(void* p0, struct S_FIP p1, float p2) ;
+EXPORT void f6_V_PSF_FFI(void* p0, struct S_FFI p1, float p2) ;
+EXPORT void f6_V_PSF_FFF(void* p0, struct S_FFF p1, float p2) ;
+EXPORT void f6_V_PSF_FFD(void* p0, struct S_FFD p1, float p2) ;
+EXPORT void f6_V_PSF_FFP(void* p0, struct S_FFP p1, float p2) ;
+EXPORT void f6_V_PSF_FDI(void* p0, struct S_FDI p1, float p2) ;
+EXPORT void f6_V_PSF_FDF(void* p0, struct S_FDF p1, float p2) ;
+EXPORT void f6_V_PSF_FDD(void* p0, struct S_FDD p1, float p2) ;
+EXPORT void f6_V_PSF_FDP(void* p0, struct S_FDP p1, float p2) ;
+EXPORT void f6_V_PSF_FPI(void* p0, struct S_FPI p1, float p2) ;
+EXPORT void f6_V_PSF_FPF(void* p0, struct S_FPF p1, float p2) ;
+EXPORT void f6_V_PSF_FPD(void* p0, struct S_FPD p1, float p2) ;
+EXPORT void f6_V_PSF_FPP(void* p0, struct S_FPP p1, float p2) ;
+EXPORT void f6_V_PSF_DII(void* p0, struct S_DII p1, float p2) ;
+EXPORT void f6_V_PSF_DIF(void* p0, struct S_DIF p1, float p2) ;
+EXPORT void f6_V_PSF_DID(void* p0, struct S_DID p1, float p2) ;
+EXPORT void f6_V_PSF_DIP(void* p0, struct S_DIP p1, float p2) ;
+EXPORT void f6_V_PSF_DFI(void* p0, struct S_DFI p1, float p2) ;
+EXPORT void f6_V_PSF_DFF(void* p0, struct S_DFF p1, float p2) ;
+EXPORT void f6_V_PSF_DFD(void* p0, struct S_DFD p1, float p2) ;
+EXPORT void f6_V_PSF_DFP(void* p0, struct S_DFP p1, float p2) ;
+EXPORT void f6_V_PSF_DDI(void* p0, struct S_DDI p1, float p2) ;
+EXPORT void f6_V_PSF_DDF(void* p0, struct S_DDF p1, float p2) ;
+EXPORT void f6_V_PSF_DDD(void* p0, struct S_DDD p1, float p2) ;
+EXPORT void f6_V_PSF_DDP(void* p0, struct S_DDP p1, float p2) ;
+EXPORT void f6_V_PSF_DPI(void* p0, struct S_DPI p1, float p2) ;
+EXPORT void f6_V_PSF_DPF(void* p0, struct S_DPF p1, float p2) ;
+EXPORT void f6_V_PSF_DPD(void* p0, struct S_DPD p1, float p2) ;
+EXPORT void f6_V_PSF_DPP(void* p0, struct S_DPP p1, float p2) ;
+EXPORT void f6_V_PSF_PII(void* p0, struct S_PII p1, float p2) ;
+EXPORT void f6_V_PSF_PIF(void* p0, struct S_PIF p1, float p2) ;
+EXPORT void f6_V_PSF_PID(void* p0, struct S_PID p1, float p2) ;
+EXPORT void f6_V_PSF_PIP(void* p0, struct S_PIP p1, float p2) ;
+EXPORT void f6_V_PSF_PFI(void* p0, struct S_PFI p1, float p2) ;
+EXPORT void f6_V_PSF_PFF(void* p0, struct S_PFF p1, float p2) ;
+EXPORT void f6_V_PSF_PFD(void* p0, struct S_PFD p1, float p2) ;
+EXPORT void f6_V_PSF_PFP(void* p0, struct S_PFP p1, float p2) ;
+EXPORT void f6_V_PSF_PDI(void* p0, struct S_PDI p1, float p2) ;
+EXPORT void f6_V_PSF_PDF(void* p0, struct S_PDF p1, float p2) ;
+EXPORT void f6_V_PSF_PDD(void* p0, struct S_PDD p1, float p2) ;
+EXPORT void f6_V_PSF_PDP(void* p0, struct S_PDP p1, float p2) ;
+EXPORT void f6_V_PSF_PPI(void* p0, struct S_PPI p1, float p2) ;
+EXPORT void f6_V_PSF_PPF(void* p0, struct S_PPF p1, float p2) ;
+EXPORT void f6_V_PSF_PPD(void* p0, struct S_PPD p1, float p2) ;
+EXPORT void f6_V_PSF_PPP(void* p0, struct S_PPP p1, float p2) ;
+EXPORT void f6_V_PSD_I(void* p0, struct S_I p1, double p2) ;
+EXPORT void f6_V_PSD_F(void* p0, struct S_F p1, double p2) ;
+EXPORT void f6_V_PSD_D(void* p0, struct S_D p1, double p2) ;
+EXPORT void f6_V_PSD_P(void* p0, struct S_P p1, double p2) ;
+EXPORT void f6_V_PSD_II(void* p0, struct S_II p1, double p2) ;
+EXPORT void f6_V_PSD_IF(void* p0, struct S_IF p1, double p2) ;
+EXPORT void f6_V_PSD_ID(void* p0, struct S_ID p1, double p2) ;
+EXPORT void f6_V_PSD_IP(void* p0, struct S_IP p1, double p2) ;
+EXPORT void f6_V_PSD_FI(void* p0, struct S_FI p1, double p2) ;
+EXPORT void f6_V_PSD_FF(void* p0, struct S_FF p1, double p2) ;
+EXPORT void f6_V_PSD_FD(void* p0, struct S_FD p1, double p2) ;
+EXPORT void f6_V_PSD_FP(void* p0, struct S_FP p1, double p2) ;
+EXPORT void f6_V_PSD_DI(void* p0, struct S_DI p1, double p2) ;
+EXPORT void f6_V_PSD_DF(void* p0, struct S_DF p1, double p2) ;
+EXPORT void f6_V_PSD_DD(void* p0, struct S_DD p1, double p2) ;
+EXPORT void f6_V_PSD_DP(void* p0, struct S_DP p1, double p2) ;
+EXPORT void f6_V_PSD_PI(void* p0, struct S_PI p1, double p2) ;
+EXPORT void f6_V_PSD_PF(void* p0, struct S_PF p1, double p2) ;
+EXPORT void f6_V_PSD_PD(void* p0, struct S_PD p1, double p2) ;
+EXPORT void f6_V_PSD_PP(void* p0, struct S_PP p1, double p2) ;
+EXPORT void f6_V_PSD_III(void* p0, struct S_III p1, double p2) ;
+EXPORT void f6_V_PSD_IIF(void* p0, struct S_IIF p1, double p2) ;
+EXPORT void f6_V_PSD_IID(void* p0, struct S_IID p1, double p2) ;
+EXPORT void f6_V_PSD_IIP(void* p0, struct S_IIP p1, double p2) ;
+EXPORT void f6_V_PSD_IFI(void* p0, struct S_IFI p1, double p2) ;
+EXPORT void f6_V_PSD_IFF(void* p0, struct S_IFF p1, double p2) ;
+EXPORT void f6_V_PSD_IFD(void* p0, struct S_IFD p1, double p2) ;
+EXPORT void f6_V_PSD_IFP(void* p0, struct S_IFP p1, double p2) ;
+EXPORT void f6_V_PSD_IDI(void* p0, struct S_IDI p1, double p2) ;
+EXPORT void f6_V_PSD_IDF(void* p0, struct S_IDF p1, double p2) ;
+EXPORT void f6_V_PSD_IDD(void* p0, struct S_IDD p1, double p2) ;
+EXPORT void f6_V_PSD_IDP(void* p0, struct S_IDP p1, double p2) ;
+EXPORT void f6_V_PSD_IPI(void* p0, struct S_IPI p1, double p2) ;
+EXPORT void f6_V_PSD_IPF(void* p0, struct S_IPF p1, double p2) ;
+EXPORT void f6_V_PSD_IPD(void* p0, struct S_IPD p1, double p2) ;
+EXPORT void f6_V_PSD_IPP(void* p0, struct S_IPP p1, double p2) ;
+EXPORT void f6_V_PSD_FII(void* p0, struct S_FII p1, double p2) ;
+EXPORT void f6_V_PSD_FIF(void* p0, struct S_FIF p1, double p2) ;
+EXPORT void f6_V_PSD_FID(void* p0, struct S_FID p1, double p2) ;
+EXPORT void f6_V_PSD_FIP(void* p0, struct S_FIP p1, double p2) ;
+EXPORT void f6_V_PSD_FFI(void* p0, struct S_FFI p1, double p2) ;
+EXPORT void f6_V_PSD_FFF(void* p0, struct S_FFF p1, double p2) ;
+EXPORT void f6_V_PSD_FFD(void* p0, struct S_FFD p1, double p2) ;
+EXPORT void f6_V_PSD_FFP(void* p0, struct S_FFP p1, double p2) ;
+EXPORT void f6_V_PSD_FDI(void* p0, struct S_FDI p1, double p2) ;
+EXPORT void f6_V_PSD_FDF(void* p0, struct S_FDF p1, double p2) ;
+EXPORT void f6_V_PSD_FDD(void* p0, struct S_FDD p1, double p2) ;
+EXPORT void f6_V_PSD_FDP(void* p0, struct S_FDP p1, double p2) ;
+EXPORT void f6_V_PSD_FPI(void* p0, struct S_FPI p1, double p2) ;
+EXPORT void f6_V_PSD_FPF(void* p0, struct S_FPF p1, double p2) ;
+EXPORT void f6_V_PSD_FPD(void* p0, struct S_FPD p1, double p2) ;
+EXPORT void f6_V_PSD_FPP(void* p0, struct S_FPP p1, double p2) ;
+EXPORT void f6_V_PSD_DII(void* p0, struct S_DII p1, double p2) ;
+EXPORT void f6_V_PSD_DIF(void* p0, struct S_DIF p1, double p2) ;
+EXPORT void f6_V_PSD_DID(void* p0, struct S_DID p1, double p2) ;
+EXPORT void f6_V_PSD_DIP(void* p0, struct S_DIP p1, double p2) ;
+EXPORT void f6_V_PSD_DFI(void* p0, struct S_DFI p1, double p2) ;
+EXPORT void f6_V_PSD_DFF(void* p0, struct S_DFF p1, double p2) ;
+EXPORT void f6_V_PSD_DFD(void* p0, struct S_DFD p1, double p2) ;
+EXPORT void f6_V_PSD_DFP(void* p0, struct S_DFP p1, double p2) ;
+EXPORT void f6_V_PSD_DDI(void* p0, struct S_DDI p1, double p2) ;
+EXPORT void f6_V_PSD_DDF(void* p0, struct S_DDF p1, double p2) ;
+EXPORT void f6_V_PSD_DDD(void* p0, struct S_DDD p1, double p2) ;
+EXPORT void f6_V_PSD_DDP(void* p0, struct S_DDP p1, double p2) ;
+EXPORT void f6_V_PSD_DPI(void* p0, struct S_DPI p1, double p2) ;
+EXPORT void f6_V_PSD_DPF(void* p0, struct S_DPF p1, double p2) ;
+EXPORT void f6_V_PSD_DPD(void* p0, struct S_DPD p1, double p2) ;
+EXPORT void f6_V_PSD_DPP(void* p0, struct S_DPP p1, double p2) ;
+EXPORT void f6_V_PSD_PII(void* p0, struct S_PII p1, double p2) ;
+EXPORT void f6_V_PSD_PIF(void* p0, struct S_PIF p1, double p2) ;
+EXPORT void f6_V_PSD_PID(void* p0, struct S_PID p1, double p2) ;
+EXPORT void f6_V_PSD_PIP(void* p0, struct S_PIP p1, double p2) ;
+EXPORT void f6_V_PSD_PFI(void* p0, struct S_PFI p1, double p2) ;
+EXPORT void f6_V_PSD_PFF(void* p0, struct S_PFF p1, double p2) ;
+EXPORT void f6_V_PSD_PFD(void* p0, struct S_PFD p1, double p2) ;
+EXPORT void f6_V_PSD_PFP(void* p0, struct S_PFP p1, double p2) ;
+EXPORT void f6_V_PSD_PDI(void* p0, struct S_PDI p1, double p2) ;
+EXPORT void f6_V_PSD_PDF(void* p0, struct S_PDF p1, double p2) ;
+EXPORT void f6_V_PSD_PDD(void* p0, struct S_PDD p1, double p2) ;
+EXPORT void f6_V_PSD_PDP(void* p0, struct S_PDP p1, double p2) ;
+EXPORT void f6_V_PSD_PPI(void* p0, struct S_PPI p1, double p2) ;
+EXPORT void f6_V_PSD_PPF(void* p0, struct S_PPF p1, double p2) ;
+EXPORT void f6_V_PSD_PPD(void* p0, struct S_PPD p1, double p2) ;
+EXPORT void f6_V_PSD_PPP(void* p0, struct S_PPP p1, double p2) ;
+EXPORT void f6_V_PSP_I(void* p0, struct S_I p1, void* p2) ;
+EXPORT void f6_V_PSP_F(void* p0, struct S_F p1, void* p2) ;
+EXPORT void f6_V_PSP_D(void* p0, struct S_D p1, void* p2) ;
+EXPORT void f6_V_PSP_P(void* p0, struct S_P p1, void* p2) ;
+EXPORT void f6_V_PSP_II(void* p0, struct S_II p1, void* p2) ;
+EXPORT void f6_V_PSP_IF(void* p0, struct S_IF p1, void* p2) ;
+EXPORT void f6_V_PSP_ID(void* p0, struct S_ID p1, void* p2) ;
+EXPORT void f6_V_PSP_IP(void* p0, struct S_IP p1, void* p2) ;
+EXPORT void f6_V_PSP_FI(void* p0, struct S_FI p1, void* p2) ;
+EXPORT void f6_V_PSP_FF(void* p0, struct S_FF p1, void* p2) ;
+EXPORT void f6_V_PSP_FD(void* p0, struct S_FD p1, void* p2) ;
+EXPORT void f6_V_PSP_FP(void* p0, struct S_FP p1, void* p2) ;
+EXPORT void f6_V_PSP_DI(void* p0, struct S_DI p1, void* p2) ;
+EXPORT void f6_V_PSP_DF(void* p0, struct S_DF p1, void* p2) ;
+EXPORT void f6_V_PSP_DD(void* p0, struct S_DD p1, void* p2) ;
+EXPORT void f6_V_PSP_DP(void* p0, struct S_DP p1, void* p2) ;
+EXPORT void f6_V_PSP_PI(void* p0, struct S_PI p1, void* p2) ;
+EXPORT void f6_V_PSP_PF(void* p0, struct S_PF p1, void* p2) ;
+EXPORT void f6_V_PSP_PD(void* p0, struct S_PD p1, void* p2) ;
+EXPORT void f6_V_PSP_PP(void* p0, struct S_PP p1, void* p2) ;
+EXPORT void f6_V_PSP_III(void* p0, struct S_III p1, void* p2) ;
+EXPORT void f6_V_PSP_IIF(void* p0, struct S_IIF p1, void* p2) ;
+EXPORT void f6_V_PSP_IID(void* p0, struct S_IID p1, void* p2) ;
+EXPORT void f6_V_PSP_IIP(void* p0, struct S_IIP p1, void* p2) ;
+EXPORT void f6_V_PSP_IFI(void* p0, struct S_IFI p1, void* p2) ;
+EXPORT void f6_V_PSP_IFF(void* p0, struct S_IFF p1, void* p2) ;
+EXPORT void f6_V_PSP_IFD(void* p0, struct S_IFD p1, void* p2) ;
+EXPORT void f6_V_PSP_IFP(void* p0, struct S_IFP p1, void* p2) ;
+EXPORT void f6_V_PSP_IDI(void* p0, struct S_IDI p1, void* p2) ;
+EXPORT void f6_V_PSP_IDF(void* p0, struct S_IDF p1, void* p2) ;
+EXPORT void f6_V_PSP_IDD(void* p0, struct S_IDD p1, void* p2) ;
+EXPORT void f6_V_PSP_IDP(void* p0, struct S_IDP p1, void* p2) ;
+EXPORT void f6_V_PSP_IPI(void* p0, struct S_IPI p1, void* p2) ;
+EXPORT void f6_V_PSP_IPF(void* p0, struct S_IPF p1, void* p2) ;
+EXPORT void f6_V_PSP_IPD(void* p0, struct S_IPD p1, void* p2) ;
+EXPORT void f6_V_PSP_IPP(void* p0, struct S_IPP p1, void* p2) ;
+EXPORT void f6_V_PSP_FII(void* p0, struct S_FII p1, void* p2) ;
+EXPORT void f6_V_PSP_FIF(void* p0, struct S_FIF p1, void* p2) ;
+EXPORT void f6_V_PSP_FID(void* p0, struct S_FID p1, void* p2) ;
+EXPORT void f6_V_PSP_FIP(void* p0, struct S_FIP p1, void* p2) ;
+EXPORT void f6_V_PSP_FFI(void* p0, struct S_FFI p1, void* p2) ;
+EXPORT void f6_V_PSP_FFF(void* p0, struct S_FFF p1, void* p2) ;
+EXPORT void f6_V_PSP_FFD(void* p0, struct S_FFD p1, void* p2) ;
+EXPORT void f6_V_PSP_FFP(void* p0, struct S_FFP p1, void* p2) ;
+EXPORT void f6_V_PSP_FDI(void* p0, struct S_FDI p1, void* p2) ;
+EXPORT void f6_V_PSP_FDF(void* p0, struct S_FDF p1, void* p2) ;
+EXPORT void f6_V_PSP_FDD(void* p0, struct S_FDD p1, void* p2) ;
+EXPORT void f6_V_PSP_FDP(void* p0, struct S_FDP p1, void* p2) ;
+EXPORT void f6_V_PSP_FPI(void* p0, struct S_FPI p1, void* p2) ;
+EXPORT void f6_V_PSP_FPF(void* p0, struct S_FPF p1, void* p2) ;
+EXPORT void f6_V_PSP_FPD(void* p0, struct S_FPD p1, void* p2) ;
+EXPORT void f6_V_PSP_FPP(void* p0, struct S_FPP p1, void* p2) ;
+EXPORT void f6_V_PSP_DII(void* p0, struct S_DII p1, void* p2) ;
+EXPORT void f6_V_PSP_DIF(void* p0, struct S_DIF p1, void* p2) ;
+EXPORT void f6_V_PSP_DID(void* p0, struct S_DID p1, void* p2) ;
+EXPORT void f6_V_PSP_DIP(void* p0, struct S_DIP p1, void* p2) ;
+EXPORT void f6_V_PSP_DFI(void* p0, struct S_DFI p1, void* p2) ;
+EXPORT void f6_V_PSP_DFF(void* p0, struct S_DFF p1, void* p2) ;
+EXPORT void f6_V_PSP_DFD(void* p0, struct S_DFD p1, void* p2) ;
+EXPORT void f6_V_PSP_DFP(void* p0, struct S_DFP p1, void* p2) ;
+EXPORT void f6_V_PSP_DDI(void* p0, struct S_DDI p1, void* p2) ;
+EXPORT void f6_V_PSP_DDF(void* p0, struct S_DDF p1, void* p2) ;
+EXPORT void f6_V_PSP_DDD(void* p0, struct S_DDD p1, void* p2) ;
+EXPORT void f6_V_PSP_DDP(void* p0, struct S_DDP p1, void* p2) ;
+EXPORT void f6_V_PSP_DPI(void* p0, struct S_DPI p1, void* p2) ;
+EXPORT void f6_V_PSP_DPF(void* p0, struct S_DPF p1, void* p2) ;
+EXPORT void f6_V_PSP_DPD(void* p0, struct S_DPD p1, void* p2) ;
+EXPORT void f6_V_PSP_DPP(void* p0, struct S_DPP p1, void* p2) ;
+EXPORT void f6_V_PSP_PII(void* p0, struct S_PII p1, void* p2) ;
+EXPORT void f6_V_PSP_PIF(void* p0, struct S_PIF p1, void* p2) ;
+EXPORT void f6_V_PSP_PID(void* p0, struct S_PID p1, void* p2) ;
+EXPORT void f6_V_PSP_PIP(void* p0, struct S_PIP p1, void* p2) ;
+EXPORT void f6_V_PSP_PFI(void* p0, struct S_PFI p1, void* p2) ;
+EXPORT void f6_V_PSP_PFF(void* p0, struct S_PFF p1, void* p2) ;
+EXPORT void f6_V_PSP_PFD(void* p0, struct S_PFD p1, void* p2) ;
+EXPORT void f6_V_PSP_PFP(void* p0, struct S_PFP p1, void* p2) ;
+EXPORT void f6_V_PSP_PDI(void* p0, struct S_PDI p1, void* p2) ;
+EXPORT void f6_V_PSP_PDF(void* p0, struct S_PDF p1, void* p2) ;
+EXPORT void f6_V_PSP_PDD(void* p0, struct S_PDD p1, void* p2) ;
+EXPORT void f6_V_PSP_PDP(void* p0, struct S_PDP p1, void* p2) ;
+EXPORT void f6_V_PSP_PPI(void* p0, struct S_PPI p1, void* p2) ;
+EXPORT void f6_V_PSP_PPF(void* p0, struct S_PPF p1, void* p2) ;
+EXPORT void f6_V_PSP_PPD(void* p0, struct S_PPD p1, void* p2) ;
+EXPORT void f6_V_PSP_PPP(void* p0, struct S_PPP p1, void* p2) ;
+EXPORT void f6_V_PSS_I(void* p0, struct S_I p1, struct S_I p2) ;
+EXPORT void f6_V_PSS_F(void* p0, struct S_F p1, struct S_F p2) ;
+EXPORT void f6_V_PSS_D(void* p0, struct S_D p1, struct S_D p2) ;
+EXPORT void f6_V_PSS_P(void* p0, struct S_P p1, struct S_P p2) ;
+EXPORT void f6_V_PSS_II(void* p0, struct S_II p1, struct S_II p2) ;
+EXPORT void f6_V_PSS_IF(void* p0, struct S_IF p1, struct S_IF p2) ;
+EXPORT void f6_V_PSS_ID(void* p0, struct S_ID p1, struct S_ID p2) ;
+EXPORT void f6_V_PSS_IP(void* p0, struct S_IP p1, struct S_IP p2) ;
+EXPORT void f6_V_PSS_FI(void* p0, struct S_FI p1, struct S_FI p2) ;
+EXPORT void f6_V_PSS_FF(void* p0, struct S_FF p1, struct S_FF p2) ;
+EXPORT void f6_V_PSS_FD(void* p0, struct S_FD p1, struct S_FD p2) ;
+EXPORT void f6_V_PSS_FP(void* p0, struct S_FP p1, struct S_FP p2) ;
+EXPORT void f6_V_PSS_DI(void* p0, struct S_DI p1, struct S_DI p2) ;
+EXPORT void f6_V_PSS_DF(void* p0, struct S_DF p1, struct S_DF p2) ;
+EXPORT void f6_V_PSS_DD(void* p0, struct S_DD p1, struct S_DD p2) ;
+EXPORT void f6_V_PSS_DP(void* p0, struct S_DP p1, struct S_DP p2) ;
+EXPORT void f6_V_PSS_PI(void* p0, struct S_PI p1, struct S_PI p2) ;
+EXPORT void f6_V_PSS_PF(void* p0, struct S_PF p1, struct S_PF p2) ;
+EXPORT void f6_V_PSS_PD(void* p0, struct S_PD p1, struct S_PD p2) ;
+EXPORT void f6_V_PSS_PP(void* p0, struct S_PP p1, struct S_PP p2) ;
+EXPORT void f6_V_PSS_III(void* p0, struct S_III p1, struct S_III p2) ;
+EXPORT void f6_V_PSS_IIF(void* p0, struct S_IIF p1, struct S_IIF p2) ;
+EXPORT void f6_V_PSS_IID(void* p0, struct S_IID p1, struct S_IID p2) ;
+EXPORT void f6_V_PSS_IIP(void* p0, struct S_IIP p1, struct S_IIP p2) ;
+EXPORT void f6_V_PSS_IFI(void* p0, struct S_IFI p1, struct S_IFI p2) ;
+EXPORT void f6_V_PSS_IFF(void* p0, struct S_IFF p1, struct S_IFF p2) ;
+EXPORT void f6_V_PSS_IFD(void* p0, struct S_IFD p1, struct S_IFD p2) ;
+EXPORT void f6_V_PSS_IFP(void* p0, struct S_IFP p1, struct S_IFP p2) ;
+EXPORT void f6_V_PSS_IDI(void* p0, struct S_IDI p1, struct S_IDI p2) ;
+EXPORT void f6_V_PSS_IDF(void* p0, struct S_IDF p1, struct S_IDF p2) ;
+EXPORT void f6_V_PSS_IDD(void* p0, struct S_IDD p1, struct S_IDD p2) ;
+EXPORT void f6_V_PSS_IDP(void* p0, struct S_IDP p1, struct S_IDP p2) ;
+EXPORT void f6_V_PSS_IPI(void* p0, struct S_IPI p1, struct S_IPI p2) ;
+EXPORT void f6_V_PSS_IPF(void* p0, struct S_IPF p1, struct S_IPF p2) ;
+EXPORT void f6_V_PSS_IPD(void* p0, struct S_IPD p1, struct S_IPD p2) ;
+EXPORT void f6_V_PSS_IPP(void* p0, struct S_IPP p1, struct S_IPP p2) ;
+EXPORT void f6_V_PSS_FII(void* p0, struct S_FII p1, struct S_FII p2) ;
+EXPORT void f6_V_PSS_FIF(void* p0, struct S_FIF p1, struct S_FIF p2) ;
+EXPORT void f6_V_PSS_FID(void* p0, struct S_FID p1, struct S_FID p2) ;
+EXPORT void f6_V_PSS_FIP(void* p0, struct S_FIP p1, struct S_FIP p2) ;
+EXPORT void f6_V_PSS_FFI(void* p0, struct S_FFI p1, struct S_FFI p2) ;
+EXPORT void f6_V_PSS_FFF(void* p0, struct S_FFF p1, struct S_FFF p2) ;
+EXPORT void f6_V_PSS_FFD(void* p0, struct S_FFD p1, struct S_FFD p2) ;
+EXPORT void f6_V_PSS_FFP(void* p0, struct S_FFP p1, struct S_FFP p2) ;
+EXPORT void f6_V_PSS_FDI(void* p0, struct S_FDI p1, struct S_FDI p2) ;
+EXPORT void f6_V_PSS_FDF(void* p0, struct S_FDF p1, struct S_FDF p2) ;
+EXPORT void f6_V_PSS_FDD(void* p0, struct S_FDD p1, struct S_FDD p2) ;
+EXPORT void f6_V_PSS_FDP(void* p0, struct S_FDP p1, struct S_FDP p2) ;
+EXPORT void f6_V_PSS_FPI(void* p0, struct S_FPI p1, struct S_FPI p2) ;
+EXPORT void f6_V_PSS_FPF(void* p0, struct S_FPF p1, struct S_FPF p2) ;
+EXPORT void f6_V_PSS_FPD(void* p0, struct S_FPD p1, struct S_FPD p2) ;
+EXPORT void f6_V_PSS_FPP(void* p0, struct S_FPP p1, struct S_FPP p2) ;
+EXPORT void f6_V_PSS_DII(void* p0, struct S_DII p1, struct S_DII p2) ;
+EXPORT void f6_V_PSS_DIF(void* p0, struct S_DIF p1, struct S_DIF p2) ;
+EXPORT void f6_V_PSS_DID(void* p0, struct S_DID p1, struct S_DID p2) ;
+EXPORT void f6_V_PSS_DIP(void* p0, struct S_DIP p1, struct S_DIP p2) ;
+EXPORT void f6_V_PSS_DFI(void* p0, struct S_DFI p1, struct S_DFI p2) ;
+EXPORT void f6_V_PSS_DFF(void* p0, struct S_DFF p1, struct S_DFF p2) ;
+EXPORT void f6_V_PSS_DFD(void* p0, struct S_DFD p1, struct S_DFD p2) ;
+EXPORT void f6_V_PSS_DFP(void* p0, struct S_DFP p1, struct S_DFP p2) ;
+EXPORT void f6_V_PSS_DDI(void* p0, struct S_DDI p1, struct S_DDI p2) ;
+EXPORT void f6_V_PSS_DDF(void* p0, struct S_DDF p1, struct S_DDF p2) ;
+EXPORT void f6_V_PSS_DDD(void* p0, struct S_DDD p1, struct S_DDD p2) ;
+EXPORT void f6_V_PSS_DDP(void* p0, struct S_DDP p1, struct S_DDP p2) ;
+EXPORT void f6_V_PSS_DPI(void* p0, struct S_DPI p1, struct S_DPI p2) ;
+EXPORT void f6_V_PSS_DPF(void* p0, struct S_DPF p1, struct S_DPF p2) ;
+EXPORT void f6_V_PSS_DPD(void* p0, struct S_DPD p1, struct S_DPD p2) ;
+EXPORT void f6_V_PSS_DPP(void* p0, struct S_DPP p1, struct S_DPP p2) ;
+EXPORT void f6_V_PSS_PII(void* p0, struct S_PII p1, struct S_PII p2) ;
+EXPORT void f6_V_PSS_PIF(void* p0, struct S_PIF p1, struct S_PIF p2) ;
+EXPORT void f6_V_PSS_PID(void* p0, struct S_PID p1, struct S_PID p2) ;
+EXPORT void f6_V_PSS_PIP(void* p0, struct S_PIP p1, struct S_PIP p2) ;
+EXPORT void f6_V_PSS_PFI(void* p0, struct S_PFI p1, struct S_PFI p2) ;
+EXPORT void f6_V_PSS_PFF(void* p0, struct S_PFF p1, struct S_PFF p2) ;
+EXPORT void f6_V_PSS_PFD(void* p0, struct S_PFD p1, struct S_PFD p2) ;
+EXPORT void f6_V_PSS_PFP(void* p0, struct S_PFP p1, struct S_PFP p2) ;
+EXPORT void f6_V_PSS_PDI(void* p0, struct S_PDI p1, struct S_PDI p2) ;
+EXPORT void f6_V_PSS_PDF(void* p0, struct S_PDF p1, struct S_PDF p2) ;
+EXPORT void f6_V_PSS_PDD(void* p0, struct S_PDD p1, struct S_PDD p2) ;
+EXPORT void f6_V_PSS_PDP(void* p0, struct S_PDP p1, struct S_PDP p2) ;
+EXPORT void f6_V_PSS_PPI(void* p0, struct S_PPI p1, struct S_PPI p2) ;
+EXPORT void f6_V_PSS_PPF(void* p0, struct S_PPF p1, struct S_PPF p2) ;
+EXPORT void f6_V_PSS_PPD(void* p0, struct S_PPD p1, struct S_PPD p2) ;
+EXPORT void f6_V_PSS_PPP(void* p0, struct S_PPP p1, struct S_PPP p2) ;
+EXPORT void f6_V_SII_I(struct S_I p0, int p1, int p2) ;
+EXPORT void f6_V_SII_F(struct S_F p0, int p1, int p2) ;
+EXPORT void f6_V_SII_D(struct S_D p0, int p1, int p2) ;
+EXPORT void f6_V_SII_P(struct S_P p0, int p1, int p2) ;
+EXPORT void f6_V_SII_II(struct S_II p0, int p1, int p2) ;
+EXPORT void f6_V_SII_IF(struct S_IF p0, int p1, int p2) ;
+EXPORT void f6_V_SII_ID(struct S_ID p0, int p1, int p2) ;
+EXPORT void f6_V_SII_IP(struct S_IP p0, int p1, int p2) ;
+EXPORT void f6_V_SII_FI(struct S_FI p0, int p1, int p2) ;
+EXPORT void f6_V_SII_FF(struct S_FF p0, int p1, int p2) ;
+EXPORT void f6_V_SII_FD(struct S_FD p0, int p1, int p2) ;
+EXPORT void f6_V_SII_FP(struct S_FP p0, int p1, int p2) ;
+EXPORT void f6_V_SII_DI(struct S_DI p0, int p1, int p2) ;
+EXPORT void f6_V_SII_DF(struct S_DF p0, int p1, int p2) ;
+EXPORT void f6_V_SII_DD(struct S_DD p0, int p1, int p2) ;
+EXPORT void f6_V_SII_DP(struct S_DP p0, int p1, int p2) ;
+EXPORT void f6_V_SII_PI(struct S_PI p0, int p1, int p2) ;
+EXPORT void f6_V_SII_PF(struct S_PF p0, int p1, int p2) ;
+EXPORT void f6_V_SII_PD(struct S_PD p0, int p1, int p2) ;
+EXPORT void f6_V_SII_PP(struct S_PP p0, int p1, int p2) ;
+EXPORT void f6_V_SII_III(struct S_III p0, int p1, int p2) ;
+EXPORT void f6_V_SII_IIF(struct S_IIF p0, int p1, int p2) ;
+EXPORT void f6_V_SII_IID(struct S_IID p0, int p1, int p2) ;
+EXPORT void f6_V_SII_IIP(struct S_IIP p0, int p1, int p2) ;
+EXPORT void f6_V_SII_IFI(struct S_IFI p0, int p1, int p2) ;
+EXPORT void f6_V_SII_IFF(struct S_IFF p0, int p1, int p2) ;
+EXPORT void f6_V_SII_IFD(struct S_IFD p0, int p1, int p2) ;
+EXPORT void f6_V_SII_IFP(struct S_IFP p0, int p1, int p2) ;
+EXPORT void f6_V_SII_IDI(struct S_IDI p0, int p1, int p2) ;
+EXPORT void f6_V_SII_IDF(struct S_IDF p0, int p1, int p2) ;
+EXPORT void f6_V_SII_IDD(struct S_IDD p0, int p1, int p2) ;
+EXPORT void f6_V_SII_IDP(struct S_IDP p0, int p1, int p2) ;
+EXPORT void f6_V_SII_IPI(struct S_IPI p0, int p1, int p2) ;
+EXPORT void f6_V_SII_IPF(struct S_IPF p0, int p1, int p2) ;
+EXPORT void f6_V_SII_IPD(struct S_IPD p0, int p1, int p2) ;
+EXPORT void f6_V_SII_IPP(struct S_IPP p0, int p1, int p2) ;
+EXPORT void f6_V_SII_FII(struct S_FII p0, int p1, int p2) ;
+EXPORT void f6_V_SII_FIF(struct S_FIF p0, int p1, int p2) ;
+EXPORT void f6_V_SII_FID(struct S_FID p0, int p1, int p2) ;
+EXPORT void f6_V_SII_FIP(struct S_FIP p0, int p1, int p2) ;
+EXPORT void f6_V_SII_FFI(struct S_FFI p0, int p1, int p2) ;
+EXPORT void f6_V_SII_FFF(struct S_FFF p0, int p1, int p2) ;
+EXPORT void f6_V_SII_FFD(struct S_FFD p0, int p1, int p2) ;
+EXPORT void f6_V_SII_FFP(struct S_FFP p0, int p1, int p2) ;
+EXPORT void f6_V_SII_FDI(struct S_FDI p0, int p1, int p2) ;
+EXPORT void f6_V_SII_FDF(struct S_FDF p0, int p1, int p2) ;
+EXPORT void f6_V_SII_FDD(struct S_FDD p0, int p1, int p2) ;
+EXPORT void f6_V_SII_FDP(struct S_FDP p0, int p1, int p2) ;
+EXPORT void f6_V_SII_FPI(struct S_FPI p0, int p1, int p2) ;
+EXPORT void f6_V_SII_FPF(struct S_FPF p0, int p1, int p2) ;
+EXPORT void f6_V_SII_FPD(struct S_FPD p0, int p1, int p2) ;
+EXPORT void f6_V_SII_FPP(struct S_FPP p0, int p1, int p2) ;
+EXPORT void f6_V_SII_DII(struct S_DII p0, int p1, int p2) ;
+EXPORT void f6_V_SII_DIF(struct S_DIF p0, int p1, int p2) ;
+EXPORT void f6_V_SII_DID(struct S_DID p0, int p1, int p2) ;
+EXPORT void f6_V_SII_DIP(struct S_DIP p0, int p1, int p2) ;
+EXPORT void f6_V_SII_DFI(struct S_DFI p0, int p1, int p2) ;
+EXPORT void f6_V_SII_DFF(struct S_DFF p0, int p1, int p2) ;
+EXPORT void f6_V_SII_DFD(struct S_DFD p0, int p1, int p2) ;
+EXPORT void f6_V_SII_DFP(struct S_DFP p0, int p1, int p2) ;
+EXPORT void f6_V_SII_DDI(struct S_DDI p0, int p1, int p2) ;
+EXPORT void f6_V_SII_DDF(struct S_DDF p0, int p1, int p2) ;
+EXPORT void f6_V_SII_DDD(struct S_DDD p0, int p1, int p2) ;
+EXPORT void f6_V_SII_DDP(struct S_DDP p0, int p1, int p2) ;
+EXPORT void f6_V_SII_DPI(struct S_DPI p0, int p1, int p2) ;
+EXPORT void f6_V_SII_DPF(struct S_DPF p0, int p1, int p2) ;
+EXPORT void f6_V_SII_DPD(struct S_DPD p0, int p1, int p2) ;
+EXPORT void f6_V_SII_DPP(struct S_DPP p0, int p1, int p2) ;
+EXPORT void f6_V_SII_PII(struct S_PII p0, int p1, int p2) ;
+EXPORT void f6_V_SII_PIF(struct S_PIF p0, int p1, int p2) ;
+EXPORT void f6_V_SII_PID(struct S_PID p0, int p1, int p2) ;
+EXPORT void f6_V_SII_PIP(struct S_PIP p0, int p1, int p2) ;
+EXPORT void f6_V_SII_PFI(struct S_PFI p0, int p1, int p2) ;
+EXPORT void f6_V_SII_PFF(struct S_PFF p0, int p1, int p2) ;
+EXPORT void f6_V_SII_PFD(struct S_PFD p0, int p1, int p2) ;
+EXPORT void f6_V_SII_PFP(struct S_PFP p0, int p1, int p2) ;
+EXPORT void f6_V_SII_PDI(struct S_PDI p0, int p1, int p2) ;
+EXPORT void f6_V_SII_PDF(struct S_PDF p0, int p1, int p2) ;
+EXPORT void f6_V_SII_PDD(struct S_PDD p0, int p1, int p2) ;
+EXPORT void f6_V_SII_PDP(struct S_PDP p0, int p1, int p2) ;
+EXPORT void f6_V_SII_PPI(struct S_PPI p0, int p1, int p2) ;
+EXPORT void f6_V_SII_PPF(struct S_PPF p0, int p1, int p2) ;
+EXPORT void f6_V_SII_PPD(struct S_PPD p0, int p1, int p2) ;
+EXPORT void f6_V_SII_PPP(struct S_PPP p0, int p1, int p2) ;
+EXPORT void f6_V_SIF_I(struct S_I p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_F(struct S_F p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_D(struct S_D p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_P(struct S_P p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_II(struct S_II p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_IF(struct S_IF p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_ID(struct S_ID p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_IP(struct S_IP p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_FI(struct S_FI p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_FF(struct S_FF p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_FD(struct S_FD p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_FP(struct S_FP p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_DI(struct S_DI p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_DF(struct S_DF p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_DD(struct S_DD p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_DP(struct S_DP p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_PI(struct S_PI p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_PF(struct S_PF p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_PD(struct S_PD p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_PP(struct S_PP p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_III(struct S_III p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_IIF(struct S_IIF p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_IID(struct S_IID p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_IIP(struct S_IIP p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_IFI(struct S_IFI p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_IFF(struct S_IFF p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_IFD(struct S_IFD p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_IFP(struct S_IFP p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_IDI(struct S_IDI p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_IDF(struct S_IDF p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_IDD(struct S_IDD p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_IDP(struct S_IDP p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_IPI(struct S_IPI p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_IPF(struct S_IPF p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_IPD(struct S_IPD p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_IPP(struct S_IPP p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_FII(struct S_FII p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_FIF(struct S_FIF p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_FID(struct S_FID p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_FIP(struct S_FIP p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_FFI(struct S_FFI p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_FFF(struct S_FFF p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_FFD(struct S_FFD p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_FFP(struct S_FFP p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_FDI(struct S_FDI p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_FDF(struct S_FDF p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_FDD(struct S_FDD p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_FDP(struct S_FDP p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_FPI(struct S_FPI p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_FPF(struct S_FPF p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_FPD(struct S_FPD p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_FPP(struct S_FPP p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_DII(struct S_DII p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_DIF(struct S_DIF p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_DID(struct S_DID p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_DIP(struct S_DIP p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_DFI(struct S_DFI p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_DFF(struct S_DFF p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_DFD(struct S_DFD p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_DFP(struct S_DFP p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_DDI(struct S_DDI p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_DDF(struct S_DDF p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_DDD(struct S_DDD p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_DDP(struct S_DDP p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_DPI(struct S_DPI p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_DPF(struct S_DPF p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_DPD(struct S_DPD p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_DPP(struct S_DPP p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_PII(struct S_PII p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_PIF(struct S_PIF p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_PID(struct S_PID p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_PIP(struct S_PIP p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_PFI(struct S_PFI p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_PFF(struct S_PFF p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_PFD(struct S_PFD p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_PFP(struct S_PFP p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_PDI(struct S_PDI p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_PDF(struct S_PDF p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_PDD(struct S_PDD p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_PDP(struct S_PDP p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_PPI(struct S_PPI p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_PPF(struct S_PPF p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_PPD(struct S_PPD p0, int p1, float p2) ;
+EXPORT void f6_V_SIF_PPP(struct S_PPP p0, int p1, float p2) ;
+EXPORT void f6_V_SID_I(struct S_I p0, int p1, double p2) ;
+EXPORT void f6_V_SID_F(struct S_F p0, int p1, double p2) ;
+EXPORT void f6_V_SID_D(struct S_D p0, int p1, double p2) ;
+EXPORT void f6_V_SID_P(struct S_P p0, int p1, double p2) ;
+EXPORT void f6_V_SID_II(struct S_II p0, int p1, double p2) ;
+EXPORT void f6_V_SID_IF(struct S_IF p0, int p1, double p2) ;
+EXPORT void f6_V_SID_ID(struct S_ID p0, int p1, double p2) ;
+EXPORT void f6_V_SID_IP(struct S_IP p0, int p1, double p2) ;
+EXPORT void f6_V_SID_FI(struct S_FI p0, int p1, double p2) ;
+EXPORT void f6_V_SID_FF(struct S_FF p0, int p1, double p2) ;
+EXPORT void f6_V_SID_FD(struct S_FD p0, int p1, double p2) ;
+EXPORT void f6_V_SID_FP(struct S_FP p0, int p1, double p2) ;
+EXPORT void f6_V_SID_DI(struct S_DI p0, int p1, double p2) ;
+EXPORT void f6_V_SID_DF(struct S_DF p0, int p1, double p2) ;
+EXPORT void f6_V_SID_DD(struct S_DD p0, int p1, double p2) ;
+EXPORT void f6_V_SID_DP(struct S_DP p0, int p1, double p2) ;
+EXPORT void f6_V_SID_PI(struct S_PI p0, int p1, double p2) ;
+EXPORT void f6_V_SID_PF(struct S_PF p0, int p1, double p2) ;
+EXPORT void f6_V_SID_PD(struct S_PD p0, int p1, double p2) ;
+EXPORT void f6_V_SID_PP(struct S_PP p0, int p1, double p2) ;
+EXPORT void f6_V_SID_III(struct S_III p0, int p1, double p2) ;
+EXPORT void f6_V_SID_IIF(struct S_IIF p0, int p1, double p2) ;
+EXPORT void f6_V_SID_IID(struct S_IID p0, int p1, double p2) ;
+EXPORT void f6_V_SID_IIP(struct S_IIP p0, int p1, double p2) ;
+EXPORT void f6_V_SID_IFI(struct S_IFI p0, int p1, double p2) ;
+EXPORT void f6_V_SID_IFF(struct S_IFF p0, int p1, double p2) ;
+EXPORT void f6_V_SID_IFD(struct S_IFD p0, int p1, double p2) ;
+EXPORT void f6_V_SID_IFP(struct S_IFP p0, int p1, double p2) ;
+EXPORT void f6_V_SID_IDI(struct S_IDI p0, int p1, double p2) ;
+EXPORT void f6_V_SID_IDF(struct S_IDF p0, int p1, double p2) ;
+EXPORT void f6_V_SID_IDD(struct S_IDD p0, int p1, double p2) ;
+EXPORT void f6_V_SID_IDP(struct S_IDP p0, int p1, double p2) ;
+EXPORT void f6_V_SID_IPI(struct S_IPI p0, int p1, double p2) ;
+EXPORT void f6_V_SID_IPF(struct S_IPF p0, int p1, double p2) ;
+EXPORT void f6_V_SID_IPD(struct S_IPD p0, int p1, double p2) ;
+EXPORT void f6_V_SID_IPP(struct S_IPP p0, int p1, double p2) ;
+EXPORT void f6_V_SID_FII(struct S_FII p0, int p1, double p2) ;
+EXPORT void f6_V_SID_FIF(struct S_FIF p0, int p1, double p2) ;
+EXPORT void f6_V_SID_FID(struct S_FID p0, int p1, double p2) ;
+EXPORT void f6_V_SID_FIP(struct S_FIP p0, int p1, double p2) ;
+EXPORT void f6_V_SID_FFI(struct S_FFI p0, int p1, double p2) ;
+EXPORT void f6_V_SID_FFF(struct S_FFF p0, int p1, double p2) ;
+EXPORT void f6_V_SID_FFD(struct S_FFD p0, int p1, double p2) ;
+EXPORT void f6_V_SID_FFP(struct S_FFP p0, int p1, double p2) ;
+EXPORT void f6_V_SID_FDI(struct S_FDI p0, int p1, double p2) ;
+EXPORT void f6_V_SID_FDF(struct S_FDF p0, int p1, double p2) ;
+EXPORT void f6_V_SID_FDD(struct S_FDD p0, int p1, double p2) ;
+EXPORT void f6_V_SID_FDP(struct S_FDP p0, int p1, double p2) ;
+EXPORT void f6_V_SID_FPI(struct S_FPI p0, int p1, double p2) ;
+EXPORT void f6_V_SID_FPF(struct S_FPF p0, int p1, double p2) ;
+EXPORT void f6_V_SID_FPD(struct S_FPD p0, int p1, double p2) ;
+EXPORT void f6_V_SID_FPP(struct S_FPP p0, int p1, double p2) ;
+EXPORT void f6_V_SID_DII(struct S_DII p0, int p1, double p2) ;
+EXPORT void f6_V_SID_DIF(struct S_DIF p0, int p1, double p2) ;
+EXPORT void f6_V_SID_DID(struct S_DID p0, int p1, double p2) ;
+EXPORT void f6_V_SID_DIP(struct S_DIP p0, int p1, double p2) ;
+EXPORT void f6_V_SID_DFI(struct S_DFI p0, int p1, double p2) ;
+EXPORT void f6_V_SID_DFF(struct S_DFF p0, int p1, double p2) ;
+EXPORT void f6_V_SID_DFD(struct S_DFD p0, int p1, double p2) ;
+EXPORT void f6_V_SID_DFP(struct S_DFP p0, int p1, double p2) ;
+EXPORT void f6_V_SID_DDI(struct S_DDI p0, int p1, double p2) ;
+EXPORT void f6_V_SID_DDF(struct S_DDF p0, int p1, double p2) ;
+EXPORT void f6_V_SID_DDD(struct S_DDD p0, int p1, double p2) ;
+EXPORT void f6_V_SID_DDP(struct S_DDP p0, int p1, double p2) ;
+EXPORT void f6_V_SID_DPI(struct S_DPI p0, int p1, double p2) ;
+EXPORT void f6_V_SID_DPF(struct S_DPF p0, int p1, double p2) ;
+EXPORT void f6_V_SID_DPD(struct S_DPD p0, int p1, double p2) ;
+EXPORT void f6_V_SID_DPP(struct S_DPP p0, int p1, double p2) ;
+EXPORT void f6_V_SID_PII(struct S_PII p0, int p1, double p2) ;
+EXPORT void f6_V_SID_PIF(struct S_PIF p0, int p1, double p2) ;
+EXPORT void f6_V_SID_PID(struct S_PID p0, int p1, double p2) ;
+EXPORT void f6_V_SID_PIP(struct S_PIP p0, int p1, double p2) ;
+EXPORT void f6_V_SID_PFI(struct S_PFI p0, int p1, double p2) ;
+EXPORT void f6_V_SID_PFF(struct S_PFF p0, int p1, double p2) ;
+EXPORT void f6_V_SID_PFD(struct S_PFD p0, int p1, double p2) ;
+EXPORT void f6_V_SID_PFP(struct S_PFP p0, int p1, double p2) ;
+EXPORT void f6_V_SID_PDI(struct S_PDI p0, int p1, double p2) ;
+EXPORT void f6_V_SID_PDF(struct S_PDF p0, int p1, double p2) ;
+EXPORT void f6_V_SID_PDD(struct S_PDD p0, int p1, double p2) ;
+EXPORT void f6_V_SID_PDP(struct S_PDP p0, int p1, double p2) ;
+EXPORT void f6_V_SID_PPI(struct S_PPI p0, int p1, double p2) ;
+EXPORT void f6_V_SID_PPF(struct S_PPF p0, int p1, double p2) ;
+EXPORT void f6_V_SID_PPD(struct S_PPD p0, int p1, double p2) ;
+EXPORT void f7_V_SID_PPP(struct S_PPP p0, int p1, double p2) ;
+EXPORT void f7_V_SIP_I(struct S_I p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_F(struct S_F p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_D(struct S_D p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_P(struct S_P p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_II(struct S_II p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_IF(struct S_IF p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_ID(struct S_ID p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_IP(struct S_IP p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_FI(struct S_FI p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_FF(struct S_FF p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_FD(struct S_FD p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_FP(struct S_FP p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_DI(struct S_DI p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_DF(struct S_DF p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_DD(struct S_DD p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_DP(struct S_DP p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_PI(struct S_PI p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_PF(struct S_PF p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_PD(struct S_PD p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_PP(struct S_PP p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_III(struct S_III p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_IIF(struct S_IIF p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_IID(struct S_IID p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_IIP(struct S_IIP p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_IFI(struct S_IFI p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_IFF(struct S_IFF p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_IFD(struct S_IFD p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_IFP(struct S_IFP p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_IDI(struct S_IDI p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_IDF(struct S_IDF p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_IDD(struct S_IDD p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_IDP(struct S_IDP p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_IPI(struct S_IPI p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_IPF(struct S_IPF p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_IPD(struct S_IPD p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_IPP(struct S_IPP p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_FII(struct S_FII p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_FIF(struct S_FIF p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_FID(struct S_FID p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_FIP(struct S_FIP p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_FFI(struct S_FFI p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_FFF(struct S_FFF p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_FFD(struct S_FFD p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_FFP(struct S_FFP p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_FDI(struct S_FDI p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_FDF(struct S_FDF p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_FDD(struct S_FDD p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_FDP(struct S_FDP p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_FPI(struct S_FPI p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_FPF(struct S_FPF p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_FPD(struct S_FPD p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_FPP(struct S_FPP p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_DII(struct S_DII p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_DIF(struct S_DIF p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_DID(struct S_DID p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_DIP(struct S_DIP p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_DFI(struct S_DFI p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_DFF(struct S_DFF p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_DFD(struct S_DFD p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_DFP(struct S_DFP p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_DDI(struct S_DDI p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_DDF(struct S_DDF p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_DDD(struct S_DDD p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_DDP(struct S_DDP p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_DPI(struct S_DPI p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_DPF(struct S_DPF p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_DPD(struct S_DPD p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_DPP(struct S_DPP p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_PII(struct S_PII p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_PIF(struct S_PIF p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_PID(struct S_PID p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_PIP(struct S_PIP p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_PFI(struct S_PFI p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_PFF(struct S_PFF p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_PFD(struct S_PFD p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_PFP(struct S_PFP p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_PDI(struct S_PDI p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_PDF(struct S_PDF p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_PDD(struct S_PDD p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_PDP(struct S_PDP p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_PPI(struct S_PPI p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_PPF(struct S_PPF p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_PPD(struct S_PPD p0, int p1, void* p2) ;
+EXPORT void f7_V_SIP_PPP(struct S_PPP p0, int p1, void* p2) ;
+EXPORT void f7_V_SIS_I(struct S_I p0, int p1, struct S_I p2) ;
+EXPORT void f7_V_SIS_F(struct S_F p0, int p1, struct S_F p2) ;
+EXPORT void f7_V_SIS_D(struct S_D p0, int p1, struct S_D p2) ;
+EXPORT void f7_V_SIS_P(struct S_P p0, int p1, struct S_P p2) ;
+EXPORT void f7_V_SIS_II(struct S_II p0, int p1, struct S_II p2) ;
+EXPORT void f7_V_SIS_IF(struct S_IF p0, int p1, struct S_IF p2) ;
+EXPORT void f7_V_SIS_ID(struct S_ID p0, int p1, struct S_ID p2) ;
+EXPORT void f7_V_SIS_IP(struct S_IP p0, int p1, struct S_IP p2) ;
+EXPORT void f7_V_SIS_FI(struct S_FI p0, int p1, struct S_FI p2) ;
+EXPORT void f7_V_SIS_FF(struct S_FF p0, int p1, struct S_FF p2) ;
+EXPORT void f7_V_SIS_FD(struct S_FD p0, int p1, struct S_FD p2) ;
+EXPORT void f7_V_SIS_FP(struct S_FP p0, int p1, struct S_FP p2) ;
+EXPORT void f7_V_SIS_DI(struct S_DI p0, int p1, struct S_DI p2) ;
+EXPORT void f7_V_SIS_DF(struct S_DF p0, int p1, struct S_DF p2) ;
+EXPORT void f7_V_SIS_DD(struct S_DD p0, int p1, struct S_DD p2) ;
+EXPORT void f7_V_SIS_DP(struct S_DP p0, int p1, struct S_DP p2) ;
+EXPORT void f7_V_SIS_PI(struct S_PI p0, int p1, struct S_PI p2) ;
+EXPORT void f7_V_SIS_PF(struct S_PF p0, int p1, struct S_PF p2) ;
+EXPORT void f7_V_SIS_PD(struct S_PD p0, int p1, struct S_PD p2) ;
+EXPORT void f7_V_SIS_PP(struct S_PP p0, int p1, struct S_PP p2) ;
+EXPORT void f7_V_SIS_III(struct S_III p0, int p1, struct S_III p2) ;
+EXPORT void f7_V_SIS_IIF(struct S_IIF p0, int p1, struct S_IIF p2) ;
+EXPORT void f7_V_SIS_IID(struct S_IID p0, int p1, struct S_IID p2) ;
+EXPORT void f7_V_SIS_IIP(struct S_IIP p0, int p1, struct S_IIP p2) ;
+EXPORT void f7_V_SIS_IFI(struct S_IFI p0, int p1, struct S_IFI p2) ;
+EXPORT void f7_V_SIS_IFF(struct S_IFF p0, int p1, struct S_IFF p2) ;
+EXPORT void f7_V_SIS_IFD(struct S_IFD p0, int p1, struct S_IFD p2) ;
+EXPORT void f7_V_SIS_IFP(struct S_IFP p0, int p1, struct S_IFP p2) ;
+EXPORT void f7_V_SIS_IDI(struct S_IDI p0, int p1, struct S_IDI p2) ;
+EXPORT void f7_V_SIS_IDF(struct S_IDF p0, int p1, struct S_IDF p2) ;
+EXPORT void f7_V_SIS_IDD(struct S_IDD p0, int p1, struct S_IDD p2) ;
+EXPORT void f7_V_SIS_IDP(struct S_IDP p0, int p1, struct S_IDP p2) ;
+EXPORT void f7_V_SIS_IPI(struct S_IPI p0, int p1, struct S_IPI p2) ;
+EXPORT void f7_V_SIS_IPF(struct S_IPF p0, int p1, struct S_IPF p2) ;
+EXPORT void f7_V_SIS_IPD(struct S_IPD p0, int p1, struct S_IPD p2) ;
+EXPORT void f7_V_SIS_IPP(struct S_IPP p0, int p1, struct S_IPP p2) ;
+EXPORT void f7_V_SIS_FII(struct S_FII p0, int p1, struct S_FII p2) ;
+EXPORT void f7_V_SIS_FIF(struct S_FIF p0, int p1, struct S_FIF p2) ;
+EXPORT void f7_V_SIS_FID(struct S_FID p0, int p1, struct S_FID p2) ;
+EXPORT void f7_V_SIS_FIP(struct S_FIP p0, int p1, struct S_FIP p2) ;
+EXPORT void f7_V_SIS_FFI(struct S_FFI p0, int p1, struct S_FFI p2) ;
+EXPORT void f7_V_SIS_FFF(struct S_FFF p0, int p1, struct S_FFF p2) ;
+EXPORT void f7_V_SIS_FFD(struct S_FFD p0, int p1, struct S_FFD p2) ;
+EXPORT void f7_V_SIS_FFP(struct S_FFP p0, int p1, struct S_FFP p2) ;
+EXPORT void f7_V_SIS_FDI(struct S_FDI p0, int p1, struct S_FDI p2) ;
+EXPORT void f7_V_SIS_FDF(struct S_FDF p0, int p1, struct S_FDF p2) ;
+EXPORT void f7_V_SIS_FDD(struct S_FDD p0, int p1, struct S_FDD p2) ;
+EXPORT void f7_V_SIS_FDP(struct S_FDP p0, int p1, struct S_FDP p2) ;
+EXPORT void f7_V_SIS_FPI(struct S_FPI p0, int p1, struct S_FPI p2) ;
+EXPORT void f7_V_SIS_FPF(struct S_FPF p0, int p1, struct S_FPF p2) ;
+EXPORT void f7_V_SIS_FPD(struct S_FPD p0, int p1, struct S_FPD p2) ;
+EXPORT void f7_V_SIS_FPP(struct S_FPP p0, int p1, struct S_FPP p2) ;
+EXPORT void f7_V_SIS_DII(struct S_DII p0, int p1, struct S_DII p2) ;
+EXPORT void f7_V_SIS_DIF(struct S_DIF p0, int p1, struct S_DIF p2) ;
+EXPORT void f7_V_SIS_DID(struct S_DID p0, int p1, struct S_DID p2) ;
+EXPORT void f7_V_SIS_DIP(struct S_DIP p0, int p1, struct S_DIP p2) ;
+EXPORT void f7_V_SIS_DFI(struct S_DFI p0, int p1, struct S_DFI p2) ;
+EXPORT void f7_V_SIS_DFF(struct S_DFF p0, int p1, struct S_DFF p2) ;
+EXPORT void f7_V_SIS_DFD(struct S_DFD p0, int p1, struct S_DFD p2) ;
+EXPORT void f7_V_SIS_DFP(struct S_DFP p0, int p1, struct S_DFP p2) ;
+EXPORT void f7_V_SIS_DDI(struct S_DDI p0, int p1, struct S_DDI p2) ;
+EXPORT void f7_V_SIS_DDF(struct S_DDF p0, int p1, struct S_DDF p2) ;
+EXPORT void f7_V_SIS_DDD(struct S_DDD p0, int p1, struct S_DDD p2) ;
+EXPORT void f7_V_SIS_DDP(struct S_DDP p0, int p1, struct S_DDP p2) ;
+EXPORT void f7_V_SIS_DPI(struct S_DPI p0, int p1, struct S_DPI p2) ;
+EXPORT void f7_V_SIS_DPF(struct S_DPF p0, int p1, struct S_DPF p2) ;
+EXPORT void f7_V_SIS_DPD(struct S_DPD p0, int p1, struct S_DPD p2) ;
+EXPORT void f7_V_SIS_DPP(struct S_DPP p0, int p1, struct S_DPP p2) ;
+EXPORT void f7_V_SIS_PII(struct S_PII p0, int p1, struct S_PII p2) ;
+EXPORT void f7_V_SIS_PIF(struct S_PIF p0, int p1, struct S_PIF p2) ;
+EXPORT void f7_V_SIS_PID(struct S_PID p0, int p1, struct S_PID p2) ;
+EXPORT void f7_V_SIS_PIP(struct S_PIP p0, int p1, struct S_PIP p2) ;
+EXPORT void f7_V_SIS_PFI(struct S_PFI p0, int p1, struct S_PFI p2) ;
+EXPORT void f7_V_SIS_PFF(struct S_PFF p0, int p1, struct S_PFF p2) ;
+EXPORT void f7_V_SIS_PFD(struct S_PFD p0, int p1, struct S_PFD p2) ;
+EXPORT void f7_V_SIS_PFP(struct S_PFP p0, int p1, struct S_PFP p2) ;
+EXPORT void f7_V_SIS_PDI(struct S_PDI p0, int p1, struct S_PDI p2) ;
+EXPORT void f7_V_SIS_PDF(struct S_PDF p0, int p1, struct S_PDF p2) ;
+EXPORT void f7_V_SIS_PDD(struct S_PDD p0, int p1, struct S_PDD p2) ;
+EXPORT void f7_V_SIS_PDP(struct S_PDP p0, int p1, struct S_PDP p2) ;
+EXPORT void f7_V_SIS_PPI(struct S_PPI p0, int p1, struct S_PPI p2) ;
+EXPORT void f7_V_SIS_PPF(struct S_PPF p0, int p1, struct S_PPF p2) ;
+EXPORT void f7_V_SIS_PPD(struct S_PPD p0, int p1, struct S_PPD p2) ;
+EXPORT void f7_V_SIS_PPP(struct S_PPP p0, int p1, struct S_PPP p2) ;
+EXPORT void f7_V_SFI_I(struct S_I p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_F(struct S_F p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_D(struct S_D p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_P(struct S_P p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_II(struct S_II p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_IF(struct S_IF p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_ID(struct S_ID p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_IP(struct S_IP p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_FI(struct S_FI p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_FF(struct S_FF p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_FD(struct S_FD p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_FP(struct S_FP p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_DI(struct S_DI p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_DF(struct S_DF p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_DD(struct S_DD p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_DP(struct S_DP p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_PI(struct S_PI p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_PF(struct S_PF p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_PD(struct S_PD p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_PP(struct S_PP p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_III(struct S_III p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_IIF(struct S_IIF p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_IID(struct S_IID p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_IIP(struct S_IIP p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_IFI(struct S_IFI p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_IFF(struct S_IFF p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_IFD(struct S_IFD p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_IFP(struct S_IFP p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_IDI(struct S_IDI p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_IDF(struct S_IDF p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_IDD(struct S_IDD p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_IDP(struct S_IDP p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_IPI(struct S_IPI p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_IPF(struct S_IPF p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_IPD(struct S_IPD p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_IPP(struct S_IPP p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_FII(struct S_FII p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_FIF(struct S_FIF p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_FID(struct S_FID p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_FIP(struct S_FIP p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_FFI(struct S_FFI p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_FFF(struct S_FFF p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_FFD(struct S_FFD p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_FFP(struct S_FFP p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_FDI(struct S_FDI p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_FDF(struct S_FDF p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_FDD(struct S_FDD p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_FDP(struct S_FDP p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_FPI(struct S_FPI p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_FPF(struct S_FPF p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_FPD(struct S_FPD p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_FPP(struct S_FPP p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_DII(struct S_DII p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_DIF(struct S_DIF p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_DID(struct S_DID p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_DIP(struct S_DIP p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_DFI(struct S_DFI p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_DFF(struct S_DFF p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_DFD(struct S_DFD p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_DFP(struct S_DFP p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_DDI(struct S_DDI p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_DDF(struct S_DDF p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_DDD(struct S_DDD p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_DDP(struct S_DDP p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_DPI(struct S_DPI p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_DPF(struct S_DPF p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_DPD(struct S_DPD p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_DPP(struct S_DPP p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_PII(struct S_PII p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_PIF(struct S_PIF p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_PID(struct S_PID p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_PIP(struct S_PIP p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_PFI(struct S_PFI p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_PFF(struct S_PFF p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_PFD(struct S_PFD p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_PFP(struct S_PFP p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_PDI(struct S_PDI p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_PDF(struct S_PDF p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_PDD(struct S_PDD p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_PDP(struct S_PDP p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_PPI(struct S_PPI p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_PPF(struct S_PPF p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_PPD(struct S_PPD p0, float p1, int p2) ;
+EXPORT void f7_V_SFI_PPP(struct S_PPP p0, float p1, int p2) ;
+EXPORT void f7_V_SFF_I(struct S_I p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_F(struct S_F p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_D(struct S_D p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_P(struct S_P p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_II(struct S_II p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_IF(struct S_IF p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_ID(struct S_ID p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_IP(struct S_IP p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_FI(struct S_FI p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_FF(struct S_FF p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_FD(struct S_FD p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_FP(struct S_FP p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_DI(struct S_DI p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_DF(struct S_DF p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_DD(struct S_DD p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_DP(struct S_DP p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_PI(struct S_PI p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_PF(struct S_PF p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_PD(struct S_PD p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_PP(struct S_PP p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_III(struct S_III p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_IIF(struct S_IIF p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_IID(struct S_IID p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_IIP(struct S_IIP p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_IFI(struct S_IFI p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_IFF(struct S_IFF p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_IFD(struct S_IFD p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_IFP(struct S_IFP p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_IDI(struct S_IDI p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_IDF(struct S_IDF p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_IDD(struct S_IDD p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_IDP(struct S_IDP p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_IPI(struct S_IPI p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_IPF(struct S_IPF p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_IPD(struct S_IPD p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_IPP(struct S_IPP p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_FII(struct S_FII p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_FIF(struct S_FIF p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_FID(struct S_FID p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_FIP(struct S_FIP p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_FFI(struct S_FFI p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_FFF(struct S_FFF p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_FFD(struct S_FFD p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_FFP(struct S_FFP p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_FDI(struct S_FDI p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_FDF(struct S_FDF p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_FDD(struct S_FDD p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_FDP(struct S_FDP p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_FPI(struct S_FPI p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_FPF(struct S_FPF p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_FPD(struct S_FPD p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_FPP(struct S_FPP p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_DII(struct S_DII p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_DIF(struct S_DIF p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_DID(struct S_DID p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_DIP(struct S_DIP p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_DFI(struct S_DFI p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_DFF(struct S_DFF p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_DFD(struct S_DFD p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_DFP(struct S_DFP p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_DDI(struct S_DDI p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_DDF(struct S_DDF p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_DDD(struct S_DDD p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_DDP(struct S_DDP p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_DPI(struct S_DPI p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_DPF(struct S_DPF p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_DPD(struct S_DPD p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_DPP(struct S_DPP p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_PII(struct S_PII p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_PIF(struct S_PIF p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_PID(struct S_PID p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_PIP(struct S_PIP p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_PFI(struct S_PFI p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_PFF(struct S_PFF p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_PFD(struct S_PFD p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_PFP(struct S_PFP p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_PDI(struct S_PDI p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_PDF(struct S_PDF p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_PDD(struct S_PDD p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_PDP(struct S_PDP p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_PPI(struct S_PPI p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_PPF(struct S_PPF p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_PPD(struct S_PPD p0, float p1, float p2) ;
+EXPORT void f7_V_SFF_PPP(struct S_PPP p0, float p1, float p2) ;
+EXPORT void f7_V_SFD_I(struct S_I p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_F(struct S_F p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_D(struct S_D p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_P(struct S_P p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_II(struct S_II p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_IF(struct S_IF p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_ID(struct S_ID p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_IP(struct S_IP p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_FI(struct S_FI p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_FF(struct S_FF p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_FD(struct S_FD p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_FP(struct S_FP p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_DI(struct S_DI p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_DF(struct S_DF p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_DD(struct S_DD p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_DP(struct S_DP p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_PI(struct S_PI p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_PF(struct S_PF p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_PD(struct S_PD p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_PP(struct S_PP p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_III(struct S_III p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_IIF(struct S_IIF p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_IID(struct S_IID p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_IIP(struct S_IIP p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_IFI(struct S_IFI p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_IFF(struct S_IFF p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_IFD(struct S_IFD p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_IFP(struct S_IFP p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_IDI(struct S_IDI p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_IDF(struct S_IDF p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_IDD(struct S_IDD p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_IDP(struct S_IDP p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_IPI(struct S_IPI p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_IPF(struct S_IPF p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_IPD(struct S_IPD p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_IPP(struct S_IPP p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_FII(struct S_FII p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_FIF(struct S_FIF p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_FID(struct S_FID p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_FIP(struct S_FIP p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_FFI(struct S_FFI p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_FFF(struct S_FFF p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_FFD(struct S_FFD p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_FFP(struct S_FFP p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_FDI(struct S_FDI p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_FDF(struct S_FDF p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_FDD(struct S_FDD p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_FDP(struct S_FDP p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_FPI(struct S_FPI p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_FPF(struct S_FPF p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_FPD(struct S_FPD p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_FPP(struct S_FPP p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_DII(struct S_DII p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_DIF(struct S_DIF p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_DID(struct S_DID p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_DIP(struct S_DIP p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_DFI(struct S_DFI p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_DFF(struct S_DFF p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_DFD(struct S_DFD p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_DFP(struct S_DFP p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_DDI(struct S_DDI p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_DDF(struct S_DDF p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_DDD(struct S_DDD p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_DDP(struct S_DDP p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_DPI(struct S_DPI p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_DPF(struct S_DPF p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_DPD(struct S_DPD p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_DPP(struct S_DPP p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_PII(struct S_PII p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_PIF(struct S_PIF p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_PID(struct S_PID p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_PIP(struct S_PIP p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_PFI(struct S_PFI p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_PFF(struct S_PFF p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_PFD(struct S_PFD p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_PFP(struct S_PFP p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_PDI(struct S_PDI p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_PDF(struct S_PDF p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_PDD(struct S_PDD p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_PDP(struct S_PDP p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_PPI(struct S_PPI p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_PPF(struct S_PPF p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_PPD(struct S_PPD p0, float p1, double p2) ;
+EXPORT void f7_V_SFD_PPP(struct S_PPP p0, float p1, double p2) ;
+EXPORT void f7_V_SFP_I(struct S_I p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_F(struct S_F p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_D(struct S_D p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_P(struct S_P p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_II(struct S_II p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_IF(struct S_IF p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_ID(struct S_ID p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_IP(struct S_IP p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_FI(struct S_FI p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_FF(struct S_FF p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_FD(struct S_FD p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_FP(struct S_FP p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_DI(struct S_DI p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_DF(struct S_DF p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_DD(struct S_DD p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_DP(struct S_DP p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_PI(struct S_PI p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_PF(struct S_PF p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_PD(struct S_PD p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_PP(struct S_PP p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_III(struct S_III p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_IIF(struct S_IIF p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_IID(struct S_IID p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_IIP(struct S_IIP p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_IFI(struct S_IFI p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_IFF(struct S_IFF p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_IFD(struct S_IFD p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_IFP(struct S_IFP p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_IDI(struct S_IDI p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_IDF(struct S_IDF p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_IDD(struct S_IDD p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_IDP(struct S_IDP p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_IPI(struct S_IPI p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_IPF(struct S_IPF p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_IPD(struct S_IPD p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_IPP(struct S_IPP p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_FII(struct S_FII p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_FIF(struct S_FIF p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_FID(struct S_FID p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_FIP(struct S_FIP p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_FFI(struct S_FFI p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_FFF(struct S_FFF p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_FFD(struct S_FFD p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_FFP(struct S_FFP p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_FDI(struct S_FDI p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_FDF(struct S_FDF p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_FDD(struct S_FDD p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_FDP(struct S_FDP p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_FPI(struct S_FPI p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_FPF(struct S_FPF p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_FPD(struct S_FPD p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_FPP(struct S_FPP p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_DII(struct S_DII p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_DIF(struct S_DIF p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_DID(struct S_DID p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_DIP(struct S_DIP p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_DFI(struct S_DFI p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_DFF(struct S_DFF p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_DFD(struct S_DFD p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_DFP(struct S_DFP p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_DDI(struct S_DDI p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_DDF(struct S_DDF p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_DDD(struct S_DDD p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_DDP(struct S_DDP p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_DPI(struct S_DPI p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_DPF(struct S_DPF p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_DPD(struct S_DPD p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_DPP(struct S_DPP p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_PII(struct S_PII p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_PIF(struct S_PIF p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_PID(struct S_PID p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_PIP(struct S_PIP p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_PFI(struct S_PFI p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_PFF(struct S_PFF p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_PFD(struct S_PFD p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_PFP(struct S_PFP p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_PDI(struct S_PDI p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_PDF(struct S_PDF p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_PDD(struct S_PDD p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_PDP(struct S_PDP p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_PPI(struct S_PPI p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_PPF(struct S_PPF p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_PPD(struct S_PPD p0, float p1, void* p2) ;
+EXPORT void f7_V_SFP_PPP(struct S_PPP p0, float p1, void* p2) ;
+EXPORT void f7_V_SFS_I(struct S_I p0, float p1, struct S_I p2) ;
+EXPORT void f7_V_SFS_F(struct S_F p0, float p1, struct S_F p2) ;
+EXPORT void f7_V_SFS_D(struct S_D p0, float p1, struct S_D p2) ;
+EXPORT void f7_V_SFS_P(struct S_P p0, float p1, struct S_P p2) ;
+EXPORT void f7_V_SFS_II(struct S_II p0, float p1, struct S_II p2) ;
+EXPORT void f7_V_SFS_IF(struct S_IF p0, float p1, struct S_IF p2) ;
+EXPORT void f7_V_SFS_ID(struct S_ID p0, float p1, struct S_ID p2) ;
+EXPORT void f7_V_SFS_IP(struct S_IP p0, float p1, struct S_IP p2) ;
+EXPORT void f7_V_SFS_FI(struct S_FI p0, float p1, struct S_FI p2) ;
+EXPORT void f7_V_SFS_FF(struct S_FF p0, float p1, struct S_FF p2) ;
+EXPORT void f7_V_SFS_FD(struct S_FD p0, float p1, struct S_FD p2) ;
+EXPORT void f7_V_SFS_FP(struct S_FP p0, float p1, struct S_FP p2) ;
+EXPORT void f7_V_SFS_DI(struct S_DI p0, float p1, struct S_DI p2) ;
+EXPORT void f7_V_SFS_DF(struct S_DF p0, float p1, struct S_DF p2) ;
+EXPORT void f7_V_SFS_DD(struct S_DD p0, float p1, struct S_DD p2) ;
+EXPORT void f7_V_SFS_DP(struct S_DP p0, float p1, struct S_DP p2) ;
+EXPORT void f7_V_SFS_PI(struct S_PI p0, float p1, struct S_PI p2) ;
+EXPORT void f7_V_SFS_PF(struct S_PF p0, float p1, struct S_PF p2) ;
+EXPORT void f7_V_SFS_PD(struct S_PD p0, float p1, struct S_PD p2) ;
+EXPORT void f7_V_SFS_PP(struct S_PP p0, float p1, struct S_PP p2) ;
+EXPORT void f7_V_SFS_III(struct S_III p0, float p1, struct S_III p2) ;
+EXPORT void f7_V_SFS_IIF(struct S_IIF p0, float p1, struct S_IIF p2) ;
+EXPORT void f7_V_SFS_IID(struct S_IID p0, float p1, struct S_IID p2) ;
+EXPORT void f7_V_SFS_IIP(struct S_IIP p0, float p1, struct S_IIP p2) ;
+EXPORT void f7_V_SFS_IFI(struct S_IFI p0, float p1, struct S_IFI p2) ;
+EXPORT void f7_V_SFS_IFF(struct S_IFF p0, float p1, struct S_IFF p2) ;
+EXPORT void f7_V_SFS_IFD(struct S_IFD p0, float p1, struct S_IFD p2) ;
+EXPORT void f7_V_SFS_IFP(struct S_IFP p0, float p1, struct S_IFP p2) ;
+EXPORT void f7_V_SFS_IDI(struct S_IDI p0, float p1, struct S_IDI p2) ;
+EXPORT void f7_V_SFS_IDF(struct S_IDF p0, float p1, struct S_IDF p2) ;
+EXPORT void f7_V_SFS_IDD(struct S_IDD p0, float p1, struct S_IDD p2) ;
+EXPORT void f7_V_SFS_IDP(struct S_IDP p0, float p1, struct S_IDP p2) ;
+EXPORT void f7_V_SFS_IPI(struct S_IPI p0, float p1, struct S_IPI p2) ;
+EXPORT void f7_V_SFS_IPF(struct S_IPF p0, float p1, struct S_IPF p2) ;
+EXPORT void f7_V_SFS_IPD(struct S_IPD p0, float p1, struct S_IPD p2) ;
+EXPORT void f7_V_SFS_IPP(struct S_IPP p0, float p1, struct S_IPP p2) ;
+EXPORT void f7_V_SFS_FII(struct S_FII p0, float p1, struct S_FII p2) ;
+EXPORT void f7_V_SFS_FIF(struct S_FIF p0, float p1, struct S_FIF p2) ;
+EXPORT void f7_V_SFS_FID(struct S_FID p0, float p1, struct S_FID p2) ;
+EXPORT void f7_V_SFS_FIP(struct S_FIP p0, float p1, struct S_FIP p2) ;
+EXPORT void f7_V_SFS_FFI(struct S_FFI p0, float p1, struct S_FFI p2) ;
+EXPORT void f7_V_SFS_FFF(struct S_FFF p0, float p1, struct S_FFF p2) ;
+EXPORT void f7_V_SFS_FFD(struct S_FFD p0, float p1, struct S_FFD p2) ;
+EXPORT void f7_V_SFS_FFP(struct S_FFP p0, float p1, struct S_FFP p2) ;
+EXPORT void f7_V_SFS_FDI(struct S_FDI p0, float p1, struct S_FDI p2) ;
+EXPORT void f7_V_SFS_FDF(struct S_FDF p0, float p1, struct S_FDF p2) ;
+EXPORT void f7_V_SFS_FDD(struct S_FDD p0, float p1, struct S_FDD p2) ;
+EXPORT void f7_V_SFS_FDP(struct S_FDP p0, float p1, struct S_FDP p2) ;
+EXPORT void f7_V_SFS_FPI(struct S_FPI p0, float p1, struct S_FPI p2) ;
+EXPORT void f7_V_SFS_FPF(struct S_FPF p0, float p1, struct S_FPF p2) ;
+EXPORT void f7_V_SFS_FPD(struct S_FPD p0, float p1, struct S_FPD p2) ;
+EXPORT void f7_V_SFS_FPP(struct S_FPP p0, float p1, struct S_FPP p2) ;
+EXPORT void f7_V_SFS_DII(struct S_DII p0, float p1, struct S_DII p2) ;
+EXPORT void f7_V_SFS_DIF(struct S_DIF p0, float p1, struct S_DIF p2) ;
+EXPORT void f7_V_SFS_DID(struct S_DID p0, float p1, struct S_DID p2) ;
+EXPORT void f7_V_SFS_DIP(struct S_DIP p0, float p1, struct S_DIP p2) ;
+EXPORT void f7_V_SFS_DFI(struct S_DFI p0, float p1, struct S_DFI p2) ;
+EXPORT void f7_V_SFS_DFF(struct S_DFF p0, float p1, struct S_DFF p2) ;
+EXPORT void f7_V_SFS_DFD(struct S_DFD p0, float p1, struct S_DFD p2) ;
+EXPORT void f7_V_SFS_DFP(struct S_DFP p0, float p1, struct S_DFP p2) ;
+EXPORT void f7_V_SFS_DDI(struct S_DDI p0, float p1, struct S_DDI p2) ;
+EXPORT void f7_V_SFS_DDF(struct S_DDF p0, float p1, struct S_DDF p2) ;
+EXPORT void f7_V_SFS_DDD(struct S_DDD p0, float p1, struct S_DDD p2) ;
+EXPORT void f7_V_SFS_DDP(struct S_DDP p0, float p1, struct S_DDP p2) ;
+EXPORT void f7_V_SFS_DPI(struct S_DPI p0, float p1, struct S_DPI p2) ;
+EXPORT void f7_V_SFS_DPF(struct S_DPF p0, float p1, struct S_DPF p2) ;
+EXPORT void f7_V_SFS_DPD(struct S_DPD p0, float p1, struct S_DPD p2) ;
+EXPORT void f7_V_SFS_DPP(struct S_DPP p0, float p1, struct S_DPP p2) ;
+EXPORT void f7_V_SFS_PII(struct S_PII p0, float p1, struct S_PII p2) ;
+EXPORT void f7_V_SFS_PIF(struct S_PIF p0, float p1, struct S_PIF p2) ;
+EXPORT void f7_V_SFS_PID(struct S_PID p0, float p1, struct S_PID p2) ;
+EXPORT void f7_V_SFS_PIP(struct S_PIP p0, float p1, struct S_PIP p2) ;
+EXPORT void f7_V_SFS_PFI(struct S_PFI p0, float p1, struct S_PFI p2) ;
+EXPORT void f7_V_SFS_PFF(struct S_PFF p0, float p1, struct S_PFF p2) ;
+EXPORT void f7_V_SFS_PFD(struct S_PFD p0, float p1, struct S_PFD p2) ;
+EXPORT void f7_V_SFS_PFP(struct S_PFP p0, float p1, struct S_PFP p2) ;
+EXPORT void f7_V_SFS_PDI(struct S_PDI p0, float p1, struct S_PDI p2) ;
+EXPORT void f7_V_SFS_PDF(struct S_PDF p0, float p1, struct S_PDF p2) ;
+EXPORT void f7_V_SFS_PDD(struct S_PDD p0, float p1, struct S_PDD p2) ;
+EXPORT void f7_V_SFS_PDP(struct S_PDP p0, float p1, struct S_PDP p2) ;
+EXPORT void f7_V_SFS_PPI(struct S_PPI p0, float p1, struct S_PPI p2) ;
+EXPORT void f7_V_SFS_PPF(struct S_PPF p0, float p1, struct S_PPF p2) ;
+EXPORT void f7_V_SFS_PPD(struct S_PPD p0, float p1, struct S_PPD p2) ;
+EXPORT void f7_V_SFS_PPP(struct S_PPP p0, float p1, struct S_PPP p2) ;
+EXPORT void f7_V_SDI_I(struct S_I p0, double p1, int p2) ;
+EXPORT void f7_V_SDI_F(struct S_F p0, double p1, int p2) ;
+EXPORT void f7_V_SDI_D(struct S_D p0, double p1, int p2) ;
+EXPORT void f7_V_SDI_P(struct S_P p0, double p1, int p2) ;
+EXPORT void f7_V_SDI_II(struct S_II p0, double p1, int p2) ;
+EXPORT void f7_V_SDI_IF(struct S_IF p0, double p1, int p2) ;
+EXPORT void f7_V_SDI_ID(struct S_ID p0, double p1, int p2) ;
+EXPORT void f7_V_SDI_IP(struct S_IP p0, double p1, int p2) ;
+EXPORT void f7_V_SDI_FI(struct S_FI p0, double p1, int p2) ;
+EXPORT void f7_V_SDI_FF(struct S_FF p0, double p1, int p2) ;
+EXPORT void f7_V_SDI_FD(struct S_FD p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_FP(struct S_FP p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_DI(struct S_DI p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_DF(struct S_DF p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_DD(struct S_DD p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_DP(struct S_DP p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_PI(struct S_PI p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_PF(struct S_PF p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_PD(struct S_PD p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_PP(struct S_PP p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_III(struct S_III p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_IIF(struct S_IIF p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_IID(struct S_IID p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_IIP(struct S_IIP p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_IFI(struct S_IFI p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_IFF(struct S_IFF p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_IFD(struct S_IFD p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_IFP(struct S_IFP p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_IDI(struct S_IDI p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_IDF(struct S_IDF p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_IDD(struct S_IDD p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_IDP(struct S_IDP p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_IPI(struct S_IPI p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_IPF(struct S_IPF p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_IPD(struct S_IPD p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_IPP(struct S_IPP p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_FII(struct S_FII p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_FIF(struct S_FIF p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_FID(struct S_FID p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_FIP(struct S_FIP p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_FFI(struct S_FFI p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_FFF(struct S_FFF p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_FFD(struct S_FFD p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_FFP(struct S_FFP p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_FDI(struct S_FDI p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_FDF(struct S_FDF p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_FDD(struct S_FDD p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_FDP(struct S_FDP p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_FPI(struct S_FPI p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_FPF(struct S_FPF p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_FPD(struct S_FPD p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_FPP(struct S_FPP p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_DII(struct S_DII p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_DIF(struct S_DIF p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_DID(struct S_DID p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_DIP(struct S_DIP p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_DFI(struct S_DFI p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_DFF(struct S_DFF p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_DFD(struct S_DFD p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_DFP(struct S_DFP p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_DDI(struct S_DDI p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_DDF(struct S_DDF p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_DDD(struct S_DDD p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_DDP(struct S_DDP p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_DPI(struct S_DPI p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_DPF(struct S_DPF p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_DPD(struct S_DPD p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_DPP(struct S_DPP p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_PII(struct S_PII p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_PIF(struct S_PIF p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_PID(struct S_PID p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_PIP(struct S_PIP p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_PFI(struct S_PFI p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_PFF(struct S_PFF p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_PFD(struct S_PFD p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_PFP(struct S_PFP p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_PDI(struct S_PDI p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_PDF(struct S_PDF p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_PDD(struct S_PDD p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_PDP(struct S_PDP p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_PPI(struct S_PPI p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_PPF(struct S_PPF p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_PPD(struct S_PPD p0, double p1, int p2) ;
+EXPORT void f8_V_SDI_PPP(struct S_PPP p0, double p1, int p2) ;
+EXPORT void f8_V_SDF_I(struct S_I p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_F(struct S_F p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_D(struct S_D p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_P(struct S_P p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_II(struct S_II p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_IF(struct S_IF p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_ID(struct S_ID p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_IP(struct S_IP p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_FI(struct S_FI p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_FF(struct S_FF p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_FD(struct S_FD p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_FP(struct S_FP p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_DI(struct S_DI p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_DF(struct S_DF p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_DD(struct S_DD p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_DP(struct S_DP p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_PI(struct S_PI p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_PF(struct S_PF p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_PD(struct S_PD p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_PP(struct S_PP p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_III(struct S_III p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_IIF(struct S_IIF p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_IID(struct S_IID p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_IIP(struct S_IIP p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_IFI(struct S_IFI p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_IFF(struct S_IFF p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_IFD(struct S_IFD p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_IFP(struct S_IFP p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_IDI(struct S_IDI p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_IDF(struct S_IDF p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_IDD(struct S_IDD p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_IDP(struct S_IDP p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_IPI(struct S_IPI p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_IPF(struct S_IPF p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_IPD(struct S_IPD p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_IPP(struct S_IPP p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_FII(struct S_FII p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_FIF(struct S_FIF p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_FID(struct S_FID p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_FIP(struct S_FIP p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_FFI(struct S_FFI p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_FFF(struct S_FFF p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_FFD(struct S_FFD p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_FFP(struct S_FFP p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_FDI(struct S_FDI p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_FDF(struct S_FDF p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_FDD(struct S_FDD p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_FDP(struct S_FDP p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_FPI(struct S_FPI p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_FPF(struct S_FPF p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_FPD(struct S_FPD p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_FPP(struct S_FPP p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_DII(struct S_DII p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_DIF(struct S_DIF p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_DID(struct S_DID p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_DIP(struct S_DIP p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_DFI(struct S_DFI p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_DFF(struct S_DFF p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_DFD(struct S_DFD p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_DFP(struct S_DFP p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_DDI(struct S_DDI p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_DDF(struct S_DDF p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_DDD(struct S_DDD p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_DDP(struct S_DDP p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_DPI(struct S_DPI p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_DPF(struct S_DPF p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_DPD(struct S_DPD p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_DPP(struct S_DPP p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_PII(struct S_PII p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_PIF(struct S_PIF p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_PID(struct S_PID p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_PIP(struct S_PIP p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_PFI(struct S_PFI p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_PFF(struct S_PFF p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_PFD(struct S_PFD p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_PFP(struct S_PFP p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_PDI(struct S_PDI p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_PDF(struct S_PDF p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_PDD(struct S_PDD p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_PDP(struct S_PDP p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_PPI(struct S_PPI p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_PPF(struct S_PPF p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_PPD(struct S_PPD p0, double p1, float p2) ;
+EXPORT void f8_V_SDF_PPP(struct S_PPP p0, double p1, float p2) ;
+EXPORT void f8_V_SDD_I(struct S_I p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_F(struct S_F p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_D(struct S_D p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_P(struct S_P p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_II(struct S_II p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_IF(struct S_IF p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_ID(struct S_ID p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_IP(struct S_IP p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_FI(struct S_FI p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_FF(struct S_FF p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_FD(struct S_FD p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_FP(struct S_FP p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_DI(struct S_DI p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_DF(struct S_DF p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_DD(struct S_DD p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_DP(struct S_DP p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_PI(struct S_PI p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_PF(struct S_PF p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_PD(struct S_PD p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_PP(struct S_PP p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_III(struct S_III p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_IIF(struct S_IIF p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_IID(struct S_IID p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_IIP(struct S_IIP p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_IFI(struct S_IFI p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_IFF(struct S_IFF p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_IFD(struct S_IFD p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_IFP(struct S_IFP p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_IDI(struct S_IDI p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_IDF(struct S_IDF p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_IDD(struct S_IDD p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_IDP(struct S_IDP p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_IPI(struct S_IPI p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_IPF(struct S_IPF p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_IPD(struct S_IPD p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_IPP(struct S_IPP p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_FII(struct S_FII p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_FIF(struct S_FIF p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_FID(struct S_FID p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_FIP(struct S_FIP p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_FFI(struct S_FFI p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_FFF(struct S_FFF p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_FFD(struct S_FFD p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_FFP(struct S_FFP p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_FDI(struct S_FDI p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_FDF(struct S_FDF p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_FDD(struct S_FDD p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_FDP(struct S_FDP p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_FPI(struct S_FPI p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_FPF(struct S_FPF p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_FPD(struct S_FPD p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_FPP(struct S_FPP p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_DII(struct S_DII p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_DIF(struct S_DIF p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_DID(struct S_DID p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_DIP(struct S_DIP p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_DFI(struct S_DFI p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_DFF(struct S_DFF p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_DFD(struct S_DFD p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_DFP(struct S_DFP p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_DDI(struct S_DDI p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_DDF(struct S_DDF p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_DDD(struct S_DDD p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_DDP(struct S_DDP p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_DPI(struct S_DPI p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_DPF(struct S_DPF p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_DPD(struct S_DPD p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_DPP(struct S_DPP p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_PII(struct S_PII p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_PIF(struct S_PIF p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_PID(struct S_PID p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_PIP(struct S_PIP p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_PFI(struct S_PFI p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_PFF(struct S_PFF p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_PFD(struct S_PFD p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_PFP(struct S_PFP p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_PDI(struct S_PDI p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_PDF(struct S_PDF p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_PDD(struct S_PDD p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_PDP(struct S_PDP p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_PPI(struct S_PPI p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_PPF(struct S_PPF p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_PPD(struct S_PPD p0, double p1, double p2) ;
+EXPORT void f8_V_SDD_PPP(struct S_PPP p0, double p1, double p2) ;
+EXPORT void f8_V_SDP_I(struct S_I p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_F(struct S_F p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_D(struct S_D p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_P(struct S_P p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_II(struct S_II p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_IF(struct S_IF p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_ID(struct S_ID p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_IP(struct S_IP p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_FI(struct S_FI p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_FF(struct S_FF p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_FD(struct S_FD p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_FP(struct S_FP p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_DI(struct S_DI p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_DF(struct S_DF p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_DD(struct S_DD p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_DP(struct S_DP p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_PI(struct S_PI p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_PF(struct S_PF p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_PD(struct S_PD p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_PP(struct S_PP p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_III(struct S_III p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_IIF(struct S_IIF p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_IID(struct S_IID p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_IIP(struct S_IIP p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_IFI(struct S_IFI p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_IFF(struct S_IFF p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_IFD(struct S_IFD p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_IFP(struct S_IFP p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_IDI(struct S_IDI p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_IDF(struct S_IDF p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_IDD(struct S_IDD p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_IDP(struct S_IDP p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_IPI(struct S_IPI p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_IPF(struct S_IPF p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_IPD(struct S_IPD p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_IPP(struct S_IPP p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_FII(struct S_FII p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_FIF(struct S_FIF p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_FID(struct S_FID p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_FIP(struct S_FIP p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_FFI(struct S_FFI p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_FFF(struct S_FFF p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_FFD(struct S_FFD p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_FFP(struct S_FFP p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_FDI(struct S_FDI p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_FDF(struct S_FDF p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_FDD(struct S_FDD p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_FDP(struct S_FDP p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_FPI(struct S_FPI p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_FPF(struct S_FPF p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_FPD(struct S_FPD p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_FPP(struct S_FPP p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_DII(struct S_DII p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_DIF(struct S_DIF p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_DID(struct S_DID p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_DIP(struct S_DIP p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_DFI(struct S_DFI p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_DFF(struct S_DFF p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_DFD(struct S_DFD p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_DFP(struct S_DFP p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_DDI(struct S_DDI p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_DDF(struct S_DDF p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_DDD(struct S_DDD p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_DDP(struct S_DDP p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_DPI(struct S_DPI p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_DPF(struct S_DPF p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_DPD(struct S_DPD p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_DPP(struct S_DPP p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_PII(struct S_PII p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_PIF(struct S_PIF p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_PID(struct S_PID p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_PIP(struct S_PIP p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_PFI(struct S_PFI p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_PFF(struct S_PFF p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_PFD(struct S_PFD p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_PFP(struct S_PFP p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_PDI(struct S_PDI p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_PDF(struct S_PDF p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_PDD(struct S_PDD p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_PDP(struct S_PDP p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_PPI(struct S_PPI p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_PPF(struct S_PPF p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_PPD(struct S_PPD p0, double p1, void* p2) ;
+EXPORT void f8_V_SDP_PPP(struct S_PPP p0, double p1, void* p2) ;
+EXPORT void f8_V_SDS_I(struct S_I p0, double p1, struct S_I p2) ;
+EXPORT void f8_V_SDS_F(struct S_F p0, double p1, struct S_F p2) ;
+EXPORT void f8_V_SDS_D(struct S_D p0, double p1, struct S_D p2) ;
+EXPORT void f8_V_SDS_P(struct S_P p0, double p1, struct S_P p2) ;
+EXPORT void f8_V_SDS_II(struct S_II p0, double p1, struct S_II p2) ;
+EXPORT void f8_V_SDS_IF(struct S_IF p0, double p1, struct S_IF p2) ;
+EXPORT void f8_V_SDS_ID(struct S_ID p0, double p1, struct S_ID p2) ;
+EXPORT void f8_V_SDS_IP(struct S_IP p0, double p1, struct S_IP p2) ;
+EXPORT void f8_V_SDS_FI(struct S_FI p0, double p1, struct S_FI p2) ;
+EXPORT void f8_V_SDS_FF(struct S_FF p0, double p1, struct S_FF p2) ;
+EXPORT void f8_V_SDS_FD(struct S_FD p0, double p1, struct S_FD p2) ;
+EXPORT void f8_V_SDS_FP(struct S_FP p0, double p1, struct S_FP p2) ;
+EXPORT void f8_V_SDS_DI(struct S_DI p0, double p1, struct S_DI p2) ;
+EXPORT void f8_V_SDS_DF(struct S_DF p0, double p1, struct S_DF p2) ;
+EXPORT void f8_V_SDS_DD(struct S_DD p0, double p1, struct S_DD p2) ;
+EXPORT void f8_V_SDS_DP(struct S_DP p0, double p1, struct S_DP p2) ;
+EXPORT void f8_V_SDS_PI(struct S_PI p0, double p1, struct S_PI p2) ;
+EXPORT void f8_V_SDS_PF(struct S_PF p0, double p1, struct S_PF p2) ;
+EXPORT void f8_V_SDS_PD(struct S_PD p0, double p1, struct S_PD p2) ;
+EXPORT void f8_V_SDS_PP(struct S_PP p0, double p1, struct S_PP p2) ;
+EXPORT void f8_V_SDS_III(struct S_III p0, double p1, struct S_III p2) ;
+EXPORT void f8_V_SDS_IIF(struct S_IIF p0, double p1, struct S_IIF p2) ;
+EXPORT void f8_V_SDS_IID(struct S_IID p0, double p1, struct S_IID p2) ;
+EXPORT void f8_V_SDS_IIP(struct S_IIP p0, double p1, struct S_IIP p2) ;
+EXPORT void f8_V_SDS_IFI(struct S_IFI p0, double p1, struct S_IFI p2) ;
+EXPORT void f8_V_SDS_IFF(struct S_IFF p0, double p1, struct S_IFF p2) ;
+EXPORT void f8_V_SDS_IFD(struct S_IFD p0, double p1, struct S_IFD p2) ;
+EXPORT void f8_V_SDS_IFP(struct S_IFP p0, double p1, struct S_IFP p2) ;
+EXPORT void f8_V_SDS_IDI(struct S_IDI p0, double p1, struct S_IDI p2) ;
+EXPORT void f8_V_SDS_IDF(struct S_IDF p0, double p1, struct S_IDF p2) ;
+EXPORT void f8_V_SDS_IDD(struct S_IDD p0, double p1, struct S_IDD p2) ;
+EXPORT void f8_V_SDS_IDP(struct S_IDP p0, double p1, struct S_IDP p2) ;
+EXPORT void f8_V_SDS_IPI(struct S_IPI p0, double p1, struct S_IPI p2) ;
+EXPORT void f8_V_SDS_IPF(struct S_IPF p0, double p1, struct S_IPF p2) ;
+EXPORT void f8_V_SDS_IPD(struct S_IPD p0, double p1, struct S_IPD p2) ;
+EXPORT void f8_V_SDS_IPP(struct S_IPP p0, double p1, struct S_IPP p2) ;
+EXPORT void f8_V_SDS_FII(struct S_FII p0, double p1, struct S_FII p2) ;
+EXPORT void f8_V_SDS_FIF(struct S_FIF p0, double p1, struct S_FIF p2) ;
+EXPORT void f8_V_SDS_FID(struct S_FID p0, double p1, struct S_FID p2) ;
+EXPORT void f8_V_SDS_FIP(struct S_FIP p0, double p1, struct S_FIP p2) ;
+EXPORT void f8_V_SDS_FFI(struct S_FFI p0, double p1, struct S_FFI p2) ;
+EXPORT void f8_V_SDS_FFF(struct S_FFF p0, double p1, struct S_FFF p2) ;
+EXPORT void f8_V_SDS_FFD(struct S_FFD p0, double p1, struct S_FFD p2) ;
+EXPORT void f8_V_SDS_FFP(struct S_FFP p0, double p1, struct S_FFP p2) ;
+EXPORT void f8_V_SDS_FDI(struct S_FDI p0, double p1, struct S_FDI p2) ;
+EXPORT void f8_V_SDS_FDF(struct S_FDF p0, double p1, struct S_FDF p2) ;
+EXPORT void f8_V_SDS_FDD(struct S_FDD p0, double p1, struct S_FDD p2) ;
+EXPORT void f8_V_SDS_FDP(struct S_FDP p0, double p1, struct S_FDP p2) ;
+EXPORT void f8_V_SDS_FPI(struct S_FPI p0, double p1, struct S_FPI p2) ;
+EXPORT void f8_V_SDS_FPF(struct S_FPF p0, double p1, struct S_FPF p2) ;
+EXPORT void f8_V_SDS_FPD(struct S_FPD p0, double p1, struct S_FPD p2) ;
+EXPORT void f8_V_SDS_FPP(struct S_FPP p0, double p1, struct S_FPP p2) ;
+EXPORT void f8_V_SDS_DII(struct S_DII p0, double p1, struct S_DII p2) ;
+EXPORT void f8_V_SDS_DIF(struct S_DIF p0, double p1, struct S_DIF p2) ;
+EXPORT void f8_V_SDS_DID(struct S_DID p0, double p1, struct S_DID p2) ;
+EXPORT void f8_V_SDS_DIP(struct S_DIP p0, double p1, struct S_DIP p2) ;
+EXPORT void f8_V_SDS_DFI(struct S_DFI p0, double p1, struct S_DFI p2) ;
+EXPORT void f8_V_SDS_DFF(struct S_DFF p0, double p1, struct S_DFF p2) ;
+EXPORT void f8_V_SDS_DFD(struct S_DFD p0, double p1, struct S_DFD p2) ;
+EXPORT void f8_V_SDS_DFP(struct S_DFP p0, double p1, struct S_DFP p2) ;
+EXPORT void f8_V_SDS_DDI(struct S_DDI p0, double p1, struct S_DDI p2) ;
+EXPORT void f8_V_SDS_DDF(struct S_DDF p0, double p1, struct S_DDF p2) ;
+EXPORT void f8_V_SDS_DDD(struct S_DDD p0, double p1, struct S_DDD p2) ;
+EXPORT void f8_V_SDS_DDP(struct S_DDP p0, double p1, struct S_DDP p2) ;
+EXPORT void f8_V_SDS_DPI(struct S_DPI p0, double p1, struct S_DPI p2) ;
+EXPORT void f8_V_SDS_DPF(struct S_DPF p0, double p1, struct S_DPF p2) ;
+EXPORT void f8_V_SDS_DPD(struct S_DPD p0, double p1, struct S_DPD p2) ;
+EXPORT void f8_V_SDS_DPP(struct S_DPP p0, double p1, struct S_DPP p2) ;
+EXPORT void f8_V_SDS_PII(struct S_PII p0, double p1, struct S_PII p2) ;
+EXPORT void f8_V_SDS_PIF(struct S_PIF p0, double p1, struct S_PIF p2) ;
+EXPORT void f8_V_SDS_PID(struct S_PID p0, double p1, struct S_PID p2) ;
+EXPORT void f8_V_SDS_PIP(struct S_PIP p0, double p1, struct S_PIP p2) ;
+EXPORT void f8_V_SDS_PFI(struct S_PFI p0, double p1, struct S_PFI p2) ;
+EXPORT void f8_V_SDS_PFF(struct S_PFF p0, double p1, struct S_PFF p2) ;
+EXPORT void f8_V_SDS_PFD(struct S_PFD p0, double p1, struct S_PFD p2) ;
+EXPORT void f8_V_SDS_PFP(struct S_PFP p0, double p1, struct S_PFP p2) ;
+EXPORT void f8_V_SDS_PDI(struct S_PDI p0, double p1, struct S_PDI p2) ;
+EXPORT void f8_V_SDS_PDF(struct S_PDF p0, double p1, struct S_PDF p2) ;
+EXPORT void f8_V_SDS_PDD(struct S_PDD p0, double p1, struct S_PDD p2) ;
+EXPORT void f8_V_SDS_PDP(struct S_PDP p0, double p1, struct S_PDP p2) ;
+EXPORT void f8_V_SDS_PPI(struct S_PPI p0, double p1, struct S_PPI p2) ;
+EXPORT void f8_V_SDS_PPF(struct S_PPF p0, double p1, struct S_PPF p2) ;
+EXPORT void f8_V_SDS_PPD(struct S_PPD p0, double p1, struct S_PPD p2) ;
+EXPORT void f8_V_SDS_PPP(struct S_PPP p0, double p1, struct S_PPP p2) ;
+EXPORT void f8_V_SPI_I(struct S_I p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_F(struct S_F p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_D(struct S_D p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_P(struct S_P p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_II(struct S_II p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_IF(struct S_IF p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_ID(struct S_ID p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_IP(struct S_IP p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_FI(struct S_FI p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_FF(struct S_FF p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_FD(struct S_FD p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_FP(struct S_FP p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_DI(struct S_DI p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_DF(struct S_DF p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_DD(struct S_DD p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_DP(struct S_DP p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_PI(struct S_PI p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_PF(struct S_PF p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_PD(struct S_PD p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_PP(struct S_PP p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_III(struct S_III p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_IIF(struct S_IIF p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_IID(struct S_IID p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_IIP(struct S_IIP p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_IFI(struct S_IFI p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_IFF(struct S_IFF p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_IFD(struct S_IFD p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_IFP(struct S_IFP p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_IDI(struct S_IDI p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_IDF(struct S_IDF p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_IDD(struct S_IDD p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_IDP(struct S_IDP p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_IPI(struct S_IPI p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_IPF(struct S_IPF p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_IPD(struct S_IPD p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_IPP(struct S_IPP p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_FII(struct S_FII p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_FIF(struct S_FIF p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_FID(struct S_FID p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_FIP(struct S_FIP p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_FFI(struct S_FFI p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_FFF(struct S_FFF p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_FFD(struct S_FFD p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_FFP(struct S_FFP p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_FDI(struct S_FDI p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_FDF(struct S_FDF p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_FDD(struct S_FDD p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_FDP(struct S_FDP p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_FPI(struct S_FPI p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_FPF(struct S_FPF p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_FPD(struct S_FPD p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_FPP(struct S_FPP p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_DII(struct S_DII p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_DIF(struct S_DIF p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_DID(struct S_DID p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_DIP(struct S_DIP p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_DFI(struct S_DFI p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_DFF(struct S_DFF p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_DFD(struct S_DFD p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_DFP(struct S_DFP p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_DDI(struct S_DDI p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_DDF(struct S_DDF p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_DDD(struct S_DDD p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_DDP(struct S_DDP p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_DPI(struct S_DPI p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_DPF(struct S_DPF p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_DPD(struct S_DPD p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_DPP(struct S_DPP p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_PII(struct S_PII p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_PIF(struct S_PIF p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_PID(struct S_PID p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_PIP(struct S_PIP p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_PFI(struct S_PFI p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_PFF(struct S_PFF p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_PFD(struct S_PFD p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_PFP(struct S_PFP p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_PDI(struct S_PDI p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_PDF(struct S_PDF p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_PDD(struct S_PDD p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_PDP(struct S_PDP p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_PPI(struct S_PPI p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_PPF(struct S_PPF p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_PPD(struct S_PPD p0, void* p1, int p2) ;
+EXPORT void f8_V_SPI_PPP(struct S_PPP p0, void* p1, int p2) ;
+EXPORT void f8_V_SPF_I(struct S_I p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_F(struct S_F p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_D(struct S_D p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_P(struct S_P p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_II(struct S_II p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_IF(struct S_IF p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_ID(struct S_ID p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_IP(struct S_IP p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_FI(struct S_FI p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_FF(struct S_FF p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_FD(struct S_FD p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_FP(struct S_FP p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_DI(struct S_DI p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_DF(struct S_DF p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_DD(struct S_DD p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_DP(struct S_DP p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_PI(struct S_PI p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_PF(struct S_PF p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_PD(struct S_PD p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_PP(struct S_PP p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_III(struct S_III p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_IIF(struct S_IIF p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_IID(struct S_IID p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_IIP(struct S_IIP p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_IFI(struct S_IFI p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_IFF(struct S_IFF p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_IFD(struct S_IFD p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_IFP(struct S_IFP p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_IDI(struct S_IDI p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_IDF(struct S_IDF p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_IDD(struct S_IDD p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_IDP(struct S_IDP p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_IPI(struct S_IPI p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_IPF(struct S_IPF p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_IPD(struct S_IPD p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_IPP(struct S_IPP p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_FII(struct S_FII p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_FIF(struct S_FIF p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_FID(struct S_FID p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_FIP(struct S_FIP p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_FFI(struct S_FFI p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_FFF(struct S_FFF p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_FFD(struct S_FFD p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_FFP(struct S_FFP p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_FDI(struct S_FDI p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_FDF(struct S_FDF p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_FDD(struct S_FDD p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_FDP(struct S_FDP p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_FPI(struct S_FPI p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_FPF(struct S_FPF p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_FPD(struct S_FPD p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_FPP(struct S_FPP p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_DII(struct S_DII p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_DIF(struct S_DIF p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_DID(struct S_DID p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_DIP(struct S_DIP p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_DFI(struct S_DFI p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_DFF(struct S_DFF p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_DFD(struct S_DFD p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_DFP(struct S_DFP p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_DDI(struct S_DDI p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_DDF(struct S_DDF p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_DDD(struct S_DDD p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_DDP(struct S_DDP p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_DPI(struct S_DPI p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_DPF(struct S_DPF p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_DPD(struct S_DPD p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_DPP(struct S_DPP p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_PII(struct S_PII p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_PIF(struct S_PIF p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_PID(struct S_PID p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_PIP(struct S_PIP p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_PFI(struct S_PFI p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_PFF(struct S_PFF p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_PFD(struct S_PFD p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_PFP(struct S_PFP p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_PDI(struct S_PDI p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_PDF(struct S_PDF p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_PDD(struct S_PDD p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_PDP(struct S_PDP p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_PPI(struct S_PPI p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_PPF(struct S_PPF p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_PPD(struct S_PPD p0, void* p1, float p2) ;
+EXPORT void f8_V_SPF_PPP(struct S_PPP p0, void* p1, float p2) ;
+EXPORT void f8_V_SPD_I(struct S_I p0, void* p1, double p2) ;
+EXPORT void f8_V_SPD_F(struct S_F p0, void* p1, double p2) ;
+EXPORT void f8_V_SPD_D(struct S_D p0, void* p1, double p2) ;
+EXPORT void f8_V_SPD_P(struct S_P p0, void* p1, double p2) ;
+EXPORT void f8_V_SPD_II(struct S_II p0, void* p1, double p2) ;
+EXPORT void f8_V_SPD_IF(struct S_IF p0, void* p1, double p2) ;
+EXPORT void f8_V_SPD_ID(struct S_ID p0, void* p1, double p2) ;
+EXPORT void f8_V_SPD_IP(struct S_IP p0, void* p1, double p2) ;
+EXPORT void f8_V_SPD_FI(struct S_FI p0, void* p1, double p2) ;
+EXPORT void f8_V_SPD_FF(struct S_FF p0, void* p1, double p2) ;
+EXPORT void f8_V_SPD_FD(struct S_FD p0, void* p1, double p2) ;
+EXPORT void f8_V_SPD_FP(struct S_FP p0, void* p1, double p2) ;
+EXPORT void f8_V_SPD_DI(struct S_DI p0, void* p1, double p2) ;
+EXPORT void f8_V_SPD_DF(struct S_DF p0, void* p1, double p2) ;
+EXPORT void f8_V_SPD_DD(struct S_DD p0, void* p1, double p2) ;
+EXPORT void f8_V_SPD_DP(struct S_DP p0, void* p1, double p2) ;
+EXPORT void f8_V_SPD_PI(struct S_PI p0, void* p1, double p2) ;
+EXPORT void f8_V_SPD_PF(struct S_PF p0, void* p1, double p2) ;
+EXPORT void f8_V_SPD_PD(struct S_PD p0, void* p1, double p2) ;
+EXPORT void f8_V_SPD_PP(struct S_PP p0, void* p1, double p2) ;
+EXPORT void f8_V_SPD_III(struct S_III p0, void* p1, double p2) ;
+EXPORT void f8_V_SPD_IIF(struct S_IIF p0, void* p1, double p2) ;
+EXPORT void f8_V_SPD_IID(struct S_IID p0, void* p1, double p2) ;
+EXPORT void f9_V_SPD_IIP(struct S_IIP p0, void* p1, double p2) ;
+EXPORT void f9_V_SPD_IFI(struct S_IFI p0, void* p1, double p2) ;
+EXPORT void f9_V_SPD_IFF(struct S_IFF p0, void* p1, double p2) ;
+EXPORT void f9_V_SPD_IFD(struct S_IFD p0, void* p1, double p2) ;
+EXPORT void f9_V_SPD_IFP(struct S_IFP p0, void* p1, double p2) ;
+EXPORT void f9_V_SPD_IDI(struct S_IDI p0, void* p1, double p2) ;
+EXPORT void f9_V_SPD_IDF(struct S_IDF p0, void* p1, double p2) ;
+EXPORT void f9_V_SPD_IDD(struct S_IDD p0, void* p1, double p2) ;
+EXPORT void f9_V_SPD_IDP(struct S_IDP p0, void* p1, double p2) ;
+EXPORT void f9_V_SPD_IPI(struct S_IPI p0, void* p1, double p2) ;
+EXPORT void f9_V_SPD_IPF(struct S_IPF p0, void* p1, double p2) ;
+EXPORT void f9_V_SPD_IPD(struct S_IPD p0, void* p1, double p2) ;
+EXPORT void f9_V_SPD_IPP(struct S_IPP p0, void* p1, double p2) ;
+EXPORT void f9_V_SPD_FII(struct S_FII p0, void* p1, double p2) ;
+EXPORT void f9_V_SPD_FIF(struct S_FIF p0, void* p1, double p2) ;
+EXPORT void f9_V_SPD_FID(struct S_FID p0, void* p1, double p2) ;
+EXPORT void f9_V_SPD_FIP(struct S_FIP p0, void* p1, double p2) ;
+EXPORT void f9_V_SPD_FFI(struct S_FFI p0, void* p1, double p2) ;
+EXPORT void f9_V_SPD_FFF(struct S_FFF p0, void* p1, double p2) ;
+EXPORT void f9_V_SPD_FFD(struct S_FFD p0, void* p1, double p2) ;
+EXPORT void f9_V_SPD_FFP(struct S_FFP p0, void* p1, double p2) ;
+EXPORT void f9_V_SPD_FDI(struct S_FDI p0, void* p1, double p2) ;
+EXPORT void f9_V_SPD_FDF(struct S_FDF p0, void* p1, double p2) ;
+EXPORT void f9_V_SPD_FDD(struct S_FDD p0, void* p1, double p2) ;
+EXPORT void f9_V_SPD_FDP(struct S_FDP p0, void* p1, double p2) ;
+EXPORT void f9_V_SPD_FPI(struct S_FPI p0, void* p1, double p2) ;
+EXPORT void f9_V_SPD_FPF(struct S_FPF p0, void* p1, double p2) ;
+EXPORT void f9_V_SPD_FPD(struct S_FPD p0, void* p1, double p2) ;
+EXPORT void f9_V_SPD_FPP(struct S_FPP p0, void* p1, double p2) ;
+EXPORT void f9_V_SPD_DII(struct S_DII p0, void* p1, double p2) ;
+EXPORT void f9_V_SPD_DIF(struct S_DIF p0, void* p1, double p2) ;
+EXPORT void f9_V_SPD_DID(struct S_DID p0, void* p1, double p2) ;
+EXPORT void f9_V_SPD_DIP(struct S_DIP p0, void* p1, double p2) ;
+EXPORT void f9_V_SPD_DFI(struct S_DFI p0, void* p1, double p2) ;
+EXPORT void f9_V_SPD_DFF(struct S_DFF p0, void* p1, double p2) ;
+EXPORT void f9_V_SPD_DFD(struct S_DFD p0, void* p1, double p2) ;
+EXPORT void f9_V_SPD_DFP(struct S_DFP p0, void* p1, double p2) ;
+EXPORT void f9_V_SPD_DDI(struct S_DDI p0, void* p1, double p2) ;
+EXPORT void f9_V_SPD_DDF(struct S_DDF p0, void* p1, double p2) ;
+EXPORT void f9_V_SPD_DDD(struct S_DDD p0, void* p1, double p2) ;
+EXPORT void f9_V_SPD_DDP(struct S_DDP p0, void* p1, double p2) ;
+EXPORT void f9_V_SPD_DPI(struct S_DPI p0, void* p1, double p2) ;
+EXPORT void f9_V_SPD_DPF(struct S_DPF p0, void* p1, double p2) ;
+EXPORT void f9_V_SPD_DPD(struct S_DPD p0, void* p1, double p2) ;
+EXPORT void f9_V_SPD_DPP(struct S_DPP p0, void* p1, double p2) ;
+EXPORT void f9_V_SPD_PII(struct S_PII p0, void* p1, double p2) ;
+EXPORT void f9_V_SPD_PIF(struct S_PIF p0, void* p1, double p2) ;
+EXPORT void f9_V_SPD_PID(struct S_PID p0, void* p1, double p2) ;
+EXPORT void f9_V_SPD_PIP(struct S_PIP p0, void* p1, double p2) ;
+EXPORT void f9_V_SPD_PFI(struct S_PFI p0, void* p1, double p2) ;
+EXPORT void f9_V_SPD_PFF(struct S_PFF p0, void* p1, double p2) ;
+EXPORT void f9_V_SPD_PFD(struct S_PFD p0, void* p1, double p2) ;
+EXPORT void f9_V_SPD_PFP(struct S_PFP p0, void* p1, double p2) ;
+EXPORT void f9_V_SPD_PDI(struct S_PDI p0, void* p1, double p2) ;
+EXPORT void f9_V_SPD_PDF(struct S_PDF p0, void* p1, double p2) ;
+EXPORT void f9_V_SPD_PDD(struct S_PDD p0, void* p1, double p2) ;
+EXPORT void f9_V_SPD_PDP(struct S_PDP p0, void* p1, double p2) ;
+EXPORT void f9_V_SPD_PPI(struct S_PPI p0, void* p1, double p2) ;
+EXPORT void f9_V_SPD_PPF(struct S_PPF p0, void* p1, double p2) ;
+EXPORT void f9_V_SPD_PPD(struct S_PPD p0, void* p1, double p2) ;
+EXPORT void f9_V_SPD_PPP(struct S_PPP p0, void* p1, double p2) ;
+EXPORT void f9_V_SPP_I(struct S_I p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_F(struct S_F p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_D(struct S_D p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_P(struct S_P p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_II(struct S_II p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_IF(struct S_IF p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_ID(struct S_ID p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_IP(struct S_IP p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_FI(struct S_FI p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_FF(struct S_FF p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_FD(struct S_FD p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_FP(struct S_FP p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_DI(struct S_DI p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_DF(struct S_DF p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_DD(struct S_DD p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_DP(struct S_DP p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_PI(struct S_PI p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_PF(struct S_PF p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_PD(struct S_PD p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_PP(struct S_PP p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_III(struct S_III p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_IIF(struct S_IIF p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_IID(struct S_IID p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_IIP(struct S_IIP p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_IFI(struct S_IFI p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_IFF(struct S_IFF p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_IFD(struct S_IFD p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_IFP(struct S_IFP p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_IDI(struct S_IDI p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_IDF(struct S_IDF p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_IDD(struct S_IDD p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_IDP(struct S_IDP p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_IPI(struct S_IPI p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_IPF(struct S_IPF p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_IPD(struct S_IPD p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_IPP(struct S_IPP p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_FII(struct S_FII p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_FIF(struct S_FIF p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_FID(struct S_FID p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_FIP(struct S_FIP p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_FFI(struct S_FFI p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_FFF(struct S_FFF p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_FFD(struct S_FFD p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_FFP(struct S_FFP p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_FDI(struct S_FDI p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_FDF(struct S_FDF p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_FDD(struct S_FDD p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_FDP(struct S_FDP p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_FPI(struct S_FPI p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_FPF(struct S_FPF p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_FPD(struct S_FPD p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_FPP(struct S_FPP p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_DII(struct S_DII p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_DIF(struct S_DIF p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_DID(struct S_DID p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_DIP(struct S_DIP p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_DFI(struct S_DFI p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_DFF(struct S_DFF p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_DFD(struct S_DFD p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_DFP(struct S_DFP p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_DDI(struct S_DDI p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_DDF(struct S_DDF p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_DDD(struct S_DDD p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_DDP(struct S_DDP p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_DPI(struct S_DPI p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_DPF(struct S_DPF p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_DPD(struct S_DPD p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_DPP(struct S_DPP p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_PII(struct S_PII p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_PIF(struct S_PIF p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_PID(struct S_PID p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_PIP(struct S_PIP p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_PFI(struct S_PFI p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_PFF(struct S_PFF p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_PFD(struct S_PFD p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_PFP(struct S_PFP p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_PDI(struct S_PDI p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_PDF(struct S_PDF p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_PDD(struct S_PDD p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_PDP(struct S_PDP p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_PPI(struct S_PPI p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_PPF(struct S_PPF p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_PPD(struct S_PPD p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPP_PPP(struct S_PPP p0, void* p1, void* p2) ;
+EXPORT void f9_V_SPS_I(struct S_I p0, void* p1, struct S_I p2) ;
+EXPORT void f9_V_SPS_F(struct S_F p0, void* p1, struct S_F p2) ;
+EXPORT void f9_V_SPS_D(struct S_D p0, void* p1, struct S_D p2) ;
+EXPORT void f9_V_SPS_P(struct S_P p0, void* p1, struct S_P p2) ;
+EXPORT void f9_V_SPS_II(struct S_II p0, void* p1, struct S_II p2) ;
+EXPORT void f9_V_SPS_IF(struct S_IF p0, void* p1, struct S_IF p2) ;
+EXPORT void f9_V_SPS_ID(struct S_ID p0, void* p1, struct S_ID p2) ;
+EXPORT void f9_V_SPS_IP(struct S_IP p0, void* p1, struct S_IP p2) ;
+EXPORT void f9_V_SPS_FI(struct S_FI p0, void* p1, struct S_FI p2) ;
+EXPORT void f9_V_SPS_FF(struct S_FF p0, void* p1, struct S_FF p2) ;
+EXPORT void f9_V_SPS_FD(struct S_FD p0, void* p1, struct S_FD p2) ;
+EXPORT void f9_V_SPS_FP(struct S_FP p0, void* p1, struct S_FP p2) ;
+EXPORT void f9_V_SPS_DI(struct S_DI p0, void* p1, struct S_DI p2) ;
+EXPORT void f9_V_SPS_DF(struct S_DF p0, void* p1, struct S_DF p2) ;
+EXPORT void f9_V_SPS_DD(struct S_DD p0, void* p1, struct S_DD p2) ;
+EXPORT void f9_V_SPS_DP(struct S_DP p0, void* p1, struct S_DP p2) ;
+EXPORT void f9_V_SPS_PI(struct S_PI p0, void* p1, struct S_PI p2) ;
+EXPORT void f9_V_SPS_PF(struct S_PF p0, void* p1, struct S_PF p2) ;
+EXPORT void f9_V_SPS_PD(struct S_PD p0, void* p1, struct S_PD p2) ;
+EXPORT void f9_V_SPS_PP(struct S_PP p0, void* p1, struct S_PP p2) ;
+EXPORT void f9_V_SPS_III(struct S_III p0, void* p1, struct S_III p2) ;
+EXPORT void f9_V_SPS_IIF(struct S_IIF p0, void* p1, struct S_IIF p2) ;
+EXPORT void f9_V_SPS_IID(struct S_IID p0, void* p1, struct S_IID p2) ;
+EXPORT void f9_V_SPS_IIP(struct S_IIP p0, void* p1, struct S_IIP p2) ;
+EXPORT void f9_V_SPS_IFI(struct S_IFI p0, void* p1, struct S_IFI p2) ;
+EXPORT void f9_V_SPS_IFF(struct S_IFF p0, void* p1, struct S_IFF p2) ;
+EXPORT void f9_V_SPS_IFD(struct S_IFD p0, void* p1, struct S_IFD p2) ;
+EXPORT void f9_V_SPS_IFP(struct S_IFP p0, void* p1, struct S_IFP p2) ;
+EXPORT void f9_V_SPS_IDI(struct S_IDI p0, void* p1, struct S_IDI p2) ;
+EXPORT void f9_V_SPS_IDF(struct S_IDF p0, void* p1, struct S_IDF p2) ;
+EXPORT void f9_V_SPS_IDD(struct S_IDD p0, void* p1, struct S_IDD p2) ;
+EXPORT void f9_V_SPS_IDP(struct S_IDP p0, void* p1, struct S_IDP p2) ;
+EXPORT void f9_V_SPS_IPI(struct S_IPI p0, void* p1, struct S_IPI p2) ;
+EXPORT void f9_V_SPS_IPF(struct S_IPF p0, void* p1, struct S_IPF p2) ;
+EXPORT void f9_V_SPS_IPD(struct S_IPD p0, void* p1, struct S_IPD p2) ;
+EXPORT void f9_V_SPS_IPP(struct S_IPP p0, void* p1, struct S_IPP p2) ;
+EXPORT void f9_V_SPS_FII(struct S_FII p0, void* p1, struct S_FII p2) ;
+EXPORT void f9_V_SPS_FIF(struct S_FIF p0, void* p1, struct S_FIF p2) ;
+EXPORT void f9_V_SPS_FID(struct S_FID p0, void* p1, struct S_FID p2) ;
+EXPORT void f9_V_SPS_FIP(struct S_FIP p0, void* p1, struct S_FIP p2) ;
+EXPORT void f9_V_SPS_FFI(struct S_FFI p0, void* p1, struct S_FFI p2) ;
+EXPORT void f9_V_SPS_FFF(struct S_FFF p0, void* p1, struct S_FFF p2) ;
+EXPORT void f9_V_SPS_FFD(struct S_FFD p0, void* p1, struct S_FFD p2) ;
+EXPORT void f9_V_SPS_FFP(struct S_FFP p0, void* p1, struct S_FFP p2) ;
+EXPORT void f9_V_SPS_FDI(struct S_FDI p0, void* p1, struct S_FDI p2) ;
+EXPORT void f9_V_SPS_FDF(struct S_FDF p0, void* p1, struct S_FDF p2) ;
+EXPORT void f9_V_SPS_FDD(struct S_FDD p0, void* p1, struct S_FDD p2) ;
+EXPORT void f9_V_SPS_FDP(struct S_FDP p0, void* p1, struct S_FDP p2) ;
+EXPORT void f9_V_SPS_FPI(struct S_FPI p0, void* p1, struct S_FPI p2) ;
+EXPORT void f9_V_SPS_FPF(struct S_FPF p0, void* p1, struct S_FPF p2) ;
+EXPORT void f9_V_SPS_FPD(struct S_FPD p0, void* p1, struct S_FPD p2) ;
+EXPORT void f9_V_SPS_FPP(struct S_FPP p0, void* p1, struct S_FPP p2) ;
+EXPORT void f9_V_SPS_DII(struct S_DII p0, void* p1, struct S_DII p2) ;
+EXPORT void f9_V_SPS_DIF(struct S_DIF p0, void* p1, struct S_DIF p2) ;
+EXPORT void f9_V_SPS_DID(struct S_DID p0, void* p1, struct S_DID p2) ;
+EXPORT void f9_V_SPS_DIP(struct S_DIP p0, void* p1, struct S_DIP p2) ;
+EXPORT void f9_V_SPS_DFI(struct S_DFI p0, void* p1, struct S_DFI p2) ;
+EXPORT void f9_V_SPS_DFF(struct S_DFF p0, void* p1, struct S_DFF p2) ;
+EXPORT void f9_V_SPS_DFD(struct S_DFD p0, void* p1, struct S_DFD p2) ;
+EXPORT void f9_V_SPS_DFP(struct S_DFP p0, void* p1, struct S_DFP p2) ;
+EXPORT void f9_V_SPS_DDI(struct S_DDI p0, void* p1, struct S_DDI p2) ;
+EXPORT void f9_V_SPS_DDF(struct S_DDF p0, void* p1, struct S_DDF p2) ;
+EXPORT void f9_V_SPS_DDD(struct S_DDD p0, void* p1, struct S_DDD p2) ;
+EXPORT void f9_V_SPS_DDP(struct S_DDP p0, void* p1, struct S_DDP p2) ;
+EXPORT void f9_V_SPS_DPI(struct S_DPI p0, void* p1, struct S_DPI p2) ;
+EXPORT void f9_V_SPS_DPF(struct S_DPF p0, void* p1, struct S_DPF p2) ;
+EXPORT void f9_V_SPS_DPD(struct S_DPD p0, void* p1, struct S_DPD p2) ;
+EXPORT void f9_V_SPS_DPP(struct S_DPP p0, void* p1, struct S_DPP p2) ;
+EXPORT void f9_V_SPS_PII(struct S_PII p0, void* p1, struct S_PII p2) ;
+EXPORT void f9_V_SPS_PIF(struct S_PIF p0, void* p1, struct S_PIF p2) ;
+EXPORT void f9_V_SPS_PID(struct S_PID p0, void* p1, struct S_PID p2) ;
+EXPORT void f9_V_SPS_PIP(struct S_PIP p0, void* p1, struct S_PIP p2) ;
+EXPORT void f9_V_SPS_PFI(struct S_PFI p0, void* p1, struct S_PFI p2) ;
+EXPORT void f9_V_SPS_PFF(struct S_PFF p0, void* p1, struct S_PFF p2) ;
+EXPORT void f9_V_SPS_PFD(struct S_PFD p0, void* p1, struct S_PFD p2) ;
+EXPORT void f9_V_SPS_PFP(struct S_PFP p0, void* p1, struct S_PFP p2) ;
+EXPORT void f9_V_SPS_PDI(struct S_PDI p0, void* p1, struct S_PDI p2) ;
+EXPORT void f9_V_SPS_PDF(struct S_PDF p0, void* p1, struct S_PDF p2) ;
+EXPORT void f9_V_SPS_PDD(struct S_PDD p0, void* p1, struct S_PDD p2) ;
+EXPORT void f9_V_SPS_PDP(struct S_PDP p0, void* p1, struct S_PDP p2) ;
+EXPORT void f9_V_SPS_PPI(struct S_PPI p0, void* p1, struct S_PPI p2) ;
+EXPORT void f9_V_SPS_PPF(struct S_PPF p0, void* p1, struct S_PPF p2) ;
+EXPORT void f9_V_SPS_PPD(struct S_PPD p0, void* p1, struct S_PPD p2) ;
+EXPORT void f9_V_SPS_PPP(struct S_PPP p0, void* p1, struct S_PPP p2) ;
+EXPORT void f9_V_SSI_I(struct S_I p0, struct S_I p1, int p2) ;
+EXPORT void f9_V_SSI_F(struct S_F p0, struct S_F p1, int p2) ;
+EXPORT void f9_V_SSI_D(struct S_D p0, struct S_D p1, int p2) ;
+EXPORT void f9_V_SSI_P(struct S_P p0, struct S_P p1, int p2) ;
+EXPORT void f9_V_SSI_II(struct S_II p0, struct S_II p1, int p2) ;
+EXPORT void f9_V_SSI_IF(struct S_IF p0, struct S_IF p1, int p2) ;
+EXPORT void f9_V_SSI_ID(struct S_ID p0, struct S_ID p1, int p2) ;
+EXPORT void f9_V_SSI_IP(struct S_IP p0, struct S_IP p1, int p2) ;
+EXPORT void f9_V_SSI_FI(struct S_FI p0, struct S_FI p1, int p2) ;
+EXPORT void f9_V_SSI_FF(struct S_FF p0, struct S_FF p1, int p2) ;
+EXPORT void f9_V_SSI_FD(struct S_FD p0, struct S_FD p1, int p2) ;
+EXPORT void f9_V_SSI_FP(struct S_FP p0, struct S_FP p1, int p2) ;
+EXPORT void f9_V_SSI_DI(struct S_DI p0, struct S_DI p1, int p2) ;
+EXPORT void f9_V_SSI_DF(struct S_DF p0, struct S_DF p1, int p2) ;
+EXPORT void f9_V_SSI_DD(struct S_DD p0, struct S_DD p1, int p2) ;
+EXPORT void f9_V_SSI_DP(struct S_DP p0, struct S_DP p1, int p2) ;
+EXPORT void f9_V_SSI_PI(struct S_PI p0, struct S_PI p1, int p2) ;
+EXPORT void f9_V_SSI_PF(struct S_PF p0, struct S_PF p1, int p2) ;
+EXPORT void f9_V_SSI_PD(struct S_PD p0, struct S_PD p1, int p2) ;
+EXPORT void f9_V_SSI_PP(struct S_PP p0, struct S_PP p1, int p2) ;
+EXPORT void f9_V_SSI_III(struct S_III p0, struct S_III p1, int p2) ;
+EXPORT void f9_V_SSI_IIF(struct S_IIF p0, struct S_IIF p1, int p2) ;
+EXPORT void f9_V_SSI_IID(struct S_IID p0, struct S_IID p1, int p2) ;
+EXPORT void f9_V_SSI_IIP(struct S_IIP p0, struct S_IIP p1, int p2) ;
+EXPORT void f9_V_SSI_IFI(struct S_IFI p0, struct S_IFI p1, int p2) ;
+EXPORT void f9_V_SSI_IFF(struct S_IFF p0, struct S_IFF p1, int p2) ;
+EXPORT void f9_V_SSI_IFD(struct S_IFD p0, struct S_IFD p1, int p2) ;
+EXPORT void f9_V_SSI_IFP(struct S_IFP p0, struct S_IFP p1, int p2) ;
+EXPORT void f9_V_SSI_IDI(struct S_IDI p0, struct S_IDI p1, int p2) ;
+EXPORT void f9_V_SSI_IDF(struct S_IDF p0, struct S_IDF p1, int p2) ;
+EXPORT void f9_V_SSI_IDD(struct S_IDD p0, struct S_IDD p1, int p2) ;
+EXPORT void f9_V_SSI_IDP(struct S_IDP p0, struct S_IDP p1, int p2) ;
+EXPORT void f9_V_SSI_IPI(struct S_IPI p0, struct S_IPI p1, int p2) ;
+EXPORT void f9_V_SSI_IPF(struct S_IPF p0, struct S_IPF p1, int p2) ;
+EXPORT void f9_V_SSI_IPD(struct S_IPD p0, struct S_IPD p1, int p2) ;
+EXPORT void f9_V_SSI_IPP(struct S_IPP p0, struct S_IPP p1, int p2) ;
+EXPORT void f9_V_SSI_FII(struct S_FII p0, struct S_FII p1, int p2) ;
+EXPORT void f9_V_SSI_FIF(struct S_FIF p0, struct S_FIF p1, int p2) ;
+EXPORT void f9_V_SSI_FID(struct S_FID p0, struct S_FID p1, int p2) ;
+EXPORT void f9_V_SSI_FIP(struct S_FIP p0, struct S_FIP p1, int p2) ;
+EXPORT void f9_V_SSI_FFI(struct S_FFI p0, struct S_FFI p1, int p2) ;
+EXPORT void f9_V_SSI_FFF(struct S_FFF p0, struct S_FFF p1, int p2) ;
+EXPORT void f9_V_SSI_FFD(struct S_FFD p0, struct S_FFD p1, int p2) ;
+EXPORT void f9_V_SSI_FFP(struct S_FFP p0, struct S_FFP p1, int p2) ;
+EXPORT void f9_V_SSI_FDI(struct S_FDI p0, struct S_FDI p1, int p2) ;
+EXPORT void f9_V_SSI_FDF(struct S_FDF p0, struct S_FDF p1, int p2) ;
+EXPORT void f9_V_SSI_FDD(struct S_FDD p0, struct S_FDD p1, int p2) ;
+EXPORT void f9_V_SSI_FDP(struct S_FDP p0, struct S_FDP p1, int p2) ;
+EXPORT void f9_V_SSI_FPI(struct S_FPI p0, struct S_FPI p1, int p2) ;
+EXPORT void f9_V_SSI_FPF(struct S_FPF p0, struct S_FPF p1, int p2) ;
+EXPORT void f9_V_SSI_FPD(struct S_FPD p0, struct S_FPD p1, int p2) ;
+EXPORT void f9_V_SSI_FPP(struct S_FPP p0, struct S_FPP p1, int p2) ;
+EXPORT void f9_V_SSI_DII(struct S_DII p0, struct S_DII p1, int p2) ;
+EXPORT void f9_V_SSI_DIF(struct S_DIF p0, struct S_DIF p1, int p2) ;
+EXPORT void f9_V_SSI_DID(struct S_DID p0, struct S_DID p1, int p2) ;
+EXPORT void f9_V_SSI_DIP(struct S_DIP p0, struct S_DIP p1, int p2) ;
+EXPORT void f9_V_SSI_DFI(struct S_DFI p0, struct S_DFI p1, int p2) ;
+EXPORT void f9_V_SSI_DFF(struct S_DFF p0, struct S_DFF p1, int p2) ;
+EXPORT void f9_V_SSI_DFD(struct S_DFD p0, struct S_DFD p1, int p2) ;
+EXPORT void f9_V_SSI_DFP(struct S_DFP p0, struct S_DFP p1, int p2) ;
+EXPORT void f9_V_SSI_DDI(struct S_DDI p0, struct S_DDI p1, int p2) ;
+EXPORT void f9_V_SSI_DDF(struct S_DDF p0, struct S_DDF p1, int p2) ;
+EXPORT void f9_V_SSI_DDD(struct S_DDD p0, struct S_DDD p1, int p2) ;
+EXPORT void f9_V_SSI_DDP(struct S_DDP p0, struct S_DDP p1, int p2) ;
+EXPORT void f9_V_SSI_DPI(struct S_DPI p0, struct S_DPI p1, int p2) ;
+EXPORT void f9_V_SSI_DPF(struct S_DPF p0, struct S_DPF p1, int p2) ;
+EXPORT void f9_V_SSI_DPD(struct S_DPD p0, struct S_DPD p1, int p2) ;
+EXPORT void f9_V_SSI_DPP(struct S_DPP p0, struct S_DPP p1, int p2) ;
+EXPORT void f9_V_SSI_PII(struct S_PII p0, struct S_PII p1, int p2) ;
+EXPORT void f9_V_SSI_PIF(struct S_PIF p0, struct S_PIF p1, int p2) ;
+EXPORT void f9_V_SSI_PID(struct S_PID p0, struct S_PID p1, int p2) ;
+EXPORT void f9_V_SSI_PIP(struct S_PIP p0, struct S_PIP p1, int p2) ;
+EXPORT void f9_V_SSI_PFI(struct S_PFI p0, struct S_PFI p1, int p2) ;
+EXPORT void f9_V_SSI_PFF(struct S_PFF p0, struct S_PFF p1, int p2) ;
+EXPORT void f9_V_SSI_PFD(struct S_PFD p0, struct S_PFD p1, int p2) ;
+EXPORT void f9_V_SSI_PFP(struct S_PFP p0, struct S_PFP p1, int p2) ;
+EXPORT void f9_V_SSI_PDI(struct S_PDI p0, struct S_PDI p1, int p2) ;
+EXPORT void f9_V_SSI_PDF(struct S_PDF p0, struct S_PDF p1, int p2) ;
+EXPORT void f9_V_SSI_PDD(struct S_PDD p0, struct S_PDD p1, int p2) ;
+EXPORT void f9_V_SSI_PDP(struct S_PDP p0, struct S_PDP p1, int p2) ;
+EXPORT void f9_V_SSI_PPI(struct S_PPI p0, struct S_PPI p1, int p2) ;
+EXPORT void f9_V_SSI_PPF(struct S_PPF p0, struct S_PPF p1, int p2) ;
+EXPORT void f9_V_SSI_PPD(struct S_PPD p0, struct S_PPD p1, int p2) ;
+EXPORT void f9_V_SSI_PPP(struct S_PPP p0, struct S_PPP p1, int p2) ;
+EXPORT void f9_V_SSF_I(struct S_I p0, struct S_I p1, float p2) ;
+EXPORT void f9_V_SSF_F(struct S_F p0, struct S_F p1, float p2) ;
+EXPORT void f9_V_SSF_D(struct S_D p0, struct S_D p1, float p2) ;
+EXPORT void f9_V_SSF_P(struct S_P p0, struct S_P p1, float p2) ;
+EXPORT void f9_V_SSF_II(struct S_II p0, struct S_II p1, float p2) ;
+EXPORT void f9_V_SSF_IF(struct S_IF p0, struct S_IF p1, float p2) ;
+EXPORT void f9_V_SSF_ID(struct S_ID p0, struct S_ID p1, float p2) ;
+EXPORT void f9_V_SSF_IP(struct S_IP p0, struct S_IP p1, float p2) ;
+EXPORT void f9_V_SSF_FI(struct S_FI p0, struct S_FI p1, float p2) ;
+EXPORT void f9_V_SSF_FF(struct S_FF p0, struct S_FF p1, float p2) ;
+EXPORT void f9_V_SSF_FD(struct S_FD p0, struct S_FD p1, float p2) ;
+EXPORT void f9_V_SSF_FP(struct S_FP p0, struct S_FP p1, float p2) ;
+EXPORT void f9_V_SSF_DI(struct S_DI p0, struct S_DI p1, float p2) ;
+EXPORT void f9_V_SSF_DF(struct S_DF p0, struct S_DF p1, float p2) ;
+EXPORT void f9_V_SSF_DD(struct S_DD p0, struct S_DD p1, float p2) ;
+EXPORT void f9_V_SSF_DP(struct S_DP p0, struct S_DP p1, float p2) ;
+EXPORT void f9_V_SSF_PI(struct S_PI p0, struct S_PI p1, float p2) ;
+EXPORT void f9_V_SSF_PF(struct S_PF p0, struct S_PF p1, float p2) ;
+EXPORT void f9_V_SSF_PD(struct S_PD p0, struct S_PD p1, float p2) ;
+EXPORT void f9_V_SSF_PP(struct S_PP p0, struct S_PP p1, float p2) ;
+EXPORT void f9_V_SSF_III(struct S_III p0, struct S_III p1, float p2) ;
+EXPORT void f9_V_SSF_IIF(struct S_IIF p0, struct S_IIF p1, float p2) ;
+EXPORT void f9_V_SSF_IID(struct S_IID p0, struct S_IID p1, float p2) ;
+EXPORT void f9_V_SSF_IIP(struct S_IIP p0, struct S_IIP p1, float p2) ;
+EXPORT void f9_V_SSF_IFI(struct S_IFI p0, struct S_IFI p1, float p2) ;
+EXPORT void f9_V_SSF_IFF(struct S_IFF p0, struct S_IFF p1, float p2) ;
+EXPORT void f9_V_SSF_IFD(struct S_IFD p0, struct S_IFD p1, float p2) ;
+EXPORT void f9_V_SSF_IFP(struct S_IFP p0, struct S_IFP p1, float p2) ;
+EXPORT void f9_V_SSF_IDI(struct S_IDI p0, struct S_IDI p1, float p2) ;
+EXPORT void f9_V_SSF_IDF(struct S_IDF p0, struct S_IDF p1, float p2) ;
+EXPORT void f9_V_SSF_IDD(struct S_IDD p0, struct S_IDD p1, float p2) ;
+EXPORT void f9_V_SSF_IDP(struct S_IDP p0, struct S_IDP p1, float p2) ;
+EXPORT void f9_V_SSF_IPI(struct S_IPI p0, struct S_IPI p1, float p2) ;
+EXPORT void f9_V_SSF_IPF(struct S_IPF p0, struct S_IPF p1, float p2) ;
+EXPORT void f9_V_SSF_IPD(struct S_IPD p0, struct S_IPD p1, float p2) ;
+EXPORT void f9_V_SSF_IPP(struct S_IPP p0, struct S_IPP p1, float p2) ;
+EXPORT void f9_V_SSF_FII(struct S_FII p0, struct S_FII p1, float p2) ;
+EXPORT void f9_V_SSF_FIF(struct S_FIF p0, struct S_FIF p1, float p2) ;
+EXPORT void f9_V_SSF_FID(struct S_FID p0, struct S_FID p1, float p2) ;
+EXPORT void f9_V_SSF_FIP(struct S_FIP p0, struct S_FIP p1, float p2) ;
+EXPORT void f9_V_SSF_FFI(struct S_FFI p0, struct S_FFI p1, float p2) ;
+EXPORT void f9_V_SSF_FFF(struct S_FFF p0, struct S_FFF p1, float p2) ;
+EXPORT void f9_V_SSF_FFD(struct S_FFD p0, struct S_FFD p1, float p2) ;
+EXPORT void f9_V_SSF_FFP(struct S_FFP p0, struct S_FFP p1, float p2) ;
+EXPORT void f9_V_SSF_FDI(struct S_FDI p0, struct S_FDI p1, float p2) ;
+EXPORT void f9_V_SSF_FDF(struct S_FDF p0, struct S_FDF p1, float p2) ;
+EXPORT void f9_V_SSF_FDD(struct S_FDD p0, struct S_FDD p1, float p2) ;
+EXPORT void f9_V_SSF_FDP(struct S_FDP p0, struct S_FDP p1, float p2) ;
+EXPORT void f9_V_SSF_FPI(struct S_FPI p0, struct S_FPI p1, float p2) ;
+EXPORT void f9_V_SSF_FPF(struct S_FPF p0, struct S_FPF p1, float p2) ;
+EXPORT void f9_V_SSF_FPD(struct S_FPD p0, struct S_FPD p1, float p2) ;
+EXPORT void f9_V_SSF_FPP(struct S_FPP p0, struct S_FPP p1, float p2) ;
+EXPORT void f9_V_SSF_DII(struct S_DII p0, struct S_DII p1, float p2) ;
+EXPORT void f9_V_SSF_DIF(struct S_DIF p0, struct S_DIF p1, float p2) ;
+EXPORT void f9_V_SSF_DID(struct S_DID p0, struct S_DID p1, float p2) ;
+EXPORT void f9_V_SSF_DIP(struct S_DIP p0, struct S_DIP p1, float p2) ;
+EXPORT void f9_V_SSF_DFI(struct S_DFI p0, struct S_DFI p1, float p2) ;
+EXPORT void f9_V_SSF_DFF(struct S_DFF p0, struct S_DFF p1, float p2) ;
+EXPORT void f9_V_SSF_DFD(struct S_DFD p0, struct S_DFD p1, float p2) ;
+EXPORT void f9_V_SSF_DFP(struct S_DFP p0, struct S_DFP p1, float p2) ;
+EXPORT void f9_V_SSF_DDI(struct S_DDI p0, struct S_DDI p1, float p2) ;
+EXPORT void f9_V_SSF_DDF(struct S_DDF p0, struct S_DDF p1, float p2) ;
+EXPORT void f9_V_SSF_DDD(struct S_DDD p0, struct S_DDD p1, float p2) ;
+EXPORT void f9_V_SSF_DDP(struct S_DDP p0, struct S_DDP p1, float p2) ;
+EXPORT void f9_V_SSF_DPI(struct S_DPI p0, struct S_DPI p1, float p2) ;
+EXPORT void f9_V_SSF_DPF(struct S_DPF p0, struct S_DPF p1, float p2) ;
+EXPORT void f9_V_SSF_DPD(struct S_DPD p0, struct S_DPD p1, float p2) ;
+EXPORT void f9_V_SSF_DPP(struct S_DPP p0, struct S_DPP p1, float p2) ;
+EXPORT void f9_V_SSF_PII(struct S_PII p0, struct S_PII p1, float p2) ;
+EXPORT void f9_V_SSF_PIF(struct S_PIF p0, struct S_PIF p1, float p2) ;
+EXPORT void f9_V_SSF_PID(struct S_PID p0, struct S_PID p1, float p2) ;
+EXPORT void f9_V_SSF_PIP(struct S_PIP p0, struct S_PIP p1, float p2) ;
+EXPORT void f9_V_SSF_PFI(struct S_PFI p0, struct S_PFI p1, float p2) ;
+EXPORT void f9_V_SSF_PFF(struct S_PFF p0, struct S_PFF p1, float p2) ;
+EXPORT void f9_V_SSF_PFD(struct S_PFD p0, struct S_PFD p1, float p2) ;
+EXPORT void f9_V_SSF_PFP(struct S_PFP p0, struct S_PFP p1, float p2) ;
+EXPORT void f9_V_SSF_PDI(struct S_PDI p0, struct S_PDI p1, float p2) ;
+EXPORT void f9_V_SSF_PDF(struct S_PDF p0, struct S_PDF p1, float p2) ;
+EXPORT void f9_V_SSF_PDD(struct S_PDD p0, struct S_PDD p1, float p2) ;
+EXPORT void f9_V_SSF_PDP(struct S_PDP p0, struct S_PDP p1, float p2) ;
+EXPORT void f9_V_SSF_PPI(struct S_PPI p0, struct S_PPI p1, float p2) ;
+EXPORT void f9_V_SSF_PPF(struct S_PPF p0, struct S_PPF p1, float p2) ;
+EXPORT void f9_V_SSF_PPD(struct S_PPD p0, struct S_PPD p1, float p2) ;
+EXPORT void f9_V_SSF_PPP(struct S_PPP p0, struct S_PPP p1, float p2) ;
+EXPORT void f9_V_SSD_I(struct S_I p0, struct S_I p1, double p2) ;
+EXPORT void f9_V_SSD_F(struct S_F p0, struct S_F p1, double p2) ;
+EXPORT void f9_V_SSD_D(struct S_D p0, struct S_D p1, double p2) ;
+EXPORT void f9_V_SSD_P(struct S_P p0, struct S_P p1, double p2) ;
+EXPORT void f9_V_SSD_II(struct S_II p0, struct S_II p1, double p2) ;
+EXPORT void f9_V_SSD_IF(struct S_IF p0, struct S_IF p1, double p2) ;
+EXPORT void f9_V_SSD_ID(struct S_ID p0, struct S_ID p1, double p2) ;
+EXPORT void f9_V_SSD_IP(struct S_IP p0, struct S_IP p1, double p2) ;
+EXPORT void f9_V_SSD_FI(struct S_FI p0, struct S_FI p1, double p2) ;
+EXPORT void f9_V_SSD_FF(struct S_FF p0, struct S_FF p1, double p2) ;
+EXPORT void f9_V_SSD_FD(struct S_FD p0, struct S_FD p1, double p2) ;
+EXPORT void f9_V_SSD_FP(struct S_FP p0, struct S_FP p1, double p2) ;
+EXPORT void f9_V_SSD_DI(struct S_DI p0, struct S_DI p1, double p2) ;
+EXPORT void f9_V_SSD_DF(struct S_DF p0, struct S_DF p1, double p2) ;
+EXPORT void f9_V_SSD_DD(struct S_DD p0, struct S_DD p1, double p2) ;
+EXPORT void f9_V_SSD_DP(struct S_DP p0, struct S_DP p1, double p2) ;
+EXPORT void f9_V_SSD_PI(struct S_PI p0, struct S_PI p1, double p2) ;
+EXPORT void f9_V_SSD_PF(struct S_PF p0, struct S_PF p1, double p2) ;
+EXPORT void f9_V_SSD_PD(struct S_PD p0, struct S_PD p1, double p2) ;
+EXPORT void f9_V_SSD_PP(struct S_PP p0, struct S_PP p1, double p2) ;
+EXPORT void f9_V_SSD_III(struct S_III p0, struct S_III p1, double p2) ;
+EXPORT void f9_V_SSD_IIF(struct S_IIF p0, struct S_IIF p1, double p2) ;
+EXPORT void f9_V_SSD_IID(struct S_IID p0, struct S_IID p1, double p2) ;
+EXPORT void f9_V_SSD_IIP(struct S_IIP p0, struct S_IIP p1, double p2) ;
+EXPORT void f9_V_SSD_IFI(struct S_IFI p0, struct S_IFI p1, double p2) ;
+EXPORT void f9_V_SSD_IFF(struct S_IFF p0, struct S_IFF p1, double p2) ;
+EXPORT void f9_V_SSD_IFD(struct S_IFD p0, struct S_IFD p1, double p2) ;
+EXPORT void f9_V_SSD_IFP(struct S_IFP p0, struct S_IFP p1, double p2) ;
+EXPORT void f9_V_SSD_IDI(struct S_IDI p0, struct S_IDI p1, double p2) ;
+EXPORT void f9_V_SSD_IDF(struct S_IDF p0, struct S_IDF p1, double p2) ;
+EXPORT void f9_V_SSD_IDD(struct S_IDD p0, struct S_IDD p1, double p2) ;
+EXPORT void f9_V_SSD_IDP(struct S_IDP p0, struct S_IDP p1, double p2) ;
+EXPORT void f9_V_SSD_IPI(struct S_IPI p0, struct S_IPI p1, double p2) ;
+EXPORT void f9_V_SSD_IPF(struct S_IPF p0, struct S_IPF p1, double p2) ;
+EXPORT void f9_V_SSD_IPD(struct S_IPD p0, struct S_IPD p1, double p2) ;
+EXPORT void f9_V_SSD_IPP(struct S_IPP p0, struct S_IPP p1, double p2) ;
+EXPORT void f9_V_SSD_FII(struct S_FII p0, struct S_FII p1, double p2) ;
+EXPORT void f9_V_SSD_FIF(struct S_FIF p0, struct S_FIF p1, double p2) ;
+EXPORT void f9_V_SSD_FID(struct S_FID p0, struct S_FID p1, double p2) ;
+EXPORT void f9_V_SSD_FIP(struct S_FIP p0, struct S_FIP p1, double p2) ;
+EXPORT void f9_V_SSD_FFI(struct S_FFI p0, struct S_FFI p1, double p2) ;
+EXPORT void f9_V_SSD_FFF(struct S_FFF p0, struct S_FFF p1, double p2) ;
+EXPORT void f9_V_SSD_FFD(struct S_FFD p0, struct S_FFD p1, double p2) ;
+EXPORT void f9_V_SSD_FFP(struct S_FFP p0, struct S_FFP p1, double p2) ;
+EXPORT void f9_V_SSD_FDI(struct S_FDI p0, struct S_FDI p1, double p2) ;
+EXPORT void f9_V_SSD_FDF(struct S_FDF p0, struct S_FDF p1, double p2) ;
+EXPORT void f9_V_SSD_FDD(struct S_FDD p0, struct S_FDD p1, double p2) ;
+EXPORT void f9_V_SSD_FDP(struct S_FDP p0, struct S_FDP p1, double p2) ;
+EXPORT void f9_V_SSD_FPI(struct S_FPI p0, struct S_FPI p1, double p2) ;
+EXPORT void f9_V_SSD_FPF(struct S_FPF p0, struct S_FPF p1, double p2) ;
+EXPORT void f9_V_SSD_FPD(struct S_FPD p0, struct S_FPD p1, double p2) ;
+EXPORT void f9_V_SSD_FPP(struct S_FPP p0, struct S_FPP p1, double p2) ;
+EXPORT void f9_V_SSD_DII(struct S_DII p0, struct S_DII p1, double p2) ;
+EXPORT void f9_V_SSD_DIF(struct S_DIF p0, struct S_DIF p1, double p2) ;
+EXPORT void f9_V_SSD_DID(struct S_DID p0, struct S_DID p1, double p2) ;
+EXPORT void f9_V_SSD_DIP(struct S_DIP p0, struct S_DIP p1, double p2) ;
+EXPORT void f9_V_SSD_DFI(struct S_DFI p0, struct S_DFI p1, double p2) ;
+EXPORT void f9_V_SSD_DFF(struct S_DFF p0, struct S_DFF p1, double p2) ;
+EXPORT void f9_V_SSD_DFD(struct S_DFD p0, struct S_DFD p1, double p2) ;
+EXPORT void f9_V_SSD_DFP(struct S_DFP p0, struct S_DFP p1, double p2) ;
+EXPORT void f9_V_SSD_DDI(struct S_DDI p0, struct S_DDI p1, double p2) ;
+EXPORT void f9_V_SSD_DDF(struct S_DDF p0, struct S_DDF p1, double p2) ;
+EXPORT void f9_V_SSD_DDD(struct S_DDD p0, struct S_DDD p1, double p2) ;
+EXPORT void f9_V_SSD_DDP(struct S_DDP p0, struct S_DDP p1, double p2) ;
+EXPORT void f9_V_SSD_DPI(struct S_DPI p0, struct S_DPI p1, double p2) ;
+EXPORT void f9_V_SSD_DPF(struct S_DPF p0, struct S_DPF p1, double p2) ;
+EXPORT void f9_V_SSD_DPD(struct S_DPD p0, struct S_DPD p1, double p2) ;
+EXPORT void f9_V_SSD_DPP(struct S_DPP p0, struct S_DPP p1, double p2) ;
+EXPORT void f9_V_SSD_PII(struct S_PII p0, struct S_PII p1, double p2) ;
+EXPORT void f9_V_SSD_PIF(struct S_PIF p0, struct S_PIF p1, double p2) ;
+EXPORT void f9_V_SSD_PID(struct S_PID p0, struct S_PID p1, double p2) ;
+EXPORT void f9_V_SSD_PIP(struct S_PIP p0, struct S_PIP p1, double p2) ;
+EXPORT void f9_V_SSD_PFI(struct S_PFI p0, struct S_PFI p1, double p2) ;
+EXPORT void f9_V_SSD_PFF(struct S_PFF p0, struct S_PFF p1, double p2) ;
+EXPORT void f9_V_SSD_PFD(struct S_PFD p0, struct S_PFD p1, double p2) ;
+EXPORT void f9_V_SSD_PFP(struct S_PFP p0, struct S_PFP p1, double p2) ;
+EXPORT void f9_V_SSD_PDI(struct S_PDI p0, struct S_PDI p1, double p2) ;
+EXPORT void f9_V_SSD_PDF(struct S_PDF p0, struct S_PDF p1, double p2) ;
+EXPORT void f9_V_SSD_PDD(struct S_PDD p0, struct S_PDD p1, double p2) ;
+EXPORT void f9_V_SSD_PDP(struct S_PDP p0, struct S_PDP p1, double p2) ;
+EXPORT void f9_V_SSD_PPI(struct S_PPI p0, struct S_PPI p1, double p2) ;
+EXPORT void f9_V_SSD_PPF(struct S_PPF p0, struct S_PPF p1, double p2) ;
+EXPORT void f9_V_SSD_PPD(struct S_PPD p0, struct S_PPD p1, double p2) ;
+EXPORT void f9_V_SSD_PPP(struct S_PPP p0, struct S_PPP p1, double p2) ;
+EXPORT void f9_V_SSP_I(struct S_I p0, struct S_I p1, void* p2) ;
+EXPORT void f9_V_SSP_F(struct S_F p0, struct S_F p1, void* p2) ;
+EXPORT void f9_V_SSP_D(struct S_D p0, struct S_D p1, void* p2) ;
+EXPORT void f9_V_SSP_P(struct S_P p0, struct S_P p1, void* p2) ;
+EXPORT void f9_V_SSP_II(struct S_II p0, struct S_II p1, void* p2) ;
+EXPORT void f9_V_SSP_IF(struct S_IF p0, struct S_IF p1, void* p2) ;
+EXPORT void f9_V_SSP_ID(struct S_ID p0, struct S_ID p1, void* p2) ;
+EXPORT void f9_V_SSP_IP(struct S_IP p0, struct S_IP p1, void* p2) ;
+EXPORT void f9_V_SSP_FI(struct S_FI p0, struct S_FI p1, void* p2) ;
+EXPORT void f9_V_SSP_FF(struct S_FF p0, struct S_FF p1, void* p2) ;
+EXPORT void f9_V_SSP_FD(struct S_FD p0, struct S_FD p1, void* p2) ;
+EXPORT void f9_V_SSP_FP(struct S_FP p0, struct S_FP p1, void* p2) ;
+EXPORT void f9_V_SSP_DI(struct S_DI p0, struct S_DI p1, void* p2) ;
+EXPORT void f9_V_SSP_DF(struct S_DF p0, struct S_DF p1, void* p2) ;
+EXPORT void f9_V_SSP_DD(struct S_DD p0, struct S_DD p1, void* p2) ;
+EXPORT void f9_V_SSP_DP(struct S_DP p0, struct S_DP p1, void* p2) ;
+EXPORT void f9_V_SSP_PI(struct S_PI p0, struct S_PI p1, void* p2) ;
+EXPORT void f9_V_SSP_PF(struct S_PF p0, struct S_PF p1, void* p2) ;
+EXPORT void f9_V_SSP_PD(struct S_PD p0, struct S_PD p1, void* p2) ;
+EXPORT void f9_V_SSP_PP(struct S_PP p0, struct S_PP p1, void* p2) ;
+EXPORT void f9_V_SSP_III(struct S_III p0, struct S_III p1, void* p2) ;
+EXPORT void f9_V_SSP_IIF(struct S_IIF p0, struct S_IIF p1, void* p2) ;
+EXPORT void f9_V_SSP_IID(struct S_IID p0, struct S_IID p1, void* p2) ;
+EXPORT void f9_V_SSP_IIP(struct S_IIP p0, struct S_IIP p1, void* p2) ;
+EXPORT void f9_V_SSP_IFI(struct S_IFI p0, struct S_IFI p1, void* p2) ;
+EXPORT void f9_V_SSP_IFF(struct S_IFF p0, struct S_IFF p1, void* p2) ;
+EXPORT void f9_V_SSP_IFD(struct S_IFD p0, struct S_IFD p1, void* p2) ;
+EXPORT void f9_V_SSP_IFP(struct S_IFP p0, struct S_IFP p1, void* p2) ;
+EXPORT void f9_V_SSP_IDI(struct S_IDI p0, struct S_IDI p1, void* p2) ;
+EXPORT void f9_V_SSP_IDF(struct S_IDF p0, struct S_IDF p1, void* p2) ;
+EXPORT void f9_V_SSP_IDD(struct S_IDD p0, struct S_IDD p1, void* p2) ;
+EXPORT void f9_V_SSP_IDP(struct S_IDP p0, struct S_IDP p1, void* p2) ;
+EXPORT void f9_V_SSP_IPI(struct S_IPI p0, struct S_IPI p1, void* p2) ;
+EXPORT void f9_V_SSP_IPF(struct S_IPF p0, struct S_IPF p1, void* p2) ;
+EXPORT void f9_V_SSP_IPD(struct S_IPD p0, struct S_IPD p1, void* p2) ;
+EXPORT void f9_V_SSP_IPP(struct S_IPP p0, struct S_IPP p1, void* p2) ;
+EXPORT void f9_V_SSP_FII(struct S_FII p0, struct S_FII p1, void* p2) ;
+EXPORT void f9_V_SSP_FIF(struct S_FIF p0, struct S_FIF p1, void* p2) ;
+EXPORT void f9_V_SSP_FID(struct S_FID p0, struct S_FID p1, void* p2) ;
+EXPORT void f9_V_SSP_FIP(struct S_FIP p0, struct S_FIP p1, void* p2) ;
+EXPORT void f9_V_SSP_FFI(struct S_FFI p0, struct S_FFI p1, void* p2) ;
+EXPORT void f9_V_SSP_FFF(struct S_FFF p0, struct S_FFF p1, void* p2) ;
+EXPORT void f9_V_SSP_FFD(struct S_FFD p0, struct S_FFD p1, void* p2) ;
+EXPORT void f9_V_SSP_FFP(struct S_FFP p0, struct S_FFP p1, void* p2) ;
+EXPORT void f9_V_SSP_FDI(struct S_FDI p0, struct S_FDI p1, void* p2) ;
+EXPORT void f9_V_SSP_FDF(struct S_FDF p0, struct S_FDF p1, void* p2) ;
+EXPORT void f9_V_SSP_FDD(struct S_FDD p0, struct S_FDD p1, void* p2) ;
+EXPORT void f9_V_SSP_FDP(struct S_FDP p0, struct S_FDP p1, void* p2) ;
+EXPORT void f9_V_SSP_FPI(struct S_FPI p0, struct S_FPI p1, void* p2) ;
+EXPORT void f9_V_SSP_FPF(struct S_FPF p0, struct S_FPF p1, void* p2) ;
+EXPORT void f9_V_SSP_FPD(struct S_FPD p0, struct S_FPD p1, void* p2) ;
+EXPORT void f9_V_SSP_FPP(struct S_FPP p0, struct S_FPP p1, void* p2) ;
+EXPORT void f9_V_SSP_DII(struct S_DII p0, struct S_DII p1, void* p2) ;
+EXPORT void f9_V_SSP_DIF(struct S_DIF p0, struct S_DIF p1, void* p2) ;
+EXPORT void f9_V_SSP_DID(struct S_DID p0, struct S_DID p1, void* p2) ;
+EXPORT void f9_V_SSP_DIP(struct S_DIP p0, struct S_DIP p1, void* p2) ;
+EXPORT void f9_V_SSP_DFI(struct S_DFI p0, struct S_DFI p1, void* p2) ;
+EXPORT void f9_V_SSP_DFF(struct S_DFF p0, struct S_DFF p1, void* p2) ;
+EXPORT void f9_V_SSP_DFD(struct S_DFD p0, struct S_DFD p1, void* p2) ;
+EXPORT void f9_V_SSP_DFP(struct S_DFP p0, struct S_DFP p1, void* p2) ;
+EXPORT void f9_V_SSP_DDI(struct S_DDI p0, struct S_DDI p1, void* p2) ;
+EXPORT void f9_V_SSP_DDF(struct S_DDF p0, struct S_DDF p1, void* p2) ;
+EXPORT void f9_V_SSP_DDD(struct S_DDD p0, struct S_DDD p1, void* p2) ;
+EXPORT void f9_V_SSP_DDP(struct S_DDP p0, struct S_DDP p1, void* p2) ;
+EXPORT void f9_V_SSP_DPI(struct S_DPI p0, struct S_DPI p1, void* p2) ;
+EXPORT void f9_V_SSP_DPF(struct S_DPF p0, struct S_DPF p1, void* p2) ;
+EXPORT void f9_V_SSP_DPD(struct S_DPD p0, struct S_DPD p1, void* p2) ;
+EXPORT void f9_V_SSP_DPP(struct S_DPP p0, struct S_DPP p1, void* p2) ;
+EXPORT void f9_V_SSP_PII(struct S_PII p0, struct S_PII p1, void* p2) ;
+EXPORT void f9_V_SSP_PIF(struct S_PIF p0, struct S_PIF p1, void* p2) ;
+EXPORT void f9_V_SSP_PID(struct S_PID p0, struct S_PID p1, void* p2) ;
+EXPORT void f9_V_SSP_PIP(struct S_PIP p0, struct S_PIP p1, void* p2) ;
+EXPORT void f9_V_SSP_PFI(struct S_PFI p0, struct S_PFI p1, void* p2) ;
+EXPORT void f9_V_SSP_PFF(struct S_PFF p0, struct S_PFF p1, void* p2) ;
+EXPORT void f9_V_SSP_PFD(struct S_PFD p0, struct S_PFD p1, void* p2) ;
+EXPORT void f9_V_SSP_PFP(struct S_PFP p0, struct S_PFP p1, void* p2) ;
+EXPORT void f9_V_SSP_PDI(struct S_PDI p0, struct S_PDI p1, void* p2) ;
+EXPORT void f9_V_SSP_PDF(struct S_PDF p0, struct S_PDF p1, void* p2) ;
+EXPORT void f9_V_SSP_PDD(struct S_PDD p0, struct S_PDD p1, void* p2) ;
+EXPORT void f9_V_SSP_PDP(struct S_PDP p0, struct S_PDP p1, void* p2) ;
+EXPORT void f9_V_SSP_PPI(struct S_PPI p0, struct S_PPI p1, void* p2) ;
+EXPORT void f9_V_SSP_PPF(struct S_PPF p0, struct S_PPF p1, void* p2) ;
+EXPORT void f9_V_SSP_PPD(struct S_PPD p0, struct S_PPD p1, void* p2) ;
+EXPORT void f9_V_SSP_PPP(struct S_PPP p0, struct S_PPP p1, void* p2) ;
+EXPORT void f9_V_SSS_I(struct S_I p0, struct S_I p1, struct S_I p2) ;
+EXPORT void f9_V_SSS_F(struct S_F p0, struct S_F p1, struct S_F p2) ;
+EXPORT void f9_V_SSS_D(struct S_D p0, struct S_D p1, struct S_D p2) ;
+EXPORT void f9_V_SSS_P(struct S_P p0, struct S_P p1, struct S_P p2) ;
+EXPORT void f9_V_SSS_II(struct S_II p0, struct S_II p1, struct S_II p2) ;
+EXPORT void f9_V_SSS_IF(struct S_IF p0, struct S_IF p1, struct S_IF p2) ;
+EXPORT void f9_V_SSS_ID(struct S_ID p0, struct S_ID p1, struct S_ID p2) ;
+EXPORT void f9_V_SSS_IP(struct S_IP p0, struct S_IP p1, struct S_IP p2) ;
+EXPORT void f9_V_SSS_FI(struct S_FI p0, struct S_FI p1, struct S_FI p2) ;
+EXPORT void f9_V_SSS_FF(struct S_FF p0, struct S_FF p1, struct S_FF p2) ;
+EXPORT void f9_V_SSS_FD(struct S_FD p0, struct S_FD p1, struct S_FD p2) ;
+EXPORT void f9_V_SSS_FP(struct S_FP p0, struct S_FP p1, struct S_FP p2) ;
+EXPORT void f9_V_SSS_DI(struct S_DI p0, struct S_DI p1, struct S_DI p2) ;
+EXPORT void f9_V_SSS_DF(struct S_DF p0, struct S_DF p1, struct S_DF p2) ;
+EXPORT void f9_V_SSS_DD(struct S_DD p0, struct S_DD p1, struct S_DD p2) ;
+EXPORT void f9_V_SSS_DP(struct S_DP p0, struct S_DP p1, struct S_DP p2) ;
+EXPORT void f9_V_SSS_PI(struct S_PI p0, struct S_PI p1, struct S_PI p2) ;
+EXPORT void f9_V_SSS_PF(struct S_PF p0, struct S_PF p1, struct S_PF p2) ;
+EXPORT void f9_V_SSS_PD(struct S_PD p0, struct S_PD p1, struct S_PD p2) ;
+EXPORT void f9_V_SSS_PP(struct S_PP p0, struct S_PP p1, struct S_PP p2) ;
+EXPORT void f9_V_SSS_III(struct S_III p0, struct S_III p1, struct S_III p2) ;
+EXPORT void f9_V_SSS_IIF(struct S_IIF p0, struct S_IIF p1, struct S_IIF p2) ;
+EXPORT void f9_V_SSS_IID(struct S_IID p0, struct S_IID p1, struct S_IID p2) ;
+EXPORT void f9_V_SSS_IIP(struct S_IIP p0, struct S_IIP p1, struct S_IIP p2) ;
+EXPORT void f9_V_SSS_IFI(struct S_IFI p0, struct S_IFI p1, struct S_IFI p2) ;
+EXPORT void f9_V_SSS_IFF(struct S_IFF p0, struct S_IFF p1, struct S_IFF p2) ;
+EXPORT void f9_V_SSS_IFD(struct S_IFD p0, struct S_IFD p1, struct S_IFD p2) ;
+EXPORT void f9_V_SSS_IFP(struct S_IFP p0, struct S_IFP p1, struct S_IFP p2) ;
+EXPORT void f9_V_SSS_IDI(struct S_IDI p0, struct S_IDI p1, struct S_IDI p2) ;
+EXPORT void f9_V_SSS_IDF(struct S_IDF p0, struct S_IDF p1, struct S_IDF p2) ;
+EXPORT void f9_V_SSS_IDD(struct S_IDD p0, struct S_IDD p1, struct S_IDD p2) ;
+EXPORT void f9_V_SSS_IDP(struct S_IDP p0, struct S_IDP p1, struct S_IDP p2) ;
+EXPORT void f9_V_SSS_IPI(struct S_IPI p0, struct S_IPI p1, struct S_IPI p2) ;
+EXPORT void f9_V_SSS_IPF(struct S_IPF p0, struct S_IPF p1, struct S_IPF p2) ;
+EXPORT void f9_V_SSS_IPD(struct S_IPD p0, struct S_IPD p1, struct S_IPD p2) ;
+EXPORT void f10_V_SSS_IPP(struct S_IPP p0, struct S_IPP p1, struct S_IPP p2) ;
+EXPORT void f10_V_SSS_FII(struct S_FII p0, struct S_FII p1, struct S_FII p2) ;
+EXPORT void f10_V_SSS_FIF(struct S_FIF p0, struct S_FIF p1, struct S_FIF p2) ;
+EXPORT void f10_V_SSS_FID(struct S_FID p0, struct S_FID p1, struct S_FID p2) ;
+EXPORT void f10_V_SSS_FIP(struct S_FIP p0, struct S_FIP p1, struct S_FIP p2) ;
+EXPORT void f10_V_SSS_FFI(struct S_FFI p0, struct S_FFI p1, struct S_FFI p2) ;
+EXPORT void f10_V_SSS_FFF(struct S_FFF p0, struct S_FFF p1, struct S_FFF p2) ;
+EXPORT void f10_V_SSS_FFD(struct S_FFD p0, struct S_FFD p1, struct S_FFD p2) ;
+EXPORT void f10_V_SSS_FFP(struct S_FFP p0, struct S_FFP p1, struct S_FFP p2) ;
+EXPORT void f10_V_SSS_FDI(struct S_FDI p0, struct S_FDI p1, struct S_FDI p2) ;
+EXPORT void f10_V_SSS_FDF(struct S_FDF p0, struct S_FDF p1, struct S_FDF p2) ;
+EXPORT void f10_V_SSS_FDD(struct S_FDD p0, struct S_FDD p1, struct S_FDD p2) ;
+EXPORT void f10_V_SSS_FDP(struct S_FDP p0, struct S_FDP p1, struct S_FDP p2) ;
+EXPORT void f10_V_SSS_FPI(struct S_FPI p0, struct S_FPI p1, struct S_FPI p2) ;
+EXPORT void f10_V_SSS_FPF(struct S_FPF p0, struct S_FPF p1, struct S_FPF p2) ;
+EXPORT void f10_V_SSS_FPD(struct S_FPD p0, struct S_FPD p1, struct S_FPD p2) ;
+EXPORT void f10_V_SSS_FPP(struct S_FPP p0, struct S_FPP p1, struct S_FPP p2) ;
+EXPORT void f10_V_SSS_DII(struct S_DII p0, struct S_DII p1, struct S_DII p2) ;
+EXPORT void f10_V_SSS_DIF(struct S_DIF p0, struct S_DIF p1, struct S_DIF p2) ;
+EXPORT void f10_V_SSS_DID(struct S_DID p0, struct S_DID p1, struct S_DID p2) ;
+EXPORT void f10_V_SSS_DIP(struct S_DIP p0, struct S_DIP p1, struct S_DIP p2) ;
+EXPORT void f10_V_SSS_DFI(struct S_DFI p0, struct S_DFI p1, struct S_DFI p2) ;
+EXPORT void f10_V_SSS_DFF(struct S_DFF p0, struct S_DFF p1, struct S_DFF p2) ;
+EXPORT void f10_V_SSS_DFD(struct S_DFD p0, struct S_DFD p1, struct S_DFD p2) ;
+EXPORT void f10_V_SSS_DFP(struct S_DFP p0, struct S_DFP p1, struct S_DFP p2) ;
+EXPORT void f10_V_SSS_DDI(struct S_DDI p0, struct S_DDI p1, struct S_DDI p2) ;
+EXPORT void f10_V_SSS_DDF(struct S_DDF p0, struct S_DDF p1, struct S_DDF p2) ;
+EXPORT void f10_V_SSS_DDD(struct S_DDD p0, struct S_DDD p1, struct S_DDD p2) ;
+EXPORT void f10_V_SSS_DDP(struct S_DDP p0, struct S_DDP p1, struct S_DDP p2) ;
+EXPORT void f10_V_SSS_DPI(struct S_DPI p0, struct S_DPI p1, struct S_DPI p2) ;
+EXPORT void f10_V_SSS_DPF(struct S_DPF p0, struct S_DPF p1, struct S_DPF p2) ;
+EXPORT void f10_V_SSS_DPD(struct S_DPD p0, struct S_DPD p1, struct S_DPD p2) ;
+EXPORT void f10_V_SSS_DPP(struct S_DPP p0, struct S_DPP p1, struct S_DPP p2) ;
+EXPORT void f10_V_SSS_PII(struct S_PII p0, struct S_PII p1, struct S_PII p2) ;
+EXPORT void f10_V_SSS_PIF(struct S_PIF p0, struct S_PIF p1, struct S_PIF p2) ;
+EXPORT void f10_V_SSS_PID(struct S_PID p0, struct S_PID p1, struct S_PID p2) ;
+EXPORT void f10_V_SSS_PIP(struct S_PIP p0, struct S_PIP p1, struct S_PIP p2) ;
+EXPORT void f10_V_SSS_PFI(struct S_PFI p0, struct S_PFI p1, struct S_PFI p2) ;
+EXPORT void f10_V_SSS_PFF(struct S_PFF p0, struct S_PFF p1, struct S_PFF p2) ;
+EXPORT void f10_V_SSS_PFD(struct S_PFD p0, struct S_PFD p1, struct S_PFD p2) ;
+EXPORT void f10_V_SSS_PFP(struct S_PFP p0, struct S_PFP p1, struct S_PFP p2) ;
+EXPORT void f10_V_SSS_PDI(struct S_PDI p0, struct S_PDI p1, struct S_PDI p2) ;
+EXPORT void f10_V_SSS_PDF(struct S_PDF p0, struct S_PDF p1, struct S_PDF p2) ;
+EXPORT void f10_V_SSS_PDD(struct S_PDD p0, struct S_PDD p1, struct S_PDD p2) ;
+EXPORT void f10_V_SSS_PDP(struct S_PDP p0, struct S_PDP p1, struct S_PDP p2) ;
+EXPORT void f10_V_SSS_PPI(struct S_PPI p0, struct S_PPI p1, struct S_PPI p2) ;
+EXPORT void f10_V_SSS_PPF(struct S_PPF p0, struct S_PPF p1, struct S_PPF p2) ;
+EXPORT void f10_V_SSS_PPD(struct S_PPD p0, struct S_PPD p1, struct S_PPD p2) ;
+EXPORT void f10_V_SSS_PPP(struct S_PPP p0, struct S_PPP p1, struct S_PPP p2) ;
+EXPORT int f10_I_I_(int p0) ;
+EXPORT float f10_F_F_(float p0) ;
+EXPORT double f10_D_D_(double p0) ;
+EXPORT void* f10_P_P_(void* p0) ;
+EXPORT struct S_I f10_S_S_I(struct S_I p0) ;
+EXPORT struct S_F f10_S_S_F(struct S_F p0) ;
+EXPORT struct S_D f10_S_S_D(struct S_D p0) ;
+EXPORT struct S_P f10_S_S_P(struct S_P p0) ;
+EXPORT struct S_II f10_S_S_II(struct S_II p0) ;
+EXPORT struct S_IF f10_S_S_IF(struct S_IF p0) ;
+EXPORT struct S_ID f10_S_S_ID(struct S_ID p0) ;
+EXPORT struct S_IP f10_S_S_IP(struct S_IP p0) ;
+EXPORT struct S_FI f10_S_S_FI(struct S_FI p0) ;
+EXPORT struct S_FF f10_S_S_FF(struct S_FF p0) ;
+EXPORT struct S_FD f10_S_S_FD(struct S_FD p0) ;
+EXPORT struct S_FP f10_S_S_FP(struct S_FP p0) ;
+EXPORT struct S_DI f10_S_S_DI(struct S_DI p0) ;
+EXPORT struct S_DF f10_S_S_DF(struct S_DF p0) ;
+EXPORT struct S_DD f10_S_S_DD(struct S_DD p0) ;
+EXPORT struct S_DP f10_S_S_DP(struct S_DP p0) ;
+EXPORT struct S_PI f10_S_S_PI(struct S_PI p0) ;
+EXPORT struct S_PF f10_S_S_PF(struct S_PF p0) ;
+EXPORT struct S_PD f10_S_S_PD(struct S_PD p0) ;
+EXPORT struct S_PP f10_S_S_PP(struct S_PP p0) ;
+EXPORT struct S_III f10_S_S_III(struct S_III p0) ;
+EXPORT struct S_IIF f10_S_S_IIF(struct S_IIF p0) ;
+EXPORT struct S_IID f10_S_S_IID(struct S_IID p0) ;
+EXPORT struct S_IIP f10_S_S_IIP(struct S_IIP p0) ;
+EXPORT struct S_IFI f10_S_S_IFI(struct S_IFI p0) ;
+EXPORT struct S_IFF f10_S_S_IFF(struct S_IFF p0) ;
+EXPORT struct S_IFD f10_S_S_IFD(struct S_IFD p0) ;
+EXPORT struct S_IFP f10_S_S_IFP(struct S_IFP p0) ;
+EXPORT struct S_IDI f10_S_S_IDI(struct S_IDI p0) ;
+EXPORT struct S_IDF f10_S_S_IDF(struct S_IDF p0) ;
+EXPORT struct S_IDD f10_S_S_IDD(struct S_IDD p0) ;
+EXPORT struct S_IDP f10_S_S_IDP(struct S_IDP p0) ;
+EXPORT struct S_IPI f10_S_S_IPI(struct S_IPI p0) ;
+EXPORT struct S_IPF f10_S_S_IPF(struct S_IPF p0) ;
+EXPORT struct S_IPD f10_S_S_IPD(struct S_IPD p0) ;
+EXPORT struct S_IPP f10_S_S_IPP(struct S_IPP p0) ;
+EXPORT struct S_FII f10_S_S_FII(struct S_FII p0) ;
+EXPORT struct S_FIF f10_S_S_FIF(struct S_FIF p0) ;
+EXPORT struct S_FID f10_S_S_FID(struct S_FID p0) ;
+EXPORT struct S_FIP f10_S_S_FIP(struct S_FIP p0) ;
+EXPORT struct S_FFI f10_S_S_FFI(struct S_FFI p0) ;
+EXPORT struct S_FFF f10_S_S_FFF(struct S_FFF p0) ;
+EXPORT struct S_FFD f10_S_S_FFD(struct S_FFD p0) ;
+EXPORT struct S_FFP f10_S_S_FFP(struct S_FFP p0) ;
+EXPORT struct S_FDI f10_S_S_FDI(struct S_FDI p0) ;
+EXPORT struct S_FDF f10_S_S_FDF(struct S_FDF p0) ;
+EXPORT struct S_FDD f10_S_S_FDD(struct S_FDD p0) ;
+EXPORT struct S_FDP f10_S_S_FDP(struct S_FDP p0) ;
+EXPORT struct S_FPI f10_S_S_FPI(struct S_FPI p0) ;
+EXPORT struct S_FPF f10_S_S_FPF(struct S_FPF p0) ;
+EXPORT struct S_FPD f10_S_S_FPD(struct S_FPD p0) ;
+EXPORT struct S_FPP f10_S_S_FPP(struct S_FPP p0) ;
+EXPORT struct S_DII f10_S_S_DII(struct S_DII p0) ;
+EXPORT struct S_DIF f10_S_S_DIF(struct S_DIF p0) ;
+EXPORT struct S_DID f10_S_S_DID(struct S_DID p0) ;
+EXPORT struct S_DIP f10_S_S_DIP(struct S_DIP p0) ;
+EXPORT struct S_DFI f10_S_S_DFI(struct S_DFI p0) ;
+EXPORT struct S_DFF f10_S_S_DFF(struct S_DFF p0) ;
+EXPORT struct S_DFD f10_S_S_DFD(struct S_DFD p0) ;
+EXPORT struct S_DFP f10_S_S_DFP(struct S_DFP p0) ;
+EXPORT struct S_DDI f10_S_S_DDI(struct S_DDI p0) ;
+EXPORT struct S_DDF f10_S_S_DDF(struct S_DDF p0) ;
+EXPORT struct S_DDD f10_S_S_DDD(struct S_DDD p0) ;
+EXPORT struct S_DDP f10_S_S_DDP(struct S_DDP p0) ;
+EXPORT struct S_DPI f10_S_S_DPI(struct S_DPI p0) ;
+EXPORT struct S_DPF f10_S_S_DPF(struct S_DPF p0) ;
+EXPORT struct S_DPD f10_S_S_DPD(struct S_DPD p0) ;
+EXPORT struct S_DPP f10_S_S_DPP(struct S_DPP p0) ;
+EXPORT struct S_PII f10_S_S_PII(struct S_PII p0) ;
+EXPORT struct S_PIF f10_S_S_PIF(struct S_PIF p0) ;
+EXPORT struct S_PID f10_S_S_PID(struct S_PID p0) ;
+EXPORT struct S_PIP f10_S_S_PIP(struct S_PIP p0) ;
+EXPORT struct S_PFI f10_S_S_PFI(struct S_PFI p0) ;
+EXPORT struct S_PFF f10_S_S_PFF(struct S_PFF p0) ;
+EXPORT struct S_PFD f10_S_S_PFD(struct S_PFD p0) ;
+EXPORT struct S_PFP f10_S_S_PFP(struct S_PFP p0) ;
+EXPORT struct S_PDI f10_S_S_PDI(struct S_PDI p0) ;
+EXPORT struct S_PDF f10_S_S_PDF(struct S_PDF p0) ;
+EXPORT struct S_PDD f10_S_S_PDD(struct S_PDD p0) ;
+EXPORT struct S_PDP f10_S_S_PDP(struct S_PDP p0) ;
+EXPORT struct S_PPI f10_S_S_PPI(struct S_PPI p0) ;
+EXPORT struct S_PPF f10_S_S_PPF(struct S_PPF p0) ;
+EXPORT struct S_PPD f10_S_S_PPD(struct S_PPD p0) ;
+EXPORT struct S_PPP f10_S_S_PPP(struct S_PPP p0) ;
+EXPORT int f10_I_II_(int p0, int p1) ;
+EXPORT int f10_I_IF_(int p0, float p1) ;
+EXPORT int f10_I_ID_(int p0, double p1) ;
+EXPORT int f10_I_IP_(int p0, void* p1) ;
+EXPORT int f10_I_IS_I(int p0, struct S_I p1) ;
+EXPORT int f10_I_IS_F(int p0, struct S_F p1) ;
+EXPORT int f10_I_IS_D(int p0, struct S_D p1) ;
+EXPORT int f10_I_IS_P(int p0, struct S_P p1) ;
+EXPORT int f10_I_IS_II(int p0, struct S_II p1) ;
+EXPORT int f10_I_IS_IF(int p0, struct S_IF p1) ;
+EXPORT int f10_I_IS_ID(int p0, struct S_ID p1) ;
+EXPORT int f10_I_IS_IP(int p0, struct S_IP p1) ;
+EXPORT int f10_I_IS_FI(int p0, struct S_FI p1) ;
+EXPORT int f10_I_IS_FF(int p0, struct S_FF p1) ;
+EXPORT int f10_I_IS_FD(int p0, struct S_FD p1) ;
+EXPORT int f10_I_IS_FP(int p0, struct S_FP p1) ;
+EXPORT int f10_I_IS_DI(int p0, struct S_DI p1) ;
+EXPORT int f10_I_IS_DF(int p0, struct S_DF p1) ;
+EXPORT int f10_I_IS_DD(int p0, struct S_DD p1) ;
+EXPORT int f10_I_IS_DP(int p0, struct S_DP p1) ;
+EXPORT int f10_I_IS_PI(int p0, struct S_PI p1) ;
+EXPORT int f10_I_IS_PF(int p0, struct S_PF p1) ;
+EXPORT int f10_I_IS_PD(int p0, struct S_PD p1) ;
+EXPORT int f10_I_IS_PP(int p0, struct S_PP p1) ;
+EXPORT int f10_I_IS_III(int p0, struct S_III p1) ;
+EXPORT int f10_I_IS_IIF(int p0, struct S_IIF p1) ;
+EXPORT int f10_I_IS_IID(int p0, struct S_IID p1) ;
+EXPORT int f10_I_IS_IIP(int p0, struct S_IIP p1) ;
+EXPORT int f10_I_IS_IFI(int p0, struct S_IFI p1) ;
+EXPORT int f10_I_IS_IFF(int p0, struct S_IFF p1) ;
+EXPORT int f10_I_IS_IFD(int p0, struct S_IFD p1) ;
+EXPORT int f10_I_IS_IFP(int p0, struct S_IFP p1) ;
+EXPORT int f10_I_IS_IDI(int p0, struct S_IDI p1) ;
+EXPORT int f10_I_IS_IDF(int p0, struct S_IDF p1) ;
+EXPORT int f10_I_IS_IDD(int p0, struct S_IDD p1) ;
+EXPORT int f10_I_IS_IDP(int p0, struct S_IDP p1) ;
+EXPORT int f10_I_IS_IPI(int p0, struct S_IPI p1) ;
+EXPORT int f10_I_IS_IPF(int p0, struct S_IPF p1) ;
+EXPORT int f10_I_IS_IPD(int p0, struct S_IPD p1) ;
+EXPORT int f10_I_IS_IPP(int p0, struct S_IPP p1) ;
+EXPORT int f10_I_IS_FII(int p0, struct S_FII p1) ;
+EXPORT int f10_I_IS_FIF(int p0, struct S_FIF p1) ;
+EXPORT int f10_I_IS_FID(int p0, struct S_FID p1) ;
+EXPORT int f10_I_IS_FIP(int p0, struct S_FIP p1) ;
+EXPORT int f10_I_IS_FFI(int p0, struct S_FFI p1) ;
+EXPORT int f10_I_IS_FFF(int p0, struct S_FFF p1) ;
+EXPORT int f10_I_IS_FFD(int p0, struct S_FFD p1) ;
+EXPORT int f10_I_IS_FFP(int p0, struct S_FFP p1) ;
+EXPORT int f10_I_IS_FDI(int p0, struct S_FDI p1) ;
+EXPORT int f10_I_IS_FDF(int p0, struct S_FDF p1) ;
+EXPORT int f10_I_IS_FDD(int p0, struct S_FDD p1) ;
+EXPORT int f10_I_IS_FDP(int p0, struct S_FDP p1) ;
+EXPORT int f10_I_IS_FPI(int p0, struct S_FPI p1) ;
+EXPORT int f10_I_IS_FPF(int p0, struct S_FPF p1) ;
+EXPORT int f10_I_IS_FPD(int p0, struct S_FPD p1) ;
+EXPORT int f10_I_IS_FPP(int p0, struct S_FPP p1) ;
+EXPORT int f10_I_IS_DII(int p0, struct S_DII p1) ;
+EXPORT int f10_I_IS_DIF(int p0, struct S_DIF p1) ;
+EXPORT int f10_I_IS_DID(int p0, struct S_DID p1) ;
+EXPORT int f10_I_IS_DIP(int p0, struct S_DIP p1) ;
+EXPORT int f10_I_IS_DFI(int p0, struct S_DFI p1) ;
+EXPORT int f10_I_IS_DFF(int p0, struct S_DFF p1) ;
+EXPORT int f10_I_IS_DFD(int p0, struct S_DFD p1) ;
+EXPORT int f10_I_IS_DFP(int p0, struct S_DFP p1) ;
+EXPORT int f10_I_IS_DDI(int p0, struct S_DDI p1) ;
+EXPORT int f10_I_IS_DDF(int p0, struct S_DDF p1) ;
+EXPORT int f10_I_IS_DDD(int p0, struct S_DDD p1) ;
+EXPORT int f10_I_IS_DDP(int p0, struct S_DDP p1) ;
+EXPORT int f10_I_IS_DPI(int p0, struct S_DPI p1) ;
+EXPORT int f10_I_IS_DPF(int p0, struct S_DPF p1) ;
+EXPORT int f10_I_IS_DPD(int p0, struct S_DPD p1) ;
+EXPORT int f10_I_IS_DPP(int p0, struct S_DPP p1) ;
+EXPORT int f10_I_IS_PII(int p0, struct S_PII p1) ;
+EXPORT int f10_I_IS_PIF(int p0, struct S_PIF p1) ;
+EXPORT int f10_I_IS_PID(int p0, struct S_PID p1) ;
+EXPORT int f10_I_IS_PIP(int p0, struct S_PIP p1) ;
+EXPORT int f10_I_IS_PFI(int p0, struct S_PFI p1) ;
+EXPORT int f10_I_IS_PFF(int p0, struct S_PFF p1) ;
+EXPORT int f10_I_IS_PFD(int p0, struct S_PFD p1) ;
+EXPORT int f10_I_IS_PFP(int p0, struct S_PFP p1) ;
+EXPORT int f10_I_IS_PDI(int p0, struct S_PDI p1) ;
+EXPORT int f10_I_IS_PDF(int p0, struct S_PDF p1) ;
+EXPORT int f10_I_IS_PDD(int p0, struct S_PDD p1) ;
+EXPORT int f10_I_IS_PDP(int p0, struct S_PDP p1) ;
+EXPORT int f10_I_IS_PPI(int p0, struct S_PPI p1) ;
+EXPORT int f10_I_IS_PPF(int p0, struct S_PPF p1) ;
+EXPORT int f10_I_IS_PPD(int p0, struct S_PPD p1) ;
+EXPORT int f10_I_IS_PPP(int p0, struct S_PPP p1) ;
+EXPORT float f10_F_FI_(float p0, int p1) ;
+EXPORT float f10_F_FF_(float p0, float p1) ;
+EXPORT float f10_F_FD_(float p0, double p1) ;
+EXPORT float f10_F_FP_(float p0, void* p1) ;
+EXPORT float f10_F_FS_I(float p0, struct S_I p1) ;
+EXPORT float f10_F_FS_F(float p0, struct S_F p1) ;
+EXPORT float f10_F_FS_D(float p0, struct S_D p1) ;
+EXPORT float f10_F_FS_P(float p0, struct S_P p1) ;
+EXPORT float f10_F_FS_II(float p0, struct S_II p1) ;
+EXPORT float f10_F_FS_IF(float p0, struct S_IF p1) ;
+EXPORT float f10_F_FS_ID(float p0, struct S_ID p1) ;
+EXPORT float f10_F_FS_IP(float p0, struct S_IP p1) ;
+EXPORT float f10_F_FS_FI(float p0, struct S_FI p1) ;
+EXPORT float f10_F_FS_FF(float p0, struct S_FF p1) ;
+EXPORT float f10_F_FS_FD(float p0, struct S_FD p1) ;
+EXPORT float f10_F_FS_FP(float p0, struct S_FP p1) ;
+EXPORT float f10_F_FS_DI(float p0, struct S_DI p1) ;
+EXPORT float f10_F_FS_DF(float p0, struct S_DF p1) ;
+EXPORT float f10_F_FS_DD(float p0, struct S_DD p1) ;
+EXPORT float f10_F_FS_DP(float p0, struct S_DP p1) ;
+EXPORT float f10_F_FS_PI(float p0, struct S_PI p1) ;
+EXPORT float f10_F_FS_PF(float p0, struct S_PF p1) ;
+EXPORT float f10_F_FS_PD(float p0, struct S_PD p1) ;
+EXPORT float f10_F_FS_PP(float p0, struct S_PP p1) ;
+EXPORT float f10_F_FS_III(float p0, struct S_III p1) ;
+EXPORT float f10_F_FS_IIF(float p0, struct S_IIF p1) ;
+EXPORT float f10_F_FS_IID(float p0, struct S_IID p1) ;
+EXPORT float f10_F_FS_IIP(float p0, struct S_IIP p1) ;
+EXPORT float f10_F_FS_IFI(float p0, struct S_IFI p1) ;
+EXPORT float f10_F_FS_IFF(float p0, struct S_IFF p1) ;
+EXPORT float f10_F_FS_IFD(float p0, struct S_IFD p1) ;
+EXPORT float f10_F_FS_IFP(float p0, struct S_IFP p1) ;
+EXPORT float f10_F_FS_IDI(float p0, struct S_IDI p1) ;
+EXPORT float f10_F_FS_IDF(float p0, struct S_IDF p1) ;
+EXPORT float f10_F_FS_IDD(float p0, struct S_IDD p1) ;
+EXPORT float f10_F_FS_IDP(float p0, struct S_IDP p1) ;
+EXPORT float f10_F_FS_IPI(float p0, struct S_IPI p1) ;
+EXPORT float f10_F_FS_IPF(float p0, struct S_IPF p1) ;
+EXPORT float f10_F_FS_IPD(float p0, struct S_IPD p1) ;
+EXPORT float f10_F_FS_IPP(float p0, struct S_IPP p1) ;
+EXPORT float f10_F_FS_FII(float p0, struct S_FII p1) ;
+EXPORT float f10_F_FS_FIF(float p0, struct S_FIF p1) ;
+EXPORT float f10_F_FS_FID(float p0, struct S_FID p1) ;
+EXPORT float f10_F_FS_FIP(float p0, struct S_FIP p1) ;
+EXPORT float f10_F_FS_FFI(float p0, struct S_FFI p1) ;
+EXPORT float f10_F_FS_FFF(float p0, struct S_FFF p1) ;
+EXPORT float f10_F_FS_FFD(float p0, struct S_FFD p1) ;
+EXPORT float f10_F_FS_FFP(float p0, struct S_FFP p1) ;
+EXPORT float f10_F_FS_FDI(float p0, struct S_FDI p1) ;
+EXPORT float f10_F_FS_FDF(float p0, struct S_FDF p1) ;
+EXPORT float f10_F_FS_FDD(float p0, struct S_FDD p1) ;
+EXPORT float f10_F_FS_FDP(float p0, struct S_FDP p1) ;
+EXPORT float f10_F_FS_FPI(float p0, struct S_FPI p1) ;
+EXPORT float f10_F_FS_FPF(float p0, struct S_FPF p1) ;
+EXPORT float f10_F_FS_FPD(float p0, struct S_FPD p1) ;
+EXPORT float f10_F_FS_FPP(float p0, struct S_FPP p1) ;
+EXPORT float f10_F_FS_DII(float p0, struct S_DII p1) ;
+EXPORT float f10_F_FS_DIF(float p0, struct S_DIF p1) ;
+EXPORT float f10_F_FS_DID(float p0, struct S_DID p1) ;
+EXPORT float f10_F_FS_DIP(float p0, struct S_DIP p1) ;
+EXPORT float f10_F_FS_DFI(float p0, struct S_DFI p1) ;
+EXPORT float f10_F_FS_DFF(float p0, struct S_DFF p1) ;
+EXPORT float f10_F_FS_DFD(float p0, struct S_DFD p1) ;
+EXPORT float f10_F_FS_DFP(float p0, struct S_DFP p1) ;
+EXPORT float f10_F_FS_DDI(float p0, struct S_DDI p1) ;
+EXPORT float f10_F_FS_DDF(float p0, struct S_DDF p1) ;
+EXPORT float f10_F_FS_DDD(float p0, struct S_DDD p1) ;
+EXPORT float f10_F_FS_DDP(float p0, struct S_DDP p1) ;
+EXPORT float f10_F_FS_DPI(float p0, struct S_DPI p1) ;
+EXPORT float f10_F_FS_DPF(float p0, struct S_DPF p1) ;
+EXPORT float f10_F_FS_DPD(float p0, struct S_DPD p1) ;
+EXPORT float f10_F_FS_DPP(float p0, struct S_DPP p1) ;
+EXPORT float f10_F_FS_PII(float p0, struct S_PII p1) ;
+EXPORT float f10_F_FS_PIF(float p0, struct S_PIF p1) ;
+EXPORT float f10_F_FS_PID(float p0, struct S_PID p1) ;
+EXPORT float f10_F_FS_PIP(float p0, struct S_PIP p1) ;
+EXPORT float f10_F_FS_PFI(float p0, struct S_PFI p1) ;
+EXPORT float f10_F_FS_PFF(float p0, struct S_PFF p1) ;
+EXPORT float f10_F_FS_PFD(float p0, struct S_PFD p1) ;
+EXPORT float f10_F_FS_PFP(float p0, struct S_PFP p1) ;
+EXPORT float f10_F_FS_PDI(float p0, struct S_PDI p1) ;
+EXPORT float f10_F_FS_PDF(float p0, struct S_PDF p1) ;
+EXPORT float f10_F_FS_PDD(float p0, struct S_PDD p1) ;
+EXPORT float f10_F_FS_PDP(float p0, struct S_PDP p1) ;
+EXPORT float f10_F_FS_PPI(float p0, struct S_PPI p1) ;
+EXPORT float f10_F_FS_PPF(float p0, struct S_PPF p1) ;
+EXPORT float f10_F_FS_PPD(float p0, struct S_PPD p1) ;
+EXPORT float f10_F_FS_PPP(float p0, struct S_PPP p1) ;
+EXPORT double f10_D_DI_(double p0, int p1) ;
+EXPORT double f10_D_DF_(double p0, float p1) ;
+EXPORT double f10_D_DD_(double p0, double p1) ;
+EXPORT double f10_D_DP_(double p0, void* p1) ;
+EXPORT double f10_D_DS_I(double p0, struct S_I p1) ;
+EXPORT double f10_D_DS_F(double p0, struct S_F p1) ;
+EXPORT double f10_D_DS_D(double p0, struct S_D p1) ;
+EXPORT double f10_D_DS_P(double p0, struct S_P p1) ;
+EXPORT double f10_D_DS_II(double p0, struct S_II p1) ;
+EXPORT double f10_D_DS_IF(double p0, struct S_IF p1) ;
+EXPORT double f10_D_DS_ID(double p0, struct S_ID p1) ;
+EXPORT double f10_D_DS_IP(double p0, struct S_IP p1) ;
+EXPORT double f10_D_DS_FI(double p0, struct S_FI p1) ;
+EXPORT double f10_D_DS_FF(double p0, struct S_FF p1) ;
+EXPORT double f10_D_DS_FD(double p0, struct S_FD p1) ;
+EXPORT double f10_D_DS_FP(double p0, struct S_FP p1) ;
+EXPORT double f10_D_DS_DI(double p0, struct S_DI p1) ;
+EXPORT double f10_D_DS_DF(double p0, struct S_DF p1) ;
+EXPORT double f10_D_DS_DD(double p0, struct S_DD p1) ;
+EXPORT double f10_D_DS_DP(double p0, struct S_DP p1) ;
+EXPORT double f10_D_DS_PI(double p0, struct S_PI p1) ;
+EXPORT double f10_D_DS_PF(double p0, struct S_PF p1) ;
+EXPORT double f10_D_DS_PD(double p0, struct S_PD p1) ;
+EXPORT double f10_D_DS_PP(double p0, struct S_PP p1) ;
+EXPORT double f10_D_DS_III(double p0, struct S_III p1) ;
+EXPORT double f10_D_DS_IIF(double p0, struct S_IIF p1) ;
+EXPORT double f10_D_DS_IID(double p0, struct S_IID p1) ;
+EXPORT double f10_D_DS_IIP(double p0, struct S_IIP p1) ;
+EXPORT double f10_D_DS_IFI(double p0, struct S_IFI p1) ;
+EXPORT double f10_D_DS_IFF(double p0, struct S_IFF p1) ;
+EXPORT double f10_D_DS_IFD(double p0, struct S_IFD p1) ;
+EXPORT double f10_D_DS_IFP(double p0, struct S_IFP p1) ;
+EXPORT double f10_D_DS_IDI(double p0, struct S_IDI p1) ;
+EXPORT double f10_D_DS_IDF(double p0, struct S_IDF p1) ;
+EXPORT double f10_D_DS_IDD(double p0, struct S_IDD p1) ;
+EXPORT double f10_D_DS_IDP(double p0, struct S_IDP p1) ;
+EXPORT double f10_D_DS_IPI(double p0, struct S_IPI p1) ;
+EXPORT double f10_D_DS_IPF(double p0, struct S_IPF p1) ;
+EXPORT double f10_D_DS_IPD(double p0, struct S_IPD p1) ;
+EXPORT double f10_D_DS_IPP(double p0, struct S_IPP p1) ;
+EXPORT double f10_D_DS_FII(double p0, struct S_FII p1) ;
+EXPORT double f10_D_DS_FIF(double p0, struct S_FIF p1) ;
+EXPORT double f10_D_DS_FID(double p0, struct S_FID p1) ;
+EXPORT double f10_D_DS_FIP(double p0, struct S_FIP p1) ;
+EXPORT double f10_D_DS_FFI(double p0, struct S_FFI p1) ;
+EXPORT double f10_D_DS_FFF(double p0, struct S_FFF p1) ;
+EXPORT double f10_D_DS_FFD(double p0, struct S_FFD p1) ;
+EXPORT double f10_D_DS_FFP(double p0, struct S_FFP p1) ;
+EXPORT double f10_D_DS_FDI(double p0, struct S_FDI p1) ;
+EXPORT double f10_D_DS_FDF(double p0, struct S_FDF p1) ;
+EXPORT double f10_D_DS_FDD(double p0, struct S_FDD p1) ;
+EXPORT double f10_D_DS_FDP(double p0, struct S_FDP p1) ;
+EXPORT double f10_D_DS_FPI(double p0, struct S_FPI p1) ;
+EXPORT double f10_D_DS_FPF(double p0, struct S_FPF p1) ;
+EXPORT double f10_D_DS_FPD(double p0, struct S_FPD p1) ;
+EXPORT double f10_D_DS_FPP(double p0, struct S_FPP p1) ;
+EXPORT double f10_D_DS_DII(double p0, struct S_DII p1) ;
+EXPORT double f10_D_DS_DIF(double p0, struct S_DIF p1) ;
+EXPORT double f10_D_DS_DID(double p0, struct S_DID p1) ;
+EXPORT double f10_D_DS_DIP(double p0, struct S_DIP p1) ;
+EXPORT double f10_D_DS_DFI(double p0, struct S_DFI p1) ;
+EXPORT double f10_D_DS_DFF(double p0, struct S_DFF p1) ;
+EXPORT double f10_D_DS_DFD(double p0, struct S_DFD p1) ;
+EXPORT double f10_D_DS_DFP(double p0, struct S_DFP p1) ;
+EXPORT double f10_D_DS_DDI(double p0, struct S_DDI p1) ;
+EXPORT double f10_D_DS_DDF(double p0, struct S_DDF p1) ;
+EXPORT double f10_D_DS_DDD(double p0, struct S_DDD p1) ;
+EXPORT double f10_D_DS_DDP(double p0, struct S_DDP p1) ;
+EXPORT double f10_D_DS_DPI(double p0, struct S_DPI p1) ;
+EXPORT double f10_D_DS_DPF(double p0, struct S_DPF p1) ;
+EXPORT double f10_D_DS_DPD(double p0, struct S_DPD p1) ;
+EXPORT double f10_D_DS_DPP(double p0, struct S_DPP p1) ;
+EXPORT double f10_D_DS_PII(double p0, struct S_PII p1) ;
+EXPORT double f10_D_DS_PIF(double p0, struct S_PIF p1) ;
+EXPORT double f10_D_DS_PID(double p0, struct S_PID p1) ;
+EXPORT double f10_D_DS_PIP(double p0, struct S_PIP p1) ;
+EXPORT double f10_D_DS_PFI(double p0, struct S_PFI p1) ;
+EXPORT double f10_D_DS_PFF(double p0, struct S_PFF p1) ;
+EXPORT double f10_D_DS_PFD(double p0, struct S_PFD p1) ;
+EXPORT double f10_D_DS_PFP(double p0, struct S_PFP p1) ;
+EXPORT double f10_D_DS_PDI(double p0, struct S_PDI p1) ;
+EXPORT double f10_D_DS_PDF(double p0, struct S_PDF p1) ;
+EXPORT double f10_D_DS_PDD(double p0, struct S_PDD p1) ;
+EXPORT double f10_D_DS_PDP(double p0, struct S_PDP p1) ;
+EXPORT double f10_D_DS_PPI(double p0, struct S_PPI p1) ;
+EXPORT double f10_D_DS_PPF(double p0, struct S_PPF p1) ;
+EXPORT double f10_D_DS_PPD(double p0, struct S_PPD p1) ;
+EXPORT double f10_D_DS_PPP(double p0, struct S_PPP p1) ;
+EXPORT void* f10_P_PI_(void* p0, int p1) ;
+EXPORT void* f10_P_PF_(void* p0, float p1) ;
+EXPORT void* f10_P_PD_(void* p0, double p1) ;
+EXPORT void* f10_P_PP_(void* p0, void* p1) ;
+EXPORT void* f10_P_PS_I(void* p0, struct S_I p1) ;
+EXPORT void* f10_P_PS_F(void* p0, struct S_F p1) ;
+EXPORT void* f10_P_PS_D(void* p0, struct S_D p1) ;
+EXPORT void* f10_P_PS_P(void* p0, struct S_P p1) ;
+EXPORT void* f10_P_PS_II(void* p0, struct S_II p1) ;
+EXPORT void* f10_P_PS_IF(void* p0, struct S_IF p1) ;
+EXPORT void* f10_P_PS_ID(void* p0, struct S_ID p1) ;
+EXPORT void* f10_P_PS_IP(void* p0, struct S_IP p1) ;
+EXPORT void* f10_P_PS_FI(void* p0, struct S_FI p1) ;
+EXPORT void* f10_P_PS_FF(void* p0, struct S_FF p1) ;
+EXPORT void* f10_P_PS_FD(void* p0, struct S_FD p1) ;
+EXPORT void* f10_P_PS_FP(void* p0, struct S_FP p1) ;
+EXPORT void* f10_P_PS_DI(void* p0, struct S_DI p1) ;
+EXPORT void* f10_P_PS_DF(void* p0, struct S_DF p1) ;
+EXPORT void* f10_P_PS_DD(void* p0, struct S_DD p1) ;
+EXPORT void* f10_P_PS_DP(void* p0, struct S_DP p1) ;
+EXPORT void* f10_P_PS_PI(void* p0, struct S_PI p1) ;
+EXPORT void* f10_P_PS_PF(void* p0, struct S_PF p1) ;
+EXPORT void* f10_P_PS_PD(void* p0, struct S_PD p1) ;
+EXPORT void* f10_P_PS_PP(void* p0, struct S_PP p1) ;
+EXPORT void* f10_P_PS_III(void* p0, struct S_III p1) ;
+EXPORT void* f10_P_PS_IIF(void* p0, struct S_IIF p1) ;
+EXPORT void* f10_P_PS_IID(void* p0, struct S_IID p1) ;
+EXPORT void* f10_P_PS_IIP(void* p0, struct S_IIP p1) ;
+EXPORT void* f10_P_PS_IFI(void* p0, struct S_IFI p1) ;
+EXPORT void* f10_P_PS_IFF(void* p0, struct S_IFF p1) ;
+EXPORT void* f10_P_PS_IFD(void* p0, struct S_IFD p1) ;
+EXPORT void* f10_P_PS_IFP(void* p0, struct S_IFP p1) ;
+EXPORT void* f10_P_PS_IDI(void* p0, struct S_IDI p1) ;
+EXPORT void* f10_P_PS_IDF(void* p0, struct S_IDF p1) ;
+EXPORT void* f10_P_PS_IDD(void* p0, struct S_IDD p1) ;
+EXPORT void* f10_P_PS_IDP(void* p0, struct S_IDP p1) ;
+EXPORT void* f10_P_PS_IPI(void* p0, struct S_IPI p1) ;
+EXPORT void* f10_P_PS_IPF(void* p0, struct S_IPF p1) ;
+EXPORT void* f10_P_PS_IPD(void* p0, struct S_IPD p1) ;
+EXPORT void* f10_P_PS_IPP(void* p0, struct S_IPP p1) ;
+EXPORT void* f10_P_PS_FII(void* p0, struct S_FII p1) ;
+EXPORT void* f10_P_PS_FIF(void* p0, struct S_FIF p1) ;
+EXPORT void* f10_P_PS_FID(void* p0, struct S_FID p1) ;
+EXPORT void* f10_P_PS_FIP(void* p0, struct S_FIP p1) ;
+EXPORT void* f10_P_PS_FFI(void* p0, struct S_FFI p1) ;
+EXPORT void* f10_P_PS_FFF(void* p0, struct S_FFF p1) ;
+EXPORT void* f10_P_PS_FFD(void* p0, struct S_FFD p1) ;
+EXPORT void* f10_P_PS_FFP(void* p0, struct S_FFP p1) ;
+EXPORT void* f10_P_PS_FDI(void* p0, struct S_FDI p1) ;
+EXPORT void* f10_P_PS_FDF(void* p0, struct S_FDF p1) ;
+EXPORT void* f10_P_PS_FDD(void* p0, struct S_FDD p1) ;
+EXPORT void* f10_P_PS_FDP(void* p0, struct S_FDP p1) ;
+EXPORT void* f10_P_PS_FPI(void* p0, struct S_FPI p1) ;
+EXPORT void* f10_P_PS_FPF(void* p0, struct S_FPF p1) ;
+EXPORT void* f10_P_PS_FPD(void* p0, struct S_FPD p1) ;
+EXPORT void* f10_P_PS_FPP(void* p0, struct S_FPP p1) ;
+EXPORT void* f10_P_PS_DII(void* p0, struct S_DII p1) ;
+EXPORT void* f10_P_PS_DIF(void* p0, struct S_DIF p1) ;
+EXPORT void* f10_P_PS_DID(void* p0, struct S_DID p1) ;
+EXPORT void* f10_P_PS_DIP(void* p0, struct S_DIP p1) ;
+EXPORT void* f10_P_PS_DFI(void* p0, struct S_DFI p1) ;
+EXPORT void* f10_P_PS_DFF(void* p0, struct S_DFF p1) ;
+EXPORT void* f10_P_PS_DFD(void* p0, struct S_DFD p1) ;
+EXPORT void* f10_P_PS_DFP(void* p0, struct S_DFP p1) ;
+EXPORT void* f10_P_PS_DDI(void* p0, struct S_DDI p1) ;
+EXPORT void* f10_P_PS_DDF(void* p0, struct S_DDF p1) ;
+EXPORT void* f10_P_PS_DDD(void* p0, struct S_DDD p1) ;
+EXPORT void* f10_P_PS_DDP(void* p0, struct S_DDP p1) ;
+EXPORT void* f10_P_PS_DPI(void* p0, struct S_DPI p1) ;
+EXPORT void* f10_P_PS_DPF(void* p0, struct S_DPF p1) ;
+EXPORT void* f10_P_PS_DPD(void* p0, struct S_DPD p1) ;
+EXPORT void* f10_P_PS_DPP(void* p0, struct S_DPP p1) ;
+EXPORT void* f10_P_PS_PII(void* p0, struct S_PII p1) ;
+EXPORT void* f10_P_PS_PIF(void* p0, struct S_PIF p1) ;
+EXPORT void* f10_P_PS_PID(void* p0, struct S_PID p1) ;
+EXPORT void* f10_P_PS_PIP(void* p0, struct S_PIP p1) ;
+EXPORT void* f10_P_PS_PFI(void* p0, struct S_PFI p1) ;
+EXPORT void* f10_P_PS_PFF(void* p0, struct S_PFF p1) ;
+EXPORT void* f10_P_PS_PFD(void* p0, struct S_PFD p1) ;
+EXPORT void* f10_P_PS_PFP(void* p0, struct S_PFP p1) ;
+EXPORT void* f10_P_PS_PDI(void* p0, struct S_PDI p1) ;
+EXPORT void* f10_P_PS_PDF(void* p0, struct S_PDF p1) ;
+EXPORT void* f10_P_PS_PDD(void* p0, struct S_PDD p1) ;
+EXPORT void* f10_P_PS_PDP(void* p0, struct S_PDP p1) ;
+EXPORT void* f10_P_PS_PPI(void* p0, struct S_PPI p1) ;
+EXPORT void* f10_P_PS_PPF(void* p0, struct S_PPF p1) ;
+EXPORT void* f10_P_PS_PPD(void* p0, struct S_PPD p1) ;
+EXPORT void* f10_P_PS_PPP(void* p0, struct S_PPP p1) ;
+EXPORT struct S_I f10_S_SI_I(struct S_I p0, int p1) ;
+EXPORT struct S_F f10_S_SI_F(struct S_F p0, int p1) ;
+EXPORT struct S_D f10_S_SI_D(struct S_D p0, int p1) ;
+EXPORT struct S_P f10_S_SI_P(struct S_P p0, int p1) ;
+EXPORT struct S_II f10_S_SI_II(struct S_II p0, int p1) ;
+EXPORT struct S_IF f10_S_SI_IF(struct S_IF p0, int p1) ;
+EXPORT struct S_ID f10_S_SI_ID(struct S_ID p0, int p1) ;
+EXPORT struct S_IP f10_S_SI_IP(struct S_IP p0, int p1) ;
+EXPORT struct S_FI f10_S_SI_FI(struct S_FI p0, int p1) ;
+EXPORT struct S_FF f10_S_SI_FF(struct S_FF p0, int p1) ;
+EXPORT struct S_FD f10_S_SI_FD(struct S_FD p0, int p1) ;
+EXPORT struct S_FP f10_S_SI_FP(struct S_FP p0, int p1) ;
+EXPORT struct S_DI f10_S_SI_DI(struct S_DI p0, int p1) ;
+EXPORT struct S_DF f10_S_SI_DF(struct S_DF p0, int p1) ;
+EXPORT struct S_DD f10_S_SI_DD(struct S_DD p0, int p1) ;
+EXPORT struct S_DP f10_S_SI_DP(struct S_DP p0, int p1) ;
+EXPORT struct S_PI f10_S_SI_PI(struct S_PI p0, int p1) ;
+EXPORT struct S_PF f10_S_SI_PF(struct S_PF p0, int p1) ;
+EXPORT struct S_PD f10_S_SI_PD(struct S_PD p0, int p1) ;
+EXPORT struct S_PP f10_S_SI_PP(struct S_PP p0, int p1) ;
+EXPORT struct S_III f10_S_SI_III(struct S_III p0, int p1) ;
+EXPORT struct S_IIF f10_S_SI_IIF(struct S_IIF p0, int p1) ;
+EXPORT struct S_IID f10_S_SI_IID(struct S_IID p0, int p1) ;
+EXPORT struct S_IIP f10_S_SI_IIP(struct S_IIP p0, int p1) ;
+EXPORT struct S_IFI f10_S_SI_IFI(struct S_IFI p0, int p1) ;
+EXPORT struct S_IFF f10_S_SI_IFF(struct S_IFF p0, int p1) ;
+EXPORT struct S_IFD f10_S_SI_IFD(struct S_IFD p0, int p1) ;
+EXPORT struct S_IFP f10_S_SI_IFP(struct S_IFP p0, int p1) ;
+EXPORT struct S_IDI f10_S_SI_IDI(struct S_IDI p0, int p1) ;
+EXPORT struct S_IDF f10_S_SI_IDF(struct S_IDF p0, int p1) ;
+EXPORT struct S_IDD f10_S_SI_IDD(struct S_IDD p0, int p1) ;
+EXPORT struct S_IDP f10_S_SI_IDP(struct S_IDP p0, int p1) ;
+EXPORT struct S_IPI f10_S_SI_IPI(struct S_IPI p0, int p1) ;
+EXPORT struct S_IPF f10_S_SI_IPF(struct S_IPF p0, int p1) ;
+EXPORT struct S_IPD f10_S_SI_IPD(struct S_IPD p0, int p1) ;
+EXPORT struct S_IPP f10_S_SI_IPP(struct S_IPP p0, int p1) ;
+EXPORT struct S_FII f10_S_SI_FII(struct S_FII p0, int p1) ;
+EXPORT struct S_FIF f10_S_SI_FIF(struct S_FIF p0, int p1) ;
+EXPORT struct S_FID f10_S_SI_FID(struct S_FID p0, int p1) ;
+EXPORT struct S_FIP f10_S_SI_FIP(struct S_FIP p0, int p1) ;
+EXPORT struct S_FFI f10_S_SI_FFI(struct S_FFI p0, int p1) ;
+EXPORT struct S_FFF f10_S_SI_FFF(struct S_FFF p0, int p1) ;
+EXPORT struct S_FFD f10_S_SI_FFD(struct S_FFD p0, int p1) ;
+EXPORT struct S_FFP f10_S_SI_FFP(struct S_FFP p0, int p1) ;
+EXPORT struct S_FDI f10_S_SI_FDI(struct S_FDI p0, int p1) ;
+EXPORT struct S_FDF f10_S_SI_FDF(struct S_FDF p0, int p1) ;
+EXPORT struct S_FDD f10_S_SI_FDD(struct S_FDD p0, int p1) ;
+EXPORT struct S_FDP f10_S_SI_FDP(struct S_FDP p0, int p1) ;
+EXPORT struct S_FPI f10_S_SI_FPI(struct S_FPI p0, int p1) ;
+EXPORT struct S_FPF f10_S_SI_FPF(struct S_FPF p0, int p1) ;
+EXPORT struct S_FPD f10_S_SI_FPD(struct S_FPD p0, int p1) ;
+EXPORT struct S_FPP f10_S_SI_FPP(struct S_FPP p0, int p1) ;
+EXPORT struct S_DII f10_S_SI_DII(struct S_DII p0, int p1) ;
+EXPORT struct S_DIF f10_S_SI_DIF(struct S_DIF p0, int p1) ;
+EXPORT struct S_DID f10_S_SI_DID(struct S_DID p0, int p1) ;
+EXPORT struct S_DIP f10_S_SI_DIP(struct S_DIP p0, int p1) ;
+EXPORT struct S_DFI f10_S_SI_DFI(struct S_DFI p0, int p1) ;
+EXPORT struct S_DFF f10_S_SI_DFF(struct S_DFF p0, int p1) ;
+EXPORT struct S_DFD f10_S_SI_DFD(struct S_DFD p0, int p1) ;
+EXPORT struct S_DFP f10_S_SI_DFP(struct S_DFP p0, int p1) ;
+EXPORT struct S_DDI f10_S_SI_DDI(struct S_DDI p0, int p1) ;
+EXPORT struct S_DDF f10_S_SI_DDF(struct S_DDF p0, int p1) ;
+EXPORT struct S_DDD f10_S_SI_DDD(struct S_DDD p0, int p1) ;
+EXPORT struct S_DDP f10_S_SI_DDP(struct S_DDP p0, int p1) ;
+EXPORT struct S_DPI f10_S_SI_DPI(struct S_DPI p0, int p1) ;
+EXPORT struct S_DPF f10_S_SI_DPF(struct S_DPF p0, int p1) ;
+EXPORT struct S_DPD f10_S_SI_DPD(struct S_DPD p0, int p1) ;
+EXPORT struct S_DPP f10_S_SI_DPP(struct S_DPP p0, int p1) ;
+EXPORT struct S_PII f10_S_SI_PII(struct S_PII p0, int p1) ;
+EXPORT struct S_PIF f10_S_SI_PIF(struct S_PIF p0, int p1) ;
+EXPORT struct S_PID f10_S_SI_PID(struct S_PID p0, int p1) ;
+EXPORT struct S_PIP f10_S_SI_PIP(struct S_PIP p0, int p1) ;
+EXPORT struct S_PFI f10_S_SI_PFI(struct S_PFI p0, int p1) ;
+EXPORT struct S_PFF f10_S_SI_PFF(struct S_PFF p0, int p1) ;
+EXPORT struct S_PFD f10_S_SI_PFD(struct S_PFD p0, int p1) ;
+EXPORT struct S_PFP f10_S_SI_PFP(struct S_PFP p0, int p1) ;
+EXPORT struct S_PDI f10_S_SI_PDI(struct S_PDI p0, int p1) ;
+EXPORT struct S_PDF f10_S_SI_PDF(struct S_PDF p0, int p1) ;
+EXPORT struct S_PDD f10_S_SI_PDD(struct S_PDD p0, int p1) ;
+EXPORT struct S_PDP f10_S_SI_PDP(struct S_PDP p0, int p1) ;
+EXPORT struct S_PPI f10_S_SI_PPI(struct S_PPI p0, int p1) ;
+EXPORT struct S_PPF f10_S_SI_PPF(struct S_PPF p0, int p1) ;
+EXPORT struct S_PPD f10_S_SI_PPD(struct S_PPD p0, int p1) ;
+EXPORT struct S_PPP f10_S_SI_PPP(struct S_PPP p0, int p1) ;
+EXPORT struct S_I f10_S_SF_I(struct S_I p0, float p1) ;
+EXPORT struct S_F f10_S_SF_F(struct S_F p0, float p1) ;
+EXPORT struct S_D f10_S_SF_D(struct S_D p0, float p1) ;
+EXPORT struct S_P f10_S_SF_P(struct S_P p0, float p1) ;
+EXPORT struct S_II f10_S_SF_II(struct S_II p0, float p1) ;
+EXPORT struct S_IF f10_S_SF_IF(struct S_IF p0, float p1) ;
+EXPORT struct S_ID f10_S_SF_ID(struct S_ID p0, float p1) ;
+EXPORT struct S_IP f10_S_SF_IP(struct S_IP p0, float p1) ;
+EXPORT struct S_FI f10_S_SF_FI(struct S_FI p0, float p1) ;
+EXPORT struct S_FF f10_S_SF_FF(struct S_FF p0, float p1) ;
+EXPORT struct S_FD f10_S_SF_FD(struct S_FD p0, float p1) ;
+EXPORT struct S_FP f10_S_SF_FP(struct S_FP p0, float p1) ;
+EXPORT struct S_DI f10_S_SF_DI(struct S_DI p0, float p1) ;
+EXPORT struct S_DF f10_S_SF_DF(struct S_DF p0, float p1) ;
+EXPORT struct S_DD f10_S_SF_DD(struct S_DD p0, float p1) ;
+EXPORT struct S_DP f10_S_SF_DP(struct S_DP p0, float p1) ;
+EXPORT struct S_PI f10_S_SF_PI(struct S_PI p0, float p1) ;
+EXPORT struct S_PF f10_S_SF_PF(struct S_PF p0, float p1) ;
+EXPORT struct S_PD f10_S_SF_PD(struct S_PD p0, float p1) ;
+EXPORT struct S_PP f10_S_SF_PP(struct S_PP p0, float p1) ;
+EXPORT struct S_III f10_S_SF_III(struct S_III p0, float p1) ;
+EXPORT struct S_IIF f10_S_SF_IIF(struct S_IIF p0, float p1) ;
+EXPORT struct S_IID f10_S_SF_IID(struct S_IID p0, float p1) ;
+EXPORT struct S_IIP f10_S_SF_IIP(struct S_IIP p0, float p1) ;
+EXPORT struct S_IFI f10_S_SF_IFI(struct S_IFI p0, float p1) ;
+EXPORT struct S_IFF f10_S_SF_IFF(struct S_IFF p0, float p1) ;
+EXPORT struct S_IFD f10_S_SF_IFD(struct S_IFD p0, float p1) ;
+EXPORT struct S_IFP f11_S_SF_IFP(struct S_IFP p0, float p1) ;
+EXPORT struct S_IDI f11_S_SF_IDI(struct S_IDI p0, float p1) ;
+EXPORT struct S_IDF f11_S_SF_IDF(struct S_IDF p0, float p1) ;
+EXPORT struct S_IDD f11_S_SF_IDD(struct S_IDD p0, float p1) ;
+EXPORT struct S_IDP f11_S_SF_IDP(struct S_IDP p0, float p1) ;
+EXPORT struct S_IPI f11_S_SF_IPI(struct S_IPI p0, float p1) ;
+EXPORT struct S_IPF f11_S_SF_IPF(struct S_IPF p0, float p1) ;
+EXPORT struct S_IPD f11_S_SF_IPD(struct S_IPD p0, float p1) ;
+EXPORT struct S_IPP f11_S_SF_IPP(struct S_IPP p0, float p1) ;
+EXPORT struct S_FII f11_S_SF_FII(struct S_FII p0, float p1) ;
+EXPORT struct S_FIF f11_S_SF_FIF(struct S_FIF p0, float p1) ;
+EXPORT struct S_FID f11_S_SF_FID(struct S_FID p0, float p1) ;
+EXPORT struct S_FIP f11_S_SF_FIP(struct S_FIP p0, float p1) ;
+EXPORT struct S_FFI f11_S_SF_FFI(struct S_FFI p0, float p1) ;
+EXPORT struct S_FFF f11_S_SF_FFF(struct S_FFF p0, float p1) ;
+EXPORT struct S_FFD f11_S_SF_FFD(struct S_FFD p0, float p1) ;
+EXPORT struct S_FFP f11_S_SF_FFP(struct S_FFP p0, float p1) ;
+EXPORT struct S_FDI f11_S_SF_FDI(struct S_FDI p0, float p1) ;
+EXPORT struct S_FDF f11_S_SF_FDF(struct S_FDF p0, float p1) ;
+EXPORT struct S_FDD f11_S_SF_FDD(struct S_FDD p0, float p1) ;
+EXPORT struct S_FDP f11_S_SF_FDP(struct S_FDP p0, float p1) ;
+EXPORT struct S_FPI f11_S_SF_FPI(struct S_FPI p0, float p1) ;
+EXPORT struct S_FPF f11_S_SF_FPF(struct S_FPF p0, float p1) ;
+EXPORT struct S_FPD f11_S_SF_FPD(struct S_FPD p0, float p1) ;
+EXPORT struct S_FPP f11_S_SF_FPP(struct S_FPP p0, float p1) ;
+EXPORT struct S_DII f11_S_SF_DII(struct S_DII p0, float p1) ;
+EXPORT struct S_DIF f11_S_SF_DIF(struct S_DIF p0, float p1) ;
+EXPORT struct S_DID f11_S_SF_DID(struct S_DID p0, float p1) ;
+EXPORT struct S_DIP f11_S_SF_DIP(struct S_DIP p0, float p1) ;
+EXPORT struct S_DFI f11_S_SF_DFI(struct S_DFI p0, float p1) ;
+EXPORT struct S_DFF f11_S_SF_DFF(struct S_DFF p0, float p1) ;
+EXPORT struct S_DFD f11_S_SF_DFD(struct S_DFD p0, float p1) ;
+EXPORT struct S_DFP f11_S_SF_DFP(struct S_DFP p0, float p1) ;
+EXPORT struct S_DDI f11_S_SF_DDI(struct S_DDI p0, float p1) ;
+EXPORT struct S_DDF f11_S_SF_DDF(struct S_DDF p0, float p1) ;
+EXPORT struct S_DDD f11_S_SF_DDD(struct S_DDD p0, float p1) ;
+EXPORT struct S_DDP f11_S_SF_DDP(struct S_DDP p0, float p1) ;
+EXPORT struct S_DPI f11_S_SF_DPI(struct S_DPI p0, float p1) ;
+EXPORT struct S_DPF f11_S_SF_DPF(struct S_DPF p0, float p1) ;
+EXPORT struct S_DPD f11_S_SF_DPD(struct S_DPD p0, float p1) ;
+EXPORT struct S_DPP f11_S_SF_DPP(struct S_DPP p0, float p1) ;
+EXPORT struct S_PII f11_S_SF_PII(struct S_PII p0, float p1) ;
+EXPORT struct S_PIF f11_S_SF_PIF(struct S_PIF p0, float p1) ;
+EXPORT struct S_PID f11_S_SF_PID(struct S_PID p0, float p1) ;
+EXPORT struct S_PIP f11_S_SF_PIP(struct S_PIP p0, float p1) ;
+EXPORT struct S_PFI f11_S_SF_PFI(struct S_PFI p0, float p1) ;
+EXPORT struct S_PFF f11_S_SF_PFF(struct S_PFF p0, float p1) ;
+EXPORT struct S_PFD f11_S_SF_PFD(struct S_PFD p0, float p1) ;
+EXPORT struct S_PFP f11_S_SF_PFP(struct S_PFP p0, float p1) ;
+EXPORT struct S_PDI f11_S_SF_PDI(struct S_PDI p0, float p1) ;
+EXPORT struct S_PDF f11_S_SF_PDF(struct S_PDF p0, float p1) ;
+EXPORT struct S_PDD f11_S_SF_PDD(struct S_PDD p0, float p1) ;
+EXPORT struct S_PDP f11_S_SF_PDP(struct S_PDP p0, float p1) ;
+EXPORT struct S_PPI f11_S_SF_PPI(struct S_PPI p0, float p1) ;
+EXPORT struct S_PPF f11_S_SF_PPF(struct S_PPF p0, float p1) ;
+EXPORT struct S_PPD f11_S_SF_PPD(struct S_PPD p0, float p1) ;
+EXPORT struct S_PPP f11_S_SF_PPP(struct S_PPP p0, float p1) ;
+EXPORT struct S_I f11_S_SD_I(struct S_I p0, double p1) ;
+EXPORT struct S_F f11_S_SD_F(struct S_F p0, double p1) ;
+EXPORT struct S_D f11_S_SD_D(struct S_D p0, double p1) ;
+EXPORT struct S_P f11_S_SD_P(struct S_P p0, double p1) ;
+EXPORT struct S_II f11_S_SD_II(struct S_II p0, double p1) ;
+EXPORT struct S_IF f11_S_SD_IF(struct S_IF p0, double p1) ;
+EXPORT struct S_ID f11_S_SD_ID(struct S_ID p0, double p1) ;
+EXPORT struct S_IP f11_S_SD_IP(struct S_IP p0, double p1) ;
+EXPORT struct S_FI f11_S_SD_FI(struct S_FI p0, double p1) ;
+EXPORT struct S_FF f11_S_SD_FF(struct S_FF p0, double p1) ;
+EXPORT struct S_FD f11_S_SD_FD(struct S_FD p0, double p1) ;
+EXPORT struct S_FP f11_S_SD_FP(struct S_FP p0, double p1) ;
+EXPORT struct S_DI f11_S_SD_DI(struct S_DI p0, double p1) ;
+EXPORT struct S_DF f11_S_SD_DF(struct S_DF p0, double p1) ;
+EXPORT struct S_DD f11_S_SD_DD(struct S_DD p0, double p1) ;
+EXPORT struct S_DP f11_S_SD_DP(struct S_DP p0, double p1) ;
+EXPORT struct S_PI f11_S_SD_PI(struct S_PI p0, double p1) ;
+EXPORT struct S_PF f11_S_SD_PF(struct S_PF p0, double p1) ;
+EXPORT struct S_PD f11_S_SD_PD(struct S_PD p0, double p1) ;
+EXPORT struct S_PP f11_S_SD_PP(struct S_PP p0, double p1) ;
+EXPORT struct S_III f11_S_SD_III(struct S_III p0, double p1) ;
+EXPORT struct S_IIF f11_S_SD_IIF(struct S_IIF p0, double p1) ;
+EXPORT struct S_IID f11_S_SD_IID(struct S_IID p0, double p1) ;
+EXPORT struct S_IIP f11_S_SD_IIP(struct S_IIP p0, double p1) ;
+EXPORT struct S_IFI f11_S_SD_IFI(struct S_IFI p0, double p1) ;
+EXPORT struct S_IFF f11_S_SD_IFF(struct S_IFF p0, double p1) ;
+EXPORT struct S_IFD f11_S_SD_IFD(struct S_IFD p0, double p1) ;
+EXPORT struct S_IFP f11_S_SD_IFP(struct S_IFP p0, double p1) ;
+EXPORT struct S_IDI f11_S_SD_IDI(struct S_IDI p0, double p1) ;
+EXPORT struct S_IDF f11_S_SD_IDF(struct S_IDF p0, double p1) ;
+EXPORT struct S_IDD f11_S_SD_IDD(struct S_IDD p0, double p1) ;
+EXPORT struct S_IDP f11_S_SD_IDP(struct S_IDP p0, double p1) ;
+EXPORT struct S_IPI f11_S_SD_IPI(struct S_IPI p0, double p1) ;
+EXPORT struct S_IPF f11_S_SD_IPF(struct S_IPF p0, double p1) ;
+EXPORT struct S_IPD f11_S_SD_IPD(struct S_IPD p0, double p1) ;
+EXPORT struct S_IPP f11_S_SD_IPP(struct S_IPP p0, double p1) ;
+EXPORT struct S_FII f11_S_SD_FII(struct S_FII p0, double p1) ;
+EXPORT struct S_FIF f11_S_SD_FIF(struct S_FIF p0, double p1) ;
+EXPORT struct S_FID f11_S_SD_FID(struct S_FID p0, double p1) ;
+EXPORT struct S_FIP f11_S_SD_FIP(struct S_FIP p0, double p1) ;
+EXPORT struct S_FFI f11_S_SD_FFI(struct S_FFI p0, double p1) ;
+EXPORT struct S_FFF f11_S_SD_FFF(struct S_FFF p0, double p1) ;
+EXPORT struct S_FFD f11_S_SD_FFD(struct S_FFD p0, double p1) ;
+EXPORT struct S_FFP f11_S_SD_FFP(struct S_FFP p0, double p1) ;
+EXPORT struct S_FDI f11_S_SD_FDI(struct S_FDI p0, double p1) ;
+EXPORT struct S_FDF f11_S_SD_FDF(struct S_FDF p0, double p1) ;
+EXPORT struct S_FDD f11_S_SD_FDD(struct S_FDD p0, double p1) ;
+EXPORT struct S_FDP f11_S_SD_FDP(struct S_FDP p0, double p1) ;
+EXPORT struct S_FPI f11_S_SD_FPI(struct S_FPI p0, double p1) ;
+EXPORT struct S_FPF f11_S_SD_FPF(struct S_FPF p0, double p1) ;
+EXPORT struct S_FPD f11_S_SD_FPD(struct S_FPD p0, double p1) ;
+EXPORT struct S_FPP f11_S_SD_FPP(struct S_FPP p0, double p1) ;
+EXPORT struct S_DII f11_S_SD_DII(struct S_DII p0, double p1) ;
+EXPORT struct S_DIF f11_S_SD_DIF(struct S_DIF p0, double p1) ;
+EXPORT struct S_DID f11_S_SD_DID(struct S_DID p0, double p1) ;
+EXPORT struct S_DIP f11_S_SD_DIP(struct S_DIP p0, double p1) ;
+EXPORT struct S_DFI f11_S_SD_DFI(struct S_DFI p0, double p1) ;
+EXPORT struct S_DFF f11_S_SD_DFF(struct S_DFF p0, double p1) ;
+EXPORT struct S_DFD f11_S_SD_DFD(struct S_DFD p0, double p1) ;
+EXPORT struct S_DFP f11_S_SD_DFP(struct S_DFP p0, double p1) ;
+EXPORT struct S_DDI f11_S_SD_DDI(struct S_DDI p0, double p1) ;
+EXPORT struct S_DDF f11_S_SD_DDF(struct S_DDF p0, double p1) ;
+EXPORT struct S_DDD f11_S_SD_DDD(struct S_DDD p0, double p1) ;
+EXPORT struct S_DDP f11_S_SD_DDP(struct S_DDP p0, double p1) ;
+EXPORT struct S_DPI f11_S_SD_DPI(struct S_DPI p0, double p1) ;
+EXPORT struct S_DPF f11_S_SD_DPF(struct S_DPF p0, double p1) ;
+EXPORT struct S_DPD f11_S_SD_DPD(struct S_DPD p0, double p1) ;
+EXPORT struct S_DPP f11_S_SD_DPP(struct S_DPP p0, double p1) ;
+EXPORT struct S_PII f11_S_SD_PII(struct S_PII p0, double p1) ;
+EXPORT struct S_PIF f11_S_SD_PIF(struct S_PIF p0, double p1) ;
+EXPORT struct S_PID f11_S_SD_PID(struct S_PID p0, double p1) ;
+EXPORT struct S_PIP f11_S_SD_PIP(struct S_PIP p0, double p1) ;
+EXPORT struct S_PFI f11_S_SD_PFI(struct S_PFI p0, double p1) ;
+EXPORT struct S_PFF f11_S_SD_PFF(struct S_PFF p0, double p1) ;
+EXPORT struct S_PFD f11_S_SD_PFD(struct S_PFD p0, double p1) ;
+EXPORT struct S_PFP f11_S_SD_PFP(struct S_PFP p0, double p1) ;
+EXPORT struct S_PDI f11_S_SD_PDI(struct S_PDI p0, double p1) ;
+EXPORT struct S_PDF f11_S_SD_PDF(struct S_PDF p0, double p1) ;
+EXPORT struct S_PDD f11_S_SD_PDD(struct S_PDD p0, double p1) ;
+EXPORT struct S_PDP f11_S_SD_PDP(struct S_PDP p0, double p1) ;
+EXPORT struct S_PPI f11_S_SD_PPI(struct S_PPI p0, double p1) ;
+EXPORT struct S_PPF f11_S_SD_PPF(struct S_PPF p0, double p1) ;
+EXPORT struct S_PPD f11_S_SD_PPD(struct S_PPD p0, double p1) ;
+EXPORT struct S_PPP f11_S_SD_PPP(struct S_PPP p0, double p1) ;
+EXPORT struct S_I f11_S_SP_I(struct S_I p0, void* p1) ;
+EXPORT struct S_F f11_S_SP_F(struct S_F p0, void* p1) ;
+EXPORT struct S_D f11_S_SP_D(struct S_D p0, void* p1) ;
+EXPORT struct S_P f11_S_SP_P(struct S_P p0, void* p1) ;
+EXPORT struct S_II f11_S_SP_II(struct S_II p0, void* p1) ;
+EXPORT struct S_IF f11_S_SP_IF(struct S_IF p0, void* p1) ;
+EXPORT struct S_ID f11_S_SP_ID(struct S_ID p0, void* p1) ;
+EXPORT struct S_IP f11_S_SP_IP(struct S_IP p0, void* p1) ;
+EXPORT struct S_FI f11_S_SP_FI(struct S_FI p0, void* p1) ;
+EXPORT struct S_FF f11_S_SP_FF(struct S_FF p0, void* p1) ;
+EXPORT struct S_FD f11_S_SP_FD(struct S_FD p0, void* p1) ;
+EXPORT struct S_FP f11_S_SP_FP(struct S_FP p0, void* p1) ;
+EXPORT struct S_DI f11_S_SP_DI(struct S_DI p0, void* p1) ;
+EXPORT struct S_DF f11_S_SP_DF(struct S_DF p0, void* p1) ;
+EXPORT struct S_DD f11_S_SP_DD(struct S_DD p0, void* p1) ;
+EXPORT struct S_DP f11_S_SP_DP(struct S_DP p0, void* p1) ;
+EXPORT struct S_PI f11_S_SP_PI(struct S_PI p0, void* p1) ;
+EXPORT struct S_PF f11_S_SP_PF(struct S_PF p0, void* p1) ;
+EXPORT struct S_PD f11_S_SP_PD(struct S_PD p0, void* p1) ;
+EXPORT struct S_PP f11_S_SP_PP(struct S_PP p0, void* p1) ;
+EXPORT struct S_III f11_S_SP_III(struct S_III p0, void* p1) ;
+EXPORT struct S_IIF f11_S_SP_IIF(struct S_IIF p0, void* p1) ;
+EXPORT struct S_IID f11_S_SP_IID(struct S_IID p0, void* p1) ;
+EXPORT struct S_IIP f11_S_SP_IIP(struct S_IIP p0, void* p1) ;
+EXPORT struct S_IFI f11_S_SP_IFI(struct S_IFI p0, void* p1) ;
+EXPORT struct S_IFF f11_S_SP_IFF(struct S_IFF p0, void* p1) ;
+EXPORT struct S_IFD f11_S_SP_IFD(struct S_IFD p0, void* p1) ;
+EXPORT struct S_IFP f11_S_SP_IFP(struct S_IFP p0, void* p1) ;
+EXPORT struct S_IDI f11_S_SP_IDI(struct S_IDI p0, void* p1) ;
+EXPORT struct S_IDF f11_S_SP_IDF(struct S_IDF p0, void* p1) ;
+EXPORT struct S_IDD f11_S_SP_IDD(struct S_IDD p0, void* p1) ;
+EXPORT struct S_IDP f11_S_SP_IDP(struct S_IDP p0, void* p1) ;
+EXPORT struct S_IPI f11_S_SP_IPI(struct S_IPI p0, void* p1) ;
+EXPORT struct S_IPF f11_S_SP_IPF(struct S_IPF p0, void* p1) ;
+EXPORT struct S_IPD f11_S_SP_IPD(struct S_IPD p0, void* p1) ;
+EXPORT struct S_IPP f11_S_SP_IPP(struct S_IPP p0, void* p1) ;
+EXPORT struct S_FII f11_S_SP_FII(struct S_FII p0, void* p1) ;
+EXPORT struct S_FIF f11_S_SP_FIF(struct S_FIF p0, void* p1) ;
+EXPORT struct S_FID f11_S_SP_FID(struct S_FID p0, void* p1) ;
+EXPORT struct S_FIP f11_S_SP_FIP(struct S_FIP p0, void* p1) ;
+EXPORT struct S_FFI f11_S_SP_FFI(struct S_FFI p0, void* p1) ;
+EXPORT struct S_FFF f11_S_SP_FFF(struct S_FFF p0, void* p1) ;
+EXPORT struct S_FFD f11_S_SP_FFD(struct S_FFD p0, void* p1) ;
+EXPORT struct S_FFP f11_S_SP_FFP(struct S_FFP p0, void* p1) ;
+EXPORT struct S_FDI f11_S_SP_FDI(struct S_FDI p0, void* p1) ;
+EXPORT struct S_FDF f11_S_SP_FDF(struct S_FDF p0, void* p1) ;
+EXPORT struct S_FDD f11_S_SP_FDD(struct S_FDD p0, void* p1) ;
+EXPORT struct S_FDP f11_S_SP_FDP(struct S_FDP p0, void* p1) ;
+EXPORT struct S_FPI f11_S_SP_FPI(struct S_FPI p0, void* p1) ;
+EXPORT struct S_FPF f11_S_SP_FPF(struct S_FPF p0, void* p1) ;
+EXPORT struct S_FPD f11_S_SP_FPD(struct S_FPD p0, void* p1) ;
+EXPORT struct S_FPP f11_S_SP_FPP(struct S_FPP p0, void* p1) ;
+EXPORT struct S_DII f11_S_SP_DII(struct S_DII p0, void* p1) ;
+EXPORT struct S_DIF f11_S_SP_DIF(struct S_DIF p0, void* p1) ;
+EXPORT struct S_DID f11_S_SP_DID(struct S_DID p0, void* p1) ;
+EXPORT struct S_DIP f11_S_SP_DIP(struct S_DIP p0, void* p1) ;
+EXPORT struct S_DFI f11_S_SP_DFI(struct S_DFI p0, void* p1) ;
+EXPORT struct S_DFF f11_S_SP_DFF(struct S_DFF p0, void* p1) ;
+EXPORT struct S_DFD f11_S_SP_DFD(struct S_DFD p0, void* p1) ;
+EXPORT struct S_DFP f11_S_SP_DFP(struct S_DFP p0, void* p1) ;
+EXPORT struct S_DDI f11_S_SP_DDI(struct S_DDI p0, void* p1) ;
+EXPORT struct S_DDF f11_S_SP_DDF(struct S_DDF p0, void* p1) ;
+EXPORT struct S_DDD f11_S_SP_DDD(struct S_DDD p0, void* p1) ;
+EXPORT struct S_DDP f11_S_SP_DDP(struct S_DDP p0, void* p1) ;
+EXPORT struct S_DPI f11_S_SP_DPI(struct S_DPI p0, void* p1) ;
+EXPORT struct S_DPF f11_S_SP_DPF(struct S_DPF p0, void* p1) ;
+EXPORT struct S_DPD f11_S_SP_DPD(struct S_DPD p0, void* p1) ;
+EXPORT struct S_DPP f11_S_SP_DPP(struct S_DPP p0, void* p1) ;
+EXPORT struct S_PII f11_S_SP_PII(struct S_PII p0, void* p1) ;
+EXPORT struct S_PIF f11_S_SP_PIF(struct S_PIF p0, void* p1) ;
+EXPORT struct S_PID f11_S_SP_PID(struct S_PID p0, void* p1) ;
+EXPORT struct S_PIP f11_S_SP_PIP(struct S_PIP p0, void* p1) ;
+EXPORT struct S_PFI f11_S_SP_PFI(struct S_PFI p0, void* p1) ;
+EXPORT struct S_PFF f11_S_SP_PFF(struct S_PFF p0, void* p1) ;
+EXPORT struct S_PFD f11_S_SP_PFD(struct S_PFD p0, void* p1) ;
+EXPORT struct S_PFP f11_S_SP_PFP(struct S_PFP p0, void* p1) ;
+EXPORT struct S_PDI f11_S_SP_PDI(struct S_PDI p0, void* p1) ;
+EXPORT struct S_PDF f11_S_SP_PDF(struct S_PDF p0, void* p1) ;
+EXPORT struct S_PDD f11_S_SP_PDD(struct S_PDD p0, void* p1) ;
+EXPORT struct S_PDP f11_S_SP_PDP(struct S_PDP p0, void* p1) ;
+EXPORT struct S_PPI f11_S_SP_PPI(struct S_PPI p0, void* p1) ;
+EXPORT struct S_PPF f11_S_SP_PPF(struct S_PPF p0, void* p1) ;
+EXPORT struct S_PPD f11_S_SP_PPD(struct S_PPD p0, void* p1) ;
+EXPORT struct S_PPP f11_S_SP_PPP(struct S_PPP p0, void* p1) ;
+EXPORT struct S_I f11_S_SS_I(struct S_I p0, struct S_I p1) ;
+EXPORT struct S_F f11_S_SS_F(struct S_F p0, struct S_F p1) ;
+EXPORT struct S_D f11_S_SS_D(struct S_D p0, struct S_D p1) ;
+EXPORT struct S_P f11_S_SS_P(struct S_P p0, struct S_P p1) ;
+EXPORT struct S_II f11_S_SS_II(struct S_II p0, struct S_II p1) ;
+EXPORT struct S_IF f11_S_SS_IF(struct S_IF p0, struct S_IF p1) ;
+EXPORT struct S_ID f11_S_SS_ID(struct S_ID p0, struct S_ID p1) ;
+EXPORT struct S_IP f11_S_SS_IP(struct S_IP p0, struct S_IP p1) ;
+EXPORT struct S_FI f11_S_SS_FI(struct S_FI p0, struct S_FI p1) ;
+EXPORT struct S_FF f11_S_SS_FF(struct S_FF p0, struct S_FF p1) ;
+EXPORT struct S_FD f11_S_SS_FD(struct S_FD p0, struct S_FD p1) ;
+EXPORT struct S_FP f11_S_SS_FP(struct S_FP p0, struct S_FP p1) ;
+EXPORT struct S_DI f11_S_SS_DI(struct S_DI p0, struct S_DI p1) ;
+EXPORT struct S_DF f11_S_SS_DF(struct S_DF p0, struct S_DF p1) ;
+EXPORT struct S_DD f11_S_SS_DD(struct S_DD p0, struct S_DD p1) ;
+EXPORT struct S_DP f11_S_SS_DP(struct S_DP p0, struct S_DP p1) ;
+EXPORT struct S_PI f11_S_SS_PI(struct S_PI p0, struct S_PI p1) ;
+EXPORT struct S_PF f11_S_SS_PF(struct S_PF p0, struct S_PF p1) ;
+EXPORT struct S_PD f11_S_SS_PD(struct S_PD p0, struct S_PD p1) ;
+EXPORT struct S_PP f11_S_SS_PP(struct S_PP p0, struct S_PP p1) ;
+EXPORT struct S_III f11_S_SS_III(struct S_III p0, struct S_III p1) ;
+EXPORT struct S_IIF f11_S_SS_IIF(struct S_IIF p0, struct S_IIF p1) ;
+EXPORT struct S_IID f11_S_SS_IID(struct S_IID p0, struct S_IID p1) ;
+EXPORT struct S_IIP f11_S_SS_IIP(struct S_IIP p0, struct S_IIP p1) ;
+EXPORT struct S_IFI f11_S_SS_IFI(struct S_IFI p0, struct S_IFI p1) ;
+EXPORT struct S_IFF f11_S_SS_IFF(struct S_IFF p0, struct S_IFF p1) ;
+EXPORT struct S_IFD f11_S_SS_IFD(struct S_IFD p0, struct S_IFD p1) ;
+EXPORT struct S_IFP f11_S_SS_IFP(struct S_IFP p0, struct S_IFP p1) ;
+EXPORT struct S_IDI f11_S_SS_IDI(struct S_IDI p0, struct S_IDI p1) ;
+EXPORT struct S_IDF f11_S_SS_IDF(struct S_IDF p0, struct S_IDF p1) ;
+EXPORT struct S_IDD f11_S_SS_IDD(struct S_IDD p0, struct S_IDD p1) ;
+EXPORT struct S_IDP f11_S_SS_IDP(struct S_IDP p0, struct S_IDP p1) ;
+EXPORT struct S_IPI f11_S_SS_IPI(struct S_IPI p0, struct S_IPI p1) ;
+EXPORT struct S_IPF f11_S_SS_IPF(struct S_IPF p0, struct S_IPF p1) ;
+EXPORT struct S_IPD f11_S_SS_IPD(struct S_IPD p0, struct S_IPD p1) ;
+EXPORT struct S_IPP f11_S_SS_IPP(struct S_IPP p0, struct S_IPP p1) ;
+EXPORT struct S_FII f11_S_SS_FII(struct S_FII p0, struct S_FII p1) ;
+EXPORT struct S_FIF f11_S_SS_FIF(struct S_FIF p0, struct S_FIF p1) ;
+EXPORT struct S_FID f11_S_SS_FID(struct S_FID p0, struct S_FID p1) ;
+EXPORT struct S_FIP f11_S_SS_FIP(struct S_FIP p0, struct S_FIP p1) ;
+EXPORT struct S_FFI f11_S_SS_FFI(struct S_FFI p0, struct S_FFI p1) ;
+EXPORT struct S_FFF f11_S_SS_FFF(struct S_FFF p0, struct S_FFF p1) ;
+EXPORT struct S_FFD f11_S_SS_FFD(struct S_FFD p0, struct S_FFD p1) ;
+EXPORT struct S_FFP f11_S_SS_FFP(struct S_FFP p0, struct S_FFP p1) ;
+EXPORT struct S_FDI f11_S_SS_FDI(struct S_FDI p0, struct S_FDI p1) ;
+EXPORT struct S_FDF f11_S_SS_FDF(struct S_FDF p0, struct S_FDF p1) ;
+EXPORT struct S_FDD f11_S_SS_FDD(struct S_FDD p0, struct S_FDD p1) ;
+EXPORT struct S_FDP f11_S_SS_FDP(struct S_FDP p0, struct S_FDP p1) ;
+EXPORT struct S_FPI f11_S_SS_FPI(struct S_FPI p0, struct S_FPI p1) ;
+EXPORT struct S_FPF f11_S_SS_FPF(struct S_FPF p0, struct S_FPF p1) ;
+EXPORT struct S_FPD f11_S_SS_FPD(struct S_FPD p0, struct S_FPD p1) ;
+EXPORT struct S_FPP f11_S_SS_FPP(struct S_FPP p0, struct S_FPP p1) ;
+EXPORT struct S_DII f11_S_SS_DII(struct S_DII p0, struct S_DII p1) ;
+EXPORT struct S_DIF f11_S_SS_DIF(struct S_DIF p0, struct S_DIF p1) ;
+EXPORT struct S_DID f11_S_SS_DID(struct S_DID p0, struct S_DID p1) ;
+EXPORT struct S_DIP f11_S_SS_DIP(struct S_DIP p0, struct S_DIP p1) ;
+EXPORT struct S_DFI f11_S_SS_DFI(struct S_DFI p0, struct S_DFI p1) ;
+EXPORT struct S_DFF f11_S_SS_DFF(struct S_DFF p0, struct S_DFF p1) ;
+EXPORT struct S_DFD f11_S_SS_DFD(struct S_DFD p0, struct S_DFD p1) ;
+EXPORT struct S_DFP f11_S_SS_DFP(struct S_DFP p0, struct S_DFP p1) ;
+EXPORT struct S_DDI f11_S_SS_DDI(struct S_DDI p0, struct S_DDI p1) ;
+EXPORT struct S_DDF f11_S_SS_DDF(struct S_DDF p0, struct S_DDF p1) ;
+EXPORT struct S_DDD f11_S_SS_DDD(struct S_DDD p0, struct S_DDD p1) ;
+EXPORT struct S_DDP f11_S_SS_DDP(struct S_DDP p0, struct S_DDP p1) ;
+EXPORT struct S_DPI f11_S_SS_DPI(struct S_DPI p0, struct S_DPI p1) ;
+EXPORT struct S_DPF f11_S_SS_DPF(struct S_DPF p0, struct S_DPF p1) ;
+EXPORT struct S_DPD f11_S_SS_DPD(struct S_DPD p0, struct S_DPD p1) ;
+EXPORT struct S_DPP f11_S_SS_DPP(struct S_DPP p0, struct S_DPP p1) ;
+EXPORT struct S_PII f11_S_SS_PII(struct S_PII p0, struct S_PII p1) ;
+EXPORT struct S_PIF f11_S_SS_PIF(struct S_PIF p0, struct S_PIF p1) ;
+EXPORT struct S_PID f11_S_SS_PID(struct S_PID p0, struct S_PID p1) ;
+EXPORT struct S_PIP f11_S_SS_PIP(struct S_PIP p0, struct S_PIP p1) ;
+EXPORT struct S_PFI f11_S_SS_PFI(struct S_PFI p0, struct S_PFI p1) ;
+EXPORT struct S_PFF f11_S_SS_PFF(struct S_PFF p0, struct S_PFF p1) ;
+EXPORT struct S_PFD f11_S_SS_PFD(struct S_PFD p0, struct S_PFD p1) ;
+EXPORT struct S_PFP f11_S_SS_PFP(struct S_PFP p0, struct S_PFP p1) ;
+EXPORT struct S_PDI f11_S_SS_PDI(struct S_PDI p0, struct S_PDI p1) ;
+EXPORT struct S_PDF f11_S_SS_PDF(struct S_PDF p0, struct S_PDF p1) ;
+EXPORT struct S_PDD f11_S_SS_PDD(struct S_PDD p0, struct S_PDD p1) ;
+EXPORT struct S_PDP f11_S_SS_PDP(struct S_PDP p0, struct S_PDP p1) ;
+EXPORT struct S_PPI f11_S_SS_PPI(struct S_PPI p0, struct S_PPI p1) ;
+EXPORT struct S_PPF f11_S_SS_PPF(struct S_PPF p0, struct S_PPF p1) ;
+EXPORT struct S_PPD f11_S_SS_PPD(struct S_PPD p0, struct S_PPD p1) ;
+EXPORT struct S_PPP f11_S_SS_PPP(struct S_PPP p0, struct S_PPP p1) ;
+EXPORT int f11_I_III_(int p0, int p1, int p2) ;
+EXPORT int f11_I_IIF_(int p0, int p1, float p2) ;
+EXPORT int f11_I_IID_(int p0, int p1, double p2) ;
+EXPORT int f11_I_IIP_(int p0, int p1, void* p2) ;
+EXPORT int f11_I_IIS_I(int p0, int p1, struct S_I p2) ;
+EXPORT int f11_I_IIS_F(int p0, int p1, struct S_F p2) ;
+EXPORT int f11_I_IIS_D(int p0, int p1, struct S_D p2) ;
+EXPORT int f11_I_IIS_P(int p0, int p1, struct S_P p2) ;
+EXPORT int f11_I_IIS_II(int p0, int p1, struct S_II p2) ;
+EXPORT int f11_I_IIS_IF(int p0, int p1, struct S_IF p2) ;
+EXPORT int f11_I_IIS_ID(int p0, int p1, struct S_ID p2) ;
+EXPORT int f11_I_IIS_IP(int p0, int p1, struct S_IP p2) ;
+EXPORT int f11_I_IIS_FI(int p0, int p1, struct S_FI p2) ;
+EXPORT int f11_I_IIS_FF(int p0, int p1, struct S_FF p2) ;
+EXPORT int f11_I_IIS_FD(int p0, int p1, struct S_FD p2) ;
+EXPORT int f11_I_IIS_FP(int p0, int p1, struct S_FP p2) ;
+EXPORT int f11_I_IIS_DI(int p0, int p1, struct S_DI p2) ;
+EXPORT int f11_I_IIS_DF(int p0, int p1, struct S_DF p2) ;
+EXPORT int f11_I_IIS_DD(int p0, int p1, struct S_DD p2) ;
+EXPORT int f11_I_IIS_DP(int p0, int p1, struct S_DP p2) ;
+EXPORT int f11_I_IIS_PI(int p0, int p1, struct S_PI p2) ;
+EXPORT int f11_I_IIS_PF(int p0, int p1, struct S_PF p2) ;
+EXPORT int f11_I_IIS_PD(int p0, int p1, struct S_PD p2) ;
+EXPORT int f11_I_IIS_PP(int p0, int p1, struct S_PP p2) ;
+EXPORT int f11_I_IIS_III(int p0, int p1, struct S_III p2) ;
+EXPORT int f11_I_IIS_IIF(int p0, int p1, struct S_IIF p2) ;
+EXPORT int f11_I_IIS_IID(int p0, int p1, struct S_IID p2) ;
+EXPORT int f11_I_IIS_IIP(int p0, int p1, struct S_IIP p2) ;
+EXPORT int f11_I_IIS_IFI(int p0, int p1, struct S_IFI p2) ;
+EXPORT int f11_I_IIS_IFF(int p0, int p1, struct S_IFF p2) ;
+EXPORT int f11_I_IIS_IFD(int p0, int p1, struct S_IFD p2) ;
+EXPORT int f11_I_IIS_IFP(int p0, int p1, struct S_IFP p2) ;
+EXPORT int f11_I_IIS_IDI(int p0, int p1, struct S_IDI p2) ;
+EXPORT int f11_I_IIS_IDF(int p0, int p1, struct S_IDF p2) ;
+EXPORT int f11_I_IIS_IDD(int p0, int p1, struct S_IDD p2) ;
+EXPORT int f11_I_IIS_IDP(int p0, int p1, struct S_IDP p2) ;
+EXPORT int f11_I_IIS_IPI(int p0, int p1, struct S_IPI p2) ;
+EXPORT int f11_I_IIS_IPF(int p0, int p1, struct S_IPF p2) ;
+EXPORT int f11_I_IIS_IPD(int p0, int p1, struct S_IPD p2) ;
+EXPORT int f11_I_IIS_IPP(int p0, int p1, struct S_IPP p2) ;
+EXPORT int f11_I_IIS_FII(int p0, int p1, struct S_FII p2) ;
+EXPORT int f11_I_IIS_FIF(int p0, int p1, struct S_FIF p2) ;
+EXPORT int f11_I_IIS_FID(int p0, int p1, struct S_FID p2) ;
+EXPORT int f11_I_IIS_FIP(int p0, int p1, struct S_FIP p2) ;
+EXPORT int f11_I_IIS_FFI(int p0, int p1, struct S_FFI p2) ;
+EXPORT int f11_I_IIS_FFF(int p0, int p1, struct S_FFF p2) ;
+EXPORT int f11_I_IIS_FFD(int p0, int p1, struct S_FFD p2) ;
+EXPORT int f11_I_IIS_FFP(int p0, int p1, struct S_FFP p2) ;
+EXPORT int f11_I_IIS_FDI(int p0, int p1, struct S_FDI p2) ;
+EXPORT int f11_I_IIS_FDF(int p0, int p1, struct S_FDF p2) ;
+EXPORT int f11_I_IIS_FDD(int p0, int p1, struct S_FDD p2) ;
+EXPORT int f11_I_IIS_FDP(int p0, int p1, struct S_FDP p2) ;
+EXPORT int f11_I_IIS_FPI(int p0, int p1, struct S_FPI p2) ;
+EXPORT int f11_I_IIS_FPF(int p0, int p1, struct S_FPF p2) ;
+EXPORT int f11_I_IIS_FPD(int p0, int p1, struct S_FPD p2) ;
+EXPORT int f11_I_IIS_FPP(int p0, int p1, struct S_FPP p2) ;
+EXPORT int f11_I_IIS_DII(int p0, int p1, struct S_DII p2) ;
+EXPORT int f11_I_IIS_DIF(int p0, int p1, struct S_DIF p2) ;
+EXPORT int f11_I_IIS_DID(int p0, int p1, struct S_DID p2) ;
+EXPORT int f11_I_IIS_DIP(int p0, int p1, struct S_DIP p2) ;
+EXPORT int f11_I_IIS_DFI(int p0, int p1, struct S_DFI p2) ;
+EXPORT int f11_I_IIS_DFF(int p0, int p1, struct S_DFF p2) ;
+EXPORT int f11_I_IIS_DFD(int p0, int p1, struct S_DFD p2) ;
+EXPORT int f11_I_IIS_DFP(int p0, int p1, struct S_DFP p2) ;
+EXPORT int f11_I_IIS_DDI(int p0, int p1, struct S_DDI p2) ;
+EXPORT int f11_I_IIS_DDF(int p0, int p1, struct S_DDF p2) ;
+EXPORT int f11_I_IIS_DDD(int p0, int p1, struct S_DDD p2) ;
+EXPORT int f11_I_IIS_DDP(int p0, int p1, struct S_DDP p2) ;
+EXPORT int f11_I_IIS_DPI(int p0, int p1, struct S_DPI p2) ;
+EXPORT int f11_I_IIS_DPF(int p0, int p1, struct S_DPF p2) ;
+EXPORT int f11_I_IIS_DPD(int p0, int p1, struct S_DPD p2) ;
+EXPORT int f11_I_IIS_DPP(int p0, int p1, struct S_DPP p2) ;
+EXPORT int f11_I_IIS_PII(int p0, int p1, struct S_PII p2) ;
+EXPORT int f11_I_IIS_PIF(int p0, int p1, struct S_PIF p2) ;
+EXPORT int f11_I_IIS_PID(int p0, int p1, struct S_PID p2) ;
+EXPORT int f11_I_IIS_PIP(int p0, int p1, struct S_PIP p2) ;
+EXPORT int f11_I_IIS_PFI(int p0, int p1, struct S_PFI p2) ;
+EXPORT int f11_I_IIS_PFF(int p0, int p1, struct S_PFF p2) ;
+EXPORT int f11_I_IIS_PFD(int p0, int p1, struct S_PFD p2) ;
+EXPORT int f11_I_IIS_PFP(int p0, int p1, struct S_PFP p2) ;
+EXPORT int f11_I_IIS_PDI(int p0, int p1, struct S_PDI p2) ;
+EXPORT int f11_I_IIS_PDF(int p0, int p1, struct S_PDF p2) ;
+EXPORT int f11_I_IIS_PDD(int p0, int p1, struct S_PDD p2) ;
+EXPORT int f11_I_IIS_PDP(int p0, int p1, struct S_PDP p2) ;
+EXPORT int f11_I_IIS_PPI(int p0, int p1, struct S_PPI p2) ;
+EXPORT int f11_I_IIS_PPF(int p0, int p1, struct S_PPF p2) ;
+EXPORT int f11_I_IIS_PPD(int p0, int p1, struct S_PPD p2) ;
+EXPORT int f11_I_IIS_PPP(int p0, int p1, struct S_PPP p2) ;
+EXPORT int f11_I_IFI_(int p0, float p1, int p2) ;
+EXPORT int f11_I_IFF_(int p0, float p1, float p2) ;
+EXPORT int f11_I_IFD_(int p0, float p1, double p2) ;
+EXPORT int f11_I_IFP_(int p0, float p1, void* p2) ;
+EXPORT int f11_I_IFS_I(int p0, float p1, struct S_I p2) ;
+EXPORT int f11_I_IFS_F(int p0, float p1, struct S_F p2) ;
+EXPORT int f11_I_IFS_D(int p0, float p1, struct S_D p2) ;
+EXPORT int f11_I_IFS_P(int p0, float p1, struct S_P p2) ;
+EXPORT int f11_I_IFS_II(int p0, float p1, struct S_II p2) ;
+EXPORT int f11_I_IFS_IF(int p0, float p1, struct S_IF p2) ;
+EXPORT int f11_I_IFS_ID(int p0, float p1, struct S_ID p2) ;
+EXPORT int f11_I_IFS_IP(int p0, float p1, struct S_IP p2) ;
+EXPORT int f11_I_IFS_FI(int p0, float p1, struct S_FI p2) ;
+EXPORT int f11_I_IFS_FF(int p0, float p1, struct S_FF p2) ;
+EXPORT int f11_I_IFS_FD(int p0, float p1, struct S_FD p2) ;
+EXPORT int f11_I_IFS_FP(int p0, float p1, struct S_FP p2) ;
+EXPORT int f11_I_IFS_DI(int p0, float p1, struct S_DI p2) ;
+EXPORT int f11_I_IFS_DF(int p0, float p1, struct S_DF p2) ;
+EXPORT int f11_I_IFS_DD(int p0, float p1, struct S_DD p2) ;
+EXPORT int f11_I_IFS_DP(int p0, float p1, struct S_DP p2) ;
+EXPORT int f11_I_IFS_PI(int p0, float p1, struct S_PI p2) ;
+EXPORT int f11_I_IFS_PF(int p0, float p1, struct S_PF p2) ;
+EXPORT int f11_I_IFS_PD(int p0, float p1, struct S_PD p2) ;
+EXPORT int f11_I_IFS_PP(int p0, float p1, struct S_PP p2) ;
+EXPORT int f11_I_IFS_III(int p0, float p1, struct S_III p2) ;
+EXPORT int f11_I_IFS_IIF(int p0, float p1, struct S_IIF p2) ;
+EXPORT int f11_I_IFS_IID(int p0, float p1, struct S_IID p2) ;
+EXPORT int f11_I_IFS_IIP(int p0, float p1, struct S_IIP p2) ;
+EXPORT int f11_I_IFS_IFI(int p0, float p1, struct S_IFI p2) ;
+EXPORT int f11_I_IFS_IFF(int p0, float p1, struct S_IFF p2) ;
+EXPORT int f11_I_IFS_IFD(int p0, float p1, struct S_IFD p2) ;
+EXPORT int f11_I_IFS_IFP(int p0, float p1, struct S_IFP p2) ;
+EXPORT int f11_I_IFS_IDI(int p0, float p1, struct S_IDI p2) ;
+EXPORT int f11_I_IFS_IDF(int p0, float p1, struct S_IDF p2) ;
+EXPORT int f11_I_IFS_IDD(int p0, float p1, struct S_IDD p2) ;
+EXPORT int f11_I_IFS_IDP(int p0, float p1, struct S_IDP p2) ;
+EXPORT int f11_I_IFS_IPI(int p0, float p1, struct S_IPI p2) ;
+EXPORT int f11_I_IFS_IPF(int p0, float p1, struct S_IPF p2) ;
+EXPORT int f11_I_IFS_IPD(int p0, float p1, struct S_IPD p2) ;
+EXPORT int f11_I_IFS_IPP(int p0, float p1, struct S_IPP p2) ;
+EXPORT int f11_I_IFS_FII(int p0, float p1, struct S_FII p2) ;
+EXPORT int f11_I_IFS_FIF(int p0, float p1, struct S_FIF p2) ;
+EXPORT int f11_I_IFS_FID(int p0, float p1, struct S_FID p2) ;
+EXPORT int f11_I_IFS_FIP(int p0, float p1, struct S_FIP p2) ;
+EXPORT int f11_I_IFS_FFI(int p0, float p1, struct S_FFI p2) ;
+EXPORT int f11_I_IFS_FFF(int p0, float p1, struct S_FFF p2) ;
+EXPORT int f11_I_IFS_FFD(int p0, float p1, struct S_FFD p2) ;
+EXPORT int f11_I_IFS_FFP(int p0, float p1, struct S_FFP p2) ;
+EXPORT int f11_I_IFS_FDI(int p0, float p1, struct S_FDI p2) ;
+EXPORT int f11_I_IFS_FDF(int p0, float p1, struct S_FDF p2) ;
+EXPORT int f11_I_IFS_FDD(int p0, float p1, struct S_FDD p2) ;
+EXPORT int f11_I_IFS_FDP(int p0, float p1, struct S_FDP p2) ;
+EXPORT int f11_I_IFS_FPI(int p0, float p1, struct S_FPI p2) ;
+EXPORT int f11_I_IFS_FPF(int p0, float p1, struct S_FPF p2) ;
+EXPORT int f11_I_IFS_FPD(int p0, float p1, struct S_FPD p2) ;
+EXPORT int f11_I_IFS_FPP(int p0, float p1, struct S_FPP p2) ;
+EXPORT int f11_I_IFS_DII(int p0, float p1, struct S_DII p2) ;
+EXPORT int f11_I_IFS_DIF(int p0, float p1, struct S_DIF p2) ;
+EXPORT int f11_I_IFS_DID(int p0, float p1, struct S_DID p2) ;
+EXPORT int f11_I_IFS_DIP(int p0, float p1, struct S_DIP p2) ;
+EXPORT int f11_I_IFS_DFI(int p0, float p1, struct S_DFI p2) ;
+EXPORT int f11_I_IFS_DFF(int p0, float p1, struct S_DFF p2) ;
+EXPORT int f11_I_IFS_DFD(int p0, float p1, struct S_DFD p2) ;
+EXPORT int f11_I_IFS_DFP(int p0, float p1, struct S_DFP p2) ;
+EXPORT int f11_I_IFS_DDI(int p0, float p1, struct S_DDI p2) ;
+EXPORT int f11_I_IFS_DDF(int p0, float p1, struct S_DDF p2) ;
+EXPORT int f11_I_IFS_DDD(int p0, float p1, struct S_DDD p2) ;
+EXPORT int f11_I_IFS_DDP(int p0, float p1, struct S_DDP p2) ;
+EXPORT int f11_I_IFS_DPI(int p0, float p1, struct S_DPI p2) ;
+EXPORT int f11_I_IFS_DPF(int p0, float p1, struct S_DPF p2) ;
+EXPORT int f11_I_IFS_DPD(int p0, float p1, struct S_DPD p2) ;
+EXPORT int f11_I_IFS_DPP(int p0, float p1, struct S_DPP p2) ;
+EXPORT int f11_I_IFS_PII(int p0, float p1, struct S_PII p2) ;
+EXPORT int f11_I_IFS_PIF(int p0, float p1, struct S_PIF p2) ;
+EXPORT int f11_I_IFS_PID(int p0, float p1, struct S_PID p2) ;
+EXPORT int f11_I_IFS_PIP(int p0, float p1, struct S_PIP p2) ;
+EXPORT int f11_I_IFS_PFI(int p0, float p1, struct S_PFI p2) ;
+EXPORT int f11_I_IFS_PFF(int p0, float p1, struct S_PFF p2) ;
+EXPORT int f11_I_IFS_PFD(int p0, float p1, struct S_PFD p2) ;
+EXPORT int f11_I_IFS_PFP(int p0, float p1, struct S_PFP p2) ;
+EXPORT int f11_I_IFS_PDI(int p0, float p1, struct S_PDI p2) ;
+EXPORT int f11_I_IFS_PDF(int p0, float p1, struct S_PDF p2) ;
+EXPORT int f11_I_IFS_PDD(int p0, float p1, struct S_PDD p2) ;
+EXPORT int f11_I_IFS_PDP(int p0, float p1, struct S_PDP p2) ;
+EXPORT int f11_I_IFS_PPI(int p0, float p1, struct S_PPI p2) ;
+EXPORT int f11_I_IFS_PPF(int p0, float p1, struct S_PPF p2) ;
+EXPORT int f11_I_IFS_PPD(int p0, float p1, struct S_PPD p2) ;
+EXPORT int f11_I_IFS_PPP(int p0, float p1, struct S_PPP p2) ;
+EXPORT int f11_I_IDI_(int p0, double p1, int p2) ;
+EXPORT int f11_I_IDF_(int p0, double p1, float p2) ;
+EXPORT int f11_I_IDD_(int p0, double p1, double p2) ;
+EXPORT int f11_I_IDP_(int p0, double p1, void* p2) ;
+EXPORT int f11_I_IDS_I(int p0, double p1, struct S_I p2) ;
+EXPORT int f11_I_IDS_F(int p0, double p1, struct S_F p2) ;
+EXPORT int f11_I_IDS_D(int p0, double p1, struct S_D p2) ;
+EXPORT int f11_I_IDS_P(int p0, double p1, struct S_P p2) ;
+EXPORT int f11_I_IDS_II(int p0, double p1, struct S_II p2) ;
+EXPORT int f11_I_IDS_IF(int p0, double p1, struct S_IF p2) ;
+EXPORT int f11_I_IDS_ID(int p0, double p1, struct S_ID p2) ;
+EXPORT int f11_I_IDS_IP(int p0, double p1, struct S_IP p2) ;
+EXPORT int f11_I_IDS_FI(int p0, double p1, struct S_FI p2) ;
+EXPORT int f11_I_IDS_FF(int p0, double p1, struct S_FF p2) ;
+EXPORT int f11_I_IDS_FD(int p0, double p1, struct S_FD p2) ;
+EXPORT int f11_I_IDS_FP(int p0, double p1, struct S_FP p2) ;
+EXPORT int f11_I_IDS_DI(int p0, double p1, struct S_DI p2) ;
+EXPORT int f11_I_IDS_DF(int p0, double p1, struct S_DF p2) ;
+EXPORT int f11_I_IDS_DD(int p0, double p1, struct S_DD p2) ;
+EXPORT int f11_I_IDS_DP(int p0, double p1, struct S_DP p2) ;
+EXPORT int f11_I_IDS_PI(int p0, double p1, struct S_PI p2) ;
+EXPORT int f11_I_IDS_PF(int p0, double p1, struct S_PF p2) ;
+EXPORT int f11_I_IDS_PD(int p0, double p1, struct S_PD p2) ;
+EXPORT int f11_I_IDS_PP(int p0, double p1, struct S_PP p2) ;
+EXPORT int f11_I_IDS_III(int p0, double p1, struct S_III p2) ;
+EXPORT int f11_I_IDS_IIF(int p0, double p1, struct S_IIF p2) ;
+EXPORT int f11_I_IDS_IID(int p0, double p1, struct S_IID p2) ;
+EXPORT int f11_I_IDS_IIP(int p0, double p1, struct S_IIP p2) ;
+EXPORT int f11_I_IDS_IFI(int p0, double p1, struct S_IFI p2) ;
+EXPORT int f11_I_IDS_IFF(int p0, double p1, struct S_IFF p2) ;
+EXPORT int f11_I_IDS_IFD(int p0, double p1, struct S_IFD p2) ;
+EXPORT int f11_I_IDS_IFP(int p0, double p1, struct S_IFP p2) ;
+EXPORT int f11_I_IDS_IDI(int p0, double p1, struct S_IDI p2) ;
+EXPORT int f11_I_IDS_IDF(int p0, double p1, struct S_IDF p2) ;
+EXPORT int f11_I_IDS_IDD(int p0, double p1, struct S_IDD p2) ;
+EXPORT int f11_I_IDS_IDP(int p0, double p1, struct S_IDP p2) ;
+EXPORT int f11_I_IDS_IPI(int p0, double p1, struct S_IPI p2) ;
+EXPORT int f11_I_IDS_IPF(int p0, double p1, struct S_IPF p2) ;
+EXPORT int f11_I_IDS_IPD(int p0, double p1, struct S_IPD p2) ;
+EXPORT int f11_I_IDS_IPP(int p0, double p1, struct S_IPP p2) ;
+EXPORT int f11_I_IDS_FII(int p0, double p1, struct S_FII p2) ;
+EXPORT int f11_I_IDS_FIF(int p0, double p1, struct S_FIF p2) ;
+EXPORT int f11_I_IDS_FID(int p0, double p1, struct S_FID p2) ;
+EXPORT int f11_I_IDS_FIP(int p0, double p1, struct S_FIP p2) ;
+EXPORT int f11_I_IDS_FFI(int p0, double p1, struct S_FFI p2) ;
+EXPORT int f11_I_IDS_FFF(int p0, double p1, struct S_FFF p2) ;
+EXPORT int f11_I_IDS_FFD(int p0, double p1, struct S_FFD p2) ;
+EXPORT int f11_I_IDS_FFP(int p0, double p1, struct S_FFP p2) ;
+EXPORT int f11_I_IDS_FDI(int p0, double p1, struct S_FDI p2) ;
+EXPORT int f11_I_IDS_FDF(int p0, double p1, struct S_FDF p2) ;
+EXPORT int f11_I_IDS_FDD(int p0, double p1, struct S_FDD p2) ;
+EXPORT int f11_I_IDS_FDP(int p0, double p1, struct S_FDP p2) ;
+EXPORT int f11_I_IDS_FPI(int p0, double p1, struct S_FPI p2) ;
+EXPORT int f11_I_IDS_FPF(int p0, double p1, struct S_FPF p2) ;
+EXPORT int f11_I_IDS_FPD(int p0, double p1, struct S_FPD p2) ;
+EXPORT int f11_I_IDS_FPP(int p0, double p1, struct S_FPP p2) ;
+EXPORT int f11_I_IDS_DII(int p0, double p1, struct S_DII p2) ;
+EXPORT int f11_I_IDS_DIF(int p0, double p1, struct S_DIF p2) ;
+EXPORT int f11_I_IDS_DID(int p0, double p1, struct S_DID p2) ;
+EXPORT int f11_I_IDS_DIP(int p0, double p1, struct S_DIP p2) ;
+EXPORT int f11_I_IDS_DFI(int p0, double p1, struct S_DFI p2) ;
+EXPORT int f11_I_IDS_DFF(int p0, double p1, struct S_DFF p2) ;
+EXPORT int f11_I_IDS_DFD(int p0, double p1, struct S_DFD p2) ;
+EXPORT int f11_I_IDS_DFP(int p0, double p1, struct S_DFP p2) ;
+EXPORT int f11_I_IDS_DDI(int p0, double p1, struct S_DDI p2) ;
+EXPORT int f11_I_IDS_DDF(int p0, double p1, struct S_DDF p2) ;
+EXPORT int f11_I_IDS_DDD(int p0, double p1, struct S_DDD p2) ;
+EXPORT int f11_I_IDS_DDP(int p0, double p1, struct S_DDP p2) ;
+EXPORT int f11_I_IDS_DPI(int p0, double p1, struct S_DPI p2) ;
+EXPORT int f11_I_IDS_DPF(int p0, double p1, struct S_DPF p2) ;
+EXPORT int f11_I_IDS_DPD(int p0, double p1, struct S_DPD p2) ;
+EXPORT int f11_I_IDS_DPP(int p0, double p1, struct S_DPP p2) ;
+EXPORT int f11_I_IDS_PII(int p0, double p1, struct S_PII p2) ;
+EXPORT int f11_I_IDS_PIF(int p0, double p1, struct S_PIF p2) ;
+EXPORT int f11_I_IDS_PID(int p0, double p1, struct S_PID p2) ;
+EXPORT int f11_I_IDS_PIP(int p0, double p1, struct S_PIP p2) ;
+EXPORT int f11_I_IDS_PFI(int p0, double p1, struct S_PFI p2) ;
+EXPORT int f11_I_IDS_PFF(int p0, double p1, struct S_PFF p2) ;
+EXPORT int f11_I_IDS_PFD(int p0, double p1, struct S_PFD p2) ;
+EXPORT int f11_I_IDS_PFP(int p0, double p1, struct S_PFP p2) ;
+EXPORT int f11_I_IDS_PDI(int p0, double p1, struct S_PDI p2) ;
+EXPORT int f11_I_IDS_PDF(int p0, double p1, struct S_PDF p2) ;
+EXPORT int f11_I_IDS_PDD(int p0, double p1, struct S_PDD p2) ;
+EXPORT int f11_I_IDS_PDP(int p0, double p1, struct S_PDP p2) ;
+EXPORT int f11_I_IDS_PPI(int p0, double p1, struct S_PPI p2) ;
+EXPORT int f11_I_IDS_PPF(int p0, double p1, struct S_PPF p2) ;
+EXPORT int f11_I_IDS_PPD(int p0, double p1, struct S_PPD p2) ;
+EXPORT int f11_I_IDS_PPP(int p0, double p1, struct S_PPP p2) ;
+EXPORT int f11_I_IPI_(int p0, void* p1, int p2) ;
+EXPORT int f11_I_IPF_(int p0, void* p1, float p2) ;
+EXPORT int f11_I_IPD_(int p0, void* p1, double p2) ;
+EXPORT int f11_I_IPP_(int p0, void* p1, void* p2) ;
+EXPORT int f11_I_IPS_I(int p0, void* p1, struct S_I p2) ;
+EXPORT int f11_I_IPS_F(int p0, void* p1, struct S_F p2) ;
+EXPORT int f11_I_IPS_D(int p0, void* p1, struct S_D p2) ;
+EXPORT int f11_I_IPS_P(int p0, void* p1, struct S_P p2) ;
+EXPORT int f11_I_IPS_II(int p0, void* p1, struct S_II p2) ;
+EXPORT int f11_I_IPS_IF(int p0, void* p1, struct S_IF p2) ;
+EXPORT int f11_I_IPS_ID(int p0, void* p1, struct S_ID p2) ;
+EXPORT int f11_I_IPS_IP(int p0, void* p1, struct S_IP p2) ;
+EXPORT int f11_I_IPS_FI(int p0, void* p1, struct S_FI p2) ;
+EXPORT int f11_I_IPS_FF(int p0, void* p1, struct S_FF p2) ;
+EXPORT int f11_I_IPS_FD(int p0, void* p1, struct S_FD p2) ;
+EXPORT int f11_I_IPS_FP(int p0, void* p1, struct S_FP p2) ;
+EXPORT int f11_I_IPS_DI(int p0, void* p1, struct S_DI p2) ;
+EXPORT int f11_I_IPS_DF(int p0, void* p1, struct S_DF p2) ;
+EXPORT int f11_I_IPS_DD(int p0, void* p1, struct S_DD p2) ;
+EXPORT int f11_I_IPS_DP(int p0, void* p1, struct S_DP p2) ;
+EXPORT int f11_I_IPS_PI(int p0, void* p1, struct S_PI p2) ;
+EXPORT int f11_I_IPS_PF(int p0, void* p1, struct S_PF p2) ;
+EXPORT int f11_I_IPS_PD(int p0, void* p1, struct S_PD p2) ;
+EXPORT int f11_I_IPS_PP(int p0, void* p1, struct S_PP p2) ;
+EXPORT int f11_I_IPS_III(int p0, void* p1, struct S_III p2) ;
+EXPORT int f11_I_IPS_IIF(int p0, void* p1, struct S_IIF p2) ;
+EXPORT int f11_I_IPS_IID(int p0, void* p1, struct S_IID p2) ;
+EXPORT int f12_I_IPS_IIP(int p0, void* p1, struct S_IIP p2) ;
+EXPORT int f12_I_IPS_IFI(int p0, void* p1, struct S_IFI p2) ;
+EXPORT int f12_I_IPS_IFF(int p0, void* p1, struct S_IFF p2) ;
+EXPORT int f12_I_IPS_IFD(int p0, void* p1, struct S_IFD p2) ;
+EXPORT int f12_I_IPS_IFP(int p0, void* p1, struct S_IFP p2) ;
+EXPORT int f12_I_IPS_IDI(int p0, void* p1, struct S_IDI p2) ;
+EXPORT int f12_I_IPS_IDF(int p0, void* p1, struct S_IDF p2) ;
+EXPORT int f12_I_IPS_IDD(int p0, void* p1, struct S_IDD p2) ;
+EXPORT int f12_I_IPS_IDP(int p0, void* p1, struct S_IDP p2) ;
+EXPORT int f12_I_IPS_IPI(int p0, void* p1, struct S_IPI p2) ;
+EXPORT int f12_I_IPS_IPF(int p0, void* p1, struct S_IPF p2) ;
+EXPORT int f12_I_IPS_IPD(int p0, void* p1, struct S_IPD p2) ;
+EXPORT int f12_I_IPS_IPP(int p0, void* p1, struct S_IPP p2) ;
+EXPORT int f12_I_IPS_FII(int p0, void* p1, struct S_FII p2) ;
+EXPORT int f12_I_IPS_FIF(int p0, void* p1, struct S_FIF p2) ;
+EXPORT int f12_I_IPS_FID(int p0, void* p1, struct S_FID p2) ;
+EXPORT int f12_I_IPS_FIP(int p0, void* p1, struct S_FIP p2) ;
+EXPORT int f12_I_IPS_FFI(int p0, void* p1, struct S_FFI p2) ;
+EXPORT int f12_I_IPS_FFF(int p0, void* p1, struct S_FFF p2) ;
+EXPORT int f12_I_IPS_FFD(int p0, void* p1, struct S_FFD p2) ;
+EXPORT int f12_I_IPS_FFP(int p0, void* p1, struct S_FFP p2) ;
+EXPORT int f12_I_IPS_FDI(int p0, void* p1, struct S_FDI p2) ;
+EXPORT int f12_I_IPS_FDF(int p0, void* p1, struct S_FDF p2) ;
+EXPORT int f12_I_IPS_FDD(int p0, void* p1, struct S_FDD p2) ;
+EXPORT int f12_I_IPS_FDP(int p0, void* p1, struct S_FDP p2) ;
+EXPORT int f12_I_IPS_FPI(int p0, void* p1, struct S_FPI p2) ;
+EXPORT int f12_I_IPS_FPF(int p0, void* p1, struct S_FPF p2) ;
+EXPORT int f12_I_IPS_FPD(int p0, void* p1, struct S_FPD p2) ;
+EXPORT int f12_I_IPS_FPP(int p0, void* p1, struct S_FPP p2) ;
+EXPORT int f12_I_IPS_DII(int p0, void* p1, struct S_DII p2) ;
+EXPORT int f12_I_IPS_DIF(int p0, void* p1, struct S_DIF p2) ;
+EXPORT int f12_I_IPS_DID(int p0, void* p1, struct S_DID p2) ;
+EXPORT int f12_I_IPS_DIP(int p0, void* p1, struct S_DIP p2) ;
+EXPORT int f12_I_IPS_DFI(int p0, void* p1, struct S_DFI p2) ;
+EXPORT int f12_I_IPS_DFF(int p0, void* p1, struct S_DFF p2) ;
+EXPORT int f12_I_IPS_DFD(int p0, void* p1, struct S_DFD p2) ;
+EXPORT int f12_I_IPS_DFP(int p0, void* p1, struct S_DFP p2) ;
+EXPORT int f12_I_IPS_DDI(int p0, void* p1, struct S_DDI p2) ;
+EXPORT int f12_I_IPS_DDF(int p0, void* p1, struct S_DDF p2) ;
+EXPORT int f12_I_IPS_DDD(int p0, void* p1, struct S_DDD p2) ;
+EXPORT int f12_I_IPS_DDP(int p0, void* p1, struct S_DDP p2) ;
+EXPORT int f12_I_IPS_DPI(int p0, void* p1, struct S_DPI p2) ;
+EXPORT int f12_I_IPS_DPF(int p0, void* p1, struct S_DPF p2) ;
+EXPORT int f12_I_IPS_DPD(int p0, void* p1, struct S_DPD p2) ;
+EXPORT int f12_I_IPS_DPP(int p0, void* p1, struct S_DPP p2) ;
+EXPORT int f12_I_IPS_PII(int p0, void* p1, struct S_PII p2) ;
+EXPORT int f12_I_IPS_PIF(int p0, void* p1, struct S_PIF p2) ;
+EXPORT int f12_I_IPS_PID(int p0, void* p1, struct S_PID p2) ;
+EXPORT int f12_I_IPS_PIP(int p0, void* p1, struct S_PIP p2) ;
+EXPORT int f12_I_IPS_PFI(int p0, void* p1, struct S_PFI p2) ;
+EXPORT int f12_I_IPS_PFF(int p0, void* p1, struct S_PFF p2) ;
+EXPORT int f12_I_IPS_PFD(int p0, void* p1, struct S_PFD p2) ;
+EXPORT int f12_I_IPS_PFP(int p0, void* p1, struct S_PFP p2) ;
+EXPORT int f12_I_IPS_PDI(int p0, void* p1, struct S_PDI p2) ;
+EXPORT int f12_I_IPS_PDF(int p0, void* p1, struct S_PDF p2) ;
+EXPORT int f12_I_IPS_PDD(int p0, void* p1, struct S_PDD p2) ;
+EXPORT int f12_I_IPS_PDP(int p0, void* p1, struct S_PDP p2) ;
+EXPORT int f12_I_IPS_PPI(int p0, void* p1, struct S_PPI p2) ;
+EXPORT int f12_I_IPS_PPF(int p0, void* p1, struct S_PPF p2) ;
+EXPORT int f12_I_IPS_PPD(int p0, void* p1, struct S_PPD p2) ;
+EXPORT int f12_I_IPS_PPP(int p0, void* p1, struct S_PPP p2) ;
+EXPORT int f12_I_ISI_I(int p0, struct S_I p1, int p2) ;
+EXPORT int f12_I_ISI_F(int p0, struct S_F p1, int p2) ;
+EXPORT int f12_I_ISI_D(int p0, struct S_D p1, int p2) ;
+EXPORT int f12_I_ISI_P(int p0, struct S_P p1, int p2) ;
+EXPORT int f12_I_ISI_II(int p0, struct S_II p1, int p2) ;
+EXPORT int f12_I_ISI_IF(int p0, struct S_IF p1, int p2) ;
+EXPORT int f12_I_ISI_ID(int p0, struct S_ID p1, int p2) ;
+EXPORT int f12_I_ISI_IP(int p0, struct S_IP p1, int p2) ;
+EXPORT int f12_I_ISI_FI(int p0, struct S_FI p1, int p2) ;
+EXPORT int f12_I_ISI_FF(int p0, struct S_FF p1, int p2) ;
+EXPORT int f12_I_ISI_FD(int p0, struct S_FD p1, int p2) ;
+EXPORT int f12_I_ISI_FP(int p0, struct S_FP p1, int p2) ;
+EXPORT int f12_I_ISI_DI(int p0, struct S_DI p1, int p2) ;
+EXPORT int f12_I_ISI_DF(int p0, struct S_DF p1, int p2) ;
+EXPORT int f12_I_ISI_DD(int p0, struct S_DD p1, int p2) ;
+EXPORT int f12_I_ISI_DP(int p0, struct S_DP p1, int p2) ;
+EXPORT int f12_I_ISI_PI(int p0, struct S_PI p1, int p2) ;
+EXPORT int f12_I_ISI_PF(int p0, struct S_PF p1, int p2) ;
+EXPORT int f12_I_ISI_PD(int p0, struct S_PD p1, int p2) ;
+EXPORT int f12_I_ISI_PP(int p0, struct S_PP p1, int p2) ;
+EXPORT int f12_I_ISI_III(int p0, struct S_III p1, int p2) ;
+EXPORT int f12_I_ISI_IIF(int p0, struct S_IIF p1, int p2) ;
+EXPORT int f12_I_ISI_IID(int p0, struct S_IID p1, int p2) ;
+EXPORT int f12_I_ISI_IIP(int p0, struct S_IIP p1, int p2) ;
+EXPORT int f12_I_ISI_IFI(int p0, struct S_IFI p1, int p2) ;
+EXPORT int f12_I_ISI_IFF(int p0, struct S_IFF p1, int p2) ;
+EXPORT int f12_I_ISI_IFD(int p0, struct S_IFD p1, int p2) ;
+EXPORT int f12_I_ISI_IFP(int p0, struct S_IFP p1, int p2) ;
+EXPORT int f12_I_ISI_IDI(int p0, struct S_IDI p1, int p2) ;
+EXPORT int f12_I_ISI_IDF(int p0, struct S_IDF p1, int p2) ;
+EXPORT int f12_I_ISI_IDD(int p0, struct S_IDD p1, int p2) ;
+EXPORT int f12_I_ISI_IDP(int p0, struct S_IDP p1, int p2) ;
+EXPORT int f12_I_ISI_IPI(int p0, struct S_IPI p1, int p2) ;
+EXPORT int f12_I_ISI_IPF(int p0, struct S_IPF p1, int p2) ;
+EXPORT int f12_I_ISI_IPD(int p0, struct S_IPD p1, int p2) ;
+EXPORT int f12_I_ISI_IPP(int p0, struct S_IPP p1, int p2) ;
+EXPORT int f12_I_ISI_FII(int p0, struct S_FII p1, int p2) ;
+EXPORT int f12_I_ISI_FIF(int p0, struct S_FIF p1, int p2) ;
+EXPORT int f12_I_ISI_FID(int p0, struct S_FID p1, int p2) ;
+EXPORT int f12_I_ISI_FIP(int p0, struct S_FIP p1, int p2) ;
+EXPORT int f12_I_ISI_FFI(int p0, struct S_FFI p1, int p2) ;
+EXPORT int f12_I_ISI_FFF(int p0, struct S_FFF p1, int p2) ;
+EXPORT int f12_I_ISI_FFD(int p0, struct S_FFD p1, int p2) ;
+EXPORT int f12_I_ISI_FFP(int p0, struct S_FFP p1, int p2) ;
+EXPORT int f12_I_ISI_FDI(int p0, struct S_FDI p1, int p2) ;
+EXPORT int f12_I_ISI_FDF(int p0, struct S_FDF p1, int p2) ;
+EXPORT int f12_I_ISI_FDD(int p0, struct S_FDD p1, int p2) ;
+EXPORT int f12_I_ISI_FDP(int p0, struct S_FDP p1, int p2) ;
+EXPORT int f12_I_ISI_FPI(int p0, struct S_FPI p1, int p2) ;
+EXPORT int f12_I_ISI_FPF(int p0, struct S_FPF p1, int p2) ;
+EXPORT int f12_I_ISI_FPD(int p0, struct S_FPD p1, int p2) ;
+EXPORT int f12_I_ISI_FPP(int p0, struct S_FPP p1, int p2) ;
+EXPORT int f12_I_ISI_DII(int p0, struct S_DII p1, int p2) ;
+EXPORT int f12_I_ISI_DIF(int p0, struct S_DIF p1, int p2) ;
+EXPORT int f12_I_ISI_DID(int p0, struct S_DID p1, int p2) ;
+EXPORT int f12_I_ISI_DIP(int p0, struct S_DIP p1, int p2) ;
+EXPORT int f12_I_ISI_DFI(int p0, struct S_DFI p1, int p2) ;
+EXPORT int f12_I_ISI_DFF(int p0, struct S_DFF p1, int p2) ;
+EXPORT int f12_I_ISI_DFD(int p0, struct S_DFD p1, int p2) ;
+EXPORT int f12_I_ISI_DFP(int p0, struct S_DFP p1, int p2) ;
+EXPORT int f12_I_ISI_DDI(int p0, struct S_DDI p1, int p2) ;
+EXPORT int f12_I_ISI_DDF(int p0, struct S_DDF p1, int p2) ;
+EXPORT int f12_I_ISI_DDD(int p0, struct S_DDD p1, int p2) ;
+EXPORT int f12_I_ISI_DDP(int p0, struct S_DDP p1, int p2) ;
+EXPORT int f12_I_ISI_DPI(int p0, struct S_DPI p1, int p2) ;
+EXPORT int f12_I_ISI_DPF(int p0, struct S_DPF p1, int p2) ;
+EXPORT int f12_I_ISI_DPD(int p0, struct S_DPD p1, int p2) ;
+EXPORT int f12_I_ISI_DPP(int p0, struct S_DPP p1, int p2) ;
+EXPORT int f12_I_ISI_PII(int p0, struct S_PII p1, int p2) ;
+EXPORT int f12_I_ISI_PIF(int p0, struct S_PIF p1, int p2) ;
+EXPORT int f12_I_ISI_PID(int p0, struct S_PID p1, int p2) ;
+EXPORT int f12_I_ISI_PIP(int p0, struct S_PIP p1, int p2) ;
+EXPORT int f12_I_ISI_PFI(int p0, struct S_PFI p1, int p2) ;
+EXPORT int f12_I_ISI_PFF(int p0, struct S_PFF p1, int p2) ;
+EXPORT int f12_I_ISI_PFD(int p0, struct S_PFD p1, int p2) ;
+EXPORT int f12_I_ISI_PFP(int p0, struct S_PFP p1, int p2) ;
+EXPORT int f12_I_ISI_PDI(int p0, struct S_PDI p1, int p2) ;
+EXPORT int f12_I_ISI_PDF(int p0, struct S_PDF p1, int p2) ;
+EXPORT int f12_I_ISI_PDD(int p0, struct S_PDD p1, int p2) ;
+EXPORT int f12_I_ISI_PDP(int p0, struct S_PDP p1, int p2) ;
+EXPORT int f12_I_ISI_PPI(int p0, struct S_PPI p1, int p2) ;
+EXPORT int f12_I_ISI_PPF(int p0, struct S_PPF p1, int p2) ;
+EXPORT int f12_I_ISI_PPD(int p0, struct S_PPD p1, int p2) ;
+EXPORT int f12_I_ISI_PPP(int p0, struct S_PPP p1, int p2) ;
+EXPORT int f12_I_ISF_I(int p0, struct S_I p1, float p2) ;
+EXPORT int f12_I_ISF_F(int p0, struct S_F p1, float p2) ;
+EXPORT int f12_I_ISF_D(int p0, struct S_D p1, float p2) ;
+EXPORT int f12_I_ISF_P(int p0, struct S_P p1, float p2) ;
+EXPORT int f12_I_ISF_II(int p0, struct S_II p1, float p2) ;
+EXPORT int f12_I_ISF_IF(int p0, struct S_IF p1, float p2) ;
+EXPORT int f12_I_ISF_ID(int p0, struct S_ID p1, float p2) ;
+EXPORT int f12_I_ISF_IP(int p0, struct S_IP p1, float p2) ;
+EXPORT int f12_I_ISF_FI(int p0, struct S_FI p1, float p2) ;
+EXPORT int f12_I_ISF_FF(int p0, struct S_FF p1, float p2) ;
+EXPORT int f12_I_ISF_FD(int p0, struct S_FD p1, float p2) ;
+EXPORT int f12_I_ISF_FP(int p0, struct S_FP p1, float p2) ;
+EXPORT int f12_I_ISF_DI(int p0, struct S_DI p1, float p2) ;
+EXPORT int f12_I_ISF_DF(int p0, struct S_DF p1, float p2) ;
+EXPORT int f12_I_ISF_DD(int p0, struct S_DD p1, float p2) ;
+EXPORT int f12_I_ISF_DP(int p0, struct S_DP p1, float p2) ;
+EXPORT int f12_I_ISF_PI(int p0, struct S_PI p1, float p2) ;
+EXPORT int f12_I_ISF_PF(int p0, struct S_PF p1, float p2) ;
+EXPORT int f12_I_ISF_PD(int p0, struct S_PD p1, float p2) ;
+EXPORT int f12_I_ISF_PP(int p0, struct S_PP p1, float p2) ;
+EXPORT int f12_I_ISF_III(int p0, struct S_III p1, float p2) ;
+EXPORT int f12_I_ISF_IIF(int p0, struct S_IIF p1, float p2) ;
+EXPORT int f12_I_ISF_IID(int p0, struct S_IID p1, float p2) ;
+EXPORT int f12_I_ISF_IIP(int p0, struct S_IIP p1, float p2) ;
+EXPORT int f12_I_ISF_IFI(int p0, struct S_IFI p1, float p2) ;
+EXPORT int f12_I_ISF_IFF(int p0, struct S_IFF p1, float p2) ;
+EXPORT int f12_I_ISF_IFD(int p0, struct S_IFD p1, float p2) ;
+EXPORT int f12_I_ISF_IFP(int p0, struct S_IFP p1, float p2) ;
+EXPORT int f12_I_ISF_IDI(int p0, struct S_IDI p1, float p2) ;
+EXPORT int f12_I_ISF_IDF(int p0, struct S_IDF p1, float p2) ;
+EXPORT int f12_I_ISF_IDD(int p0, struct S_IDD p1, float p2) ;
+EXPORT int f12_I_ISF_IDP(int p0, struct S_IDP p1, float p2) ;
+EXPORT int f12_I_ISF_IPI(int p0, struct S_IPI p1, float p2) ;
+EXPORT int f12_I_ISF_IPF(int p0, struct S_IPF p1, float p2) ;
+EXPORT int f12_I_ISF_IPD(int p0, struct S_IPD p1, float p2) ;
+EXPORT int f12_I_ISF_IPP(int p0, struct S_IPP p1, float p2) ;
+EXPORT int f12_I_ISF_FII(int p0, struct S_FII p1, float p2) ;
+EXPORT int f12_I_ISF_FIF(int p0, struct S_FIF p1, float p2) ;
+EXPORT int f12_I_ISF_FID(int p0, struct S_FID p1, float p2) ;
+EXPORT int f12_I_ISF_FIP(int p0, struct S_FIP p1, float p2) ;
+EXPORT int f12_I_ISF_FFI(int p0, struct S_FFI p1, float p2) ;
+EXPORT int f12_I_ISF_FFF(int p0, struct S_FFF p1, float p2) ;
+EXPORT int f12_I_ISF_FFD(int p0, struct S_FFD p1, float p2) ;
+EXPORT int f12_I_ISF_FFP(int p0, struct S_FFP p1, float p2) ;
+EXPORT int f12_I_ISF_FDI(int p0, struct S_FDI p1, float p2) ;
+EXPORT int f12_I_ISF_FDF(int p0, struct S_FDF p1, float p2) ;
+EXPORT int f12_I_ISF_FDD(int p0, struct S_FDD p1, float p2) ;
+EXPORT int f12_I_ISF_FDP(int p0, struct S_FDP p1, float p2) ;
+EXPORT int f12_I_ISF_FPI(int p0, struct S_FPI p1, float p2) ;
+EXPORT int f12_I_ISF_FPF(int p0, struct S_FPF p1, float p2) ;
+EXPORT int f12_I_ISF_FPD(int p0, struct S_FPD p1, float p2) ;
+EXPORT int f12_I_ISF_FPP(int p0, struct S_FPP p1, float p2) ;
+EXPORT int f12_I_ISF_DII(int p0, struct S_DII p1, float p2) ;
+EXPORT int f12_I_ISF_DIF(int p0, struct S_DIF p1, float p2) ;
+EXPORT int f12_I_ISF_DID(int p0, struct S_DID p1, float p2) ;
+EXPORT int f12_I_ISF_DIP(int p0, struct S_DIP p1, float p2) ;
+EXPORT int f12_I_ISF_DFI(int p0, struct S_DFI p1, float p2) ;
+EXPORT int f12_I_ISF_DFF(int p0, struct S_DFF p1, float p2) ;
+EXPORT int f12_I_ISF_DFD(int p0, struct S_DFD p1, float p2) ;
+EXPORT int f12_I_ISF_DFP(int p0, struct S_DFP p1, float p2) ;
+EXPORT int f12_I_ISF_DDI(int p0, struct S_DDI p1, float p2) ;
+EXPORT int f12_I_ISF_DDF(int p0, struct S_DDF p1, float p2) ;
+EXPORT int f12_I_ISF_DDD(int p0, struct S_DDD p1, float p2) ;
+EXPORT int f12_I_ISF_DDP(int p0, struct S_DDP p1, float p2) ;
+EXPORT int f12_I_ISF_DPI(int p0, struct S_DPI p1, float p2) ;
+EXPORT int f12_I_ISF_DPF(int p0, struct S_DPF p1, float p2) ;
+EXPORT int f12_I_ISF_DPD(int p0, struct S_DPD p1, float p2) ;
+EXPORT int f12_I_ISF_DPP(int p0, struct S_DPP p1, float p2) ;
+EXPORT int f12_I_ISF_PII(int p0, struct S_PII p1, float p2) ;
+EXPORT int f12_I_ISF_PIF(int p0, struct S_PIF p1, float p2) ;
+EXPORT int f12_I_ISF_PID(int p0, struct S_PID p1, float p2) ;
+EXPORT int f12_I_ISF_PIP(int p0, struct S_PIP p1, float p2) ;
+EXPORT int f12_I_ISF_PFI(int p0, struct S_PFI p1, float p2) ;
+EXPORT int f12_I_ISF_PFF(int p0, struct S_PFF p1, float p2) ;
+EXPORT int f12_I_ISF_PFD(int p0, struct S_PFD p1, float p2) ;
+EXPORT int f12_I_ISF_PFP(int p0, struct S_PFP p1, float p2) ;
+EXPORT int f12_I_ISF_PDI(int p0, struct S_PDI p1, float p2) ;
+EXPORT int f12_I_ISF_PDF(int p0, struct S_PDF p1, float p2) ;
+EXPORT int f12_I_ISF_PDD(int p0, struct S_PDD p1, float p2) ;
+EXPORT int f12_I_ISF_PDP(int p0, struct S_PDP p1, float p2) ;
+EXPORT int f12_I_ISF_PPI(int p0, struct S_PPI p1, float p2) ;
+EXPORT int f12_I_ISF_PPF(int p0, struct S_PPF p1, float p2) ;
+EXPORT int f12_I_ISF_PPD(int p0, struct S_PPD p1, float p2) ;
+EXPORT int f12_I_ISF_PPP(int p0, struct S_PPP p1, float p2) ;
+EXPORT int f12_I_ISD_I(int p0, struct S_I p1, double p2) ;
+EXPORT int f12_I_ISD_F(int p0, struct S_F p1, double p2) ;
+EXPORT int f12_I_ISD_D(int p0, struct S_D p1, double p2) ;
+EXPORT int f12_I_ISD_P(int p0, struct S_P p1, double p2) ;
+EXPORT int f12_I_ISD_II(int p0, struct S_II p1, double p2) ;
+EXPORT int f12_I_ISD_IF(int p0, struct S_IF p1, double p2) ;
+EXPORT int f12_I_ISD_ID(int p0, struct S_ID p1, double p2) ;
+EXPORT int f12_I_ISD_IP(int p0, struct S_IP p1, double p2) ;
+EXPORT int f12_I_ISD_FI(int p0, struct S_FI p1, double p2) ;
+EXPORT int f12_I_ISD_FF(int p0, struct S_FF p1, double p2) ;
+EXPORT int f12_I_ISD_FD(int p0, struct S_FD p1, double p2) ;
+EXPORT int f12_I_ISD_FP(int p0, struct S_FP p1, double p2) ;
+EXPORT int f12_I_ISD_DI(int p0, struct S_DI p1, double p2) ;
+EXPORT int f12_I_ISD_DF(int p0, struct S_DF p1, double p2) ;
+EXPORT int f12_I_ISD_DD(int p0, struct S_DD p1, double p2) ;
+EXPORT int f12_I_ISD_DP(int p0, struct S_DP p1, double p2) ;
+EXPORT int f12_I_ISD_PI(int p0, struct S_PI p1, double p2) ;
+EXPORT int f12_I_ISD_PF(int p0, struct S_PF p1, double p2) ;
+EXPORT int f12_I_ISD_PD(int p0, struct S_PD p1, double p2) ;
+EXPORT int f12_I_ISD_PP(int p0, struct S_PP p1, double p2) ;
+EXPORT int f12_I_ISD_III(int p0, struct S_III p1, double p2) ;
+EXPORT int f12_I_ISD_IIF(int p0, struct S_IIF p1, double p2) ;
+EXPORT int f12_I_ISD_IID(int p0, struct S_IID p1, double p2) ;
+EXPORT int f12_I_ISD_IIP(int p0, struct S_IIP p1, double p2) ;
+EXPORT int f12_I_ISD_IFI(int p0, struct S_IFI p1, double p2) ;
+EXPORT int f12_I_ISD_IFF(int p0, struct S_IFF p1, double p2) ;
+EXPORT int f12_I_ISD_IFD(int p0, struct S_IFD p1, double p2) ;
+EXPORT int f12_I_ISD_IFP(int p0, struct S_IFP p1, double p2) ;
+EXPORT int f12_I_ISD_IDI(int p0, struct S_IDI p1, double p2) ;
+EXPORT int f12_I_ISD_IDF(int p0, struct S_IDF p1, double p2) ;
+EXPORT int f12_I_ISD_IDD(int p0, struct S_IDD p1, double p2) ;
+EXPORT int f12_I_ISD_IDP(int p0, struct S_IDP p1, double p2) ;
+EXPORT int f12_I_ISD_IPI(int p0, struct S_IPI p1, double p2) ;
+EXPORT int f12_I_ISD_IPF(int p0, struct S_IPF p1, double p2) ;
+EXPORT int f12_I_ISD_IPD(int p0, struct S_IPD p1, double p2) ;
+EXPORT int f12_I_ISD_IPP(int p0, struct S_IPP p1, double p2) ;
+EXPORT int f12_I_ISD_FII(int p0, struct S_FII p1, double p2) ;
+EXPORT int f12_I_ISD_FIF(int p0, struct S_FIF p1, double p2) ;
+EXPORT int f12_I_ISD_FID(int p0, struct S_FID p1, double p2) ;
+EXPORT int f12_I_ISD_FIP(int p0, struct S_FIP p1, double p2) ;
+EXPORT int f12_I_ISD_FFI(int p0, struct S_FFI p1, double p2) ;
+EXPORT int f12_I_ISD_FFF(int p0, struct S_FFF p1, double p2) ;
+EXPORT int f12_I_ISD_FFD(int p0, struct S_FFD p1, double p2) ;
+EXPORT int f12_I_ISD_FFP(int p0, struct S_FFP p1, double p2) ;
+EXPORT int f12_I_ISD_FDI(int p0, struct S_FDI p1, double p2) ;
+EXPORT int f12_I_ISD_FDF(int p0, struct S_FDF p1, double p2) ;
+EXPORT int f12_I_ISD_FDD(int p0, struct S_FDD p1, double p2) ;
+EXPORT int f12_I_ISD_FDP(int p0, struct S_FDP p1, double p2) ;
+EXPORT int f12_I_ISD_FPI(int p0, struct S_FPI p1, double p2) ;
+EXPORT int f12_I_ISD_FPF(int p0, struct S_FPF p1, double p2) ;
+EXPORT int f12_I_ISD_FPD(int p0, struct S_FPD p1, double p2) ;
+EXPORT int f12_I_ISD_FPP(int p0, struct S_FPP p1, double p2) ;
+EXPORT int f12_I_ISD_DII(int p0, struct S_DII p1, double p2) ;
+EXPORT int f12_I_ISD_DIF(int p0, struct S_DIF p1, double p2) ;
+EXPORT int f12_I_ISD_DID(int p0, struct S_DID p1, double p2) ;
+EXPORT int f12_I_ISD_DIP(int p0, struct S_DIP p1, double p2) ;
+EXPORT int f12_I_ISD_DFI(int p0, struct S_DFI p1, double p2) ;
+EXPORT int f12_I_ISD_DFF(int p0, struct S_DFF p1, double p2) ;
+EXPORT int f12_I_ISD_DFD(int p0, struct S_DFD p1, double p2) ;
+EXPORT int f12_I_ISD_DFP(int p0, struct S_DFP p1, double p2) ;
+EXPORT int f12_I_ISD_DDI(int p0, struct S_DDI p1, double p2) ;
+EXPORT int f12_I_ISD_DDF(int p0, struct S_DDF p1, double p2) ;
+EXPORT int f12_I_ISD_DDD(int p0, struct S_DDD p1, double p2) ;
+EXPORT int f12_I_ISD_DDP(int p0, struct S_DDP p1, double p2) ;
+EXPORT int f12_I_ISD_DPI(int p0, struct S_DPI p1, double p2) ;
+EXPORT int f12_I_ISD_DPF(int p0, struct S_DPF p1, double p2) ;
+EXPORT int f12_I_ISD_DPD(int p0, struct S_DPD p1, double p2) ;
+EXPORT int f12_I_ISD_DPP(int p0, struct S_DPP p1, double p2) ;
+EXPORT int f12_I_ISD_PII(int p0, struct S_PII p1, double p2) ;
+EXPORT int f12_I_ISD_PIF(int p0, struct S_PIF p1, double p2) ;
+EXPORT int f12_I_ISD_PID(int p0, struct S_PID p1, double p2) ;
+EXPORT int f12_I_ISD_PIP(int p0, struct S_PIP p1, double p2) ;
+EXPORT int f12_I_ISD_PFI(int p0, struct S_PFI p1, double p2) ;
+EXPORT int f12_I_ISD_PFF(int p0, struct S_PFF p1, double p2) ;
+EXPORT int f12_I_ISD_PFD(int p0, struct S_PFD p1, double p2) ;
+EXPORT int f12_I_ISD_PFP(int p0, struct S_PFP p1, double p2) ;
+EXPORT int f12_I_ISD_PDI(int p0, struct S_PDI p1, double p2) ;
+EXPORT int f12_I_ISD_PDF(int p0, struct S_PDF p1, double p2) ;
+EXPORT int f12_I_ISD_PDD(int p0, struct S_PDD p1, double p2) ;
+EXPORT int f12_I_ISD_PDP(int p0, struct S_PDP p1, double p2) ;
+EXPORT int f12_I_ISD_PPI(int p0, struct S_PPI p1, double p2) ;
+EXPORT int f12_I_ISD_PPF(int p0, struct S_PPF p1, double p2) ;
+EXPORT int f12_I_ISD_PPD(int p0, struct S_PPD p1, double p2) ;
+EXPORT int f12_I_ISD_PPP(int p0, struct S_PPP p1, double p2) ;
+EXPORT int f12_I_ISP_I(int p0, struct S_I p1, void* p2) ;
+EXPORT int f12_I_ISP_F(int p0, struct S_F p1, void* p2) ;
+EXPORT int f12_I_ISP_D(int p0, struct S_D p1, void* p2) ;
+EXPORT int f12_I_ISP_P(int p0, struct S_P p1, void* p2) ;
+EXPORT int f12_I_ISP_II(int p0, struct S_II p1, void* p2) ;
+EXPORT int f12_I_ISP_IF(int p0, struct S_IF p1, void* p2) ;
+EXPORT int f12_I_ISP_ID(int p0, struct S_ID p1, void* p2) ;
+EXPORT int f12_I_ISP_IP(int p0, struct S_IP p1, void* p2) ;
+EXPORT int f12_I_ISP_FI(int p0, struct S_FI p1, void* p2) ;
+EXPORT int f12_I_ISP_FF(int p0, struct S_FF p1, void* p2) ;
+EXPORT int f12_I_ISP_FD(int p0, struct S_FD p1, void* p2) ;
+EXPORT int f12_I_ISP_FP(int p0, struct S_FP p1, void* p2) ;
+EXPORT int f12_I_ISP_DI(int p0, struct S_DI p1, void* p2) ;
+EXPORT int f12_I_ISP_DF(int p0, struct S_DF p1, void* p2) ;
+EXPORT int f12_I_ISP_DD(int p0, struct S_DD p1, void* p2) ;
+EXPORT int f12_I_ISP_DP(int p0, struct S_DP p1, void* p2) ;
+EXPORT int f12_I_ISP_PI(int p0, struct S_PI p1, void* p2) ;
+EXPORT int f12_I_ISP_PF(int p0, struct S_PF p1, void* p2) ;
+EXPORT int f12_I_ISP_PD(int p0, struct S_PD p1, void* p2) ;
+EXPORT int f12_I_ISP_PP(int p0, struct S_PP p1, void* p2) ;
+EXPORT int f12_I_ISP_III(int p0, struct S_III p1, void* p2) ;
+EXPORT int f12_I_ISP_IIF(int p0, struct S_IIF p1, void* p2) ;
+EXPORT int f12_I_ISP_IID(int p0, struct S_IID p1, void* p2) ;
+EXPORT int f12_I_ISP_IIP(int p0, struct S_IIP p1, void* p2) ;
+EXPORT int f12_I_ISP_IFI(int p0, struct S_IFI p1, void* p2) ;
+EXPORT int f12_I_ISP_IFF(int p0, struct S_IFF p1, void* p2) ;
+EXPORT int f12_I_ISP_IFD(int p0, struct S_IFD p1, void* p2) ;
+EXPORT int f12_I_ISP_IFP(int p0, struct S_IFP p1, void* p2) ;
+EXPORT int f12_I_ISP_IDI(int p0, struct S_IDI p1, void* p2) ;
+EXPORT int f12_I_ISP_IDF(int p0, struct S_IDF p1, void* p2) ;
+EXPORT int f12_I_ISP_IDD(int p0, struct S_IDD p1, void* p2) ;
+EXPORT int f12_I_ISP_IDP(int p0, struct S_IDP p1, void* p2) ;
+EXPORT int f12_I_ISP_IPI(int p0, struct S_IPI p1, void* p2) ;
+EXPORT int f12_I_ISP_IPF(int p0, struct S_IPF p1, void* p2) ;
+EXPORT int f12_I_ISP_IPD(int p0, struct S_IPD p1, void* p2) ;
+EXPORT int f12_I_ISP_IPP(int p0, struct S_IPP p1, void* p2) ;
+EXPORT int f12_I_ISP_FII(int p0, struct S_FII p1, void* p2) ;
+EXPORT int f12_I_ISP_FIF(int p0, struct S_FIF p1, void* p2) ;
+EXPORT int f12_I_ISP_FID(int p0, struct S_FID p1, void* p2) ;
+EXPORT int f12_I_ISP_FIP(int p0, struct S_FIP p1, void* p2) ;
+EXPORT int f12_I_ISP_FFI(int p0, struct S_FFI p1, void* p2) ;
+EXPORT int f12_I_ISP_FFF(int p0, struct S_FFF p1, void* p2) ;
+EXPORT int f12_I_ISP_FFD(int p0, struct S_FFD p1, void* p2) ;
+EXPORT int f12_I_ISP_FFP(int p0, struct S_FFP p1, void* p2) ;
+EXPORT int f12_I_ISP_FDI(int p0, struct S_FDI p1, void* p2) ;
+EXPORT int f12_I_ISP_FDF(int p0, struct S_FDF p1, void* p2) ;
+EXPORT int f12_I_ISP_FDD(int p0, struct S_FDD p1, void* p2) ;
+EXPORT int f12_I_ISP_FDP(int p0, struct S_FDP p1, void* p2) ;
+EXPORT int f12_I_ISP_FPI(int p0, struct S_FPI p1, void* p2) ;
+EXPORT int f12_I_ISP_FPF(int p0, struct S_FPF p1, void* p2) ;
+EXPORT int f12_I_ISP_FPD(int p0, struct S_FPD p1, void* p2) ;
+EXPORT int f12_I_ISP_FPP(int p0, struct S_FPP p1, void* p2) ;
+EXPORT int f12_I_ISP_DII(int p0, struct S_DII p1, void* p2) ;
+EXPORT int f12_I_ISP_DIF(int p0, struct S_DIF p1, void* p2) ;
+EXPORT int f12_I_ISP_DID(int p0, struct S_DID p1, void* p2) ;
+EXPORT int f12_I_ISP_DIP(int p0, struct S_DIP p1, void* p2) ;
+EXPORT int f12_I_ISP_DFI(int p0, struct S_DFI p1, void* p2) ;
+EXPORT int f12_I_ISP_DFF(int p0, struct S_DFF p1, void* p2) ;
+EXPORT int f12_I_ISP_DFD(int p0, struct S_DFD p1, void* p2) ;
+EXPORT int f12_I_ISP_DFP(int p0, struct S_DFP p1, void* p2) ;
+EXPORT int f12_I_ISP_DDI(int p0, struct S_DDI p1, void* p2) ;
+EXPORT int f12_I_ISP_DDF(int p0, struct S_DDF p1, void* p2) ;
+EXPORT int f12_I_ISP_DDD(int p0, struct S_DDD p1, void* p2) ;
+EXPORT int f12_I_ISP_DDP(int p0, struct S_DDP p1, void* p2) ;
+EXPORT int f12_I_ISP_DPI(int p0, struct S_DPI p1, void* p2) ;
+EXPORT int f12_I_ISP_DPF(int p0, struct S_DPF p1, void* p2) ;
+EXPORT int f12_I_ISP_DPD(int p0, struct S_DPD p1, void* p2) ;
+EXPORT int f12_I_ISP_DPP(int p0, struct S_DPP p1, void* p2) ;
+EXPORT int f12_I_ISP_PII(int p0, struct S_PII p1, void* p2) ;
+EXPORT int f12_I_ISP_PIF(int p0, struct S_PIF p1, void* p2) ;
+EXPORT int f12_I_ISP_PID(int p0, struct S_PID p1, void* p2) ;
+EXPORT int f12_I_ISP_PIP(int p0, struct S_PIP p1, void* p2) ;
+EXPORT int f12_I_ISP_PFI(int p0, struct S_PFI p1, void* p2) ;
+EXPORT int f12_I_ISP_PFF(int p0, struct S_PFF p1, void* p2) ;
+EXPORT int f12_I_ISP_PFD(int p0, struct S_PFD p1, void* p2) ;
+EXPORT int f12_I_ISP_PFP(int p0, struct S_PFP p1, void* p2) ;
+EXPORT int f12_I_ISP_PDI(int p0, struct S_PDI p1, void* p2) ;
+EXPORT int f12_I_ISP_PDF(int p0, struct S_PDF p1, void* p2) ;
+EXPORT int f12_I_ISP_PDD(int p0, struct S_PDD p1, void* p2) ;
+EXPORT int f12_I_ISP_PDP(int p0, struct S_PDP p1, void* p2) ;
+EXPORT int f12_I_ISP_PPI(int p0, struct S_PPI p1, void* p2) ;
+EXPORT int f12_I_ISP_PPF(int p0, struct S_PPF p1, void* p2) ;
+EXPORT int f12_I_ISP_PPD(int p0, struct S_PPD p1, void* p2) ;
+EXPORT int f12_I_ISP_PPP(int p0, struct S_PPP p1, void* p2) ;
+EXPORT int f12_I_ISS_I(int p0, struct S_I p1, struct S_I p2) ;
+EXPORT int f12_I_ISS_F(int p0, struct S_F p1, struct S_F p2) ;
+EXPORT int f12_I_ISS_D(int p0, struct S_D p1, struct S_D p2) ;
+EXPORT int f12_I_ISS_P(int p0, struct S_P p1, struct S_P p2) ;
+EXPORT int f12_I_ISS_II(int p0, struct S_II p1, struct S_II p2) ;
+EXPORT int f12_I_ISS_IF(int p0, struct S_IF p1, struct S_IF p2) ;
+EXPORT int f12_I_ISS_ID(int p0, struct S_ID p1, struct S_ID p2) ;
+EXPORT int f12_I_ISS_IP(int p0, struct S_IP p1, struct S_IP p2) ;
+EXPORT int f12_I_ISS_FI(int p0, struct S_FI p1, struct S_FI p2) ;
+EXPORT int f12_I_ISS_FF(int p0, struct S_FF p1, struct S_FF p2) ;
+EXPORT int f12_I_ISS_FD(int p0, struct S_FD p1, struct S_FD p2) ;
+EXPORT int f12_I_ISS_FP(int p0, struct S_FP p1, struct S_FP p2) ;
+EXPORT int f12_I_ISS_DI(int p0, struct S_DI p1, struct S_DI p2) ;
+EXPORT int f12_I_ISS_DF(int p0, struct S_DF p1, struct S_DF p2) ;
+EXPORT int f12_I_ISS_DD(int p0, struct S_DD p1, struct S_DD p2) ;
+EXPORT int f12_I_ISS_DP(int p0, struct S_DP p1, struct S_DP p2) ;
+EXPORT int f12_I_ISS_PI(int p0, struct S_PI p1, struct S_PI p2) ;
+EXPORT int f12_I_ISS_PF(int p0, struct S_PF p1, struct S_PF p2) ;
+EXPORT int f12_I_ISS_PD(int p0, struct S_PD p1, struct S_PD p2) ;
+EXPORT int f12_I_ISS_PP(int p0, struct S_PP p1, struct S_PP p2) ;
+EXPORT int f12_I_ISS_III(int p0, struct S_III p1, struct S_III p2) ;
+EXPORT int f12_I_ISS_IIF(int p0, struct S_IIF p1, struct S_IIF p2) ;
+EXPORT int f12_I_ISS_IID(int p0, struct S_IID p1, struct S_IID p2) ;
+EXPORT int f12_I_ISS_IIP(int p0, struct S_IIP p1, struct S_IIP p2) ;
+EXPORT int f12_I_ISS_IFI(int p0, struct S_IFI p1, struct S_IFI p2) ;
+EXPORT int f12_I_ISS_IFF(int p0, struct S_IFF p1, struct S_IFF p2) ;
+EXPORT int f12_I_ISS_IFD(int p0, struct S_IFD p1, struct S_IFD p2) ;
+EXPORT int f12_I_ISS_IFP(int p0, struct S_IFP p1, struct S_IFP p2) ;
+EXPORT int f12_I_ISS_IDI(int p0, struct S_IDI p1, struct S_IDI p2) ;
+EXPORT int f12_I_ISS_IDF(int p0, struct S_IDF p1, struct S_IDF p2) ;
+EXPORT int f12_I_ISS_IDD(int p0, struct S_IDD p1, struct S_IDD p2) ;
+EXPORT int f12_I_ISS_IDP(int p0, struct S_IDP p1, struct S_IDP p2) ;
+EXPORT int f12_I_ISS_IPI(int p0, struct S_IPI p1, struct S_IPI p2) ;
+EXPORT int f12_I_ISS_IPF(int p0, struct S_IPF p1, struct S_IPF p2) ;
+EXPORT int f12_I_ISS_IPD(int p0, struct S_IPD p1, struct S_IPD p2) ;
+EXPORT int f12_I_ISS_IPP(int p0, struct S_IPP p1, struct S_IPP p2) ;
+EXPORT int f12_I_ISS_FII(int p0, struct S_FII p1, struct S_FII p2) ;
+EXPORT int f12_I_ISS_FIF(int p0, struct S_FIF p1, struct S_FIF p2) ;
+EXPORT int f12_I_ISS_FID(int p0, struct S_FID p1, struct S_FID p2) ;
+EXPORT int f12_I_ISS_FIP(int p0, struct S_FIP p1, struct S_FIP p2) ;
+EXPORT int f12_I_ISS_FFI(int p0, struct S_FFI p1, struct S_FFI p2) ;
+EXPORT int f12_I_ISS_FFF(int p0, struct S_FFF p1, struct S_FFF p2) ;
+EXPORT int f12_I_ISS_FFD(int p0, struct S_FFD p1, struct S_FFD p2) ;
+EXPORT int f12_I_ISS_FFP(int p0, struct S_FFP p1, struct S_FFP p2) ;
+EXPORT int f12_I_ISS_FDI(int p0, struct S_FDI p1, struct S_FDI p2) ;
+EXPORT int f12_I_ISS_FDF(int p0, struct S_FDF p1, struct S_FDF p2) ;
+EXPORT int f12_I_ISS_FDD(int p0, struct S_FDD p1, struct S_FDD p2) ;
+EXPORT int f12_I_ISS_FDP(int p0, struct S_FDP p1, struct S_FDP p2) ;
+EXPORT int f12_I_ISS_FPI(int p0, struct S_FPI p1, struct S_FPI p2) ;
+EXPORT int f12_I_ISS_FPF(int p0, struct S_FPF p1, struct S_FPF p2) ;
+EXPORT int f12_I_ISS_FPD(int p0, struct S_FPD p1, struct S_FPD p2) ;
+EXPORT int f12_I_ISS_FPP(int p0, struct S_FPP p1, struct S_FPP p2) ;
+EXPORT int f12_I_ISS_DII(int p0, struct S_DII p1, struct S_DII p2) ;
+EXPORT int f12_I_ISS_DIF(int p0, struct S_DIF p1, struct S_DIF p2) ;
+EXPORT int f12_I_ISS_DID(int p0, struct S_DID p1, struct S_DID p2) ;
+EXPORT int f12_I_ISS_DIP(int p0, struct S_DIP p1, struct S_DIP p2) ;
+EXPORT int f12_I_ISS_DFI(int p0, struct S_DFI p1, struct S_DFI p2) ;
+EXPORT int f12_I_ISS_DFF(int p0, struct S_DFF p1, struct S_DFF p2) ;
+EXPORT int f12_I_ISS_DFD(int p0, struct S_DFD p1, struct S_DFD p2) ;
+EXPORT int f12_I_ISS_DFP(int p0, struct S_DFP p1, struct S_DFP p2) ;
+EXPORT int f12_I_ISS_DDI(int p0, struct S_DDI p1, struct S_DDI p2) ;
+EXPORT int f12_I_ISS_DDF(int p0, struct S_DDF p1, struct S_DDF p2) ;
+EXPORT int f12_I_ISS_DDD(int p0, struct S_DDD p1, struct S_DDD p2) ;
+EXPORT int f12_I_ISS_DDP(int p0, struct S_DDP p1, struct S_DDP p2) ;
+EXPORT int f12_I_ISS_DPI(int p0, struct S_DPI p1, struct S_DPI p2) ;
+EXPORT int f12_I_ISS_DPF(int p0, struct S_DPF p1, struct S_DPF p2) ;
+EXPORT int f12_I_ISS_DPD(int p0, struct S_DPD p1, struct S_DPD p2) ;
+EXPORT int f12_I_ISS_DPP(int p0, struct S_DPP p1, struct S_DPP p2) ;
+EXPORT int f12_I_ISS_PII(int p0, struct S_PII p1, struct S_PII p2) ;
+EXPORT int f12_I_ISS_PIF(int p0, struct S_PIF p1, struct S_PIF p2) ;
+EXPORT int f12_I_ISS_PID(int p0, struct S_PID p1, struct S_PID p2) ;
+EXPORT int f12_I_ISS_PIP(int p0, struct S_PIP p1, struct S_PIP p2) ;
+EXPORT int f12_I_ISS_PFI(int p0, struct S_PFI p1, struct S_PFI p2) ;
+EXPORT int f12_I_ISS_PFF(int p0, struct S_PFF p1, struct S_PFF p2) ;
+EXPORT int f12_I_ISS_PFD(int p0, struct S_PFD p1, struct S_PFD p2) ;
+EXPORT int f12_I_ISS_PFP(int p0, struct S_PFP p1, struct S_PFP p2) ;
+EXPORT int f12_I_ISS_PDI(int p0, struct S_PDI p1, struct S_PDI p2) ;
+EXPORT int f12_I_ISS_PDF(int p0, struct S_PDF p1, struct S_PDF p2) ;
+EXPORT int f12_I_ISS_PDD(int p0, struct S_PDD p1, struct S_PDD p2) ;
+EXPORT int f12_I_ISS_PDP(int p0, struct S_PDP p1, struct S_PDP p2) ;
+EXPORT int f12_I_ISS_PPI(int p0, struct S_PPI p1, struct S_PPI p2) ;
+EXPORT int f12_I_ISS_PPF(int p0, struct S_PPF p1, struct S_PPF p2) ;
+EXPORT int f12_I_ISS_PPD(int p0, struct S_PPD p1, struct S_PPD p2) ;
+EXPORT int f12_I_ISS_PPP(int p0, struct S_PPP p1, struct S_PPP p2) ;
+EXPORT float f12_F_FII_(float p0, int p1, int p2) ;
+EXPORT float f12_F_FIF_(float p0, int p1, float p2) ;
+EXPORT float f12_F_FID_(float p0, int p1, double p2) ;
+EXPORT float f12_F_FIP_(float p0, int p1, void* p2) ;
+EXPORT float f12_F_FIS_I(float p0, int p1, struct S_I p2) ;
+EXPORT float f12_F_FIS_F(float p0, int p1, struct S_F p2) ;
+EXPORT float f12_F_FIS_D(float p0, int p1, struct S_D p2) ;
+EXPORT float f12_F_FIS_P(float p0, int p1, struct S_P p2) ;
+EXPORT float f12_F_FIS_II(float p0, int p1, struct S_II p2) ;
+EXPORT float f12_F_FIS_IF(float p0, int p1, struct S_IF p2) ;
+EXPORT float f12_F_FIS_ID(float p0, int p1, struct S_ID p2) ;
+EXPORT float f12_F_FIS_IP(float p0, int p1, struct S_IP p2) ;
+EXPORT float f12_F_FIS_FI(float p0, int p1, struct S_FI p2) ;
+EXPORT float f12_F_FIS_FF(float p0, int p1, struct S_FF p2) ;
+EXPORT float f12_F_FIS_FD(float p0, int p1, struct S_FD p2) ;
+EXPORT float f12_F_FIS_FP(float p0, int p1, struct S_FP p2) ;
+EXPORT float f12_F_FIS_DI(float p0, int p1, struct S_DI p2) ;
+EXPORT float f12_F_FIS_DF(float p0, int p1, struct S_DF p2) ;
+EXPORT float f12_F_FIS_DD(float p0, int p1, struct S_DD p2) ;
+EXPORT float f12_F_FIS_DP(float p0, int p1, struct S_DP p2) ;
+EXPORT float f12_F_FIS_PI(float p0, int p1, struct S_PI p2) ;
+EXPORT float f12_F_FIS_PF(float p0, int p1, struct S_PF p2) ;
+EXPORT float f12_F_FIS_PD(float p0, int p1, struct S_PD p2) ;
+EXPORT float f12_F_FIS_PP(float p0, int p1, struct S_PP p2) ;
+EXPORT float f12_F_FIS_III(float p0, int p1, struct S_III p2) ;
+EXPORT float f12_F_FIS_IIF(float p0, int p1, struct S_IIF p2) ;
+EXPORT float f12_F_FIS_IID(float p0, int p1, struct S_IID p2) ;
+EXPORT float f12_F_FIS_IIP(float p0, int p1, struct S_IIP p2) ;
+EXPORT float f12_F_FIS_IFI(float p0, int p1, struct S_IFI p2) ;
+EXPORT float f12_F_FIS_IFF(float p0, int p1, struct S_IFF p2) ;
+EXPORT float f12_F_FIS_IFD(float p0, int p1, struct S_IFD p2) ;
+EXPORT float f12_F_FIS_IFP(float p0, int p1, struct S_IFP p2) ;
+EXPORT float f12_F_FIS_IDI(float p0, int p1, struct S_IDI p2) ;
+EXPORT float f12_F_FIS_IDF(float p0, int p1, struct S_IDF p2) ;
+EXPORT float f12_F_FIS_IDD(float p0, int p1, struct S_IDD p2) ;
+EXPORT float f12_F_FIS_IDP(float p0, int p1, struct S_IDP p2) ;
+EXPORT float f12_F_FIS_IPI(float p0, int p1, struct S_IPI p2) ;
+EXPORT float f12_F_FIS_IPF(float p0, int p1, struct S_IPF p2) ;
+EXPORT float f12_F_FIS_IPD(float p0, int p1, struct S_IPD p2) ;
+EXPORT float f12_F_FIS_IPP(float p0, int p1, struct S_IPP p2) ;
+EXPORT float f12_F_FIS_FII(float p0, int p1, struct S_FII p2) ;
+EXPORT float f12_F_FIS_FIF(float p0, int p1, struct S_FIF p2) ;
+EXPORT float f12_F_FIS_FID(float p0, int p1, struct S_FID p2) ;
+EXPORT float f12_F_FIS_FIP(float p0, int p1, struct S_FIP p2) ;
+EXPORT float f12_F_FIS_FFI(float p0, int p1, struct S_FFI p2) ;
+EXPORT float f12_F_FIS_FFF(float p0, int p1, struct S_FFF p2) ;
+EXPORT float f12_F_FIS_FFD(float p0, int p1, struct S_FFD p2) ;
+EXPORT float f12_F_FIS_FFP(float p0, int p1, struct S_FFP p2) ;
+EXPORT float f12_F_FIS_FDI(float p0, int p1, struct S_FDI p2) ;
+EXPORT float f12_F_FIS_FDF(float p0, int p1, struct S_FDF p2) ;
+EXPORT float f12_F_FIS_FDD(float p0, int p1, struct S_FDD p2) ;
+EXPORT float f12_F_FIS_FDP(float p0, int p1, struct S_FDP p2) ;
+EXPORT float f12_F_FIS_FPI(float p0, int p1, struct S_FPI p2) ;
+EXPORT float f12_F_FIS_FPF(float p0, int p1, struct S_FPF p2) ;
+EXPORT float f12_F_FIS_FPD(float p0, int p1, struct S_FPD p2) ;
+EXPORT float f12_F_FIS_FPP(float p0, int p1, struct S_FPP p2) ;
+EXPORT float f12_F_FIS_DII(float p0, int p1, struct S_DII p2) ;
+EXPORT float f12_F_FIS_DIF(float p0, int p1, struct S_DIF p2) ;
+EXPORT float f12_F_FIS_DID(float p0, int p1, struct S_DID p2) ;
+EXPORT float f12_F_FIS_DIP(float p0, int p1, struct S_DIP p2) ;
+EXPORT float f12_F_FIS_DFI(float p0, int p1, struct S_DFI p2) ;
+EXPORT float f12_F_FIS_DFF(float p0, int p1, struct S_DFF p2) ;
+EXPORT float f12_F_FIS_DFD(float p0, int p1, struct S_DFD p2) ;
+EXPORT float f12_F_FIS_DFP(float p0, int p1, struct S_DFP p2) ;
+EXPORT float f12_F_FIS_DDI(float p0, int p1, struct S_DDI p2) ;
+EXPORT float f12_F_FIS_DDF(float p0, int p1, struct S_DDF p2) ;
+EXPORT float f12_F_FIS_DDD(float p0, int p1, struct S_DDD p2) ;
+EXPORT float f12_F_FIS_DDP(float p0, int p1, struct S_DDP p2) ;
+EXPORT float f12_F_FIS_DPI(float p0, int p1, struct S_DPI p2) ;
+EXPORT float f12_F_FIS_DPF(float p0, int p1, struct S_DPF p2) ;
+EXPORT float f12_F_FIS_DPD(float p0, int p1, struct S_DPD p2) ;
+EXPORT float f12_F_FIS_DPP(float p0, int p1, struct S_DPP p2) ;
+EXPORT float f12_F_FIS_PII(float p0, int p1, struct S_PII p2) ;
+EXPORT float f12_F_FIS_PIF(float p0, int p1, struct S_PIF p2) ;
+EXPORT float f12_F_FIS_PID(float p0, int p1, struct S_PID p2) ;
+EXPORT float f12_F_FIS_PIP(float p0, int p1, struct S_PIP p2) ;
+EXPORT float f12_F_FIS_PFI(float p0, int p1, struct S_PFI p2) ;
+EXPORT float f12_F_FIS_PFF(float p0, int p1, struct S_PFF p2) ;
+EXPORT float f12_F_FIS_PFD(float p0, int p1, struct S_PFD p2) ;
+EXPORT float f12_F_FIS_PFP(float p0, int p1, struct S_PFP p2) ;
+EXPORT float f12_F_FIS_PDI(float p0, int p1, struct S_PDI p2) ;
+EXPORT float f12_F_FIS_PDF(float p0, int p1, struct S_PDF p2) ;
+EXPORT float f12_F_FIS_PDD(float p0, int p1, struct S_PDD p2) ;
+EXPORT float f12_F_FIS_PDP(float p0, int p1, struct S_PDP p2) ;
+EXPORT float f12_F_FIS_PPI(float p0, int p1, struct S_PPI p2) ;
+EXPORT float f12_F_FIS_PPF(float p0, int p1, struct S_PPF p2) ;
+EXPORT float f12_F_FIS_PPD(float p0, int p1, struct S_PPD p2) ;
+EXPORT float f12_F_FIS_PPP(float p0, int p1, struct S_PPP p2) ;
+EXPORT float f12_F_FFI_(float p0, float p1, int p2) ;
+EXPORT float f12_F_FFF_(float p0, float p1, float p2) ;
+EXPORT float f12_F_FFD_(float p0, float p1, double p2) ;
+EXPORT float f12_F_FFP_(float p0, float p1, void* p2) ;
+EXPORT float f12_F_FFS_I(float p0, float p1, struct S_I p2) ;
+EXPORT float f12_F_FFS_F(float p0, float p1, struct S_F p2) ;
+EXPORT float f12_F_FFS_D(float p0, float p1, struct S_D p2) ;
+EXPORT float f12_F_FFS_P(float p0, float p1, struct S_P p2) ;
+EXPORT float f12_F_FFS_II(float p0, float p1, struct S_II p2) ;
+EXPORT float f12_F_FFS_IF(float p0, float p1, struct S_IF p2) ;
+EXPORT float f12_F_FFS_ID(float p0, float p1, struct S_ID p2) ;
+EXPORT float f12_F_FFS_IP(float p0, float p1, struct S_IP p2) ;
+EXPORT float f12_F_FFS_FI(float p0, float p1, struct S_FI p2) ;
+EXPORT float f12_F_FFS_FF(float p0, float p1, struct S_FF p2) ;
+EXPORT float f12_F_FFS_FD(float p0, float p1, struct S_FD p2) ;
+EXPORT float f12_F_FFS_FP(float p0, float p1, struct S_FP p2) ;
+EXPORT float f12_F_FFS_DI(float p0, float p1, struct S_DI p2) ;
+EXPORT float f12_F_FFS_DF(float p0, float p1, struct S_DF p2) ;
+EXPORT float f12_F_FFS_DD(float p0, float p1, struct S_DD p2) ;
+EXPORT float f12_F_FFS_DP(float p0, float p1, struct S_DP p2) ;
+EXPORT float f12_F_FFS_PI(float p0, float p1, struct S_PI p2) ;
+EXPORT float f12_F_FFS_PF(float p0, float p1, struct S_PF p2) ;
+EXPORT float f12_F_FFS_PD(float p0, float p1, struct S_PD p2) ;
+EXPORT float f12_F_FFS_PP(float p0, float p1, struct S_PP p2) ;
+EXPORT float f12_F_FFS_III(float p0, float p1, struct S_III p2) ;
+EXPORT float f12_F_FFS_IIF(float p0, float p1, struct S_IIF p2) ;
+EXPORT float f12_F_FFS_IID(float p0, float p1, struct S_IID p2) ;
+EXPORT float f12_F_FFS_IIP(float p0, float p1, struct S_IIP p2) ;
+EXPORT float f12_F_FFS_IFI(float p0, float p1, struct S_IFI p2) ;
+EXPORT float f12_F_FFS_IFF(float p0, float p1, struct S_IFF p2) ;
+EXPORT float f12_F_FFS_IFD(float p0, float p1, struct S_IFD p2) ;
+EXPORT float f13_F_FFS_IFP(float p0, float p1, struct S_IFP p2) ;
+EXPORT float f13_F_FFS_IDI(float p0, float p1, struct S_IDI p2) ;
+EXPORT float f13_F_FFS_IDF(float p0, float p1, struct S_IDF p2) ;
+EXPORT float f13_F_FFS_IDD(float p0, float p1, struct S_IDD p2) ;
+EXPORT float f13_F_FFS_IDP(float p0, float p1, struct S_IDP p2) ;
+EXPORT float f13_F_FFS_IPI(float p0, float p1, struct S_IPI p2) ;
+EXPORT float f13_F_FFS_IPF(float p0, float p1, struct S_IPF p2) ;
+EXPORT float f13_F_FFS_IPD(float p0, float p1, struct S_IPD p2) ;
+EXPORT float f13_F_FFS_IPP(float p0, float p1, struct S_IPP p2) ;
+EXPORT float f13_F_FFS_FII(float p0, float p1, struct S_FII p2) ;
+EXPORT float f13_F_FFS_FIF(float p0, float p1, struct S_FIF p2) ;
+EXPORT float f13_F_FFS_FID(float p0, float p1, struct S_FID p2) ;
+EXPORT float f13_F_FFS_FIP(float p0, float p1, struct S_FIP p2) ;
+EXPORT float f13_F_FFS_FFI(float p0, float p1, struct S_FFI p2) ;
+EXPORT float f13_F_FFS_FFF(float p0, float p1, struct S_FFF p2) ;
+EXPORT float f13_F_FFS_FFD(float p0, float p1, struct S_FFD p2) ;
+EXPORT float f13_F_FFS_FFP(float p0, float p1, struct S_FFP p2) ;
+EXPORT float f13_F_FFS_FDI(float p0, float p1, struct S_FDI p2) ;
+EXPORT float f13_F_FFS_FDF(float p0, float p1, struct S_FDF p2) ;
+EXPORT float f13_F_FFS_FDD(float p0, float p1, struct S_FDD p2) ;
+EXPORT float f13_F_FFS_FDP(float p0, float p1, struct S_FDP p2) ;
+EXPORT float f13_F_FFS_FPI(float p0, float p1, struct S_FPI p2) ;
+EXPORT float f13_F_FFS_FPF(float p0, float p1, struct S_FPF p2) ;
+EXPORT float f13_F_FFS_FPD(float p0, float p1, struct S_FPD p2) ;
+EXPORT float f13_F_FFS_FPP(float p0, float p1, struct S_FPP p2) ;
+EXPORT float f13_F_FFS_DII(float p0, float p1, struct S_DII p2) ;
+EXPORT float f13_F_FFS_DIF(float p0, float p1, struct S_DIF p2) ;
+EXPORT float f13_F_FFS_DID(float p0, float p1, struct S_DID p2) ;
+EXPORT float f13_F_FFS_DIP(float p0, float p1, struct S_DIP p2) ;
+EXPORT float f13_F_FFS_DFI(float p0, float p1, struct S_DFI p2) ;
+EXPORT float f13_F_FFS_DFF(float p0, float p1, struct S_DFF p2) ;
+EXPORT float f13_F_FFS_DFD(float p0, float p1, struct S_DFD p2) ;
+EXPORT float f13_F_FFS_DFP(float p0, float p1, struct S_DFP p2) ;
+EXPORT float f13_F_FFS_DDI(float p0, float p1, struct S_DDI p2) ;
+EXPORT float f13_F_FFS_DDF(float p0, float p1, struct S_DDF p2) ;
+EXPORT float f13_F_FFS_DDD(float p0, float p1, struct S_DDD p2) ;
+EXPORT float f13_F_FFS_DDP(float p0, float p1, struct S_DDP p2) ;
+EXPORT float f13_F_FFS_DPI(float p0, float p1, struct S_DPI p2) ;
+EXPORT float f13_F_FFS_DPF(float p0, float p1, struct S_DPF p2) ;
+EXPORT float f13_F_FFS_DPD(float p0, float p1, struct S_DPD p2) ;
+EXPORT float f13_F_FFS_DPP(float p0, float p1, struct S_DPP p2) ;
+EXPORT float f13_F_FFS_PII(float p0, float p1, struct S_PII p2) ;
+EXPORT float f13_F_FFS_PIF(float p0, float p1, struct S_PIF p2) ;
+EXPORT float f13_F_FFS_PID(float p0, float p1, struct S_PID p2) ;
+EXPORT float f13_F_FFS_PIP(float p0, float p1, struct S_PIP p2) ;
+EXPORT float f13_F_FFS_PFI(float p0, float p1, struct S_PFI p2) ;
+EXPORT float f13_F_FFS_PFF(float p0, float p1, struct S_PFF p2) ;
+EXPORT float f13_F_FFS_PFD(float p0, float p1, struct S_PFD p2) ;
+EXPORT float f13_F_FFS_PFP(float p0, float p1, struct S_PFP p2) ;
+EXPORT float f13_F_FFS_PDI(float p0, float p1, struct S_PDI p2) ;
+EXPORT float f13_F_FFS_PDF(float p0, float p1, struct S_PDF p2) ;
+EXPORT float f13_F_FFS_PDD(float p0, float p1, struct S_PDD p2) ;
+EXPORT float f13_F_FFS_PDP(float p0, float p1, struct S_PDP p2) ;
+EXPORT float f13_F_FFS_PPI(float p0, float p1, struct S_PPI p2) ;
+EXPORT float f13_F_FFS_PPF(float p0, float p1, struct S_PPF p2) ;
+EXPORT float f13_F_FFS_PPD(float p0, float p1, struct S_PPD p2) ;
+EXPORT float f13_F_FFS_PPP(float p0, float p1, struct S_PPP p2) ;
+EXPORT float f13_F_FDI_(float p0, double p1, int p2) ;
+EXPORT float f13_F_FDF_(float p0, double p1, float p2) ;
+EXPORT float f13_F_FDD_(float p0, double p1, double p2) ;
+EXPORT float f13_F_FDP_(float p0, double p1, void* p2) ;
+EXPORT float f13_F_FDS_I(float p0, double p1, struct S_I p2) ;
+EXPORT float f13_F_FDS_F(float p0, double p1, struct S_F p2) ;
+EXPORT float f13_F_FDS_D(float p0, double p1, struct S_D p2) ;
+EXPORT float f13_F_FDS_P(float p0, double p1, struct S_P p2) ;
+EXPORT float f13_F_FDS_II(float p0, double p1, struct S_II p2) ;
+EXPORT float f13_F_FDS_IF(float p0, double p1, struct S_IF p2) ;
+EXPORT float f13_F_FDS_ID(float p0, double p1, struct S_ID p2) ;
+EXPORT float f13_F_FDS_IP(float p0, double p1, struct S_IP p2) ;
+EXPORT float f13_F_FDS_FI(float p0, double p1, struct S_FI p2) ;
+EXPORT float f13_F_FDS_FF(float p0, double p1, struct S_FF p2) ;
+EXPORT float f13_F_FDS_FD(float p0, double p1, struct S_FD p2) ;
+EXPORT float f13_F_FDS_FP(float p0, double p1, struct S_FP p2) ;
+EXPORT float f13_F_FDS_DI(float p0, double p1, struct S_DI p2) ;
+EXPORT float f13_F_FDS_DF(float p0, double p1, struct S_DF p2) ;
+EXPORT float f13_F_FDS_DD(float p0, double p1, struct S_DD p2) ;
+EXPORT float f13_F_FDS_DP(float p0, double p1, struct S_DP p2) ;
+EXPORT float f13_F_FDS_PI(float p0, double p1, struct S_PI p2) ;
+EXPORT float f13_F_FDS_PF(float p0, double p1, struct S_PF p2) ;
+EXPORT float f13_F_FDS_PD(float p0, double p1, struct S_PD p2) ;
+EXPORT float f13_F_FDS_PP(float p0, double p1, struct S_PP p2) ;
+EXPORT float f13_F_FDS_III(float p0, double p1, struct S_III p2) ;
+EXPORT float f13_F_FDS_IIF(float p0, double p1, struct S_IIF p2) ;
+EXPORT float f13_F_FDS_IID(float p0, double p1, struct S_IID p2) ;
+EXPORT float f13_F_FDS_IIP(float p0, double p1, struct S_IIP p2) ;
+EXPORT float f13_F_FDS_IFI(float p0, double p1, struct S_IFI p2) ;
+EXPORT float f13_F_FDS_IFF(float p0, double p1, struct S_IFF p2) ;
+EXPORT float f13_F_FDS_IFD(float p0, double p1, struct S_IFD p2) ;
+EXPORT float f13_F_FDS_IFP(float p0, double p1, struct S_IFP p2) ;
+EXPORT float f13_F_FDS_IDI(float p0, double p1, struct S_IDI p2) ;
+EXPORT float f13_F_FDS_IDF(float p0, double p1, struct S_IDF p2) ;
+EXPORT float f13_F_FDS_IDD(float p0, double p1, struct S_IDD p2) ;
+EXPORT float f13_F_FDS_IDP(float p0, double p1, struct S_IDP p2) ;
+EXPORT float f13_F_FDS_IPI(float p0, double p1, struct S_IPI p2) ;
+EXPORT float f13_F_FDS_IPF(float p0, double p1, struct S_IPF p2) ;
+EXPORT float f13_F_FDS_IPD(float p0, double p1, struct S_IPD p2) ;
+EXPORT float f13_F_FDS_IPP(float p0, double p1, struct S_IPP p2) ;
+EXPORT float f13_F_FDS_FII(float p0, double p1, struct S_FII p2) ;
+EXPORT float f13_F_FDS_FIF(float p0, double p1, struct S_FIF p2) ;
+EXPORT float f13_F_FDS_FID(float p0, double p1, struct S_FID p2) ;
+EXPORT float f13_F_FDS_FIP(float p0, double p1, struct S_FIP p2) ;
+EXPORT float f13_F_FDS_FFI(float p0, double p1, struct S_FFI p2) ;
+EXPORT float f13_F_FDS_FFF(float p0, double p1, struct S_FFF p2) ;
+EXPORT float f13_F_FDS_FFD(float p0, double p1, struct S_FFD p2) ;
+EXPORT float f13_F_FDS_FFP(float p0, double p1, struct S_FFP p2) ;
+EXPORT float f13_F_FDS_FDI(float p0, double p1, struct S_FDI p2) ;
+EXPORT float f13_F_FDS_FDF(float p0, double p1, struct S_FDF p2) ;
+EXPORT float f13_F_FDS_FDD(float p0, double p1, struct S_FDD p2) ;
+EXPORT float f13_F_FDS_FDP(float p0, double p1, struct S_FDP p2) ;
+EXPORT float f13_F_FDS_FPI(float p0, double p1, struct S_FPI p2) ;
+EXPORT float f13_F_FDS_FPF(float p0, double p1, struct S_FPF p2) ;
+EXPORT float f13_F_FDS_FPD(float p0, double p1, struct S_FPD p2) ;
+EXPORT float f13_F_FDS_FPP(float p0, double p1, struct S_FPP p2) ;
+EXPORT float f13_F_FDS_DII(float p0, double p1, struct S_DII p2) ;
+EXPORT float f13_F_FDS_DIF(float p0, double p1, struct S_DIF p2) ;
+EXPORT float f13_F_FDS_DID(float p0, double p1, struct S_DID p2) ;
+EXPORT float f13_F_FDS_DIP(float p0, double p1, struct S_DIP p2) ;
+EXPORT float f13_F_FDS_DFI(float p0, double p1, struct S_DFI p2) ;
+EXPORT float f13_F_FDS_DFF(float p0, double p1, struct S_DFF p2) ;
+EXPORT float f13_F_FDS_DFD(float p0, double p1, struct S_DFD p2) ;
+EXPORT float f13_F_FDS_DFP(float p0, double p1, struct S_DFP p2) ;
+EXPORT float f13_F_FDS_DDI(float p0, double p1, struct S_DDI p2) ;
+EXPORT float f13_F_FDS_DDF(float p0, double p1, struct S_DDF p2) ;
+EXPORT float f13_F_FDS_DDD(float p0, double p1, struct S_DDD p2) ;
+EXPORT float f13_F_FDS_DDP(float p0, double p1, struct S_DDP p2) ;
+EXPORT float f13_F_FDS_DPI(float p0, double p1, struct S_DPI p2) ;
+EXPORT float f13_F_FDS_DPF(float p0, double p1, struct S_DPF p2) ;
+EXPORT float f13_F_FDS_DPD(float p0, double p1, struct S_DPD p2) ;
+EXPORT float f13_F_FDS_DPP(float p0, double p1, struct S_DPP p2) ;
+EXPORT float f13_F_FDS_PII(float p0, double p1, struct S_PII p2) ;
+EXPORT float f13_F_FDS_PIF(float p0, double p1, struct S_PIF p2) ;
+EXPORT float f13_F_FDS_PID(float p0, double p1, struct S_PID p2) ;
+EXPORT float f13_F_FDS_PIP(float p0, double p1, struct S_PIP p2) ;
+EXPORT float f13_F_FDS_PFI(float p0, double p1, struct S_PFI p2) ;
+EXPORT float f13_F_FDS_PFF(float p0, double p1, struct S_PFF p2) ;
+EXPORT float f13_F_FDS_PFD(float p0, double p1, struct S_PFD p2) ;
+EXPORT float f13_F_FDS_PFP(float p0, double p1, struct S_PFP p2) ;
+EXPORT float f13_F_FDS_PDI(float p0, double p1, struct S_PDI p2) ;
+EXPORT float f13_F_FDS_PDF(float p0, double p1, struct S_PDF p2) ;
+EXPORT float f13_F_FDS_PDD(float p0, double p1, struct S_PDD p2) ;
+EXPORT float f13_F_FDS_PDP(float p0, double p1, struct S_PDP p2) ;
+EXPORT float f13_F_FDS_PPI(float p0, double p1, struct S_PPI p2) ;
+EXPORT float f13_F_FDS_PPF(float p0, double p1, struct S_PPF p2) ;
+EXPORT float f13_F_FDS_PPD(float p0, double p1, struct S_PPD p2) ;
+EXPORT float f13_F_FDS_PPP(float p0, double p1, struct S_PPP p2) ;
+EXPORT float f13_F_FPI_(float p0, void* p1, int p2) ;
+EXPORT float f13_F_FPF_(float p0, void* p1, float p2) ;
+EXPORT float f13_F_FPD_(float p0, void* p1, double p2) ;
+EXPORT float f13_F_FPP_(float p0, void* p1, void* p2) ;
+EXPORT float f13_F_FPS_I(float p0, void* p1, struct S_I p2) ;
+EXPORT float f13_F_FPS_F(float p0, void* p1, struct S_F p2) ;
+EXPORT float f13_F_FPS_D(float p0, void* p1, struct S_D p2) ;
+EXPORT float f13_F_FPS_P(float p0, void* p1, struct S_P p2) ;
+EXPORT float f13_F_FPS_II(float p0, void* p1, struct S_II p2) ;
+EXPORT float f13_F_FPS_IF(float p0, void* p1, struct S_IF p2) ;
+EXPORT float f13_F_FPS_ID(float p0, void* p1, struct S_ID p2) ;
+EXPORT float f13_F_FPS_IP(float p0, void* p1, struct S_IP p2) ;
+EXPORT float f13_F_FPS_FI(float p0, void* p1, struct S_FI p2) ;
+EXPORT float f13_F_FPS_FF(float p0, void* p1, struct S_FF p2) ;
+EXPORT float f13_F_FPS_FD(float p0, void* p1, struct S_FD p2) ;
+EXPORT float f13_F_FPS_FP(float p0, void* p1, struct S_FP p2) ;
+EXPORT float f13_F_FPS_DI(float p0, void* p1, struct S_DI p2) ;
+EXPORT float f13_F_FPS_DF(float p0, void* p1, struct S_DF p2) ;
+EXPORT float f13_F_FPS_DD(float p0, void* p1, struct S_DD p2) ;
+EXPORT float f13_F_FPS_DP(float p0, void* p1, struct S_DP p2) ;
+EXPORT float f13_F_FPS_PI(float p0, void* p1, struct S_PI p2) ;
+EXPORT float f13_F_FPS_PF(float p0, void* p1, struct S_PF p2) ;
+EXPORT float f13_F_FPS_PD(float p0, void* p1, struct S_PD p2) ;
+EXPORT float f13_F_FPS_PP(float p0, void* p1, struct S_PP p2) ;
+EXPORT float f13_F_FPS_III(float p0, void* p1, struct S_III p2) ;
+EXPORT float f13_F_FPS_IIF(float p0, void* p1, struct S_IIF p2) ;
+EXPORT float f13_F_FPS_IID(float p0, void* p1, struct S_IID p2) ;
+EXPORT float f13_F_FPS_IIP(float p0, void* p1, struct S_IIP p2) ;
+EXPORT float f13_F_FPS_IFI(float p0, void* p1, struct S_IFI p2) ;
+EXPORT float f13_F_FPS_IFF(float p0, void* p1, struct S_IFF p2) ;
+EXPORT float f13_F_FPS_IFD(float p0, void* p1, struct S_IFD p2) ;
+EXPORT float f13_F_FPS_IFP(float p0, void* p1, struct S_IFP p2) ;
+EXPORT float f13_F_FPS_IDI(float p0, void* p1, struct S_IDI p2) ;
+EXPORT float f13_F_FPS_IDF(float p0, void* p1, struct S_IDF p2) ;
+EXPORT float f13_F_FPS_IDD(float p0, void* p1, struct S_IDD p2) ;
+EXPORT float f13_F_FPS_IDP(float p0, void* p1, struct S_IDP p2) ;
+EXPORT float f13_F_FPS_IPI(float p0, void* p1, struct S_IPI p2) ;
+EXPORT float f13_F_FPS_IPF(float p0, void* p1, struct S_IPF p2) ;
+EXPORT float f13_F_FPS_IPD(float p0, void* p1, struct S_IPD p2) ;
+EXPORT float f13_F_FPS_IPP(float p0, void* p1, struct S_IPP p2) ;
+EXPORT float f13_F_FPS_FII(float p0, void* p1, struct S_FII p2) ;
+EXPORT float f13_F_FPS_FIF(float p0, void* p1, struct S_FIF p2) ;
+EXPORT float f13_F_FPS_FID(float p0, void* p1, struct S_FID p2) ;
+EXPORT float f13_F_FPS_FIP(float p0, void* p1, struct S_FIP p2) ;
+EXPORT float f13_F_FPS_FFI(float p0, void* p1, struct S_FFI p2) ;
+EXPORT float f13_F_FPS_FFF(float p0, void* p1, struct S_FFF p2) ;
+EXPORT float f13_F_FPS_FFD(float p0, void* p1, struct S_FFD p2) ;
+EXPORT float f13_F_FPS_FFP(float p0, void* p1, struct S_FFP p2) ;
+EXPORT float f13_F_FPS_FDI(float p0, void* p1, struct S_FDI p2) ;
+EXPORT float f13_F_FPS_FDF(float p0, void* p1, struct S_FDF p2) ;
+EXPORT float f13_F_FPS_FDD(float p0, void* p1, struct S_FDD p2) ;
+EXPORT float f13_F_FPS_FDP(float p0, void* p1, struct S_FDP p2) ;
+EXPORT float f13_F_FPS_FPI(float p0, void* p1, struct S_FPI p2) ;
+EXPORT float f13_F_FPS_FPF(float p0, void* p1, struct S_FPF p2) ;
+EXPORT float f13_F_FPS_FPD(float p0, void* p1, struct S_FPD p2) ;
+EXPORT float f13_F_FPS_FPP(float p0, void* p1, struct S_FPP p2) ;
+EXPORT float f13_F_FPS_DII(float p0, void* p1, struct S_DII p2) ;
+EXPORT float f13_F_FPS_DIF(float p0, void* p1, struct S_DIF p2) ;
+EXPORT float f13_F_FPS_DID(float p0, void* p1, struct S_DID p2) ;
+EXPORT float f13_F_FPS_DIP(float p0, void* p1, struct S_DIP p2) ;
+EXPORT float f13_F_FPS_DFI(float p0, void* p1, struct S_DFI p2) ;
+EXPORT float f13_F_FPS_DFF(float p0, void* p1, struct S_DFF p2) ;
+EXPORT float f13_F_FPS_DFD(float p0, void* p1, struct S_DFD p2) ;
+EXPORT float f13_F_FPS_DFP(float p0, void* p1, struct S_DFP p2) ;
+EXPORT float f13_F_FPS_DDI(float p0, void* p1, struct S_DDI p2) ;
+EXPORT float f13_F_FPS_DDF(float p0, void* p1, struct S_DDF p2) ;
+EXPORT float f13_F_FPS_DDD(float p0, void* p1, struct S_DDD p2) ;
+EXPORT float f13_F_FPS_DDP(float p0, void* p1, struct S_DDP p2) ;
+EXPORT float f13_F_FPS_DPI(float p0, void* p1, struct S_DPI p2) ;
+EXPORT float f13_F_FPS_DPF(float p0, void* p1, struct S_DPF p2) ;
+EXPORT float f13_F_FPS_DPD(float p0, void* p1, struct S_DPD p2) ;
+EXPORT float f13_F_FPS_DPP(float p0, void* p1, struct S_DPP p2) ;
+EXPORT float f13_F_FPS_PII(float p0, void* p1, struct S_PII p2) ;
+EXPORT float f13_F_FPS_PIF(float p0, void* p1, struct S_PIF p2) ;
+EXPORT float f13_F_FPS_PID(float p0, void* p1, struct S_PID p2) ;
+EXPORT float f13_F_FPS_PIP(float p0, void* p1, struct S_PIP p2) ;
+EXPORT float f13_F_FPS_PFI(float p0, void* p1, struct S_PFI p2) ;
+EXPORT float f13_F_FPS_PFF(float p0, void* p1, struct S_PFF p2) ;
+EXPORT float f13_F_FPS_PFD(float p0, void* p1, struct S_PFD p2) ;
+EXPORT float f13_F_FPS_PFP(float p0, void* p1, struct S_PFP p2) ;
+EXPORT float f13_F_FPS_PDI(float p0, void* p1, struct S_PDI p2) ;
+EXPORT float f13_F_FPS_PDF(float p0, void* p1, struct S_PDF p2) ;
+EXPORT float f13_F_FPS_PDD(float p0, void* p1, struct S_PDD p2) ;
+EXPORT float f13_F_FPS_PDP(float p0, void* p1, struct S_PDP p2) ;
+EXPORT float f13_F_FPS_PPI(float p0, void* p1, struct S_PPI p2) ;
+EXPORT float f13_F_FPS_PPF(float p0, void* p1, struct S_PPF p2) ;
+EXPORT float f13_F_FPS_PPD(float p0, void* p1, struct S_PPD p2) ;
+EXPORT float f13_F_FPS_PPP(float p0, void* p1, struct S_PPP p2) ;
+EXPORT float f13_F_FSI_I(float p0, struct S_I p1, int p2) ;
+EXPORT float f13_F_FSI_F(float p0, struct S_F p1, int p2) ;
+EXPORT float f13_F_FSI_D(float p0, struct S_D p1, int p2) ;
+EXPORT float f13_F_FSI_P(float p0, struct S_P p1, int p2) ;
+EXPORT float f13_F_FSI_II(float p0, struct S_II p1, int p2) ;
+EXPORT float f13_F_FSI_IF(float p0, struct S_IF p1, int p2) ;
+EXPORT float f13_F_FSI_ID(float p0, struct S_ID p1, int p2) ;
+EXPORT float f13_F_FSI_IP(float p0, struct S_IP p1, int p2) ;
+EXPORT float f13_F_FSI_FI(float p0, struct S_FI p1, int p2) ;
+EXPORT float f13_F_FSI_FF(float p0, struct S_FF p1, int p2) ;
+EXPORT float f13_F_FSI_FD(float p0, struct S_FD p1, int p2) ;
+EXPORT float f13_F_FSI_FP(float p0, struct S_FP p1, int p2) ;
+EXPORT float f13_F_FSI_DI(float p0, struct S_DI p1, int p2) ;
+EXPORT float f13_F_FSI_DF(float p0, struct S_DF p1, int p2) ;
+EXPORT float f13_F_FSI_DD(float p0, struct S_DD p1, int p2) ;
+EXPORT float f13_F_FSI_DP(float p0, struct S_DP p1, int p2) ;
+EXPORT float f13_F_FSI_PI(float p0, struct S_PI p1, int p2) ;
+EXPORT float f13_F_FSI_PF(float p0, struct S_PF p1, int p2) ;
+EXPORT float f13_F_FSI_PD(float p0, struct S_PD p1, int p2) ;
+EXPORT float f13_F_FSI_PP(float p0, struct S_PP p1, int p2) ;
+EXPORT float f13_F_FSI_III(float p0, struct S_III p1, int p2) ;
+EXPORT float f13_F_FSI_IIF(float p0, struct S_IIF p1, int p2) ;
+EXPORT float f13_F_FSI_IID(float p0, struct S_IID p1, int p2) ;
+EXPORT float f13_F_FSI_IIP(float p0, struct S_IIP p1, int p2) ;
+EXPORT float f13_F_FSI_IFI(float p0, struct S_IFI p1, int p2) ;
+EXPORT float f13_F_FSI_IFF(float p0, struct S_IFF p1, int p2) ;
+EXPORT float f13_F_FSI_IFD(float p0, struct S_IFD p1, int p2) ;
+EXPORT float f13_F_FSI_IFP(float p0, struct S_IFP p1, int p2) ;
+EXPORT float f13_F_FSI_IDI(float p0, struct S_IDI p1, int p2) ;
+EXPORT float f13_F_FSI_IDF(float p0, struct S_IDF p1, int p2) ;
+EXPORT float f13_F_FSI_IDD(float p0, struct S_IDD p1, int p2) ;
+EXPORT float f13_F_FSI_IDP(float p0, struct S_IDP p1, int p2) ;
+EXPORT float f13_F_FSI_IPI(float p0, struct S_IPI p1, int p2) ;
+EXPORT float f13_F_FSI_IPF(float p0, struct S_IPF p1, int p2) ;
+EXPORT float f13_F_FSI_IPD(float p0, struct S_IPD p1, int p2) ;
+EXPORT float f13_F_FSI_IPP(float p0, struct S_IPP p1, int p2) ;
+EXPORT float f13_F_FSI_FII(float p0, struct S_FII p1, int p2) ;
+EXPORT float f13_F_FSI_FIF(float p0, struct S_FIF p1, int p2) ;
+EXPORT float f13_F_FSI_FID(float p0, struct S_FID p1, int p2) ;
+EXPORT float f13_F_FSI_FIP(float p0, struct S_FIP p1, int p2) ;
+EXPORT float f13_F_FSI_FFI(float p0, struct S_FFI p1, int p2) ;
+EXPORT float f13_F_FSI_FFF(float p0, struct S_FFF p1, int p2) ;
+EXPORT float f13_F_FSI_FFD(float p0, struct S_FFD p1, int p2) ;
+EXPORT float f13_F_FSI_FFP(float p0, struct S_FFP p1, int p2) ;
+EXPORT float f13_F_FSI_FDI(float p0, struct S_FDI p1, int p2) ;
+EXPORT float f13_F_FSI_FDF(float p0, struct S_FDF p1, int p2) ;
+EXPORT float f13_F_FSI_FDD(float p0, struct S_FDD p1, int p2) ;
+EXPORT float f13_F_FSI_FDP(float p0, struct S_FDP p1, int p2) ;
+EXPORT float f13_F_FSI_FPI(float p0, struct S_FPI p1, int p2) ;
+EXPORT float f13_F_FSI_FPF(float p0, struct S_FPF p1, int p2) ;
+EXPORT float f13_F_FSI_FPD(float p0, struct S_FPD p1, int p2) ;
+EXPORT float f13_F_FSI_FPP(float p0, struct S_FPP p1, int p2) ;
+EXPORT float f13_F_FSI_DII(float p0, struct S_DII p1, int p2) ;
+EXPORT float f13_F_FSI_DIF(float p0, struct S_DIF p1, int p2) ;
+EXPORT float f13_F_FSI_DID(float p0, struct S_DID p1, int p2) ;
+EXPORT float f13_F_FSI_DIP(float p0, struct S_DIP p1, int p2) ;
+EXPORT float f13_F_FSI_DFI(float p0, struct S_DFI p1, int p2) ;
+EXPORT float f13_F_FSI_DFF(float p0, struct S_DFF p1, int p2) ;
+EXPORT float f13_F_FSI_DFD(float p0, struct S_DFD p1, int p2) ;
+EXPORT float f13_F_FSI_DFP(float p0, struct S_DFP p1, int p2) ;
+EXPORT float f13_F_FSI_DDI(float p0, struct S_DDI p1, int p2) ;
+EXPORT float f13_F_FSI_DDF(float p0, struct S_DDF p1, int p2) ;
+EXPORT float f13_F_FSI_DDD(float p0, struct S_DDD p1, int p2) ;
+EXPORT float f13_F_FSI_DDP(float p0, struct S_DDP p1, int p2) ;
+EXPORT float f13_F_FSI_DPI(float p0, struct S_DPI p1, int p2) ;
+EXPORT float f13_F_FSI_DPF(float p0, struct S_DPF p1, int p2) ;
+EXPORT float f13_F_FSI_DPD(float p0, struct S_DPD p1, int p2) ;
+EXPORT float f13_F_FSI_DPP(float p0, struct S_DPP p1, int p2) ;
+EXPORT float f13_F_FSI_PII(float p0, struct S_PII p1, int p2) ;
+EXPORT float f13_F_FSI_PIF(float p0, struct S_PIF p1, int p2) ;
+EXPORT float f13_F_FSI_PID(float p0, struct S_PID p1, int p2) ;
+EXPORT float f13_F_FSI_PIP(float p0, struct S_PIP p1, int p2) ;
+EXPORT float f13_F_FSI_PFI(float p0, struct S_PFI p1, int p2) ;
+EXPORT float f13_F_FSI_PFF(float p0, struct S_PFF p1, int p2) ;
+EXPORT float f13_F_FSI_PFD(float p0, struct S_PFD p1, int p2) ;
+EXPORT float f13_F_FSI_PFP(float p0, struct S_PFP p1, int p2) ;
+EXPORT float f13_F_FSI_PDI(float p0, struct S_PDI p1, int p2) ;
+EXPORT float f13_F_FSI_PDF(float p0, struct S_PDF p1, int p2) ;
+EXPORT float f13_F_FSI_PDD(float p0, struct S_PDD p1, int p2) ;
+EXPORT float f13_F_FSI_PDP(float p0, struct S_PDP p1, int p2) ;
+EXPORT float f13_F_FSI_PPI(float p0, struct S_PPI p1, int p2) ;
+EXPORT float f13_F_FSI_PPF(float p0, struct S_PPF p1, int p2) ;
+EXPORT float f13_F_FSI_PPD(float p0, struct S_PPD p1, int p2) ;
+EXPORT float f13_F_FSI_PPP(float p0, struct S_PPP p1, int p2) ;
+EXPORT float f13_F_FSF_I(float p0, struct S_I p1, float p2) ;
+EXPORT float f13_F_FSF_F(float p0, struct S_F p1, float p2) ;
+EXPORT float f13_F_FSF_D(float p0, struct S_D p1, float p2) ;
+EXPORT float f13_F_FSF_P(float p0, struct S_P p1, float p2) ;
+EXPORT float f13_F_FSF_II(float p0, struct S_II p1, float p2) ;
+EXPORT float f13_F_FSF_IF(float p0, struct S_IF p1, float p2) ;
+EXPORT float f13_F_FSF_ID(float p0, struct S_ID p1, float p2) ;
+EXPORT float f13_F_FSF_IP(float p0, struct S_IP p1, float p2) ;
+EXPORT float f13_F_FSF_FI(float p0, struct S_FI p1, float p2) ;
+EXPORT float f13_F_FSF_FF(float p0, struct S_FF p1, float p2) ;
+EXPORT float f13_F_FSF_FD(float p0, struct S_FD p1, float p2) ;
+EXPORT float f13_F_FSF_FP(float p0, struct S_FP p1, float p2) ;
+EXPORT float f13_F_FSF_DI(float p0, struct S_DI p1, float p2) ;
+EXPORT float f13_F_FSF_DF(float p0, struct S_DF p1, float p2) ;
+EXPORT float f13_F_FSF_DD(float p0, struct S_DD p1, float p2) ;
+EXPORT float f13_F_FSF_DP(float p0, struct S_DP p1, float p2) ;
+EXPORT float f13_F_FSF_PI(float p0, struct S_PI p1, float p2) ;
+EXPORT float f13_F_FSF_PF(float p0, struct S_PF p1, float p2) ;
+EXPORT float f13_F_FSF_PD(float p0, struct S_PD p1, float p2) ;
+EXPORT float f13_F_FSF_PP(float p0, struct S_PP p1, float p2) ;
+EXPORT float f13_F_FSF_III(float p0, struct S_III p1, float p2) ;
+EXPORT float f13_F_FSF_IIF(float p0, struct S_IIF p1, float p2) ;
+EXPORT float f13_F_FSF_IID(float p0, struct S_IID p1, float p2) ;
+EXPORT float f13_F_FSF_IIP(float p0, struct S_IIP p1, float p2) ;
+EXPORT float f13_F_FSF_IFI(float p0, struct S_IFI p1, float p2) ;
+EXPORT float f13_F_FSF_IFF(float p0, struct S_IFF p1, float p2) ;
+EXPORT float f13_F_FSF_IFD(float p0, struct S_IFD p1, float p2) ;
+EXPORT float f13_F_FSF_IFP(float p0, struct S_IFP p1, float p2) ;
+EXPORT float f13_F_FSF_IDI(float p0, struct S_IDI p1, float p2) ;
+EXPORT float f13_F_FSF_IDF(float p0, struct S_IDF p1, float p2) ;
+EXPORT float f13_F_FSF_IDD(float p0, struct S_IDD p1, float p2) ;
+EXPORT float f13_F_FSF_IDP(float p0, struct S_IDP p1, float p2) ;
+EXPORT float f13_F_FSF_IPI(float p0, struct S_IPI p1, float p2) ;
+EXPORT float f13_F_FSF_IPF(float p0, struct S_IPF p1, float p2) ;
+EXPORT float f13_F_FSF_IPD(float p0, struct S_IPD p1, float p2) ;
+EXPORT float f13_F_FSF_IPP(float p0, struct S_IPP p1, float p2) ;
+EXPORT float f13_F_FSF_FII(float p0, struct S_FII p1, float p2) ;
+EXPORT float f13_F_FSF_FIF(float p0, struct S_FIF p1, float p2) ;
+EXPORT float f13_F_FSF_FID(float p0, struct S_FID p1, float p2) ;
+EXPORT float f13_F_FSF_FIP(float p0, struct S_FIP p1, float p2) ;
+EXPORT float f13_F_FSF_FFI(float p0, struct S_FFI p1, float p2) ;
+EXPORT float f13_F_FSF_FFF(float p0, struct S_FFF p1, float p2) ;
+EXPORT float f13_F_FSF_FFD(float p0, struct S_FFD p1, float p2) ;
+EXPORT float f13_F_FSF_FFP(float p0, struct S_FFP p1, float p2) ;
+EXPORT float f13_F_FSF_FDI(float p0, struct S_FDI p1, float p2) ;
+EXPORT float f13_F_FSF_FDF(float p0, struct S_FDF p1, float p2) ;
+EXPORT float f13_F_FSF_FDD(float p0, struct S_FDD p1, float p2) ;
+EXPORT float f13_F_FSF_FDP(float p0, struct S_FDP p1, float p2) ;
+EXPORT float f13_F_FSF_FPI(float p0, struct S_FPI p1, float p2) ;
+EXPORT float f13_F_FSF_FPF(float p0, struct S_FPF p1, float p2) ;
+EXPORT float f13_F_FSF_FPD(float p0, struct S_FPD p1, float p2) ;
+EXPORT float f13_F_FSF_FPP(float p0, struct S_FPP p1, float p2) ;
+EXPORT float f13_F_FSF_DII(float p0, struct S_DII p1, float p2) ;
+EXPORT float f13_F_FSF_DIF(float p0, struct S_DIF p1, float p2) ;
+EXPORT float f13_F_FSF_DID(float p0, struct S_DID p1, float p2) ;
+EXPORT float f13_F_FSF_DIP(float p0, struct S_DIP p1, float p2) ;
+EXPORT float f13_F_FSF_DFI(float p0, struct S_DFI p1, float p2) ;
+EXPORT float f13_F_FSF_DFF(float p0, struct S_DFF p1, float p2) ;
+EXPORT float f13_F_FSF_DFD(float p0, struct S_DFD p1, float p2) ;
+EXPORT float f13_F_FSF_DFP(float p0, struct S_DFP p1, float p2) ;
+EXPORT float f13_F_FSF_DDI(float p0, struct S_DDI p1, float p2) ;
+EXPORT float f13_F_FSF_DDF(float p0, struct S_DDF p1, float p2) ;
+EXPORT float f13_F_FSF_DDD(float p0, struct S_DDD p1, float p2) ;
+EXPORT float f13_F_FSF_DDP(float p0, struct S_DDP p1, float p2) ;
+EXPORT float f13_F_FSF_DPI(float p0, struct S_DPI p1, float p2) ;
+EXPORT float f13_F_FSF_DPF(float p0, struct S_DPF p1, float p2) ;
+EXPORT float f13_F_FSF_DPD(float p0, struct S_DPD p1, float p2) ;
+EXPORT float f13_F_FSF_DPP(float p0, struct S_DPP p1, float p2) ;
+EXPORT float f13_F_FSF_PII(float p0, struct S_PII p1, float p2) ;
+EXPORT float f13_F_FSF_PIF(float p0, struct S_PIF p1, float p2) ;
+EXPORT float f13_F_FSF_PID(float p0, struct S_PID p1, float p2) ;
+EXPORT float f13_F_FSF_PIP(float p0, struct S_PIP p1, float p2) ;
+EXPORT float f13_F_FSF_PFI(float p0, struct S_PFI p1, float p2) ;
+EXPORT float f13_F_FSF_PFF(float p0, struct S_PFF p1, float p2) ;
+EXPORT float f13_F_FSF_PFD(float p0, struct S_PFD p1, float p2) ;
+EXPORT float f13_F_FSF_PFP(float p0, struct S_PFP p1, float p2) ;
+EXPORT float f13_F_FSF_PDI(float p0, struct S_PDI p1, float p2) ;
+EXPORT float f13_F_FSF_PDF(float p0, struct S_PDF p1, float p2) ;
+EXPORT float f13_F_FSF_PDD(float p0, struct S_PDD p1, float p2) ;
+EXPORT float f13_F_FSF_PDP(float p0, struct S_PDP p1, float p2) ;
+EXPORT float f13_F_FSF_PPI(float p0, struct S_PPI p1, float p2) ;
+EXPORT float f13_F_FSF_PPF(float p0, struct S_PPF p1, float p2) ;
+EXPORT float f13_F_FSF_PPD(float p0, struct S_PPD p1, float p2) ;
+EXPORT float f13_F_FSF_PPP(float p0, struct S_PPP p1, float p2) ;
+EXPORT float f13_F_FSD_I(float p0, struct S_I p1, double p2) ;
+EXPORT float f13_F_FSD_F(float p0, struct S_F p1, double p2) ;
+EXPORT float f13_F_FSD_D(float p0, struct S_D p1, double p2) ;
+EXPORT float f13_F_FSD_P(float p0, struct S_P p1, double p2) ;
+EXPORT float f13_F_FSD_II(float p0, struct S_II p1, double p2) ;
+EXPORT float f13_F_FSD_IF(float p0, struct S_IF p1, double p2) ;
+EXPORT float f13_F_FSD_ID(float p0, struct S_ID p1, double p2) ;
+EXPORT float f13_F_FSD_IP(float p0, struct S_IP p1, double p2) ;
+EXPORT float f13_F_FSD_FI(float p0, struct S_FI p1, double p2) ;
+EXPORT float f13_F_FSD_FF(float p0, struct S_FF p1, double p2) ;
+EXPORT float f13_F_FSD_FD(float p0, struct S_FD p1, double p2) ;
+EXPORT float f13_F_FSD_FP(float p0, struct S_FP p1, double p2) ;
+EXPORT float f13_F_FSD_DI(float p0, struct S_DI p1, double p2) ;
+EXPORT float f13_F_FSD_DF(float p0, struct S_DF p1, double p2) ;
+EXPORT float f13_F_FSD_DD(float p0, struct S_DD p1, double p2) ;
+EXPORT float f13_F_FSD_DP(float p0, struct S_DP p1, double p2) ;
+EXPORT float f13_F_FSD_PI(float p0, struct S_PI p1, double p2) ;
+EXPORT float f13_F_FSD_PF(float p0, struct S_PF p1, double p2) ;
+EXPORT float f13_F_FSD_PD(float p0, struct S_PD p1, double p2) ;
+EXPORT float f13_F_FSD_PP(float p0, struct S_PP p1, double p2) ;
+EXPORT float f13_F_FSD_III(float p0, struct S_III p1, double p2) ;
+EXPORT float f13_F_FSD_IIF(float p0, struct S_IIF p1, double p2) ;
+EXPORT float f13_F_FSD_IID(float p0, struct S_IID p1, double p2) ;
+EXPORT float f13_F_FSD_IIP(float p0, struct S_IIP p1, double p2) ;
+EXPORT float f13_F_FSD_IFI(float p0, struct S_IFI p1, double p2) ;
+EXPORT float f13_F_FSD_IFF(float p0, struct S_IFF p1, double p2) ;
+EXPORT float f13_F_FSD_IFD(float p0, struct S_IFD p1, double p2) ;
+EXPORT float f13_F_FSD_IFP(float p0, struct S_IFP p1, double p2) ;
+EXPORT float f13_F_FSD_IDI(float p0, struct S_IDI p1, double p2) ;
+EXPORT float f13_F_FSD_IDF(float p0, struct S_IDF p1, double p2) ;
+EXPORT float f13_F_FSD_IDD(float p0, struct S_IDD p1, double p2) ;
+EXPORT float f13_F_FSD_IDP(float p0, struct S_IDP p1, double p2) ;
+EXPORT float f13_F_FSD_IPI(float p0, struct S_IPI p1, double p2) ;
+EXPORT float f13_F_FSD_IPF(float p0, struct S_IPF p1, double p2) ;
+EXPORT float f13_F_FSD_IPD(float p0, struct S_IPD p1, double p2) ;
+EXPORT float f13_F_FSD_IPP(float p0, struct S_IPP p1, double p2) ;
+EXPORT float f13_F_FSD_FII(float p0, struct S_FII p1, double p2) ;
+EXPORT float f13_F_FSD_FIF(float p0, struct S_FIF p1, double p2) ;
+EXPORT float f13_F_FSD_FID(float p0, struct S_FID p1, double p2) ;
+EXPORT float f13_F_FSD_FIP(float p0, struct S_FIP p1, double p2) ;
+EXPORT float f13_F_FSD_FFI(float p0, struct S_FFI p1, double p2) ;
+EXPORT float f13_F_FSD_FFF(float p0, struct S_FFF p1, double p2) ;
+EXPORT float f13_F_FSD_FFD(float p0, struct S_FFD p1, double p2) ;
+EXPORT float f13_F_FSD_FFP(float p0, struct S_FFP p1, double p2) ;
+EXPORT float f13_F_FSD_FDI(float p0, struct S_FDI p1, double p2) ;
+EXPORT float f13_F_FSD_FDF(float p0, struct S_FDF p1, double p2) ;
+EXPORT float f13_F_FSD_FDD(float p0, struct S_FDD p1, double p2) ;
+EXPORT float f13_F_FSD_FDP(float p0, struct S_FDP p1, double p2) ;
+EXPORT float f13_F_FSD_FPI(float p0, struct S_FPI p1, double p2) ;
+EXPORT float f13_F_FSD_FPF(float p0, struct S_FPF p1, double p2) ;
+EXPORT float f13_F_FSD_FPD(float p0, struct S_FPD p1, double p2) ;
+EXPORT float f13_F_FSD_FPP(float p0, struct S_FPP p1, double p2) ;
+EXPORT float f13_F_FSD_DII(float p0, struct S_DII p1, double p2) ;
+EXPORT float f13_F_FSD_DIF(float p0, struct S_DIF p1, double p2) ;
+EXPORT float f13_F_FSD_DID(float p0, struct S_DID p1, double p2) ;
+EXPORT float f13_F_FSD_DIP(float p0, struct S_DIP p1, double p2) ;
+EXPORT float f13_F_FSD_DFI(float p0, struct S_DFI p1, double p2) ;
+EXPORT float f13_F_FSD_DFF(float p0, struct S_DFF p1, double p2) ;
+EXPORT float f13_F_FSD_DFD(float p0, struct S_DFD p1, double p2) ;
+EXPORT float f13_F_FSD_DFP(float p0, struct S_DFP p1, double p2) ;
+EXPORT float f13_F_FSD_DDI(float p0, struct S_DDI p1, double p2) ;
+EXPORT float f13_F_FSD_DDF(float p0, struct S_DDF p1, double p2) ;
+EXPORT float f13_F_FSD_DDD(float p0, struct S_DDD p1, double p2) ;
+EXPORT float f13_F_FSD_DDP(float p0, struct S_DDP p1, double p2) ;
+EXPORT float f13_F_FSD_DPI(float p0, struct S_DPI p1, double p2) ;
+EXPORT float f13_F_FSD_DPF(float p0, struct S_DPF p1, double p2) ;
+EXPORT float f13_F_FSD_DPD(float p0, struct S_DPD p1, double p2) ;
+EXPORT float f13_F_FSD_DPP(float p0, struct S_DPP p1, double p2) ;
+EXPORT float f13_F_FSD_PII(float p0, struct S_PII p1, double p2) ;
+EXPORT float f13_F_FSD_PIF(float p0, struct S_PIF p1, double p2) ;
+EXPORT float f13_F_FSD_PID(float p0, struct S_PID p1, double p2) ;
+EXPORT float f13_F_FSD_PIP(float p0, struct S_PIP p1, double p2) ;
+EXPORT float f13_F_FSD_PFI(float p0, struct S_PFI p1, double p2) ;
+EXPORT float f13_F_FSD_PFF(float p0, struct S_PFF p1, double p2) ;
+EXPORT float f13_F_FSD_PFD(float p0, struct S_PFD p1, double p2) ;
+EXPORT float f13_F_FSD_PFP(float p0, struct S_PFP p1, double p2) ;
+EXPORT float f13_F_FSD_PDI(float p0, struct S_PDI p1, double p2) ;
+EXPORT float f13_F_FSD_PDF(float p0, struct S_PDF p1, double p2) ;
+EXPORT float f13_F_FSD_PDD(float p0, struct S_PDD p1, double p2) ;
+EXPORT float f13_F_FSD_PDP(float p0, struct S_PDP p1, double p2) ;
+EXPORT float f13_F_FSD_PPI(float p0, struct S_PPI p1, double p2) ;
+EXPORT float f13_F_FSD_PPF(float p0, struct S_PPF p1, double p2) ;
+EXPORT float f13_F_FSD_PPD(float p0, struct S_PPD p1, double p2) ;
+EXPORT float f13_F_FSD_PPP(float p0, struct S_PPP p1, double p2) ;
+EXPORT float f13_F_FSP_I(float p0, struct S_I p1, void* p2) ;
+EXPORT float f13_F_FSP_F(float p0, struct S_F p1, void* p2) ;
+EXPORT float f13_F_FSP_D(float p0, struct S_D p1, void* p2) ;
+EXPORT float f13_F_FSP_P(float p0, struct S_P p1, void* p2) ;
+EXPORT float f13_F_FSP_II(float p0, struct S_II p1, void* p2) ;
+EXPORT float f13_F_FSP_IF(float p0, struct S_IF p1, void* p2) ;
+EXPORT float f13_F_FSP_ID(float p0, struct S_ID p1, void* p2) ;
+EXPORT float f13_F_FSP_IP(float p0, struct S_IP p1, void* p2) ;
+EXPORT float f13_F_FSP_FI(float p0, struct S_FI p1, void* p2) ;
+EXPORT float f13_F_FSP_FF(float p0, struct S_FF p1, void* p2) ;
+EXPORT float f13_F_FSP_FD(float p0, struct S_FD p1, void* p2) ;
+EXPORT float f13_F_FSP_FP(float p0, struct S_FP p1, void* p2) ;
+EXPORT float f13_F_FSP_DI(float p0, struct S_DI p1, void* p2) ;
+EXPORT float f13_F_FSP_DF(float p0, struct S_DF p1, void* p2) ;
+EXPORT float f13_F_FSP_DD(float p0, struct S_DD p1, void* p2) ;
+EXPORT float f13_F_FSP_DP(float p0, struct S_DP p1, void* p2) ;
+EXPORT float f13_F_FSP_PI(float p0, struct S_PI p1, void* p2) ;
+EXPORT float f13_F_FSP_PF(float p0, struct S_PF p1, void* p2) ;
+EXPORT float f13_F_FSP_PD(float p0, struct S_PD p1, void* p2) ;
+EXPORT float f13_F_FSP_PP(float p0, struct S_PP p1, void* p2) ;
+EXPORT float f13_F_FSP_III(float p0, struct S_III p1, void* p2) ;
+EXPORT float f13_F_FSP_IIF(float p0, struct S_IIF p1, void* p2) ;
+EXPORT float f13_F_FSP_IID(float p0, struct S_IID p1, void* p2) ;
+EXPORT float f13_F_FSP_IIP(float p0, struct S_IIP p1, void* p2) ;
+EXPORT float f13_F_FSP_IFI(float p0, struct S_IFI p1, void* p2) ;
+EXPORT float f13_F_FSP_IFF(float p0, struct S_IFF p1, void* p2) ;
+EXPORT float f13_F_FSP_IFD(float p0, struct S_IFD p1, void* p2) ;
+EXPORT float f13_F_FSP_IFP(float p0, struct S_IFP p1, void* p2) ;
+EXPORT float f13_F_FSP_IDI(float p0, struct S_IDI p1, void* p2) ;
+EXPORT float f13_F_FSP_IDF(float p0, struct S_IDF p1, void* p2) ;
+EXPORT float f13_F_FSP_IDD(float p0, struct S_IDD p1, void* p2) ;
+EXPORT float f13_F_FSP_IDP(float p0, struct S_IDP p1, void* p2) ;
+EXPORT float f13_F_FSP_IPI(float p0, struct S_IPI p1, void* p2) ;
+EXPORT float f13_F_FSP_IPF(float p0, struct S_IPF p1, void* p2) ;
+EXPORT float f13_F_FSP_IPD(float p0, struct S_IPD p1, void* p2) ;
+EXPORT float f13_F_FSP_IPP(float p0, struct S_IPP p1, void* p2) ;
+EXPORT float f13_F_FSP_FII(float p0, struct S_FII p1, void* p2) ;
+EXPORT float f13_F_FSP_FIF(float p0, struct S_FIF p1, void* p2) ;
+EXPORT float f13_F_FSP_FID(float p0, struct S_FID p1, void* p2) ;
+EXPORT float f13_F_FSP_FIP(float p0, struct S_FIP p1, void* p2) ;
+EXPORT float f13_F_FSP_FFI(float p0, struct S_FFI p1, void* p2) ;
+EXPORT float f13_F_FSP_FFF(float p0, struct S_FFF p1, void* p2) ;
+EXPORT float f13_F_FSP_FFD(float p0, struct S_FFD p1, void* p2) ;
+EXPORT float f13_F_FSP_FFP(float p0, struct S_FFP p1, void* p2) ;
+EXPORT float f13_F_FSP_FDI(float p0, struct S_FDI p1, void* p2) ;
+EXPORT float f13_F_FSP_FDF(float p0, struct S_FDF p1, void* p2) ;
+EXPORT float f13_F_FSP_FDD(float p0, struct S_FDD p1, void* p2) ;
+EXPORT float f13_F_FSP_FDP(float p0, struct S_FDP p1, void* p2) ;
+EXPORT float f13_F_FSP_FPI(float p0, struct S_FPI p1, void* p2) ;
+EXPORT float f13_F_FSP_FPF(float p0, struct S_FPF p1, void* p2) ;
+EXPORT float f13_F_FSP_FPD(float p0, struct S_FPD p1, void* p2) ;
+EXPORT float f13_F_FSP_FPP(float p0, struct S_FPP p1, void* p2) ;
+EXPORT float f13_F_FSP_DII(float p0, struct S_DII p1, void* p2) ;
+EXPORT float f13_F_FSP_DIF(float p0, struct S_DIF p1, void* p2) ;
+EXPORT float f13_F_FSP_DID(float p0, struct S_DID p1, void* p2) ;
+EXPORT float f13_F_FSP_DIP(float p0, struct S_DIP p1, void* p2) ;
+EXPORT float f13_F_FSP_DFI(float p0, struct S_DFI p1, void* p2) ;
+EXPORT float f13_F_FSP_DFF(float p0, struct S_DFF p1, void* p2) ;
+EXPORT float f13_F_FSP_DFD(float p0, struct S_DFD p1, void* p2) ;
+EXPORT float f13_F_FSP_DFP(float p0, struct S_DFP p1, void* p2) ;
+EXPORT float f13_F_FSP_DDI(float p0, struct S_DDI p1, void* p2) ;
+EXPORT float f13_F_FSP_DDF(float p0, struct S_DDF p1, void* p2) ;
+EXPORT float f13_F_FSP_DDD(float p0, struct S_DDD p1, void* p2) ;
+EXPORT float f13_F_FSP_DDP(float p0, struct S_DDP p1, void* p2) ;
+EXPORT float f13_F_FSP_DPI(float p0, struct S_DPI p1, void* p2) ;
+EXPORT float f13_F_FSP_DPF(float p0, struct S_DPF p1, void* p2) ;
+EXPORT float f13_F_FSP_DPD(float p0, struct S_DPD p1, void* p2) ;
+EXPORT float f13_F_FSP_DPP(float p0, struct S_DPP p1, void* p2) ;
+EXPORT float f13_F_FSP_PII(float p0, struct S_PII p1, void* p2) ;
+EXPORT float f13_F_FSP_PIF(float p0, struct S_PIF p1, void* p2) ;
+EXPORT float f13_F_FSP_PID(float p0, struct S_PID p1, void* p2) ;
+EXPORT float f13_F_FSP_PIP(float p0, struct S_PIP p1, void* p2) ;
+EXPORT float f13_F_FSP_PFI(float p0, struct S_PFI p1, void* p2) ;
+EXPORT float f13_F_FSP_PFF(float p0, struct S_PFF p1, void* p2) ;
+EXPORT float f13_F_FSP_PFD(float p0, struct S_PFD p1, void* p2) ;
+EXPORT float f13_F_FSP_PFP(float p0, struct S_PFP p1, void* p2) ;
+EXPORT float f13_F_FSP_PDI(float p0, struct S_PDI p1, void* p2) ;
+EXPORT float f13_F_FSP_PDF(float p0, struct S_PDF p1, void* p2) ;
+EXPORT float f13_F_FSP_PDD(float p0, struct S_PDD p1, void* p2) ;
+EXPORT float f13_F_FSP_PDP(float p0, struct S_PDP p1, void* p2) ;
+EXPORT float f13_F_FSP_PPI(float p0, struct S_PPI p1, void* p2) ;
+EXPORT float f13_F_FSP_PPF(float p0, struct S_PPF p1, void* p2) ;
+EXPORT float f13_F_FSP_PPD(float p0, struct S_PPD p1, void* p2) ;
+EXPORT float f13_F_FSP_PPP(float p0, struct S_PPP p1, void* p2) ;
+EXPORT float f13_F_FSS_I(float p0, struct S_I p1, struct S_I p2) ;
+EXPORT float f13_F_FSS_F(float p0, struct S_F p1, struct S_F p2) ;
+EXPORT float f13_F_FSS_D(float p0, struct S_D p1, struct S_D p2) ;
+EXPORT float f13_F_FSS_P(float p0, struct S_P p1, struct S_P p2) ;
+EXPORT float f13_F_FSS_II(float p0, struct S_II p1, struct S_II p2) ;
+EXPORT float f13_F_FSS_IF(float p0, struct S_IF p1, struct S_IF p2) ;
+EXPORT float f13_F_FSS_ID(float p0, struct S_ID p1, struct S_ID p2) ;
+EXPORT float f13_F_FSS_IP(float p0, struct S_IP p1, struct S_IP p2) ;
+EXPORT float f13_F_FSS_FI(float p0, struct S_FI p1, struct S_FI p2) ;
+EXPORT float f13_F_FSS_FF(float p0, struct S_FF p1, struct S_FF p2) ;
+EXPORT float f13_F_FSS_FD(float p0, struct S_FD p1, struct S_FD p2) ;
+EXPORT float f13_F_FSS_FP(float p0, struct S_FP p1, struct S_FP p2) ;
+EXPORT float f13_F_FSS_DI(float p0, struct S_DI p1, struct S_DI p2) ;
+EXPORT float f13_F_FSS_DF(float p0, struct S_DF p1, struct S_DF p2) ;
+EXPORT float f13_F_FSS_DD(float p0, struct S_DD p1, struct S_DD p2) ;
+EXPORT float f13_F_FSS_DP(float p0, struct S_DP p1, struct S_DP p2) ;
+EXPORT float f13_F_FSS_PI(float p0, struct S_PI p1, struct S_PI p2) ;
+EXPORT float f13_F_FSS_PF(float p0, struct S_PF p1, struct S_PF p2) ;
+EXPORT float f13_F_FSS_PD(float p0, struct S_PD p1, struct S_PD p2) ;
+EXPORT float f13_F_FSS_PP(float p0, struct S_PP p1, struct S_PP p2) ;
+EXPORT float f13_F_FSS_III(float p0, struct S_III p1, struct S_III p2) ;
+EXPORT float f13_F_FSS_IIF(float p0, struct S_IIF p1, struct S_IIF p2) ;
+EXPORT float f13_F_FSS_IID(float p0, struct S_IID p1, struct S_IID p2) ;
+EXPORT float f13_F_FSS_IIP(float p0, struct S_IIP p1, struct S_IIP p2) ;
+EXPORT float f13_F_FSS_IFI(float p0, struct S_IFI p1, struct S_IFI p2) ;
+EXPORT float f13_F_FSS_IFF(float p0, struct S_IFF p1, struct S_IFF p2) ;
+EXPORT float f13_F_FSS_IFD(float p0, struct S_IFD p1, struct S_IFD p2) ;
+EXPORT float f13_F_FSS_IFP(float p0, struct S_IFP p1, struct S_IFP p2) ;
+EXPORT float f13_F_FSS_IDI(float p0, struct S_IDI p1, struct S_IDI p2) ;
+EXPORT float f13_F_FSS_IDF(float p0, struct S_IDF p1, struct S_IDF p2) ;
+EXPORT float f13_F_FSS_IDD(float p0, struct S_IDD p1, struct S_IDD p2) ;
+EXPORT float f14_F_FSS_IDP(float p0, struct S_IDP p1, struct S_IDP p2) ;
+EXPORT float f14_F_FSS_IPI(float p0, struct S_IPI p1, struct S_IPI p2) ;
+EXPORT float f14_F_FSS_IPF(float p0, struct S_IPF p1, struct S_IPF p2) ;
+EXPORT float f14_F_FSS_IPD(float p0, struct S_IPD p1, struct S_IPD p2) ;
+EXPORT float f14_F_FSS_IPP(float p0, struct S_IPP p1, struct S_IPP p2) ;
+EXPORT float f14_F_FSS_FII(float p0, struct S_FII p1, struct S_FII p2) ;
+EXPORT float f14_F_FSS_FIF(float p0, struct S_FIF p1, struct S_FIF p2) ;
+EXPORT float f14_F_FSS_FID(float p0, struct S_FID p1, struct S_FID p2) ;
+EXPORT float f14_F_FSS_FIP(float p0, struct S_FIP p1, struct S_FIP p2) ;
+EXPORT float f14_F_FSS_FFI(float p0, struct S_FFI p1, struct S_FFI p2) ;
+EXPORT float f14_F_FSS_FFF(float p0, struct S_FFF p1, struct S_FFF p2) ;
+EXPORT float f14_F_FSS_FFD(float p0, struct S_FFD p1, struct S_FFD p2) ;
+EXPORT float f14_F_FSS_FFP(float p0, struct S_FFP p1, struct S_FFP p2) ;
+EXPORT float f14_F_FSS_FDI(float p0, struct S_FDI p1, struct S_FDI p2) ;
+EXPORT float f14_F_FSS_FDF(float p0, struct S_FDF p1, struct S_FDF p2) ;
+EXPORT float f14_F_FSS_FDD(float p0, struct S_FDD p1, struct S_FDD p2) ;
+EXPORT float f14_F_FSS_FDP(float p0, struct S_FDP p1, struct S_FDP p2) ;
+EXPORT float f14_F_FSS_FPI(float p0, struct S_FPI p1, struct S_FPI p2) ;
+EXPORT float f14_F_FSS_FPF(float p0, struct S_FPF p1, struct S_FPF p2) ;
+EXPORT float f14_F_FSS_FPD(float p0, struct S_FPD p1, struct S_FPD p2) ;
+EXPORT float f14_F_FSS_FPP(float p0, struct S_FPP p1, struct S_FPP p2) ;
+EXPORT float f14_F_FSS_DII(float p0, struct S_DII p1, struct S_DII p2) ;
+EXPORT float f14_F_FSS_DIF(float p0, struct S_DIF p1, struct S_DIF p2) ;
+EXPORT float f14_F_FSS_DID(float p0, struct S_DID p1, struct S_DID p2) ;
+EXPORT float f14_F_FSS_DIP(float p0, struct S_DIP p1, struct S_DIP p2) ;
+EXPORT float f14_F_FSS_DFI(float p0, struct S_DFI p1, struct S_DFI p2) ;
+EXPORT float f14_F_FSS_DFF(float p0, struct S_DFF p1, struct S_DFF p2) ;
+EXPORT float f14_F_FSS_DFD(float p0, struct S_DFD p1, struct S_DFD p2) ;
+EXPORT float f14_F_FSS_DFP(float p0, struct S_DFP p1, struct S_DFP p2) ;
+EXPORT float f14_F_FSS_DDI(float p0, struct S_DDI p1, struct S_DDI p2) ;
+EXPORT float f14_F_FSS_DDF(float p0, struct S_DDF p1, struct S_DDF p2) ;
+EXPORT float f14_F_FSS_DDD(float p0, struct S_DDD p1, struct S_DDD p2) ;
+EXPORT float f14_F_FSS_DDP(float p0, struct S_DDP p1, struct S_DDP p2) ;
+EXPORT float f14_F_FSS_DPI(float p0, struct S_DPI p1, struct S_DPI p2) ;
+EXPORT float f14_F_FSS_DPF(float p0, struct S_DPF p1, struct S_DPF p2) ;
+EXPORT float f14_F_FSS_DPD(float p0, struct S_DPD p1, struct S_DPD p2) ;
+EXPORT float f14_F_FSS_DPP(float p0, struct S_DPP p1, struct S_DPP p2) ;
+EXPORT float f14_F_FSS_PII(float p0, struct S_PII p1, struct S_PII p2) ;
+EXPORT float f14_F_FSS_PIF(float p0, struct S_PIF p1, struct S_PIF p2) ;
+EXPORT float f14_F_FSS_PID(float p0, struct S_PID p1, struct S_PID p2) ;
+EXPORT float f14_F_FSS_PIP(float p0, struct S_PIP p1, struct S_PIP p2) ;
+EXPORT float f14_F_FSS_PFI(float p0, struct S_PFI p1, struct S_PFI p2) ;
+EXPORT float f14_F_FSS_PFF(float p0, struct S_PFF p1, struct S_PFF p2) ;
+EXPORT float f14_F_FSS_PFD(float p0, struct S_PFD p1, struct S_PFD p2) ;
+EXPORT float f14_F_FSS_PFP(float p0, struct S_PFP p1, struct S_PFP p2) ;
+EXPORT float f14_F_FSS_PDI(float p0, struct S_PDI p1, struct S_PDI p2) ;
+EXPORT float f14_F_FSS_PDF(float p0, struct S_PDF p1, struct S_PDF p2) ;
+EXPORT float f14_F_FSS_PDD(float p0, struct S_PDD p1, struct S_PDD p2) ;
+EXPORT float f14_F_FSS_PDP(float p0, struct S_PDP p1, struct S_PDP p2) ;
+EXPORT float f14_F_FSS_PPI(float p0, struct S_PPI p1, struct S_PPI p2) ;
+EXPORT float f14_F_FSS_PPF(float p0, struct S_PPF p1, struct S_PPF p2) ;
+EXPORT float f14_F_FSS_PPD(float p0, struct S_PPD p1, struct S_PPD p2) ;
+EXPORT float f14_F_FSS_PPP(float p0, struct S_PPP p1, struct S_PPP p2) ;
+EXPORT double f14_D_DII_(double p0, int p1, int p2) ;
+EXPORT double f14_D_DIF_(double p0, int p1, float p2) ;
+EXPORT double f14_D_DID_(double p0, int p1, double p2) ;
+EXPORT double f14_D_DIP_(double p0, int p1, void* p2) ;
+EXPORT double f14_D_DIS_I(double p0, int p1, struct S_I p2) ;
+EXPORT double f14_D_DIS_F(double p0, int p1, struct S_F p2) ;
+EXPORT double f14_D_DIS_D(double p0, int p1, struct S_D p2) ;
+EXPORT double f14_D_DIS_P(double p0, int p1, struct S_P p2) ;
+EXPORT double f14_D_DIS_II(double p0, int p1, struct S_II p2) ;
+EXPORT double f14_D_DIS_IF(double p0, int p1, struct S_IF p2) ;
+EXPORT double f14_D_DIS_ID(double p0, int p1, struct S_ID p2) ;
+EXPORT double f14_D_DIS_IP(double p0, int p1, struct S_IP p2) ;
+EXPORT double f14_D_DIS_FI(double p0, int p1, struct S_FI p2) ;
+EXPORT double f14_D_DIS_FF(double p0, int p1, struct S_FF p2) ;
+EXPORT double f14_D_DIS_FD(double p0, int p1, struct S_FD p2) ;
+EXPORT double f14_D_DIS_FP(double p0, int p1, struct S_FP p2) ;
+EXPORT double f14_D_DIS_DI(double p0, int p1, struct S_DI p2) ;
+EXPORT double f14_D_DIS_DF(double p0, int p1, struct S_DF p2) ;
+EXPORT double f14_D_DIS_DD(double p0, int p1, struct S_DD p2) ;
+EXPORT double f14_D_DIS_DP(double p0, int p1, struct S_DP p2) ;
+EXPORT double f14_D_DIS_PI(double p0, int p1, struct S_PI p2) ;
+EXPORT double f14_D_DIS_PF(double p0, int p1, struct S_PF p2) ;
+EXPORT double f14_D_DIS_PD(double p0, int p1, struct S_PD p2) ;
+EXPORT double f14_D_DIS_PP(double p0, int p1, struct S_PP p2) ;
+EXPORT double f14_D_DIS_III(double p0, int p1, struct S_III p2) ;
+EXPORT double f14_D_DIS_IIF(double p0, int p1, struct S_IIF p2) ;
+EXPORT double f14_D_DIS_IID(double p0, int p1, struct S_IID p2) ;
+EXPORT double f14_D_DIS_IIP(double p0, int p1, struct S_IIP p2) ;
+EXPORT double f14_D_DIS_IFI(double p0, int p1, struct S_IFI p2) ;
+EXPORT double f14_D_DIS_IFF(double p0, int p1, struct S_IFF p2) ;
+EXPORT double f14_D_DIS_IFD(double p0, int p1, struct S_IFD p2) ;
+EXPORT double f14_D_DIS_IFP(double p0, int p1, struct S_IFP p2) ;
+EXPORT double f14_D_DIS_IDI(double p0, int p1, struct S_IDI p2) ;
+EXPORT double f14_D_DIS_IDF(double p0, int p1, struct S_IDF p2) ;
+EXPORT double f14_D_DIS_IDD(double p0, int p1, struct S_IDD p2) ;
+EXPORT double f14_D_DIS_IDP(double p0, int p1, struct S_IDP p2) ;
+EXPORT double f14_D_DIS_IPI(double p0, int p1, struct S_IPI p2) ;
+EXPORT double f14_D_DIS_IPF(double p0, int p1, struct S_IPF p2) ;
+EXPORT double f14_D_DIS_IPD(double p0, int p1, struct S_IPD p2) ;
+EXPORT double f14_D_DIS_IPP(double p0, int p1, struct S_IPP p2) ;
+EXPORT double f14_D_DIS_FII(double p0, int p1, struct S_FII p2) ;
+EXPORT double f14_D_DIS_FIF(double p0, int p1, struct S_FIF p2) ;
+EXPORT double f14_D_DIS_FID(double p0, int p1, struct S_FID p2) ;
+EXPORT double f14_D_DIS_FIP(double p0, int p1, struct S_FIP p2) ;
+EXPORT double f14_D_DIS_FFI(double p0, int p1, struct S_FFI p2) ;
+EXPORT double f14_D_DIS_FFF(double p0, int p1, struct S_FFF p2) ;
+EXPORT double f14_D_DIS_FFD(double p0, int p1, struct S_FFD p2) ;
+EXPORT double f14_D_DIS_FFP(double p0, int p1, struct S_FFP p2) ;
+EXPORT double f14_D_DIS_FDI(double p0, int p1, struct S_FDI p2) ;
+EXPORT double f14_D_DIS_FDF(double p0, int p1, struct S_FDF p2) ;
+EXPORT double f14_D_DIS_FDD(double p0, int p1, struct S_FDD p2) ;
+EXPORT double f14_D_DIS_FDP(double p0, int p1, struct S_FDP p2) ;
+EXPORT double f14_D_DIS_FPI(double p0, int p1, struct S_FPI p2) ;
+EXPORT double f14_D_DIS_FPF(double p0, int p1, struct S_FPF p2) ;
+EXPORT double f14_D_DIS_FPD(double p0, int p1, struct S_FPD p2) ;
+EXPORT double f14_D_DIS_FPP(double p0, int p1, struct S_FPP p2) ;
+EXPORT double f14_D_DIS_DII(double p0, int p1, struct S_DII p2) ;
+EXPORT double f14_D_DIS_DIF(double p0, int p1, struct S_DIF p2) ;
+EXPORT double f14_D_DIS_DID(double p0, int p1, struct S_DID p2) ;
+EXPORT double f14_D_DIS_DIP(double p0, int p1, struct S_DIP p2) ;
+EXPORT double f14_D_DIS_DFI(double p0, int p1, struct S_DFI p2) ;
+EXPORT double f14_D_DIS_DFF(double p0, int p1, struct S_DFF p2) ;
+EXPORT double f14_D_DIS_DFD(double p0, int p1, struct S_DFD p2) ;
+EXPORT double f14_D_DIS_DFP(double p0, int p1, struct S_DFP p2) ;
+EXPORT double f14_D_DIS_DDI(double p0, int p1, struct S_DDI p2) ;
+EXPORT double f14_D_DIS_DDF(double p0, int p1, struct S_DDF p2) ;
+EXPORT double f14_D_DIS_DDD(double p0, int p1, struct S_DDD p2) ;
+EXPORT double f14_D_DIS_DDP(double p0, int p1, struct S_DDP p2) ;
+EXPORT double f14_D_DIS_DPI(double p0, int p1, struct S_DPI p2) ;
+EXPORT double f14_D_DIS_DPF(double p0, int p1, struct S_DPF p2) ;
+EXPORT double f14_D_DIS_DPD(double p0, int p1, struct S_DPD p2) ;
+EXPORT double f14_D_DIS_DPP(double p0, int p1, struct S_DPP p2) ;
+EXPORT double f14_D_DIS_PII(double p0, int p1, struct S_PII p2) ;
+EXPORT double f14_D_DIS_PIF(double p0, int p1, struct S_PIF p2) ;
+EXPORT double f14_D_DIS_PID(double p0, int p1, struct S_PID p2) ;
+EXPORT double f14_D_DIS_PIP(double p0, int p1, struct S_PIP p2) ;
+EXPORT double f14_D_DIS_PFI(double p0, int p1, struct S_PFI p2) ;
+EXPORT double f14_D_DIS_PFF(double p0, int p1, struct S_PFF p2) ;
+EXPORT double f14_D_DIS_PFD(double p0, int p1, struct S_PFD p2) ;
+EXPORT double f14_D_DIS_PFP(double p0, int p1, struct S_PFP p2) ;
+EXPORT double f14_D_DIS_PDI(double p0, int p1, struct S_PDI p2) ;
+EXPORT double f14_D_DIS_PDF(double p0, int p1, struct S_PDF p2) ;
+EXPORT double f14_D_DIS_PDD(double p0, int p1, struct S_PDD p2) ;
+EXPORT double f14_D_DIS_PDP(double p0, int p1, struct S_PDP p2) ;
+EXPORT double f14_D_DIS_PPI(double p0, int p1, struct S_PPI p2) ;
+EXPORT double f14_D_DIS_PPF(double p0, int p1, struct S_PPF p2) ;
+EXPORT double f14_D_DIS_PPD(double p0, int p1, struct S_PPD p2) ;
+EXPORT double f14_D_DIS_PPP(double p0, int p1, struct S_PPP p2) ;
+EXPORT double f14_D_DFI_(double p0, float p1, int p2) ;
+EXPORT double f14_D_DFF_(double p0, float p1, float p2) ;
+EXPORT double f14_D_DFD_(double p0, float p1, double p2) ;
+EXPORT double f14_D_DFP_(double p0, float p1, void* p2) ;
+EXPORT double f14_D_DFS_I(double p0, float p1, struct S_I p2) ;
+EXPORT double f14_D_DFS_F(double p0, float p1, struct S_F p2) ;
+EXPORT double f14_D_DFS_D(double p0, float p1, struct S_D p2) ;
+EXPORT double f14_D_DFS_P(double p0, float p1, struct S_P p2) ;
+EXPORT double f14_D_DFS_II(double p0, float p1, struct S_II p2) ;
+EXPORT double f14_D_DFS_IF(double p0, float p1, struct S_IF p2) ;
+EXPORT double f14_D_DFS_ID(double p0, float p1, struct S_ID p2) ;
+EXPORT double f14_D_DFS_IP(double p0, float p1, struct S_IP p2) ;
+EXPORT double f14_D_DFS_FI(double p0, float p1, struct S_FI p2) ;
+EXPORT double f14_D_DFS_FF(double p0, float p1, struct S_FF p2) ;
+EXPORT double f14_D_DFS_FD(double p0, float p1, struct S_FD p2) ;
+EXPORT double f14_D_DFS_FP(double p0, float p1, struct S_FP p2) ;
+EXPORT double f14_D_DFS_DI(double p0, float p1, struct S_DI p2) ;
+EXPORT double f14_D_DFS_DF(double p0, float p1, struct S_DF p2) ;
+EXPORT double f14_D_DFS_DD(double p0, float p1, struct S_DD p2) ;
+EXPORT double f14_D_DFS_DP(double p0, float p1, struct S_DP p2) ;
+EXPORT double f14_D_DFS_PI(double p0, float p1, struct S_PI p2) ;
+EXPORT double f14_D_DFS_PF(double p0, float p1, struct S_PF p2) ;
+EXPORT double f14_D_DFS_PD(double p0, float p1, struct S_PD p2) ;
+EXPORT double f14_D_DFS_PP(double p0, float p1, struct S_PP p2) ;
+EXPORT double f14_D_DFS_III(double p0, float p1, struct S_III p2) ;
+EXPORT double f14_D_DFS_IIF(double p0, float p1, struct S_IIF p2) ;
+EXPORT double f14_D_DFS_IID(double p0, float p1, struct S_IID p2) ;
+EXPORT double f14_D_DFS_IIP(double p0, float p1, struct S_IIP p2) ;
+EXPORT double f14_D_DFS_IFI(double p0, float p1, struct S_IFI p2) ;
+EXPORT double f14_D_DFS_IFF(double p0, float p1, struct S_IFF p2) ;
+EXPORT double f14_D_DFS_IFD(double p0, float p1, struct S_IFD p2) ;
+EXPORT double f14_D_DFS_IFP(double p0, float p1, struct S_IFP p2) ;
+EXPORT double f14_D_DFS_IDI(double p0, float p1, struct S_IDI p2) ;
+EXPORT double f14_D_DFS_IDF(double p0, float p1, struct S_IDF p2) ;
+EXPORT double f14_D_DFS_IDD(double p0, float p1, struct S_IDD p2) ;
+EXPORT double f14_D_DFS_IDP(double p0, float p1, struct S_IDP p2) ;
+EXPORT double f14_D_DFS_IPI(double p0, float p1, struct S_IPI p2) ;
+EXPORT double f14_D_DFS_IPF(double p0, float p1, struct S_IPF p2) ;
+EXPORT double f14_D_DFS_IPD(double p0, float p1, struct S_IPD p2) ;
+EXPORT double f14_D_DFS_IPP(double p0, float p1, struct S_IPP p2) ;
+EXPORT double f14_D_DFS_FII(double p0, float p1, struct S_FII p2) ;
+EXPORT double f14_D_DFS_FIF(double p0, float p1, struct S_FIF p2) ;
+EXPORT double f14_D_DFS_FID(double p0, float p1, struct S_FID p2) ;
+EXPORT double f14_D_DFS_FIP(double p0, float p1, struct S_FIP p2) ;
+EXPORT double f14_D_DFS_FFI(double p0, float p1, struct S_FFI p2) ;
+EXPORT double f14_D_DFS_FFF(double p0, float p1, struct S_FFF p2) ;
+EXPORT double f14_D_DFS_FFD(double p0, float p1, struct S_FFD p2) ;
+EXPORT double f14_D_DFS_FFP(double p0, float p1, struct S_FFP p2) ;
+EXPORT double f14_D_DFS_FDI(double p0, float p1, struct S_FDI p2) ;
+EXPORT double f14_D_DFS_FDF(double p0, float p1, struct S_FDF p2) ;
+EXPORT double f14_D_DFS_FDD(double p0, float p1, struct S_FDD p2) ;
+EXPORT double f14_D_DFS_FDP(double p0, float p1, struct S_FDP p2) ;
+EXPORT double f14_D_DFS_FPI(double p0, float p1, struct S_FPI p2) ;
+EXPORT double f14_D_DFS_FPF(double p0, float p1, struct S_FPF p2) ;
+EXPORT double f14_D_DFS_FPD(double p0, float p1, struct S_FPD p2) ;
+EXPORT double f14_D_DFS_FPP(double p0, float p1, struct S_FPP p2) ;
+EXPORT double f14_D_DFS_DII(double p0, float p1, struct S_DII p2) ;
+EXPORT double f14_D_DFS_DIF(double p0, float p1, struct S_DIF p2) ;
+EXPORT double f14_D_DFS_DID(double p0, float p1, struct S_DID p2) ;
+EXPORT double f14_D_DFS_DIP(double p0, float p1, struct S_DIP p2) ;
+EXPORT double f14_D_DFS_DFI(double p0, float p1, struct S_DFI p2) ;
+EXPORT double f14_D_DFS_DFF(double p0, float p1, struct S_DFF p2) ;
+EXPORT double f14_D_DFS_DFD(double p0, float p1, struct S_DFD p2) ;
+EXPORT double f14_D_DFS_DFP(double p0, float p1, struct S_DFP p2) ;
+EXPORT double f14_D_DFS_DDI(double p0, float p1, struct S_DDI p2) ;
+EXPORT double f14_D_DFS_DDF(double p0, float p1, struct S_DDF p2) ;
+EXPORT double f14_D_DFS_DDD(double p0, float p1, struct S_DDD p2) ;
+EXPORT double f14_D_DFS_DDP(double p0, float p1, struct S_DDP p2) ;
+EXPORT double f14_D_DFS_DPI(double p0, float p1, struct S_DPI p2) ;
+EXPORT double f14_D_DFS_DPF(double p0, float p1, struct S_DPF p2) ;
+EXPORT double f14_D_DFS_DPD(double p0, float p1, struct S_DPD p2) ;
+EXPORT double f14_D_DFS_DPP(double p0, float p1, struct S_DPP p2) ;
+EXPORT double f14_D_DFS_PII(double p0, float p1, struct S_PII p2) ;
+EXPORT double f14_D_DFS_PIF(double p0, float p1, struct S_PIF p2) ;
+EXPORT double f14_D_DFS_PID(double p0, float p1, struct S_PID p2) ;
+EXPORT double f14_D_DFS_PIP(double p0, float p1, struct S_PIP p2) ;
+EXPORT double f14_D_DFS_PFI(double p0, float p1, struct S_PFI p2) ;
+EXPORT double f14_D_DFS_PFF(double p0, float p1, struct S_PFF p2) ;
+EXPORT double f14_D_DFS_PFD(double p0, float p1, struct S_PFD p2) ;
+EXPORT double f14_D_DFS_PFP(double p0, float p1, struct S_PFP p2) ;
+EXPORT double f14_D_DFS_PDI(double p0, float p1, struct S_PDI p2) ;
+EXPORT double f14_D_DFS_PDF(double p0, float p1, struct S_PDF p2) ;
+EXPORT double f14_D_DFS_PDD(double p0, float p1, struct S_PDD p2) ;
+EXPORT double f14_D_DFS_PDP(double p0, float p1, struct S_PDP p2) ;
+EXPORT double f14_D_DFS_PPI(double p0, float p1, struct S_PPI p2) ;
+EXPORT double f14_D_DFS_PPF(double p0, float p1, struct S_PPF p2) ;
+EXPORT double f14_D_DFS_PPD(double p0, float p1, struct S_PPD p2) ;
+EXPORT double f14_D_DFS_PPP(double p0, float p1, struct S_PPP p2) ;
+EXPORT double f14_D_DDI_(double p0, double p1, int p2) ;
+EXPORT double f14_D_DDF_(double p0, double p1, float p2) ;
+EXPORT double f14_D_DDD_(double p0, double p1, double p2) ;
+EXPORT double f14_D_DDP_(double p0, double p1, void* p2) ;
+EXPORT double f14_D_DDS_I(double p0, double p1, struct S_I p2) ;
+EXPORT double f14_D_DDS_F(double p0, double p1, struct S_F p2) ;
+EXPORT double f14_D_DDS_D(double p0, double p1, struct S_D p2) ;
+EXPORT double f14_D_DDS_P(double p0, double p1, struct S_P p2) ;
+EXPORT double f14_D_DDS_II(double p0, double p1, struct S_II p2) ;
+EXPORT double f14_D_DDS_IF(double p0, double p1, struct S_IF p2) ;
+EXPORT double f14_D_DDS_ID(double p0, double p1, struct S_ID p2) ;
+EXPORT double f14_D_DDS_IP(double p0, double p1, struct S_IP p2) ;
+EXPORT double f14_D_DDS_FI(double p0, double p1, struct S_FI p2) ;
+EXPORT double f14_D_DDS_FF(double p0, double p1, struct S_FF p2) ;
+EXPORT double f14_D_DDS_FD(double p0, double p1, struct S_FD p2) ;
+EXPORT double f14_D_DDS_FP(double p0, double p1, struct S_FP p2) ;
+EXPORT double f14_D_DDS_DI(double p0, double p1, struct S_DI p2) ;
+EXPORT double f14_D_DDS_DF(double p0, double p1, struct S_DF p2) ;
+EXPORT double f14_D_DDS_DD(double p0, double p1, struct S_DD p2) ;
+EXPORT double f14_D_DDS_DP(double p0, double p1, struct S_DP p2) ;
+EXPORT double f14_D_DDS_PI(double p0, double p1, struct S_PI p2) ;
+EXPORT double f14_D_DDS_PF(double p0, double p1, struct S_PF p2) ;
+EXPORT double f14_D_DDS_PD(double p0, double p1, struct S_PD p2) ;
+EXPORT double f14_D_DDS_PP(double p0, double p1, struct S_PP p2) ;
+EXPORT double f14_D_DDS_III(double p0, double p1, struct S_III p2) ;
+EXPORT double f14_D_DDS_IIF(double p0, double p1, struct S_IIF p2) ;
+EXPORT double f14_D_DDS_IID(double p0, double p1, struct S_IID p2) ;
+EXPORT double f14_D_DDS_IIP(double p0, double p1, struct S_IIP p2) ;
+EXPORT double f14_D_DDS_IFI(double p0, double p1, struct S_IFI p2) ;
+EXPORT double f14_D_DDS_IFF(double p0, double p1, struct S_IFF p2) ;
+EXPORT double f14_D_DDS_IFD(double p0, double p1, struct S_IFD p2) ;
+EXPORT double f14_D_DDS_IFP(double p0, double p1, struct S_IFP p2) ;
+EXPORT double f14_D_DDS_IDI(double p0, double p1, struct S_IDI p2) ;
+EXPORT double f14_D_DDS_IDF(double p0, double p1, struct S_IDF p2) ;
+EXPORT double f14_D_DDS_IDD(double p0, double p1, struct S_IDD p2) ;
+EXPORT double f14_D_DDS_IDP(double p0, double p1, struct S_IDP p2) ;
+EXPORT double f14_D_DDS_IPI(double p0, double p1, struct S_IPI p2) ;
+EXPORT double f14_D_DDS_IPF(double p0, double p1, struct S_IPF p2) ;
+EXPORT double f14_D_DDS_IPD(double p0, double p1, struct S_IPD p2) ;
+EXPORT double f14_D_DDS_IPP(double p0, double p1, struct S_IPP p2) ;
+EXPORT double f14_D_DDS_FII(double p0, double p1, struct S_FII p2) ;
+EXPORT double f14_D_DDS_FIF(double p0, double p1, struct S_FIF p2) ;
+EXPORT double f14_D_DDS_FID(double p0, double p1, struct S_FID p2) ;
+EXPORT double f14_D_DDS_FIP(double p0, double p1, struct S_FIP p2) ;
+EXPORT double f14_D_DDS_FFI(double p0, double p1, struct S_FFI p2) ;
+EXPORT double f14_D_DDS_FFF(double p0, double p1, struct S_FFF p2) ;
+EXPORT double f14_D_DDS_FFD(double p0, double p1, struct S_FFD p2) ;
+EXPORT double f14_D_DDS_FFP(double p0, double p1, struct S_FFP p2) ;
+EXPORT double f14_D_DDS_FDI(double p0, double p1, struct S_FDI p2) ;
+EXPORT double f14_D_DDS_FDF(double p0, double p1, struct S_FDF p2) ;
+EXPORT double f14_D_DDS_FDD(double p0, double p1, struct S_FDD p2) ;
+EXPORT double f14_D_DDS_FDP(double p0, double p1, struct S_FDP p2) ;
+EXPORT double f14_D_DDS_FPI(double p0, double p1, struct S_FPI p2) ;
+EXPORT double f14_D_DDS_FPF(double p0, double p1, struct S_FPF p2) ;
+EXPORT double f14_D_DDS_FPD(double p0, double p1, struct S_FPD p2) ;
+EXPORT double f14_D_DDS_FPP(double p0, double p1, struct S_FPP p2) ;
+EXPORT double f14_D_DDS_DII(double p0, double p1, struct S_DII p2) ;
+EXPORT double f14_D_DDS_DIF(double p0, double p1, struct S_DIF p2) ;
+EXPORT double f14_D_DDS_DID(double p0, double p1, struct S_DID p2) ;
+EXPORT double f14_D_DDS_DIP(double p0, double p1, struct S_DIP p2) ;
+EXPORT double f14_D_DDS_DFI(double p0, double p1, struct S_DFI p2) ;
+EXPORT double f14_D_DDS_DFF(double p0, double p1, struct S_DFF p2) ;
+EXPORT double f14_D_DDS_DFD(double p0, double p1, struct S_DFD p2) ;
+EXPORT double f14_D_DDS_DFP(double p0, double p1, struct S_DFP p2) ;
+EXPORT double f14_D_DDS_DDI(double p0, double p1, struct S_DDI p2) ;
+EXPORT double f14_D_DDS_DDF(double p0, double p1, struct S_DDF p2) ;
+EXPORT double f14_D_DDS_DDD(double p0, double p1, struct S_DDD p2) ;
+EXPORT double f14_D_DDS_DDP(double p0, double p1, struct S_DDP p2) ;
+EXPORT double f14_D_DDS_DPI(double p0, double p1, struct S_DPI p2) ;
+EXPORT double f14_D_DDS_DPF(double p0, double p1, struct S_DPF p2) ;
+EXPORT double f14_D_DDS_DPD(double p0, double p1, struct S_DPD p2) ;
+EXPORT double f14_D_DDS_DPP(double p0, double p1, struct S_DPP p2) ;
+EXPORT double f14_D_DDS_PII(double p0, double p1, struct S_PII p2) ;
+EXPORT double f14_D_DDS_PIF(double p0, double p1, struct S_PIF p2) ;
+EXPORT double f14_D_DDS_PID(double p0, double p1, struct S_PID p2) ;
+EXPORT double f14_D_DDS_PIP(double p0, double p1, struct S_PIP p2) ;
+EXPORT double f14_D_DDS_PFI(double p0, double p1, struct S_PFI p2) ;
+EXPORT double f14_D_DDS_PFF(double p0, double p1, struct S_PFF p2) ;
+EXPORT double f14_D_DDS_PFD(double p0, double p1, struct S_PFD p2) ;
+EXPORT double f14_D_DDS_PFP(double p0, double p1, struct S_PFP p2) ;
+EXPORT double f14_D_DDS_PDI(double p0, double p1, struct S_PDI p2) ;
+EXPORT double f14_D_DDS_PDF(double p0, double p1, struct S_PDF p2) ;
+EXPORT double f14_D_DDS_PDD(double p0, double p1, struct S_PDD p2) ;
+EXPORT double f14_D_DDS_PDP(double p0, double p1, struct S_PDP p2) ;
+EXPORT double f14_D_DDS_PPI(double p0, double p1, struct S_PPI p2) ;
+EXPORT double f14_D_DDS_PPF(double p0, double p1, struct S_PPF p2) ;
+EXPORT double f14_D_DDS_PPD(double p0, double p1, struct S_PPD p2) ;
+EXPORT double f14_D_DDS_PPP(double p0, double p1, struct S_PPP p2) ;
+EXPORT double f14_D_DPI_(double p0, void* p1, int p2) ;
+EXPORT double f14_D_DPF_(double p0, void* p1, float p2) ;
+EXPORT double f14_D_DPD_(double p0, void* p1, double p2) ;
+EXPORT double f14_D_DPP_(double p0, void* p1, void* p2) ;
+EXPORT double f14_D_DPS_I(double p0, void* p1, struct S_I p2) ;
+EXPORT double f14_D_DPS_F(double p0, void* p1, struct S_F p2) ;
+EXPORT double f14_D_DPS_D(double p0, void* p1, struct S_D p2) ;
+EXPORT double f14_D_DPS_P(double p0, void* p1, struct S_P p2) ;
+EXPORT double f14_D_DPS_II(double p0, void* p1, struct S_II p2) ;
+EXPORT double f14_D_DPS_IF(double p0, void* p1, struct S_IF p2) ;
+EXPORT double f14_D_DPS_ID(double p0, void* p1, struct S_ID p2) ;
+EXPORT double f14_D_DPS_IP(double p0, void* p1, struct S_IP p2) ;
+EXPORT double f14_D_DPS_FI(double p0, void* p1, struct S_FI p2) ;
+EXPORT double f14_D_DPS_FF(double p0, void* p1, struct S_FF p2) ;
+EXPORT double f14_D_DPS_FD(double p0, void* p1, struct S_FD p2) ;
+EXPORT double f14_D_DPS_FP(double p0, void* p1, struct S_FP p2) ;
+EXPORT double f14_D_DPS_DI(double p0, void* p1, struct S_DI p2) ;
+EXPORT double f14_D_DPS_DF(double p0, void* p1, struct S_DF p2) ;
+EXPORT double f14_D_DPS_DD(double p0, void* p1, struct S_DD p2) ;
+EXPORT double f14_D_DPS_DP(double p0, void* p1, struct S_DP p2) ;
+EXPORT double f14_D_DPS_PI(double p0, void* p1, struct S_PI p2) ;
+EXPORT double f14_D_DPS_PF(double p0, void* p1, struct S_PF p2) ;
+EXPORT double f14_D_DPS_PD(double p0, void* p1, struct S_PD p2) ;
+EXPORT double f14_D_DPS_PP(double p0, void* p1, struct S_PP p2) ;
+EXPORT double f14_D_DPS_III(double p0, void* p1, struct S_III p2) ;
+EXPORT double f14_D_DPS_IIF(double p0, void* p1, struct S_IIF p2) ;
+EXPORT double f14_D_DPS_IID(double p0, void* p1, struct S_IID p2) ;
+EXPORT double f14_D_DPS_IIP(double p0, void* p1, struct S_IIP p2) ;
+EXPORT double f14_D_DPS_IFI(double p0, void* p1, struct S_IFI p2) ;
+EXPORT double f14_D_DPS_IFF(double p0, void* p1, struct S_IFF p2) ;
+EXPORT double f14_D_DPS_IFD(double p0, void* p1, struct S_IFD p2) ;
+EXPORT double f14_D_DPS_IFP(double p0, void* p1, struct S_IFP p2) ;
+EXPORT double f14_D_DPS_IDI(double p0, void* p1, struct S_IDI p2) ;
+EXPORT double f14_D_DPS_IDF(double p0, void* p1, struct S_IDF p2) ;
+EXPORT double f14_D_DPS_IDD(double p0, void* p1, struct S_IDD p2) ;
+EXPORT double f14_D_DPS_IDP(double p0, void* p1, struct S_IDP p2) ;
+EXPORT double f14_D_DPS_IPI(double p0, void* p1, struct S_IPI p2) ;
+EXPORT double f14_D_DPS_IPF(double p0, void* p1, struct S_IPF p2) ;
+EXPORT double f14_D_DPS_IPD(double p0, void* p1, struct S_IPD p2) ;
+EXPORT double f14_D_DPS_IPP(double p0, void* p1, struct S_IPP p2) ;
+EXPORT double f14_D_DPS_FII(double p0, void* p1, struct S_FII p2) ;
+EXPORT double f14_D_DPS_FIF(double p0, void* p1, struct S_FIF p2) ;
+EXPORT double f14_D_DPS_FID(double p0, void* p1, struct S_FID p2) ;
+EXPORT double f14_D_DPS_FIP(double p0, void* p1, struct S_FIP p2) ;
+EXPORT double f14_D_DPS_FFI(double p0, void* p1, struct S_FFI p2) ;
+EXPORT double f14_D_DPS_FFF(double p0, void* p1, struct S_FFF p2) ;
+EXPORT double f14_D_DPS_FFD(double p0, void* p1, struct S_FFD p2) ;
+EXPORT double f14_D_DPS_FFP(double p0, void* p1, struct S_FFP p2) ;
+EXPORT double f14_D_DPS_FDI(double p0, void* p1, struct S_FDI p2) ;
+EXPORT double f14_D_DPS_FDF(double p0, void* p1, struct S_FDF p2) ;
+EXPORT double f14_D_DPS_FDD(double p0, void* p1, struct S_FDD p2) ;
+EXPORT double f14_D_DPS_FDP(double p0, void* p1, struct S_FDP p2) ;
+EXPORT double f14_D_DPS_FPI(double p0, void* p1, struct S_FPI p2) ;
+EXPORT double f14_D_DPS_FPF(double p0, void* p1, struct S_FPF p2) ;
+EXPORT double f14_D_DPS_FPD(double p0, void* p1, struct S_FPD p2) ;
+EXPORT double f14_D_DPS_FPP(double p0, void* p1, struct S_FPP p2) ;
+EXPORT double f14_D_DPS_DII(double p0, void* p1, struct S_DII p2) ;
+EXPORT double f14_D_DPS_DIF(double p0, void* p1, struct S_DIF p2) ;
+EXPORT double f14_D_DPS_DID(double p0, void* p1, struct S_DID p2) ;
+EXPORT double f14_D_DPS_DIP(double p0, void* p1, struct S_DIP p2) ;
+EXPORT double f14_D_DPS_DFI(double p0, void* p1, struct S_DFI p2) ;
+EXPORT double f14_D_DPS_DFF(double p0, void* p1, struct S_DFF p2) ;
+EXPORT double f14_D_DPS_DFD(double p0, void* p1, struct S_DFD p2) ;
+EXPORT double f14_D_DPS_DFP(double p0, void* p1, struct S_DFP p2) ;
+EXPORT double f14_D_DPS_DDI(double p0, void* p1, struct S_DDI p2) ;
+EXPORT double f14_D_DPS_DDF(double p0, void* p1, struct S_DDF p2) ;
+EXPORT double f14_D_DPS_DDD(double p0, void* p1, struct S_DDD p2) ;
+EXPORT double f14_D_DPS_DDP(double p0, void* p1, struct S_DDP p2) ;
+EXPORT double f14_D_DPS_DPI(double p0, void* p1, struct S_DPI p2) ;
+EXPORT double f14_D_DPS_DPF(double p0, void* p1, struct S_DPF p2) ;
+EXPORT double f14_D_DPS_DPD(double p0, void* p1, struct S_DPD p2) ;
+EXPORT double f14_D_DPS_DPP(double p0, void* p1, struct S_DPP p2) ;
+EXPORT double f14_D_DPS_PII(double p0, void* p1, struct S_PII p2) ;
+EXPORT double f14_D_DPS_PIF(double p0, void* p1, struct S_PIF p2) ;
+EXPORT double f14_D_DPS_PID(double p0, void* p1, struct S_PID p2) ;
+EXPORT double f14_D_DPS_PIP(double p0, void* p1, struct S_PIP p2) ;
+EXPORT double f14_D_DPS_PFI(double p0, void* p1, struct S_PFI p2) ;
+EXPORT double f14_D_DPS_PFF(double p0, void* p1, struct S_PFF p2) ;
+EXPORT double f14_D_DPS_PFD(double p0, void* p1, struct S_PFD p2) ;
+EXPORT double f14_D_DPS_PFP(double p0, void* p1, struct S_PFP p2) ;
+EXPORT double f14_D_DPS_PDI(double p0, void* p1, struct S_PDI p2) ;
+EXPORT double f14_D_DPS_PDF(double p0, void* p1, struct S_PDF p2) ;
+EXPORT double f14_D_DPS_PDD(double p0, void* p1, struct S_PDD p2) ;
+EXPORT double f14_D_DPS_PDP(double p0, void* p1, struct S_PDP p2) ;
+EXPORT double f14_D_DPS_PPI(double p0, void* p1, struct S_PPI p2) ;
+EXPORT double f14_D_DPS_PPF(double p0, void* p1, struct S_PPF p2) ;
+EXPORT double f14_D_DPS_PPD(double p0, void* p1, struct S_PPD p2) ;
+EXPORT double f14_D_DPS_PPP(double p0, void* p1, struct S_PPP p2) ;
+EXPORT double f14_D_DSI_I(double p0, struct S_I p1, int p2) ;
+EXPORT double f14_D_DSI_F(double p0, struct S_F p1, int p2) ;
+EXPORT double f14_D_DSI_D(double p0, struct S_D p1, int p2) ;
+EXPORT double f14_D_DSI_P(double p0, struct S_P p1, int p2) ;
+EXPORT double f14_D_DSI_II(double p0, struct S_II p1, int p2) ;
+EXPORT double f14_D_DSI_IF(double p0, struct S_IF p1, int p2) ;
+EXPORT double f14_D_DSI_ID(double p0, struct S_ID p1, int p2) ;
+EXPORT double f14_D_DSI_IP(double p0, struct S_IP p1, int p2) ;
+EXPORT double f14_D_DSI_FI(double p0, struct S_FI p1, int p2) ;
+EXPORT double f14_D_DSI_FF(double p0, struct S_FF p1, int p2) ;
+EXPORT double f14_D_DSI_FD(double p0, struct S_FD p1, int p2) ;
+EXPORT double f14_D_DSI_FP(double p0, struct S_FP p1, int p2) ;
+EXPORT double f14_D_DSI_DI(double p0, struct S_DI p1, int p2) ;
+EXPORT double f14_D_DSI_DF(double p0, struct S_DF p1, int p2) ;
+EXPORT double f14_D_DSI_DD(double p0, struct S_DD p1, int p2) ;
+EXPORT double f14_D_DSI_DP(double p0, struct S_DP p1, int p2) ;
+EXPORT double f14_D_DSI_PI(double p0, struct S_PI p1, int p2) ;
+EXPORT double f14_D_DSI_PF(double p0, struct S_PF p1, int p2) ;
+EXPORT double f14_D_DSI_PD(double p0, struct S_PD p1, int p2) ;
+EXPORT double f14_D_DSI_PP(double p0, struct S_PP p1, int p2) ;
+EXPORT double f14_D_DSI_III(double p0, struct S_III p1, int p2) ;
+EXPORT double f14_D_DSI_IIF(double p0, struct S_IIF p1, int p2) ;
+EXPORT double f14_D_DSI_IID(double p0, struct S_IID p1, int p2) ;
+EXPORT double f14_D_DSI_IIP(double p0, struct S_IIP p1, int p2) ;
+EXPORT double f14_D_DSI_IFI(double p0, struct S_IFI p1, int p2) ;
+EXPORT double f14_D_DSI_IFF(double p0, struct S_IFF p1, int p2) ;
+EXPORT double f14_D_DSI_IFD(double p0, struct S_IFD p1, int p2) ;
+EXPORT double f14_D_DSI_IFP(double p0, struct S_IFP p1, int p2) ;
+EXPORT double f14_D_DSI_IDI(double p0, struct S_IDI p1, int p2) ;
+EXPORT double f14_D_DSI_IDF(double p0, struct S_IDF p1, int p2) ;
+EXPORT double f14_D_DSI_IDD(double p0, struct S_IDD p1, int p2) ;
+EXPORT double f14_D_DSI_IDP(double p0, struct S_IDP p1, int p2) ;
+EXPORT double f14_D_DSI_IPI(double p0, struct S_IPI p1, int p2) ;
+EXPORT double f14_D_DSI_IPF(double p0, struct S_IPF p1, int p2) ;
+EXPORT double f14_D_DSI_IPD(double p0, struct S_IPD p1, int p2) ;
+EXPORT double f14_D_DSI_IPP(double p0, struct S_IPP p1, int p2) ;
+EXPORT double f14_D_DSI_FII(double p0, struct S_FII p1, int p2) ;
+EXPORT double f14_D_DSI_FIF(double p0, struct S_FIF p1, int p2) ;
+EXPORT double f14_D_DSI_FID(double p0, struct S_FID p1, int p2) ;
+EXPORT double f14_D_DSI_FIP(double p0, struct S_FIP p1, int p2) ;
+EXPORT double f14_D_DSI_FFI(double p0, struct S_FFI p1, int p2) ;
+EXPORT double f14_D_DSI_FFF(double p0, struct S_FFF p1, int p2) ;
+EXPORT double f14_D_DSI_FFD(double p0, struct S_FFD p1, int p2) ;
+EXPORT double f14_D_DSI_FFP(double p0, struct S_FFP p1, int p2) ;
+EXPORT double f14_D_DSI_FDI(double p0, struct S_FDI p1, int p2) ;
+EXPORT double f14_D_DSI_FDF(double p0, struct S_FDF p1, int p2) ;
+EXPORT double f14_D_DSI_FDD(double p0, struct S_FDD p1, int p2) ;
+EXPORT double f14_D_DSI_FDP(double p0, struct S_FDP p1, int p2) ;
+EXPORT double f14_D_DSI_FPI(double p0, struct S_FPI p1, int p2) ;
+EXPORT double f14_D_DSI_FPF(double p0, struct S_FPF p1, int p2) ;
+EXPORT double f14_D_DSI_FPD(double p0, struct S_FPD p1, int p2) ;
+EXPORT double f14_D_DSI_FPP(double p0, struct S_FPP p1, int p2) ;
+EXPORT double f14_D_DSI_DII(double p0, struct S_DII p1, int p2) ;
+EXPORT double f14_D_DSI_DIF(double p0, struct S_DIF p1, int p2) ;
+EXPORT double f14_D_DSI_DID(double p0, struct S_DID p1, int p2) ;
+EXPORT double f14_D_DSI_DIP(double p0, struct S_DIP p1, int p2) ;
+EXPORT double f14_D_DSI_DFI(double p0, struct S_DFI p1, int p2) ;
+EXPORT double f14_D_DSI_DFF(double p0, struct S_DFF p1, int p2) ;
+EXPORT double f14_D_DSI_DFD(double p0, struct S_DFD p1, int p2) ;
+EXPORT double f14_D_DSI_DFP(double p0, struct S_DFP p1, int p2) ;
+EXPORT double f14_D_DSI_DDI(double p0, struct S_DDI p1, int p2) ;
+EXPORT double f14_D_DSI_DDF(double p0, struct S_DDF p1, int p2) ;
+EXPORT double f14_D_DSI_DDD(double p0, struct S_DDD p1, int p2) ;
+EXPORT double f14_D_DSI_DDP(double p0, struct S_DDP p1, int p2) ;
+EXPORT double f14_D_DSI_DPI(double p0, struct S_DPI p1, int p2) ;
+EXPORT double f14_D_DSI_DPF(double p0, struct S_DPF p1, int p2) ;
+EXPORT double f14_D_DSI_DPD(double p0, struct S_DPD p1, int p2) ;
+EXPORT double f14_D_DSI_DPP(double p0, struct S_DPP p1, int p2) ;
+EXPORT double f14_D_DSI_PII(double p0, struct S_PII p1, int p2) ;
+EXPORT double f14_D_DSI_PIF(double p0, struct S_PIF p1, int p2) ;
+EXPORT double f14_D_DSI_PID(double p0, struct S_PID p1, int p2) ;
+EXPORT double f14_D_DSI_PIP(double p0, struct S_PIP p1, int p2) ;
+EXPORT double f14_D_DSI_PFI(double p0, struct S_PFI p1, int p2) ;
+EXPORT double f14_D_DSI_PFF(double p0, struct S_PFF p1, int p2) ;
+EXPORT double f14_D_DSI_PFD(double p0, struct S_PFD p1, int p2) ;
+EXPORT double f14_D_DSI_PFP(double p0, struct S_PFP p1, int p2) ;
+EXPORT double f14_D_DSI_PDI(double p0, struct S_PDI p1, int p2) ;
+EXPORT double f14_D_DSI_PDF(double p0, struct S_PDF p1, int p2) ;
+EXPORT double f14_D_DSI_PDD(double p0, struct S_PDD p1, int p2) ;
+EXPORT double f14_D_DSI_PDP(double p0, struct S_PDP p1, int p2) ;
+EXPORT double f14_D_DSI_PPI(double p0, struct S_PPI p1, int p2) ;
+EXPORT double f14_D_DSI_PPF(double p0, struct S_PPF p1, int p2) ;
+EXPORT double f14_D_DSI_PPD(double p0, struct S_PPD p1, int p2) ;
+EXPORT double f14_D_DSI_PPP(double p0, struct S_PPP p1, int p2) ;
+EXPORT double f14_D_DSF_I(double p0, struct S_I p1, float p2) ;
+EXPORT double f14_D_DSF_F(double p0, struct S_F p1, float p2) ;
+EXPORT double f14_D_DSF_D(double p0, struct S_D p1, float p2) ;
+EXPORT double f14_D_DSF_P(double p0, struct S_P p1, float p2) ;
+EXPORT double f14_D_DSF_II(double p0, struct S_II p1, float p2) ;
+EXPORT double f14_D_DSF_IF(double p0, struct S_IF p1, float p2) ;
+EXPORT double f14_D_DSF_ID(double p0, struct S_ID p1, float p2) ;
+EXPORT double f14_D_DSF_IP(double p0, struct S_IP p1, float p2) ;
+EXPORT double f14_D_DSF_FI(double p0, struct S_FI p1, float p2) ;
+EXPORT double f14_D_DSF_FF(double p0, struct S_FF p1, float p2) ;
+EXPORT double f14_D_DSF_FD(double p0, struct S_FD p1, float p2) ;
+EXPORT double f14_D_DSF_FP(double p0, struct S_FP p1, float p2) ;
+EXPORT double f14_D_DSF_DI(double p0, struct S_DI p1, float p2) ;
+EXPORT double f14_D_DSF_DF(double p0, struct S_DF p1, float p2) ;
+EXPORT double f14_D_DSF_DD(double p0, struct S_DD p1, float p2) ;
+EXPORT double f14_D_DSF_DP(double p0, struct S_DP p1, float p2) ;
+EXPORT double f14_D_DSF_PI(double p0, struct S_PI p1, float p2) ;
+EXPORT double f14_D_DSF_PF(double p0, struct S_PF p1, float p2) ;
+EXPORT double f14_D_DSF_PD(double p0, struct S_PD p1, float p2) ;
+EXPORT double f14_D_DSF_PP(double p0, struct S_PP p1, float p2) ;
+EXPORT double f14_D_DSF_III(double p0, struct S_III p1, float p2) ;
+EXPORT double f14_D_DSF_IIF(double p0, struct S_IIF p1, float p2) ;
+EXPORT double f14_D_DSF_IID(double p0, struct S_IID p1, float p2) ;
+EXPORT double f14_D_DSF_IIP(double p0, struct S_IIP p1, float p2) ;
+EXPORT double f14_D_DSF_IFI(double p0, struct S_IFI p1, float p2) ;
+EXPORT double f14_D_DSF_IFF(double p0, struct S_IFF p1, float p2) ;
+EXPORT double f14_D_DSF_IFD(double p0, struct S_IFD p1, float p2) ;
+EXPORT double f14_D_DSF_IFP(double p0, struct S_IFP p1, float p2) ;
+EXPORT double f14_D_DSF_IDI(double p0, struct S_IDI p1, float p2) ;
+EXPORT double f14_D_DSF_IDF(double p0, struct S_IDF p1, float p2) ;
+EXPORT double f14_D_DSF_IDD(double p0, struct S_IDD p1, float p2) ;
+EXPORT double f14_D_DSF_IDP(double p0, struct S_IDP p1, float p2) ;
+EXPORT double f14_D_DSF_IPI(double p0, struct S_IPI p1, float p2) ;
+EXPORT double f14_D_DSF_IPF(double p0, struct S_IPF p1, float p2) ;
+EXPORT double f14_D_DSF_IPD(double p0, struct S_IPD p1, float p2) ;
+EXPORT double f14_D_DSF_IPP(double p0, struct S_IPP p1, float p2) ;
+EXPORT double f14_D_DSF_FII(double p0, struct S_FII p1, float p2) ;
+EXPORT double f14_D_DSF_FIF(double p0, struct S_FIF p1, float p2) ;
+EXPORT double f14_D_DSF_FID(double p0, struct S_FID p1, float p2) ;
+EXPORT double f14_D_DSF_FIP(double p0, struct S_FIP p1, float p2) ;
+EXPORT double f14_D_DSF_FFI(double p0, struct S_FFI p1, float p2) ;
+EXPORT double f14_D_DSF_FFF(double p0, struct S_FFF p1, float p2) ;
+EXPORT double f14_D_DSF_FFD(double p0, struct S_FFD p1, float p2) ;
+EXPORT double f14_D_DSF_FFP(double p0, struct S_FFP p1, float p2) ;
+EXPORT double f14_D_DSF_FDI(double p0, struct S_FDI p1, float p2) ;
+EXPORT double f14_D_DSF_FDF(double p0, struct S_FDF p1, float p2) ;
+EXPORT double f14_D_DSF_FDD(double p0, struct S_FDD p1, float p2) ;
+EXPORT double f14_D_DSF_FDP(double p0, struct S_FDP p1, float p2) ;
+EXPORT double f14_D_DSF_FPI(double p0, struct S_FPI p1, float p2) ;
+EXPORT double f14_D_DSF_FPF(double p0, struct S_FPF p1, float p2) ;
+EXPORT double f14_D_DSF_FPD(double p0, struct S_FPD p1, float p2) ;
+EXPORT double f14_D_DSF_FPP(double p0, struct S_FPP p1, float p2) ;
+EXPORT double f14_D_DSF_DII(double p0, struct S_DII p1, float p2) ;
+EXPORT double f14_D_DSF_DIF(double p0, struct S_DIF p1, float p2) ;
+EXPORT double f14_D_DSF_DID(double p0, struct S_DID p1, float p2) ;
+EXPORT double f14_D_DSF_DIP(double p0, struct S_DIP p1, float p2) ;
+EXPORT double f14_D_DSF_DFI(double p0, struct S_DFI p1, float p2) ;
+EXPORT double f14_D_DSF_DFF(double p0, struct S_DFF p1, float p2) ;
+EXPORT double f14_D_DSF_DFD(double p0, struct S_DFD p1, float p2) ;
+EXPORT double f14_D_DSF_DFP(double p0, struct S_DFP p1, float p2) ;
+EXPORT double f14_D_DSF_DDI(double p0, struct S_DDI p1, float p2) ;
+EXPORT double f14_D_DSF_DDF(double p0, struct S_DDF p1, float p2) ;
+EXPORT double f14_D_DSF_DDD(double p0, struct S_DDD p1, float p2) ;
+EXPORT double f14_D_DSF_DDP(double p0, struct S_DDP p1, float p2) ;
+EXPORT double f14_D_DSF_DPI(double p0, struct S_DPI p1, float p2) ;
+EXPORT double f14_D_DSF_DPF(double p0, struct S_DPF p1, float p2) ;
+EXPORT double f14_D_DSF_DPD(double p0, struct S_DPD p1, float p2) ;
+EXPORT double f14_D_DSF_DPP(double p0, struct S_DPP p1, float p2) ;
+EXPORT double f14_D_DSF_PII(double p0, struct S_PII p1, float p2) ;
+EXPORT double f14_D_DSF_PIF(double p0, struct S_PIF p1, float p2) ;
+EXPORT double f14_D_DSF_PID(double p0, struct S_PID p1, float p2) ;
+EXPORT double f14_D_DSF_PIP(double p0, struct S_PIP p1, float p2) ;
+EXPORT double f14_D_DSF_PFI(double p0, struct S_PFI p1, float p2) ;
+EXPORT double f14_D_DSF_PFF(double p0, struct S_PFF p1, float p2) ;
+EXPORT double f14_D_DSF_PFD(double p0, struct S_PFD p1, float p2) ;
+EXPORT double f14_D_DSF_PFP(double p0, struct S_PFP p1, float p2) ;
+EXPORT double f14_D_DSF_PDI(double p0, struct S_PDI p1, float p2) ;
+EXPORT double f14_D_DSF_PDF(double p0, struct S_PDF p1, float p2) ;
+EXPORT double f14_D_DSF_PDD(double p0, struct S_PDD p1, float p2) ;
+EXPORT double f14_D_DSF_PDP(double p0, struct S_PDP p1, float p2) ;
+EXPORT double f14_D_DSF_PPI(double p0, struct S_PPI p1, float p2) ;
+EXPORT double f14_D_DSF_PPF(double p0, struct S_PPF p1, float p2) ;
+EXPORT double f14_D_DSF_PPD(double p0, struct S_PPD p1, float p2) ;
+EXPORT double f14_D_DSF_PPP(double p0, struct S_PPP p1, float p2) ;
+EXPORT double f14_D_DSD_I(double p0, struct S_I p1, double p2) ;
+EXPORT double f14_D_DSD_F(double p0, struct S_F p1, double p2) ;
+EXPORT double f14_D_DSD_D(double p0, struct S_D p1, double p2) ;
+EXPORT double f14_D_DSD_P(double p0, struct S_P p1, double p2) ;
+EXPORT double f14_D_DSD_II(double p0, struct S_II p1, double p2) ;
+EXPORT double f14_D_DSD_IF(double p0, struct S_IF p1, double p2) ;
+EXPORT double f14_D_DSD_ID(double p0, struct S_ID p1, double p2) ;
+EXPORT double f14_D_DSD_IP(double p0, struct S_IP p1, double p2) ;
+EXPORT double f14_D_DSD_FI(double p0, struct S_FI p1, double p2) ;
+EXPORT double f14_D_DSD_FF(double p0, struct S_FF p1, double p2) ;
+EXPORT double f14_D_DSD_FD(double p0, struct S_FD p1, double p2) ;
+EXPORT double f14_D_DSD_FP(double p0, struct S_FP p1, double p2) ;
+EXPORT double f14_D_DSD_DI(double p0, struct S_DI p1, double p2) ;
+EXPORT double f14_D_DSD_DF(double p0, struct S_DF p1, double p2) ;
+EXPORT double f14_D_DSD_DD(double p0, struct S_DD p1, double p2) ;
+EXPORT double f14_D_DSD_DP(double p0, struct S_DP p1, double p2) ;
+EXPORT double f14_D_DSD_PI(double p0, struct S_PI p1, double p2) ;
+EXPORT double f14_D_DSD_PF(double p0, struct S_PF p1, double p2) ;
+EXPORT double f14_D_DSD_PD(double p0, struct S_PD p1, double p2) ;
+EXPORT double f14_D_DSD_PP(double p0, struct S_PP p1, double p2) ;
+EXPORT double f14_D_DSD_III(double p0, struct S_III p1, double p2) ;
+EXPORT double f14_D_DSD_IIF(double p0, struct S_IIF p1, double p2) ;
+EXPORT double f14_D_DSD_IID(double p0, struct S_IID p1, double p2) ;
+EXPORT double f14_D_DSD_IIP(double p0, struct S_IIP p1, double p2) ;
+EXPORT double f14_D_DSD_IFI(double p0, struct S_IFI p1, double p2) ;
+EXPORT double f14_D_DSD_IFF(double p0, struct S_IFF p1, double p2) ;
+EXPORT double f14_D_DSD_IFD(double p0, struct S_IFD p1, double p2) ;
+EXPORT double f15_D_DSD_IFP(double p0, struct S_IFP p1, double p2) ;
+EXPORT double f15_D_DSD_IDI(double p0, struct S_IDI p1, double p2) ;
+EXPORT double f15_D_DSD_IDF(double p0, struct S_IDF p1, double p2) ;
+EXPORT double f15_D_DSD_IDD(double p0, struct S_IDD p1, double p2) ;
+EXPORT double f15_D_DSD_IDP(double p0, struct S_IDP p1, double p2) ;
+EXPORT double f15_D_DSD_IPI(double p0, struct S_IPI p1, double p2) ;
+EXPORT double f15_D_DSD_IPF(double p0, struct S_IPF p1, double p2) ;
+EXPORT double f15_D_DSD_IPD(double p0, struct S_IPD p1, double p2) ;
+EXPORT double f15_D_DSD_IPP(double p0, struct S_IPP p1, double p2) ;
+EXPORT double f15_D_DSD_FII(double p0, struct S_FII p1, double p2) ;
+EXPORT double f15_D_DSD_FIF(double p0, struct S_FIF p1, double p2) ;
+EXPORT double f15_D_DSD_FID(double p0, struct S_FID p1, double p2) ;
+EXPORT double f15_D_DSD_FIP(double p0, struct S_FIP p1, double p2) ;
+EXPORT double f15_D_DSD_FFI(double p0, struct S_FFI p1, double p2) ;
+EXPORT double f15_D_DSD_FFF(double p0, struct S_FFF p1, double p2) ;
+EXPORT double f15_D_DSD_FFD(double p0, struct S_FFD p1, double p2) ;
+EXPORT double f15_D_DSD_FFP(double p0, struct S_FFP p1, double p2) ;
+EXPORT double f15_D_DSD_FDI(double p0, struct S_FDI p1, double p2) ;
+EXPORT double f15_D_DSD_FDF(double p0, struct S_FDF p1, double p2) ;
+EXPORT double f15_D_DSD_FDD(double p0, struct S_FDD p1, double p2) ;
+EXPORT double f15_D_DSD_FDP(double p0, struct S_FDP p1, double p2) ;
+EXPORT double f15_D_DSD_FPI(double p0, struct S_FPI p1, double p2) ;
+EXPORT double f15_D_DSD_FPF(double p0, struct S_FPF p1, double p2) ;
+EXPORT double f15_D_DSD_FPD(double p0, struct S_FPD p1, double p2) ;
+EXPORT double f15_D_DSD_FPP(double p0, struct S_FPP p1, double p2) ;
+EXPORT double f15_D_DSD_DII(double p0, struct S_DII p1, double p2) ;
+EXPORT double f15_D_DSD_DIF(double p0, struct S_DIF p1, double p2) ;
+EXPORT double f15_D_DSD_DID(double p0, struct S_DID p1, double p2) ;
+EXPORT double f15_D_DSD_DIP(double p0, struct S_DIP p1, double p2) ;
+EXPORT double f15_D_DSD_DFI(double p0, struct S_DFI p1, double p2) ;
+EXPORT double f15_D_DSD_DFF(double p0, struct S_DFF p1, double p2) ;
+EXPORT double f15_D_DSD_DFD(double p0, struct S_DFD p1, double p2) ;
+EXPORT double f15_D_DSD_DFP(double p0, struct S_DFP p1, double p2) ;
+EXPORT double f15_D_DSD_DDI(double p0, struct S_DDI p1, double p2) ;
+EXPORT double f15_D_DSD_DDF(double p0, struct S_DDF p1, double p2) ;
+EXPORT double f15_D_DSD_DDD(double p0, struct S_DDD p1, double p2) ;
+EXPORT double f15_D_DSD_DDP(double p0, struct S_DDP p1, double p2) ;
+EXPORT double f15_D_DSD_DPI(double p0, struct S_DPI p1, double p2) ;
+EXPORT double f15_D_DSD_DPF(double p0, struct S_DPF p1, double p2) ;
+EXPORT double f15_D_DSD_DPD(double p0, struct S_DPD p1, double p2) ;
+EXPORT double f15_D_DSD_DPP(double p0, struct S_DPP p1, double p2) ;
+EXPORT double f15_D_DSD_PII(double p0, struct S_PII p1, double p2) ;
+EXPORT double f15_D_DSD_PIF(double p0, struct S_PIF p1, double p2) ;
+EXPORT double f15_D_DSD_PID(double p0, struct S_PID p1, double p2) ;
+EXPORT double f15_D_DSD_PIP(double p0, struct S_PIP p1, double p2) ;
+EXPORT double f15_D_DSD_PFI(double p0, struct S_PFI p1, double p2) ;
+EXPORT double f15_D_DSD_PFF(double p0, struct S_PFF p1, double p2) ;
+EXPORT double f15_D_DSD_PFD(double p0, struct S_PFD p1, double p2) ;
+EXPORT double f15_D_DSD_PFP(double p0, struct S_PFP p1, double p2) ;
+EXPORT double f15_D_DSD_PDI(double p0, struct S_PDI p1, double p2) ;
+EXPORT double f15_D_DSD_PDF(double p0, struct S_PDF p1, double p2) ;
+EXPORT double f15_D_DSD_PDD(double p0, struct S_PDD p1, double p2) ;
+EXPORT double f15_D_DSD_PDP(double p0, struct S_PDP p1, double p2) ;
+EXPORT double f15_D_DSD_PPI(double p0, struct S_PPI p1, double p2) ;
+EXPORT double f15_D_DSD_PPF(double p0, struct S_PPF p1, double p2) ;
+EXPORT double f15_D_DSD_PPD(double p0, struct S_PPD p1, double p2) ;
+EXPORT double f15_D_DSD_PPP(double p0, struct S_PPP p1, double p2) ;
+EXPORT double f15_D_DSP_I(double p0, struct S_I p1, void* p2) ;
+EXPORT double f15_D_DSP_F(double p0, struct S_F p1, void* p2) ;
+EXPORT double f15_D_DSP_D(double p0, struct S_D p1, void* p2) ;
+EXPORT double f15_D_DSP_P(double p0, struct S_P p1, void* p2) ;
+EXPORT double f15_D_DSP_II(double p0, struct S_II p1, void* p2) ;
+EXPORT double f15_D_DSP_IF(double p0, struct S_IF p1, void* p2) ;
+EXPORT double f15_D_DSP_ID(double p0, struct S_ID p1, void* p2) ;
+EXPORT double f15_D_DSP_IP(double p0, struct S_IP p1, void* p2) ;
+EXPORT double f15_D_DSP_FI(double p0, struct S_FI p1, void* p2) ;
+EXPORT double f15_D_DSP_FF(double p0, struct S_FF p1, void* p2) ;
+EXPORT double f15_D_DSP_FD(double p0, struct S_FD p1, void* p2) ;
+EXPORT double f15_D_DSP_FP(double p0, struct S_FP p1, void* p2) ;
+EXPORT double f15_D_DSP_DI(double p0, struct S_DI p1, void* p2) ;
+EXPORT double f15_D_DSP_DF(double p0, struct S_DF p1, void* p2) ;
+EXPORT double f15_D_DSP_DD(double p0, struct S_DD p1, void* p2) ;
+EXPORT double f15_D_DSP_DP(double p0, struct S_DP p1, void* p2) ;
+EXPORT double f15_D_DSP_PI(double p0, struct S_PI p1, void* p2) ;
+EXPORT double f15_D_DSP_PF(double p0, struct S_PF p1, void* p2) ;
+EXPORT double f15_D_DSP_PD(double p0, struct S_PD p1, void* p2) ;
+EXPORT double f15_D_DSP_PP(double p0, struct S_PP p1, void* p2) ;
+EXPORT double f15_D_DSP_III(double p0, struct S_III p1, void* p2) ;
+EXPORT double f15_D_DSP_IIF(double p0, struct S_IIF p1, void* p2) ;
+EXPORT double f15_D_DSP_IID(double p0, struct S_IID p1, void* p2) ;
+EXPORT double f15_D_DSP_IIP(double p0, struct S_IIP p1, void* p2) ;
+EXPORT double f15_D_DSP_IFI(double p0, struct S_IFI p1, void* p2) ;
+EXPORT double f15_D_DSP_IFF(double p0, struct S_IFF p1, void* p2) ;
+EXPORT double f15_D_DSP_IFD(double p0, struct S_IFD p1, void* p2) ;
+EXPORT double f15_D_DSP_IFP(double p0, struct S_IFP p1, void* p2) ;
+EXPORT double f15_D_DSP_IDI(double p0, struct S_IDI p1, void* p2) ;
+EXPORT double f15_D_DSP_IDF(double p0, struct S_IDF p1, void* p2) ;
+EXPORT double f15_D_DSP_IDD(double p0, struct S_IDD p1, void* p2) ;
+EXPORT double f15_D_DSP_IDP(double p0, struct S_IDP p1, void* p2) ;
+EXPORT double f15_D_DSP_IPI(double p0, struct S_IPI p1, void* p2) ;
+EXPORT double f15_D_DSP_IPF(double p0, struct S_IPF p1, void* p2) ;
+EXPORT double f15_D_DSP_IPD(double p0, struct S_IPD p1, void* p2) ;
+EXPORT double f15_D_DSP_IPP(double p0, struct S_IPP p1, void* p2) ;
+EXPORT double f15_D_DSP_FII(double p0, struct S_FII p1, void* p2) ;
+EXPORT double f15_D_DSP_FIF(double p0, struct S_FIF p1, void* p2) ;
+EXPORT double f15_D_DSP_FID(double p0, struct S_FID p1, void* p2) ;
+EXPORT double f15_D_DSP_FIP(double p0, struct S_FIP p1, void* p2) ;
+EXPORT double f15_D_DSP_FFI(double p0, struct S_FFI p1, void* p2) ;
+EXPORT double f15_D_DSP_FFF(double p0, struct S_FFF p1, void* p2) ;
+EXPORT double f15_D_DSP_FFD(double p0, struct S_FFD p1, void* p2) ;
+EXPORT double f15_D_DSP_FFP(double p0, struct S_FFP p1, void* p2) ;
+EXPORT double f15_D_DSP_FDI(double p0, struct S_FDI p1, void* p2) ;
+EXPORT double f15_D_DSP_FDF(double p0, struct S_FDF p1, void* p2) ;
+EXPORT double f15_D_DSP_FDD(double p0, struct S_FDD p1, void* p2) ;
+EXPORT double f15_D_DSP_FDP(double p0, struct S_FDP p1, void* p2) ;
+EXPORT double f15_D_DSP_FPI(double p0, struct S_FPI p1, void* p2) ;
+EXPORT double f15_D_DSP_FPF(double p0, struct S_FPF p1, void* p2) ;
+EXPORT double f15_D_DSP_FPD(double p0, struct S_FPD p1, void* p2) ;
+EXPORT double f15_D_DSP_FPP(double p0, struct S_FPP p1, void* p2) ;
+EXPORT double f15_D_DSP_DII(double p0, struct S_DII p1, void* p2) ;
+EXPORT double f15_D_DSP_DIF(double p0, struct S_DIF p1, void* p2) ;
+EXPORT double f15_D_DSP_DID(double p0, struct S_DID p1, void* p2) ;
+EXPORT double f15_D_DSP_DIP(double p0, struct S_DIP p1, void* p2) ;
+EXPORT double f15_D_DSP_DFI(double p0, struct S_DFI p1, void* p2) ;
+EXPORT double f15_D_DSP_DFF(double p0, struct S_DFF p1, void* p2) ;
+EXPORT double f15_D_DSP_DFD(double p0, struct S_DFD p1, void* p2) ;
+EXPORT double f15_D_DSP_DFP(double p0, struct S_DFP p1, void* p2) ;
+EXPORT double f15_D_DSP_DDI(double p0, struct S_DDI p1, void* p2) ;
+EXPORT double f15_D_DSP_DDF(double p0, struct S_DDF p1, void* p2) ;
+EXPORT double f15_D_DSP_DDD(double p0, struct S_DDD p1, void* p2) ;
+EXPORT double f15_D_DSP_DDP(double p0, struct S_DDP p1, void* p2) ;
+EXPORT double f15_D_DSP_DPI(double p0, struct S_DPI p1, void* p2) ;
+EXPORT double f15_D_DSP_DPF(double p0, struct S_DPF p1, void* p2) ;
+EXPORT double f15_D_DSP_DPD(double p0, struct S_DPD p1, void* p2) ;
+EXPORT double f15_D_DSP_DPP(double p0, struct S_DPP p1, void* p2) ;
+EXPORT double f15_D_DSP_PII(double p0, struct S_PII p1, void* p2) ;
+EXPORT double f15_D_DSP_PIF(double p0, struct S_PIF p1, void* p2) ;
+EXPORT double f15_D_DSP_PID(double p0, struct S_PID p1, void* p2) ;
+EXPORT double f15_D_DSP_PIP(double p0, struct S_PIP p1, void* p2) ;
+EXPORT double f15_D_DSP_PFI(double p0, struct S_PFI p1, void* p2) ;
+EXPORT double f15_D_DSP_PFF(double p0, struct S_PFF p1, void* p2) ;
+EXPORT double f15_D_DSP_PFD(double p0, struct S_PFD p1, void* p2) ;
+EXPORT double f15_D_DSP_PFP(double p0, struct S_PFP p1, void* p2) ;
+EXPORT double f15_D_DSP_PDI(double p0, struct S_PDI p1, void* p2) ;
+EXPORT double f15_D_DSP_PDF(double p0, struct S_PDF p1, void* p2) ;
+EXPORT double f15_D_DSP_PDD(double p0, struct S_PDD p1, void* p2) ;
+EXPORT double f15_D_DSP_PDP(double p0, struct S_PDP p1, void* p2) ;
+EXPORT double f15_D_DSP_PPI(double p0, struct S_PPI p1, void* p2) ;
+EXPORT double f15_D_DSP_PPF(double p0, struct S_PPF p1, void* p2) ;
+EXPORT double f15_D_DSP_PPD(double p0, struct S_PPD p1, void* p2) ;
+EXPORT double f15_D_DSP_PPP(double p0, struct S_PPP p1, void* p2) ;
+EXPORT double f15_D_DSS_I(double p0, struct S_I p1, struct S_I p2) ;
+EXPORT double f15_D_DSS_F(double p0, struct S_F p1, struct S_F p2) ;
+EXPORT double f15_D_DSS_D(double p0, struct S_D p1, struct S_D p2) ;
+EXPORT double f15_D_DSS_P(double p0, struct S_P p1, struct S_P p2) ;
+EXPORT double f15_D_DSS_II(double p0, struct S_II p1, struct S_II p2) ;
+EXPORT double f15_D_DSS_IF(double p0, struct S_IF p1, struct S_IF p2) ;
+EXPORT double f15_D_DSS_ID(double p0, struct S_ID p1, struct S_ID p2) ;
+EXPORT double f15_D_DSS_IP(double p0, struct S_IP p1, struct S_IP p2) ;
+EXPORT double f15_D_DSS_FI(double p0, struct S_FI p1, struct S_FI p2) ;
+EXPORT double f15_D_DSS_FF(double p0, struct S_FF p1, struct S_FF p2) ;
+EXPORT double f15_D_DSS_FD(double p0, struct S_FD p1, struct S_FD p2) ;
+EXPORT double f15_D_DSS_FP(double p0, struct S_FP p1, struct S_FP p2) ;
+EXPORT double f15_D_DSS_DI(double p0, struct S_DI p1, struct S_DI p2) ;
+EXPORT double f15_D_DSS_DF(double p0, struct S_DF p1, struct S_DF p2) ;
+EXPORT double f15_D_DSS_DD(double p0, struct S_DD p1, struct S_DD p2) ;
+EXPORT double f15_D_DSS_DP(double p0, struct S_DP p1, struct S_DP p2) ;
+EXPORT double f15_D_DSS_PI(double p0, struct S_PI p1, struct S_PI p2) ;
+EXPORT double f15_D_DSS_PF(double p0, struct S_PF p1, struct S_PF p2) ;
+EXPORT double f15_D_DSS_PD(double p0, struct S_PD p1, struct S_PD p2) ;
+EXPORT double f15_D_DSS_PP(double p0, struct S_PP p1, struct S_PP p2) ;
+EXPORT double f15_D_DSS_III(double p0, struct S_III p1, struct S_III p2) ;
+EXPORT double f15_D_DSS_IIF(double p0, struct S_IIF p1, struct S_IIF p2) ;
+EXPORT double f15_D_DSS_IID(double p0, struct S_IID p1, struct S_IID p2) ;
+EXPORT double f15_D_DSS_IIP(double p0, struct S_IIP p1, struct S_IIP p2) ;
+EXPORT double f15_D_DSS_IFI(double p0, struct S_IFI p1, struct S_IFI p2) ;
+EXPORT double f15_D_DSS_IFF(double p0, struct S_IFF p1, struct S_IFF p2) ;
+EXPORT double f15_D_DSS_IFD(double p0, struct S_IFD p1, struct S_IFD p2) ;
+EXPORT double f15_D_DSS_IFP(double p0, struct S_IFP p1, struct S_IFP p2) ;
+EXPORT double f15_D_DSS_IDI(double p0, struct S_IDI p1, struct S_IDI p2) ;
+EXPORT double f15_D_DSS_IDF(double p0, struct S_IDF p1, struct S_IDF p2) ;
+EXPORT double f15_D_DSS_IDD(double p0, struct S_IDD p1, struct S_IDD p2) ;
+EXPORT double f15_D_DSS_IDP(double p0, struct S_IDP p1, struct S_IDP p2) ;
+EXPORT double f15_D_DSS_IPI(double p0, struct S_IPI p1, struct S_IPI p2) ;
+EXPORT double f15_D_DSS_IPF(double p0, struct S_IPF p1, struct S_IPF p2) ;
+EXPORT double f15_D_DSS_IPD(double p0, struct S_IPD p1, struct S_IPD p2) ;
+EXPORT double f15_D_DSS_IPP(double p0, struct S_IPP p1, struct S_IPP p2) ;
+EXPORT double f15_D_DSS_FII(double p0, struct S_FII p1, struct S_FII p2) ;
+EXPORT double f15_D_DSS_FIF(double p0, struct S_FIF p1, struct S_FIF p2) ;
+EXPORT double f15_D_DSS_FID(double p0, struct S_FID p1, struct S_FID p2) ;
+EXPORT double f15_D_DSS_FIP(double p0, struct S_FIP p1, struct S_FIP p2) ;
+EXPORT double f15_D_DSS_FFI(double p0, struct S_FFI p1, struct S_FFI p2) ;
+EXPORT double f15_D_DSS_FFF(double p0, struct S_FFF p1, struct S_FFF p2) ;
+EXPORT double f15_D_DSS_FFD(double p0, struct S_FFD p1, struct S_FFD p2) ;
+EXPORT double f15_D_DSS_FFP(double p0, struct S_FFP p1, struct S_FFP p2) ;
+EXPORT double f15_D_DSS_FDI(double p0, struct S_FDI p1, struct S_FDI p2) ;
+EXPORT double f15_D_DSS_FDF(double p0, struct S_FDF p1, struct S_FDF p2) ;
+EXPORT double f15_D_DSS_FDD(double p0, struct S_FDD p1, struct S_FDD p2) ;
+EXPORT double f15_D_DSS_FDP(double p0, struct S_FDP p1, struct S_FDP p2) ;
+EXPORT double f15_D_DSS_FPI(double p0, struct S_FPI p1, struct S_FPI p2) ;
+EXPORT double f15_D_DSS_FPF(double p0, struct S_FPF p1, struct S_FPF p2) ;
+EXPORT double f15_D_DSS_FPD(double p0, struct S_FPD p1, struct S_FPD p2) ;
+EXPORT double f15_D_DSS_FPP(double p0, struct S_FPP p1, struct S_FPP p2) ;
+EXPORT double f15_D_DSS_DII(double p0, struct S_DII p1, struct S_DII p2) ;
+EXPORT double f15_D_DSS_DIF(double p0, struct S_DIF p1, struct S_DIF p2) ;
+EXPORT double f15_D_DSS_DID(double p0, struct S_DID p1, struct S_DID p2) ;
+EXPORT double f15_D_DSS_DIP(double p0, struct S_DIP p1, struct S_DIP p2) ;
+EXPORT double f15_D_DSS_DFI(double p0, struct S_DFI p1, struct S_DFI p2) ;
+EXPORT double f15_D_DSS_DFF(double p0, struct S_DFF p1, struct S_DFF p2) ;
+EXPORT double f15_D_DSS_DFD(double p0, struct S_DFD p1, struct S_DFD p2) ;
+EXPORT double f15_D_DSS_DFP(double p0, struct S_DFP p1, struct S_DFP p2) ;
+EXPORT double f15_D_DSS_DDI(double p0, struct S_DDI p1, struct S_DDI p2) ;
+EXPORT double f15_D_DSS_DDF(double p0, struct S_DDF p1, struct S_DDF p2) ;
+EXPORT double f15_D_DSS_DDD(double p0, struct S_DDD p1, struct S_DDD p2) ;
+EXPORT double f15_D_DSS_DDP(double p0, struct S_DDP p1, struct S_DDP p2) ;
+EXPORT double f15_D_DSS_DPI(double p0, struct S_DPI p1, struct S_DPI p2) ;
+EXPORT double f15_D_DSS_DPF(double p0, struct S_DPF p1, struct S_DPF p2) ;
+EXPORT double f15_D_DSS_DPD(double p0, struct S_DPD p1, struct S_DPD p2) ;
+EXPORT double f15_D_DSS_DPP(double p0, struct S_DPP p1, struct S_DPP p2) ;
+EXPORT double f15_D_DSS_PII(double p0, struct S_PII p1, struct S_PII p2) ;
+EXPORT double f15_D_DSS_PIF(double p0, struct S_PIF p1, struct S_PIF p2) ;
+EXPORT double f15_D_DSS_PID(double p0, struct S_PID p1, struct S_PID p2) ;
+EXPORT double f15_D_DSS_PIP(double p0, struct S_PIP p1, struct S_PIP p2) ;
+EXPORT double f15_D_DSS_PFI(double p0, struct S_PFI p1, struct S_PFI p2) ;
+EXPORT double f15_D_DSS_PFF(double p0, struct S_PFF p1, struct S_PFF p2) ;
+EXPORT double f15_D_DSS_PFD(double p0, struct S_PFD p1, struct S_PFD p2) ;
+EXPORT double f15_D_DSS_PFP(double p0, struct S_PFP p1, struct S_PFP p2) ;
+EXPORT double f15_D_DSS_PDI(double p0, struct S_PDI p1, struct S_PDI p2) ;
+EXPORT double f15_D_DSS_PDF(double p0, struct S_PDF p1, struct S_PDF p2) ;
+EXPORT double f15_D_DSS_PDD(double p0, struct S_PDD p1, struct S_PDD p2) ;
+EXPORT double f15_D_DSS_PDP(double p0, struct S_PDP p1, struct S_PDP p2) ;
+EXPORT double f15_D_DSS_PPI(double p0, struct S_PPI p1, struct S_PPI p2) ;
+EXPORT double f15_D_DSS_PPF(double p0, struct S_PPF p1, struct S_PPF p2) ;
+EXPORT double f15_D_DSS_PPD(double p0, struct S_PPD p1, struct S_PPD p2) ;
+EXPORT double f15_D_DSS_PPP(double p0, struct S_PPP p1, struct S_PPP p2) ;
+EXPORT void* f15_P_PII_(void* p0, int p1, int p2) ;
+EXPORT void* f15_P_PIF_(void* p0, int p1, float p2) ;
+EXPORT void* f15_P_PID_(void* p0, int p1, double p2) ;
+EXPORT void* f15_P_PIP_(void* p0, int p1, void* p2) ;
+EXPORT void* f15_P_PIS_I(void* p0, int p1, struct S_I p2) ;
+EXPORT void* f15_P_PIS_F(void* p0, int p1, struct S_F p2) ;
+EXPORT void* f15_P_PIS_D(void* p0, int p1, struct S_D p2) ;
+EXPORT void* f15_P_PIS_P(void* p0, int p1, struct S_P p2) ;
+EXPORT void* f15_P_PIS_II(void* p0, int p1, struct S_II p2) ;
+EXPORT void* f15_P_PIS_IF(void* p0, int p1, struct S_IF p2) ;
+EXPORT void* f15_P_PIS_ID(void* p0, int p1, struct S_ID p2) ;
+EXPORT void* f15_P_PIS_IP(void* p0, int p1, struct S_IP p2) ;
+EXPORT void* f15_P_PIS_FI(void* p0, int p1, struct S_FI p2) ;
+EXPORT void* f15_P_PIS_FF(void* p0, int p1, struct S_FF p2) ;
+EXPORT void* f15_P_PIS_FD(void* p0, int p1, struct S_FD p2) ;
+EXPORT void* f15_P_PIS_FP(void* p0, int p1, struct S_FP p2) ;
+EXPORT void* f15_P_PIS_DI(void* p0, int p1, struct S_DI p2) ;
+EXPORT void* f15_P_PIS_DF(void* p0, int p1, struct S_DF p2) ;
+EXPORT void* f15_P_PIS_DD(void* p0, int p1, struct S_DD p2) ;
+EXPORT void* f15_P_PIS_DP(void* p0, int p1, struct S_DP p2) ;
+EXPORT void* f15_P_PIS_PI(void* p0, int p1, struct S_PI p2) ;
+EXPORT void* f15_P_PIS_PF(void* p0, int p1, struct S_PF p2) ;
+EXPORT void* f15_P_PIS_PD(void* p0, int p1, struct S_PD p2) ;
+EXPORT void* f15_P_PIS_PP(void* p0, int p1, struct S_PP p2) ;
+EXPORT void* f15_P_PIS_III(void* p0, int p1, struct S_III p2) ;
+EXPORT void* f15_P_PIS_IIF(void* p0, int p1, struct S_IIF p2) ;
+EXPORT void* f15_P_PIS_IID(void* p0, int p1, struct S_IID p2) ;
+EXPORT void* f15_P_PIS_IIP(void* p0, int p1, struct S_IIP p2) ;
+EXPORT void* f15_P_PIS_IFI(void* p0, int p1, struct S_IFI p2) ;
+EXPORT void* f15_P_PIS_IFF(void* p0, int p1, struct S_IFF p2) ;
+EXPORT void* f15_P_PIS_IFD(void* p0, int p1, struct S_IFD p2) ;
+EXPORT void* f15_P_PIS_IFP(void* p0, int p1, struct S_IFP p2) ;
+EXPORT void* f15_P_PIS_IDI(void* p0, int p1, struct S_IDI p2) ;
+EXPORT void* f15_P_PIS_IDF(void* p0, int p1, struct S_IDF p2) ;
+EXPORT void* f15_P_PIS_IDD(void* p0, int p1, struct S_IDD p2) ;
+EXPORT void* f15_P_PIS_IDP(void* p0, int p1, struct S_IDP p2) ;
+EXPORT void* f15_P_PIS_IPI(void* p0, int p1, struct S_IPI p2) ;
+EXPORT void* f15_P_PIS_IPF(void* p0, int p1, struct S_IPF p2) ;
+EXPORT void* f15_P_PIS_IPD(void* p0, int p1, struct S_IPD p2) ;
+EXPORT void* f15_P_PIS_IPP(void* p0, int p1, struct S_IPP p2) ;
+EXPORT void* f15_P_PIS_FII(void* p0, int p1, struct S_FII p2) ;
+EXPORT void* f15_P_PIS_FIF(void* p0, int p1, struct S_FIF p2) ;
+EXPORT void* f15_P_PIS_FID(void* p0, int p1, struct S_FID p2) ;
+EXPORT void* f15_P_PIS_FIP(void* p0, int p1, struct S_FIP p2) ;
+EXPORT void* f15_P_PIS_FFI(void* p0, int p1, struct S_FFI p2) ;
+EXPORT void* f15_P_PIS_FFF(void* p0, int p1, struct S_FFF p2) ;
+EXPORT void* f15_P_PIS_FFD(void* p0, int p1, struct S_FFD p2) ;
+EXPORT void* f15_P_PIS_FFP(void* p0, int p1, struct S_FFP p2) ;
+EXPORT void* f15_P_PIS_FDI(void* p0, int p1, struct S_FDI p2) ;
+EXPORT void* f15_P_PIS_FDF(void* p0, int p1, struct S_FDF p2) ;
+EXPORT void* f15_P_PIS_FDD(void* p0, int p1, struct S_FDD p2) ;
+EXPORT void* f15_P_PIS_FDP(void* p0, int p1, struct S_FDP p2) ;
+EXPORT void* f15_P_PIS_FPI(void* p0, int p1, struct S_FPI p2) ;
+EXPORT void* f15_P_PIS_FPF(void* p0, int p1, struct S_FPF p2) ;
+EXPORT void* f15_P_PIS_FPD(void* p0, int p1, struct S_FPD p2) ;
+EXPORT void* f15_P_PIS_FPP(void* p0, int p1, struct S_FPP p2) ;
+EXPORT void* f15_P_PIS_DII(void* p0, int p1, struct S_DII p2) ;
+EXPORT void* f15_P_PIS_DIF(void* p0, int p1, struct S_DIF p2) ;
+EXPORT void* f15_P_PIS_DID(void* p0, int p1, struct S_DID p2) ;
+EXPORT void* f15_P_PIS_DIP(void* p0, int p1, struct S_DIP p2) ;
+EXPORT void* f15_P_PIS_DFI(void* p0, int p1, struct S_DFI p2) ;
+EXPORT void* f15_P_PIS_DFF(void* p0, int p1, struct S_DFF p2) ;
+EXPORT void* f15_P_PIS_DFD(void* p0, int p1, struct S_DFD p2) ;
+EXPORT void* f15_P_PIS_DFP(void* p0, int p1, struct S_DFP p2) ;
+EXPORT void* f15_P_PIS_DDI(void* p0, int p1, struct S_DDI p2) ;
+EXPORT void* f15_P_PIS_DDF(void* p0, int p1, struct S_DDF p2) ;
+EXPORT void* f15_P_PIS_DDD(void* p0, int p1, struct S_DDD p2) ;
+EXPORT void* f15_P_PIS_DDP(void* p0, int p1, struct S_DDP p2) ;
+EXPORT void* f15_P_PIS_DPI(void* p0, int p1, struct S_DPI p2) ;
+EXPORT void* f15_P_PIS_DPF(void* p0, int p1, struct S_DPF p2) ;
+EXPORT void* f15_P_PIS_DPD(void* p0, int p1, struct S_DPD p2) ;
+EXPORT void* f15_P_PIS_DPP(void* p0, int p1, struct S_DPP p2) ;
+EXPORT void* f15_P_PIS_PII(void* p0, int p1, struct S_PII p2) ;
+EXPORT void* f15_P_PIS_PIF(void* p0, int p1, struct S_PIF p2) ;
+EXPORT void* f15_P_PIS_PID(void* p0, int p1, struct S_PID p2) ;
+EXPORT void* f15_P_PIS_PIP(void* p0, int p1, struct S_PIP p2) ;
+EXPORT void* f15_P_PIS_PFI(void* p0, int p1, struct S_PFI p2) ;
+EXPORT void* f15_P_PIS_PFF(void* p0, int p1, struct S_PFF p2) ;
+EXPORT void* f15_P_PIS_PFD(void* p0, int p1, struct S_PFD p2) ;
+EXPORT void* f15_P_PIS_PFP(void* p0, int p1, struct S_PFP p2) ;
+EXPORT void* f15_P_PIS_PDI(void* p0, int p1, struct S_PDI p2) ;
+EXPORT void* f15_P_PIS_PDF(void* p0, int p1, struct S_PDF p2) ;
+EXPORT void* f15_P_PIS_PDD(void* p0, int p1, struct S_PDD p2) ;
+EXPORT void* f15_P_PIS_PDP(void* p0, int p1, struct S_PDP p2) ;
+EXPORT void* f15_P_PIS_PPI(void* p0, int p1, struct S_PPI p2) ;
+EXPORT void* f15_P_PIS_PPF(void* p0, int p1, struct S_PPF p2) ;
+EXPORT void* f15_P_PIS_PPD(void* p0, int p1, struct S_PPD p2) ;
+EXPORT void* f15_P_PIS_PPP(void* p0, int p1, struct S_PPP p2) ;
+EXPORT void* f15_P_PFI_(void* p0, float p1, int p2) ;
+EXPORT void* f15_P_PFF_(void* p0, float p1, float p2) ;
+EXPORT void* f15_P_PFD_(void* p0, float p1, double p2) ;
+EXPORT void* f15_P_PFP_(void* p0, float p1, void* p2) ;
+EXPORT void* f15_P_PFS_I(void* p0, float p1, struct S_I p2) ;
+EXPORT void* f15_P_PFS_F(void* p0, float p1, struct S_F p2) ;
+EXPORT void* f15_P_PFS_D(void* p0, float p1, struct S_D p2) ;
+EXPORT void* f15_P_PFS_P(void* p0, float p1, struct S_P p2) ;
+EXPORT void* f15_P_PFS_II(void* p0, float p1, struct S_II p2) ;
+EXPORT void* f15_P_PFS_IF(void* p0, float p1, struct S_IF p2) ;
+EXPORT void* f15_P_PFS_ID(void* p0, float p1, struct S_ID p2) ;
+EXPORT void* f15_P_PFS_IP(void* p0, float p1, struct S_IP p2) ;
+EXPORT void* f15_P_PFS_FI(void* p0, float p1, struct S_FI p2) ;
+EXPORT void* f15_P_PFS_FF(void* p0, float p1, struct S_FF p2) ;
+EXPORT void* f15_P_PFS_FD(void* p0, float p1, struct S_FD p2) ;
+EXPORT void* f15_P_PFS_FP(void* p0, float p1, struct S_FP p2) ;
+EXPORT void* f15_P_PFS_DI(void* p0, float p1, struct S_DI p2) ;
+EXPORT void* f15_P_PFS_DF(void* p0, float p1, struct S_DF p2) ;
+EXPORT void* f15_P_PFS_DD(void* p0, float p1, struct S_DD p2) ;
+EXPORT void* f15_P_PFS_DP(void* p0, float p1, struct S_DP p2) ;
+EXPORT void* f15_P_PFS_PI(void* p0, float p1, struct S_PI p2) ;
+EXPORT void* f15_P_PFS_PF(void* p0, float p1, struct S_PF p2) ;
+EXPORT void* f15_P_PFS_PD(void* p0, float p1, struct S_PD p2) ;
+EXPORT void* f15_P_PFS_PP(void* p0, float p1, struct S_PP p2) ;
+EXPORT void* f15_P_PFS_III(void* p0, float p1, struct S_III p2) ;
+EXPORT void* f15_P_PFS_IIF(void* p0, float p1, struct S_IIF p2) ;
+EXPORT void* f15_P_PFS_IID(void* p0, float p1, struct S_IID p2) ;
+EXPORT void* f15_P_PFS_IIP(void* p0, float p1, struct S_IIP p2) ;
+EXPORT void* f15_P_PFS_IFI(void* p0, float p1, struct S_IFI p2) ;
+EXPORT void* f15_P_PFS_IFF(void* p0, float p1, struct S_IFF p2) ;
+EXPORT void* f15_P_PFS_IFD(void* p0, float p1, struct S_IFD p2) ;
+EXPORT void* f15_P_PFS_IFP(void* p0, float p1, struct S_IFP p2) ;
+EXPORT void* f15_P_PFS_IDI(void* p0, float p1, struct S_IDI p2) ;
+EXPORT void* f15_P_PFS_IDF(void* p0, float p1, struct S_IDF p2) ;
+EXPORT void* f15_P_PFS_IDD(void* p0, float p1, struct S_IDD p2) ;
+EXPORT void* f15_P_PFS_IDP(void* p0, float p1, struct S_IDP p2) ;
+EXPORT void* f15_P_PFS_IPI(void* p0, float p1, struct S_IPI p2) ;
+EXPORT void* f15_P_PFS_IPF(void* p0, float p1, struct S_IPF p2) ;
+EXPORT void* f15_P_PFS_IPD(void* p0, float p1, struct S_IPD p2) ;
+EXPORT void* f15_P_PFS_IPP(void* p0, float p1, struct S_IPP p2) ;
+EXPORT void* f15_P_PFS_FII(void* p0, float p1, struct S_FII p2) ;
+EXPORT void* f15_P_PFS_FIF(void* p0, float p1, struct S_FIF p2) ;
+EXPORT void* f15_P_PFS_FID(void* p0, float p1, struct S_FID p2) ;
+EXPORT void* f15_P_PFS_FIP(void* p0, float p1, struct S_FIP p2) ;
+EXPORT void* f15_P_PFS_FFI(void* p0, float p1, struct S_FFI p2) ;
+EXPORT void* f15_P_PFS_FFF(void* p0, float p1, struct S_FFF p2) ;
+EXPORT void* f15_P_PFS_FFD(void* p0, float p1, struct S_FFD p2) ;
+EXPORT void* f15_P_PFS_FFP(void* p0, float p1, struct S_FFP p2) ;
+EXPORT void* f15_P_PFS_FDI(void* p0, float p1, struct S_FDI p2) ;
+EXPORT void* f15_P_PFS_FDF(void* p0, float p1, struct S_FDF p2) ;
+EXPORT void* f15_P_PFS_FDD(void* p0, float p1, struct S_FDD p2) ;
+EXPORT void* f15_P_PFS_FDP(void* p0, float p1, struct S_FDP p2) ;
+EXPORT void* f15_P_PFS_FPI(void* p0, float p1, struct S_FPI p2) ;
+EXPORT void* f15_P_PFS_FPF(void* p0, float p1, struct S_FPF p2) ;
+EXPORT void* f15_P_PFS_FPD(void* p0, float p1, struct S_FPD p2) ;
+EXPORT void* f15_P_PFS_FPP(void* p0, float p1, struct S_FPP p2) ;
+EXPORT void* f15_P_PFS_DII(void* p0, float p1, struct S_DII p2) ;
+EXPORT void* f15_P_PFS_DIF(void* p0, float p1, struct S_DIF p2) ;
+EXPORT void* f15_P_PFS_DID(void* p0, float p1, struct S_DID p2) ;
+EXPORT void* f15_P_PFS_DIP(void* p0, float p1, struct S_DIP p2) ;
+EXPORT void* f15_P_PFS_DFI(void* p0, float p1, struct S_DFI p2) ;
+EXPORT void* f15_P_PFS_DFF(void* p0, float p1, struct S_DFF p2) ;
+EXPORT void* f15_P_PFS_DFD(void* p0, float p1, struct S_DFD p2) ;
+EXPORT void* f15_P_PFS_DFP(void* p0, float p1, struct S_DFP p2) ;
+EXPORT void* f15_P_PFS_DDI(void* p0, float p1, struct S_DDI p2) ;
+EXPORT void* f15_P_PFS_DDF(void* p0, float p1, struct S_DDF p2) ;
+EXPORT void* f15_P_PFS_DDD(void* p0, float p1, struct S_DDD p2) ;
+EXPORT void* f15_P_PFS_DDP(void* p0, float p1, struct S_DDP p2) ;
+EXPORT void* f15_P_PFS_DPI(void* p0, float p1, struct S_DPI p2) ;
+EXPORT void* f15_P_PFS_DPF(void* p0, float p1, struct S_DPF p2) ;
+EXPORT void* f15_P_PFS_DPD(void* p0, float p1, struct S_DPD p2) ;
+EXPORT void* f15_P_PFS_DPP(void* p0, float p1, struct S_DPP p2) ;
+EXPORT void* f15_P_PFS_PII(void* p0, float p1, struct S_PII p2) ;
+EXPORT void* f15_P_PFS_PIF(void* p0, float p1, struct S_PIF p2) ;
+EXPORT void* f15_P_PFS_PID(void* p0, float p1, struct S_PID p2) ;
+EXPORT void* f15_P_PFS_PIP(void* p0, float p1, struct S_PIP p2) ;
+EXPORT void* f15_P_PFS_PFI(void* p0, float p1, struct S_PFI p2) ;
+EXPORT void* f15_P_PFS_PFF(void* p0, float p1, struct S_PFF p2) ;
+EXPORT void* f15_P_PFS_PFD(void* p0, float p1, struct S_PFD p2) ;
+EXPORT void* f15_P_PFS_PFP(void* p0, float p1, struct S_PFP p2) ;
+EXPORT void* f15_P_PFS_PDI(void* p0, float p1, struct S_PDI p2) ;
+EXPORT void* f15_P_PFS_PDF(void* p0, float p1, struct S_PDF p2) ;
+EXPORT void* f15_P_PFS_PDD(void* p0, float p1, struct S_PDD p2) ;
+EXPORT void* f15_P_PFS_PDP(void* p0, float p1, struct S_PDP p2) ;
+EXPORT void* f15_P_PFS_PPI(void* p0, float p1, struct S_PPI p2) ;
+EXPORT void* f15_P_PFS_PPF(void* p0, float p1, struct S_PPF p2) ;
+EXPORT void* f15_P_PFS_PPD(void* p0, float p1, struct S_PPD p2) ;
+EXPORT void* f15_P_PFS_PPP(void* p0, float p1, struct S_PPP p2) ;
+EXPORT void* f15_P_PDI_(void* p0, double p1, int p2) ;
+EXPORT void* f15_P_PDF_(void* p0, double p1, float p2) ;
+EXPORT void* f15_P_PDD_(void* p0, double p1, double p2) ;
+EXPORT void* f15_P_PDP_(void* p0, double p1, void* p2) ;
+EXPORT void* f15_P_PDS_I(void* p0, double p1, struct S_I p2) ;
+EXPORT void* f15_P_PDS_F(void* p0, double p1, struct S_F p2) ;
+EXPORT void* f15_P_PDS_D(void* p0, double p1, struct S_D p2) ;
+EXPORT void* f15_P_PDS_P(void* p0, double p1, struct S_P p2) ;
+EXPORT void* f15_P_PDS_II(void* p0, double p1, struct S_II p2) ;
+EXPORT void* f15_P_PDS_IF(void* p0, double p1, struct S_IF p2) ;
+EXPORT void* f15_P_PDS_ID(void* p0, double p1, struct S_ID p2) ;
+EXPORT void* f15_P_PDS_IP(void* p0, double p1, struct S_IP p2) ;
+EXPORT void* f15_P_PDS_FI(void* p0, double p1, struct S_FI p2) ;
+EXPORT void* f15_P_PDS_FF(void* p0, double p1, struct S_FF p2) ;
+EXPORT void* f15_P_PDS_FD(void* p0, double p1, struct S_FD p2) ;
+EXPORT void* f15_P_PDS_FP(void* p0, double p1, struct S_FP p2) ;
+EXPORT void* f15_P_PDS_DI(void* p0, double p1, struct S_DI p2) ;
+EXPORT void* f15_P_PDS_DF(void* p0, double p1, struct S_DF p2) ;
+EXPORT void* f15_P_PDS_DD(void* p0, double p1, struct S_DD p2) ;
+EXPORT void* f15_P_PDS_DP(void* p0, double p1, struct S_DP p2) ;
+EXPORT void* f15_P_PDS_PI(void* p0, double p1, struct S_PI p2) ;
+EXPORT void* f15_P_PDS_PF(void* p0, double p1, struct S_PF p2) ;
+EXPORT void* f15_P_PDS_PD(void* p0, double p1, struct S_PD p2) ;
+EXPORT void* f15_P_PDS_PP(void* p0, double p1, struct S_PP p2) ;
+EXPORT void* f15_P_PDS_III(void* p0, double p1, struct S_III p2) ;
+EXPORT void* f15_P_PDS_IIF(void* p0, double p1, struct S_IIF p2) ;
+EXPORT void* f15_P_PDS_IID(void* p0, double p1, struct S_IID p2) ;
+EXPORT void* f15_P_PDS_IIP(void* p0, double p1, struct S_IIP p2) ;
+EXPORT void* f15_P_PDS_IFI(void* p0, double p1, struct S_IFI p2) ;
+EXPORT void* f15_P_PDS_IFF(void* p0, double p1, struct S_IFF p2) ;
+EXPORT void* f15_P_PDS_IFD(void* p0, double p1, struct S_IFD p2) ;
+EXPORT void* f15_P_PDS_IFP(void* p0, double p1, struct S_IFP p2) ;
+EXPORT void* f15_P_PDS_IDI(void* p0, double p1, struct S_IDI p2) ;
+EXPORT void* f15_P_PDS_IDF(void* p0, double p1, struct S_IDF p2) ;
+EXPORT void* f15_P_PDS_IDD(void* p0, double p1, struct S_IDD p2) ;
+EXPORT void* f15_P_PDS_IDP(void* p0, double p1, struct S_IDP p2) ;
+EXPORT void* f15_P_PDS_IPI(void* p0, double p1, struct S_IPI p2) ;
+EXPORT void* f15_P_PDS_IPF(void* p0, double p1, struct S_IPF p2) ;
+EXPORT void* f15_P_PDS_IPD(void* p0, double p1, struct S_IPD p2) ;
+EXPORT void* f15_P_PDS_IPP(void* p0, double p1, struct S_IPP p2) ;
+EXPORT void* f15_P_PDS_FII(void* p0, double p1, struct S_FII p2) ;
+EXPORT void* f15_P_PDS_FIF(void* p0, double p1, struct S_FIF p2) ;
+EXPORT void* f15_P_PDS_FID(void* p0, double p1, struct S_FID p2) ;
+EXPORT void* f15_P_PDS_FIP(void* p0, double p1, struct S_FIP p2) ;
+EXPORT void* f15_P_PDS_FFI(void* p0, double p1, struct S_FFI p2) ;
+EXPORT void* f15_P_PDS_FFF(void* p0, double p1, struct S_FFF p2) ;
+EXPORT void* f15_P_PDS_FFD(void* p0, double p1, struct S_FFD p2) ;
+EXPORT void* f15_P_PDS_FFP(void* p0, double p1, struct S_FFP p2) ;
+EXPORT void* f15_P_PDS_FDI(void* p0, double p1, struct S_FDI p2) ;
+EXPORT void* f15_P_PDS_FDF(void* p0, double p1, struct S_FDF p2) ;
+EXPORT void* f15_P_PDS_FDD(void* p0, double p1, struct S_FDD p2) ;
+EXPORT void* f15_P_PDS_FDP(void* p0, double p1, struct S_FDP p2) ;
+EXPORT void* f15_P_PDS_FPI(void* p0, double p1, struct S_FPI p2) ;
+EXPORT void* f15_P_PDS_FPF(void* p0, double p1, struct S_FPF p2) ;
+EXPORT void* f15_P_PDS_FPD(void* p0, double p1, struct S_FPD p2) ;
+EXPORT void* f15_P_PDS_FPP(void* p0, double p1, struct S_FPP p2) ;
+EXPORT void* f15_P_PDS_DII(void* p0, double p1, struct S_DII p2) ;
+EXPORT void* f15_P_PDS_DIF(void* p0, double p1, struct S_DIF p2) ;
+EXPORT void* f15_P_PDS_DID(void* p0, double p1, struct S_DID p2) ;
+EXPORT void* f15_P_PDS_DIP(void* p0, double p1, struct S_DIP p2) ;
+EXPORT void* f15_P_PDS_DFI(void* p0, double p1, struct S_DFI p2) ;
+EXPORT void* f15_P_PDS_DFF(void* p0, double p1, struct S_DFF p2) ;
+EXPORT void* f15_P_PDS_DFD(void* p0, double p1, struct S_DFD p2) ;
+EXPORT void* f15_P_PDS_DFP(void* p0, double p1, struct S_DFP p2) ;
+EXPORT void* f15_P_PDS_DDI(void* p0, double p1, struct S_DDI p2) ;
+EXPORT void* f15_P_PDS_DDF(void* p0, double p1, struct S_DDF p2) ;
+EXPORT void* f15_P_PDS_DDD(void* p0, double p1, struct S_DDD p2) ;
+EXPORT void* f15_P_PDS_DDP(void* p0, double p1, struct S_DDP p2) ;
+EXPORT void* f15_P_PDS_DPI(void* p0, double p1, struct S_DPI p2) ;
+EXPORT void* f15_P_PDS_DPF(void* p0, double p1, struct S_DPF p2) ;
+EXPORT void* f15_P_PDS_DPD(void* p0, double p1, struct S_DPD p2) ;
+EXPORT void* f15_P_PDS_DPP(void* p0, double p1, struct S_DPP p2) ;
+EXPORT void* f15_P_PDS_PII(void* p0, double p1, struct S_PII p2) ;
+EXPORT void* f15_P_PDS_PIF(void* p0, double p1, struct S_PIF p2) ;
+EXPORT void* f15_P_PDS_PID(void* p0, double p1, struct S_PID p2) ;
+EXPORT void* f15_P_PDS_PIP(void* p0, double p1, struct S_PIP p2) ;
+EXPORT void* f15_P_PDS_PFI(void* p0, double p1, struct S_PFI p2) ;
+EXPORT void* f15_P_PDS_PFF(void* p0, double p1, struct S_PFF p2) ;
+EXPORT void* f15_P_PDS_PFD(void* p0, double p1, struct S_PFD p2) ;
+EXPORT void* f15_P_PDS_PFP(void* p0, double p1, struct S_PFP p2) ;
+EXPORT void* f15_P_PDS_PDI(void* p0, double p1, struct S_PDI p2) ;
+EXPORT void* f15_P_PDS_PDF(void* p0, double p1, struct S_PDF p2) ;
+EXPORT void* f15_P_PDS_PDD(void* p0, double p1, struct S_PDD p2) ;
+EXPORT void* f15_P_PDS_PDP(void* p0, double p1, struct S_PDP p2) ;
+EXPORT void* f15_P_PDS_PPI(void* p0, double p1, struct S_PPI p2) ;
+EXPORT void* f15_P_PDS_PPF(void* p0, double p1, struct S_PPF p2) ;
+EXPORT void* f15_P_PDS_PPD(void* p0, double p1, struct S_PPD p2) ;
+EXPORT void* f15_P_PDS_PPP(void* p0, double p1, struct S_PPP p2) ;
+EXPORT void* f15_P_PPI_(void* p0, void* p1, int p2) ;
+EXPORT void* f15_P_PPF_(void* p0, void* p1, float p2) ;
+EXPORT void* f15_P_PPD_(void* p0, void* p1, double p2) ;
+EXPORT void* f15_P_PPP_(void* p0, void* p1, void* p2) ;
+EXPORT void* f15_P_PPS_I(void* p0, void* p1, struct S_I p2) ;
+EXPORT void* f15_P_PPS_F(void* p0, void* p1, struct S_F p2) ;
+EXPORT void* f15_P_PPS_D(void* p0, void* p1, struct S_D p2) ;
+EXPORT void* f15_P_PPS_P(void* p0, void* p1, struct S_P p2) ;
+EXPORT void* f15_P_PPS_II(void* p0, void* p1, struct S_II p2) ;
+EXPORT void* f15_P_PPS_IF(void* p0, void* p1, struct S_IF p2) ;
+EXPORT void* f15_P_PPS_ID(void* p0, void* p1, struct S_ID p2) ;
+EXPORT void* f15_P_PPS_IP(void* p0, void* p1, struct S_IP p2) ;
+EXPORT void* f15_P_PPS_FI(void* p0, void* p1, struct S_FI p2) ;
+EXPORT void* f15_P_PPS_FF(void* p0, void* p1, struct S_FF p2) ;
+EXPORT void* f15_P_PPS_FD(void* p0, void* p1, struct S_FD p2) ;
+EXPORT void* f15_P_PPS_FP(void* p0, void* p1, struct S_FP p2) ;
+EXPORT void* f15_P_PPS_DI(void* p0, void* p1, struct S_DI p2) ;
+EXPORT void* f15_P_PPS_DF(void* p0, void* p1, struct S_DF p2) ;
+EXPORT void* f15_P_PPS_DD(void* p0, void* p1, struct S_DD p2) ;
+EXPORT void* f15_P_PPS_DP(void* p0, void* p1, struct S_DP p2) ;
+EXPORT void* f15_P_PPS_PI(void* p0, void* p1, struct S_PI p2) ;
+EXPORT void* f15_P_PPS_PF(void* p0, void* p1, struct S_PF p2) ;
+EXPORT void* f15_P_PPS_PD(void* p0, void* p1, struct S_PD p2) ;
+EXPORT void* f15_P_PPS_PP(void* p0, void* p1, struct S_PP p2) ;
+EXPORT void* f15_P_PPS_III(void* p0, void* p1, struct S_III p2) ;
+EXPORT void* f15_P_PPS_IIF(void* p0, void* p1, struct S_IIF p2) ;
+EXPORT void* f15_P_PPS_IID(void* p0, void* p1, struct S_IID p2) ;
+EXPORT void* f15_P_PPS_IIP(void* p0, void* p1, struct S_IIP p2) ;
+EXPORT void* f15_P_PPS_IFI(void* p0, void* p1, struct S_IFI p2) ;
+EXPORT void* f15_P_PPS_IFF(void* p0, void* p1, struct S_IFF p2) ;
+EXPORT void* f15_P_PPS_IFD(void* p0, void* p1, struct S_IFD p2) ;
+EXPORT void* f15_P_PPS_IFP(void* p0, void* p1, struct S_IFP p2) ;
+EXPORT void* f15_P_PPS_IDI(void* p0, void* p1, struct S_IDI p2) ;
+EXPORT void* f15_P_PPS_IDF(void* p0, void* p1, struct S_IDF p2) ;
+EXPORT void* f15_P_PPS_IDD(void* p0, void* p1, struct S_IDD p2) ;
+EXPORT void* f15_P_PPS_IDP(void* p0, void* p1, struct S_IDP p2) ;
+EXPORT void* f15_P_PPS_IPI(void* p0, void* p1, struct S_IPI p2) ;
+EXPORT void* f15_P_PPS_IPF(void* p0, void* p1, struct S_IPF p2) ;
+EXPORT void* f15_P_PPS_IPD(void* p0, void* p1, struct S_IPD p2) ;
+EXPORT void* f15_P_PPS_IPP(void* p0, void* p1, struct S_IPP p2) ;
+EXPORT void* f15_P_PPS_FII(void* p0, void* p1, struct S_FII p2) ;
+EXPORT void* f15_P_PPS_FIF(void* p0, void* p1, struct S_FIF p2) ;
+EXPORT void* f15_P_PPS_FID(void* p0, void* p1, struct S_FID p2) ;
+EXPORT void* f15_P_PPS_FIP(void* p0, void* p1, struct S_FIP p2) ;
+EXPORT void* f15_P_PPS_FFI(void* p0, void* p1, struct S_FFI p2) ;
+EXPORT void* f15_P_PPS_FFF(void* p0, void* p1, struct S_FFF p2) ;
+EXPORT void* f15_P_PPS_FFD(void* p0, void* p1, struct S_FFD p2) ;
+EXPORT void* f15_P_PPS_FFP(void* p0, void* p1, struct S_FFP p2) ;
+EXPORT void* f15_P_PPS_FDI(void* p0, void* p1, struct S_FDI p2) ;
+EXPORT void* f15_P_PPS_FDF(void* p0, void* p1, struct S_FDF p2) ;
+EXPORT void* f15_P_PPS_FDD(void* p0, void* p1, struct S_FDD p2) ;
+EXPORT void* f15_P_PPS_FDP(void* p0, void* p1, struct S_FDP p2) ;
+EXPORT void* f15_P_PPS_FPI(void* p0, void* p1, struct S_FPI p2) ;
+EXPORT void* f15_P_PPS_FPF(void* p0, void* p1, struct S_FPF p2) ;
+EXPORT void* f15_P_PPS_FPD(void* p0, void* p1, struct S_FPD p2) ;
+EXPORT void* f15_P_PPS_FPP(void* p0, void* p1, struct S_FPP p2) ;
+EXPORT void* f15_P_PPS_DII(void* p0, void* p1, struct S_DII p2) ;
+EXPORT void* f15_P_PPS_DIF(void* p0, void* p1, struct S_DIF p2) ;
+EXPORT void* f15_P_PPS_DID(void* p0, void* p1, struct S_DID p2) ;
+EXPORT void* f15_P_PPS_DIP(void* p0, void* p1, struct S_DIP p2) ;
+EXPORT void* f15_P_PPS_DFI(void* p0, void* p1, struct S_DFI p2) ;
+EXPORT void* f15_P_PPS_DFF(void* p0, void* p1, struct S_DFF p2) ;
+EXPORT void* f15_P_PPS_DFD(void* p0, void* p1, struct S_DFD p2) ;
+EXPORT void* f15_P_PPS_DFP(void* p0, void* p1, struct S_DFP p2) ;
+EXPORT void* f15_P_PPS_DDI(void* p0, void* p1, struct S_DDI p2) ;
+EXPORT void* f15_P_PPS_DDF(void* p0, void* p1, struct S_DDF p2) ;
+EXPORT void* f15_P_PPS_DDD(void* p0, void* p1, struct S_DDD p2) ;
+EXPORT void* f15_P_PPS_DDP(void* p0, void* p1, struct S_DDP p2) ;
+EXPORT void* f15_P_PPS_DPI(void* p0, void* p1, struct S_DPI p2) ;
+EXPORT void* f15_P_PPS_DPF(void* p0, void* p1, struct S_DPF p2) ;
+EXPORT void* f15_P_PPS_DPD(void* p0, void* p1, struct S_DPD p2) ;
+EXPORT void* f15_P_PPS_DPP(void* p0, void* p1, struct S_DPP p2) ;
+EXPORT void* f15_P_PPS_PII(void* p0, void* p1, struct S_PII p2) ;
+EXPORT void* f15_P_PPS_PIF(void* p0, void* p1, struct S_PIF p2) ;
+EXPORT void* f15_P_PPS_PID(void* p0, void* p1, struct S_PID p2) ;
+EXPORT void* f15_P_PPS_PIP(void* p0, void* p1, struct S_PIP p2) ;
+EXPORT void* f15_P_PPS_PFI(void* p0, void* p1, struct S_PFI p2) ;
+EXPORT void* f15_P_PPS_PFF(void* p0, void* p1, struct S_PFF p2) ;
+EXPORT void* f15_P_PPS_PFD(void* p0, void* p1, struct S_PFD p2) ;
+EXPORT void* f15_P_PPS_PFP(void* p0, void* p1, struct S_PFP p2) ;
+EXPORT void* f15_P_PPS_PDI(void* p0, void* p1, struct S_PDI p2) ;
+EXPORT void* f15_P_PPS_PDF(void* p0, void* p1, struct S_PDF p2) ;
+EXPORT void* f15_P_PPS_PDD(void* p0, void* p1, struct S_PDD p2) ;
+EXPORT void* f15_P_PPS_PDP(void* p0, void* p1, struct S_PDP p2) ;
+EXPORT void* f15_P_PPS_PPI(void* p0, void* p1, struct S_PPI p2) ;
+EXPORT void* f15_P_PPS_PPF(void* p0, void* p1, struct S_PPF p2) ;
+EXPORT void* f15_P_PPS_PPD(void* p0, void* p1, struct S_PPD p2) ;
+EXPORT void* f15_P_PPS_PPP(void* p0, void* p1, struct S_PPP p2) ;
+EXPORT void* f15_P_PSI_I(void* p0, struct S_I p1, int p2) ;
+EXPORT void* f15_P_PSI_F(void* p0, struct S_F p1, int p2) ;
+EXPORT void* f15_P_PSI_D(void* p0, struct S_D p1, int p2) ;
+EXPORT void* f15_P_PSI_P(void* p0, struct S_P p1, int p2) ;
+EXPORT void* f15_P_PSI_II(void* p0, struct S_II p1, int p2) ;
+EXPORT void* f15_P_PSI_IF(void* p0, struct S_IF p1, int p2) ;
+EXPORT void* f15_P_PSI_ID(void* p0, struct S_ID p1, int p2) ;
+EXPORT void* f15_P_PSI_IP(void* p0, struct S_IP p1, int p2) ;
+EXPORT void* f15_P_PSI_FI(void* p0, struct S_FI p1, int p2) ;
+EXPORT void* f15_P_PSI_FF(void* p0, struct S_FF p1, int p2) ;
+EXPORT void* f15_P_PSI_FD(void* p0, struct S_FD p1, int p2) ;
+EXPORT void* f15_P_PSI_FP(void* p0, struct S_FP p1, int p2) ;
+EXPORT void* f15_P_PSI_DI(void* p0, struct S_DI p1, int p2) ;
+EXPORT void* f15_P_PSI_DF(void* p0, struct S_DF p1, int p2) ;
+EXPORT void* f15_P_PSI_DD(void* p0, struct S_DD p1, int p2) ;
+EXPORT void* f15_P_PSI_DP(void* p0, struct S_DP p1, int p2) ;
+EXPORT void* f15_P_PSI_PI(void* p0, struct S_PI p1, int p2) ;
+EXPORT void* f15_P_PSI_PF(void* p0, struct S_PF p1, int p2) ;
+EXPORT void* f15_P_PSI_PD(void* p0, struct S_PD p1, int p2) ;
+EXPORT void* f15_P_PSI_PP(void* p0, struct S_PP p1, int p2) ;
+EXPORT void* f15_P_PSI_III(void* p0, struct S_III p1, int p2) ;
+EXPORT void* f15_P_PSI_IIF(void* p0, struct S_IIF p1, int p2) ;
+EXPORT void* f15_P_PSI_IID(void* p0, struct S_IID p1, int p2) ;
+EXPORT void* f16_P_PSI_IIP(void* p0, struct S_IIP p1, int p2) ;
+EXPORT void* f16_P_PSI_IFI(void* p0, struct S_IFI p1, int p2) ;
+EXPORT void* f16_P_PSI_IFF(void* p0, struct S_IFF p1, int p2) ;
+EXPORT void* f16_P_PSI_IFD(void* p0, struct S_IFD p1, int p2) ;
+EXPORT void* f16_P_PSI_IFP(void* p0, struct S_IFP p1, int p2) ;
+EXPORT void* f16_P_PSI_IDI(void* p0, struct S_IDI p1, int p2) ;
+EXPORT void* f16_P_PSI_IDF(void* p0, struct S_IDF p1, int p2) ;
+EXPORT void* f16_P_PSI_IDD(void* p0, struct S_IDD p1, int p2) ;
+EXPORT void* f16_P_PSI_IDP(void* p0, struct S_IDP p1, int p2) ;
+EXPORT void* f16_P_PSI_IPI(void* p0, struct S_IPI p1, int p2) ;
+EXPORT void* f16_P_PSI_IPF(void* p0, struct S_IPF p1, int p2) ;
+EXPORT void* f16_P_PSI_IPD(void* p0, struct S_IPD p1, int p2) ;
+EXPORT void* f16_P_PSI_IPP(void* p0, struct S_IPP p1, int p2) ;
+EXPORT void* f16_P_PSI_FII(void* p0, struct S_FII p1, int p2) ;
+EXPORT void* f16_P_PSI_FIF(void* p0, struct S_FIF p1, int p2) ;
+EXPORT void* f16_P_PSI_FID(void* p0, struct S_FID p1, int p2) ;
+EXPORT void* f16_P_PSI_FIP(void* p0, struct S_FIP p1, int p2) ;
+EXPORT void* f16_P_PSI_FFI(void* p0, struct S_FFI p1, int p2) ;
+EXPORT void* f16_P_PSI_FFF(void* p0, struct S_FFF p1, int p2) ;
+EXPORT void* f16_P_PSI_FFD(void* p0, struct S_FFD p1, int p2) ;
+EXPORT void* f16_P_PSI_FFP(void* p0, struct S_FFP p1, int p2) ;
+EXPORT void* f16_P_PSI_FDI(void* p0, struct S_FDI p1, int p2) ;
+EXPORT void* f16_P_PSI_FDF(void* p0, struct S_FDF p1, int p2) ;
+EXPORT void* f16_P_PSI_FDD(void* p0, struct S_FDD p1, int p2) ;
+EXPORT void* f16_P_PSI_FDP(void* p0, struct S_FDP p1, int p2) ;
+EXPORT void* f16_P_PSI_FPI(void* p0, struct S_FPI p1, int p2) ;
+EXPORT void* f16_P_PSI_FPF(void* p0, struct S_FPF p1, int p2) ;
+EXPORT void* f16_P_PSI_FPD(void* p0, struct S_FPD p1, int p2) ;
+EXPORT void* f16_P_PSI_FPP(void* p0, struct S_FPP p1, int p2) ;
+EXPORT void* f16_P_PSI_DII(void* p0, struct S_DII p1, int p2) ;
+EXPORT void* f16_P_PSI_DIF(void* p0, struct S_DIF p1, int p2) ;
+EXPORT void* f16_P_PSI_DID(void* p0, struct S_DID p1, int p2) ;
+EXPORT void* f16_P_PSI_DIP(void* p0, struct S_DIP p1, int p2) ;
+EXPORT void* f16_P_PSI_DFI(void* p0, struct S_DFI p1, int p2) ;
+EXPORT void* f16_P_PSI_DFF(void* p0, struct S_DFF p1, int p2) ;
+EXPORT void* f16_P_PSI_DFD(void* p0, struct S_DFD p1, int p2) ;
+EXPORT void* f16_P_PSI_DFP(void* p0, struct S_DFP p1, int p2) ;
+EXPORT void* f16_P_PSI_DDI(void* p0, struct S_DDI p1, int p2) ;
+EXPORT void* f16_P_PSI_DDF(void* p0, struct S_DDF p1, int p2) ;
+EXPORT void* f16_P_PSI_DDD(void* p0, struct S_DDD p1, int p2) ;
+EXPORT void* f16_P_PSI_DDP(void* p0, struct S_DDP p1, int p2) ;
+EXPORT void* f16_P_PSI_DPI(void* p0, struct S_DPI p1, int p2) ;
+EXPORT void* f16_P_PSI_DPF(void* p0, struct S_DPF p1, int p2) ;
+EXPORT void* f16_P_PSI_DPD(void* p0, struct S_DPD p1, int p2) ;
+EXPORT void* f16_P_PSI_DPP(void* p0, struct S_DPP p1, int p2) ;
+EXPORT void* f16_P_PSI_PII(void* p0, struct S_PII p1, int p2) ;
+EXPORT void* f16_P_PSI_PIF(void* p0, struct S_PIF p1, int p2) ;
+EXPORT void* f16_P_PSI_PID(void* p0, struct S_PID p1, int p2) ;
+EXPORT void* f16_P_PSI_PIP(void* p0, struct S_PIP p1, int p2) ;
+EXPORT void* f16_P_PSI_PFI(void* p0, struct S_PFI p1, int p2) ;
+EXPORT void* f16_P_PSI_PFF(void* p0, struct S_PFF p1, int p2) ;
+EXPORT void* f16_P_PSI_PFD(void* p0, struct S_PFD p1, int p2) ;
+EXPORT void* f16_P_PSI_PFP(void* p0, struct S_PFP p1, int p2) ;
+EXPORT void* f16_P_PSI_PDI(void* p0, struct S_PDI p1, int p2) ;
+EXPORT void* f16_P_PSI_PDF(void* p0, struct S_PDF p1, int p2) ;
+EXPORT void* f16_P_PSI_PDD(void* p0, struct S_PDD p1, int p2) ;
+EXPORT void* f16_P_PSI_PDP(void* p0, struct S_PDP p1, int p2) ;
+EXPORT void* f16_P_PSI_PPI(void* p0, struct S_PPI p1, int p2) ;
+EXPORT void* f16_P_PSI_PPF(void* p0, struct S_PPF p1, int p2) ;
+EXPORT void* f16_P_PSI_PPD(void* p0, struct S_PPD p1, int p2) ;
+EXPORT void* f16_P_PSI_PPP(void* p0, struct S_PPP p1, int p2) ;
+EXPORT void* f16_P_PSF_I(void* p0, struct S_I p1, float p2) ;
+EXPORT void* f16_P_PSF_F(void* p0, struct S_F p1, float p2) ;
+EXPORT void* f16_P_PSF_D(void* p0, struct S_D p1, float p2) ;
+EXPORT void* f16_P_PSF_P(void* p0, struct S_P p1, float p2) ;
+EXPORT void* f16_P_PSF_II(void* p0, struct S_II p1, float p2) ;
+EXPORT void* f16_P_PSF_IF(void* p0, struct S_IF p1, float p2) ;
+EXPORT void* f16_P_PSF_ID(void* p0, struct S_ID p1, float p2) ;
+EXPORT void* f16_P_PSF_IP(void* p0, struct S_IP p1, float p2) ;
+EXPORT void* f16_P_PSF_FI(void* p0, struct S_FI p1, float p2) ;
+EXPORT void* f16_P_PSF_FF(void* p0, struct S_FF p1, float p2) ;
+EXPORT void* f16_P_PSF_FD(void* p0, struct S_FD p1, float p2) ;
+EXPORT void* f16_P_PSF_FP(void* p0, struct S_FP p1, float p2) ;
+EXPORT void* f16_P_PSF_DI(void* p0, struct S_DI p1, float p2) ;
+EXPORT void* f16_P_PSF_DF(void* p0, struct S_DF p1, float p2) ;
+EXPORT void* f16_P_PSF_DD(void* p0, struct S_DD p1, float p2) ;
+EXPORT void* f16_P_PSF_DP(void* p0, struct S_DP p1, float p2) ;
+EXPORT void* f16_P_PSF_PI(void* p0, struct S_PI p1, float p2) ;
+EXPORT void* f16_P_PSF_PF(void* p0, struct S_PF p1, float p2) ;
+EXPORT void* f16_P_PSF_PD(void* p0, struct S_PD p1, float p2) ;
+EXPORT void* f16_P_PSF_PP(void* p0, struct S_PP p1, float p2) ;
+EXPORT void* f16_P_PSF_III(void* p0, struct S_III p1, float p2) ;
+EXPORT void* f16_P_PSF_IIF(void* p0, struct S_IIF p1, float p2) ;
+EXPORT void* f16_P_PSF_IID(void* p0, struct S_IID p1, float p2) ;
+EXPORT void* f16_P_PSF_IIP(void* p0, struct S_IIP p1, float p2) ;
+EXPORT void* f16_P_PSF_IFI(void* p0, struct S_IFI p1, float p2) ;
+EXPORT void* f16_P_PSF_IFF(void* p0, struct S_IFF p1, float p2) ;
+EXPORT void* f16_P_PSF_IFD(void* p0, struct S_IFD p1, float p2) ;
+EXPORT void* f16_P_PSF_IFP(void* p0, struct S_IFP p1, float p2) ;
+EXPORT void* f16_P_PSF_IDI(void* p0, struct S_IDI p1, float p2) ;
+EXPORT void* f16_P_PSF_IDF(void* p0, struct S_IDF p1, float p2) ;
+EXPORT void* f16_P_PSF_IDD(void* p0, struct S_IDD p1, float p2) ;
+EXPORT void* f16_P_PSF_IDP(void* p0, struct S_IDP p1, float p2) ;
+EXPORT void* f16_P_PSF_IPI(void* p0, struct S_IPI p1, float p2) ;
+EXPORT void* f16_P_PSF_IPF(void* p0, struct S_IPF p1, float p2) ;
+EXPORT void* f16_P_PSF_IPD(void* p0, struct S_IPD p1, float p2) ;
+EXPORT void* f16_P_PSF_IPP(void* p0, struct S_IPP p1, float p2) ;
+EXPORT void* f16_P_PSF_FII(void* p0, struct S_FII p1, float p2) ;
+EXPORT void* f16_P_PSF_FIF(void* p0, struct S_FIF p1, float p2) ;
+EXPORT void* f16_P_PSF_FID(void* p0, struct S_FID p1, float p2) ;
+EXPORT void* f16_P_PSF_FIP(void* p0, struct S_FIP p1, float p2) ;
+EXPORT void* f16_P_PSF_FFI(void* p0, struct S_FFI p1, float p2) ;
+EXPORT void* f16_P_PSF_FFF(void* p0, struct S_FFF p1, float p2) ;
+EXPORT void* f16_P_PSF_FFD(void* p0, struct S_FFD p1, float p2) ;
+EXPORT void* f16_P_PSF_FFP(void* p0, struct S_FFP p1, float p2) ;
+EXPORT void* f16_P_PSF_FDI(void* p0, struct S_FDI p1, float p2) ;
+EXPORT void* f16_P_PSF_FDF(void* p0, struct S_FDF p1, float p2) ;
+EXPORT void* f16_P_PSF_FDD(void* p0, struct S_FDD p1, float p2) ;
+EXPORT void* f16_P_PSF_FDP(void* p0, struct S_FDP p1, float p2) ;
+EXPORT void* f16_P_PSF_FPI(void* p0, struct S_FPI p1, float p2) ;
+EXPORT void* f16_P_PSF_FPF(void* p0, struct S_FPF p1, float p2) ;
+EXPORT void* f16_P_PSF_FPD(void* p0, struct S_FPD p1, float p2) ;
+EXPORT void* f16_P_PSF_FPP(void* p0, struct S_FPP p1, float p2) ;
+EXPORT void* f16_P_PSF_DII(void* p0, struct S_DII p1, float p2) ;
+EXPORT void* f16_P_PSF_DIF(void* p0, struct S_DIF p1, float p2) ;
+EXPORT void* f16_P_PSF_DID(void* p0, struct S_DID p1, float p2) ;
+EXPORT void* f16_P_PSF_DIP(void* p0, struct S_DIP p1, float p2) ;
+EXPORT void* f16_P_PSF_DFI(void* p0, struct S_DFI p1, float p2) ;
+EXPORT void* f16_P_PSF_DFF(void* p0, struct S_DFF p1, float p2) ;
+EXPORT void* f16_P_PSF_DFD(void* p0, struct S_DFD p1, float p2) ;
+EXPORT void* f16_P_PSF_DFP(void* p0, struct S_DFP p1, float p2) ;
+EXPORT void* f16_P_PSF_DDI(void* p0, struct S_DDI p1, float p2) ;
+EXPORT void* f16_P_PSF_DDF(void* p0, struct S_DDF p1, float p2) ;
+EXPORT void* f16_P_PSF_DDD(void* p0, struct S_DDD p1, float p2) ;
+EXPORT void* f16_P_PSF_DDP(void* p0, struct S_DDP p1, float p2) ;
+EXPORT void* f16_P_PSF_DPI(void* p0, struct S_DPI p1, float p2) ;
+EXPORT void* f16_P_PSF_DPF(void* p0, struct S_DPF p1, float p2) ;
+EXPORT void* f16_P_PSF_DPD(void* p0, struct S_DPD p1, float p2) ;
+EXPORT void* f16_P_PSF_DPP(void* p0, struct S_DPP p1, float p2) ;
+EXPORT void* f16_P_PSF_PII(void* p0, struct S_PII p1, float p2) ;
+EXPORT void* f16_P_PSF_PIF(void* p0, struct S_PIF p1, float p2) ;
+EXPORT void* f16_P_PSF_PID(void* p0, struct S_PID p1, float p2) ;
+EXPORT void* f16_P_PSF_PIP(void* p0, struct S_PIP p1, float p2) ;
+EXPORT void* f16_P_PSF_PFI(void* p0, struct S_PFI p1, float p2) ;
+EXPORT void* f16_P_PSF_PFF(void* p0, struct S_PFF p1, float p2) ;
+EXPORT void* f16_P_PSF_PFD(void* p0, struct S_PFD p1, float p2) ;
+EXPORT void* f16_P_PSF_PFP(void* p0, struct S_PFP p1, float p2) ;
+EXPORT void* f16_P_PSF_PDI(void* p0, struct S_PDI p1, float p2) ;
+EXPORT void* f16_P_PSF_PDF(void* p0, struct S_PDF p1, float p2) ;
+EXPORT void* f16_P_PSF_PDD(void* p0, struct S_PDD p1, float p2) ;
+EXPORT void* f16_P_PSF_PDP(void* p0, struct S_PDP p1, float p2) ;
+EXPORT void* f16_P_PSF_PPI(void* p0, struct S_PPI p1, float p2) ;
+EXPORT void* f16_P_PSF_PPF(void* p0, struct S_PPF p1, float p2) ;
+EXPORT void* f16_P_PSF_PPD(void* p0, struct S_PPD p1, float p2) ;
+EXPORT void* f16_P_PSF_PPP(void* p0, struct S_PPP p1, float p2) ;
+EXPORT void* f16_P_PSD_I(void* p0, struct S_I p1, double p2) ;
+EXPORT void* f16_P_PSD_F(void* p0, struct S_F p1, double p2) ;
+EXPORT void* f16_P_PSD_D(void* p0, struct S_D p1, double p2) ;
+EXPORT void* f16_P_PSD_P(void* p0, struct S_P p1, double p2) ;
+EXPORT void* f16_P_PSD_II(void* p0, struct S_II p1, double p2) ;
+EXPORT void* f16_P_PSD_IF(void* p0, struct S_IF p1, double p2) ;
+EXPORT void* f16_P_PSD_ID(void* p0, struct S_ID p1, double p2) ;
+EXPORT void* f16_P_PSD_IP(void* p0, struct S_IP p1, double p2) ;
+EXPORT void* f16_P_PSD_FI(void* p0, struct S_FI p1, double p2) ;
+EXPORT void* f16_P_PSD_FF(void* p0, struct S_FF p1, double p2) ;
+EXPORT void* f16_P_PSD_FD(void* p0, struct S_FD p1, double p2) ;
+EXPORT void* f16_P_PSD_FP(void* p0, struct S_FP p1, double p2) ;
+EXPORT void* f16_P_PSD_DI(void* p0, struct S_DI p1, double p2) ;
+EXPORT void* f16_P_PSD_DF(void* p0, struct S_DF p1, double p2) ;
+EXPORT void* f16_P_PSD_DD(void* p0, struct S_DD p1, double p2) ;
+EXPORT void* f16_P_PSD_DP(void* p0, struct S_DP p1, double p2) ;
+EXPORT void* f16_P_PSD_PI(void* p0, struct S_PI p1, double p2) ;
+EXPORT void* f16_P_PSD_PF(void* p0, struct S_PF p1, double p2) ;
+EXPORT void* f16_P_PSD_PD(void* p0, struct S_PD p1, double p2) ;
+EXPORT void* f16_P_PSD_PP(void* p0, struct S_PP p1, double p2) ;
+EXPORT void* f16_P_PSD_III(void* p0, struct S_III p1, double p2) ;
+EXPORT void* f16_P_PSD_IIF(void* p0, struct S_IIF p1, double p2) ;
+EXPORT void* f16_P_PSD_IID(void* p0, struct S_IID p1, double p2) ;
+EXPORT void* f16_P_PSD_IIP(void* p0, struct S_IIP p1, double p2) ;
+EXPORT void* f16_P_PSD_IFI(void* p0, struct S_IFI p1, double p2) ;
+EXPORT void* f16_P_PSD_IFF(void* p0, struct S_IFF p1, double p2) ;
+EXPORT void* f16_P_PSD_IFD(void* p0, struct S_IFD p1, double p2) ;
+EXPORT void* f16_P_PSD_IFP(void* p0, struct S_IFP p1, double p2) ;
+EXPORT void* f16_P_PSD_IDI(void* p0, struct S_IDI p1, double p2) ;
+EXPORT void* f16_P_PSD_IDF(void* p0, struct S_IDF p1, double p2) ;
+EXPORT void* f16_P_PSD_IDD(void* p0, struct S_IDD p1, double p2) ;
+EXPORT void* f16_P_PSD_IDP(void* p0, struct S_IDP p1, double p2) ;
+EXPORT void* f16_P_PSD_IPI(void* p0, struct S_IPI p1, double p2) ;
+EXPORT void* f16_P_PSD_IPF(void* p0, struct S_IPF p1, double p2) ;
+EXPORT void* f16_P_PSD_IPD(void* p0, struct S_IPD p1, double p2) ;
+EXPORT void* f16_P_PSD_IPP(void* p0, struct S_IPP p1, double p2) ;
+EXPORT void* f16_P_PSD_FII(void* p0, struct S_FII p1, double p2) ;
+EXPORT void* f16_P_PSD_FIF(void* p0, struct S_FIF p1, double p2) ;
+EXPORT void* f16_P_PSD_FID(void* p0, struct S_FID p1, double p2) ;
+EXPORT void* f16_P_PSD_FIP(void* p0, struct S_FIP p1, double p2) ;
+EXPORT void* f16_P_PSD_FFI(void* p0, struct S_FFI p1, double p2) ;
+EXPORT void* f16_P_PSD_FFF(void* p0, struct S_FFF p1, double p2) ;
+EXPORT void* f16_P_PSD_FFD(void* p0, struct S_FFD p1, double p2) ;
+EXPORT void* f16_P_PSD_FFP(void* p0, struct S_FFP p1, double p2) ;
+EXPORT void* f16_P_PSD_FDI(void* p0, struct S_FDI p1, double p2) ;
+EXPORT void* f16_P_PSD_FDF(void* p0, struct S_FDF p1, double p2) ;
+EXPORT void* f16_P_PSD_FDD(void* p0, struct S_FDD p1, double p2) ;
+EXPORT void* f16_P_PSD_FDP(void* p0, struct S_FDP p1, double p2) ;
+EXPORT void* f16_P_PSD_FPI(void* p0, struct S_FPI p1, double p2) ;
+EXPORT void* f16_P_PSD_FPF(void* p0, struct S_FPF p1, double p2) ;
+EXPORT void* f16_P_PSD_FPD(void* p0, struct S_FPD p1, double p2) ;
+EXPORT void* f16_P_PSD_FPP(void* p0, struct S_FPP p1, double p2) ;
+EXPORT void* f16_P_PSD_DII(void* p0, struct S_DII p1, double p2) ;
+EXPORT void* f16_P_PSD_DIF(void* p0, struct S_DIF p1, double p2) ;
+EXPORT void* f16_P_PSD_DID(void* p0, struct S_DID p1, double p2) ;
+EXPORT void* f16_P_PSD_DIP(void* p0, struct S_DIP p1, double p2) ;
+EXPORT void* f16_P_PSD_DFI(void* p0, struct S_DFI p1, double p2) ;
+EXPORT void* f16_P_PSD_DFF(void* p0, struct S_DFF p1, double p2) ;
+EXPORT void* f16_P_PSD_DFD(void* p0, struct S_DFD p1, double p2) ;
+EXPORT void* f16_P_PSD_DFP(void* p0, struct S_DFP p1, double p2) ;
+EXPORT void* f16_P_PSD_DDI(void* p0, struct S_DDI p1, double p2) ;
+EXPORT void* f16_P_PSD_DDF(void* p0, struct S_DDF p1, double p2) ;
+EXPORT void* f16_P_PSD_DDD(void* p0, struct S_DDD p1, double p2) ;
+EXPORT void* f16_P_PSD_DDP(void* p0, struct S_DDP p1, double p2) ;
+EXPORT void* f16_P_PSD_DPI(void* p0, struct S_DPI p1, double p2) ;
+EXPORT void* f16_P_PSD_DPF(void* p0, struct S_DPF p1, double p2) ;
+EXPORT void* f16_P_PSD_DPD(void* p0, struct S_DPD p1, double p2) ;
+EXPORT void* f16_P_PSD_DPP(void* p0, struct S_DPP p1, double p2) ;
+EXPORT void* f16_P_PSD_PII(void* p0, struct S_PII p1, double p2) ;
+EXPORT void* f16_P_PSD_PIF(void* p0, struct S_PIF p1, double p2) ;
+EXPORT void* f16_P_PSD_PID(void* p0, struct S_PID p1, double p2) ;
+EXPORT void* f16_P_PSD_PIP(void* p0, struct S_PIP p1, double p2) ;
+EXPORT void* f16_P_PSD_PFI(void* p0, struct S_PFI p1, double p2) ;
+EXPORT void* f16_P_PSD_PFF(void* p0, struct S_PFF p1, double p2) ;
+EXPORT void* f16_P_PSD_PFD(void* p0, struct S_PFD p1, double p2) ;
+EXPORT void* f16_P_PSD_PFP(void* p0, struct S_PFP p1, double p2) ;
+EXPORT void* f16_P_PSD_PDI(void* p0, struct S_PDI p1, double p2) ;
+EXPORT void* f16_P_PSD_PDF(void* p0, struct S_PDF p1, double p2) ;
+EXPORT void* f16_P_PSD_PDD(void* p0, struct S_PDD p1, double p2) ;
+EXPORT void* f16_P_PSD_PDP(void* p0, struct S_PDP p1, double p2) ;
+EXPORT void* f16_P_PSD_PPI(void* p0, struct S_PPI p1, double p2) ;
+EXPORT void* f16_P_PSD_PPF(void* p0, struct S_PPF p1, double p2) ;
+EXPORT void* f16_P_PSD_PPD(void* p0, struct S_PPD p1, double p2) ;
+EXPORT void* f16_P_PSD_PPP(void* p0, struct S_PPP p1, double p2) ;
+EXPORT void* f16_P_PSP_I(void* p0, struct S_I p1, void* p2) ;
+EXPORT void* f16_P_PSP_F(void* p0, struct S_F p1, void* p2) ;
+EXPORT void* f16_P_PSP_D(void* p0, struct S_D p1, void* p2) ;
+EXPORT void* f16_P_PSP_P(void* p0, struct S_P p1, void* p2) ;
+EXPORT void* f16_P_PSP_II(void* p0, struct S_II p1, void* p2) ;
+EXPORT void* f16_P_PSP_IF(void* p0, struct S_IF p1, void* p2) ;
+EXPORT void* f16_P_PSP_ID(void* p0, struct S_ID p1, void* p2) ;
+EXPORT void* f16_P_PSP_IP(void* p0, struct S_IP p1, void* p2) ;
+EXPORT void* f16_P_PSP_FI(void* p0, struct S_FI p1, void* p2) ;
+EXPORT void* f16_P_PSP_FF(void* p0, struct S_FF p1, void* p2) ;
+EXPORT void* f16_P_PSP_FD(void* p0, struct S_FD p1, void* p2) ;
+EXPORT void* f16_P_PSP_FP(void* p0, struct S_FP p1, void* p2) ;
+EXPORT void* f16_P_PSP_DI(void* p0, struct S_DI p1, void* p2) ;
+EXPORT void* f16_P_PSP_DF(void* p0, struct S_DF p1, void* p2) ;
+EXPORT void* f16_P_PSP_DD(void* p0, struct S_DD p1, void* p2) ;
+EXPORT void* f16_P_PSP_DP(void* p0, struct S_DP p1, void* p2) ;
+EXPORT void* f16_P_PSP_PI(void* p0, struct S_PI p1, void* p2) ;
+EXPORT void* f16_P_PSP_PF(void* p0, struct S_PF p1, void* p2) ;
+EXPORT void* f16_P_PSP_PD(void* p0, struct S_PD p1, void* p2) ;
+EXPORT void* f16_P_PSP_PP(void* p0, struct S_PP p1, void* p2) ;
+EXPORT void* f16_P_PSP_III(void* p0, struct S_III p1, void* p2) ;
+EXPORT void* f16_P_PSP_IIF(void* p0, struct S_IIF p1, void* p2) ;
+EXPORT void* f16_P_PSP_IID(void* p0, struct S_IID p1, void* p2) ;
+EXPORT void* f16_P_PSP_IIP(void* p0, struct S_IIP p1, void* p2) ;
+EXPORT void* f16_P_PSP_IFI(void* p0, struct S_IFI p1, void* p2) ;
+EXPORT void* f16_P_PSP_IFF(void* p0, struct S_IFF p1, void* p2) ;
+EXPORT void* f16_P_PSP_IFD(void* p0, struct S_IFD p1, void* p2) ;
+EXPORT void* f16_P_PSP_IFP(void* p0, struct S_IFP p1, void* p2) ;
+EXPORT void* f16_P_PSP_IDI(void* p0, struct S_IDI p1, void* p2) ;
+EXPORT void* f16_P_PSP_IDF(void* p0, struct S_IDF p1, void* p2) ;
+EXPORT void* f16_P_PSP_IDD(void* p0, struct S_IDD p1, void* p2) ;
+EXPORT void* f16_P_PSP_IDP(void* p0, struct S_IDP p1, void* p2) ;
+EXPORT void* f16_P_PSP_IPI(void* p0, struct S_IPI p1, void* p2) ;
+EXPORT void* f16_P_PSP_IPF(void* p0, struct S_IPF p1, void* p2) ;
+EXPORT void* f16_P_PSP_IPD(void* p0, struct S_IPD p1, void* p2) ;
+EXPORT void* f16_P_PSP_IPP(void* p0, struct S_IPP p1, void* p2) ;
+EXPORT void* f16_P_PSP_FII(void* p0, struct S_FII p1, void* p2) ;
+EXPORT void* f16_P_PSP_FIF(void* p0, struct S_FIF p1, void* p2) ;
+EXPORT void* f16_P_PSP_FID(void* p0, struct S_FID p1, void* p2) ;
+EXPORT void* f16_P_PSP_FIP(void* p0, struct S_FIP p1, void* p2) ;
+EXPORT void* f16_P_PSP_FFI(void* p0, struct S_FFI p1, void* p2) ;
+EXPORT void* f16_P_PSP_FFF(void* p0, struct S_FFF p1, void* p2) ;
+EXPORT void* f16_P_PSP_FFD(void* p0, struct S_FFD p1, void* p2) ;
+EXPORT void* f16_P_PSP_FFP(void* p0, struct S_FFP p1, void* p2) ;
+EXPORT void* f16_P_PSP_FDI(void* p0, struct S_FDI p1, void* p2) ;
+EXPORT void* f16_P_PSP_FDF(void* p0, struct S_FDF p1, void* p2) ;
+EXPORT void* f16_P_PSP_FDD(void* p0, struct S_FDD p1, void* p2) ;
+EXPORT void* f16_P_PSP_FDP(void* p0, struct S_FDP p1, void* p2) ;
+EXPORT void* f16_P_PSP_FPI(void* p0, struct S_FPI p1, void* p2) ;
+EXPORT void* f16_P_PSP_FPF(void* p0, struct S_FPF p1, void* p2) ;
+EXPORT void* f16_P_PSP_FPD(void* p0, struct S_FPD p1, void* p2) ;
+EXPORT void* f16_P_PSP_FPP(void* p0, struct S_FPP p1, void* p2) ;
+EXPORT void* f16_P_PSP_DII(void* p0, struct S_DII p1, void* p2) ;
+EXPORT void* f16_P_PSP_DIF(void* p0, struct S_DIF p1, void* p2) ;
+EXPORT void* f16_P_PSP_DID(void* p0, struct S_DID p1, void* p2) ;
+EXPORT void* f16_P_PSP_DIP(void* p0, struct S_DIP p1, void* p2) ;
+EXPORT void* f16_P_PSP_DFI(void* p0, struct S_DFI p1, void* p2) ;
+EXPORT void* f16_P_PSP_DFF(void* p0, struct S_DFF p1, void* p2) ;
+EXPORT void* f16_P_PSP_DFD(void* p0, struct S_DFD p1, void* p2) ;
+EXPORT void* f16_P_PSP_DFP(void* p0, struct S_DFP p1, void* p2) ;
+EXPORT void* f16_P_PSP_DDI(void* p0, struct S_DDI p1, void* p2) ;
+EXPORT void* f16_P_PSP_DDF(void* p0, struct S_DDF p1, void* p2) ;
+EXPORT void* f16_P_PSP_DDD(void* p0, struct S_DDD p1, void* p2) ;
+EXPORT void* f16_P_PSP_DDP(void* p0, struct S_DDP p1, void* p2) ;
+EXPORT void* f16_P_PSP_DPI(void* p0, struct S_DPI p1, void* p2) ;
+EXPORT void* f16_P_PSP_DPF(void* p0, struct S_DPF p1, void* p2) ;
+EXPORT void* f16_P_PSP_DPD(void* p0, struct S_DPD p1, void* p2) ;
+EXPORT void* f16_P_PSP_DPP(void* p0, struct S_DPP p1, void* p2) ;
+EXPORT void* f16_P_PSP_PII(void* p0, struct S_PII p1, void* p2) ;
+EXPORT void* f16_P_PSP_PIF(void* p0, struct S_PIF p1, void* p2) ;
+EXPORT void* f16_P_PSP_PID(void* p0, struct S_PID p1, void* p2) ;
+EXPORT void* f16_P_PSP_PIP(void* p0, struct S_PIP p1, void* p2) ;
+EXPORT void* f16_P_PSP_PFI(void* p0, struct S_PFI p1, void* p2) ;
+EXPORT void* f16_P_PSP_PFF(void* p0, struct S_PFF p1, void* p2) ;
+EXPORT void* f16_P_PSP_PFD(void* p0, struct S_PFD p1, void* p2) ;
+EXPORT void* f16_P_PSP_PFP(void* p0, struct S_PFP p1, void* p2) ;
+EXPORT void* f16_P_PSP_PDI(void* p0, struct S_PDI p1, void* p2) ;
+EXPORT void* f16_P_PSP_PDF(void* p0, struct S_PDF p1, void* p2) ;
+EXPORT void* f16_P_PSP_PDD(void* p0, struct S_PDD p1, void* p2) ;
+EXPORT void* f16_P_PSP_PDP(void* p0, struct S_PDP p1, void* p2) ;
+EXPORT void* f16_P_PSP_PPI(void* p0, struct S_PPI p1, void* p2) ;
+EXPORT void* f16_P_PSP_PPF(void* p0, struct S_PPF p1, void* p2) ;
+EXPORT void* f16_P_PSP_PPD(void* p0, struct S_PPD p1, void* p2) ;
+EXPORT void* f16_P_PSP_PPP(void* p0, struct S_PPP p1, void* p2) ;
+EXPORT void* f16_P_PSS_I(void* p0, struct S_I p1, struct S_I p2) ;
+EXPORT void* f16_P_PSS_F(void* p0, struct S_F p1, struct S_F p2) ;
+EXPORT void* f16_P_PSS_D(void* p0, struct S_D p1, struct S_D p2) ;
+EXPORT void* f16_P_PSS_P(void* p0, struct S_P p1, struct S_P p2) ;
+EXPORT void* f16_P_PSS_II(void* p0, struct S_II p1, struct S_II p2) ;
+EXPORT void* f16_P_PSS_IF(void* p0, struct S_IF p1, struct S_IF p2) ;
+EXPORT void* f16_P_PSS_ID(void* p0, struct S_ID p1, struct S_ID p2) ;
+EXPORT void* f16_P_PSS_IP(void* p0, struct S_IP p1, struct S_IP p2) ;
+EXPORT void* f16_P_PSS_FI(void* p0, struct S_FI p1, struct S_FI p2) ;
+EXPORT void* f16_P_PSS_FF(void* p0, struct S_FF p1, struct S_FF p2) ;
+EXPORT void* f16_P_PSS_FD(void* p0, struct S_FD p1, struct S_FD p2) ;
+EXPORT void* f16_P_PSS_FP(void* p0, struct S_FP p1, struct S_FP p2) ;
+EXPORT void* f16_P_PSS_DI(void* p0, struct S_DI p1, struct S_DI p2) ;
+EXPORT void* f16_P_PSS_DF(void* p0, struct S_DF p1, struct S_DF p2) ;
+EXPORT void* f16_P_PSS_DD(void* p0, struct S_DD p1, struct S_DD p2) ;
+EXPORT void* f16_P_PSS_DP(void* p0, struct S_DP p1, struct S_DP p2) ;
+EXPORT void* f16_P_PSS_PI(void* p0, struct S_PI p1, struct S_PI p2) ;
+EXPORT void* f16_P_PSS_PF(void* p0, struct S_PF p1, struct S_PF p2) ;
+EXPORT void* f16_P_PSS_PD(void* p0, struct S_PD p1, struct S_PD p2) ;
+EXPORT void* f16_P_PSS_PP(void* p0, struct S_PP p1, struct S_PP p2) ;
+EXPORT void* f16_P_PSS_III(void* p0, struct S_III p1, struct S_III p2) ;
+EXPORT void* f16_P_PSS_IIF(void* p0, struct S_IIF p1, struct S_IIF p2) ;
+EXPORT void* f16_P_PSS_IID(void* p0, struct S_IID p1, struct S_IID p2) ;
+EXPORT void* f16_P_PSS_IIP(void* p0, struct S_IIP p1, struct S_IIP p2) ;
+EXPORT void* f16_P_PSS_IFI(void* p0, struct S_IFI p1, struct S_IFI p2) ;
+EXPORT void* f16_P_PSS_IFF(void* p0, struct S_IFF p1, struct S_IFF p2) ;
+EXPORT void* f16_P_PSS_IFD(void* p0, struct S_IFD p1, struct S_IFD p2) ;
+EXPORT void* f16_P_PSS_IFP(void* p0, struct S_IFP p1, struct S_IFP p2) ;
+EXPORT void* f16_P_PSS_IDI(void* p0, struct S_IDI p1, struct S_IDI p2) ;
+EXPORT void* f16_P_PSS_IDF(void* p0, struct S_IDF p1, struct S_IDF p2) ;
+EXPORT void* f16_P_PSS_IDD(void* p0, struct S_IDD p1, struct S_IDD p2) ;
+EXPORT void* f16_P_PSS_IDP(void* p0, struct S_IDP p1, struct S_IDP p2) ;
+EXPORT void* f16_P_PSS_IPI(void* p0, struct S_IPI p1, struct S_IPI p2) ;
+EXPORT void* f16_P_PSS_IPF(void* p0, struct S_IPF p1, struct S_IPF p2) ;
+EXPORT void* f16_P_PSS_IPD(void* p0, struct S_IPD p1, struct S_IPD p2) ;
+EXPORT void* f16_P_PSS_IPP(void* p0, struct S_IPP p1, struct S_IPP p2) ;
+EXPORT void* f16_P_PSS_FII(void* p0, struct S_FII p1, struct S_FII p2) ;
+EXPORT void* f16_P_PSS_FIF(void* p0, struct S_FIF p1, struct S_FIF p2) ;
+EXPORT void* f16_P_PSS_FID(void* p0, struct S_FID p1, struct S_FID p2) ;
+EXPORT void* f16_P_PSS_FIP(void* p0, struct S_FIP p1, struct S_FIP p2) ;
+EXPORT void* f16_P_PSS_FFI(void* p0, struct S_FFI p1, struct S_FFI p2) ;
+EXPORT void* f16_P_PSS_FFF(void* p0, struct S_FFF p1, struct S_FFF p2) ;
+EXPORT void* f16_P_PSS_FFD(void* p0, struct S_FFD p1, struct S_FFD p2) ;
+EXPORT void* f16_P_PSS_FFP(void* p0, struct S_FFP p1, struct S_FFP p2) ;
+EXPORT void* f16_P_PSS_FDI(void* p0, struct S_FDI p1, struct S_FDI p2) ;
+EXPORT void* f16_P_PSS_FDF(void* p0, struct S_FDF p1, struct S_FDF p2) ;
+EXPORT void* f16_P_PSS_FDD(void* p0, struct S_FDD p1, struct S_FDD p2) ;
+EXPORT void* f16_P_PSS_FDP(void* p0, struct S_FDP p1, struct S_FDP p2) ;
+EXPORT void* f16_P_PSS_FPI(void* p0, struct S_FPI p1, struct S_FPI p2) ;
+EXPORT void* f16_P_PSS_FPF(void* p0, struct S_FPF p1, struct S_FPF p2) ;
+EXPORT void* f16_P_PSS_FPD(void* p0, struct S_FPD p1, struct S_FPD p2) ;
+EXPORT void* f16_P_PSS_FPP(void* p0, struct S_FPP p1, struct S_FPP p2) ;
+EXPORT void* f16_P_PSS_DII(void* p0, struct S_DII p1, struct S_DII p2) ;
+EXPORT void* f16_P_PSS_DIF(void* p0, struct S_DIF p1, struct S_DIF p2) ;
+EXPORT void* f16_P_PSS_DID(void* p0, struct S_DID p1, struct S_DID p2) ;
+EXPORT void* f16_P_PSS_DIP(void* p0, struct S_DIP p1, struct S_DIP p2) ;
+EXPORT void* f16_P_PSS_DFI(void* p0, struct S_DFI p1, struct S_DFI p2) ;
+EXPORT void* f16_P_PSS_DFF(void* p0, struct S_DFF p1, struct S_DFF p2) ;
+EXPORT void* f16_P_PSS_DFD(void* p0, struct S_DFD p1, struct S_DFD p2) ;
+EXPORT void* f16_P_PSS_DFP(void* p0, struct S_DFP p1, struct S_DFP p2) ;
+EXPORT void* f16_P_PSS_DDI(void* p0, struct S_DDI p1, struct S_DDI p2) ;
+EXPORT void* f16_P_PSS_DDF(void* p0, struct S_DDF p1, struct S_DDF p2) ;
+EXPORT void* f16_P_PSS_DDD(void* p0, struct S_DDD p1, struct S_DDD p2) ;
+EXPORT void* f16_P_PSS_DDP(void* p0, struct S_DDP p1, struct S_DDP p2) ;
+EXPORT void* f16_P_PSS_DPI(void* p0, struct S_DPI p1, struct S_DPI p2) ;
+EXPORT void* f16_P_PSS_DPF(void* p0, struct S_DPF p1, struct S_DPF p2) ;
+EXPORT void* f16_P_PSS_DPD(void* p0, struct S_DPD p1, struct S_DPD p2) ;
+EXPORT void* f16_P_PSS_DPP(void* p0, struct S_DPP p1, struct S_DPP p2) ;
+EXPORT void* f16_P_PSS_PII(void* p0, struct S_PII p1, struct S_PII p2) ;
+EXPORT void* f16_P_PSS_PIF(void* p0, struct S_PIF p1, struct S_PIF p2) ;
+EXPORT void* f16_P_PSS_PID(void* p0, struct S_PID p1, struct S_PID p2) ;
+EXPORT void* f16_P_PSS_PIP(void* p0, struct S_PIP p1, struct S_PIP p2) ;
+EXPORT void* f16_P_PSS_PFI(void* p0, struct S_PFI p1, struct S_PFI p2) ;
+EXPORT void* f16_P_PSS_PFF(void* p0, struct S_PFF p1, struct S_PFF p2) ;
+EXPORT void* f16_P_PSS_PFD(void* p0, struct S_PFD p1, struct S_PFD p2) ;
+EXPORT void* f16_P_PSS_PFP(void* p0, struct S_PFP p1, struct S_PFP p2) ;
+EXPORT void* f16_P_PSS_PDI(void* p0, struct S_PDI p1, struct S_PDI p2) ;
+EXPORT void* f16_P_PSS_PDF(void* p0, struct S_PDF p1, struct S_PDF p2) ;
+EXPORT void* f16_P_PSS_PDD(void* p0, struct S_PDD p1, struct S_PDD p2) ;
+EXPORT void* f16_P_PSS_PDP(void* p0, struct S_PDP p1, struct S_PDP p2) ;
+EXPORT void* f16_P_PSS_PPI(void* p0, struct S_PPI p1, struct S_PPI p2) ;
+EXPORT void* f16_P_PSS_PPF(void* p0, struct S_PPF p1, struct S_PPF p2) ;
+EXPORT void* f16_P_PSS_PPD(void* p0, struct S_PPD p1, struct S_PPD p2) ;
+EXPORT void* f16_P_PSS_PPP(void* p0, struct S_PPP p1, struct S_PPP p2) ;
+EXPORT struct S_I f16_S_SII_I(struct S_I p0, int p1, int p2) ;
+EXPORT struct S_F f16_S_SII_F(struct S_F p0, int p1, int p2) ;
+EXPORT struct S_D f16_S_SII_D(struct S_D p0, int p1, int p2) ;
+EXPORT struct S_P f16_S_SII_P(struct S_P p0, int p1, int p2) ;
+EXPORT struct S_II f16_S_SII_II(struct S_II p0, int p1, int p2) ;
+EXPORT struct S_IF f16_S_SII_IF(struct S_IF p0, int p1, int p2) ;
+EXPORT struct S_ID f16_S_SII_ID(struct S_ID p0, int p1, int p2) ;
+EXPORT struct S_IP f16_S_SII_IP(struct S_IP p0, int p1, int p2) ;
+EXPORT struct S_FI f16_S_SII_FI(struct S_FI p0, int p1, int p2) ;
+EXPORT struct S_FF f16_S_SII_FF(struct S_FF p0, int p1, int p2) ;
+EXPORT struct S_FD f16_S_SII_FD(struct S_FD p0, int p1, int p2) ;
+EXPORT struct S_FP f16_S_SII_FP(struct S_FP p0, int p1, int p2) ;
+EXPORT struct S_DI f16_S_SII_DI(struct S_DI p0, int p1, int p2) ;
+EXPORT struct S_DF f16_S_SII_DF(struct S_DF p0, int p1, int p2) ;
+EXPORT struct S_DD f16_S_SII_DD(struct S_DD p0, int p1, int p2) ;
+EXPORT struct S_DP f16_S_SII_DP(struct S_DP p0, int p1, int p2) ;
+EXPORT struct S_PI f16_S_SII_PI(struct S_PI p0, int p1, int p2) ;
+EXPORT struct S_PF f16_S_SII_PF(struct S_PF p0, int p1, int p2) ;
+EXPORT struct S_PD f16_S_SII_PD(struct S_PD p0, int p1, int p2) ;
+EXPORT struct S_PP f16_S_SII_PP(struct S_PP p0, int p1, int p2) ;
+EXPORT struct S_III f16_S_SII_III(struct S_III p0, int p1, int p2) ;
+EXPORT struct S_IIF f16_S_SII_IIF(struct S_IIF p0, int p1, int p2) ;
+EXPORT struct S_IID f16_S_SII_IID(struct S_IID p0, int p1, int p2) ;
+EXPORT struct S_IIP f16_S_SII_IIP(struct S_IIP p0, int p1, int p2) ;
+EXPORT struct S_IFI f16_S_SII_IFI(struct S_IFI p0, int p1, int p2) ;
+EXPORT struct S_IFF f16_S_SII_IFF(struct S_IFF p0, int p1, int p2) ;
+EXPORT struct S_IFD f16_S_SII_IFD(struct S_IFD p0, int p1, int p2) ;
+EXPORT struct S_IFP f16_S_SII_IFP(struct S_IFP p0, int p1, int p2) ;
+EXPORT struct S_IDI f16_S_SII_IDI(struct S_IDI p0, int p1, int p2) ;
+EXPORT struct S_IDF f16_S_SII_IDF(struct S_IDF p0, int p1, int p2) ;
+EXPORT struct S_IDD f16_S_SII_IDD(struct S_IDD p0, int p1, int p2) ;
+EXPORT struct S_IDP f16_S_SII_IDP(struct S_IDP p0, int p1, int p2) ;
+EXPORT struct S_IPI f16_S_SII_IPI(struct S_IPI p0, int p1, int p2) ;
+EXPORT struct S_IPF f16_S_SII_IPF(struct S_IPF p0, int p1, int p2) ;
+EXPORT struct S_IPD f16_S_SII_IPD(struct S_IPD p0, int p1, int p2) ;
+EXPORT struct S_IPP f16_S_SII_IPP(struct S_IPP p0, int p1, int p2) ;
+EXPORT struct S_FII f16_S_SII_FII(struct S_FII p0, int p1, int p2) ;
+EXPORT struct S_FIF f16_S_SII_FIF(struct S_FIF p0, int p1, int p2) ;
+EXPORT struct S_FID f16_S_SII_FID(struct S_FID p0, int p1, int p2) ;
+EXPORT struct S_FIP f16_S_SII_FIP(struct S_FIP p0, int p1, int p2) ;
+EXPORT struct S_FFI f16_S_SII_FFI(struct S_FFI p0, int p1, int p2) ;
+EXPORT struct S_FFF f16_S_SII_FFF(struct S_FFF p0, int p1, int p2) ;
+EXPORT struct S_FFD f16_S_SII_FFD(struct S_FFD p0, int p1, int p2) ;
+EXPORT struct S_FFP f16_S_SII_FFP(struct S_FFP p0, int p1, int p2) ;
+EXPORT struct S_FDI f16_S_SII_FDI(struct S_FDI p0, int p1, int p2) ;
+EXPORT struct S_FDF f16_S_SII_FDF(struct S_FDF p0, int p1, int p2) ;
+EXPORT struct S_FDD f16_S_SII_FDD(struct S_FDD p0, int p1, int p2) ;
+EXPORT struct S_FDP f16_S_SII_FDP(struct S_FDP p0, int p1, int p2) ;
+EXPORT struct S_FPI f16_S_SII_FPI(struct S_FPI p0, int p1, int p2) ;
+EXPORT struct S_FPF f16_S_SII_FPF(struct S_FPF p0, int p1, int p2) ;
+EXPORT struct S_FPD f16_S_SII_FPD(struct S_FPD p0, int p1, int p2) ;
+EXPORT struct S_FPP f16_S_SII_FPP(struct S_FPP p0, int p1, int p2) ;
+EXPORT struct S_DII f16_S_SII_DII(struct S_DII p0, int p1, int p2) ;
+EXPORT struct S_DIF f16_S_SII_DIF(struct S_DIF p0, int p1, int p2) ;
+EXPORT struct S_DID f16_S_SII_DID(struct S_DID p0, int p1, int p2) ;
+EXPORT struct S_DIP f16_S_SII_DIP(struct S_DIP p0, int p1, int p2) ;
+EXPORT struct S_DFI f16_S_SII_DFI(struct S_DFI p0, int p1, int p2) ;
+EXPORT struct S_DFF f16_S_SII_DFF(struct S_DFF p0, int p1, int p2) ;
+EXPORT struct S_DFD f16_S_SII_DFD(struct S_DFD p0, int p1, int p2) ;
+EXPORT struct S_DFP f16_S_SII_DFP(struct S_DFP p0, int p1, int p2) ;
+EXPORT struct S_DDI f16_S_SII_DDI(struct S_DDI p0, int p1, int p2) ;
+EXPORT struct S_DDF f16_S_SII_DDF(struct S_DDF p0, int p1, int p2) ;
+EXPORT struct S_DDD f16_S_SII_DDD(struct S_DDD p0, int p1, int p2) ;
+EXPORT struct S_DDP f16_S_SII_DDP(struct S_DDP p0, int p1, int p2) ;
+EXPORT struct S_DPI f16_S_SII_DPI(struct S_DPI p0, int p1, int p2) ;
+EXPORT struct S_DPF f16_S_SII_DPF(struct S_DPF p0, int p1, int p2) ;
+EXPORT struct S_DPD f16_S_SII_DPD(struct S_DPD p0, int p1, int p2) ;
+EXPORT struct S_DPP f16_S_SII_DPP(struct S_DPP p0, int p1, int p2) ;
+EXPORT struct S_PII f16_S_SII_PII(struct S_PII p0, int p1, int p2) ;
+EXPORT struct S_PIF f16_S_SII_PIF(struct S_PIF p0, int p1, int p2) ;
+EXPORT struct S_PID f16_S_SII_PID(struct S_PID p0, int p1, int p2) ;
+EXPORT struct S_PIP f16_S_SII_PIP(struct S_PIP p0, int p1, int p2) ;
+EXPORT struct S_PFI f16_S_SII_PFI(struct S_PFI p0, int p1, int p2) ;
+EXPORT struct S_PFF f16_S_SII_PFF(struct S_PFF p0, int p1, int p2) ;
+EXPORT struct S_PFD f16_S_SII_PFD(struct S_PFD p0, int p1, int p2) ;
+EXPORT struct S_PFP f16_S_SII_PFP(struct S_PFP p0, int p1, int p2) ;
+EXPORT struct S_PDI f16_S_SII_PDI(struct S_PDI p0, int p1, int p2) ;
+EXPORT struct S_PDF f16_S_SII_PDF(struct S_PDF p0, int p1, int p2) ;
+EXPORT struct S_PDD f16_S_SII_PDD(struct S_PDD p0, int p1, int p2) ;
+EXPORT struct S_PDP f16_S_SII_PDP(struct S_PDP p0, int p1, int p2) ;
+EXPORT struct S_PPI f16_S_SII_PPI(struct S_PPI p0, int p1, int p2) ;
+EXPORT struct S_PPF f16_S_SII_PPF(struct S_PPF p0, int p1, int p2) ;
+EXPORT struct S_PPD f16_S_SII_PPD(struct S_PPD p0, int p1, int p2) ;
+EXPORT struct S_PPP f16_S_SII_PPP(struct S_PPP p0, int p1, int p2) ;
+EXPORT struct S_I f16_S_SIF_I(struct S_I p0, int p1, float p2) ;
+EXPORT struct S_F f16_S_SIF_F(struct S_F p0, int p1, float p2) ;
+EXPORT struct S_D f16_S_SIF_D(struct S_D p0, int p1, float p2) ;
+EXPORT struct S_P f16_S_SIF_P(struct S_P p0, int p1, float p2) ;
+EXPORT struct S_II f16_S_SIF_II(struct S_II p0, int p1, float p2) ;
+EXPORT struct S_IF f16_S_SIF_IF(struct S_IF p0, int p1, float p2) ;
+EXPORT struct S_ID f16_S_SIF_ID(struct S_ID p0, int p1, float p2) ;
+EXPORT struct S_IP f16_S_SIF_IP(struct S_IP p0, int p1, float p2) ;
+EXPORT struct S_FI f16_S_SIF_FI(struct S_FI p0, int p1, float p2) ;
+EXPORT struct S_FF f16_S_SIF_FF(struct S_FF p0, int p1, float p2) ;
+EXPORT struct S_FD f16_S_SIF_FD(struct S_FD p0, int p1, float p2) ;
+EXPORT struct S_FP f16_S_SIF_FP(struct S_FP p0, int p1, float p2) ;
+EXPORT struct S_DI f16_S_SIF_DI(struct S_DI p0, int p1, float p2) ;
+EXPORT struct S_DF f16_S_SIF_DF(struct S_DF p0, int p1, float p2) ;
+EXPORT struct S_DD f16_S_SIF_DD(struct S_DD p0, int p1, float p2) ;
+EXPORT struct S_DP f16_S_SIF_DP(struct S_DP p0, int p1, float p2) ;
+EXPORT struct S_PI f16_S_SIF_PI(struct S_PI p0, int p1, float p2) ;
+EXPORT struct S_PF f16_S_SIF_PF(struct S_PF p0, int p1, float p2) ;
+EXPORT struct S_PD f16_S_SIF_PD(struct S_PD p0, int p1, float p2) ;
+EXPORT struct S_PP f16_S_SIF_PP(struct S_PP p0, int p1, float p2) ;
+EXPORT struct S_III f16_S_SIF_III(struct S_III p0, int p1, float p2) ;
+EXPORT struct S_IIF f16_S_SIF_IIF(struct S_IIF p0, int p1, float p2) ;
+EXPORT struct S_IID f16_S_SIF_IID(struct S_IID p0, int p1, float p2) ;
+EXPORT struct S_IIP f16_S_SIF_IIP(struct S_IIP p0, int p1, float p2) ;
+EXPORT struct S_IFI f16_S_SIF_IFI(struct S_IFI p0, int p1, float p2) ;
+EXPORT struct S_IFF f16_S_SIF_IFF(struct S_IFF p0, int p1, float p2) ;
+EXPORT struct S_IFD f16_S_SIF_IFD(struct S_IFD p0, int p1, float p2) ;
+EXPORT struct S_IFP f16_S_SIF_IFP(struct S_IFP p0, int p1, float p2) ;
+EXPORT struct S_IDI f16_S_SIF_IDI(struct S_IDI p0, int p1, float p2) ;
+EXPORT struct S_IDF f16_S_SIF_IDF(struct S_IDF p0, int p1, float p2) ;
+EXPORT struct S_IDD f16_S_SIF_IDD(struct S_IDD p0, int p1, float p2) ;
+EXPORT struct S_IDP f16_S_SIF_IDP(struct S_IDP p0, int p1, float p2) ;
+EXPORT struct S_IPI f16_S_SIF_IPI(struct S_IPI p0, int p1, float p2) ;
+EXPORT struct S_IPF f16_S_SIF_IPF(struct S_IPF p0, int p1, float p2) ;
+EXPORT struct S_IPD f16_S_SIF_IPD(struct S_IPD p0, int p1, float p2) ;
+EXPORT struct S_IPP f16_S_SIF_IPP(struct S_IPP p0, int p1, float p2) ;
+EXPORT struct S_FII f16_S_SIF_FII(struct S_FII p0, int p1, float p2) ;
+EXPORT struct S_FIF f16_S_SIF_FIF(struct S_FIF p0, int p1, float p2) ;
+EXPORT struct S_FID f16_S_SIF_FID(struct S_FID p0, int p1, float p2) ;
+EXPORT struct S_FIP f16_S_SIF_FIP(struct S_FIP p0, int p1, float p2) ;
+EXPORT struct S_FFI f16_S_SIF_FFI(struct S_FFI p0, int p1, float p2) ;
+EXPORT struct S_FFF f16_S_SIF_FFF(struct S_FFF p0, int p1, float p2) ;
+EXPORT struct S_FFD f16_S_SIF_FFD(struct S_FFD p0, int p1, float p2) ;
+EXPORT struct S_FFP f16_S_SIF_FFP(struct S_FFP p0, int p1, float p2) ;
+EXPORT struct S_FDI f16_S_SIF_FDI(struct S_FDI p0, int p1, float p2) ;
+EXPORT struct S_FDF f16_S_SIF_FDF(struct S_FDF p0, int p1, float p2) ;
+EXPORT struct S_FDD f16_S_SIF_FDD(struct S_FDD p0, int p1, float p2) ;
+EXPORT struct S_FDP f16_S_SIF_FDP(struct S_FDP p0, int p1, float p2) ;
+EXPORT struct S_FPI f16_S_SIF_FPI(struct S_FPI p0, int p1, float p2) ;
+EXPORT struct S_FPF f16_S_SIF_FPF(struct S_FPF p0, int p1, float p2) ;
+EXPORT struct S_FPD f16_S_SIF_FPD(struct S_FPD p0, int p1, float p2) ;
+EXPORT struct S_FPP f16_S_SIF_FPP(struct S_FPP p0, int p1, float p2) ;
+EXPORT struct S_DII f16_S_SIF_DII(struct S_DII p0, int p1, float p2) ;
+EXPORT struct S_DIF f16_S_SIF_DIF(struct S_DIF p0, int p1, float p2) ;
+EXPORT struct S_DID f16_S_SIF_DID(struct S_DID p0, int p1, float p2) ;
+EXPORT struct S_DIP f16_S_SIF_DIP(struct S_DIP p0, int p1, float p2) ;
+EXPORT struct S_DFI f16_S_SIF_DFI(struct S_DFI p0, int p1, float p2) ;
+EXPORT struct S_DFF f16_S_SIF_DFF(struct S_DFF p0, int p1, float p2) ;
+EXPORT struct S_DFD f16_S_SIF_DFD(struct S_DFD p0, int p1, float p2) ;
+EXPORT struct S_DFP f16_S_SIF_DFP(struct S_DFP p0, int p1, float p2) ;
+EXPORT struct S_DDI f16_S_SIF_DDI(struct S_DDI p0, int p1, float p2) ;
+EXPORT struct S_DDF f16_S_SIF_DDF(struct S_DDF p0, int p1, float p2) ;
+EXPORT struct S_DDD f16_S_SIF_DDD(struct S_DDD p0, int p1, float p2) ;
+EXPORT struct S_DDP f16_S_SIF_DDP(struct S_DDP p0, int p1, float p2) ;
+EXPORT struct S_DPI f16_S_SIF_DPI(struct S_DPI p0, int p1, float p2) ;
+EXPORT struct S_DPF f16_S_SIF_DPF(struct S_DPF p0, int p1, float p2) ;
+EXPORT struct S_DPD f16_S_SIF_DPD(struct S_DPD p0, int p1, float p2) ;
+EXPORT struct S_DPP f16_S_SIF_DPP(struct S_DPP p0, int p1, float p2) ;
+EXPORT struct S_PII f16_S_SIF_PII(struct S_PII p0, int p1, float p2) ;
+EXPORT struct S_PIF f16_S_SIF_PIF(struct S_PIF p0, int p1, float p2) ;
+EXPORT struct S_PID f16_S_SIF_PID(struct S_PID p0, int p1, float p2) ;
+EXPORT struct S_PIP f16_S_SIF_PIP(struct S_PIP p0, int p1, float p2) ;
+EXPORT struct S_PFI f16_S_SIF_PFI(struct S_PFI p0, int p1, float p2) ;
+EXPORT struct S_PFF f16_S_SIF_PFF(struct S_PFF p0, int p1, float p2) ;
+EXPORT struct S_PFD f16_S_SIF_PFD(struct S_PFD p0, int p1, float p2) ;
+EXPORT struct S_PFP f16_S_SIF_PFP(struct S_PFP p0, int p1, float p2) ;
+EXPORT struct S_PDI f16_S_SIF_PDI(struct S_PDI p0, int p1, float p2) ;
+EXPORT struct S_PDF f16_S_SIF_PDF(struct S_PDF p0, int p1, float p2) ;
+EXPORT struct S_PDD f16_S_SIF_PDD(struct S_PDD p0, int p1, float p2) ;
+EXPORT struct S_PDP f16_S_SIF_PDP(struct S_PDP p0, int p1, float p2) ;
+EXPORT struct S_PPI f16_S_SIF_PPI(struct S_PPI p0, int p1, float p2) ;
+EXPORT struct S_PPF f16_S_SIF_PPF(struct S_PPF p0, int p1, float p2) ;
+EXPORT struct S_PPD f16_S_SIF_PPD(struct S_PPD p0, int p1, float p2) ;
+EXPORT struct S_PPP f16_S_SIF_PPP(struct S_PPP p0, int p1, float p2) ;
+EXPORT struct S_I f16_S_SID_I(struct S_I p0, int p1, double p2) ;
+EXPORT struct S_F f16_S_SID_F(struct S_F p0, int p1, double p2) ;
+EXPORT struct S_D f16_S_SID_D(struct S_D p0, int p1, double p2) ;
+EXPORT struct S_P f16_S_SID_P(struct S_P p0, int p1, double p2) ;
+EXPORT struct S_II f16_S_SID_II(struct S_II p0, int p1, double p2) ;
+EXPORT struct S_IF f16_S_SID_IF(struct S_IF p0, int p1, double p2) ;
+EXPORT struct S_ID f16_S_SID_ID(struct S_ID p0, int p1, double p2) ;
+EXPORT struct S_IP f16_S_SID_IP(struct S_IP p0, int p1, double p2) ;
+EXPORT struct S_FI f16_S_SID_FI(struct S_FI p0, int p1, double p2) ;
+EXPORT struct S_FF f16_S_SID_FF(struct S_FF p0, int p1, double p2) ;
+EXPORT struct S_FD f16_S_SID_FD(struct S_FD p0, int p1, double p2) ;
+EXPORT struct S_FP f16_S_SID_FP(struct S_FP p0, int p1, double p2) ;
+EXPORT struct S_DI f16_S_SID_DI(struct S_DI p0, int p1, double p2) ;
+EXPORT struct S_DF f16_S_SID_DF(struct S_DF p0, int p1, double p2) ;
+EXPORT struct S_DD f16_S_SID_DD(struct S_DD p0, int p1, double p2) ;
+EXPORT struct S_DP f16_S_SID_DP(struct S_DP p0, int p1, double p2) ;
+EXPORT struct S_PI f16_S_SID_PI(struct S_PI p0, int p1, double p2) ;
+EXPORT struct S_PF f16_S_SID_PF(struct S_PF p0, int p1, double p2) ;
+EXPORT struct S_PD f16_S_SID_PD(struct S_PD p0, int p1, double p2) ;
+EXPORT struct S_PP f16_S_SID_PP(struct S_PP p0, int p1, double p2) ;
+EXPORT struct S_III f16_S_SID_III(struct S_III p0, int p1, double p2) ;
+EXPORT struct S_IIF f16_S_SID_IIF(struct S_IIF p0, int p1, double p2) ;
+EXPORT struct S_IID f16_S_SID_IID(struct S_IID p0, int p1, double p2) ;
+EXPORT struct S_IIP f16_S_SID_IIP(struct S_IIP p0, int p1, double p2) ;
+EXPORT struct S_IFI f16_S_SID_IFI(struct S_IFI p0, int p1, double p2) ;
+EXPORT struct S_IFF f16_S_SID_IFF(struct S_IFF p0, int p1, double p2) ;
+EXPORT struct S_IFD f16_S_SID_IFD(struct S_IFD p0, int p1, double p2) ;
+EXPORT struct S_IFP f16_S_SID_IFP(struct S_IFP p0, int p1, double p2) ;
+EXPORT struct S_IDI f16_S_SID_IDI(struct S_IDI p0, int p1, double p2) ;
+EXPORT struct S_IDF f16_S_SID_IDF(struct S_IDF p0, int p1, double p2) ;
+EXPORT struct S_IDD f16_S_SID_IDD(struct S_IDD p0, int p1, double p2) ;
+EXPORT struct S_IDP f16_S_SID_IDP(struct S_IDP p0, int p1, double p2) ;
+EXPORT struct S_IPI f16_S_SID_IPI(struct S_IPI p0, int p1, double p2) ;
+EXPORT struct S_IPF f16_S_SID_IPF(struct S_IPF p0, int p1, double p2) ;
+EXPORT struct S_IPD f16_S_SID_IPD(struct S_IPD p0, int p1, double p2) ;
+EXPORT struct S_IPP f17_S_SID_IPP(struct S_IPP p0, int p1, double p2) ;
+EXPORT struct S_FII f17_S_SID_FII(struct S_FII p0, int p1, double p2) ;
+EXPORT struct S_FIF f17_S_SID_FIF(struct S_FIF p0, int p1, double p2) ;
+EXPORT struct S_FID f17_S_SID_FID(struct S_FID p0, int p1, double p2) ;
+EXPORT struct S_FIP f17_S_SID_FIP(struct S_FIP p0, int p1, double p2) ;
+EXPORT struct S_FFI f17_S_SID_FFI(struct S_FFI p0, int p1, double p2) ;
+EXPORT struct S_FFF f17_S_SID_FFF(struct S_FFF p0, int p1, double p2) ;
+EXPORT struct S_FFD f17_S_SID_FFD(struct S_FFD p0, int p1, double p2) ;
+EXPORT struct S_FFP f17_S_SID_FFP(struct S_FFP p0, int p1, double p2) ;
+EXPORT struct S_FDI f17_S_SID_FDI(struct S_FDI p0, int p1, double p2) ;
+EXPORT struct S_FDF f17_S_SID_FDF(struct S_FDF p0, int p1, double p2) ;
+EXPORT struct S_FDD f17_S_SID_FDD(struct S_FDD p0, int p1, double p2) ;
+EXPORT struct S_FDP f17_S_SID_FDP(struct S_FDP p0, int p1, double p2) ;
+EXPORT struct S_FPI f17_S_SID_FPI(struct S_FPI p0, int p1, double p2) ;
+EXPORT struct S_FPF f17_S_SID_FPF(struct S_FPF p0, int p1, double p2) ;
+EXPORT struct S_FPD f17_S_SID_FPD(struct S_FPD p0, int p1, double p2) ;
+EXPORT struct S_FPP f17_S_SID_FPP(struct S_FPP p0, int p1, double p2) ;
+EXPORT struct S_DII f17_S_SID_DII(struct S_DII p0, int p1, double p2) ;
+EXPORT struct S_DIF f17_S_SID_DIF(struct S_DIF p0, int p1, double p2) ;
+EXPORT struct S_DID f17_S_SID_DID(struct S_DID p0, int p1, double p2) ;
+EXPORT struct S_DIP f17_S_SID_DIP(struct S_DIP p0, int p1, double p2) ;
+EXPORT struct S_DFI f17_S_SID_DFI(struct S_DFI p0, int p1, double p2) ;
+EXPORT struct S_DFF f17_S_SID_DFF(struct S_DFF p0, int p1, double p2) ;
+EXPORT struct S_DFD f17_S_SID_DFD(struct S_DFD p0, int p1, double p2) ;
+EXPORT struct S_DFP f17_S_SID_DFP(struct S_DFP p0, int p1, double p2) ;
+EXPORT struct S_DDI f17_S_SID_DDI(struct S_DDI p0, int p1, double p2) ;
+EXPORT struct S_DDF f17_S_SID_DDF(struct S_DDF p0, int p1, double p2) ;
+EXPORT struct S_DDD f17_S_SID_DDD(struct S_DDD p0, int p1, double p2) ;
+EXPORT struct S_DDP f17_S_SID_DDP(struct S_DDP p0, int p1, double p2) ;
+EXPORT struct S_DPI f17_S_SID_DPI(struct S_DPI p0, int p1, double p2) ;
+EXPORT struct S_DPF f17_S_SID_DPF(struct S_DPF p0, int p1, double p2) ;
+EXPORT struct S_DPD f17_S_SID_DPD(struct S_DPD p0, int p1, double p2) ;
+EXPORT struct S_DPP f17_S_SID_DPP(struct S_DPP p0, int p1, double p2) ;
+EXPORT struct S_PII f17_S_SID_PII(struct S_PII p0, int p1, double p2) ;
+EXPORT struct S_PIF f17_S_SID_PIF(struct S_PIF p0, int p1, double p2) ;
+EXPORT struct S_PID f17_S_SID_PID(struct S_PID p0, int p1, double p2) ;
+EXPORT struct S_PIP f17_S_SID_PIP(struct S_PIP p0, int p1, double p2) ;
+EXPORT struct S_PFI f17_S_SID_PFI(struct S_PFI p0, int p1, double p2) ;
+EXPORT struct S_PFF f17_S_SID_PFF(struct S_PFF p0, int p1, double p2) ;
+EXPORT struct S_PFD f17_S_SID_PFD(struct S_PFD p0, int p1, double p2) ;
+EXPORT struct S_PFP f17_S_SID_PFP(struct S_PFP p0, int p1, double p2) ;
+EXPORT struct S_PDI f17_S_SID_PDI(struct S_PDI p0, int p1, double p2) ;
+EXPORT struct S_PDF f17_S_SID_PDF(struct S_PDF p0, int p1, double p2) ;
+EXPORT struct S_PDD f17_S_SID_PDD(struct S_PDD p0, int p1, double p2) ;
+EXPORT struct S_PDP f17_S_SID_PDP(struct S_PDP p0, int p1, double p2) ;
+EXPORT struct S_PPI f17_S_SID_PPI(struct S_PPI p0, int p1, double p2) ;
+EXPORT struct S_PPF f17_S_SID_PPF(struct S_PPF p0, int p1, double p2) ;
+EXPORT struct S_PPD f17_S_SID_PPD(struct S_PPD p0, int p1, double p2) ;
+EXPORT struct S_PPP f17_S_SID_PPP(struct S_PPP p0, int p1, double p2) ;
+EXPORT struct S_I f17_S_SIP_I(struct S_I p0, int p1, void* p2) ;
+EXPORT struct S_F f17_S_SIP_F(struct S_F p0, int p1, void* p2) ;
+EXPORT struct S_D f17_S_SIP_D(struct S_D p0, int p1, void* p2) ;
+EXPORT struct S_P f17_S_SIP_P(struct S_P p0, int p1, void* p2) ;
+EXPORT struct S_II f17_S_SIP_II(struct S_II p0, int p1, void* p2) ;
+EXPORT struct S_IF f17_S_SIP_IF(struct S_IF p0, int p1, void* p2) ;
+EXPORT struct S_ID f17_S_SIP_ID(struct S_ID p0, int p1, void* p2) ;
+EXPORT struct S_IP f17_S_SIP_IP(struct S_IP p0, int p1, void* p2) ;
+EXPORT struct S_FI f17_S_SIP_FI(struct S_FI p0, int p1, void* p2) ;
+EXPORT struct S_FF f17_S_SIP_FF(struct S_FF p0, int p1, void* p2) ;
+EXPORT struct S_FD f17_S_SIP_FD(struct S_FD p0, int p1, void* p2) ;
+EXPORT struct S_FP f17_S_SIP_FP(struct S_FP p0, int p1, void* p2) ;
+EXPORT struct S_DI f17_S_SIP_DI(struct S_DI p0, int p1, void* p2) ;
+EXPORT struct S_DF f17_S_SIP_DF(struct S_DF p0, int p1, void* p2) ;
+EXPORT struct S_DD f17_S_SIP_DD(struct S_DD p0, int p1, void* p2) ;
+EXPORT struct S_DP f17_S_SIP_DP(struct S_DP p0, int p1, void* p2) ;
+EXPORT struct S_PI f17_S_SIP_PI(struct S_PI p0, int p1, void* p2) ;
+EXPORT struct S_PF f17_S_SIP_PF(struct S_PF p0, int p1, void* p2) ;
+EXPORT struct S_PD f17_S_SIP_PD(struct S_PD p0, int p1, void* p2) ;
+EXPORT struct S_PP f17_S_SIP_PP(struct S_PP p0, int p1, void* p2) ;
+EXPORT struct S_III f17_S_SIP_III(struct S_III p0, int p1, void* p2) ;
+EXPORT struct S_IIF f17_S_SIP_IIF(struct S_IIF p0, int p1, void* p2) ;
+EXPORT struct S_IID f17_S_SIP_IID(struct S_IID p0, int p1, void* p2) ;
+EXPORT struct S_IIP f17_S_SIP_IIP(struct S_IIP p0, int p1, void* p2) ;
+EXPORT struct S_IFI f17_S_SIP_IFI(struct S_IFI p0, int p1, void* p2) ;
+EXPORT struct S_IFF f17_S_SIP_IFF(struct S_IFF p0, int p1, void* p2) ;
+EXPORT struct S_IFD f17_S_SIP_IFD(struct S_IFD p0, int p1, void* p2) ;
+EXPORT struct S_IFP f17_S_SIP_IFP(struct S_IFP p0, int p1, void* p2) ;
+EXPORT struct S_IDI f17_S_SIP_IDI(struct S_IDI p0, int p1, void* p2) ;
+EXPORT struct S_IDF f17_S_SIP_IDF(struct S_IDF p0, int p1, void* p2) ;
+EXPORT struct S_IDD f17_S_SIP_IDD(struct S_IDD p0, int p1, void* p2) ;
+EXPORT struct S_IDP f17_S_SIP_IDP(struct S_IDP p0, int p1, void* p2) ;
+EXPORT struct S_IPI f17_S_SIP_IPI(struct S_IPI p0, int p1, void* p2) ;
+EXPORT struct S_IPF f17_S_SIP_IPF(struct S_IPF p0, int p1, void* p2) ;
+EXPORT struct S_IPD f17_S_SIP_IPD(struct S_IPD p0, int p1, void* p2) ;
+EXPORT struct S_IPP f17_S_SIP_IPP(struct S_IPP p0, int p1, void* p2) ;
+EXPORT struct S_FII f17_S_SIP_FII(struct S_FII p0, int p1, void* p2) ;
+EXPORT struct S_FIF f17_S_SIP_FIF(struct S_FIF p0, int p1, void* p2) ;
+EXPORT struct S_FID f17_S_SIP_FID(struct S_FID p0, int p1, void* p2) ;
+EXPORT struct S_FIP f17_S_SIP_FIP(struct S_FIP p0, int p1, void* p2) ;
+EXPORT struct S_FFI f17_S_SIP_FFI(struct S_FFI p0, int p1, void* p2) ;
+EXPORT struct S_FFF f17_S_SIP_FFF(struct S_FFF p0, int p1, void* p2) ;
+EXPORT struct S_FFD f17_S_SIP_FFD(struct S_FFD p0, int p1, void* p2) ;
+EXPORT struct S_FFP f17_S_SIP_FFP(struct S_FFP p0, int p1, void* p2) ;
+EXPORT struct S_FDI f17_S_SIP_FDI(struct S_FDI p0, int p1, void* p2) ;
+EXPORT struct S_FDF f17_S_SIP_FDF(struct S_FDF p0, int p1, void* p2) ;
+EXPORT struct S_FDD f17_S_SIP_FDD(struct S_FDD p0, int p1, void* p2) ;
+EXPORT struct S_FDP f17_S_SIP_FDP(struct S_FDP p0, int p1, void* p2) ;
+EXPORT struct S_FPI f17_S_SIP_FPI(struct S_FPI p0, int p1, void* p2) ;
+EXPORT struct S_FPF f17_S_SIP_FPF(struct S_FPF p0, int p1, void* p2) ;
+EXPORT struct S_FPD f17_S_SIP_FPD(struct S_FPD p0, int p1, void* p2) ;
+EXPORT struct S_FPP f17_S_SIP_FPP(struct S_FPP p0, int p1, void* p2) ;
+EXPORT struct S_DII f17_S_SIP_DII(struct S_DII p0, int p1, void* p2) ;
+EXPORT struct S_DIF f17_S_SIP_DIF(struct S_DIF p0, int p1, void* p2) ;
+EXPORT struct S_DID f17_S_SIP_DID(struct S_DID p0, int p1, void* p2) ;
+EXPORT struct S_DIP f17_S_SIP_DIP(struct S_DIP p0, int p1, void* p2) ;
+EXPORT struct S_DFI f17_S_SIP_DFI(struct S_DFI p0, int p1, void* p2) ;
+EXPORT struct S_DFF f17_S_SIP_DFF(struct S_DFF p0, int p1, void* p2) ;
+EXPORT struct S_DFD f17_S_SIP_DFD(struct S_DFD p0, int p1, void* p2) ;
+EXPORT struct S_DFP f17_S_SIP_DFP(struct S_DFP p0, int p1, void* p2) ;
+EXPORT struct S_DDI f17_S_SIP_DDI(struct S_DDI p0, int p1, void* p2) ;
+EXPORT struct S_DDF f17_S_SIP_DDF(struct S_DDF p0, int p1, void* p2) ;
+EXPORT struct S_DDD f17_S_SIP_DDD(struct S_DDD p0, int p1, void* p2) ;
+EXPORT struct S_DDP f17_S_SIP_DDP(struct S_DDP p0, int p1, void* p2) ;
+EXPORT struct S_DPI f17_S_SIP_DPI(struct S_DPI p0, int p1, void* p2) ;
+EXPORT struct S_DPF f17_S_SIP_DPF(struct S_DPF p0, int p1, void* p2) ;
+EXPORT struct S_DPD f17_S_SIP_DPD(struct S_DPD p0, int p1, void* p2) ;
+EXPORT struct S_DPP f17_S_SIP_DPP(struct S_DPP p0, int p1, void* p2) ;
+EXPORT struct S_PII f17_S_SIP_PII(struct S_PII p0, int p1, void* p2) ;
+EXPORT struct S_PIF f17_S_SIP_PIF(struct S_PIF p0, int p1, void* p2) ;
+EXPORT struct S_PID f17_S_SIP_PID(struct S_PID p0, int p1, void* p2) ;
+EXPORT struct S_PIP f17_S_SIP_PIP(struct S_PIP p0, int p1, void* p2) ;
+EXPORT struct S_PFI f17_S_SIP_PFI(struct S_PFI p0, int p1, void* p2) ;
+EXPORT struct S_PFF f17_S_SIP_PFF(struct S_PFF p0, int p1, void* p2) ;
+EXPORT struct S_PFD f17_S_SIP_PFD(struct S_PFD p0, int p1, void* p2) ;
+EXPORT struct S_PFP f17_S_SIP_PFP(struct S_PFP p0, int p1, void* p2) ;
+EXPORT struct S_PDI f17_S_SIP_PDI(struct S_PDI p0, int p1, void* p2) ;
+EXPORT struct S_PDF f17_S_SIP_PDF(struct S_PDF p0, int p1, void* p2) ;
+EXPORT struct S_PDD f17_S_SIP_PDD(struct S_PDD p0, int p1, void* p2) ;
+EXPORT struct S_PDP f17_S_SIP_PDP(struct S_PDP p0, int p1, void* p2) ;
+EXPORT struct S_PPI f17_S_SIP_PPI(struct S_PPI p0, int p1, void* p2) ;
+EXPORT struct S_PPF f17_S_SIP_PPF(struct S_PPF p0, int p1, void* p2) ;
+EXPORT struct S_PPD f17_S_SIP_PPD(struct S_PPD p0, int p1, void* p2) ;
+EXPORT struct S_PPP f17_S_SIP_PPP(struct S_PPP p0, int p1, void* p2) ;
+EXPORT struct S_I f17_S_SIS_I(struct S_I p0, int p1, struct S_I p2) ;
+EXPORT struct S_F f17_S_SIS_F(struct S_F p0, int p1, struct S_F p2) ;
+EXPORT struct S_D f17_S_SIS_D(struct S_D p0, int p1, struct S_D p2) ;
+EXPORT struct S_P f17_S_SIS_P(struct S_P p0, int p1, struct S_P p2) ;
+EXPORT struct S_II f17_S_SIS_II(struct S_II p0, int p1, struct S_II p2) ;
+EXPORT struct S_IF f17_S_SIS_IF(struct S_IF p0, int p1, struct S_IF p2) ;
+EXPORT struct S_ID f17_S_SIS_ID(struct S_ID p0, int p1, struct S_ID p2) ;
+EXPORT struct S_IP f17_S_SIS_IP(struct S_IP p0, int p1, struct S_IP p2) ;
+EXPORT struct S_FI f17_S_SIS_FI(struct S_FI p0, int p1, struct S_FI p2) ;
+EXPORT struct S_FF f17_S_SIS_FF(struct S_FF p0, int p1, struct S_FF p2) ;
+EXPORT struct S_FD f17_S_SIS_FD(struct S_FD p0, int p1, struct S_FD p2) ;
+EXPORT struct S_FP f17_S_SIS_FP(struct S_FP p0, int p1, struct S_FP p2) ;
+EXPORT struct S_DI f17_S_SIS_DI(struct S_DI p0, int p1, struct S_DI p2) ;
+EXPORT struct S_DF f17_S_SIS_DF(struct S_DF p0, int p1, struct S_DF p2) ;
+EXPORT struct S_DD f17_S_SIS_DD(struct S_DD p0, int p1, struct S_DD p2) ;
+EXPORT struct S_DP f17_S_SIS_DP(struct S_DP p0, int p1, struct S_DP p2) ;
+EXPORT struct S_PI f17_S_SIS_PI(struct S_PI p0, int p1, struct S_PI p2) ;
+EXPORT struct S_PF f17_S_SIS_PF(struct S_PF p0, int p1, struct S_PF p2) ;
+EXPORT struct S_PD f17_S_SIS_PD(struct S_PD p0, int p1, struct S_PD p2) ;
+EXPORT struct S_PP f17_S_SIS_PP(struct S_PP p0, int p1, struct S_PP p2) ;
+EXPORT struct S_III f17_S_SIS_III(struct S_III p0, int p1, struct S_III p2) ;
+EXPORT struct S_IIF f17_S_SIS_IIF(struct S_IIF p0, int p1, struct S_IIF p2) ;
+EXPORT struct S_IID f17_S_SIS_IID(struct S_IID p0, int p1, struct S_IID p2) ;
+EXPORT struct S_IIP f17_S_SIS_IIP(struct S_IIP p0, int p1, struct S_IIP p2) ;
+EXPORT struct S_IFI f17_S_SIS_IFI(struct S_IFI p0, int p1, struct S_IFI p2) ;
+EXPORT struct S_IFF f17_S_SIS_IFF(struct S_IFF p0, int p1, struct S_IFF p2) ;
+EXPORT struct S_IFD f17_S_SIS_IFD(struct S_IFD p0, int p1, struct S_IFD p2) ;
+EXPORT struct S_IFP f17_S_SIS_IFP(struct S_IFP p0, int p1, struct S_IFP p2) ;
+EXPORT struct S_IDI f17_S_SIS_IDI(struct S_IDI p0, int p1, struct S_IDI p2) ;
+EXPORT struct S_IDF f17_S_SIS_IDF(struct S_IDF p0, int p1, struct S_IDF p2) ;
+EXPORT struct S_IDD f17_S_SIS_IDD(struct S_IDD p0, int p1, struct S_IDD p2) ;
+EXPORT struct S_IDP f17_S_SIS_IDP(struct S_IDP p0, int p1, struct S_IDP p2) ;
+EXPORT struct S_IPI f17_S_SIS_IPI(struct S_IPI p0, int p1, struct S_IPI p2) ;
+EXPORT struct S_IPF f17_S_SIS_IPF(struct S_IPF p0, int p1, struct S_IPF p2) ;
+EXPORT struct S_IPD f17_S_SIS_IPD(struct S_IPD p0, int p1, struct S_IPD p2) ;
+EXPORT struct S_IPP f17_S_SIS_IPP(struct S_IPP p0, int p1, struct S_IPP p2) ;
+EXPORT struct S_FII f17_S_SIS_FII(struct S_FII p0, int p1, struct S_FII p2) ;
+EXPORT struct S_FIF f17_S_SIS_FIF(struct S_FIF p0, int p1, struct S_FIF p2) ;
+EXPORT struct S_FID f17_S_SIS_FID(struct S_FID p0, int p1, struct S_FID p2) ;
+EXPORT struct S_FIP f17_S_SIS_FIP(struct S_FIP p0, int p1, struct S_FIP p2) ;
+EXPORT struct S_FFI f17_S_SIS_FFI(struct S_FFI p0, int p1, struct S_FFI p2) ;
+EXPORT struct S_FFF f17_S_SIS_FFF(struct S_FFF p0, int p1, struct S_FFF p2) ;
+EXPORT struct S_FFD f17_S_SIS_FFD(struct S_FFD p0, int p1, struct S_FFD p2) ;
+EXPORT struct S_FFP f17_S_SIS_FFP(struct S_FFP p0, int p1, struct S_FFP p2) ;
+EXPORT struct S_FDI f17_S_SIS_FDI(struct S_FDI p0, int p1, struct S_FDI p2) ;
+EXPORT struct S_FDF f17_S_SIS_FDF(struct S_FDF p0, int p1, struct S_FDF p2) ;
+EXPORT struct S_FDD f17_S_SIS_FDD(struct S_FDD p0, int p1, struct S_FDD p2) ;
+EXPORT struct S_FDP f17_S_SIS_FDP(struct S_FDP p0, int p1, struct S_FDP p2) ;
+EXPORT struct S_FPI f17_S_SIS_FPI(struct S_FPI p0, int p1, struct S_FPI p2) ;
+EXPORT struct S_FPF f17_S_SIS_FPF(struct S_FPF p0, int p1, struct S_FPF p2) ;
+EXPORT struct S_FPD f17_S_SIS_FPD(struct S_FPD p0, int p1, struct S_FPD p2) ;
+EXPORT struct S_FPP f17_S_SIS_FPP(struct S_FPP p0, int p1, struct S_FPP p2) ;
+EXPORT struct S_DII f17_S_SIS_DII(struct S_DII p0, int p1, struct S_DII p2) ;
+EXPORT struct S_DIF f17_S_SIS_DIF(struct S_DIF p0, int p1, struct S_DIF p2) ;
+EXPORT struct S_DID f17_S_SIS_DID(struct S_DID p0, int p1, struct S_DID p2) ;
+EXPORT struct S_DIP f17_S_SIS_DIP(struct S_DIP p0, int p1, struct S_DIP p2) ;
+EXPORT struct S_DFI f17_S_SIS_DFI(struct S_DFI p0, int p1, struct S_DFI p2) ;
+EXPORT struct S_DFF f17_S_SIS_DFF(struct S_DFF p0, int p1, struct S_DFF p2) ;
+EXPORT struct S_DFD f17_S_SIS_DFD(struct S_DFD p0, int p1, struct S_DFD p2) ;
+EXPORT struct S_DFP f17_S_SIS_DFP(struct S_DFP p0, int p1, struct S_DFP p2) ;
+EXPORT struct S_DDI f17_S_SIS_DDI(struct S_DDI p0, int p1, struct S_DDI p2) ;
+EXPORT struct S_DDF f17_S_SIS_DDF(struct S_DDF p0, int p1, struct S_DDF p2) ;
+EXPORT struct S_DDD f17_S_SIS_DDD(struct S_DDD p0, int p1, struct S_DDD p2) ;
+EXPORT struct S_DDP f17_S_SIS_DDP(struct S_DDP p0, int p1, struct S_DDP p2) ;
+EXPORT struct S_DPI f17_S_SIS_DPI(struct S_DPI p0, int p1, struct S_DPI p2) ;
+EXPORT struct S_DPF f17_S_SIS_DPF(struct S_DPF p0, int p1, struct S_DPF p2) ;
+EXPORT struct S_DPD f17_S_SIS_DPD(struct S_DPD p0, int p1, struct S_DPD p2) ;
+EXPORT struct S_DPP f17_S_SIS_DPP(struct S_DPP p0, int p1, struct S_DPP p2) ;
+EXPORT struct S_PII f17_S_SIS_PII(struct S_PII p0, int p1, struct S_PII p2) ;
+EXPORT struct S_PIF f17_S_SIS_PIF(struct S_PIF p0, int p1, struct S_PIF p2) ;
+EXPORT struct S_PID f17_S_SIS_PID(struct S_PID p0, int p1, struct S_PID p2) ;
+EXPORT struct S_PIP f17_S_SIS_PIP(struct S_PIP p0, int p1, struct S_PIP p2) ;
+EXPORT struct S_PFI f17_S_SIS_PFI(struct S_PFI p0, int p1, struct S_PFI p2) ;
+EXPORT struct S_PFF f17_S_SIS_PFF(struct S_PFF p0, int p1, struct S_PFF p2) ;
+EXPORT struct S_PFD f17_S_SIS_PFD(struct S_PFD p0, int p1, struct S_PFD p2) ;
+EXPORT struct S_PFP f17_S_SIS_PFP(struct S_PFP p0, int p1, struct S_PFP p2) ;
+EXPORT struct S_PDI f17_S_SIS_PDI(struct S_PDI p0, int p1, struct S_PDI p2) ;
+EXPORT struct S_PDF f17_S_SIS_PDF(struct S_PDF p0, int p1, struct S_PDF p2) ;
+EXPORT struct S_PDD f17_S_SIS_PDD(struct S_PDD p0, int p1, struct S_PDD p2) ;
+EXPORT struct S_PDP f17_S_SIS_PDP(struct S_PDP p0, int p1, struct S_PDP p2) ;
+EXPORT struct S_PPI f17_S_SIS_PPI(struct S_PPI p0, int p1, struct S_PPI p2) ;
+EXPORT struct S_PPF f17_S_SIS_PPF(struct S_PPF p0, int p1, struct S_PPF p2) ;
+EXPORT struct S_PPD f17_S_SIS_PPD(struct S_PPD p0, int p1, struct S_PPD p2) ;
+EXPORT struct S_PPP f17_S_SIS_PPP(struct S_PPP p0, int p1, struct S_PPP p2) ;
+EXPORT struct S_I f17_S_SFI_I(struct S_I p0, float p1, int p2) ;
+EXPORT struct S_F f17_S_SFI_F(struct S_F p0, float p1, int p2) ;
+EXPORT struct S_D f17_S_SFI_D(struct S_D p0, float p1, int p2) ;
+EXPORT struct S_P f17_S_SFI_P(struct S_P p0, float p1, int p2) ;
+EXPORT struct S_II f17_S_SFI_II(struct S_II p0, float p1, int p2) ;
+EXPORT struct S_IF f17_S_SFI_IF(struct S_IF p0, float p1, int p2) ;
+EXPORT struct S_ID f17_S_SFI_ID(struct S_ID p0, float p1, int p2) ;
+EXPORT struct S_IP f17_S_SFI_IP(struct S_IP p0, float p1, int p2) ;
+EXPORT struct S_FI f17_S_SFI_FI(struct S_FI p0, float p1, int p2) ;
+EXPORT struct S_FF f17_S_SFI_FF(struct S_FF p0, float p1, int p2) ;
+EXPORT struct S_FD f17_S_SFI_FD(struct S_FD p0, float p1, int p2) ;
+EXPORT struct S_FP f17_S_SFI_FP(struct S_FP p0, float p1, int p2) ;
+EXPORT struct S_DI f17_S_SFI_DI(struct S_DI p0, float p1, int p2) ;
+EXPORT struct S_DF f17_S_SFI_DF(struct S_DF p0, float p1, int p2) ;
+EXPORT struct S_DD f17_S_SFI_DD(struct S_DD p0, float p1, int p2) ;
+EXPORT struct S_DP f17_S_SFI_DP(struct S_DP p0, float p1, int p2) ;
+EXPORT struct S_PI f17_S_SFI_PI(struct S_PI p0, float p1, int p2) ;
+EXPORT struct S_PF f17_S_SFI_PF(struct S_PF p0, float p1, int p2) ;
+EXPORT struct S_PD f17_S_SFI_PD(struct S_PD p0, float p1, int p2) ;
+EXPORT struct S_PP f17_S_SFI_PP(struct S_PP p0, float p1, int p2) ;
+EXPORT struct S_III f17_S_SFI_III(struct S_III p0, float p1, int p2) ;
+EXPORT struct S_IIF f17_S_SFI_IIF(struct S_IIF p0, float p1, int p2) ;
+EXPORT struct S_IID f17_S_SFI_IID(struct S_IID p0, float p1, int p2) ;
+EXPORT struct S_IIP f17_S_SFI_IIP(struct S_IIP p0, float p1, int p2) ;
+EXPORT struct S_IFI f17_S_SFI_IFI(struct S_IFI p0, float p1, int p2) ;
+EXPORT struct S_IFF f17_S_SFI_IFF(struct S_IFF p0, float p1, int p2) ;
+EXPORT struct S_IFD f17_S_SFI_IFD(struct S_IFD p0, float p1, int p2) ;
+EXPORT struct S_IFP f17_S_SFI_IFP(struct S_IFP p0, float p1, int p2) ;
+EXPORT struct S_IDI f17_S_SFI_IDI(struct S_IDI p0, float p1, int p2) ;
+EXPORT struct S_IDF f17_S_SFI_IDF(struct S_IDF p0, float p1, int p2) ;
+EXPORT struct S_IDD f17_S_SFI_IDD(struct S_IDD p0, float p1, int p2) ;
+EXPORT struct S_IDP f17_S_SFI_IDP(struct S_IDP p0, float p1, int p2) ;
+EXPORT struct S_IPI f17_S_SFI_IPI(struct S_IPI p0, float p1, int p2) ;
+EXPORT struct S_IPF f17_S_SFI_IPF(struct S_IPF p0, float p1, int p2) ;
+EXPORT struct S_IPD f17_S_SFI_IPD(struct S_IPD p0, float p1, int p2) ;
+EXPORT struct S_IPP f17_S_SFI_IPP(struct S_IPP p0, float p1, int p2) ;
+EXPORT struct S_FII f17_S_SFI_FII(struct S_FII p0, float p1, int p2) ;
+EXPORT struct S_FIF f17_S_SFI_FIF(struct S_FIF p0, float p1, int p2) ;
+EXPORT struct S_FID f17_S_SFI_FID(struct S_FID p0, float p1, int p2) ;
+EXPORT struct S_FIP f17_S_SFI_FIP(struct S_FIP p0, float p1, int p2) ;
+EXPORT struct S_FFI f17_S_SFI_FFI(struct S_FFI p0, float p1, int p2) ;
+EXPORT struct S_FFF f17_S_SFI_FFF(struct S_FFF p0, float p1, int p2) ;
+EXPORT struct S_FFD f17_S_SFI_FFD(struct S_FFD p0, float p1, int p2) ;
+EXPORT struct S_FFP f17_S_SFI_FFP(struct S_FFP p0, float p1, int p2) ;
+EXPORT struct S_FDI f17_S_SFI_FDI(struct S_FDI p0, float p1, int p2) ;
+EXPORT struct S_FDF f17_S_SFI_FDF(struct S_FDF p0, float p1, int p2) ;
+EXPORT struct S_FDD f17_S_SFI_FDD(struct S_FDD p0, float p1, int p2) ;
+EXPORT struct S_FDP f17_S_SFI_FDP(struct S_FDP p0, float p1, int p2) ;
+EXPORT struct S_FPI f17_S_SFI_FPI(struct S_FPI p0, float p1, int p2) ;
+EXPORT struct S_FPF f17_S_SFI_FPF(struct S_FPF p0, float p1, int p2) ;
+EXPORT struct S_FPD f17_S_SFI_FPD(struct S_FPD p0, float p1, int p2) ;
+EXPORT struct S_FPP f17_S_SFI_FPP(struct S_FPP p0, float p1, int p2) ;
+EXPORT struct S_DII f17_S_SFI_DII(struct S_DII p0, float p1, int p2) ;
+EXPORT struct S_DIF f17_S_SFI_DIF(struct S_DIF p0, float p1, int p2) ;
+EXPORT struct S_DID f17_S_SFI_DID(struct S_DID p0, float p1, int p2) ;
+EXPORT struct S_DIP f17_S_SFI_DIP(struct S_DIP p0, float p1, int p2) ;
+EXPORT struct S_DFI f17_S_SFI_DFI(struct S_DFI p0, float p1, int p2) ;
+EXPORT struct S_DFF f17_S_SFI_DFF(struct S_DFF p0, float p1, int p2) ;
+EXPORT struct S_DFD f17_S_SFI_DFD(struct S_DFD p0, float p1, int p2) ;
+EXPORT struct S_DFP f17_S_SFI_DFP(struct S_DFP p0, float p1, int p2) ;
+EXPORT struct S_DDI f17_S_SFI_DDI(struct S_DDI p0, float p1, int p2) ;
+EXPORT struct S_DDF f17_S_SFI_DDF(struct S_DDF p0, float p1, int p2) ;
+EXPORT struct S_DDD f17_S_SFI_DDD(struct S_DDD p0, float p1, int p2) ;
+EXPORT struct S_DDP f17_S_SFI_DDP(struct S_DDP p0, float p1, int p2) ;
+EXPORT struct S_DPI f17_S_SFI_DPI(struct S_DPI p0, float p1, int p2) ;
+EXPORT struct S_DPF f17_S_SFI_DPF(struct S_DPF p0, float p1, int p2) ;
+EXPORT struct S_DPD f17_S_SFI_DPD(struct S_DPD p0, float p1, int p2) ;
+EXPORT struct S_DPP f17_S_SFI_DPP(struct S_DPP p0, float p1, int p2) ;
+EXPORT struct S_PII f17_S_SFI_PII(struct S_PII p0, float p1, int p2) ;
+EXPORT struct S_PIF f17_S_SFI_PIF(struct S_PIF p0, float p1, int p2) ;
+EXPORT struct S_PID f17_S_SFI_PID(struct S_PID p0, float p1, int p2) ;
+EXPORT struct S_PIP f17_S_SFI_PIP(struct S_PIP p0, float p1, int p2) ;
+EXPORT struct S_PFI f17_S_SFI_PFI(struct S_PFI p0, float p1, int p2) ;
+EXPORT struct S_PFF f17_S_SFI_PFF(struct S_PFF p0, float p1, int p2) ;
+EXPORT struct S_PFD f17_S_SFI_PFD(struct S_PFD p0, float p1, int p2) ;
+EXPORT struct S_PFP f17_S_SFI_PFP(struct S_PFP p0, float p1, int p2) ;
+EXPORT struct S_PDI f17_S_SFI_PDI(struct S_PDI p0, float p1, int p2) ;
+EXPORT struct S_PDF f17_S_SFI_PDF(struct S_PDF p0, float p1, int p2) ;
+EXPORT struct S_PDD f17_S_SFI_PDD(struct S_PDD p0, float p1, int p2) ;
+EXPORT struct S_PDP f17_S_SFI_PDP(struct S_PDP p0, float p1, int p2) ;
+EXPORT struct S_PPI f17_S_SFI_PPI(struct S_PPI p0, float p1, int p2) ;
+EXPORT struct S_PPF f17_S_SFI_PPF(struct S_PPF p0, float p1, int p2) ;
+EXPORT struct S_PPD f17_S_SFI_PPD(struct S_PPD p0, float p1, int p2) ;
+EXPORT struct S_PPP f17_S_SFI_PPP(struct S_PPP p0, float p1, int p2) ;
+EXPORT struct S_I f17_S_SFF_I(struct S_I p0, float p1, float p2) ;
+EXPORT struct S_F f17_S_SFF_F(struct S_F p0, float p1, float p2) ;
+EXPORT struct S_D f17_S_SFF_D(struct S_D p0, float p1, float p2) ;
+EXPORT struct S_P f17_S_SFF_P(struct S_P p0, float p1, float p2) ;
+EXPORT struct S_II f17_S_SFF_II(struct S_II p0, float p1, float p2) ;
+EXPORT struct S_IF f17_S_SFF_IF(struct S_IF p0, float p1, float p2) ;
+EXPORT struct S_ID f17_S_SFF_ID(struct S_ID p0, float p1, float p2) ;
+EXPORT struct S_IP f17_S_SFF_IP(struct S_IP p0, float p1, float p2) ;
+EXPORT struct S_FI f17_S_SFF_FI(struct S_FI p0, float p1, float p2) ;
+EXPORT struct S_FF f17_S_SFF_FF(struct S_FF p0, float p1, float p2) ;
+EXPORT struct S_FD f17_S_SFF_FD(struct S_FD p0, float p1, float p2) ;
+EXPORT struct S_FP f17_S_SFF_FP(struct S_FP p0, float p1, float p2) ;
+EXPORT struct S_DI f17_S_SFF_DI(struct S_DI p0, float p1, float p2) ;
+EXPORT struct S_DF f17_S_SFF_DF(struct S_DF p0, float p1, float p2) ;
+EXPORT struct S_DD f17_S_SFF_DD(struct S_DD p0, float p1, float p2) ;
+EXPORT struct S_DP f17_S_SFF_DP(struct S_DP p0, float p1, float p2) ;
+EXPORT struct S_PI f17_S_SFF_PI(struct S_PI p0, float p1, float p2) ;
+EXPORT struct S_PF f17_S_SFF_PF(struct S_PF p0, float p1, float p2) ;
+EXPORT struct S_PD f17_S_SFF_PD(struct S_PD p0, float p1, float p2) ;
+EXPORT struct S_PP f17_S_SFF_PP(struct S_PP p0, float p1, float p2) ;
+EXPORT struct S_III f17_S_SFF_III(struct S_III p0, float p1, float p2) ;
+EXPORT struct S_IIF f17_S_SFF_IIF(struct S_IIF p0, float p1, float p2) ;
+EXPORT struct S_IID f17_S_SFF_IID(struct S_IID p0, float p1, float p2) ;
+EXPORT struct S_IIP f17_S_SFF_IIP(struct S_IIP p0, float p1, float p2) ;
+EXPORT struct S_IFI f17_S_SFF_IFI(struct S_IFI p0, float p1, float p2) ;
+EXPORT struct S_IFF f17_S_SFF_IFF(struct S_IFF p0, float p1, float p2) ;
+EXPORT struct S_IFD f17_S_SFF_IFD(struct S_IFD p0, float p1, float p2) ;
+EXPORT struct S_IFP f17_S_SFF_IFP(struct S_IFP p0, float p1, float p2) ;
+EXPORT struct S_IDI f17_S_SFF_IDI(struct S_IDI p0, float p1, float p2) ;
+EXPORT struct S_IDF f17_S_SFF_IDF(struct S_IDF p0, float p1, float p2) ;
+EXPORT struct S_IDD f17_S_SFF_IDD(struct S_IDD p0, float p1, float p2) ;
+EXPORT struct S_IDP f17_S_SFF_IDP(struct S_IDP p0, float p1, float p2) ;
+EXPORT struct S_IPI f17_S_SFF_IPI(struct S_IPI p0, float p1, float p2) ;
+EXPORT struct S_IPF f17_S_SFF_IPF(struct S_IPF p0, float p1, float p2) ;
+EXPORT struct S_IPD f17_S_SFF_IPD(struct S_IPD p0, float p1, float p2) ;
+EXPORT struct S_IPP f17_S_SFF_IPP(struct S_IPP p0, float p1, float p2) ;
+EXPORT struct S_FII f17_S_SFF_FII(struct S_FII p0, float p1, float p2) ;
+EXPORT struct S_FIF f17_S_SFF_FIF(struct S_FIF p0, float p1, float p2) ;
+EXPORT struct S_FID f17_S_SFF_FID(struct S_FID p0, float p1, float p2) ;
+EXPORT struct S_FIP f17_S_SFF_FIP(struct S_FIP p0, float p1, float p2) ;
+EXPORT struct S_FFI f17_S_SFF_FFI(struct S_FFI p0, float p1, float p2) ;
+EXPORT struct S_FFF f17_S_SFF_FFF(struct S_FFF p0, float p1, float p2) ;
+EXPORT struct S_FFD f17_S_SFF_FFD(struct S_FFD p0, float p1, float p2) ;
+EXPORT struct S_FFP f17_S_SFF_FFP(struct S_FFP p0, float p1, float p2) ;
+EXPORT struct S_FDI f17_S_SFF_FDI(struct S_FDI p0, float p1, float p2) ;
+EXPORT struct S_FDF f17_S_SFF_FDF(struct S_FDF p0, float p1, float p2) ;
+EXPORT struct S_FDD f17_S_SFF_FDD(struct S_FDD p0, float p1, float p2) ;
+EXPORT struct S_FDP f17_S_SFF_FDP(struct S_FDP p0, float p1, float p2) ;
+EXPORT struct S_FPI f17_S_SFF_FPI(struct S_FPI p0, float p1, float p2) ;
+EXPORT struct S_FPF f17_S_SFF_FPF(struct S_FPF p0, float p1, float p2) ;
+EXPORT struct S_FPD f17_S_SFF_FPD(struct S_FPD p0, float p1, float p2) ;
+EXPORT struct S_FPP f17_S_SFF_FPP(struct S_FPP p0, float p1, float p2) ;
+EXPORT struct S_DII f17_S_SFF_DII(struct S_DII p0, float p1, float p2) ;
+EXPORT struct S_DIF f17_S_SFF_DIF(struct S_DIF p0, float p1, float p2) ;
+EXPORT struct S_DID f17_S_SFF_DID(struct S_DID p0, float p1, float p2) ;
+EXPORT struct S_DIP f17_S_SFF_DIP(struct S_DIP p0, float p1, float p2) ;
+EXPORT struct S_DFI f17_S_SFF_DFI(struct S_DFI p0, float p1, float p2) ;
+EXPORT struct S_DFF f17_S_SFF_DFF(struct S_DFF p0, float p1, float p2) ;
+EXPORT struct S_DFD f17_S_SFF_DFD(struct S_DFD p0, float p1, float p2) ;
+EXPORT struct S_DFP f17_S_SFF_DFP(struct S_DFP p0, float p1, float p2) ;
+EXPORT struct S_DDI f17_S_SFF_DDI(struct S_DDI p0, float p1, float p2) ;
+EXPORT struct S_DDF f17_S_SFF_DDF(struct S_DDF p0, float p1, float p2) ;
+EXPORT struct S_DDD f17_S_SFF_DDD(struct S_DDD p0, float p1, float p2) ;
+EXPORT struct S_DDP f17_S_SFF_DDP(struct S_DDP p0, float p1, float p2) ;
+EXPORT struct S_DPI f17_S_SFF_DPI(struct S_DPI p0, float p1, float p2) ;
+EXPORT struct S_DPF f17_S_SFF_DPF(struct S_DPF p0, float p1, float p2) ;
+EXPORT struct S_DPD f17_S_SFF_DPD(struct S_DPD p0, float p1, float p2) ;
+EXPORT struct S_DPP f17_S_SFF_DPP(struct S_DPP p0, float p1, float p2) ;
+EXPORT struct S_PII f17_S_SFF_PII(struct S_PII p0, float p1, float p2) ;
+EXPORT struct S_PIF f17_S_SFF_PIF(struct S_PIF p0, float p1, float p2) ;
+EXPORT struct S_PID f17_S_SFF_PID(struct S_PID p0, float p1, float p2) ;
+EXPORT struct S_PIP f17_S_SFF_PIP(struct S_PIP p0, float p1, float p2) ;
+EXPORT struct S_PFI f17_S_SFF_PFI(struct S_PFI p0, float p1, float p2) ;
+EXPORT struct S_PFF f17_S_SFF_PFF(struct S_PFF p0, float p1, float p2) ;
+EXPORT struct S_PFD f17_S_SFF_PFD(struct S_PFD p0, float p1, float p2) ;
+EXPORT struct S_PFP f17_S_SFF_PFP(struct S_PFP p0, float p1, float p2) ;
+EXPORT struct S_PDI f17_S_SFF_PDI(struct S_PDI p0, float p1, float p2) ;
+EXPORT struct S_PDF f17_S_SFF_PDF(struct S_PDF p0, float p1, float p2) ;
+EXPORT struct S_PDD f17_S_SFF_PDD(struct S_PDD p0, float p1, float p2) ;
+EXPORT struct S_PDP f17_S_SFF_PDP(struct S_PDP p0, float p1, float p2) ;
+EXPORT struct S_PPI f17_S_SFF_PPI(struct S_PPI p0, float p1, float p2) ;
+EXPORT struct S_PPF f17_S_SFF_PPF(struct S_PPF p0, float p1, float p2) ;
+EXPORT struct S_PPD f17_S_SFF_PPD(struct S_PPD p0, float p1, float p2) ;
+EXPORT struct S_PPP f17_S_SFF_PPP(struct S_PPP p0, float p1, float p2) ;
+EXPORT struct S_I f17_S_SFD_I(struct S_I p0, float p1, double p2) ;
+EXPORT struct S_F f17_S_SFD_F(struct S_F p0, float p1, double p2) ;
+EXPORT struct S_D f17_S_SFD_D(struct S_D p0, float p1, double p2) ;
+EXPORT struct S_P f17_S_SFD_P(struct S_P p0, float p1, double p2) ;
+EXPORT struct S_II f17_S_SFD_II(struct S_II p0, float p1, double p2) ;
+EXPORT struct S_IF f17_S_SFD_IF(struct S_IF p0, float p1, double p2) ;
+EXPORT struct S_ID f17_S_SFD_ID(struct S_ID p0, float p1, double p2) ;
+EXPORT struct S_IP f17_S_SFD_IP(struct S_IP p0, float p1, double p2) ;
+EXPORT struct S_FI f17_S_SFD_FI(struct S_FI p0, float p1, double p2) ;
+EXPORT struct S_FF f17_S_SFD_FF(struct S_FF p0, float p1, double p2) ;
+EXPORT struct S_FD f17_S_SFD_FD(struct S_FD p0, float p1, double p2) ;
+EXPORT struct S_FP f17_S_SFD_FP(struct S_FP p0, float p1, double p2) ;
+EXPORT struct S_DI f17_S_SFD_DI(struct S_DI p0, float p1, double p2) ;
+EXPORT struct S_DF f17_S_SFD_DF(struct S_DF p0, float p1, double p2) ;
+EXPORT struct S_DD f17_S_SFD_DD(struct S_DD p0, float p1, double p2) ;
+EXPORT struct S_DP f17_S_SFD_DP(struct S_DP p0, float p1, double p2) ;
+EXPORT struct S_PI f17_S_SFD_PI(struct S_PI p0, float p1, double p2) ;
+EXPORT struct S_PF f17_S_SFD_PF(struct S_PF p0, float p1, double p2) ;
+EXPORT struct S_PD f17_S_SFD_PD(struct S_PD p0, float p1, double p2) ;
+EXPORT struct S_PP f17_S_SFD_PP(struct S_PP p0, float p1, double p2) ;
+EXPORT struct S_III f17_S_SFD_III(struct S_III p0, float p1, double p2) ;
+EXPORT struct S_IIF f17_S_SFD_IIF(struct S_IIF p0, float p1, double p2) ;
+EXPORT struct S_IID f17_S_SFD_IID(struct S_IID p0, float p1, double p2) ;
+EXPORT struct S_IIP f17_S_SFD_IIP(struct S_IIP p0, float p1, double p2) ;
+EXPORT struct S_IFI f17_S_SFD_IFI(struct S_IFI p0, float p1, double p2) ;
+EXPORT struct S_IFF f17_S_SFD_IFF(struct S_IFF p0, float p1, double p2) ;
+EXPORT struct S_IFD f17_S_SFD_IFD(struct S_IFD p0, float p1, double p2) ;
+EXPORT struct S_IFP f17_S_SFD_IFP(struct S_IFP p0, float p1, double p2) ;
+EXPORT struct S_IDI f17_S_SFD_IDI(struct S_IDI p0, float p1, double p2) ;
+EXPORT struct S_IDF f17_S_SFD_IDF(struct S_IDF p0, float p1, double p2) ;
+EXPORT struct S_IDD f17_S_SFD_IDD(struct S_IDD p0, float p1, double p2) ;
+EXPORT struct S_IDP f17_S_SFD_IDP(struct S_IDP p0, float p1, double p2) ;
+EXPORT struct S_IPI f17_S_SFD_IPI(struct S_IPI p0, float p1, double p2) ;
+EXPORT struct S_IPF f17_S_SFD_IPF(struct S_IPF p0, float p1, double p2) ;
+EXPORT struct S_IPD f17_S_SFD_IPD(struct S_IPD p0, float p1, double p2) ;
+EXPORT struct S_IPP f17_S_SFD_IPP(struct S_IPP p0, float p1, double p2) ;
+EXPORT struct S_FII f17_S_SFD_FII(struct S_FII p0, float p1, double p2) ;
+EXPORT struct S_FIF f17_S_SFD_FIF(struct S_FIF p0, float p1, double p2) ;
+EXPORT struct S_FID f17_S_SFD_FID(struct S_FID p0, float p1, double p2) ;
+EXPORT struct S_FIP f17_S_SFD_FIP(struct S_FIP p0, float p1, double p2) ;
+EXPORT struct S_FFI f17_S_SFD_FFI(struct S_FFI p0, float p1, double p2) ;
+EXPORT struct S_FFF f17_S_SFD_FFF(struct S_FFF p0, float p1, double p2) ;
+EXPORT struct S_FFD f17_S_SFD_FFD(struct S_FFD p0, float p1, double p2) ;
+EXPORT struct S_FFP f17_S_SFD_FFP(struct S_FFP p0, float p1, double p2) ;
+EXPORT struct S_FDI f17_S_SFD_FDI(struct S_FDI p0, float p1, double p2) ;
+EXPORT struct S_FDF f17_S_SFD_FDF(struct S_FDF p0, float p1, double p2) ;
+EXPORT struct S_FDD f17_S_SFD_FDD(struct S_FDD p0, float p1, double p2) ;
+EXPORT struct S_FDP f17_S_SFD_FDP(struct S_FDP p0, float p1, double p2) ;
+EXPORT struct S_FPI f17_S_SFD_FPI(struct S_FPI p0, float p1, double p2) ;
+EXPORT struct S_FPF f17_S_SFD_FPF(struct S_FPF p0, float p1, double p2) ;
+EXPORT struct S_FPD f17_S_SFD_FPD(struct S_FPD p0, float p1, double p2) ;
+EXPORT struct S_FPP f17_S_SFD_FPP(struct S_FPP p0, float p1, double p2) ;
+EXPORT struct S_DII f17_S_SFD_DII(struct S_DII p0, float p1, double p2) ;
+EXPORT struct S_DIF f17_S_SFD_DIF(struct S_DIF p0, float p1, double p2) ;
+EXPORT struct S_DID f17_S_SFD_DID(struct S_DID p0, float p1, double p2) ;
+EXPORT struct S_DIP f17_S_SFD_DIP(struct S_DIP p0, float p1, double p2) ;
+EXPORT struct S_DFI f17_S_SFD_DFI(struct S_DFI p0, float p1, double p2) ;
+EXPORT struct S_DFF f17_S_SFD_DFF(struct S_DFF p0, float p1, double p2) ;
+EXPORT struct S_DFD f17_S_SFD_DFD(struct S_DFD p0, float p1, double p2) ;
+EXPORT struct S_DFP f17_S_SFD_DFP(struct S_DFP p0, float p1, double p2) ;
+EXPORT struct S_DDI f17_S_SFD_DDI(struct S_DDI p0, float p1, double p2) ;
+EXPORT struct S_DDF f17_S_SFD_DDF(struct S_DDF p0, float p1, double p2) ;
+EXPORT struct S_DDD f17_S_SFD_DDD(struct S_DDD p0, float p1, double p2) ;
+EXPORT struct S_DDP f17_S_SFD_DDP(struct S_DDP p0, float p1, double p2) ;
+EXPORT struct S_DPI f17_S_SFD_DPI(struct S_DPI p0, float p1, double p2) ;
+EXPORT struct S_DPF f17_S_SFD_DPF(struct S_DPF p0, float p1, double p2) ;
+EXPORT struct S_DPD f17_S_SFD_DPD(struct S_DPD p0, float p1, double p2) ;
+EXPORT struct S_DPP f17_S_SFD_DPP(struct S_DPP p0, float p1, double p2) ;
+EXPORT struct S_PII f17_S_SFD_PII(struct S_PII p0, float p1, double p2) ;
+EXPORT struct S_PIF f17_S_SFD_PIF(struct S_PIF p0, float p1, double p2) ;
+EXPORT struct S_PID f17_S_SFD_PID(struct S_PID p0, float p1, double p2) ;
+EXPORT struct S_PIP f17_S_SFD_PIP(struct S_PIP p0, float p1, double p2) ;
+EXPORT struct S_PFI f17_S_SFD_PFI(struct S_PFI p0, float p1, double p2) ;
+EXPORT struct S_PFF f17_S_SFD_PFF(struct S_PFF p0, float p1, double p2) ;
+EXPORT struct S_PFD f17_S_SFD_PFD(struct S_PFD p0, float p1, double p2) ;
+EXPORT struct S_PFP f17_S_SFD_PFP(struct S_PFP p0, float p1, double p2) ;
+EXPORT struct S_PDI f17_S_SFD_PDI(struct S_PDI p0, float p1, double p2) ;
+EXPORT struct S_PDF f17_S_SFD_PDF(struct S_PDF p0, float p1, double p2) ;
+EXPORT struct S_PDD f17_S_SFD_PDD(struct S_PDD p0, float p1, double p2) ;
+EXPORT struct S_PDP f17_S_SFD_PDP(struct S_PDP p0, float p1, double p2) ;
+EXPORT struct S_PPI f17_S_SFD_PPI(struct S_PPI p0, float p1, double p2) ;
+EXPORT struct S_PPF f17_S_SFD_PPF(struct S_PPF p0, float p1, double p2) ;
+EXPORT struct S_PPD f17_S_SFD_PPD(struct S_PPD p0, float p1, double p2) ;
+EXPORT struct S_PPP f17_S_SFD_PPP(struct S_PPP p0, float p1, double p2) ;
+EXPORT struct S_I f17_S_SFP_I(struct S_I p0, float p1, void* p2) ;
+EXPORT struct S_F f17_S_SFP_F(struct S_F p0, float p1, void* p2) ;
+EXPORT struct S_D f17_S_SFP_D(struct S_D p0, float p1, void* p2) ;
+EXPORT struct S_P f17_S_SFP_P(struct S_P p0, float p1, void* p2) ;
+EXPORT struct S_II f17_S_SFP_II(struct S_II p0, float p1, void* p2) ;
+EXPORT struct S_IF f17_S_SFP_IF(struct S_IF p0, float p1, void* p2) ;
+EXPORT struct S_ID f17_S_SFP_ID(struct S_ID p0, float p1, void* p2) ;
+EXPORT struct S_IP f17_S_SFP_IP(struct S_IP p0, float p1, void* p2) ;
+EXPORT struct S_FI f17_S_SFP_FI(struct S_FI p0, float p1, void* p2) ;
+EXPORT struct S_FF f17_S_SFP_FF(struct S_FF p0, float p1, void* p2) ;
+EXPORT struct S_FD f17_S_SFP_FD(struct S_FD p0, float p1, void* p2) ;
+EXPORT struct S_FP f17_S_SFP_FP(struct S_FP p0, float p1, void* p2) ;
+EXPORT struct S_DI f17_S_SFP_DI(struct S_DI p0, float p1, void* p2) ;
+EXPORT struct S_DF f17_S_SFP_DF(struct S_DF p0, float p1, void* p2) ;
+EXPORT struct S_DD f17_S_SFP_DD(struct S_DD p0, float p1, void* p2) ;
+EXPORT struct S_DP f17_S_SFP_DP(struct S_DP p0, float p1, void* p2) ;
+EXPORT struct S_PI f17_S_SFP_PI(struct S_PI p0, float p1, void* p2) ;
+EXPORT struct S_PF f17_S_SFP_PF(struct S_PF p0, float p1, void* p2) ;
+EXPORT struct S_PD f17_S_SFP_PD(struct S_PD p0, float p1, void* p2) ;
+EXPORT struct S_PP f17_S_SFP_PP(struct S_PP p0, float p1, void* p2) ;
+EXPORT struct S_III f17_S_SFP_III(struct S_III p0, float p1, void* p2) ;
+EXPORT struct S_IIF f17_S_SFP_IIF(struct S_IIF p0, float p1, void* p2) ;
+EXPORT struct S_IID f17_S_SFP_IID(struct S_IID p0, float p1, void* p2) ;
+EXPORT struct S_IIP f17_S_SFP_IIP(struct S_IIP p0, float p1, void* p2) ;
+EXPORT struct S_IFI f17_S_SFP_IFI(struct S_IFI p0, float p1, void* p2) ;
+EXPORT struct S_IFF f17_S_SFP_IFF(struct S_IFF p0, float p1, void* p2) ;
+EXPORT struct S_IFD f17_S_SFP_IFD(struct S_IFD p0, float p1, void* p2) ;
+EXPORT struct S_IFP f17_S_SFP_IFP(struct S_IFP p0, float p1, void* p2) ;
+EXPORT struct S_IDI f17_S_SFP_IDI(struct S_IDI p0, float p1, void* p2) ;
+EXPORT struct S_IDF f17_S_SFP_IDF(struct S_IDF p0, float p1, void* p2) ;
+EXPORT struct S_IDD f17_S_SFP_IDD(struct S_IDD p0, float p1, void* p2) ;
+EXPORT struct S_IDP f17_S_SFP_IDP(struct S_IDP p0, float p1, void* p2) ;
+EXPORT struct S_IPI f17_S_SFP_IPI(struct S_IPI p0, float p1, void* p2) ;
+EXPORT struct S_IPF f17_S_SFP_IPF(struct S_IPF p0, float p1, void* p2) ;
+EXPORT struct S_IPD f17_S_SFP_IPD(struct S_IPD p0, float p1, void* p2) ;
+EXPORT struct S_IPP f17_S_SFP_IPP(struct S_IPP p0, float p1, void* p2) ;
+EXPORT struct S_FII f17_S_SFP_FII(struct S_FII p0, float p1, void* p2) ;
+EXPORT struct S_FIF f17_S_SFP_FIF(struct S_FIF p0, float p1, void* p2) ;
+EXPORT struct S_FID f17_S_SFP_FID(struct S_FID p0, float p1, void* p2) ;
+EXPORT struct S_FIP f17_S_SFP_FIP(struct S_FIP p0, float p1, void* p2) ;
+EXPORT struct S_FFI f17_S_SFP_FFI(struct S_FFI p0, float p1, void* p2) ;
+EXPORT struct S_FFF f17_S_SFP_FFF(struct S_FFF p0, float p1, void* p2) ;
+EXPORT struct S_FFD f17_S_SFP_FFD(struct S_FFD p0, float p1, void* p2) ;
+EXPORT struct S_FFP f17_S_SFP_FFP(struct S_FFP p0, float p1, void* p2) ;
+EXPORT struct S_FDI f17_S_SFP_FDI(struct S_FDI p0, float p1, void* p2) ;
+EXPORT struct S_FDF f17_S_SFP_FDF(struct S_FDF p0, float p1, void* p2) ;
+EXPORT struct S_FDD f17_S_SFP_FDD(struct S_FDD p0, float p1, void* p2) ;
+EXPORT struct S_FDP f17_S_SFP_FDP(struct S_FDP p0, float p1, void* p2) ;
+EXPORT struct S_FPI f17_S_SFP_FPI(struct S_FPI p0, float p1, void* p2) ;
+EXPORT struct S_FPF f17_S_SFP_FPF(struct S_FPF p0, float p1, void* p2) ;
+EXPORT struct S_FPD f17_S_SFP_FPD(struct S_FPD p0, float p1, void* p2) ;
+EXPORT struct S_FPP f17_S_SFP_FPP(struct S_FPP p0, float p1, void* p2) ;
+EXPORT struct S_DII f17_S_SFP_DII(struct S_DII p0, float p1, void* p2) ;
+EXPORT struct S_DIF f17_S_SFP_DIF(struct S_DIF p0, float p1, void* p2) ;
+EXPORT struct S_DID f17_S_SFP_DID(struct S_DID p0, float p1, void* p2) ;
+EXPORT struct S_DIP f17_S_SFP_DIP(struct S_DIP p0, float p1, void* p2) ;
+EXPORT struct S_DFI f17_S_SFP_DFI(struct S_DFI p0, float p1, void* p2) ;
+EXPORT struct S_DFF f17_S_SFP_DFF(struct S_DFF p0, float p1, void* p2) ;
+EXPORT struct S_DFD f17_S_SFP_DFD(struct S_DFD p0, float p1, void* p2) ;
+EXPORT struct S_DFP f17_S_SFP_DFP(struct S_DFP p0, float p1, void* p2) ;
+EXPORT struct S_DDI f17_S_SFP_DDI(struct S_DDI p0, float p1, void* p2) ;
+EXPORT struct S_DDF f17_S_SFP_DDF(struct S_DDF p0, float p1, void* p2) ;
+EXPORT struct S_DDD f17_S_SFP_DDD(struct S_DDD p0, float p1, void* p2) ;
+EXPORT struct S_DDP f17_S_SFP_DDP(struct S_DDP p0, float p1, void* p2) ;
+EXPORT struct S_DPI f17_S_SFP_DPI(struct S_DPI p0, float p1, void* p2) ;
+EXPORT struct S_DPF f17_S_SFP_DPF(struct S_DPF p0, float p1, void* p2) ;
+EXPORT struct S_DPD f17_S_SFP_DPD(struct S_DPD p0, float p1, void* p2) ;
+EXPORT struct S_DPP f17_S_SFP_DPP(struct S_DPP p0, float p1, void* p2) ;
+EXPORT struct S_PII f17_S_SFP_PII(struct S_PII p0, float p1, void* p2) ;
+EXPORT struct S_PIF f17_S_SFP_PIF(struct S_PIF p0, float p1, void* p2) ;
+EXPORT struct S_PID f17_S_SFP_PID(struct S_PID p0, float p1, void* p2) ;
+EXPORT struct S_PIP f17_S_SFP_PIP(struct S_PIP p0, float p1, void* p2) ;
+EXPORT struct S_PFI f17_S_SFP_PFI(struct S_PFI p0, float p1, void* p2) ;
+EXPORT struct S_PFF f17_S_SFP_PFF(struct S_PFF p0, float p1, void* p2) ;
+EXPORT struct S_PFD f17_S_SFP_PFD(struct S_PFD p0, float p1, void* p2) ;
+EXPORT struct S_PFP f17_S_SFP_PFP(struct S_PFP p0, float p1, void* p2) ;
+EXPORT struct S_PDI f17_S_SFP_PDI(struct S_PDI p0, float p1, void* p2) ;
+EXPORT struct S_PDF f17_S_SFP_PDF(struct S_PDF p0, float p1, void* p2) ;
+EXPORT struct S_PDD f17_S_SFP_PDD(struct S_PDD p0, float p1, void* p2) ;
+EXPORT struct S_PDP f17_S_SFP_PDP(struct S_PDP p0, float p1, void* p2) ;
+EXPORT struct S_PPI f17_S_SFP_PPI(struct S_PPI p0, float p1, void* p2) ;
+EXPORT struct S_PPF f17_S_SFP_PPF(struct S_PPF p0, float p1, void* p2) ;
+EXPORT struct S_PPD f17_S_SFP_PPD(struct S_PPD p0, float p1, void* p2) ;
+EXPORT struct S_PPP f17_S_SFP_PPP(struct S_PPP p0, float p1, void* p2) ;
+EXPORT struct S_I f17_S_SFS_I(struct S_I p0, float p1, struct S_I p2) ;
+EXPORT struct S_F f17_S_SFS_F(struct S_F p0, float p1, struct S_F p2) ;
+EXPORT struct S_D f17_S_SFS_D(struct S_D p0, float p1, struct S_D p2) ;
+EXPORT struct S_P f17_S_SFS_P(struct S_P p0, float p1, struct S_P p2) ;
+EXPORT struct S_II f17_S_SFS_II(struct S_II p0, float p1, struct S_II p2) ;
+EXPORT struct S_IF f17_S_SFS_IF(struct S_IF p0, float p1, struct S_IF p2) ;
+EXPORT struct S_ID f17_S_SFS_ID(struct S_ID p0, float p1, struct S_ID p2) ;
+EXPORT struct S_IP f17_S_SFS_IP(struct S_IP p0, float p1, struct S_IP p2) ;
+EXPORT struct S_FI f17_S_SFS_FI(struct S_FI p0, float p1, struct S_FI p2) ;
+EXPORT struct S_FF f17_S_SFS_FF(struct S_FF p0, float p1, struct S_FF p2) ;
+EXPORT struct S_FD f17_S_SFS_FD(struct S_FD p0, float p1, struct S_FD p2) ;
+EXPORT struct S_FP f17_S_SFS_FP(struct S_FP p0, float p1, struct S_FP p2) ;
+EXPORT struct S_DI f17_S_SFS_DI(struct S_DI p0, float p1, struct S_DI p2) ;
+EXPORT struct S_DF f17_S_SFS_DF(struct S_DF p0, float p1, struct S_DF p2) ;
+EXPORT struct S_DD f17_S_SFS_DD(struct S_DD p0, float p1, struct S_DD p2) ;
+EXPORT struct S_DP f17_S_SFS_DP(struct S_DP p0, float p1, struct S_DP p2) ;
+EXPORT struct S_PI f17_S_SFS_PI(struct S_PI p0, float p1, struct S_PI p2) ;
+EXPORT struct S_PF f17_S_SFS_PF(struct S_PF p0, float p1, struct S_PF p2) ;
+EXPORT struct S_PD f17_S_SFS_PD(struct S_PD p0, float p1, struct S_PD p2) ;
+EXPORT struct S_PP f17_S_SFS_PP(struct S_PP p0, float p1, struct S_PP p2) ;
+EXPORT struct S_III f17_S_SFS_III(struct S_III p0, float p1, struct S_III p2) ;
+EXPORT struct S_IIF f17_S_SFS_IIF(struct S_IIF p0, float p1, struct S_IIF p2) ;
+EXPORT struct S_IID f17_S_SFS_IID(struct S_IID p0, float p1, struct S_IID p2) ;
+EXPORT struct S_IIP f17_S_SFS_IIP(struct S_IIP p0, float p1, struct S_IIP p2) ;
+EXPORT struct S_IFI f17_S_SFS_IFI(struct S_IFI p0, float p1, struct S_IFI p2) ;
+EXPORT struct S_IFF f17_S_SFS_IFF(struct S_IFF p0, float p1, struct S_IFF p2) ;
+EXPORT struct S_IFD f17_S_SFS_IFD(struct S_IFD p0, float p1, struct S_IFD p2) ;
+EXPORT struct S_IFP f17_S_SFS_IFP(struct S_IFP p0, float p1, struct S_IFP p2) ;
+EXPORT struct S_IDI f17_S_SFS_IDI(struct S_IDI p0, float p1, struct S_IDI p2) ;
+EXPORT struct S_IDF f17_S_SFS_IDF(struct S_IDF p0, float p1, struct S_IDF p2) ;
+EXPORT struct S_IDD f17_S_SFS_IDD(struct S_IDD p0, float p1, struct S_IDD p2) ;
+EXPORT struct S_IDP f17_S_SFS_IDP(struct S_IDP p0, float p1, struct S_IDP p2) ;
+EXPORT struct S_IPI f17_S_SFS_IPI(struct S_IPI p0, float p1, struct S_IPI p2) ;
+EXPORT struct S_IPF f17_S_SFS_IPF(struct S_IPF p0, float p1, struct S_IPF p2) ;
+EXPORT struct S_IPD f17_S_SFS_IPD(struct S_IPD p0, float p1, struct S_IPD p2) ;
+EXPORT struct S_IPP f17_S_SFS_IPP(struct S_IPP p0, float p1, struct S_IPP p2) ;
+EXPORT struct S_FII f17_S_SFS_FII(struct S_FII p0, float p1, struct S_FII p2) ;
+EXPORT struct S_FIF f17_S_SFS_FIF(struct S_FIF p0, float p1, struct S_FIF p2) ;
+EXPORT struct S_FID f17_S_SFS_FID(struct S_FID p0, float p1, struct S_FID p2) ;
+EXPORT struct S_FIP f17_S_SFS_FIP(struct S_FIP p0, float p1, struct S_FIP p2) ;
+EXPORT struct S_FFI f17_S_SFS_FFI(struct S_FFI p0, float p1, struct S_FFI p2) ;
+EXPORT struct S_FFF f17_S_SFS_FFF(struct S_FFF p0, float p1, struct S_FFF p2) ;
+EXPORT struct S_FFD f17_S_SFS_FFD(struct S_FFD p0, float p1, struct S_FFD p2) ;
+EXPORT struct S_FFP f17_S_SFS_FFP(struct S_FFP p0, float p1, struct S_FFP p2) ;
+EXPORT struct S_FDI f17_S_SFS_FDI(struct S_FDI p0, float p1, struct S_FDI p2) ;
+EXPORT struct S_FDF f17_S_SFS_FDF(struct S_FDF p0, float p1, struct S_FDF p2) ;
+EXPORT struct S_FDD f17_S_SFS_FDD(struct S_FDD p0, float p1, struct S_FDD p2) ;
+EXPORT struct S_FDP f18_S_SFS_FDP(struct S_FDP p0, float p1, struct S_FDP p2) ;
+EXPORT struct S_FPI f18_S_SFS_FPI(struct S_FPI p0, float p1, struct S_FPI p2) ;
+EXPORT struct S_FPF f18_S_SFS_FPF(struct S_FPF p0, float p1, struct S_FPF p2) ;
+EXPORT struct S_FPD f18_S_SFS_FPD(struct S_FPD p0, float p1, struct S_FPD p2) ;
+EXPORT struct S_FPP f18_S_SFS_FPP(struct S_FPP p0, float p1, struct S_FPP p2) ;
+EXPORT struct S_DII f18_S_SFS_DII(struct S_DII p0, float p1, struct S_DII p2) ;
+EXPORT struct S_DIF f18_S_SFS_DIF(struct S_DIF p0, float p1, struct S_DIF p2) ;
+EXPORT struct S_DID f18_S_SFS_DID(struct S_DID p0, float p1, struct S_DID p2) ;
+EXPORT struct S_DIP f18_S_SFS_DIP(struct S_DIP p0, float p1, struct S_DIP p2) ;
+EXPORT struct S_DFI f18_S_SFS_DFI(struct S_DFI p0, float p1, struct S_DFI p2) ;
+EXPORT struct S_DFF f18_S_SFS_DFF(struct S_DFF p0, float p1, struct S_DFF p2) ;
+EXPORT struct S_DFD f18_S_SFS_DFD(struct S_DFD p0, float p1, struct S_DFD p2) ;
+EXPORT struct S_DFP f18_S_SFS_DFP(struct S_DFP p0, float p1, struct S_DFP p2) ;
+EXPORT struct S_DDI f18_S_SFS_DDI(struct S_DDI p0, float p1, struct S_DDI p2) ;
+EXPORT struct S_DDF f18_S_SFS_DDF(struct S_DDF p0, float p1, struct S_DDF p2) ;
+EXPORT struct S_DDD f18_S_SFS_DDD(struct S_DDD p0, float p1, struct S_DDD p2) ;
+EXPORT struct S_DDP f18_S_SFS_DDP(struct S_DDP p0, float p1, struct S_DDP p2) ;
+EXPORT struct S_DPI f18_S_SFS_DPI(struct S_DPI p0, float p1, struct S_DPI p2) ;
+EXPORT struct S_DPF f18_S_SFS_DPF(struct S_DPF p0, float p1, struct S_DPF p2) ;
+EXPORT struct S_DPD f18_S_SFS_DPD(struct S_DPD p0, float p1, struct S_DPD p2) ;
+EXPORT struct S_DPP f18_S_SFS_DPP(struct S_DPP p0, float p1, struct S_DPP p2) ;
+EXPORT struct S_PII f18_S_SFS_PII(struct S_PII p0, float p1, struct S_PII p2) ;
+EXPORT struct S_PIF f18_S_SFS_PIF(struct S_PIF p0, float p1, struct S_PIF p2) ;
+EXPORT struct S_PID f18_S_SFS_PID(struct S_PID p0, float p1, struct S_PID p2) ;
+EXPORT struct S_PIP f18_S_SFS_PIP(struct S_PIP p0, float p1, struct S_PIP p2) ;
+EXPORT struct S_PFI f18_S_SFS_PFI(struct S_PFI p0, float p1, struct S_PFI p2) ;
+EXPORT struct S_PFF f18_S_SFS_PFF(struct S_PFF p0, float p1, struct S_PFF p2) ;
+EXPORT struct S_PFD f18_S_SFS_PFD(struct S_PFD p0, float p1, struct S_PFD p2) ;
+EXPORT struct S_PFP f18_S_SFS_PFP(struct S_PFP p0, float p1, struct S_PFP p2) ;
+EXPORT struct S_PDI f18_S_SFS_PDI(struct S_PDI p0, float p1, struct S_PDI p2) ;
+EXPORT struct S_PDF f18_S_SFS_PDF(struct S_PDF p0, float p1, struct S_PDF p2) ;
+EXPORT struct S_PDD f18_S_SFS_PDD(struct S_PDD p0, float p1, struct S_PDD p2) ;
+EXPORT struct S_PDP f18_S_SFS_PDP(struct S_PDP p0, float p1, struct S_PDP p2) ;
+EXPORT struct S_PPI f18_S_SFS_PPI(struct S_PPI p0, float p1, struct S_PPI p2) ;
+EXPORT struct S_PPF f18_S_SFS_PPF(struct S_PPF p0, float p1, struct S_PPF p2) ;
+EXPORT struct S_PPD f18_S_SFS_PPD(struct S_PPD p0, float p1, struct S_PPD p2) ;
+EXPORT struct S_PPP f18_S_SFS_PPP(struct S_PPP p0, float p1, struct S_PPP p2) ;
+EXPORT struct S_I f18_S_SDI_I(struct S_I p0, double p1, int p2) ;
+EXPORT struct S_F f18_S_SDI_F(struct S_F p0, double p1, int p2) ;
+EXPORT struct S_D f18_S_SDI_D(struct S_D p0, double p1, int p2) ;
+EXPORT struct S_P f18_S_SDI_P(struct S_P p0, double p1, int p2) ;
+EXPORT struct S_II f18_S_SDI_II(struct S_II p0, double p1, int p2) ;
+EXPORT struct S_IF f18_S_SDI_IF(struct S_IF p0, double p1, int p2) ;
+EXPORT struct S_ID f18_S_SDI_ID(struct S_ID p0, double p1, int p2) ;
+EXPORT struct S_IP f18_S_SDI_IP(struct S_IP p0, double p1, int p2) ;
+EXPORT struct S_FI f18_S_SDI_FI(struct S_FI p0, double p1, int p2) ;
+EXPORT struct S_FF f18_S_SDI_FF(struct S_FF p0, double p1, int p2) ;
+EXPORT struct S_FD f18_S_SDI_FD(struct S_FD p0, double p1, int p2) ;
+EXPORT struct S_FP f18_S_SDI_FP(struct S_FP p0, double p1, int p2) ;
+EXPORT struct S_DI f18_S_SDI_DI(struct S_DI p0, double p1, int p2) ;
+EXPORT struct S_DF f18_S_SDI_DF(struct S_DF p0, double p1, int p2) ;
+EXPORT struct S_DD f18_S_SDI_DD(struct S_DD p0, double p1, int p2) ;
+EXPORT struct S_DP f18_S_SDI_DP(struct S_DP p0, double p1, int p2) ;
+EXPORT struct S_PI f18_S_SDI_PI(struct S_PI p0, double p1, int p2) ;
+EXPORT struct S_PF f18_S_SDI_PF(struct S_PF p0, double p1, int p2) ;
+EXPORT struct S_PD f18_S_SDI_PD(struct S_PD p0, double p1, int p2) ;
+EXPORT struct S_PP f18_S_SDI_PP(struct S_PP p0, double p1, int p2) ;
+EXPORT struct S_III f18_S_SDI_III(struct S_III p0, double p1, int p2) ;
+EXPORT struct S_IIF f18_S_SDI_IIF(struct S_IIF p0, double p1, int p2) ;
+EXPORT struct S_IID f18_S_SDI_IID(struct S_IID p0, double p1, int p2) ;
+EXPORT struct S_IIP f18_S_SDI_IIP(struct S_IIP p0, double p1, int p2) ;
+EXPORT struct S_IFI f18_S_SDI_IFI(struct S_IFI p0, double p1, int p2) ;
+EXPORT struct S_IFF f18_S_SDI_IFF(struct S_IFF p0, double p1, int p2) ;
+EXPORT struct S_IFD f18_S_SDI_IFD(struct S_IFD p0, double p1, int p2) ;
+EXPORT struct S_IFP f18_S_SDI_IFP(struct S_IFP p0, double p1, int p2) ;
+EXPORT struct S_IDI f18_S_SDI_IDI(struct S_IDI p0, double p1, int p2) ;
+EXPORT struct S_IDF f18_S_SDI_IDF(struct S_IDF p0, double p1, int p2) ;
+EXPORT struct S_IDD f18_S_SDI_IDD(struct S_IDD p0, double p1, int p2) ;
+EXPORT struct S_IDP f18_S_SDI_IDP(struct S_IDP p0, double p1, int p2) ;
+EXPORT struct S_IPI f18_S_SDI_IPI(struct S_IPI p0, double p1, int p2) ;
+EXPORT struct S_IPF f18_S_SDI_IPF(struct S_IPF p0, double p1, int p2) ;
+EXPORT struct S_IPD f18_S_SDI_IPD(struct S_IPD p0, double p1, int p2) ;
+EXPORT struct S_IPP f18_S_SDI_IPP(struct S_IPP p0, double p1, int p2) ;
+EXPORT struct S_FII f18_S_SDI_FII(struct S_FII p0, double p1, int p2) ;
+EXPORT struct S_FIF f18_S_SDI_FIF(struct S_FIF p0, double p1, int p2) ;
+EXPORT struct S_FID f18_S_SDI_FID(struct S_FID p0, double p1, int p2) ;
+EXPORT struct S_FIP f18_S_SDI_FIP(struct S_FIP p0, double p1, int p2) ;
+EXPORT struct S_FFI f18_S_SDI_FFI(struct S_FFI p0, double p1, int p2) ;
+EXPORT struct S_FFF f18_S_SDI_FFF(struct S_FFF p0, double p1, int p2) ;
+EXPORT struct S_FFD f18_S_SDI_FFD(struct S_FFD p0, double p1, int p2) ;
+EXPORT struct S_FFP f18_S_SDI_FFP(struct S_FFP p0, double p1, int p2) ;
+EXPORT struct S_FDI f18_S_SDI_FDI(struct S_FDI p0, double p1, int p2) ;
+EXPORT struct S_FDF f18_S_SDI_FDF(struct S_FDF p0, double p1, int p2) ;
+EXPORT struct S_FDD f18_S_SDI_FDD(struct S_FDD p0, double p1, int p2) ;
+EXPORT struct S_FDP f18_S_SDI_FDP(struct S_FDP p0, double p1, int p2) ;
+EXPORT struct S_FPI f18_S_SDI_FPI(struct S_FPI p0, double p1, int p2) ;
+EXPORT struct S_FPF f18_S_SDI_FPF(struct S_FPF p0, double p1, int p2) ;
+EXPORT struct S_FPD f18_S_SDI_FPD(struct S_FPD p0, double p1, int p2) ;
+EXPORT struct S_FPP f18_S_SDI_FPP(struct S_FPP p0, double p1, int p2) ;
+EXPORT struct S_DII f18_S_SDI_DII(struct S_DII p0, double p1, int p2) ;
+EXPORT struct S_DIF f18_S_SDI_DIF(struct S_DIF p0, double p1, int p2) ;
+EXPORT struct S_DID f18_S_SDI_DID(struct S_DID p0, double p1, int p2) ;
+EXPORT struct S_DIP f18_S_SDI_DIP(struct S_DIP p0, double p1, int p2) ;
+EXPORT struct S_DFI f18_S_SDI_DFI(struct S_DFI p0, double p1, int p2) ;
+EXPORT struct S_DFF f18_S_SDI_DFF(struct S_DFF p0, double p1, int p2) ;
+EXPORT struct S_DFD f18_S_SDI_DFD(struct S_DFD p0, double p1, int p2) ;
+EXPORT struct S_DFP f18_S_SDI_DFP(struct S_DFP p0, double p1, int p2) ;
+EXPORT struct S_DDI f18_S_SDI_DDI(struct S_DDI p0, double p1, int p2) ;
+EXPORT struct S_DDF f18_S_SDI_DDF(struct S_DDF p0, double p1, int p2) ;
+EXPORT struct S_DDD f18_S_SDI_DDD(struct S_DDD p0, double p1, int p2) ;
+EXPORT struct S_DDP f18_S_SDI_DDP(struct S_DDP p0, double p1, int p2) ;
+EXPORT struct S_DPI f18_S_SDI_DPI(struct S_DPI p0, double p1, int p2) ;
+EXPORT struct S_DPF f18_S_SDI_DPF(struct S_DPF p0, double p1, int p2) ;
+EXPORT struct S_DPD f18_S_SDI_DPD(struct S_DPD p0, double p1, int p2) ;
+EXPORT struct S_DPP f18_S_SDI_DPP(struct S_DPP p0, double p1, int p2) ;
+EXPORT struct S_PII f18_S_SDI_PII(struct S_PII p0, double p1, int p2) ;
+EXPORT struct S_PIF f18_S_SDI_PIF(struct S_PIF p0, double p1, int p2) ;
+EXPORT struct S_PID f18_S_SDI_PID(struct S_PID p0, double p1, int p2) ;
+EXPORT struct S_PIP f18_S_SDI_PIP(struct S_PIP p0, double p1, int p2) ;
+EXPORT struct S_PFI f18_S_SDI_PFI(struct S_PFI p0, double p1, int p2) ;
+EXPORT struct S_PFF f18_S_SDI_PFF(struct S_PFF p0, double p1, int p2) ;
+EXPORT struct S_PFD f18_S_SDI_PFD(struct S_PFD p0, double p1, int p2) ;
+EXPORT struct S_PFP f18_S_SDI_PFP(struct S_PFP p0, double p1, int p2) ;
+EXPORT struct S_PDI f18_S_SDI_PDI(struct S_PDI p0, double p1, int p2) ;
+EXPORT struct S_PDF f18_S_SDI_PDF(struct S_PDF p0, double p1, int p2) ;
+EXPORT struct S_PDD f18_S_SDI_PDD(struct S_PDD p0, double p1, int p2) ;
+EXPORT struct S_PDP f18_S_SDI_PDP(struct S_PDP p0, double p1, int p2) ;
+EXPORT struct S_PPI f18_S_SDI_PPI(struct S_PPI p0, double p1, int p2) ;
+EXPORT struct S_PPF f18_S_SDI_PPF(struct S_PPF p0, double p1, int p2) ;
+EXPORT struct S_PPD f18_S_SDI_PPD(struct S_PPD p0, double p1, int p2) ;
+EXPORT struct S_PPP f18_S_SDI_PPP(struct S_PPP p0, double p1, int p2) ;
+EXPORT struct S_I f18_S_SDF_I(struct S_I p0, double p1, float p2) ;
+EXPORT struct S_F f18_S_SDF_F(struct S_F p0, double p1, float p2) ;
+EXPORT struct S_D f18_S_SDF_D(struct S_D p0, double p1, float p2) ;
+EXPORT struct S_P f18_S_SDF_P(struct S_P p0, double p1, float p2) ;
+EXPORT struct S_II f18_S_SDF_II(struct S_II p0, double p1, float p2) ;
+EXPORT struct S_IF f18_S_SDF_IF(struct S_IF p0, double p1, float p2) ;
+EXPORT struct S_ID f18_S_SDF_ID(struct S_ID p0, double p1, float p2) ;
+EXPORT struct S_IP f18_S_SDF_IP(struct S_IP p0, double p1, float p2) ;
+EXPORT struct S_FI f18_S_SDF_FI(struct S_FI p0, double p1, float p2) ;
+EXPORT struct S_FF f18_S_SDF_FF(struct S_FF p0, double p1, float p2) ;
+EXPORT struct S_FD f18_S_SDF_FD(struct S_FD p0, double p1, float p2) ;
+EXPORT struct S_FP f18_S_SDF_FP(struct S_FP p0, double p1, float p2) ;
+EXPORT struct S_DI f18_S_SDF_DI(struct S_DI p0, double p1, float p2) ;
+EXPORT struct S_DF f18_S_SDF_DF(struct S_DF p0, double p1, float p2) ;
+EXPORT struct S_DD f18_S_SDF_DD(struct S_DD p0, double p1, float p2) ;
+EXPORT struct S_DP f18_S_SDF_DP(struct S_DP p0, double p1, float p2) ;
+EXPORT struct S_PI f18_S_SDF_PI(struct S_PI p0, double p1, float p2) ;
+EXPORT struct S_PF f18_S_SDF_PF(struct S_PF p0, double p1, float p2) ;
+EXPORT struct S_PD f18_S_SDF_PD(struct S_PD p0, double p1, float p2) ;
+EXPORT struct S_PP f18_S_SDF_PP(struct S_PP p0, double p1, float p2) ;
+EXPORT struct S_III f18_S_SDF_III(struct S_III p0, double p1, float p2) ;
+EXPORT struct S_IIF f18_S_SDF_IIF(struct S_IIF p0, double p1, float p2) ;
+EXPORT struct S_IID f18_S_SDF_IID(struct S_IID p0, double p1, float p2) ;
+EXPORT struct S_IIP f18_S_SDF_IIP(struct S_IIP p0, double p1, float p2) ;
+EXPORT struct S_IFI f18_S_SDF_IFI(struct S_IFI p0, double p1, float p2) ;
+EXPORT struct S_IFF f18_S_SDF_IFF(struct S_IFF p0, double p1, float p2) ;
+EXPORT struct S_IFD f18_S_SDF_IFD(struct S_IFD p0, double p1, float p2) ;
+EXPORT struct S_IFP f18_S_SDF_IFP(struct S_IFP p0, double p1, float p2) ;
+EXPORT struct S_IDI f18_S_SDF_IDI(struct S_IDI p0, double p1, float p2) ;
+EXPORT struct S_IDF f18_S_SDF_IDF(struct S_IDF p0, double p1, float p2) ;
+EXPORT struct S_IDD f18_S_SDF_IDD(struct S_IDD p0, double p1, float p2) ;
+EXPORT struct S_IDP f18_S_SDF_IDP(struct S_IDP p0, double p1, float p2) ;
+EXPORT struct S_IPI f18_S_SDF_IPI(struct S_IPI p0, double p1, float p2) ;
+EXPORT struct S_IPF f18_S_SDF_IPF(struct S_IPF p0, double p1, float p2) ;
+EXPORT struct S_IPD f18_S_SDF_IPD(struct S_IPD p0, double p1, float p2) ;
+EXPORT struct S_IPP f18_S_SDF_IPP(struct S_IPP p0, double p1, float p2) ;
+EXPORT struct S_FII f18_S_SDF_FII(struct S_FII p0, double p1, float p2) ;
+EXPORT struct S_FIF f18_S_SDF_FIF(struct S_FIF p0, double p1, float p2) ;
+EXPORT struct S_FID f18_S_SDF_FID(struct S_FID p0, double p1, float p2) ;
+EXPORT struct S_FIP f18_S_SDF_FIP(struct S_FIP p0, double p1, float p2) ;
+EXPORT struct S_FFI f18_S_SDF_FFI(struct S_FFI p0, double p1, float p2) ;
+EXPORT struct S_FFF f18_S_SDF_FFF(struct S_FFF p0, double p1, float p2) ;
+EXPORT struct S_FFD f18_S_SDF_FFD(struct S_FFD p0, double p1, float p2) ;
+EXPORT struct S_FFP f18_S_SDF_FFP(struct S_FFP p0, double p1, float p2) ;
+EXPORT struct S_FDI f18_S_SDF_FDI(struct S_FDI p0, double p1, float p2) ;
+EXPORT struct S_FDF f18_S_SDF_FDF(struct S_FDF p0, double p1, float p2) ;
+EXPORT struct S_FDD f18_S_SDF_FDD(struct S_FDD p0, double p1, float p2) ;
+EXPORT struct S_FDP f18_S_SDF_FDP(struct S_FDP p0, double p1, float p2) ;
+EXPORT struct S_FPI f18_S_SDF_FPI(struct S_FPI p0, double p1, float p2) ;
+EXPORT struct S_FPF f18_S_SDF_FPF(struct S_FPF p0, double p1, float p2) ;
+EXPORT struct S_FPD f18_S_SDF_FPD(struct S_FPD p0, double p1, float p2) ;
+EXPORT struct S_FPP f18_S_SDF_FPP(struct S_FPP p0, double p1, float p2) ;
+EXPORT struct S_DII f18_S_SDF_DII(struct S_DII p0, double p1, float p2) ;
+EXPORT struct S_DIF f18_S_SDF_DIF(struct S_DIF p0, double p1, float p2) ;
+EXPORT struct S_DID f18_S_SDF_DID(struct S_DID p0, double p1, float p2) ;
+EXPORT struct S_DIP f18_S_SDF_DIP(struct S_DIP p0, double p1, float p2) ;
+EXPORT struct S_DFI f18_S_SDF_DFI(struct S_DFI p0, double p1, float p2) ;
+EXPORT struct S_DFF f18_S_SDF_DFF(struct S_DFF p0, double p1, float p2) ;
+EXPORT struct S_DFD f18_S_SDF_DFD(struct S_DFD p0, double p1, float p2) ;
+EXPORT struct S_DFP f18_S_SDF_DFP(struct S_DFP p0, double p1, float p2) ;
+EXPORT struct S_DDI f18_S_SDF_DDI(struct S_DDI p0, double p1, float p2) ;
+EXPORT struct S_DDF f18_S_SDF_DDF(struct S_DDF p0, double p1, float p2) ;
+EXPORT struct S_DDD f18_S_SDF_DDD(struct S_DDD p0, double p1, float p2) ;
+EXPORT struct S_DDP f18_S_SDF_DDP(struct S_DDP p0, double p1, float p2) ;
+EXPORT struct S_DPI f18_S_SDF_DPI(struct S_DPI p0, double p1, float p2) ;
+EXPORT struct S_DPF f18_S_SDF_DPF(struct S_DPF p0, double p1, float p2) ;
+EXPORT struct S_DPD f18_S_SDF_DPD(struct S_DPD p0, double p1, float p2) ;
+EXPORT struct S_DPP f18_S_SDF_DPP(struct S_DPP p0, double p1, float p2) ;
+EXPORT struct S_PII f18_S_SDF_PII(struct S_PII p0, double p1, float p2) ;
+EXPORT struct S_PIF f18_S_SDF_PIF(struct S_PIF p0, double p1, float p2) ;
+EXPORT struct S_PID f18_S_SDF_PID(struct S_PID p0, double p1, float p2) ;
+EXPORT struct S_PIP f18_S_SDF_PIP(struct S_PIP p0, double p1, float p2) ;
+EXPORT struct S_PFI f18_S_SDF_PFI(struct S_PFI p0, double p1, float p2) ;
+EXPORT struct S_PFF f18_S_SDF_PFF(struct S_PFF p0, double p1, float p2) ;
+EXPORT struct S_PFD f18_S_SDF_PFD(struct S_PFD p0, double p1, float p2) ;
+EXPORT struct S_PFP f18_S_SDF_PFP(struct S_PFP p0, double p1, float p2) ;
+EXPORT struct S_PDI f18_S_SDF_PDI(struct S_PDI p0, double p1, float p2) ;
+EXPORT struct S_PDF f18_S_SDF_PDF(struct S_PDF p0, double p1, float p2) ;
+EXPORT struct S_PDD f18_S_SDF_PDD(struct S_PDD p0, double p1, float p2) ;
+EXPORT struct S_PDP f18_S_SDF_PDP(struct S_PDP p0, double p1, float p2) ;
+EXPORT struct S_PPI f18_S_SDF_PPI(struct S_PPI p0, double p1, float p2) ;
+EXPORT struct S_PPF f18_S_SDF_PPF(struct S_PPF p0, double p1, float p2) ;
+EXPORT struct S_PPD f18_S_SDF_PPD(struct S_PPD p0, double p1, float p2) ;
+EXPORT struct S_PPP f18_S_SDF_PPP(struct S_PPP p0, double p1, float p2) ;
+EXPORT struct S_I f18_S_SDD_I(struct S_I p0, double p1, double p2) ;
+EXPORT struct S_F f18_S_SDD_F(struct S_F p0, double p1, double p2) ;
+EXPORT struct S_D f18_S_SDD_D(struct S_D p0, double p1, double p2) ;
+EXPORT struct S_P f18_S_SDD_P(struct S_P p0, double p1, double p2) ;
+EXPORT struct S_II f18_S_SDD_II(struct S_II p0, double p1, double p2) ;
+EXPORT struct S_IF f18_S_SDD_IF(struct S_IF p0, double p1, double p2) ;
+EXPORT struct S_ID f18_S_SDD_ID(struct S_ID p0, double p1, double p2) ;
+EXPORT struct S_IP f18_S_SDD_IP(struct S_IP p0, double p1, double p2) ;
+EXPORT struct S_FI f18_S_SDD_FI(struct S_FI p0, double p1, double p2) ;
+EXPORT struct S_FF f18_S_SDD_FF(struct S_FF p0, double p1, double p2) ;
+EXPORT struct S_FD f18_S_SDD_FD(struct S_FD p0, double p1, double p2) ;
+EXPORT struct S_FP f18_S_SDD_FP(struct S_FP p0, double p1, double p2) ;
+EXPORT struct S_DI f18_S_SDD_DI(struct S_DI p0, double p1, double p2) ;
+EXPORT struct S_DF f18_S_SDD_DF(struct S_DF p0, double p1, double p2) ;
+EXPORT struct S_DD f18_S_SDD_DD(struct S_DD p0, double p1, double p2) ;
+EXPORT struct S_DP f18_S_SDD_DP(struct S_DP p0, double p1, double p2) ;
+EXPORT struct S_PI f18_S_SDD_PI(struct S_PI p0, double p1, double p2) ;
+EXPORT struct S_PF f18_S_SDD_PF(struct S_PF p0, double p1, double p2) ;
+EXPORT struct S_PD f18_S_SDD_PD(struct S_PD p0, double p1, double p2) ;
+EXPORT struct S_PP f18_S_SDD_PP(struct S_PP p0, double p1, double p2) ;
+EXPORT struct S_III f18_S_SDD_III(struct S_III p0, double p1, double p2) ;
+EXPORT struct S_IIF f18_S_SDD_IIF(struct S_IIF p0, double p1, double p2) ;
+EXPORT struct S_IID f18_S_SDD_IID(struct S_IID p0, double p1, double p2) ;
+EXPORT struct S_IIP f18_S_SDD_IIP(struct S_IIP p0, double p1, double p2) ;
+EXPORT struct S_IFI f18_S_SDD_IFI(struct S_IFI p0, double p1, double p2) ;
+EXPORT struct S_IFF f18_S_SDD_IFF(struct S_IFF p0, double p1, double p2) ;
+EXPORT struct S_IFD f18_S_SDD_IFD(struct S_IFD p0, double p1, double p2) ;
+EXPORT struct S_IFP f18_S_SDD_IFP(struct S_IFP p0, double p1, double p2) ;
+EXPORT struct S_IDI f18_S_SDD_IDI(struct S_IDI p0, double p1, double p2) ;
+EXPORT struct S_IDF f18_S_SDD_IDF(struct S_IDF p0, double p1, double p2) ;
+EXPORT struct S_IDD f18_S_SDD_IDD(struct S_IDD p0, double p1, double p2) ;
+EXPORT struct S_IDP f18_S_SDD_IDP(struct S_IDP p0, double p1, double p2) ;
+EXPORT struct S_IPI f18_S_SDD_IPI(struct S_IPI p0, double p1, double p2) ;
+EXPORT struct S_IPF f18_S_SDD_IPF(struct S_IPF p0, double p1, double p2) ;
+EXPORT struct S_IPD f18_S_SDD_IPD(struct S_IPD p0, double p1, double p2) ;
+EXPORT struct S_IPP f18_S_SDD_IPP(struct S_IPP p0, double p1, double p2) ;
+EXPORT struct S_FII f18_S_SDD_FII(struct S_FII p0, double p1, double p2) ;
+EXPORT struct S_FIF f18_S_SDD_FIF(struct S_FIF p0, double p1, double p2) ;
+EXPORT struct S_FID f18_S_SDD_FID(struct S_FID p0, double p1, double p2) ;
+EXPORT struct S_FIP f18_S_SDD_FIP(struct S_FIP p0, double p1, double p2) ;
+EXPORT struct S_FFI f18_S_SDD_FFI(struct S_FFI p0, double p1, double p2) ;
+EXPORT struct S_FFF f18_S_SDD_FFF(struct S_FFF p0, double p1, double p2) ;
+EXPORT struct S_FFD f18_S_SDD_FFD(struct S_FFD p0, double p1, double p2) ;
+EXPORT struct S_FFP f18_S_SDD_FFP(struct S_FFP p0, double p1, double p2) ;
+EXPORT struct S_FDI f18_S_SDD_FDI(struct S_FDI p0, double p1, double p2) ;
+EXPORT struct S_FDF f18_S_SDD_FDF(struct S_FDF p0, double p1, double p2) ;
+EXPORT struct S_FDD f18_S_SDD_FDD(struct S_FDD p0, double p1, double p2) ;
+EXPORT struct S_FDP f18_S_SDD_FDP(struct S_FDP p0, double p1, double p2) ;
+EXPORT struct S_FPI f18_S_SDD_FPI(struct S_FPI p0, double p1, double p2) ;
+EXPORT struct S_FPF f18_S_SDD_FPF(struct S_FPF p0, double p1, double p2) ;
+EXPORT struct S_FPD f18_S_SDD_FPD(struct S_FPD p0, double p1, double p2) ;
+EXPORT struct S_FPP f18_S_SDD_FPP(struct S_FPP p0, double p1, double p2) ;
+EXPORT struct S_DII f18_S_SDD_DII(struct S_DII p0, double p1, double p2) ;
+EXPORT struct S_DIF f18_S_SDD_DIF(struct S_DIF p0, double p1, double p2) ;
+EXPORT struct S_DID f18_S_SDD_DID(struct S_DID p0, double p1, double p2) ;
+EXPORT struct S_DIP f18_S_SDD_DIP(struct S_DIP p0, double p1, double p2) ;
+EXPORT struct S_DFI f18_S_SDD_DFI(struct S_DFI p0, double p1, double p2) ;
+EXPORT struct S_DFF f18_S_SDD_DFF(struct S_DFF p0, double p1, double p2) ;
+EXPORT struct S_DFD f18_S_SDD_DFD(struct S_DFD p0, double p1, double p2) ;
+EXPORT struct S_DFP f18_S_SDD_DFP(struct S_DFP p0, double p1, double p2) ;
+EXPORT struct S_DDI f18_S_SDD_DDI(struct S_DDI p0, double p1, double p2) ;
+EXPORT struct S_DDF f18_S_SDD_DDF(struct S_DDF p0, double p1, double p2) ;
+EXPORT struct S_DDD f18_S_SDD_DDD(struct S_DDD p0, double p1, double p2) ;
+EXPORT struct S_DDP f18_S_SDD_DDP(struct S_DDP p0, double p1, double p2) ;
+EXPORT struct S_DPI f18_S_SDD_DPI(struct S_DPI p0, double p1, double p2) ;
+EXPORT struct S_DPF f18_S_SDD_DPF(struct S_DPF p0, double p1, double p2) ;
+EXPORT struct S_DPD f18_S_SDD_DPD(struct S_DPD p0, double p1, double p2) ;
+EXPORT struct S_DPP f18_S_SDD_DPP(struct S_DPP p0, double p1, double p2) ;
+EXPORT struct S_PII f18_S_SDD_PII(struct S_PII p0, double p1, double p2) ;
+EXPORT struct S_PIF f18_S_SDD_PIF(struct S_PIF p0, double p1, double p2) ;
+EXPORT struct S_PID f18_S_SDD_PID(struct S_PID p0, double p1, double p2) ;
+EXPORT struct S_PIP f18_S_SDD_PIP(struct S_PIP p0, double p1, double p2) ;
+EXPORT struct S_PFI f18_S_SDD_PFI(struct S_PFI p0, double p1, double p2) ;
+EXPORT struct S_PFF f18_S_SDD_PFF(struct S_PFF p0, double p1, double p2) ;
+EXPORT struct S_PFD f18_S_SDD_PFD(struct S_PFD p0, double p1, double p2) ;
+EXPORT struct S_PFP f18_S_SDD_PFP(struct S_PFP p0, double p1, double p2) ;
+EXPORT struct S_PDI f18_S_SDD_PDI(struct S_PDI p0, double p1, double p2) ;
+EXPORT struct S_PDF f18_S_SDD_PDF(struct S_PDF p0, double p1, double p2) ;
+EXPORT struct S_PDD f18_S_SDD_PDD(struct S_PDD p0, double p1, double p2) ;
+EXPORT struct S_PDP f18_S_SDD_PDP(struct S_PDP p0, double p1, double p2) ;
+EXPORT struct S_PPI f18_S_SDD_PPI(struct S_PPI p0, double p1, double p2) ;
+EXPORT struct S_PPF f18_S_SDD_PPF(struct S_PPF p0, double p1, double p2) ;
+EXPORT struct S_PPD f18_S_SDD_PPD(struct S_PPD p0, double p1, double p2) ;
+EXPORT struct S_PPP f18_S_SDD_PPP(struct S_PPP p0, double p1, double p2) ;
+EXPORT struct S_I f18_S_SDP_I(struct S_I p0, double p1, void* p2) ;
+EXPORT struct S_F f18_S_SDP_F(struct S_F p0, double p1, void* p2) ;
+EXPORT struct S_D f18_S_SDP_D(struct S_D p0, double p1, void* p2) ;
+EXPORT struct S_P f18_S_SDP_P(struct S_P p0, double p1, void* p2) ;
+EXPORT struct S_II f18_S_SDP_II(struct S_II p0, double p1, void* p2) ;
+EXPORT struct S_IF f18_S_SDP_IF(struct S_IF p0, double p1, void* p2) ;
+EXPORT struct S_ID f18_S_SDP_ID(struct S_ID p0, double p1, void* p2) ;
+EXPORT struct S_IP f18_S_SDP_IP(struct S_IP p0, double p1, void* p2) ;
+EXPORT struct S_FI f18_S_SDP_FI(struct S_FI p0, double p1, void* p2) ;
+EXPORT struct S_FF f18_S_SDP_FF(struct S_FF p0, double p1, void* p2) ;
+EXPORT struct S_FD f18_S_SDP_FD(struct S_FD p0, double p1, void* p2) ;
+EXPORT struct S_FP f18_S_SDP_FP(struct S_FP p0, double p1, void* p2) ;
+EXPORT struct S_DI f18_S_SDP_DI(struct S_DI p0, double p1, void* p2) ;
+EXPORT struct S_DF f18_S_SDP_DF(struct S_DF p0, double p1, void* p2) ;
+EXPORT struct S_DD f18_S_SDP_DD(struct S_DD p0, double p1, void* p2) ;
+EXPORT struct S_DP f18_S_SDP_DP(struct S_DP p0, double p1, void* p2) ;
+EXPORT struct S_PI f18_S_SDP_PI(struct S_PI p0, double p1, void* p2) ;
+EXPORT struct S_PF f18_S_SDP_PF(struct S_PF p0, double p1, void* p2) ;
+EXPORT struct S_PD f18_S_SDP_PD(struct S_PD p0, double p1, void* p2) ;
+EXPORT struct S_PP f18_S_SDP_PP(struct S_PP p0, double p1, void* p2) ;
+EXPORT struct S_III f18_S_SDP_III(struct S_III p0, double p1, void* p2) ;
+EXPORT struct S_IIF f18_S_SDP_IIF(struct S_IIF p0, double p1, void* p2) ;
+EXPORT struct S_IID f18_S_SDP_IID(struct S_IID p0, double p1, void* p2) ;
+EXPORT struct S_IIP f18_S_SDP_IIP(struct S_IIP p0, double p1, void* p2) ;
+EXPORT struct S_IFI f18_S_SDP_IFI(struct S_IFI p0, double p1, void* p2) ;
+EXPORT struct S_IFF f18_S_SDP_IFF(struct S_IFF p0, double p1, void* p2) ;
+EXPORT struct S_IFD f18_S_SDP_IFD(struct S_IFD p0, double p1, void* p2) ;
+EXPORT struct S_IFP f18_S_SDP_IFP(struct S_IFP p0, double p1, void* p2) ;
+EXPORT struct S_IDI f18_S_SDP_IDI(struct S_IDI p0, double p1, void* p2) ;
+EXPORT struct S_IDF f18_S_SDP_IDF(struct S_IDF p0, double p1, void* p2) ;
+EXPORT struct S_IDD f18_S_SDP_IDD(struct S_IDD p0, double p1, void* p2) ;
+EXPORT struct S_IDP f18_S_SDP_IDP(struct S_IDP p0, double p1, void* p2) ;
+EXPORT struct S_IPI f18_S_SDP_IPI(struct S_IPI p0, double p1, void* p2) ;
+EXPORT struct S_IPF f18_S_SDP_IPF(struct S_IPF p0, double p1, void* p2) ;
+EXPORT struct S_IPD f18_S_SDP_IPD(struct S_IPD p0, double p1, void* p2) ;
+EXPORT struct S_IPP f18_S_SDP_IPP(struct S_IPP p0, double p1, void* p2) ;
+EXPORT struct S_FII f18_S_SDP_FII(struct S_FII p0, double p1, void* p2) ;
+EXPORT struct S_FIF f18_S_SDP_FIF(struct S_FIF p0, double p1, void* p2) ;
+EXPORT struct S_FID f18_S_SDP_FID(struct S_FID p0, double p1, void* p2) ;
+EXPORT struct S_FIP f18_S_SDP_FIP(struct S_FIP p0, double p1, void* p2) ;
+EXPORT struct S_FFI f18_S_SDP_FFI(struct S_FFI p0, double p1, void* p2) ;
+EXPORT struct S_FFF f18_S_SDP_FFF(struct S_FFF p0, double p1, void* p2) ;
+EXPORT struct S_FFD f18_S_SDP_FFD(struct S_FFD p0, double p1, void* p2) ;
+EXPORT struct S_FFP f18_S_SDP_FFP(struct S_FFP p0, double p1, void* p2) ;
+EXPORT struct S_FDI f18_S_SDP_FDI(struct S_FDI p0, double p1, void* p2) ;
+EXPORT struct S_FDF f18_S_SDP_FDF(struct S_FDF p0, double p1, void* p2) ;
+EXPORT struct S_FDD f18_S_SDP_FDD(struct S_FDD p0, double p1, void* p2) ;
+EXPORT struct S_FDP f18_S_SDP_FDP(struct S_FDP p0, double p1, void* p2) ;
+EXPORT struct S_FPI f18_S_SDP_FPI(struct S_FPI p0, double p1, void* p2) ;
+EXPORT struct S_FPF f18_S_SDP_FPF(struct S_FPF p0, double p1, void* p2) ;
+EXPORT struct S_FPD f18_S_SDP_FPD(struct S_FPD p0, double p1, void* p2) ;
+EXPORT struct S_FPP f18_S_SDP_FPP(struct S_FPP p0, double p1, void* p2) ;
+EXPORT struct S_DII f18_S_SDP_DII(struct S_DII p0, double p1, void* p2) ;
+EXPORT struct S_DIF f18_S_SDP_DIF(struct S_DIF p0, double p1, void* p2) ;
+EXPORT struct S_DID f18_S_SDP_DID(struct S_DID p0, double p1, void* p2) ;
+EXPORT struct S_DIP f18_S_SDP_DIP(struct S_DIP p0, double p1, void* p2) ;
+EXPORT struct S_DFI f18_S_SDP_DFI(struct S_DFI p0, double p1, void* p2) ;
+EXPORT struct S_DFF f18_S_SDP_DFF(struct S_DFF p0, double p1, void* p2) ;
+EXPORT struct S_DFD f18_S_SDP_DFD(struct S_DFD p0, double p1, void* p2) ;
+EXPORT struct S_DFP f18_S_SDP_DFP(struct S_DFP p0, double p1, void* p2) ;
+EXPORT struct S_DDI f18_S_SDP_DDI(struct S_DDI p0, double p1, void* p2) ;
+EXPORT struct S_DDF f18_S_SDP_DDF(struct S_DDF p0, double p1, void* p2) ;
+EXPORT struct S_DDD f18_S_SDP_DDD(struct S_DDD p0, double p1, void* p2) ;
+EXPORT struct S_DDP f18_S_SDP_DDP(struct S_DDP p0, double p1, void* p2) ;
+EXPORT struct S_DPI f18_S_SDP_DPI(struct S_DPI p0, double p1, void* p2) ;
+EXPORT struct S_DPF f18_S_SDP_DPF(struct S_DPF p0, double p1, void* p2) ;
+EXPORT struct S_DPD f18_S_SDP_DPD(struct S_DPD p0, double p1, void* p2) ;
+EXPORT struct S_DPP f18_S_SDP_DPP(struct S_DPP p0, double p1, void* p2) ;
+EXPORT struct S_PII f18_S_SDP_PII(struct S_PII p0, double p1, void* p2) ;
+EXPORT struct S_PIF f18_S_SDP_PIF(struct S_PIF p0, double p1, void* p2) ;
+EXPORT struct S_PID f18_S_SDP_PID(struct S_PID p0, double p1, void* p2) ;
+EXPORT struct S_PIP f18_S_SDP_PIP(struct S_PIP p0, double p1, void* p2) ;
+EXPORT struct S_PFI f18_S_SDP_PFI(struct S_PFI p0, double p1, void* p2) ;
+EXPORT struct S_PFF f18_S_SDP_PFF(struct S_PFF p0, double p1, void* p2) ;
+EXPORT struct S_PFD f18_S_SDP_PFD(struct S_PFD p0, double p1, void* p2) ;
+EXPORT struct S_PFP f18_S_SDP_PFP(struct S_PFP p0, double p1, void* p2) ;
+EXPORT struct S_PDI f18_S_SDP_PDI(struct S_PDI p0, double p1, void* p2) ;
+EXPORT struct S_PDF f18_S_SDP_PDF(struct S_PDF p0, double p1, void* p2) ;
+EXPORT struct S_PDD f18_S_SDP_PDD(struct S_PDD p0, double p1, void* p2) ;
+EXPORT struct S_PDP f18_S_SDP_PDP(struct S_PDP p0, double p1, void* p2) ;
+EXPORT struct S_PPI f18_S_SDP_PPI(struct S_PPI p0, double p1, void* p2) ;
+EXPORT struct S_PPF f18_S_SDP_PPF(struct S_PPF p0, double p1, void* p2) ;
+EXPORT struct S_PPD f18_S_SDP_PPD(struct S_PPD p0, double p1, void* p2) ;
+EXPORT struct S_PPP f18_S_SDP_PPP(struct S_PPP p0, double p1, void* p2) ;
+EXPORT struct S_I f18_S_SDS_I(struct S_I p0, double p1, struct S_I p2) ;
+EXPORT struct S_F f18_S_SDS_F(struct S_F p0, double p1, struct S_F p2) ;
+EXPORT struct S_D f18_S_SDS_D(struct S_D p0, double p1, struct S_D p2) ;
+EXPORT struct S_P f18_S_SDS_P(struct S_P p0, double p1, struct S_P p2) ;
+EXPORT struct S_II f18_S_SDS_II(struct S_II p0, double p1, struct S_II p2) ;
+EXPORT struct S_IF f18_S_SDS_IF(struct S_IF p0, double p1, struct S_IF p2) ;
+EXPORT struct S_ID f18_S_SDS_ID(struct S_ID p0, double p1, struct S_ID p2) ;
+EXPORT struct S_IP f18_S_SDS_IP(struct S_IP p0, double p1, struct S_IP p2) ;
+EXPORT struct S_FI f18_S_SDS_FI(struct S_FI p0, double p1, struct S_FI p2) ;
+EXPORT struct S_FF f18_S_SDS_FF(struct S_FF p0, double p1, struct S_FF p2) ;
+EXPORT struct S_FD f18_S_SDS_FD(struct S_FD p0, double p1, struct S_FD p2) ;
+EXPORT struct S_FP f18_S_SDS_FP(struct S_FP p0, double p1, struct S_FP p2) ;
+EXPORT struct S_DI f18_S_SDS_DI(struct S_DI p0, double p1, struct S_DI p2) ;
+EXPORT struct S_DF f18_S_SDS_DF(struct S_DF p0, double p1, struct S_DF p2) ;
+EXPORT struct S_DD f18_S_SDS_DD(struct S_DD p0, double p1, struct S_DD p2) ;
+EXPORT struct S_DP f18_S_SDS_DP(struct S_DP p0, double p1, struct S_DP p2) ;
+EXPORT struct S_PI f18_S_SDS_PI(struct S_PI p0, double p1, struct S_PI p2) ;
+EXPORT struct S_PF f18_S_SDS_PF(struct S_PF p0, double p1, struct S_PF p2) ;
+EXPORT struct S_PD f18_S_SDS_PD(struct S_PD p0, double p1, struct S_PD p2) ;
+EXPORT struct S_PP f18_S_SDS_PP(struct S_PP p0, double p1, struct S_PP p2) ;
+EXPORT struct S_III f18_S_SDS_III(struct S_III p0, double p1, struct S_III p2) ;
+EXPORT struct S_IIF f18_S_SDS_IIF(struct S_IIF p0, double p1, struct S_IIF p2) ;
+EXPORT struct S_IID f18_S_SDS_IID(struct S_IID p0, double p1, struct S_IID p2) ;
+EXPORT struct S_IIP f18_S_SDS_IIP(struct S_IIP p0, double p1, struct S_IIP p2) ;
+EXPORT struct S_IFI f18_S_SDS_IFI(struct S_IFI p0, double p1, struct S_IFI p2) ;
+EXPORT struct S_IFF f18_S_SDS_IFF(struct S_IFF p0, double p1, struct S_IFF p2) ;
+EXPORT struct S_IFD f18_S_SDS_IFD(struct S_IFD p0, double p1, struct S_IFD p2) ;
+EXPORT struct S_IFP f18_S_SDS_IFP(struct S_IFP p0, double p1, struct S_IFP p2) ;
+EXPORT struct S_IDI f18_S_SDS_IDI(struct S_IDI p0, double p1, struct S_IDI p2) ;
+EXPORT struct S_IDF f18_S_SDS_IDF(struct S_IDF p0, double p1, struct S_IDF p2) ;
+EXPORT struct S_IDD f18_S_SDS_IDD(struct S_IDD p0, double p1, struct S_IDD p2) ;
+EXPORT struct S_IDP f18_S_SDS_IDP(struct S_IDP p0, double p1, struct S_IDP p2) ;
+EXPORT struct S_IPI f18_S_SDS_IPI(struct S_IPI p0, double p1, struct S_IPI p2) ;
+EXPORT struct S_IPF f18_S_SDS_IPF(struct S_IPF p0, double p1, struct S_IPF p2) ;
+EXPORT struct S_IPD f18_S_SDS_IPD(struct S_IPD p0, double p1, struct S_IPD p2) ;
+EXPORT struct S_IPP f18_S_SDS_IPP(struct S_IPP p0, double p1, struct S_IPP p2) ;
+EXPORT struct S_FII f18_S_SDS_FII(struct S_FII p0, double p1, struct S_FII p2) ;
+EXPORT struct S_FIF f18_S_SDS_FIF(struct S_FIF p0, double p1, struct S_FIF p2) ;
+EXPORT struct S_FID f18_S_SDS_FID(struct S_FID p0, double p1, struct S_FID p2) ;
+EXPORT struct S_FIP f18_S_SDS_FIP(struct S_FIP p0, double p1, struct S_FIP p2) ;
+EXPORT struct S_FFI f18_S_SDS_FFI(struct S_FFI p0, double p1, struct S_FFI p2) ;
+EXPORT struct S_FFF f18_S_SDS_FFF(struct S_FFF p0, double p1, struct S_FFF p2) ;
+EXPORT struct S_FFD f18_S_SDS_FFD(struct S_FFD p0, double p1, struct S_FFD p2) ;
+EXPORT struct S_FFP f18_S_SDS_FFP(struct S_FFP p0, double p1, struct S_FFP p2) ;
+EXPORT struct S_FDI f18_S_SDS_FDI(struct S_FDI p0, double p1, struct S_FDI p2) ;
+EXPORT struct S_FDF f18_S_SDS_FDF(struct S_FDF p0, double p1, struct S_FDF p2) ;
+EXPORT struct S_FDD f18_S_SDS_FDD(struct S_FDD p0, double p1, struct S_FDD p2) ;
+EXPORT struct S_FDP f18_S_SDS_FDP(struct S_FDP p0, double p1, struct S_FDP p2) ;
+EXPORT struct S_FPI f18_S_SDS_FPI(struct S_FPI p0, double p1, struct S_FPI p2) ;
+EXPORT struct S_FPF f18_S_SDS_FPF(struct S_FPF p0, double p1, struct S_FPF p2) ;
+EXPORT struct S_FPD f18_S_SDS_FPD(struct S_FPD p0, double p1, struct S_FPD p2) ;
+EXPORT struct S_FPP f18_S_SDS_FPP(struct S_FPP p0, double p1, struct S_FPP p2) ;
+EXPORT struct S_DII f18_S_SDS_DII(struct S_DII p0, double p1, struct S_DII p2) ;
+EXPORT struct S_DIF f18_S_SDS_DIF(struct S_DIF p0, double p1, struct S_DIF p2) ;
+EXPORT struct S_DID f18_S_SDS_DID(struct S_DID p0, double p1, struct S_DID p2) ;
+EXPORT struct S_DIP f18_S_SDS_DIP(struct S_DIP p0, double p1, struct S_DIP p2) ;
+EXPORT struct S_DFI f18_S_SDS_DFI(struct S_DFI p0, double p1, struct S_DFI p2) ;
+EXPORT struct S_DFF f18_S_SDS_DFF(struct S_DFF p0, double p1, struct S_DFF p2) ;
+EXPORT struct S_DFD f18_S_SDS_DFD(struct S_DFD p0, double p1, struct S_DFD p2) ;
+EXPORT struct S_DFP f18_S_SDS_DFP(struct S_DFP p0, double p1, struct S_DFP p2) ;
+EXPORT struct S_DDI f18_S_SDS_DDI(struct S_DDI p0, double p1, struct S_DDI p2) ;
+EXPORT struct S_DDF f18_S_SDS_DDF(struct S_DDF p0, double p1, struct S_DDF p2) ;
+EXPORT struct S_DDD f18_S_SDS_DDD(struct S_DDD p0, double p1, struct S_DDD p2) ;
+EXPORT struct S_DDP f18_S_SDS_DDP(struct S_DDP p0, double p1, struct S_DDP p2) ;
+EXPORT struct S_DPI f18_S_SDS_DPI(struct S_DPI p0, double p1, struct S_DPI p2) ;
+EXPORT struct S_DPF f18_S_SDS_DPF(struct S_DPF p0, double p1, struct S_DPF p2) ;
+EXPORT struct S_DPD f18_S_SDS_DPD(struct S_DPD p0, double p1, struct S_DPD p2) ;
+EXPORT struct S_DPP f18_S_SDS_DPP(struct S_DPP p0, double p1, struct S_DPP p2) ;
+EXPORT struct S_PII f18_S_SDS_PII(struct S_PII p0, double p1, struct S_PII p2) ;
+EXPORT struct S_PIF f18_S_SDS_PIF(struct S_PIF p0, double p1, struct S_PIF p2) ;
+EXPORT struct S_PID f18_S_SDS_PID(struct S_PID p0, double p1, struct S_PID p2) ;
+EXPORT struct S_PIP f18_S_SDS_PIP(struct S_PIP p0, double p1, struct S_PIP p2) ;
+EXPORT struct S_PFI f18_S_SDS_PFI(struct S_PFI p0, double p1, struct S_PFI p2) ;
+EXPORT struct S_PFF f18_S_SDS_PFF(struct S_PFF p0, double p1, struct S_PFF p2) ;
+EXPORT struct S_PFD f18_S_SDS_PFD(struct S_PFD p0, double p1, struct S_PFD p2) ;
+EXPORT struct S_PFP f18_S_SDS_PFP(struct S_PFP p0, double p1, struct S_PFP p2) ;
+EXPORT struct S_PDI f18_S_SDS_PDI(struct S_PDI p0, double p1, struct S_PDI p2) ;
+EXPORT struct S_PDF f18_S_SDS_PDF(struct S_PDF p0, double p1, struct S_PDF p2) ;
+EXPORT struct S_PDD f18_S_SDS_PDD(struct S_PDD p0, double p1, struct S_PDD p2) ;
+EXPORT struct S_PDP f18_S_SDS_PDP(struct S_PDP p0, double p1, struct S_PDP p2) ;
+EXPORT struct S_PPI f18_S_SDS_PPI(struct S_PPI p0, double p1, struct S_PPI p2) ;
+EXPORT struct S_PPF f18_S_SDS_PPF(struct S_PPF p0, double p1, struct S_PPF p2) ;
+EXPORT struct S_PPD f18_S_SDS_PPD(struct S_PPD p0, double p1, struct S_PPD p2) ;
+EXPORT struct S_PPP f18_S_SDS_PPP(struct S_PPP p0, double p1, struct S_PPP p2) ;
+EXPORT struct S_I f18_S_SPI_I(struct S_I p0, void* p1, int p2) ;
+EXPORT struct S_F f18_S_SPI_F(struct S_F p0, void* p1, int p2) ;
+EXPORT struct S_D f18_S_SPI_D(struct S_D p0, void* p1, int p2) ;
+EXPORT struct S_P f18_S_SPI_P(struct S_P p0, void* p1, int p2) ;
+EXPORT struct S_II f18_S_SPI_II(struct S_II p0, void* p1, int p2) ;
+EXPORT struct S_IF f18_S_SPI_IF(struct S_IF p0, void* p1, int p2) ;
+EXPORT struct S_ID f18_S_SPI_ID(struct S_ID p0, void* p1, int p2) ;
+EXPORT struct S_IP f18_S_SPI_IP(struct S_IP p0, void* p1, int p2) ;
+EXPORT struct S_FI f18_S_SPI_FI(struct S_FI p0, void* p1, int p2) ;
+EXPORT struct S_FF f18_S_SPI_FF(struct S_FF p0, void* p1, int p2) ;
+EXPORT struct S_FD f18_S_SPI_FD(struct S_FD p0, void* p1, int p2) ;
+EXPORT struct S_FP f18_S_SPI_FP(struct S_FP p0, void* p1, int p2) ;
+EXPORT struct S_DI f18_S_SPI_DI(struct S_DI p0, void* p1, int p2) ;
+EXPORT struct S_DF f18_S_SPI_DF(struct S_DF p0, void* p1, int p2) ;
+EXPORT struct S_DD f18_S_SPI_DD(struct S_DD p0, void* p1, int p2) ;
+EXPORT struct S_DP f18_S_SPI_DP(struct S_DP p0, void* p1, int p2) ;
+EXPORT struct S_PI f18_S_SPI_PI(struct S_PI p0, void* p1, int p2) ;
+EXPORT struct S_PF f18_S_SPI_PF(struct S_PF p0, void* p1, int p2) ;
+EXPORT struct S_PD f18_S_SPI_PD(struct S_PD p0, void* p1, int p2) ;
+EXPORT struct S_PP f18_S_SPI_PP(struct S_PP p0, void* p1, int p2) ;
+EXPORT struct S_III f18_S_SPI_III(struct S_III p0, void* p1, int p2) ;
+EXPORT struct S_IIF f18_S_SPI_IIF(struct S_IIF p0, void* p1, int p2) ;
+EXPORT struct S_IID f18_S_SPI_IID(struct S_IID p0, void* p1, int p2) ;
+EXPORT struct S_IIP f18_S_SPI_IIP(struct S_IIP p0, void* p1, int p2) ;
+EXPORT struct S_IFI f18_S_SPI_IFI(struct S_IFI p0, void* p1, int p2) ;
+EXPORT struct S_IFF f18_S_SPI_IFF(struct S_IFF p0, void* p1, int p2) ;
+EXPORT struct S_IFD f18_S_SPI_IFD(struct S_IFD p0, void* p1, int p2) ;
+EXPORT struct S_IFP f18_S_SPI_IFP(struct S_IFP p0, void* p1, int p2) ;
+EXPORT struct S_IDI f18_S_SPI_IDI(struct S_IDI p0, void* p1, int p2) ;
+EXPORT struct S_IDF f18_S_SPI_IDF(struct S_IDF p0, void* p1, int p2) ;
+EXPORT struct S_IDD f18_S_SPI_IDD(struct S_IDD p0, void* p1, int p2) ;
+EXPORT struct S_IDP f18_S_SPI_IDP(struct S_IDP p0, void* p1, int p2) ;
+EXPORT struct S_IPI f18_S_SPI_IPI(struct S_IPI p0, void* p1, int p2) ;
+EXPORT struct S_IPF f18_S_SPI_IPF(struct S_IPF p0, void* p1, int p2) ;
+EXPORT struct S_IPD f18_S_SPI_IPD(struct S_IPD p0, void* p1, int p2) ;
+EXPORT struct S_IPP f18_S_SPI_IPP(struct S_IPP p0, void* p1, int p2) ;
+EXPORT struct S_FII f18_S_SPI_FII(struct S_FII p0, void* p1, int p2) ;
+EXPORT struct S_FIF f18_S_SPI_FIF(struct S_FIF p0, void* p1, int p2) ;
+EXPORT struct S_FID f18_S_SPI_FID(struct S_FID p0, void* p1, int p2) ;
+EXPORT struct S_FIP f18_S_SPI_FIP(struct S_FIP p0, void* p1, int p2) ;
+EXPORT struct S_FFI f18_S_SPI_FFI(struct S_FFI p0, void* p1, int p2) ;
+EXPORT struct S_FFF f18_S_SPI_FFF(struct S_FFF p0, void* p1, int p2) ;
+EXPORT struct S_FFD f18_S_SPI_FFD(struct S_FFD p0, void* p1, int p2) ;
+EXPORT struct S_FFP f18_S_SPI_FFP(struct S_FFP p0, void* p1, int p2) ;
+EXPORT struct S_FDI f18_S_SPI_FDI(struct S_FDI p0, void* p1, int p2) ;
+EXPORT struct S_FDF f18_S_SPI_FDF(struct S_FDF p0, void* p1, int p2) ;
+EXPORT struct S_FDD f18_S_SPI_FDD(struct S_FDD p0, void* p1, int p2) ;
+EXPORT struct S_FDP f18_S_SPI_FDP(struct S_FDP p0, void* p1, int p2) ;
+EXPORT struct S_FPI f18_S_SPI_FPI(struct S_FPI p0, void* p1, int p2) ;
+EXPORT struct S_FPF f18_S_SPI_FPF(struct S_FPF p0, void* p1, int p2) ;
+EXPORT struct S_FPD f18_S_SPI_FPD(struct S_FPD p0, void* p1, int p2) ;
+EXPORT struct S_FPP f18_S_SPI_FPP(struct S_FPP p0, void* p1, int p2) ;
+EXPORT struct S_DII f18_S_SPI_DII(struct S_DII p0, void* p1, int p2) ;
+EXPORT struct S_DIF f18_S_SPI_DIF(struct S_DIF p0, void* p1, int p2) ;
+EXPORT struct S_DID f18_S_SPI_DID(struct S_DID p0, void* p1, int p2) ;
+EXPORT struct S_DIP f18_S_SPI_DIP(struct S_DIP p0, void* p1, int p2) ;
+EXPORT struct S_DFI f18_S_SPI_DFI(struct S_DFI p0, void* p1, int p2) ;
+EXPORT struct S_DFF f18_S_SPI_DFF(struct S_DFF p0, void* p1, int p2) ;
+EXPORT struct S_DFD f18_S_SPI_DFD(struct S_DFD p0, void* p1, int p2) ;
+EXPORT struct S_DFP f18_S_SPI_DFP(struct S_DFP p0, void* p1, int p2) ;
+EXPORT struct S_DDI f18_S_SPI_DDI(struct S_DDI p0, void* p1, int p2) ;
+EXPORT struct S_DDF f18_S_SPI_DDF(struct S_DDF p0, void* p1, int p2) ;
+EXPORT struct S_DDD f18_S_SPI_DDD(struct S_DDD p0, void* p1, int p2) ;
+EXPORT struct S_DDP f18_S_SPI_DDP(struct S_DDP p0, void* p1, int p2) ;
+EXPORT struct S_DPI f18_S_SPI_DPI(struct S_DPI p0, void* p1, int p2) ;
+EXPORT struct S_DPF f18_S_SPI_DPF(struct S_DPF p0, void* p1, int p2) ;
+EXPORT struct S_DPD f18_S_SPI_DPD(struct S_DPD p0, void* p1, int p2) ;
+EXPORT struct S_DPP f18_S_SPI_DPP(struct S_DPP p0, void* p1, int p2) ;
+EXPORT struct S_PII f18_S_SPI_PII(struct S_PII p0, void* p1, int p2) ;
+EXPORT struct S_PIF f18_S_SPI_PIF(struct S_PIF p0, void* p1, int p2) ;
+EXPORT struct S_PID f18_S_SPI_PID(struct S_PID p0, void* p1, int p2) ;
+EXPORT struct S_PIP f18_S_SPI_PIP(struct S_PIP p0, void* p1, int p2) ;
+EXPORT struct S_PFI f18_S_SPI_PFI(struct S_PFI p0, void* p1, int p2) ;
+EXPORT struct S_PFF f18_S_SPI_PFF(struct S_PFF p0, void* p1, int p2) ;
+EXPORT struct S_PFD f18_S_SPI_PFD(struct S_PFD p0, void* p1, int p2) ;
+EXPORT struct S_PFP f18_S_SPI_PFP(struct S_PFP p0, void* p1, int p2) ;
+EXPORT struct S_PDI f18_S_SPI_PDI(struct S_PDI p0, void* p1, int p2) ;
+EXPORT struct S_PDF f18_S_SPI_PDF(struct S_PDF p0, void* p1, int p2) ;
+EXPORT struct S_PDD f18_S_SPI_PDD(struct S_PDD p0, void* p1, int p2) ;
+EXPORT struct S_PDP f18_S_SPI_PDP(struct S_PDP p0, void* p1, int p2) ;
+EXPORT struct S_PPI f18_S_SPI_PPI(struct S_PPI p0, void* p1, int p2) ;
+EXPORT struct S_PPF f18_S_SPI_PPF(struct S_PPF p0, void* p1, int p2) ;
+EXPORT struct S_PPD f18_S_SPI_PPD(struct S_PPD p0, void* p1, int p2) ;
+EXPORT struct S_PPP f18_S_SPI_PPP(struct S_PPP p0, void* p1, int p2) ;
+EXPORT struct S_I f18_S_SPF_I(struct S_I p0, void* p1, float p2) ;
+EXPORT struct S_F f18_S_SPF_F(struct S_F p0, void* p1, float p2) ;
+EXPORT struct S_D f18_S_SPF_D(struct S_D p0, void* p1, float p2) ;
+EXPORT struct S_P f18_S_SPF_P(struct S_P p0, void* p1, float p2) ;
+EXPORT struct S_II f18_S_SPF_II(struct S_II p0, void* p1, float p2) ;
+EXPORT struct S_IF f18_S_SPF_IF(struct S_IF p0, void* p1, float p2) ;
+EXPORT struct S_ID f18_S_SPF_ID(struct S_ID p0, void* p1, float p2) ;
+EXPORT struct S_IP f18_S_SPF_IP(struct S_IP p0, void* p1, float p2) ;
+EXPORT struct S_FI f18_S_SPF_FI(struct S_FI p0, void* p1, float p2) ;
+EXPORT struct S_FF f18_S_SPF_FF(struct S_FF p0, void* p1, float p2) ;
+EXPORT struct S_FD f18_S_SPF_FD(struct S_FD p0, void* p1, float p2) ;
+EXPORT struct S_FP f18_S_SPF_FP(struct S_FP p0, void* p1, float p2) ;
+EXPORT struct S_DI f18_S_SPF_DI(struct S_DI p0, void* p1, float p2) ;
+EXPORT struct S_DF f18_S_SPF_DF(struct S_DF p0, void* p1, float p2) ;
+EXPORT struct S_DD f18_S_SPF_DD(struct S_DD p0, void* p1, float p2) ;
+EXPORT struct S_DP f18_S_SPF_DP(struct S_DP p0, void* p1, float p2) ;
+EXPORT struct S_PI f18_S_SPF_PI(struct S_PI p0, void* p1, float p2) ;
+EXPORT struct S_PF f18_S_SPF_PF(struct S_PF p0, void* p1, float p2) ;
+EXPORT struct S_PD f18_S_SPF_PD(struct S_PD p0, void* p1, float p2) ;
+EXPORT struct S_PP f18_S_SPF_PP(struct S_PP p0, void* p1, float p2) ;
+EXPORT struct S_III f18_S_SPF_III(struct S_III p0, void* p1, float p2) ;
+EXPORT struct S_IIF f18_S_SPF_IIF(struct S_IIF p0, void* p1, float p2) ;
+EXPORT struct S_IID f18_S_SPF_IID(struct S_IID p0, void* p1, float p2) ;
+EXPORT struct S_IIP f18_S_SPF_IIP(struct S_IIP p0, void* p1, float p2) ;
+EXPORT struct S_IFI f18_S_SPF_IFI(struct S_IFI p0, void* p1, float p2) ;
+EXPORT struct S_IFF f18_S_SPF_IFF(struct S_IFF p0, void* p1, float p2) ;
+EXPORT struct S_IFD f18_S_SPF_IFD(struct S_IFD p0, void* p1, float p2) ;
+EXPORT struct S_IFP f18_S_SPF_IFP(struct S_IFP p0, void* p1, float p2) ;
+EXPORT struct S_IDI f18_S_SPF_IDI(struct S_IDI p0, void* p1, float p2) ;
+EXPORT struct S_IDF f18_S_SPF_IDF(struct S_IDF p0, void* p1, float p2) ;
+EXPORT struct S_IDD f18_S_SPF_IDD(struct S_IDD p0, void* p1, float p2) ;
+EXPORT struct S_IDP f18_S_SPF_IDP(struct S_IDP p0, void* p1, float p2) ;
+EXPORT struct S_IPI f18_S_SPF_IPI(struct S_IPI p0, void* p1, float p2) ;
+EXPORT struct S_IPF f18_S_SPF_IPF(struct S_IPF p0, void* p1, float p2) ;
+EXPORT struct S_IPD f18_S_SPF_IPD(struct S_IPD p0, void* p1, float p2) ;
+EXPORT struct S_IPP f18_S_SPF_IPP(struct S_IPP p0, void* p1, float p2) ;
+EXPORT struct S_FII f18_S_SPF_FII(struct S_FII p0, void* p1, float p2) ;
+EXPORT struct S_FIF f18_S_SPF_FIF(struct S_FIF p0, void* p1, float p2) ;
+EXPORT struct S_FID f18_S_SPF_FID(struct S_FID p0, void* p1, float p2) ;
+EXPORT struct S_FIP f18_S_SPF_FIP(struct S_FIP p0, void* p1, float p2) ;
+EXPORT struct S_FFI f18_S_SPF_FFI(struct S_FFI p0, void* p1, float p2) ;
+EXPORT struct S_FFF f18_S_SPF_FFF(struct S_FFF p0, void* p1, float p2) ;
+EXPORT struct S_FFD f18_S_SPF_FFD(struct S_FFD p0, void* p1, float p2) ;
+EXPORT struct S_FFP f18_S_SPF_FFP(struct S_FFP p0, void* p1, float p2) ;
+EXPORT struct S_FDI f18_S_SPF_FDI(struct S_FDI p0, void* p1, float p2) ;
+EXPORT struct S_FDF f18_S_SPF_FDF(struct S_FDF p0, void* p1, float p2) ;
+EXPORT struct S_FDD f18_S_SPF_FDD(struct S_FDD p0, void* p1, float p2) ;
+EXPORT struct S_FDP f18_S_SPF_FDP(struct S_FDP p0, void* p1, float p2) ;
+EXPORT struct S_FPI f18_S_SPF_FPI(struct S_FPI p0, void* p1, float p2) ;
+EXPORT struct S_FPF f18_S_SPF_FPF(struct S_FPF p0, void* p1, float p2) ;
+EXPORT struct S_FPD f18_S_SPF_FPD(struct S_FPD p0, void* p1, float p2) ;
+EXPORT struct S_FPP f18_S_SPF_FPP(struct S_FPP p0, void* p1, float p2) ;
+EXPORT struct S_DII f18_S_SPF_DII(struct S_DII p0, void* p1, float p2) ;
+EXPORT struct S_DIF f18_S_SPF_DIF(struct S_DIF p0, void* p1, float p2) ;
+EXPORT struct S_DID f18_S_SPF_DID(struct S_DID p0, void* p1, float p2) ;
+EXPORT struct S_DIP f18_S_SPF_DIP(struct S_DIP p0, void* p1, float p2) ;
+EXPORT struct S_DFI f18_S_SPF_DFI(struct S_DFI p0, void* p1, float p2) ;
+EXPORT struct S_DFF f18_S_SPF_DFF(struct S_DFF p0, void* p1, float p2) ;
+EXPORT struct S_DFD f18_S_SPF_DFD(struct S_DFD p0, void* p1, float p2) ;
+EXPORT struct S_DFP f19_S_SPF_DFP(struct S_DFP p0, void* p1, float p2) ;
+EXPORT struct S_DDI f19_S_SPF_DDI(struct S_DDI p0, void* p1, float p2) ;
+EXPORT struct S_DDF f19_S_SPF_DDF(struct S_DDF p0, void* p1, float p2) ;
+EXPORT struct S_DDD f19_S_SPF_DDD(struct S_DDD p0, void* p1, float p2) ;
+EXPORT struct S_DDP f19_S_SPF_DDP(struct S_DDP p0, void* p1, float p2) ;
+EXPORT struct S_DPI f19_S_SPF_DPI(struct S_DPI p0, void* p1, float p2) ;
+EXPORT struct S_DPF f19_S_SPF_DPF(struct S_DPF p0, void* p1, float p2) ;
+EXPORT struct S_DPD f19_S_SPF_DPD(struct S_DPD p0, void* p1, float p2) ;
+EXPORT struct S_DPP f19_S_SPF_DPP(struct S_DPP p0, void* p1, float p2) ;
+EXPORT struct S_PII f19_S_SPF_PII(struct S_PII p0, void* p1, float p2) ;
+EXPORT struct S_PIF f19_S_SPF_PIF(struct S_PIF p0, void* p1, float p2) ;
+EXPORT struct S_PID f19_S_SPF_PID(struct S_PID p0, void* p1, float p2) ;
+EXPORT struct S_PIP f19_S_SPF_PIP(struct S_PIP p0, void* p1, float p2) ;
+EXPORT struct S_PFI f19_S_SPF_PFI(struct S_PFI p0, void* p1, float p2) ;
+EXPORT struct S_PFF f19_S_SPF_PFF(struct S_PFF p0, void* p1, float p2) ;
+EXPORT struct S_PFD f19_S_SPF_PFD(struct S_PFD p0, void* p1, float p2) ;
+EXPORT struct S_PFP f19_S_SPF_PFP(struct S_PFP p0, void* p1, float p2) ;
+EXPORT struct S_PDI f19_S_SPF_PDI(struct S_PDI p0, void* p1, float p2) ;
+EXPORT struct S_PDF f19_S_SPF_PDF(struct S_PDF p0, void* p1, float p2) ;
+EXPORT struct S_PDD f19_S_SPF_PDD(struct S_PDD p0, void* p1, float p2) ;
+EXPORT struct S_PDP f19_S_SPF_PDP(struct S_PDP p0, void* p1, float p2) ;
+EXPORT struct S_PPI f19_S_SPF_PPI(struct S_PPI p0, void* p1, float p2) ;
+EXPORT struct S_PPF f19_S_SPF_PPF(struct S_PPF p0, void* p1, float p2) ;
+EXPORT struct S_PPD f19_S_SPF_PPD(struct S_PPD p0, void* p1, float p2) ;
+EXPORT struct S_PPP f19_S_SPF_PPP(struct S_PPP p0, void* p1, float p2) ;
+EXPORT struct S_I f19_S_SPD_I(struct S_I p0, void* p1, double p2) ;
+EXPORT struct S_F f19_S_SPD_F(struct S_F p0, void* p1, double p2) ;
+EXPORT struct S_D f19_S_SPD_D(struct S_D p0, void* p1, double p2) ;
+EXPORT struct S_P f19_S_SPD_P(struct S_P p0, void* p1, double p2) ;
+EXPORT struct S_II f19_S_SPD_II(struct S_II p0, void* p1, double p2) ;
+EXPORT struct S_IF f19_S_SPD_IF(struct S_IF p0, void* p1, double p2) ;
+EXPORT struct S_ID f19_S_SPD_ID(struct S_ID p0, void* p1, double p2) ;
+EXPORT struct S_IP f19_S_SPD_IP(struct S_IP p0, void* p1, double p2) ;
+EXPORT struct S_FI f19_S_SPD_FI(struct S_FI p0, void* p1, double p2) ;
+EXPORT struct S_FF f19_S_SPD_FF(struct S_FF p0, void* p1, double p2) ;
+EXPORT struct S_FD f19_S_SPD_FD(struct S_FD p0, void* p1, double p2) ;
+EXPORT struct S_FP f19_S_SPD_FP(struct S_FP p0, void* p1, double p2) ;
+EXPORT struct S_DI f19_S_SPD_DI(struct S_DI p0, void* p1, double p2) ;
+EXPORT struct S_DF f19_S_SPD_DF(struct S_DF p0, void* p1, double p2) ;
+EXPORT struct S_DD f19_S_SPD_DD(struct S_DD p0, void* p1, double p2) ;
+EXPORT struct S_DP f19_S_SPD_DP(struct S_DP p0, void* p1, double p2) ;
+EXPORT struct S_PI f19_S_SPD_PI(struct S_PI p0, void* p1, double p2) ;
+EXPORT struct S_PF f19_S_SPD_PF(struct S_PF p0, void* p1, double p2) ;
+EXPORT struct S_PD f19_S_SPD_PD(struct S_PD p0, void* p1, double p2) ;
+EXPORT struct S_PP f19_S_SPD_PP(struct S_PP p0, void* p1, double p2) ;
+EXPORT struct S_III f19_S_SPD_III(struct S_III p0, void* p1, double p2) ;
+EXPORT struct S_IIF f19_S_SPD_IIF(struct S_IIF p0, void* p1, double p2) ;
+EXPORT struct S_IID f19_S_SPD_IID(struct S_IID p0, void* p1, double p2) ;
+EXPORT struct S_IIP f19_S_SPD_IIP(struct S_IIP p0, void* p1, double p2) ;
+EXPORT struct S_IFI f19_S_SPD_IFI(struct S_IFI p0, void* p1, double p2) ;
+EXPORT struct S_IFF f19_S_SPD_IFF(struct S_IFF p0, void* p1, double p2) ;
+EXPORT struct S_IFD f19_S_SPD_IFD(struct S_IFD p0, void* p1, double p2) ;
+EXPORT struct S_IFP f19_S_SPD_IFP(struct S_IFP p0, void* p1, double p2) ;
+EXPORT struct S_IDI f19_S_SPD_IDI(struct S_IDI p0, void* p1, double p2) ;
+EXPORT struct S_IDF f19_S_SPD_IDF(struct S_IDF p0, void* p1, double p2) ;
+EXPORT struct S_IDD f19_S_SPD_IDD(struct S_IDD p0, void* p1, double p2) ;
+EXPORT struct S_IDP f19_S_SPD_IDP(struct S_IDP p0, void* p1, double p2) ;
+EXPORT struct S_IPI f19_S_SPD_IPI(struct S_IPI p0, void* p1, double p2) ;
+EXPORT struct S_IPF f19_S_SPD_IPF(struct S_IPF p0, void* p1, double p2) ;
+EXPORT struct S_IPD f19_S_SPD_IPD(struct S_IPD p0, void* p1, double p2) ;
+EXPORT struct S_IPP f19_S_SPD_IPP(struct S_IPP p0, void* p1, double p2) ;
+EXPORT struct S_FII f19_S_SPD_FII(struct S_FII p0, void* p1, double p2) ;
+EXPORT struct S_FIF f19_S_SPD_FIF(struct S_FIF p0, void* p1, double p2) ;
+EXPORT struct S_FID f19_S_SPD_FID(struct S_FID p0, void* p1, double p2) ;
+EXPORT struct S_FIP f19_S_SPD_FIP(struct S_FIP p0, void* p1, double p2) ;
+EXPORT struct S_FFI f19_S_SPD_FFI(struct S_FFI p0, void* p1, double p2) ;
+EXPORT struct S_FFF f19_S_SPD_FFF(struct S_FFF p0, void* p1, double p2) ;
+EXPORT struct S_FFD f19_S_SPD_FFD(struct S_FFD p0, void* p1, double p2) ;
+EXPORT struct S_FFP f19_S_SPD_FFP(struct S_FFP p0, void* p1, double p2) ;
+EXPORT struct S_FDI f19_S_SPD_FDI(struct S_FDI p0, void* p1, double p2) ;
+EXPORT struct S_FDF f19_S_SPD_FDF(struct S_FDF p0, void* p1, double p2) ;
+EXPORT struct S_FDD f19_S_SPD_FDD(struct S_FDD p0, void* p1, double p2) ;
+EXPORT struct S_FDP f19_S_SPD_FDP(struct S_FDP p0, void* p1, double p2) ;
+EXPORT struct S_FPI f19_S_SPD_FPI(struct S_FPI p0, void* p1, double p2) ;
+EXPORT struct S_FPF f19_S_SPD_FPF(struct S_FPF p0, void* p1, double p2) ;
+EXPORT struct S_FPD f19_S_SPD_FPD(struct S_FPD p0, void* p1, double p2) ;
+EXPORT struct S_FPP f19_S_SPD_FPP(struct S_FPP p0, void* p1, double p2) ;
+EXPORT struct S_DII f19_S_SPD_DII(struct S_DII p0, void* p1, double p2) ;
+EXPORT struct S_DIF f19_S_SPD_DIF(struct S_DIF p0, void* p1, double p2) ;
+EXPORT struct S_DID f19_S_SPD_DID(struct S_DID p0, void* p1, double p2) ;
+EXPORT struct S_DIP f19_S_SPD_DIP(struct S_DIP p0, void* p1, double p2) ;
+EXPORT struct S_DFI f19_S_SPD_DFI(struct S_DFI p0, void* p1, double p2) ;
+EXPORT struct S_DFF f19_S_SPD_DFF(struct S_DFF p0, void* p1, double p2) ;
+EXPORT struct S_DFD f19_S_SPD_DFD(struct S_DFD p0, void* p1, double p2) ;
+EXPORT struct S_DFP f19_S_SPD_DFP(struct S_DFP p0, void* p1, double p2) ;
+EXPORT struct S_DDI f19_S_SPD_DDI(struct S_DDI p0, void* p1, double p2) ;
+EXPORT struct S_DDF f19_S_SPD_DDF(struct S_DDF p0, void* p1, double p2) ;
+EXPORT struct S_DDD f19_S_SPD_DDD(struct S_DDD p0, void* p1, double p2) ;
+EXPORT struct S_DDP f19_S_SPD_DDP(struct S_DDP p0, void* p1, double p2) ;
+EXPORT struct S_DPI f19_S_SPD_DPI(struct S_DPI p0, void* p1, double p2) ;
+EXPORT struct S_DPF f19_S_SPD_DPF(struct S_DPF p0, void* p1, double p2) ;
+EXPORT struct S_DPD f19_S_SPD_DPD(struct S_DPD p0, void* p1, double p2) ;
+EXPORT struct S_DPP f19_S_SPD_DPP(struct S_DPP p0, void* p1, double p2) ;
+EXPORT struct S_PII f19_S_SPD_PII(struct S_PII p0, void* p1, double p2) ;
+EXPORT struct S_PIF f19_S_SPD_PIF(struct S_PIF p0, void* p1, double p2) ;
+EXPORT struct S_PID f19_S_SPD_PID(struct S_PID p0, void* p1, double p2) ;
+EXPORT struct S_PIP f19_S_SPD_PIP(struct S_PIP p0, void* p1, double p2) ;
+EXPORT struct S_PFI f19_S_SPD_PFI(struct S_PFI p0, void* p1, double p2) ;
+EXPORT struct S_PFF f19_S_SPD_PFF(struct S_PFF p0, void* p1, double p2) ;
+EXPORT struct S_PFD f19_S_SPD_PFD(struct S_PFD p0, void* p1, double p2) ;
+EXPORT struct S_PFP f19_S_SPD_PFP(struct S_PFP p0, void* p1, double p2) ;
+EXPORT struct S_PDI f19_S_SPD_PDI(struct S_PDI p0, void* p1, double p2) ;
+EXPORT struct S_PDF f19_S_SPD_PDF(struct S_PDF p0, void* p1, double p2) ;
+EXPORT struct S_PDD f19_S_SPD_PDD(struct S_PDD p0, void* p1, double p2) ;
+EXPORT struct S_PDP f19_S_SPD_PDP(struct S_PDP p0, void* p1, double p2) ;
+EXPORT struct S_PPI f19_S_SPD_PPI(struct S_PPI p0, void* p1, double p2) ;
+EXPORT struct S_PPF f19_S_SPD_PPF(struct S_PPF p0, void* p1, double p2) ;
+EXPORT struct S_PPD f19_S_SPD_PPD(struct S_PPD p0, void* p1, double p2) ;
+EXPORT struct S_PPP f19_S_SPD_PPP(struct S_PPP p0, void* p1, double p2) ;
+EXPORT struct S_I f19_S_SPP_I(struct S_I p0, void* p1, void* p2) ;
+EXPORT struct S_F f19_S_SPP_F(struct S_F p0, void* p1, void* p2) ;
+EXPORT struct S_D f19_S_SPP_D(struct S_D p0, void* p1, void* p2) ;
+EXPORT struct S_P f19_S_SPP_P(struct S_P p0, void* p1, void* p2) ;
+EXPORT struct S_II f19_S_SPP_II(struct S_II p0, void* p1, void* p2) ;
+EXPORT struct S_IF f19_S_SPP_IF(struct S_IF p0, void* p1, void* p2) ;
+EXPORT struct S_ID f19_S_SPP_ID(struct S_ID p0, void* p1, void* p2) ;
+EXPORT struct S_IP f19_S_SPP_IP(struct S_IP p0, void* p1, void* p2) ;
+EXPORT struct S_FI f19_S_SPP_FI(struct S_FI p0, void* p1, void* p2) ;
+EXPORT struct S_FF f19_S_SPP_FF(struct S_FF p0, void* p1, void* p2) ;
+EXPORT struct S_FD f19_S_SPP_FD(struct S_FD p0, void* p1, void* p2) ;
+EXPORT struct S_FP f19_S_SPP_FP(struct S_FP p0, void* p1, void* p2) ;
+EXPORT struct S_DI f19_S_SPP_DI(struct S_DI p0, void* p1, void* p2) ;
+EXPORT struct S_DF f19_S_SPP_DF(struct S_DF p0, void* p1, void* p2) ;
+EXPORT struct S_DD f19_S_SPP_DD(struct S_DD p0, void* p1, void* p2) ;
+EXPORT struct S_DP f19_S_SPP_DP(struct S_DP p0, void* p1, void* p2) ;
+EXPORT struct S_PI f19_S_SPP_PI(struct S_PI p0, void* p1, void* p2) ;
+EXPORT struct S_PF f19_S_SPP_PF(struct S_PF p0, void* p1, void* p2) ;
+EXPORT struct S_PD f19_S_SPP_PD(struct S_PD p0, void* p1, void* p2) ;
+EXPORT struct S_PP f19_S_SPP_PP(struct S_PP p0, void* p1, void* p2) ;
+EXPORT struct S_III f19_S_SPP_III(struct S_III p0, void* p1, void* p2) ;
+EXPORT struct S_IIF f19_S_SPP_IIF(struct S_IIF p0, void* p1, void* p2) ;
+EXPORT struct S_IID f19_S_SPP_IID(struct S_IID p0, void* p1, void* p2) ;
+EXPORT struct S_IIP f19_S_SPP_IIP(struct S_IIP p0, void* p1, void* p2) ;
+EXPORT struct S_IFI f19_S_SPP_IFI(struct S_IFI p0, void* p1, void* p2) ;
+EXPORT struct S_IFF f19_S_SPP_IFF(struct S_IFF p0, void* p1, void* p2) ;
+EXPORT struct S_IFD f19_S_SPP_IFD(struct S_IFD p0, void* p1, void* p2) ;
+EXPORT struct S_IFP f19_S_SPP_IFP(struct S_IFP p0, void* p1, void* p2) ;
+EXPORT struct S_IDI f19_S_SPP_IDI(struct S_IDI p0, void* p1, void* p2) ;
+EXPORT struct S_IDF f19_S_SPP_IDF(struct S_IDF p0, void* p1, void* p2) ;
+EXPORT struct S_IDD f19_S_SPP_IDD(struct S_IDD p0, void* p1, void* p2) ;
+EXPORT struct S_IDP f19_S_SPP_IDP(struct S_IDP p0, void* p1, void* p2) ;
+EXPORT struct S_IPI f19_S_SPP_IPI(struct S_IPI p0, void* p1, void* p2) ;
+EXPORT struct S_IPF f19_S_SPP_IPF(struct S_IPF p0, void* p1, void* p2) ;
+EXPORT struct S_IPD f19_S_SPP_IPD(struct S_IPD p0, void* p1, void* p2) ;
+EXPORT struct S_IPP f19_S_SPP_IPP(struct S_IPP p0, void* p1, void* p2) ;
+EXPORT struct S_FII f19_S_SPP_FII(struct S_FII p0, void* p1, void* p2) ;
+EXPORT struct S_FIF f19_S_SPP_FIF(struct S_FIF p0, void* p1, void* p2) ;
+EXPORT struct S_FID f19_S_SPP_FID(struct S_FID p0, void* p1, void* p2) ;
+EXPORT struct S_FIP f19_S_SPP_FIP(struct S_FIP p0, void* p1, void* p2) ;
+EXPORT struct S_FFI f19_S_SPP_FFI(struct S_FFI p0, void* p1, void* p2) ;
+EXPORT struct S_FFF f19_S_SPP_FFF(struct S_FFF p0, void* p1, void* p2) ;
+EXPORT struct S_FFD f19_S_SPP_FFD(struct S_FFD p0, void* p1, void* p2) ;
+EXPORT struct S_FFP f19_S_SPP_FFP(struct S_FFP p0, void* p1, void* p2) ;
+EXPORT struct S_FDI f19_S_SPP_FDI(struct S_FDI p0, void* p1, void* p2) ;
+EXPORT struct S_FDF f19_S_SPP_FDF(struct S_FDF p0, void* p1, void* p2) ;
+EXPORT struct S_FDD f19_S_SPP_FDD(struct S_FDD p0, void* p1, void* p2) ;
+EXPORT struct S_FDP f19_S_SPP_FDP(struct S_FDP p0, void* p1, void* p2) ;
+EXPORT struct S_FPI f19_S_SPP_FPI(struct S_FPI p0, void* p1, void* p2) ;
+EXPORT struct S_FPF f19_S_SPP_FPF(struct S_FPF p0, void* p1, void* p2) ;
+EXPORT struct S_FPD f19_S_SPP_FPD(struct S_FPD p0, void* p1, void* p2) ;
+EXPORT struct S_FPP f19_S_SPP_FPP(struct S_FPP p0, void* p1, void* p2) ;
+EXPORT struct S_DII f19_S_SPP_DII(struct S_DII p0, void* p1, void* p2) ;
+EXPORT struct S_DIF f19_S_SPP_DIF(struct S_DIF p0, void* p1, void* p2) ;
+EXPORT struct S_DID f19_S_SPP_DID(struct S_DID p0, void* p1, void* p2) ;
+EXPORT struct S_DIP f19_S_SPP_DIP(struct S_DIP p0, void* p1, void* p2) ;
+EXPORT struct S_DFI f19_S_SPP_DFI(struct S_DFI p0, void* p1, void* p2) ;
+EXPORT struct S_DFF f19_S_SPP_DFF(struct S_DFF p0, void* p1, void* p2) ;
+EXPORT struct S_DFD f19_S_SPP_DFD(struct S_DFD p0, void* p1, void* p2) ;
+EXPORT struct S_DFP f19_S_SPP_DFP(struct S_DFP p0, void* p1, void* p2) ;
+EXPORT struct S_DDI f19_S_SPP_DDI(struct S_DDI p0, void* p1, void* p2) ;
+EXPORT struct S_DDF f19_S_SPP_DDF(struct S_DDF p0, void* p1, void* p2) ;
+EXPORT struct S_DDD f19_S_SPP_DDD(struct S_DDD p0, void* p1, void* p2) ;
+EXPORT struct S_DDP f19_S_SPP_DDP(struct S_DDP p0, void* p1, void* p2) ;
+EXPORT struct S_DPI f19_S_SPP_DPI(struct S_DPI p0, void* p1, void* p2) ;
+EXPORT struct S_DPF f19_S_SPP_DPF(struct S_DPF p0, void* p1, void* p2) ;
+EXPORT struct S_DPD f19_S_SPP_DPD(struct S_DPD p0, void* p1, void* p2) ;
+EXPORT struct S_DPP f19_S_SPP_DPP(struct S_DPP p0, void* p1, void* p2) ;
+EXPORT struct S_PII f19_S_SPP_PII(struct S_PII p0, void* p1, void* p2) ;
+EXPORT struct S_PIF f19_S_SPP_PIF(struct S_PIF p0, void* p1, void* p2) ;
+EXPORT struct S_PID f19_S_SPP_PID(struct S_PID p0, void* p1, void* p2) ;
+EXPORT struct S_PIP f19_S_SPP_PIP(struct S_PIP p0, void* p1, void* p2) ;
+EXPORT struct S_PFI f19_S_SPP_PFI(struct S_PFI p0, void* p1, void* p2) ;
+EXPORT struct S_PFF f19_S_SPP_PFF(struct S_PFF p0, void* p1, void* p2) ;
+EXPORT struct S_PFD f19_S_SPP_PFD(struct S_PFD p0, void* p1, void* p2) ;
+EXPORT struct S_PFP f19_S_SPP_PFP(struct S_PFP p0, void* p1, void* p2) ;
+EXPORT struct S_PDI f19_S_SPP_PDI(struct S_PDI p0, void* p1, void* p2) ;
+EXPORT struct S_PDF f19_S_SPP_PDF(struct S_PDF p0, void* p1, void* p2) ;
+EXPORT struct S_PDD f19_S_SPP_PDD(struct S_PDD p0, void* p1, void* p2) ;
+EXPORT struct S_PDP f19_S_SPP_PDP(struct S_PDP p0, void* p1, void* p2) ;
+EXPORT struct S_PPI f19_S_SPP_PPI(struct S_PPI p0, void* p1, void* p2) ;
+EXPORT struct S_PPF f19_S_SPP_PPF(struct S_PPF p0, void* p1, void* p2) ;
+EXPORT struct S_PPD f19_S_SPP_PPD(struct S_PPD p0, void* p1, void* p2) ;
+EXPORT struct S_PPP f19_S_SPP_PPP(struct S_PPP p0, void* p1, void* p2) ;
+EXPORT struct S_I f19_S_SPS_I(struct S_I p0, void* p1, struct S_I p2) ;
+EXPORT struct S_F f19_S_SPS_F(struct S_F p0, void* p1, struct S_F p2) ;
+EXPORT struct S_D f19_S_SPS_D(struct S_D p0, void* p1, struct S_D p2) ;
+EXPORT struct S_P f19_S_SPS_P(struct S_P p0, void* p1, struct S_P p2) ;
+EXPORT struct S_II f19_S_SPS_II(struct S_II p0, void* p1, struct S_II p2) ;
+EXPORT struct S_IF f19_S_SPS_IF(struct S_IF p0, void* p1, struct S_IF p2) ;
+EXPORT struct S_ID f19_S_SPS_ID(struct S_ID p0, void* p1, struct S_ID p2) ;
+EXPORT struct S_IP f19_S_SPS_IP(struct S_IP p0, void* p1, struct S_IP p2) ;
+EXPORT struct S_FI f19_S_SPS_FI(struct S_FI p0, void* p1, struct S_FI p2) ;
+EXPORT struct S_FF f19_S_SPS_FF(struct S_FF p0, void* p1, struct S_FF p2) ;
+EXPORT struct S_FD f19_S_SPS_FD(struct S_FD p0, void* p1, struct S_FD p2) ;
+EXPORT struct S_FP f19_S_SPS_FP(struct S_FP p0, void* p1, struct S_FP p2) ;
+EXPORT struct S_DI f19_S_SPS_DI(struct S_DI p0, void* p1, struct S_DI p2) ;
+EXPORT struct S_DF f19_S_SPS_DF(struct S_DF p0, void* p1, struct S_DF p2) ;
+EXPORT struct S_DD f19_S_SPS_DD(struct S_DD p0, void* p1, struct S_DD p2) ;
+EXPORT struct S_DP f19_S_SPS_DP(struct S_DP p0, void* p1, struct S_DP p2) ;
+EXPORT struct S_PI f19_S_SPS_PI(struct S_PI p0, void* p1, struct S_PI p2) ;
+EXPORT struct S_PF f19_S_SPS_PF(struct S_PF p0, void* p1, struct S_PF p2) ;
+EXPORT struct S_PD f19_S_SPS_PD(struct S_PD p0, void* p1, struct S_PD p2) ;
+EXPORT struct S_PP f19_S_SPS_PP(struct S_PP p0, void* p1, struct S_PP p2) ;
+EXPORT struct S_III f19_S_SPS_III(struct S_III p0, void* p1, struct S_III p2) ;
+EXPORT struct S_IIF f19_S_SPS_IIF(struct S_IIF p0, void* p1, struct S_IIF p2) ;
+EXPORT struct S_IID f19_S_SPS_IID(struct S_IID p0, void* p1, struct S_IID p2) ;
+EXPORT struct S_IIP f19_S_SPS_IIP(struct S_IIP p0, void* p1, struct S_IIP p2) ;
+EXPORT struct S_IFI f19_S_SPS_IFI(struct S_IFI p0, void* p1, struct S_IFI p2) ;
+EXPORT struct S_IFF f19_S_SPS_IFF(struct S_IFF p0, void* p1, struct S_IFF p2) ;
+EXPORT struct S_IFD f19_S_SPS_IFD(struct S_IFD p0, void* p1, struct S_IFD p2) ;
+EXPORT struct S_IFP f19_S_SPS_IFP(struct S_IFP p0, void* p1, struct S_IFP p2) ;
+EXPORT struct S_IDI f19_S_SPS_IDI(struct S_IDI p0, void* p1, struct S_IDI p2) ;
+EXPORT struct S_IDF f19_S_SPS_IDF(struct S_IDF p0, void* p1, struct S_IDF p2) ;
+EXPORT struct S_IDD f19_S_SPS_IDD(struct S_IDD p0, void* p1, struct S_IDD p2) ;
+EXPORT struct S_IDP f19_S_SPS_IDP(struct S_IDP p0, void* p1, struct S_IDP p2) ;
+EXPORT struct S_IPI f19_S_SPS_IPI(struct S_IPI p0, void* p1, struct S_IPI p2) ;
+EXPORT struct S_IPF f19_S_SPS_IPF(struct S_IPF p0, void* p1, struct S_IPF p2) ;
+EXPORT struct S_IPD f19_S_SPS_IPD(struct S_IPD p0, void* p1, struct S_IPD p2) ;
+EXPORT struct S_IPP f19_S_SPS_IPP(struct S_IPP p0, void* p1, struct S_IPP p2) ;
+EXPORT struct S_FII f19_S_SPS_FII(struct S_FII p0, void* p1, struct S_FII p2) ;
+EXPORT struct S_FIF f19_S_SPS_FIF(struct S_FIF p0, void* p1, struct S_FIF p2) ;
+EXPORT struct S_FID f19_S_SPS_FID(struct S_FID p0, void* p1, struct S_FID p2) ;
+EXPORT struct S_FIP f19_S_SPS_FIP(struct S_FIP p0, void* p1, struct S_FIP p2) ;
+EXPORT struct S_FFI f19_S_SPS_FFI(struct S_FFI p0, void* p1, struct S_FFI p2) ;
+EXPORT struct S_FFF f19_S_SPS_FFF(struct S_FFF p0, void* p1, struct S_FFF p2) ;
+EXPORT struct S_FFD f19_S_SPS_FFD(struct S_FFD p0, void* p1, struct S_FFD p2) ;
+EXPORT struct S_FFP f19_S_SPS_FFP(struct S_FFP p0, void* p1, struct S_FFP p2) ;
+EXPORT struct S_FDI f19_S_SPS_FDI(struct S_FDI p0, void* p1, struct S_FDI p2) ;
+EXPORT struct S_FDF f19_S_SPS_FDF(struct S_FDF p0, void* p1, struct S_FDF p2) ;
+EXPORT struct S_FDD f19_S_SPS_FDD(struct S_FDD p0, void* p1, struct S_FDD p2) ;
+EXPORT struct S_FDP f19_S_SPS_FDP(struct S_FDP p0, void* p1, struct S_FDP p2) ;
+EXPORT struct S_FPI f19_S_SPS_FPI(struct S_FPI p0, void* p1, struct S_FPI p2) ;
+EXPORT struct S_FPF f19_S_SPS_FPF(struct S_FPF p0, void* p1, struct S_FPF p2) ;
+EXPORT struct S_FPD f19_S_SPS_FPD(struct S_FPD p0, void* p1, struct S_FPD p2) ;
+EXPORT struct S_FPP f19_S_SPS_FPP(struct S_FPP p0, void* p1, struct S_FPP p2) ;
+EXPORT struct S_DII f19_S_SPS_DII(struct S_DII p0, void* p1, struct S_DII p2) ;
+EXPORT struct S_DIF f19_S_SPS_DIF(struct S_DIF p0, void* p1, struct S_DIF p2) ;
+EXPORT struct S_DID f19_S_SPS_DID(struct S_DID p0, void* p1, struct S_DID p2) ;
+EXPORT struct S_DIP f19_S_SPS_DIP(struct S_DIP p0, void* p1, struct S_DIP p2) ;
+EXPORT struct S_DFI f19_S_SPS_DFI(struct S_DFI p0, void* p1, struct S_DFI p2) ;
+EXPORT struct S_DFF f19_S_SPS_DFF(struct S_DFF p0, void* p1, struct S_DFF p2) ;
+EXPORT struct S_DFD f19_S_SPS_DFD(struct S_DFD p0, void* p1, struct S_DFD p2) ;
+EXPORT struct S_DFP f19_S_SPS_DFP(struct S_DFP p0, void* p1, struct S_DFP p2) ;
+EXPORT struct S_DDI f19_S_SPS_DDI(struct S_DDI p0, void* p1, struct S_DDI p2) ;
+EXPORT struct S_DDF f19_S_SPS_DDF(struct S_DDF p0, void* p1, struct S_DDF p2) ;
+EXPORT struct S_DDD f19_S_SPS_DDD(struct S_DDD p0, void* p1, struct S_DDD p2) ;
+EXPORT struct S_DDP f19_S_SPS_DDP(struct S_DDP p0, void* p1, struct S_DDP p2) ;
+EXPORT struct S_DPI f19_S_SPS_DPI(struct S_DPI p0, void* p1, struct S_DPI p2) ;
+EXPORT struct S_DPF f19_S_SPS_DPF(struct S_DPF p0, void* p1, struct S_DPF p2) ;
+EXPORT struct S_DPD f19_S_SPS_DPD(struct S_DPD p0, void* p1, struct S_DPD p2) ;
+EXPORT struct S_DPP f19_S_SPS_DPP(struct S_DPP p0, void* p1, struct S_DPP p2) ;
+EXPORT struct S_PII f19_S_SPS_PII(struct S_PII p0, void* p1, struct S_PII p2) ;
+EXPORT struct S_PIF f19_S_SPS_PIF(struct S_PIF p0, void* p1, struct S_PIF p2) ;
+EXPORT struct S_PID f19_S_SPS_PID(struct S_PID p0, void* p1, struct S_PID p2) ;
+EXPORT struct S_PIP f19_S_SPS_PIP(struct S_PIP p0, void* p1, struct S_PIP p2) ;
+EXPORT struct S_PFI f19_S_SPS_PFI(struct S_PFI p0, void* p1, struct S_PFI p2) ;
+EXPORT struct S_PFF f19_S_SPS_PFF(struct S_PFF p0, void* p1, struct S_PFF p2) ;
+EXPORT struct S_PFD f19_S_SPS_PFD(struct S_PFD p0, void* p1, struct S_PFD p2) ;
+EXPORT struct S_PFP f19_S_SPS_PFP(struct S_PFP p0, void* p1, struct S_PFP p2) ;
+EXPORT struct S_PDI f19_S_SPS_PDI(struct S_PDI p0, void* p1, struct S_PDI p2) ;
+EXPORT struct S_PDF f19_S_SPS_PDF(struct S_PDF p0, void* p1, struct S_PDF p2) ;
+EXPORT struct S_PDD f19_S_SPS_PDD(struct S_PDD p0, void* p1, struct S_PDD p2) ;
+EXPORT struct S_PDP f19_S_SPS_PDP(struct S_PDP p0, void* p1, struct S_PDP p2) ;
+EXPORT struct S_PPI f19_S_SPS_PPI(struct S_PPI p0, void* p1, struct S_PPI p2) ;
+EXPORT struct S_PPF f19_S_SPS_PPF(struct S_PPF p0, void* p1, struct S_PPF p2) ;
+EXPORT struct S_PPD f19_S_SPS_PPD(struct S_PPD p0, void* p1, struct S_PPD p2) ;
+EXPORT struct S_PPP f19_S_SPS_PPP(struct S_PPP p0, void* p1, struct S_PPP p2) ;
+EXPORT struct S_I f19_S_SSI_I(struct S_I p0, struct S_I p1, int p2) ;
+EXPORT struct S_F f19_S_SSI_F(struct S_F p0, struct S_F p1, int p2) ;
+EXPORT struct S_D f19_S_SSI_D(struct S_D p0, struct S_D p1, int p2) ;
+EXPORT struct S_P f19_S_SSI_P(struct S_P p0, struct S_P p1, int p2) ;
+EXPORT struct S_II f19_S_SSI_II(struct S_II p0, struct S_II p1, int p2) ;
+EXPORT struct S_IF f19_S_SSI_IF(struct S_IF p0, struct S_IF p1, int p2) ;
+EXPORT struct S_ID f19_S_SSI_ID(struct S_ID p0, struct S_ID p1, int p2) ;
+EXPORT struct S_IP f19_S_SSI_IP(struct S_IP p0, struct S_IP p1, int p2) ;
+EXPORT struct S_FI f19_S_SSI_FI(struct S_FI p0, struct S_FI p1, int p2) ;
+EXPORT struct S_FF f19_S_SSI_FF(struct S_FF p0, struct S_FF p1, int p2) ;
+EXPORT struct S_FD f19_S_SSI_FD(struct S_FD p0, struct S_FD p1, int p2) ;
+EXPORT struct S_FP f19_S_SSI_FP(struct S_FP p0, struct S_FP p1, int p2) ;
+EXPORT struct S_DI f19_S_SSI_DI(struct S_DI p0, struct S_DI p1, int p2) ;
+EXPORT struct S_DF f19_S_SSI_DF(struct S_DF p0, struct S_DF p1, int p2) ;
+EXPORT struct S_DD f19_S_SSI_DD(struct S_DD p0, struct S_DD p1, int p2) ;
+EXPORT struct S_DP f19_S_SSI_DP(struct S_DP p0, struct S_DP p1, int p2) ;
+EXPORT struct S_PI f19_S_SSI_PI(struct S_PI p0, struct S_PI p1, int p2) ;
+EXPORT struct S_PF f19_S_SSI_PF(struct S_PF p0, struct S_PF p1, int p2) ;
+EXPORT struct S_PD f19_S_SSI_PD(struct S_PD p0, struct S_PD p1, int p2) ;
+EXPORT struct S_PP f19_S_SSI_PP(struct S_PP p0, struct S_PP p1, int p2) ;
+EXPORT struct S_III f19_S_SSI_III(struct S_III p0, struct S_III p1, int p2) ;
+EXPORT struct S_IIF f19_S_SSI_IIF(struct S_IIF p0, struct S_IIF p1, int p2) ;
+EXPORT struct S_IID f19_S_SSI_IID(struct S_IID p0, struct S_IID p1, int p2) ;
+EXPORT struct S_IIP f19_S_SSI_IIP(struct S_IIP p0, struct S_IIP p1, int p2) ;
+EXPORT struct S_IFI f19_S_SSI_IFI(struct S_IFI p0, struct S_IFI p1, int p2) ;
+EXPORT struct S_IFF f19_S_SSI_IFF(struct S_IFF p0, struct S_IFF p1, int p2) ;
+EXPORT struct S_IFD f19_S_SSI_IFD(struct S_IFD p0, struct S_IFD p1, int p2) ;
+EXPORT struct S_IFP f19_S_SSI_IFP(struct S_IFP p0, struct S_IFP p1, int p2) ;
+EXPORT struct S_IDI f19_S_SSI_IDI(struct S_IDI p0, struct S_IDI p1, int p2) ;
+EXPORT struct S_IDF f19_S_SSI_IDF(struct S_IDF p0, struct S_IDF p1, int p2) ;
+EXPORT struct S_IDD f19_S_SSI_IDD(struct S_IDD p0, struct S_IDD p1, int p2) ;
+EXPORT struct S_IDP f19_S_SSI_IDP(struct S_IDP p0, struct S_IDP p1, int p2) ;
+EXPORT struct S_IPI f19_S_SSI_IPI(struct S_IPI p0, struct S_IPI p1, int p2) ;
+EXPORT struct S_IPF f19_S_SSI_IPF(struct S_IPF p0, struct S_IPF p1, int p2) ;
+EXPORT struct S_IPD f19_S_SSI_IPD(struct S_IPD p0, struct S_IPD p1, int p2) ;
+EXPORT struct S_IPP f19_S_SSI_IPP(struct S_IPP p0, struct S_IPP p1, int p2) ;
+EXPORT struct S_FII f19_S_SSI_FII(struct S_FII p0, struct S_FII p1, int p2) ;
+EXPORT struct S_FIF f19_S_SSI_FIF(struct S_FIF p0, struct S_FIF p1, int p2) ;
+EXPORT struct S_FID f19_S_SSI_FID(struct S_FID p0, struct S_FID p1, int p2) ;
+EXPORT struct S_FIP f19_S_SSI_FIP(struct S_FIP p0, struct S_FIP p1, int p2) ;
+EXPORT struct S_FFI f19_S_SSI_FFI(struct S_FFI p0, struct S_FFI p1, int p2) ;
+EXPORT struct S_FFF f19_S_SSI_FFF(struct S_FFF p0, struct S_FFF p1, int p2) ;
+EXPORT struct S_FFD f19_S_SSI_FFD(struct S_FFD p0, struct S_FFD p1, int p2) ;
+EXPORT struct S_FFP f19_S_SSI_FFP(struct S_FFP p0, struct S_FFP p1, int p2) ;
+EXPORT struct S_FDI f19_S_SSI_FDI(struct S_FDI p0, struct S_FDI p1, int p2) ;
+EXPORT struct S_FDF f19_S_SSI_FDF(struct S_FDF p0, struct S_FDF p1, int p2) ;
+EXPORT struct S_FDD f19_S_SSI_FDD(struct S_FDD p0, struct S_FDD p1, int p2) ;
+EXPORT struct S_FDP f19_S_SSI_FDP(struct S_FDP p0, struct S_FDP p1, int p2) ;
+EXPORT struct S_FPI f19_S_SSI_FPI(struct S_FPI p0, struct S_FPI p1, int p2) ;
+EXPORT struct S_FPF f19_S_SSI_FPF(struct S_FPF p0, struct S_FPF p1, int p2) ;
+EXPORT struct S_FPD f19_S_SSI_FPD(struct S_FPD p0, struct S_FPD p1, int p2) ;
+EXPORT struct S_FPP f19_S_SSI_FPP(struct S_FPP p0, struct S_FPP p1, int p2) ;
+EXPORT struct S_DII f19_S_SSI_DII(struct S_DII p0, struct S_DII p1, int p2) ;
+EXPORT struct S_DIF f19_S_SSI_DIF(struct S_DIF p0, struct S_DIF p1, int p2) ;
+EXPORT struct S_DID f19_S_SSI_DID(struct S_DID p0, struct S_DID p1, int p2) ;
+EXPORT struct S_DIP f19_S_SSI_DIP(struct S_DIP p0, struct S_DIP p1, int p2) ;
+EXPORT struct S_DFI f19_S_SSI_DFI(struct S_DFI p0, struct S_DFI p1, int p2) ;
+EXPORT struct S_DFF f19_S_SSI_DFF(struct S_DFF p0, struct S_DFF p1, int p2) ;
+EXPORT struct S_DFD f19_S_SSI_DFD(struct S_DFD p0, struct S_DFD p1, int p2) ;
+EXPORT struct S_DFP f19_S_SSI_DFP(struct S_DFP p0, struct S_DFP p1, int p2) ;
+EXPORT struct S_DDI f19_S_SSI_DDI(struct S_DDI p0, struct S_DDI p1, int p2) ;
+EXPORT struct S_DDF f19_S_SSI_DDF(struct S_DDF p0, struct S_DDF p1, int p2) ;
+EXPORT struct S_DDD f19_S_SSI_DDD(struct S_DDD p0, struct S_DDD p1, int p2) ;
+EXPORT struct S_DDP f19_S_SSI_DDP(struct S_DDP p0, struct S_DDP p1, int p2) ;
+EXPORT struct S_DPI f19_S_SSI_DPI(struct S_DPI p0, struct S_DPI p1, int p2) ;
+EXPORT struct S_DPF f19_S_SSI_DPF(struct S_DPF p0, struct S_DPF p1, int p2) ;
+EXPORT struct S_DPD f19_S_SSI_DPD(struct S_DPD p0, struct S_DPD p1, int p2) ;
+EXPORT struct S_DPP f19_S_SSI_DPP(struct S_DPP p0, struct S_DPP p1, int p2) ;
+EXPORT struct S_PII f19_S_SSI_PII(struct S_PII p0, struct S_PII p1, int p2) ;
+EXPORT struct S_PIF f19_S_SSI_PIF(struct S_PIF p0, struct S_PIF p1, int p2) ;
+EXPORT struct S_PID f19_S_SSI_PID(struct S_PID p0, struct S_PID p1, int p2) ;
+EXPORT struct S_PIP f19_S_SSI_PIP(struct S_PIP p0, struct S_PIP p1, int p2) ;
+EXPORT struct S_PFI f19_S_SSI_PFI(struct S_PFI p0, struct S_PFI p1, int p2) ;
+EXPORT struct S_PFF f19_S_SSI_PFF(struct S_PFF p0, struct S_PFF p1, int p2) ;
+EXPORT struct S_PFD f19_S_SSI_PFD(struct S_PFD p0, struct S_PFD p1, int p2) ;
+EXPORT struct S_PFP f19_S_SSI_PFP(struct S_PFP p0, struct S_PFP p1, int p2) ;
+EXPORT struct S_PDI f19_S_SSI_PDI(struct S_PDI p0, struct S_PDI p1, int p2) ;
+EXPORT struct S_PDF f19_S_SSI_PDF(struct S_PDF p0, struct S_PDF p1, int p2) ;
+EXPORT struct S_PDD f19_S_SSI_PDD(struct S_PDD p0, struct S_PDD p1, int p2) ;
+EXPORT struct S_PDP f19_S_SSI_PDP(struct S_PDP p0, struct S_PDP p1, int p2) ;
+EXPORT struct S_PPI f19_S_SSI_PPI(struct S_PPI p0, struct S_PPI p1, int p2) ;
+EXPORT struct S_PPF f19_S_SSI_PPF(struct S_PPF p0, struct S_PPF p1, int p2) ;
+EXPORT struct S_PPD f19_S_SSI_PPD(struct S_PPD p0, struct S_PPD p1, int p2) ;
+EXPORT struct S_PPP f19_S_SSI_PPP(struct S_PPP p0, struct S_PPP p1, int p2) ;
+EXPORT struct S_I f19_S_SSF_I(struct S_I p0, struct S_I p1, float p2) ;
+EXPORT struct S_F f19_S_SSF_F(struct S_F p0, struct S_F p1, float p2) ;
+EXPORT struct S_D f19_S_SSF_D(struct S_D p0, struct S_D p1, float p2) ;
+EXPORT struct S_P f19_S_SSF_P(struct S_P p0, struct S_P p1, float p2) ;
+EXPORT struct S_II f19_S_SSF_II(struct S_II p0, struct S_II p1, float p2) ;
+EXPORT struct S_IF f19_S_SSF_IF(struct S_IF p0, struct S_IF p1, float p2) ;
+EXPORT struct S_ID f19_S_SSF_ID(struct S_ID p0, struct S_ID p1, float p2) ;
+EXPORT struct S_IP f19_S_SSF_IP(struct S_IP p0, struct S_IP p1, float p2) ;
+EXPORT struct S_FI f19_S_SSF_FI(struct S_FI p0, struct S_FI p1, float p2) ;
+EXPORT struct S_FF f19_S_SSF_FF(struct S_FF p0, struct S_FF p1, float p2) ;
+EXPORT struct S_FD f19_S_SSF_FD(struct S_FD p0, struct S_FD p1, float p2) ;
+EXPORT struct S_FP f19_S_SSF_FP(struct S_FP p0, struct S_FP p1, float p2) ;
+EXPORT struct S_DI f19_S_SSF_DI(struct S_DI p0, struct S_DI p1, float p2) ;
+EXPORT struct S_DF f19_S_SSF_DF(struct S_DF p0, struct S_DF p1, float p2) ;
+EXPORT struct S_DD f19_S_SSF_DD(struct S_DD p0, struct S_DD p1, float p2) ;
+EXPORT struct S_DP f19_S_SSF_DP(struct S_DP p0, struct S_DP p1, float p2) ;
+EXPORT struct S_PI f19_S_SSF_PI(struct S_PI p0, struct S_PI p1, float p2) ;
+EXPORT struct S_PF f19_S_SSF_PF(struct S_PF p0, struct S_PF p1, float p2) ;
+EXPORT struct S_PD f19_S_SSF_PD(struct S_PD p0, struct S_PD p1, float p2) ;
+EXPORT struct S_PP f19_S_SSF_PP(struct S_PP p0, struct S_PP p1, float p2) ;
+EXPORT struct S_III f19_S_SSF_III(struct S_III p0, struct S_III p1, float p2) ;
+EXPORT struct S_IIF f19_S_SSF_IIF(struct S_IIF p0, struct S_IIF p1, float p2) ;
+EXPORT struct S_IID f19_S_SSF_IID(struct S_IID p0, struct S_IID p1, float p2) ;
+EXPORT struct S_IIP f19_S_SSF_IIP(struct S_IIP p0, struct S_IIP p1, float p2) ;
+EXPORT struct S_IFI f19_S_SSF_IFI(struct S_IFI p0, struct S_IFI p1, float p2) ;
+EXPORT struct S_IFF f19_S_SSF_IFF(struct S_IFF p0, struct S_IFF p1, float p2) ;
+EXPORT struct S_IFD f19_S_SSF_IFD(struct S_IFD p0, struct S_IFD p1, float p2) ;
+EXPORT struct S_IFP f19_S_SSF_IFP(struct S_IFP p0, struct S_IFP p1, float p2) ;
+EXPORT struct S_IDI f19_S_SSF_IDI(struct S_IDI p0, struct S_IDI p1, float p2) ;
+EXPORT struct S_IDF f19_S_SSF_IDF(struct S_IDF p0, struct S_IDF p1, float p2) ;
+EXPORT struct S_IDD f19_S_SSF_IDD(struct S_IDD p0, struct S_IDD p1, float p2) ;
+EXPORT struct S_IDP f19_S_SSF_IDP(struct S_IDP p0, struct S_IDP p1, float p2) ;
+EXPORT struct S_IPI f19_S_SSF_IPI(struct S_IPI p0, struct S_IPI p1, float p2) ;
+EXPORT struct S_IPF f19_S_SSF_IPF(struct S_IPF p0, struct S_IPF p1, float p2) ;
+EXPORT struct S_IPD f19_S_SSF_IPD(struct S_IPD p0, struct S_IPD p1, float p2) ;
+EXPORT struct S_IPP f19_S_SSF_IPP(struct S_IPP p0, struct S_IPP p1, float p2) ;
+EXPORT struct S_FII f19_S_SSF_FII(struct S_FII p0, struct S_FII p1, float p2) ;
+EXPORT struct S_FIF f19_S_SSF_FIF(struct S_FIF p0, struct S_FIF p1, float p2) ;
+EXPORT struct S_FID f19_S_SSF_FID(struct S_FID p0, struct S_FID p1, float p2) ;
+EXPORT struct S_FIP f19_S_SSF_FIP(struct S_FIP p0, struct S_FIP p1, float p2) ;
+EXPORT struct S_FFI f19_S_SSF_FFI(struct S_FFI p0, struct S_FFI p1, float p2) ;
+EXPORT struct S_FFF f19_S_SSF_FFF(struct S_FFF p0, struct S_FFF p1, float p2) ;
+EXPORT struct S_FFD f19_S_SSF_FFD(struct S_FFD p0, struct S_FFD p1, float p2) ;
+EXPORT struct S_FFP f19_S_SSF_FFP(struct S_FFP p0, struct S_FFP p1, float p2) ;
+EXPORT struct S_FDI f19_S_SSF_FDI(struct S_FDI p0, struct S_FDI p1, float p2) ;
+EXPORT struct S_FDF f19_S_SSF_FDF(struct S_FDF p0, struct S_FDF p1, float p2) ;
+EXPORT struct S_FDD f19_S_SSF_FDD(struct S_FDD p0, struct S_FDD p1, float p2) ;
+EXPORT struct S_FDP f19_S_SSF_FDP(struct S_FDP p0, struct S_FDP p1, float p2) ;
+EXPORT struct S_FPI f19_S_SSF_FPI(struct S_FPI p0, struct S_FPI p1, float p2) ;
+EXPORT struct S_FPF f19_S_SSF_FPF(struct S_FPF p0, struct S_FPF p1, float p2) ;
+EXPORT struct S_FPD f19_S_SSF_FPD(struct S_FPD p0, struct S_FPD p1, float p2) ;
+EXPORT struct S_FPP f19_S_SSF_FPP(struct S_FPP p0, struct S_FPP p1, float p2) ;
+EXPORT struct S_DII f19_S_SSF_DII(struct S_DII p0, struct S_DII p1, float p2) ;
+EXPORT struct S_DIF f19_S_SSF_DIF(struct S_DIF p0, struct S_DIF p1, float p2) ;
+EXPORT struct S_DID f19_S_SSF_DID(struct S_DID p0, struct S_DID p1, float p2) ;
+EXPORT struct S_DIP f19_S_SSF_DIP(struct S_DIP p0, struct S_DIP p1, float p2) ;
+EXPORT struct S_DFI f19_S_SSF_DFI(struct S_DFI p0, struct S_DFI p1, float p2) ;
+EXPORT struct S_DFF f19_S_SSF_DFF(struct S_DFF p0, struct S_DFF p1, float p2) ;
+EXPORT struct S_DFD f19_S_SSF_DFD(struct S_DFD p0, struct S_DFD p1, float p2) ;
+EXPORT struct S_DFP f19_S_SSF_DFP(struct S_DFP p0, struct S_DFP p1, float p2) ;
+EXPORT struct S_DDI f19_S_SSF_DDI(struct S_DDI p0, struct S_DDI p1, float p2) ;
+EXPORT struct S_DDF f19_S_SSF_DDF(struct S_DDF p0, struct S_DDF p1, float p2) ;
+EXPORT struct S_DDD f19_S_SSF_DDD(struct S_DDD p0, struct S_DDD p1, float p2) ;
+EXPORT struct S_DDP f19_S_SSF_DDP(struct S_DDP p0, struct S_DDP p1, float p2) ;
+EXPORT struct S_DPI f19_S_SSF_DPI(struct S_DPI p0, struct S_DPI p1, float p2) ;
+EXPORT struct S_DPF f19_S_SSF_DPF(struct S_DPF p0, struct S_DPF p1, float p2) ;
+EXPORT struct S_DPD f19_S_SSF_DPD(struct S_DPD p0, struct S_DPD p1, float p2) ;
+EXPORT struct S_DPP f19_S_SSF_DPP(struct S_DPP p0, struct S_DPP p1, float p2) ;
+EXPORT struct S_PII f19_S_SSF_PII(struct S_PII p0, struct S_PII p1, float p2) ;
+EXPORT struct S_PIF f19_S_SSF_PIF(struct S_PIF p0, struct S_PIF p1, float p2) ;
+EXPORT struct S_PID f19_S_SSF_PID(struct S_PID p0, struct S_PID p1, float p2) ;
+EXPORT struct S_PIP f19_S_SSF_PIP(struct S_PIP p0, struct S_PIP p1, float p2) ;
+EXPORT struct S_PFI f19_S_SSF_PFI(struct S_PFI p0, struct S_PFI p1, float p2) ;
+EXPORT struct S_PFF f19_S_SSF_PFF(struct S_PFF p0, struct S_PFF p1, float p2) ;
+EXPORT struct S_PFD f19_S_SSF_PFD(struct S_PFD p0, struct S_PFD p1, float p2) ;
+EXPORT struct S_PFP f19_S_SSF_PFP(struct S_PFP p0, struct S_PFP p1, float p2) ;
+EXPORT struct S_PDI f19_S_SSF_PDI(struct S_PDI p0, struct S_PDI p1, float p2) ;
+EXPORT struct S_PDF f19_S_SSF_PDF(struct S_PDF p0, struct S_PDF p1, float p2) ;
+EXPORT struct S_PDD f19_S_SSF_PDD(struct S_PDD p0, struct S_PDD p1, float p2) ;
+EXPORT struct S_PDP f19_S_SSF_PDP(struct S_PDP p0, struct S_PDP p1, float p2) ;
+EXPORT struct S_PPI f19_S_SSF_PPI(struct S_PPI p0, struct S_PPI p1, float p2) ;
+EXPORT struct S_PPF f19_S_SSF_PPF(struct S_PPF p0, struct S_PPF p1, float p2) ;
+EXPORT struct S_PPD f19_S_SSF_PPD(struct S_PPD p0, struct S_PPD p1, float p2) ;
+EXPORT struct S_PPP f19_S_SSF_PPP(struct S_PPP p0, struct S_PPP p1, float p2) ;
+EXPORT struct S_I f19_S_SSD_I(struct S_I p0, struct S_I p1, double p2) ;
+EXPORT struct S_F f19_S_SSD_F(struct S_F p0, struct S_F p1, double p2) ;
+EXPORT struct S_D f19_S_SSD_D(struct S_D p0, struct S_D p1, double p2) ;
+EXPORT struct S_P f19_S_SSD_P(struct S_P p0, struct S_P p1, double p2) ;
+EXPORT struct S_II f19_S_SSD_II(struct S_II p0, struct S_II p1, double p2) ;
+EXPORT struct S_IF f19_S_SSD_IF(struct S_IF p0, struct S_IF p1, double p2) ;
+EXPORT struct S_ID f19_S_SSD_ID(struct S_ID p0, struct S_ID p1, double p2) ;
+EXPORT struct S_IP f19_S_SSD_IP(struct S_IP p0, struct S_IP p1, double p2) ;
+EXPORT struct S_FI f19_S_SSD_FI(struct S_FI p0, struct S_FI p1, double p2) ;
+EXPORT struct S_FF f19_S_SSD_FF(struct S_FF p0, struct S_FF p1, double p2) ;
+EXPORT struct S_FD f19_S_SSD_FD(struct S_FD p0, struct S_FD p1, double p2) ;
+EXPORT struct S_FP f19_S_SSD_FP(struct S_FP p0, struct S_FP p1, double p2) ;
+EXPORT struct S_DI f19_S_SSD_DI(struct S_DI p0, struct S_DI p1, double p2) ;
+EXPORT struct S_DF f19_S_SSD_DF(struct S_DF p0, struct S_DF p1, double p2) ;
+EXPORT struct S_DD f19_S_SSD_DD(struct S_DD p0, struct S_DD p1, double p2) ;
+EXPORT struct S_DP f19_S_SSD_DP(struct S_DP p0, struct S_DP p1, double p2) ;
+EXPORT struct S_PI f19_S_SSD_PI(struct S_PI p0, struct S_PI p1, double p2) ;
+EXPORT struct S_PF f19_S_SSD_PF(struct S_PF p0, struct S_PF p1, double p2) ;
+EXPORT struct S_PD f19_S_SSD_PD(struct S_PD p0, struct S_PD p1, double p2) ;
+EXPORT struct S_PP f19_S_SSD_PP(struct S_PP p0, struct S_PP p1, double p2) ;
+EXPORT struct S_III f19_S_SSD_III(struct S_III p0, struct S_III p1, double p2) ;
+EXPORT struct S_IIF f19_S_SSD_IIF(struct S_IIF p0, struct S_IIF p1, double p2) ;
+EXPORT struct S_IID f19_S_SSD_IID(struct S_IID p0, struct S_IID p1, double p2) ;
+EXPORT struct S_IIP f19_S_SSD_IIP(struct S_IIP p0, struct S_IIP p1, double p2) ;
+EXPORT struct S_IFI f19_S_SSD_IFI(struct S_IFI p0, struct S_IFI p1, double p2) ;
+EXPORT struct S_IFF f19_S_SSD_IFF(struct S_IFF p0, struct S_IFF p1, double p2) ;
+EXPORT struct S_IFD f19_S_SSD_IFD(struct S_IFD p0, struct S_IFD p1, double p2) ;
+EXPORT struct S_IFP f19_S_SSD_IFP(struct S_IFP p0, struct S_IFP p1, double p2) ;
+EXPORT struct S_IDI f19_S_SSD_IDI(struct S_IDI p0, struct S_IDI p1, double p2) ;
+EXPORT struct S_IDF f19_S_SSD_IDF(struct S_IDF p0, struct S_IDF p1, double p2) ;
+EXPORT struct S_IDD f19_S_SSD_IDD(struct S_IDD p0, struct S_IDD p1, double p2) ;
+EXPORT struct S_IDP f19_S_SSD_IDP(struct S_IDP p0, struct S_IDP p1, double p2) ;
+EXPORT struct S_IPI f19_S_SSD_IPI(struct S_IPI p0, struct S_IPI p1, double p2) ;
+EXPORT struct S_IPF f19_S_SSD_IPF(struct S_IPF p0, struct S_IPF p1, double p2) ;
+EXPORT struct S_IPD f19_S_SSD_IPD(struct S_IPD p0, struct S_IPD p1, double p2) ;
+EXPORT struct S_IPP f19_S_SSD_IPP(struct S_IPP p0, struct S_IPP p1, double p2) ;
+EXPORT struct S_FII f19_S_SSD_FII(struct S_FII p0, struct S_FII p1, double p2) ;
+EXPORT struct S_FIF f19_S_SSD_FIF(struct S_FIF p0, struct S_FIF p1, double p2) ;
+EXPORT struct S_FID f19_S_SSD_FID(struct S_FID p0, struct S_FID p1, double p2) ;
+EXPORT struct S_FIP f19_S_SSD_FIP(struct S_FIP p0, struct S_FIP p1, double p2) ;
+EXPORT struct S_FFI f19_S_SSD_FFI(struct S_FFI p0, struct S_FFI p1, double p2) ;
+EXPORT struct S_FFF f19_S_SSD_FFF(struct S_FFF p0, struct S_FFF p1, double p2) ;
+EXPORT struct S_FFD f19_S_SSD_FFD(struct S_FFD p0, struct S_FFD p1, double p2) ;
+EXPORT struct S_FFP f19_S_SSD_FFP(struct S_FFP p0, struct S_FFP p1, double p2) ;
+EXPORT struct S_FDI f19_S_SSD_FDI(struct S_FDI p0, struct S_FDI p1, double p2) ;
+EXPORT struct S_FDF f19_S_SSD_FDF(struct S_FDF p0, struct S_FDF p1, double p2) ;
+EXPORT struct S_FDD f19_S_SSD_FDD(struct S_FDD p0, struct S_FDD p1, double p2) ;
+EXPORT struct S_FDP f19_S_SSD_FDP(struct S_FDP p0, struct S_FDP p1, double p2) ;
+EXPORT struct S_FPI f19_S_SSD_FPI(struct S_FPI p0, struct S_FPI p1, double p2) ;
+EXPORT struct S_FPF f19_S_SSD_FPF(struct S_FPF p0, struct S_FPF p1, double p2) ;
+EXPORT struct S_FPD f19_S_SSD_FPD(struct S_FPD p0, struct S_FPD p1, double p2) ;
+EXPORT struct S_FPP f19_S_SSD_FPP(struct S_FPP p0, struct S_FPP p1, double p2) ;
+EXPORT struct S_DII f19_S_SSD_DII(struct S_DII p0, struct S_DII p1, double p2) ;
+EXPORT struct S_DIF f19_S_SSD_DIF(struct S_DIF p0, struct S_DIF p1, double p2) ;
+EXPORT struct S_DID f19_S_SSD_DID(struct S_DID p0, struct S_DID p1, double p2) ;
+EXPORT struct S_DIP f19_S_SSD_DIP(struct S_DIP p0, struct S_DIP p1, double p2) ;
+EXPORT struct S_DFI f19_S_SSD_DFI(struct S_DFI p0, struct S_DFI p1, double p2) ;
+EXPORT struct S_DFF f19_S_SSD_DFF(struct S_DFF p0, struct S_DFF p1, double p2) ;
+EXPORT struct S_DFD f19_S_SSD_DFD(struct S_DFD p0, struct S_DFD p1, double p2) ;
+EXPORT struct S_DFP f19_S_SSD_DFP(struct S_DFP p0, struct S_DFP p1, double p2) ;
+EXPORT struct S_DDI f19_S_SSD_DDI(struct S_DDI p0, struct S_DDI p1, double p2) ;
+EXPORT struct S_DDF f19_S_SSD_DDF(struct S_DDF p0, struct S_DDF p1, double p2) ;
+EXPORT struct S_DDD f19_S_SSD_DDD(struct S_DDD p0, struct S_DDD p1, double p2) ;
+EXPORT struct S_DDP f19_S_SSD_DDP(struct S_DDP p0, struct S_DDP p1, double p2) ;
+EXPORT struct S_DPI f19_S_SSD_DPI(struct S_DPI p0, struct S_DPI p1, double p2) ;
+EXPORT struct S_DPF f19_S_SSD_DPF(struct S_DPF p0, struct S_DPF p1, double p2) ;
+EXPORT struct S_DPD f19_S_SSD_DPD(struct S_DPD p0, struct S_DPD p1, double p2) ;
+EXPORT struct S_DPP f19_S_SSD_DPP(struct S_DPP p0, struct S_DPP p1, double p2) ;
+EXPORT struct S_PII f19_S_SSD_PII(struct S_PII p0, struct S_PII p1, double p2) ;
+EXPORT struct S_PIF f19_S_SSD_PIF(struct S_PIF p0, struct S_PIF p1, double p2) ;
+EXPORT struct S_PID f19_S_SSD_PID(struct S_PID p0, struct S_PID p1, double p2) ;
+EXPORT struct S_PIP f19_S_SSD_PIP(struct S_PIP p0, struct S_PIP p1, double p2) ;
+EXPORT struct S_PFI f19_S_SSD_PFI(struct S_PFI p0, struct S_PFI p1, double p2) ;
+EXPORT struct S_PFF f19_S_SSD_PFF(struct S_PFF p0, struct S_PFF p1, double p2) ;
+EXPORT struct S_PFD f19_S_SSD_PFD(struct S_PFD p0, struct S_PFD p1, double p2) ;
+EXPORT struct S_PFP f19_S_SSD_PFP(struct S_PFP p0, struct S_PFP p1, double p2) ;
+EXPORT struct S_PDI f19_S_SSD_PDI(struct S_PDI p0, struct S_PDI p1, double p2) ;
+EXPORT struct S_PDF f19_S_SSD_PDF(struct S_PDF p0, struct S_PDF p1, double p2) ;
+EXPORT struct S_PDD f19_S_SSD_PDD(struct S_PDD p0, struct S_PDD p1, double p2) ;
+EXPORT struct S_PDP f19_S_SSD_PDP(struct S_PDP p0, struct S_PDP p1, double p2) ;
+EXPORT struct S_PPI f19_S_SSD_PPI(struct S_PPI p0, struct S_PPI p1, double p2) ;
+EXPORT struct S_PPF f19_S_SSD_PPF(struct S_PPF p0, struct S_PPF p1, double p2) ;
+EXPORT struct S_PPD f19_S_SSD_PPD(struct S_PPD p0, struct S_PPD p1, double p2) ;
+EXPORT struct S_PPP f19_S_SSD_PPP(struct S_PPP p0, struct S_PPP p1, double p2) ;
+EXPORT struct S_I f19_S_SSP_I(struct S_I p0, struct S_I p1, void* p2) ;
+EXPORT struct S_F f19_S_SSP_F(struct S_F p0, struct S_F p1, void* p2) ;
+EXPORT struct S_D f19_S_SSP_D(struct S_D p0, struct S_D p1, void* p2) ;
+EXPORT struct S_P f19_S_SSP_P(struct S_P p0, struct S_P p1, void* p2) ;
+EXPORT struct S_II f19_S_SSP_II(struct S_II p0, struct S_II p1, void* p2) ;
+EXPORT struct S_IF f19_S_SSP_IF(struct S_IF p0, struct S_IF p1, void* p2) ;
+EXPORT struct S_ID f19_S_SSP_ID(struct S_ID p0, struct S_ID p1, void* p2) ;
+EXPORT struct S_IP f19_S_SSP_IP(struct S_IP p0, struct S_IP p1, void* p2) ;
+EXPORT struct S_FI f19_S_SSP_FI(struct S_FI p0, struct S_FI p1, void* p2) ;
+EXPORT struct S_FF f19_S_SSP_FF(struct S_FF p0, struct S_FF p1, void* p2) ;
+EXPORT struct S_FD f19_S_SSP_FD(struct S_FD p0, struct S_FD p1, void* p2) ;
+EXPORT struct S_FP f19_S_SSP_FP(struct S_FP p0, struct S_FP p1, void* p2) ;
+EXPORT struct S_DI f19_S_SSP_DI(struct S_DI p0, struct S_DI p1, void* p2) ;
+EXPORT struct S_DF f19_S_SSP_DF(struct S_DF p0, struct S_DF p1, void* p2) ;
+EXPORT struct S_DD f19_S_SSP_DD(struct S_DD p0, struct S_DD p1, void* p2) ;
+EXPORT struct S_DP f19_S_SSP_DP(struct S_DP p0, struct S_DP p1, void* p2) ;
+EXPORT struct S_PI f19_S_SSP_PI(struct S_PI p0, struct S_PI p1, void* p2) ;
+EXPORT struct S_PF f19_S_SSP_PF(struct S_PF p0, struct S_PF p1, void* p2) ;
+EXPORT struct S_PD f19_S_SSP_PD(struct S_PD p0, struct S_PD p1, void* p2) ;
+EXPORT struct S_PP f19_S_SSP_PP(struct S_PP p0, struct S_PP p1, void* p2) ;
+EXPORT struct S_III f19_S_SSP_III(struct S_III p0, struct S_III p1, void* p2) ;
+EXPORT struct S_IIF f19_S_SSP_IIF(struct S_IIF p0, struct S_IIF p1, void* p2) ;
+EXPORT struct S_IID f19_S_SSP_IID(struct S_IID p0, struct S_IID p1, void* p2) ;
+EXPORT struct S_IIP f19_S_SSP_IIP(struct S_IIP p0, struct S_IIP p1, void* p2) ;
+EXPORT struct S_IFI f19_S_SSP_IFI(struct S_IFI p0, struct S_IFI p1, void* p2) ;
+EXPORT struct S_IFF f19_S_SSP_IFF(struct S_IFF p0, struct S_IFF p1, void* p2) ;
+EXPORT struct S_IFD f19_S_SSP_IFD(struct S_IFD p0, struct S_IFD p1, void* p2) ;
+EXPORT struct S_IFP f19_S_SSP_IFP(struct S_IFP p0, struct S_IFP p1, void* p2) ;
+EXPORT struct S_IDI f19_S_SSP_IDI(struct S_IDI p0, struct S_IDI p1, void* p2) ;
+EXPORT struct S_IDF f19_S_SSP_IDF(struct S_IDF p0, struct S_IDF p1, void* p2) ;
+EXPORT struct S_IDD f19_S_SSP_IDD(struct S_IDD p0, struct S_IDD p1, void* p2) ;
+EXPORT struct S_IDP f19_S_SSP_IDP(struct S_IDP p0, struct S_IDP p1, void* p2) ;
+EXPORT struct S_IPI f19_S_SSP_IPI(struct S_IPI p0, struct S_IPI p1, void* p2) ;
+EXPORT struct S_IPF f19_S_SSP_IPF(struct S_IPF p0, struct S_IPF p1, void* p2) ;
+EXPORT struct S_IPD f19_S_SSP_IPD(struct S_IPD p0, struct S_IPD p1, void* p2) ;
+EXPORT struct S_IPP f19_S_SSP_IPP(struct S_IPP p0, struct S_IPP p1, void* p2) ;
+EXPORT struct S_FII f19_S_SSP_FII(struct S_FII p0, struct S_FII p1, void* p2) ;
+EXPORT struct S_FIF f19_S_SSP_FIF(struct S_FIF p0, struct S_FIF p1, void* p2) ;
+EXPORT struct S_FID f19_S_SSP_FID(struct S_FID p0, struct S_FID p1, void* p2) ;
+EXPORT struct S_FIP f19_S_SSP_FIP(struct S_FIP p0, struct S_FIP p1, void* p2) ;
+EXPORT struct S_FFI f19_S_SSP_FFI(struct S_FFI p0, struct S_FFI p1, void* p2) ;
+EXPORT struct S_FFF f19_S_SSP_FFF(struct S_FFF p0, struct S_FFF p1, void* p2) ;
+EXPORT struct S_FFD f19_S_SSP_FFD(struct S_FFD p0, struct S_FFD p1, void* p2) ;
+EXPORT struct S_FFP f19_S_SSP_FFP(struct S_FFP p0, struct S_FFP p1, void* p2) ;
+EXPORT struct S_FDI f19_S_SSP_FDI(struct S_FDI p0, struct S_FDI p1, void* p2) ;
+EXPORT struct S_FDF f19_S_SSP_FDF(struct S_FDF p0, struct S_FDF p1, void* p2) ;
+EXPORT struct S_FDD f19_S_SSP_FDD(struct S_FDD p0, struct S_FDD p1, void* p2) ;
+EXPORT struct S_FDP f19_S_SSP_FDP(struct S_FDP p0, struct S_FDP p1, void* p2) ;
+EXPORT struct S_FPI f19_S_SSP_FPI(struct S_FPI p0, struct S_FPI p1, void* p2) ;
+EXPORT struct S_FPF f19_S_SSP_FPF(struct S_FPF p0, struct S_FPF p1, void* p2) ;
+EXPORT struct S_FPD f19_S_SSP_FPD(struct S_FPD p0, struct S_FPD p1, void* p2) ;
+EXPORT struct S_FPP f19_S_SSP_FPP(struct S_FPP p0, struct S_FPP p1, void* p2) ;
+EXPORT struct S_DII f19_S_SSP_DII(struct S_DII p0, struct S_DII p1, void* p2) ;
+EXPORT struct S_DIF f19_S_SSP_DIF(struct S_DIF p0, struct S_DIF p1, void* p2) ;
+EXPORT struct S_DID f19_S_SSP_DID(struct S_DID p0, struct S_DID p1, void* p2) ;
+EXPORT struct S_DIP f19_S_SSP_DIP(struct S_DIP p0, struct S_DIP p1, void* p2) ;
+EXPORT struct S_DFI f19_S_SSP_DFI(struct S_DFI p0, struct S_DFI p1, void* p2) ;
+EXPORT struct S_DFF f19_S_SSP_DFF(struct S_DFF p0, struct S_DFF p1, void* p2) ;
+EXPORT struct S_DFD f19_S_SSP_DFD(struct S_DFD p0, struct S_DFD p1, void* p2) ;
+EXPORT struct S_DFP f19_S_SSP_DFP(struct S_DFP p0, struct S_DFP p1, void* p2) ;
+EXPORT struct S_DDI f19_S_SSP_DDI(struct S_DDI p0, struct S_DDI p1, void* p2) ;
+EXPORT struct S_DDF f19_S_SSP_DDF(struct S_DDF p0, struct S_DDF p1, void* p2) ;
+EXPORT struct S_DDD f19_S_SSP_DDD(struct S_DDD p0, struct S_DDD p1, void* p2) ;
+EXPORT struct S_DDP f19_S_SSP_DDP(struct S_DDP p0, struct S_DDP p1, void* p2) ;
+EXPORT struct S_DPI f19_S_SSP_DPI(struct S_DPI p0, struct S_DPI p1, void* p2) ;
+EXPORT struct S_DPF f19_S_SSP_DPF(struct S_DPF p0, struct S_DPF p1, void* p2) ;
+EXPORT struct S_DPD f19_S_SSP_DPD(struct S_DPD p0, struct S_DPD p1, void* p2) ;
+EXPORT struct S_DPP f19_S_SSP_DPP(struct S_DPP p0, struct S_DPP p1, void* p2) ;
+EXPORT struct S_PII f19_S_SSP_PII(struct S_PII p0, struct S_PII p1, void* p2) ;
+EXPORT struct S_PIF f19_S_SSP_PIF(struct S_PIF p0, struct S_PIF p1, void* p2) ;
+EXPORT struct S_PID f19_S_SSP_PID(struct S_PID p0, struct S_PID p1, void* p2) ;
+EXPORT struct S_PIP f20_S_SSP_PIP(struct S_PIP p0, struct S_PIP p1, void* p2) ;
+EXPORT struct S_PFI f20_S_SSP_PFI(struct S_PFI p0, struct S_PFI p1, void* p2) ;
+EXPORT struct S_PFF f20_S_SSP_PFF(struct S_PFF p0, struct S_PFF p1, void* p2) ;
+EXPORT struct S_PFD f20_S_SSP_PFD(struct S_PFD p0, struct S_PFD p1, void* p2) ;
+EXPORT struct S_PFP f20_S_SSP_PFP(struct S_PFP p0, struct S_PFP p1, void* p2) ;
+EXPORT struct S_PDI f20_S_SSP_PDI(struct S_PDI p0, struct S_PDI p1, void* p2) ;
+EXPORT struct S_PDF f20_S_SSP_PDF(struct S_PDF p0, struct S_PDF p1, void* p2) ;
+EXPORT struct S_PDD f20_S_SSP_PDD(struct S_PDD p0, struct S_PDD p1, void* p2) ;
+EXPORT struct S_PDP f20_S_SSP_PDP(struct S_PDP p0, struct S_PDP p1, void* p2) ;
+EXPORT struct S_PPI f20_S_SSP_PPI(struct S_PPI p0, struct S_PPI p1, void* p2) ;
+EXPORT struct S_PPF f20_S_SSP_PPF(struct S_PPF p0, struct S_PPF p1, void* p2) ;
+EXPORT struct S_PPD f20_S_SSP_PPD(struct S_PPD p0, struct S_PPD p1, void* p2) ;
+EXPORT struct S_PPP f20_S_SSP_PPP(struct S_PPP p0, struct S_PPP p1, void* p2) ;
+EXPORT struct S_I f20_S_SSS_I(struct S_I p0, struct S_I p1, struct S_I p2) ;
+EXPORT struct S_F f20_S_SSS_F(struct S_F p0, struct S_F p1, struct S_F p2) ;
+EXPORT struct S_D f20_S_SSS_D(struct S_D p0, struct S_D p1, struct S_D p2) ;
+EXPORT struct S_P f20_S_SSS_P(struct S_P p0, struct S_P p1, struct S_P p2) ;
+EXPORT struct S_II f20_S_SSS_II(struct S_II p0, struct S_II p1, struct S_II p2) ;
+EXPORT struct S_IF f20_S_SSS_IF(struct S_IF p0, struct S_IF p1, struct S_IF p2) ;
+EXPORT struct S_ID f20_S_SSS_ID(struct S_ID p0, struct S_ID p1, struct S_ID p2) ;
+EXPORT struct S_IP f20_S_SSS_IP(struct S_IP p0, struct S_IP p1, struct S_IP p2) ;
+EXPORT struct S_FI f20_S_SSS_FI(struct S_FI p0, struct S_FI p1, struct S_FI p2) ;
+EXPORT struct S_FF f20_S_SSS_FF(struct S_FF p0, struct S_FF p1, struct S_FF p2) ;
+EXPORT struct S_FD f20_S_SSS_FD(struct S_FD p0, struct S_FD p1, struct S_FD p2) ;
+EXPORT struct S_FP f20_S_SSS_FP(struct S_FP p0, struct S_FP p1, struct S_FP p2) ;
+EXPORT struct S_DI f20_S_SSS_DI(struct S_DI p0, struct S_DI p1, struct S_DI p2) ;
+EXPORT struct S_DF f20_S_SSS_DF(struct S_DF p0, struct S_DF p1, struct S_DF p2) ;
+EXPORT struct S_DD f20_S_SSS_DD(struct S_DD p0, struct S_DD p1, struct S_DD p2) ;
+EXPORT struct S_DP f20_S_SSS_DP(struct S_DP p0, struct S_DP p1, struct S_DP p2) ;
+EXPORT struct S_PI f20_S_SSS_PI(struct S_PI p0, struct S_PI p1, struct S_PI p2) ;
+EXPORT struct S_PF f20_S_SSS_PF(struct S_PF p0, struct S_PF p1, struct S_PF p2) ;
+EXPORT struct S_PD f20_S_SSS_PD(struct S_PD p0, struct S_PD p1, struct S_PD p2) ;
+EXPORT struct S_PP f20_S_SSS_PP(struct S_PP p0, struct S_PP p1, struct S_PP p2) ;
+EXPORT struct S_III f20_S_SSS_III(struct S_III p0, struct S_III p1, struct S_III p2) ;
+EXPORT struct S_IIF f20_S_SSS_IIF(struct S_IIF p0, struct S_IIF p1, struct S_IIF p2) ;
+EXPORT struct S_IID f20_S_SSS_IID(struct S_IID p0, struct S_IID p1, struct S_IID p2) ;
+EXPORT struct S_IIP f20_S_SSS_IIP(struct S_IIP p0, struct S_IIP p1, struct S_IIP p2) ;
+EXPORT struct S_IFI f20_S_SSS_IFI(struct S_IFI p0, struct S_IFI p1, struct S_IFI p2) ;
+EXPORT struct S_IFF f20_S_SSS_IFF(struct S_IFF p0, struct S_IFF p1, struct S_IFF p2) ;
+EXPORT struct S_IFD f20_S_SSS_IFD(struct S_IFD p0, struct S_IFD p1, struct S_IFD p2) ;
+EXPORT struct S_IFP f20_S_SSS_IFP(struct S_IFP p0, struct S_IFP p1, struct S_IFP p2) ;
+EXPORT struct S_IDI f20_S_SSS_IDI(struct S_IDI p0, struct S_IDI p1, struct S_IDI p2) ;
+EXPORT struct S_IDF f20_S_SSS_IDF(struct S_IDF p0, struct S_IDF p1, struct S_IDF p2) ;
+EXPORT struct S_IDD f20_S_SSS_IDD(struct S_IDD p0, struct S_IDD p1, struct S_IDD p2) ;
+EXPORT struct S_IDP f20_S_SSS_IDP(struct S_IDP p0, struct S_IDP p1, struct S_IDP p2) ;
+EXPORT struct S_IPI f20_S_SSS_IPI(struct S_IPI p0, struct S_IPI p1, struct S_IPI p2) ;
+EXPORT struct S_IPF f20_S_SSS_IPF(struct S_IPF p0, struct S_IPF p1, struct S_IPF p2) ;
+EXPORT struct S_IPD f20_S_SSS_IPD(struct S_IPD p0, struct S_IPD p1, struct S_IPD p2) ;
+EXPORT struct S_IPP f20_S_SSS_IPP(struct S_IPP p0, struct S_IPP p1, struct S_IPP p2) ;
+EXPORT struct S_FII f20_S_SSS_FII(struct S_FII p0, struct S_FII p1, struct S_FII p2) ;
+EXPORT struct S_FIF f20_S_SSS_FIF(struct S_FIF p0, struct S_FIF p1, struct S_FIF p2) ;
+EXPORT struct S_FID f20_S_SSS_FID(struct S_FID p0, struct S_FID p1, struct S_FID p2) ;
+EXPORT struct S_FIP f20_S_SSS_FIP(struct S_FIP p0, struct S_FIP p1, struct S_FIP p2) ;
+EXPORT struct S_FFI f20_S_SSS_FFI(struct S_FFI p0, struct S_FFI p1, struct S_FFI p2) ;
+EXPORT struct S_FFF f20_S_SSS_FFF(struct S_FFF p0, struct S_FFF p1, struct S_FFF p2) ;
+EXPORT struct S_FFD f20_S_SSS_FFD(struct S_FFD p0, struct S_FFD p1, struct S_FFD p2) ;
+EXPORT struct S_FFP f20_S_SSS_FFP(struct S_FFP p0, struct S_FFP p1, struct S_FFP p2) ;
+EXPORT struct S_FDI f20_S_SSS_FDI(struct S_FDI p0, struct S_FDI p1, struct S_FDI p2) ;
+EXPORT struct S_FDF f20_S_SSS_FDF(struct S_FDF p0, struct S_FDF p1, struct S_FDF p2) ;
+EXPORT struct S_FDD f20_S_SSS_FDD(struct S_FDD p0, struct S_FDD p1, struct S_FDD p2) ;
+EXPORT struct S_FDP f20_S_SSS_FDP(struct S_FDP p0, struct S_FDP p1, struct S_FDP p2) ;
+EXPORT struct S_FPI f20_S_SSS_FPI(struct S_FPI p0, struct S_FPI p1, struct S_FPI p2) ;
+EXPORT struct S_FPF f20_S_SSS_FPF(struct S_FPF p0, struct S_FPF p1, struct S_FPF p2) ;
+EXPORT struct S_FPD f20_S_SSS_FPD(struct S_FPD p0, struct S_FPD p1, struct S_FPD p2) ;
+EXPORT struct S_FPP f20_S_SSS_FPP(struct S_FPP p0, struct S_FPP p1, struct S_FPP p2) ;
+EXPORT struct S_DII f20_S_SSS_DII(struct S_DII p0, struct S_DII p1, struct S_DII p2) ;
+EXPORT struct S_DIF f20_S_SSS_DIF(struct S_DIF p0, struct S_DIF p1, struct S_DIF p2) ;
+EXPORT struct S_DID f20_S_SSS_DID(struct S_DID p0, struct S_DID p1, struct S_DID p2) ;
+EXPORT struct S_DIP f20_S_SSS_DIP(struct S_DIP p0, struct S_DIP p1, struct S_DIP p2) ;
+EXPORT struct S_DFI f20_S_SSS_DFI(struct S_DFI p0, struct S_DFI p1, struct S_DFI p2) ;
+EXPORT struct S_DFF f20_S_SSS_DFF(struct S_DFF p0, struct S_DFF p1, struct S_DFF p2) ;
+EXPORT struct S_DFD f20_S_SSS_DFD(struct S_DFD p0, struct S_DFD p1, struct S_DFD p2) ;
+EXPORT struct S_DFP f20_S_SSS_DFP(struct S_DFP p0, struct S_DFP p1, struct S_DFP p2) ;
+EXPORT struct S_DDI f20_S_SSS_DDI(struct S_DDI p0, struct S_DDI p1, struct S_DDI p2) ;
+EXPORT struct S_DDF f20_S_SSS_DDF(struct S_DDF p0, struct S_DDF p1, struct S_DDF p2) ;
+EXPORT struct S_DDD f20_S_SSS_DDD(struct S_DDD p0, struct S_DDD p1, struct S_DDD p2) ;
+EXPORT struct S_DDP f20_S_SSS_DDP(struct S_DDP p0, struct S_DDP p1, struct S_DDP p2) ;
+EXPORT struct S_DPI f20_S_SSS_DPI(struct S_DPI p0, struct S_DPI p1, struct S_DPI p2) ;
+EXPORT struct S_DPF f20_S_SSS_DPF(struct S_DPF p0, struct S_DPF p1, struct S_DPF p2) ;
+EXPORT struct S_DPD f20_S_SSS_DPD(struct S_DPD p0, struct S_DPD p1, struct S_DPD p2) ;
+EXPORT struct S_DPP f20_S_SSS_DPP(struct S_DPP p0, struct S_DPP p1, struct S_DPP p2) ;
+EXPORT struct S_PII f20_S_SSS_PII(struct S_PII p0, struct S_PII p1, struct S_PII p2) ;
+EXPORT struct S_PIF f20_S_SSS_PIF(struct S_PIF p0, struct S_PIF p1, struct S_PIF p2) ;
+EXPORT struct S_PID f20_S_SSS_PID(struct S_PID p0, struct S_PID p1, struct S_PID p2) ;
+EXPORT struct S_PIP f20_S_SSS_PIP(struct S_PIP p0, struct S_PIP p1, struct S_PIP p2) ;
+EXPORT struct S_PFI f20_S_SSS_PFI(struct S_PFI p0, struct S_PFI p1, struct S_PFI p2) ;
+EXPORT struct S_PFF f20_S_SSS_PFF(struct S_PFF p0, struct S_PFF p1, struct S_PFF p2) ;
+EXPORT struct S_PFD f20_S_SSS_PFD(struct S_PFD p0, struct S_PFD p1, struct S_PFD p2) ;
+EXPORT struct S_PFP f20_S_SSS_PFP(struct S_PFP p0, struct S_PFP p1, struct S_PFP p2) ;
+EXPORT struct S_PDI f20_S_SSS_PDI(struct S_PDI p0, struct S_PDI p1, struct S_PDI p2) ;
+EXPORT struct S_PDF f20_S_SSS_PDF(struct S_PDF p0, struct S_PDF p1, struct S_PDF p2) ;
+EXPORT struct S_PDD f20_S_SSS_PDD(struct S_PDD p0, struct S_PDD p1, struct S_PDD p2) ;
+EXPORT struct S_PDP f20_S_SSS_PDP(struct S_PDP p0, struct S_PDP p1, struct S_PDP p2) ;
+EXPORT struct S_PPI f20_S_SSS_PPI(struct S_PPI p0, struct S_PPI p1, struct S_PPI p2) ;
+EXPORT struct S_PPF f20_S_SSS_PPF(struct S_PPF p0, struct S_PPF p1, struct S_PPF p2) ;
+EXPORT struct S_PPD f20_S_SSS_PPD(struct S_PPD p0, struct S_PPD p1, struct S_PPD p2) ;
+EXPORT struct S_PPP f20_S_SSS_PPP(struct S_PPP p0, struct S_PPP p1, struct S_PPP p2) ;
diff --git a/test/jdk/java/foreign/libTestUpcall.c b/test/jdk/java/foreign/libTestUpcall.c
new file mode 100644
index 0000000000000..d73bd3c3e034a
--- /dev/null
+++ b/test/jdk/java/foreign/libTestUpcall.c
@@ -0,0 +1,12129 @@
+/*
+ * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+#include "libTestUpcall.h"
+#ifdef __clang__
+#pragma clang optimize off
+#elif defined __GNUC__
+#pragma GCC optimize ("O0")
+#elif defined _MSC_BUILD
+#pragma optimize( "", off )
+#endif
+
+EXPORT void f0_V__( void (*cb)(void)) { cb(); }
+EXPORT void f0_V_I_(int p0,  void (*cb)(int)) { cb(p0); }
+EXPORT void f0_V_F_(float p0,  void (*cb)(float)) { cb(p0); }
+EXPORT void f0_V_D_(double p0,  void (*cb)(double)) { cb(p0); }
+EXPORT void f0_V_P_(void* p0,  void (*cb)(void*)) { cb(p0); }
+EXPORT void f0_V_S_I(struct S_I p0,  void (*cb)(struct S_I)) { cb(p0); }
+EXPORT void f0_V_S_F(struct S_F p0,  void (*cb)(struct S_F)) { cb(p0); }
+EXPORT void f0_V_S_D(struct S_D p0,  void (*cb)(struct S_D)) { cb(p0); }
+EXPORT void f0_V_S_P(struct S_P p0,  void (*cb)(struct S_P)) { cb(p0); }
+EXPORT void f0_V_S_II(struct S_II p0,  void (*cb)(struct S_II)) { cb(p0); }
+EXPORT void f0_V_S_IF(struct S_IF p0,  void (*cb)(struct S_IF)) { cb(p0); }
+EXPORT void f0_V_S_ID(struct S_ID p0,  void (*cb)(struct S_ID)) { cb(p0); }
+EXPORT void f0_V_S_IP(struct S_IP p0,  void (*cb)(struct S_IP)) { cb(p0); }
+EXPORT void f0_V_S_FI(struct S_FI p0,  void (*cb)(struct S_FI)) { cb(p0); }
+EXPORT void f0_V_S_FF(struct S_FF p0,  void (*cb)(struct S_FF)) { cb(p0); }
+EXPORT void f0_V_S_FD(struct S_FD p0,  void (*cb)(struct S_FD)) { cb(p0); }
+EXPORT void f0_V_S_FP(struct S_FP p0,  void (*cb)(struct S_FP)) { cb(p0); }
+EXPORT void f0_V_S_DI(struct S_DI p0,  void (*cb)(struct S_DI)) { cb(p0); }
+EXPORT void f0_V_S_DF(struct S_DF p0,  void (*cb)(struct S_DF)) { cb(p0); }
+EXPORT void f0_V_S_DD(struct S_DD p0,  void (*cb)(struct S_DD)) { cb(p0); }
+EXPORT void f0_V_S_DP(struct S_DP p0,  void (*cb)(struct S_DP)) { cb(p0); }
+EXPORT void f0_V_S_PI(struct S_PI p0,  void (*cb)(struct S_PI)) { cb(p0); }
+EXPORT void f0_V_S_PF(struct S_PF p0,  void (*cb)(struct S_PF)) { cb(p0); }
+EXPORT void f0_V_S_PD(struct S_PD p0,  void (*cb)(struct S_PD)) { cb(p0); }
+EXPORT void f0_V_S_PP(struct S_PP p0,  void (*cb)(struct S_PP)) { cb(p0); }
+EXPORT void f0_V_S_III(struct S_III p0,  void (*cb)(struct S_III)) { cb(p0); }
+EXPORT void f0_V_S_IIF(struct S_IIF p0,  void (*cb)(struct S_IIF)) { cb(p0); }
+EXPORT void f0_V_S_IID(struct S_IID p0,  void (*cb)(struct S_IID)) { cb(p0); }
+EXPORT void f0_V_S_IIP(struct S_IIP p0,  void (*cb)(struct S_IIP)) { cb(p0); }
+EXPORT void f0_V_S_IFI(struct S_IFI p0,  void (*cb)(struct S_IFI)) { cb(p0); }
+EXPORT void f0_V_S_IFF(struct S_IFF p0,  void (*cb)(struct S_IFF)) { cb(p0); }
+EXPORT void f0_V_S_IFD(struct S_IFD p0,  void (*cb)(struct S_IFD)) { cb(p0); }
+EXPORT void f0_V_S_IFP(struct S_IFP p0,  void (*cb)(struct S_IFP)) { cb(p0); }
+EXPORT void f0_V_S_IDI(struct S_IDI p0,  void (*cb)(struct S_IDI)) { cb(p0); }
+EXPORT void f0_V_S_IDF(struct S_IDF p0,  void (*cb)(struct S_IDF)) { cb(p0); }
+EXPORT void f0_V_S_IDD(struct S_IDD p0,  void (*cb)(struct S_IDD)) { cb(p0); }
+EXPORT void f0_V_S_IDP(struct S_IDP p0,  void (*cb)(struct S_IDP)) { cb(p0); }
+EXPORT void f0_V_S_IPI(struct S_IPI p0,  void (*cb)(struct S_IPI)) { cb(p0); }
+EXPORT void f0_V_S_IPF(struct S_IPF p0,  void (*cb)(struct S_IPF)) { cb(p0); }
+EXPORT void f0_V_S_IPD(struct S_IPD p0,  void (*cb)(struct S_IPD)) { cb(p0); }
+EXPORT void f0_V_S_IPP(struct S_IPP p0,  void (*cb)(struct S_IPP)) { cb(p0); }
+EXPORT void f0_V_S_FII(struct S_FII p0,  void (*cb)(struct S_FII)) { cb(p0); }
+EXPORT void f0_V_S_FIF(struct S_FIF p0,  void (*cb)(struct S_FIF)) { cb(p0); }
+EXPORT void f0_V_S_FID(struct S_FID p0,  void (*cb)(struct S_FID)) { cb(p0); }
+EXPORT void f0_V_S_FIP(struct S_FIP p0,  void (*cb)(struct S_FIP)) { cb(p0); }
+EXPORT void f0_V_S_FFI(struct S_FFI p0,  void (*cb)(struct S_FFI)) { cb(p0); }
+EXPORT void f0_V_S_FFF(struct S_FFF p0,  void (*cb)(struct S_FFF)) { cb(p0); }
+EXPORT void f0_V_S_FFD(struct S_FFD p0,  void (*cb)(struct S_FFD)) { cb(p0); }
+EXPORT void f0_V_S_FFP(struct S_FFP p0,  void (*cb)(struct S_FFP)) { cb(p0); }
+EXPORT void f0_V_S_FDI(struct S_FDI p0,  void (*cb)(struct S_FDI)) { cb(p0); }
+EXPORT void f0_V_S_FDF(struct S_FDF p0,  void (*cb)(struct S_FDF)) { cb(p0); }
+EXPORT void f0_V_S_FDD(struct S_FDD p0,  void (*cb)(struct S_FDD)) { cb(p0); }
+EXPORT void f0_V_S_FDP(struct S_FDP p0,  void (*cb)(struct S_FDP)) { cb(p0); }
+EXPORT void f0_V_S_FPI(struct S_FPI p0,  void (*cb)(struct S_FPI)) { cb(p0); }
+EXPORT void f0_V_S_FPF(struct S_FPF p0,  void (*cb)(struct S_FPF)) { cb(p0); }
+EXPORT void f0_V_S_FPD(struct S_FPD p0,  void (*cb)(struct S_FPD)) { cb(p0); }
+EXPORT void f0_V_S_FPP(struct S_FPP p0,  void (*cb)(struct S_FPP)) { cb(p0); }
+EXPORT void f0_V_S_DII(struct S_DII p0,  void (*cb)(struct S_DII)) { cb(p0); }
+EXPORT void f0_V_S_DIF(struct S_DIF p0,  void (*cb)(struct S_DIF)) { cb(p0); }
+EXPORT void f0_V_S_DID(struct S_DID p0,  void (*cb)(struct S_DID)) { cb(p0); }
+EXPORT void f0_V_S_DIP(struct S_DIP p0,  void (*cb)(struct S_DIP)) { cb(p0); }
+EXPORT void f0_V_S_DFI(struct S_DFI p0,  void (*cb)(struct S_DFI)) { cb(p0); }
+EXPORT void f0_V_S_DFF(struct S_DFF p0,  void (*cb)(struct S_DFF)) { cb(p0); }
+EXPORT void f0_V_S_DFD(struct S_DFD p0,  void (*cb)(struct S_DFD)) { cb(p0); }
+EXPORT void f0_V_S_DFP(struct S_DFP p0,  void (*cb)(struct S_DFP)) { cb(p0); }
+EXPORT void f0_V_S_DDI(struct S_DDI p0,  void (*cb)(struct S_DDI)) { cb(p0); }
+EXPORT void f0_V_S_DDF(struct S_DDF p0,  void (*cb)(struct S_DDF)) { cb(p0); }
+EXPORT void f0_V_S_DDD(struct S_DDD p0,  void (*cb)(struct S_DDD)) { cb(p0); }
+EXPORT void f0_V_S_DDP(struct S_DDP p0,  void (*cb)(struct S_DDP)) { cb(p0); }
+EXPORT void f0_V_S_DPI(struct S_DPI p0,  void (*cb)(struct S_DPI)) { cb(p0); }
+EXPORT void f0_V_S_DPF(struct S_DPF p0,  void (*cb)(struct S_DPF)) { cb(p0); }
+EXPORT void f0_V_S_DPD(struct S_DPD p0,  void (*cb)(struct S_DPD)) { cb(p0); }
+EXPORT void f0_V_S_DPP(struct S_DPP p0,  void (*cb)(struct S_DPP)) { cb(p0); }
+EXPORT void f0_V_S_PII(struct S_PII p0,  void (*cb)(struct S_PII)) { cb(p0); }
+EXPORT void f0_V_S_PIF(struct S_PIF p0,  void (*cb)(struct S_PIF)) { cb(p0); }
+EXPORT void f0_V_S_PID(struct S_PID p0,  void (*cb)(struct S_PID)) { cb(p0); }
+EXPORT void f0_V_S_PIP(struct S_PIP p0,  void (*cb)(struct S_PIP)) { cb(p0); }
+EXPORT void f0_V_S_PFI(struct S_PFI p0,  void (*cb)(struct S_PFI)) { cb(p0); }
+EXPORT void f0_V_S_PFF(struct S_PFF p0,  void (*cb)(struct S_PFF)) { cb(p0); }
+EXPORT void f0_V_S_PFD(struct S_PFD p0,  void (*cb)(struct S_PFD)) { cb(p0); }
+EXPORT void f0_V_S_PFP(struct S_PFP p0,  void (*cb)(struct S_PFP)) { cb(p0); }
+EXPORT void f0_V_S_PDI(struct S_PDI p0,  void (*cb)(struct S_PDI)) { cb(p0); }
+EXPORT void f0_V_S_PDF(struct S_PDF p0,  void (*cb)(struct S_PDF)) { cb(p0); }
+EXPORT void f0_V_S_PDD(struct S_PDD p0,  void (*cb)(struct S_PDD)) { cb(p0); }
+EXPORT void f0_V_S_PDP(struct S_PDP p0,  void (*cb)(struct S_PDP)) { cb(p0); }
+EXPORT void f0_V_S_PPI(struct S_PPI p0,  void (*cb)(struct S_PPI)) { cb(p0); }
+EXPORT void f0_V_S_PPF(struct S_PPF p0,  void (*cb)(struct S_PPF)) { cb(p0); }
+EXPORT void f0_V_S_PPD(struct S_PPD p0,  void (*cb)(struct S_PPD)) { cb(p0); }
+EXPORT void f0_V_S_PPP(struct S_PPP p0,  void (*cb)(struct S_PPP)) { cb(p0); }
+EXPORT void f0_V_II_(int p0, int p1,  void (*cb)(int, int)) { cb(p0,p1); }
+EXPORT void f0_V_IF_(int p0, float p1,  void (*cb)(int, float)) { cb(p0,p1); }
+EXPORT void f0_V_ID_(int p0, double p1,  void (*cb)(int, double)) { cb(p0,p1); }
+EXPORT void f0_V_IP_(int p0, void* p1,  void (*cb)(int, void*)) { cb(p0,p1); }
+EXPORT void f0_V_IS_I(int p0, struct S_I p1,  void (*cb)(int, struct S_I)) { cb(p0,p1); }
+EXPORT void f0_V_IS_F(int p0, struct S_F p1,  void (*cb)(int, struct S_F)) { cb(p0,p1); }
+EXPORT void f0_V_IS_D(int p0, struct S_D p1,  void (*cb)(int, struct S_D)) { cb(p0,p1); }
+EXPORT void f0_V_IS_P(int p0, struct S_P p1,  void (*cb)(int, struct S_P)) { cb(p0,p1); }
+EXPORT void f0_V_IS_II(int p0, struct S_II p1,  void (*cb)(int, struct S_II)) { cb(p0,p1); }
+EXPORT void f0_V_IS_IF(int p0, struct S_IF p1,  void (*cb)(int, struct S_IF)) { cb(p0,p1); }
+EXPORT void f0_V_IS_ID(int p0, struct S_ID p1,  void (*cb)(int, struct S_ID)) { cb(p0,p1); }
+EXPORT void f0_V_IS_IP(int p0, struct S_IP p1,  void (*cb)(int, struct S_IP)) { cb(p0,p1); }
+EXPORT void f0_V_IS_FI(int p0, struct S_FI p1,  void (*cb)(int, struct S_FI)) { cb(p0,p1); }
+EXPORT void f0_V_IS_FF(int p0, struct S_FF p1,  void (*cb)(int, struct S_FF)) { cb(p0,p1); }
+EXPORT void f0_V_IS_FD(int p0, struct S_FD p1,  void (*cb)(int, struct S_FD)) { cb(p0,p1); }
+EXPORT void f0_V_IS_FP(int p0, struct S_FP p1,  void (*cb)(int, struct S_FP)) { cb(p0,p1); }
+EXPORT void f0_V_IS_DI(int p0, struct S_DI p1,  void (*cb)(int, struct S_DI)) { cb(p0,p1); }
+EXPORT void f0_V_IS_DF(int p0, struct S_DF p1,  void (*cb)(int, struct S_DF)) { cb(p0,p1); }
+EXPORT void f0_V_IS_DD(int p0, struct S_DD p1,  void (*cb)(int, struct S_DD)) { cb(p0,p1); }
+EXPORT void f0_V_IS_DP(int p0, struct S_DP p1,  void (*cb)(int, struct S_DP)) { cb(p0,p1); }
+EXPORT void f0_V_IS_PI(int p0, struct S_PI p1,  void (*cb)(int, struct S_PI)) { cb(p0,p1); }
+EXPORT void f0_V_IS_PF(int p0, struct S_PF p1,  void (*cb)(int, struct S_PF)) { cb(p0,p1); }
+EXPORT void f0_V_IS_PD(int p0, struct S_PD p1,  void (*cb)(int, struct S_PD)) { cb(p0,p1); }
+EXPORT void f0_V_IS_PP(int p0, struct S_PP p1,  void (*cb)(int, struct S_PP)) { cb(p0,p1); }
+EXPORT void f0_V_IS_III(int p0, struct S_III p1,  void (*cb)(int, struct S_III)) { cb(p0,p1); }
+EXPORT void f0_V_IS_IIF(int p0, struct S_IIF p1,  void (*cb)(int, struct S_IIF)) { cb(p0,p1); }
+EXPORT void f0_V_IS_IID(int p0, struct S_IID p1,  void (*cb)(int, struct S_IID)) { cb(p0,p1); }
+EXPORT void f0_V_IS_IIP(int p0, struct S_IIP p1,  void (*cb)(int, struct S_IIP)) { cb(p0,p1); }
+EXPORT void f0_V_IS_IFI(int p0, struct S_IFI p1,  void (*cb)(int, struct S_IFI)) { cb(p0,p1); }
+EXPORT void f0_V_IS_IFF(int p0, struct S_IFF p1,  void (*cb)(int, struct S_IFF)) { cb(p0,p1); }
+EXPORT void f0_V_IS_IFD(int p0, struct S_IFD p1,  void (*cb)(int, struct S_IFD)) { cb(p0,p1); }
+EXPORT void f0_V_IS_IFP(int p0, struct S_IFP p1,  void (*cb)(int, struct S_IFP)) { cb(p0,p1); }
+EXPORT void f0_V_IS_IDI(int p0, struct S_IDI p1,  void (*cb)(int, struct S_IDI)) { cb(p0,p1); }
+EXPORT void f0_V_IS_IDF(int p0, struct S_IDF p1,  void (*cb)(int, struct S_IDF)) { cb(p0,p1); }
+EXPORT void f0_V_IS_IDD(int p0, struct S_IDD p1,  void (*cb)(int, struct S_IDD)) { cb(p0,p1); }
+EXPORT void f0_V_IS_IDP(int p0, struct S_IDP p1,  void (*cb)(int, struct S_IDP)) { cb(p0,p1); }
+EXPORT void f0_V_IS_IPI(int p0, struct S_IPI p1,  void (*cb)(int, struct S_IPI)) { cb(p0,p1); }
+EXPORT void f0_V_IS_IPF(int p0, struct S_IPF p1,  void (*cb)(int, struct S_IPF)) { cb(p0,p1); }
+EXPORT void f0_V_IS_IPD(int p0, struct S_IPD p1,  void (*cb)(int, struct S_IPD)) { cb(p0,p1); }
+EXPORT void f0_V_IS_IPP(int p0, struct S_IPP p1,  void (*cb)(int, struct S_IPP)) { cb(p0,p1); }
+EXPORT void f0_V_IS_FII(int p0, struct S_FII p1,  void (*cb)(int, struct S_FII)) { cb(p0,p1); }
+EXPORT void f0_V_IS_FIF(int p0, struct S_FIF p1,  void (*cb)(int, struct S_FIF)) { cb(p0,p1); }
+EXPORT void f0_V_IS_FID(int p0, struct S_FID p1,  void (*cb)(int, struct S_FID)) { cb(p0,p1); }
+EXPORT void f0_V_IS_FIP(int p0, struct S_FIP p1,  void (*cb)(int, struct S_FIP)) { cb(p0,p1); }
+EXPORT void f0_V_IS_FFI(int p0, struct S_FFI p1,  void (*cb)(int, struct S_FFI)) { cb(p0,p1); }
+EXPORT void f0_V_IS_FFF(int p0, struct S_FFF p1,  void (*cb)(int, struct S_FFF)) { cb(p0,p1); }
+EXPORT void f0_V_IS_FFD(int p0, struct S_FFD p1,  void (*cb)(int, struct S_FFD)) { cb(p0,p1); }
+EXPORT void f0_V_IS_FFP(int p0, struct S_FFP p1,  void (*cb)(int, struct S_FFP)) { cb(p0,p1); }
+EXPORT void f0_V_IS_FDI(int p0, struct S_FDI p1,  void (*cb)(int, struct S_FDI)) { cb(p0,p1); }
+EXPORT void f0_V_IS_FDF(int p0, struct S_FDF p1,  void (*cb)(int, struct S_FDF)) { cb(p0,p1); }
+EXPORT void f0_V_IS_FDD(int p0, struct S_FDD p1,  void (*cb)(int, struct S_FDD)) { cb(p0,p1); }
+EXPORT void f0_V_IS_FDP(int p0, struct S_FDP p1,  void (*cb)(int, struct S_FDP)) { cb(p0,p1); }
+EXPORT void f0_V_IS_FPI(int p0, struct S_FPI p1,  void (*cb)(int, struct S_FPI)) { cb(p0,p1); }
+EXPORT void f0_V_IS_FPF(int p0, struct S_FPF p1,  void (*cb)(int, struct S_FPF)) { cb(p0,p1); }
+EXPORT void f0_V_IS_FPD(int p0, struct S_FPD p1,  void (*cb)(int, struct S_FPD)) { cb(p0,p1); }
+EXPORT void f0_V_IS_FPP(int p0, struct S_FPP p1,  void (*cb)(int, struct S_FPP)) { cb(p0,p1); }
+EXPORT void f0_V_IS_DII(int p0, struct S_DII p1,  void (*cb)(int, struct S_DII)) { cb(p0,p1); }
+EXPORT void f0_V_IS_DIF(int p0, struct S_DIF p1,  void (*cb)(int, struct S_DIF)) { cb(p0,p1); }
+EXPORT void f0_V_IS_DID(int p0, struct S_DID p1,  void (*cb)(int, struct S_DID)) { cb(p0,p1); }
+EXPORT void f0_V_IS_DIP(int p0, struct S_DIP p1,  void (*cb)(int, struct S_DIP)) { cb(p0,p1); }
+EXPORT void f0_V_IS_DFI(int p0, struct S_DFI p1,  void (*cb)(int, struct S_DFI)) { cb(p0,p1); }
+EXPORT void f0_V_IS_DFF(int p0, struct S_DFF p1,  void (*cb)(int, struct S_DFF)) { cb(p0,p1); }
+EXPORT void f0_V_IS_DFD(int p0, struct S_DFD p1,  void (*cb)(int, struct S_DFD)) { cb(p0,p1); }
+EXPORT void f0_V_IS_DFP(int p0, struct S_DFP p1,  void (*cb)(int, struct S_DFP)) { cb(p0,p1); }
+EXPORT void f0_V_IS_DDI(int p0, struct S_DDI p1,  void (*cb)(int, struct S_DDI)) { cb(p0,p1); }
+EXPORT void f0_V_IS_DDF(int p0, struct S_DDF p1,  void (*cb)(int, struct S_DDF)) { cb(p0,p1); }
+EXPORT void f0_V_IS_DDD(int p0, struct S_DDD p1,  void (*cb)(int, struct S_DDD)) { cb(p0,p1); }
+EXPORT void f0_V_IS_DDP(int p0, struct S_DDP p1,  void (*cb)(int, struct S_DDP)) { cb(p0,p1); }
+EXPORT void f0_V_IS_DPI(int p0, struct S_DPI p1,  void (*cb)(int, struct S_DPI)) { cb(p0,p1); }
+EXPORT void f0_V_IS_DPF(int p0, struct S_DPF p1,  void (*cb)(int, struct S_DPF)) { cb(p0,p1); }
+EXPORT void f0_V_IS_DPD(int p0, struct S_DPD p1,  void (*cb)(int, struct S_DPD)) { cb(p0,p1); }
+EXPORT void f0_V_IS_DPP(int p0, struct S_DPP p1,  void (*cb)(int, struct S_DPP)) { cb(p0,p1); }
+EXPORT void f0_V_IS_PII(int p0, struct S_PII p1,  void (*cb)(int, struct S_PII)) { cb(p0,p1); }
+EXPORT void f0_V_IS_PIF(int p0, struct S_PIF p1,  void (*cb)(int, struct S_PIF)) { cb(p0,p1); }
+EXPORT void f0_V_IS_PID(int p0, struct S_PID p1,  void (*cb)(int, struct S_PID)) { cb(p0,p1); }
+EXPORT void f0_V_IS_PIP(int p0, struct S_PIP p1,  void (*cb)(int, struct S_PIP)) { cb(p0,p1); }
+EXPORT void f0_V_IS_PFI(int p0, struct S_PFI p1,  void (*cb)(int, struct S_PFI)) { cb(p0,p1); }
+EXPORT void f0_V_IS_PFF(int p0, struct S_PFF p1,  void (*cb)(int, struct S_PFF)) { cb(p0,p1); }
+EXPORT void f0_V_IS_PFD(int p0, struct S_PFD p1,  void (*cb)(int, struct S_PFD)) { cb(p0,p1); }
+EXPORT void f0_V_IS_PFP(int p0, struct S_PFP p1,  void (*cb)(int, struct S_PFP)) { cb(p0,p1); }
+EXPORT void f0_V_IS_PDI(int p0, struct S_PDI p1,  void (*cb)(int, struct S_PDI)) { cb(p0,p1); }
+EXPORT void f0_V_IS_PDF(int p0, struct S_PDF p1,  void (*cb)(int, struct S_PDF)) { cb(p0,p1); }
+EXPORT void f0_V_IS_PDD(int p0, struct S_PDD p1,  void (*cb)(int, struct S_PDD)) { cb(p0,p1); }
+EXPORT void f0_V_IS_PDP(int p0, struct S_PDP p1,  void (*cb)(int, struct S_PDP)) { cb(p0,p1); }
+EXPORT void f0_V_IS_PPI(int p0, struct S_PPI p1,  void (*cb)(int, struct S_PPI)) { cb(p0,p1); }
+EXPORT void f0_V_IS_PPF(int p0, struct S_PPF p1,  void (*cb)(int, struct S_PPF)) { cb(p0,p1); }
+EXPORT void f0_V_IS_PPD(int p0, struct S_PPD p1,  void (*cb)(int, struct S_PPD)) { cb(p0,p1); }
+EXPORT void f0_V_IS_PPP(int p0, struct S_PPP p1,  void (*cb)(int, struct S_PPP)) { cb(p0,p1); }
+EXPORT void f0_V_FI_(float p0, int p1,  void (*cb)(float, int)) { cb(p0,p1); }
+EXPORT void f0_V_FF_(float p0, float p1,  void (*cb)(float, float)) { cb(p0,p1); }
+EXPORT void f0_V_FD_(float p0, double p1,  void (*cb)(float, double)) { cb(p0,p1); }
+EXPORT void f0_V_FP_(float p0, void* p1,  void (*cb)(float, void*)) { cb(p0,p1); }
+EXPORT void f0_V_FS_I(float p0, struct S_I p1,  void (*cb)(float, struct S_I)) { cb(p0,p1); }
+EXPORT void f0_V_FS_F(float p0, struct S_F p1,  void (*cb)(float, struct S_F)) { cb(p0,p1); }
+EXPORT void f0_V_FS_D(float p0, struct S_D p1,  void (*cb)(float, struct S_D)) { cb(p0,p1); }
+EXPORT void f0_V_FS_P(float p0, struct S_P p1,  void (*cb)(float, struct S_P)) { cb(p0,p1); }
+EXPORT void f0_V_FS_II(float p0, struct S_II p1,  void (*cb)(float, struct S_II)) { cb(p0,p1); }
+EXPORT void f0_V_FS_IF(float p0, struct S_IF p1,  void (*cb)(float, struct S_IF)) { cb(p0,p1); }
+EXPORT void f0_V_FS_ID(float p0, struct S_ID p1,  void (*cb)(float, struct S_ID)) { cb(p0,p1); }
+EXPORT void f0_V_FS_IP(float p0, struct S_IP p1,  void (*cb)(float, struct S_IP)) { cb(p0,p1); }
+EXPORT void f0_V_FS_FI(float p0, struct S_FI p1,  void (*cb)(float, struct S_FI)) { cb(p0,p1); }
+EXPORT void f0_V_FS_FF(float p0, struct S_FF p1,  void (*cb)(float, struct S_FF)) { cb(p0,p1); }
+EXPORT void f0_V_FS_FD(float p0, struct S_FD p1,  void (*cb)(float, struct S_FD)) { cb(p0,p1); }
+EXPORT void f0_V_FS_FP(float p0, struct S_FP p1,  void (*cb)(float, struct S_FP)) { cb(p0,p1); }
+EXPORT void f0_V_FS_DI(float p0, struct S_DI p1,  void (*cb)(float, struct S_DI)) { cb(p0,p1); }
+EXPORT void f0_V_FS_DF(float p0, struct S_DF p1,  void (*cb)(float, struct S_DF)) { cb(p0,p1); }
+EXPORT void f0_V_FS_DD(float p0, struct S_DD p1,  void (*cb)(float, struct S_DD)) { cb(p0,p1); }
+EXPORT void f0_V_FS_DP(float p0, struct S_DP p1,  void (*cb)(float, struct S_DP)) { cb(p0,p1); }
+EXPORT void f0_V_FS_PI(float p0, struct S_PI p1,  void (*cb)(float, struct S_PI)) { cb(p0,p1); }
+EXPORT void f0_V_FS_PF(float p0, struct S_PF p1,  void (*cb)(float, struct S_PF)) { cb(p0,p1); }
+EXPORT void f0_V_FS_PD(float p0, struct S_PD p1,  void (*cb)(float, struct S_PD)) { cb(p0,p1); }
+EXPORT void f0_V_FS_PP(float p0, struct S_PP p1,  void (*cb)(float, struct S_PP)) { cb(p0,p1); }
+EXPORT void f0_V_FS_III(float p0, struct S_III p1,  void (*cb)(float, struct S_III)) { cb(p0,p1); }
+EXPORT void f0_V_FS_IIF(float p0, struct S_IIF p1,  void (*cb)(float, struct S_IIF)) { cb(p0,p1); }
+EXPORT void f0_V_FS_IID(float p0, struct S_IID p1,  void (*cb)(float, struct S_IID)) { cb(p0,p1); }
+EXPORT void f0_V_FS_IIP(float p0, struct S_IIP p1,  void (*cb)(float, struct S_IIP)) { cb(p0,p1); }
+EXPORT void f0_V_FS_IFI(float p0, struct S_IFI p1,  void (*cb)(float, struct S_IFI)) { cb(p0,p1); }
+EXPORT void f0_V_FS_IFF(float p0, struct S_IFF p1,  void (*cb)(float, struct S_IFF)) { cb(p0,p1); }
+EXPORT void f0_V_FS_IFD(float p0, struct S_IFD p1,  void (*cb)(float, struct S_IFD)) { cb(p0,p1); }
+EXPORT void f0_V_FS_IFP(float p0, struct S_IFP p1,  void (*cb)(float, struct S_IFP)) { cb(p0,p1); }
+EXPORT void f0_V_FS_IDI(float p0, struct S_IDI p1,  void (*cb)(float, struct S_IDI)) { cb(p0,p1); }
+EXPORT void f0_V_FS_IDF(float p0, struct S_IDF p1,  void (*cb)(float, struct S_IDF)) { cb(p0,p1); }
+EXPORT void f0_V_FS_IDD(float p0, struct S_IDD p1,  void (*cb)(float, struct S_IDD)) { cb(p0,p1); }
+EXPORT void f0_V_FS_IDP(float p0, struct S_IDP p1,  void (*cb)(float, struct S_IDP)) { cb(p0,p1); }
+EXPORT void f0_V_FS_IPI(float p0, struct S_IPI p1,  void (*cb)(float, struct S_IPI)) { cb(p0,p1); }
+EXPORT void f0_V_FS_IPF(float p0, struct S_IPF p1,  void (*cb)(float, struct S_IPF)) { cb(p0,p1); }
+EXPORT void f0_V_FS_IPD(float p0, struct S_IPD p1,  void (*cb)(float, struct S_IPD)) { cb(p0,p1); }
+EXPORT void f0_V_FS_IPP(float p0, struct S_IPP p1,  void (*cb)(float, struct S_IPP)) { cb(p0,p1); }
+EXPORT void f0_V_FS_FII(float p0, struct S_FII p1,  void (*cb)(float, struct S_FII)) { cb(p0,p1); }
+EXPORT void f0_V_FS_FIF(float p0, struct S_FIF p1,  void (*cb)(float, struct S_FIF)) { cb(p0,p1); }
+EXPORT void f0_V_FS_FID(float p0, struct S_FID p1,  void (*cb)(float, struct S_FID)) { cb(p0,p1); }
+EXPORT void f0_V_FS_FIP(float p0, struct S_FIP p1,  void (*cb)(float, struct S_FIP)) { cb(p0,p1); }
+EXPORT void f0_V_FS_FFI(float p0, struct S_FFI p1,  void (*cb)(float, struct S_FFI)) { cb(p0,p1); }
+EXPORT void f0_V_FS_FFF(float p0, struct S_FFF p1,  void (*cb)(float, struct S_FFF)) { cb(p0,p1); }
+EXPORT void f0_V_FS_FFD(float p0, struct S_FFD p1,  void (*cb)(float, struct S_FFD)) { cb(p0,p1); }
+EXPORT void f0_V_FS_FFP(float p0, struct S_FFP p1,  void (*cb)(float, struct S_FFP)) { cb(p0,p1); }
+EXPORT void f0_V_FS_FDI(float p0, struct S_FDI p1,  void (*cb)(float, struct S_FDI)) { cb(p0,p1); }
+EXPORT void f0_V_FS_FDF(float p0, struct S_FDF p1,  void (*cb)(float, struct S_FDF)) { cb(p0,p1); }
+EXPORT void f0_V_FS_FDD(float p0, struct S_FDD p1,  void (*cb)(float, struct S_FDD)) { cb(p0,p1); }
+EXPORT void f0_V_FS_FDP(float p0, struct S_FDP p1,  void (*cb)(float, struct S_FDP)) { cb(p0,p1); }
+EXPORT void f0_V_FS_FPI(float p0, struct S_FPI p1,  void (*cb)(float, struct S_FPI)) { cb(p0,p1); }
+EXPORT void f0_V_FS_FPF(float p0, struct S_FPF p1,  void (*cb)(float, struct S_FPF)) { cb(p0,p1); }
+EXPORT void f0_V_FS_FPD(float p0, struct S_FPD p1,  void (*cb)(float, struct S_FPD)) { cb(p0,p1); }
+EXPORT void f0_V_FS_FPP(float p0, struct S_FPP p1,  void (*cb)(float, struct S_FPP)) { cb(p0,p1); }
+EXPORT void f0_V_FS_DII(float p0, struct S_DII p1,  void (*cb)(float, struct S_DII)) { cb(p0,p1); }
+EXPORT void f0_V_FS_DIF(float p0, struct S_DIF p1,  void (*cb)(float, struct S_DIF)) { cb(p0,p1); }
+EXPORT void f0_V_FS_DID(float p0, struct S_DID p1,  void (*cb)(float, struct S_DID)) { cb(p0,p1); }
+EXPORT void f0_V_FS_DIP(float p0, struct S_DIP p1,  void (*cb)(float, struct S_DIP)) { cb(p0,p1); }
+EXPORT void f0_V_FS_DFI(float p0, struct S_DFI p1,  void (*cb)(float, struct S_DFI)) { cb(p0,p1); }
+EXPORT void f0_V_FS_DFF(float p0, struct S_DFF p1,  void (*cb)(float, struct S_DFF)) { cb(p0,p1); }
+EXPORT void f0_V_FS_DFD(float p0, struct S_DFD p1,  void (*cb)(float, struct S_DFD)) { cb(p0,p1); }
+EXPORT void f0_V_FS_DFP(float p0, struct S_DFP p1,  void (*cb)(float, struct S_DFP)) { cb(p0,p1); }
+EXPORT void f0_V_FS_DDI(float p0, struct S_DDI p1,  void (*cb)(float, struct S_DDI)) { cb(p0,p1); }
+EXPORT void f0_V_FS_DDF(float p0, struct S_DDF p1,  void (*cb)(float, struct S_DDF)) { cb(p0,p1); }
+EXPORT void f0_V_FS_DDD(float p0, struct S_DDD p1,  void (*cb)(float, struct S_DDD)) { cb(p0,p1); }
+EXPORT void f0_V_FS_DDP(float p0, struct S_DDP p1,  void (*cb)(float, struct S_DDP)) { cb(p0,p1); }
+EXPORT void f0_V_FS_DPI(float p0, struct S_DPI p1,  void (*cb)(float, struct S_DPI)) { cb(p0,p1); }
+EXPORT void f0_V_FS_DPF(float p0, struct S_DPF p1,  void (*cb)(float, struct S_DPF)) { cb(p0,p1); }
+EXPORT void f0_V_FS_DPD(float p0, struct S_DPD p1,  void (*cb)(float, struct S_DPD)) { cb(p0,p1); }
+EXPORT void f0_V_FS_DPP(float p0, struct S_DPP p1,  void (*cb)(float, struct S_DPP)) { cb(p0,p1); }
+EXPORT void f0_V_FS_PII(float p0, struct S_PII p1,  void (*cb)(float, struct S_PII)) { cb(p0,p1); }
+EXPORT void f0_V_FS_PIF(float p0, struct S_PIF p1,  void (*cb)(float, struct S_PIF)) { cb(p0,p1); }
+EXPORT void f0_V_FS_PID(float p0, struct S_PID p1,  void (*cb)(float, struct S_PID)) { cb(p0,p1); }
+EXPORT void f0_V_FS_PIP(float p0, struct S_PIP p1,  void (*cb)(float, struct S_PIP)) { cb(p0,p1); }
+EXPORT void f0_V_FS_PFI(float p0, struct S_PFI p1,  void (*cb)(float, struct S_PFI)) { cb(p0,p1); }
+EXPORT void f0_V_FS_PFF(float p0, struct S_PFF p1,  void (*cb)(float, struct S_PFF)) { cb(p0,p1); }
+EXPORT void f0_V_FS_PFD(float p0, struct S_PFD p1,  void (*cb)(float, struct S_PFD)) { cb(p0,p1); }
+EXPORT void f0_V_FS_PFP(float p0, struct S_PFP p1,  void (*cb)(float, struct S_PFP)) { cb(p0,p1); }
+EXPORT void f0_V_FS_PDI(float p0, struct S_PDI p1,  void (*cb)(float, struct S_PDI)) { cb(p0,p1); }
+EXPORT void f0_V_FS_PDF(float p0, struct S_PDF p1,  void (*cb)(float, struct S_PDF)) { cb(p0,p1); }
+EXPORT void f0_V_FS_PDD(float p0, struct S_PDD p1,  void (*cb)(float, struct S_PDD)) { cb(p0,p1); }
+EXPORT void f0_V_FS_PDP(float p0, struct S_PDP p1,  void (*cb)(float, struct S_PDP)) { cb(p0,p1); }
+EXPORT void f0_V_FS_PPI(float p0, struct S_PPI p1,  void (*cb)(float, struct S_PPI)) { cb(p0,p1); }
+EXPORT void f0_V_FS_PPF(float p0, struct S_PPF p1,  void (*cb)(float, struct S_PPF)) { cb(p0,p1); }
+EXPORT void f0_V_FS_PPD(float p0, struct S_PPD p1,  void (*cb)(float, struct S_PPD)) { cb(p0,p1); }
+EXPORT void f0_V_FS_PPP(float p0, struct S_PPP p1,  void (*cb)(float, struct S_PPP)) { cb(p0,p1); }
+EXPORT void f0_V_DI_(double p0, int p1,  void (*cb)(double, int)) { cb(p0,p1); }
+EXPORT void f0_V_DF_(double p0, float p1,  void (*cb)(double, float)) { cb(p0,p1); }
+EXPORT void f0_V_DD_(double p0, double p1,  void (*cb)(double, double)) { cb(p0,p1); }
+EXPORT void f0_V_DP_(double p0, void* p1,  void (*cb)(double, void*)) { cb(p0,p1); }
+EXPORT void f0_V_DS_I(double p0, struct S_I p1,  void (*cb)(double, struct S_I)) { cb(p0,p1); }
+EXPORT void f0_V_DS_F(double p0, struct S_F p1,  void (*cb)(double, struct S_F)) { cb(p0,p1); }
+EXPORT void f0_V_DS_D(double p0, struct S_D p1,  void (*cb)(double, struct S_D)) { cb(p0,p1); }
+EXPORT void f0_V_DS_P(double p0, struct S_P p1,  void (*cb)(double, struct S_P)) { cb(p0,p1); }
+EXPORT void f0_V_DS_II(double p0, struct S_II p1,  void (*cb)(double, struct S_II)) { cb(p0,p1); }
+EXPORT void f0_V_DS_IF(double p0, struct S_IF p1,  void (*cb)(double, struct S_IF)) { cb(p0,p1); }
+EXPORT void f0_V_DS_ID(double p0, struct S_ID p1,  void (*cb)(double, struct S_ID)) { cb(p0,p1); }
+EXPORT void f0_V_DS_IP(double p0, struct S_IP p1,  void (*cb)(double, struct S_IP)) { cb(p0,p1); }
+EXPORT void f0_V_DS_FI(double p0, struct S_FI p1,  void (*cb)(double, struct S_FI)) { cb(p0,p1); }
+EXPORT void f0_V_DS_FF(double p0, struct S_FF p1,  void (*cb)(double, struct S_FF)) { cb(p0,p1); }
+EXPORT void f0_V_DS_FD(double p0, struct S_FD p1,  void (*cb)(double, struct S_FD)) { cb(p0,p1); }
+EXPORT void f0_V_DS_FP(double p0, struct S_FP p1,  void (*cb)(double, struct S_FP)) { cb(p0,p1); }
+EXPORT void f0_V_DS_DI(double p0, struct S_DI p1,  void (*cb)(double, struct S_DI)) { cb(p0,p1); }
+EXPORT void f0_V_DS_DF(double p0, struct S_DF p1,  void (*cb)(double, struct S_DF)) { cb(p0,p1); }
+EXPORT void f0_V_DS_DD(double p0, struct S_DD p1,  void (*cb)(double, struct S_DD)) { cb(p0,p1); }
+EXPORT void f0_V_DS_DP(double p0, struct S_DP p1,  void (*cb)(double, struct S_DP)) { cb(p0,p1); }
+EXPORT void f0_V_DS_PI(double p0, struct S_PI p1,  void (*cb)(double, struct S_PI)) { cb(p0,p1); }
+EXPORT void f0_V_DS_PF(double p0, struct S_PF p1,  void (*cb)(double, struct S_PF)) { cb(p0,p1); }
+EXPORT void f0_V_DS_PD(double p0, struct S_PD p1,  void (*cb)(double, struct S_PD)) { cb(p0,p1); }
+EXPORT void f0_V_DS_PP(double p0, struct S_PP p1,  void (*cb)(double, struct S_PP)) { cb(p0,p1); }
+EXPORT void f0_V_DS_III(double p0, struct S_III p1,  void (*cb)(double, struct S_III)) { cb(p0,p1); }
+EXPORT void f0_V_DS_IIF(double p0, struct S_IIF p1,  void (*cb)(double, struct S_IIF)) { cb(p0,p1); }
+EXPORT void f0_V_DS_IID(double p0, struct S_IID p1,  void (*cb)(double, struct S_IID)) { cb(p0,p1); }
+EXPORT void f0_V_DS_IIP(double p0, struct S_IIP p1,  void (*cb)(double, struct S_IIP)) { cb(p0,p1); }
+EXPORT void f0_V_DS_IFI(double p0, struct S_IFI p1,  void (*cb)(double, struct S_IFI)) { cb(p0,p1); }
+EXPORT void f0_V_DS_IFF(double p0, struct S_IFF p1,  void (*cb)(double, struct S_IFF)) { cb(p0,p1); }
+EXPORT void f0_V_DS_IFD(double p0, struct S_IFD p1,  void (*cb)(double, struct S_IFD)) { cb(p0,p1); }
+EXPORT void f0_V_DS_IFP(double p0, struct S_IFP p1,  void (*cb)(double, struct S_IFP)) { cb(p0,p1); }
+EXPORT void f0_V_DS_IDI(double p0, struct S_IDI p1,  void (*cb)(double, struct S_IDI)) { cb(p0,p1); }
+EXPORT void f0_V_DS_IDF(double p0, struct S_IDF p1,  void (*cb)(double, struct S_IDF)) { cb(p0,p1); }
+EXPORT void f0_V_DS_IDD(double p0, struct S_IDD p1,  void (*cb)(double, struct S_IDD)) { cb(p0,p1); }
+EXPORT void f0_V_DS_IDP(double p0, struct S_IDP p1,  void (*cb)(double, struct S_IDP)) { cb(p0,p1); }
+EXPORT void f0_V_DS_IPI(double p0, struct S_IPI p1,  void (*cb)(double, struct S_IPI)) { cb(p0,p1); }
+EXPORT void f0_V_DS_IPF(double p0, struct S_IPF p1,  void (*cb)(double, struct S_IPF)) { cb(p0,p1); }
+EXPORT void f0_V_DS_IPD(double p0, struct S_IPD p1,  void (*cb)(double, struct S_IPD)) { cb(p0,p1); }
+EXPORT void f0_V_DS_IPP(double p0, struct S_IPP p1,  void (*cb)(double, struct S_IPP)) { cb(p0,p1); }
+EXPORT void f0_V_DS_FII(double p0, struct S_FII p1,  void (*cb)(double, struct S_FII)) { cb(p0,p1); }
+EXPORT void f0_V_DS_FIF(double p0, struct S_FIF p1,  void (*cb)(double, struct S_FIF)) { cb(p0,p1); }
+EXPORT void f0_V_DS_FID(double p0, struct S_FID p1,  void (*cb)(double, struct S_FID)) { cb(p0,p1); }
+EXPORT void f0_V_DS_FIP(double p0, struct S_FIP p1,  void (*cb)(double, struct S_FIP)) { cb(p0,p1); }
+EXPORT void f0_V_DS_FFI(double p0, struct S_FFI p1,  void (*cb)(double, struct S_FFI)) { cb(p0,p1); }
+EXPORT void f0_V_DS_FFF(double p0, struct S_FFF p1,  void (*cb)(double, struct S_FFF)) { cb(p0,p1); }
+EXPORT void f0_V_DS_FFD(double p0, struct S_FFD p1,  void (*cb)(double, struct S_FFD)) { cb(p0,p1); }
+EXPORT void f0_V_DS_FFP(double p0, struct S_FFP p1,  void (*cb)(double, struct S_FFP)) { cb(p0,p1); }
+EXPORT void f0_V_DS_FDI(double p0, struct S_FDI p1,  void (*cb)(double, struct S_FDI)) { cb(p0,p1); }
+EXPORT void f0_V_DS_FDF(double p0, struct S_FDF p1,  void (*cb)(double, struct S_FDF)) { cb(p0,p1); }
+EXPORT void f0_V_DS_FDD(double p0, struct S_FDD p1,  void (*cb)(double, struct S_FDD)) { cb(p0,p1); }
+EXPORT void f0_V_DS_FDP(double p0, struct S_FDP p1,  void (*cb)(double, struct S_FDP)) { cb(p0,p1); }
+EXPORT void f0_V_DS_FPI(double p0, struct S_FPI p1,  void (*cb)(double, struct S_FPI)) { cb(p0,p1); }
+EXPORT void f0_V_DS_FPF(double p0, struct S_FPF p1,  void (*cb)(double, struct S_FPF)) { cb(p0,p1); }
+EXPORT void f0_V_DS_FPD(double p0, struct S_FPD p1,  void (*cb)(double, struct S_FPD)) { cb(p0,p1); }
+EXPORT void f0_V_DS_FPP(double p0, struct S_FPP p1,  void (*cb)(double, struct S_FPP)) { cb(p0,p1); }
+EXPORT void f0_V_DS_DII(double p0, struct S_DII p1,  void (*cb)(double, struct S_DII)) { cb(p0,p1); }
+EXPORT void f0_V_DS_DIF(double p0, struct S_DIF p1,  void (*cb)(double, struct S_DIF)) { cb(p0,p1); }
+EXPORT void f0_V_DS_DID(double p0, struct S_DID p1,  void (*cb)(double, struct S_DID)) { cb(p0,p1); }
+EXPORT void f0_V_DS_DIP(double p0, struct S_DIP p1,  void (*cb)(double, struct S_DIP)) { cb(p0,p1); }
+EXPORT void f0_V_DS_DFI(double p0, struct S_DFI p1,  void (*cb)(double, struct S_DFI)) { cb(p0,p1); }
+EXPORT void f0_V_DS_DFF(double p0, struct S_DFF p1,  void (*cb)(double, struct S_DFF)) { cb(p0,p1); }
+EXPORT void f0_V_DS_DFD(double p0, struct S_DFD p1,  void (*cb)(double, struct S_DFD)) { cb(p0,p1); }
+EXPORT void f0_V_DS_DFP(double p0, struct S_DFP p1,  void (*cb)(double, struct S_DFP)) { cb(p0,p1); }
+EXPORT void f0_V_DS_DDI(double p0, struct S_DDI p1,  void (*cb)(double, struct S_DDI)) { cb(p0,p1); }
+EXPORT void f0_V_DS_DDF(double p0, struct S_DDF p1,  void (*cb)(double, struct S_DDF)) { cb(p0,p1); }
+EXPORT void f0_V_DS_DDD(double p0, struct S_DDD p1,  void (*cb)(double, struct S_DDD)) { cb(p0,p1); }
+EXPORT void f0_V_DS_DDP(double p0, struct S_DDP p1,  void (*cb)(double, struct S_DDP)) { cb(p0,p1); }
+EXPORT void f0_V_DS_DPI(double p0, struct S_DPI p1,  void (*cb)(double, struct S_DPI)) { cb(p0,p1); }
+EXPORT void f0_V_DS_DPF(double p0, struct S_DPF p1,  void (*cb)(double, struct S_DPF)) { cb(p0,p1); }
+EXPORT void f0_V_DS_DPD(double p0, struct S_DPD p1,  void (*cb)(double, struct S_DPD)) { cb(p0,p1); }
+EXPORT void f0_V_DS_DPP(double p0, struct S_DPP p1,  void (*cb)(double, struct S_DPP)) { cb(p0,p1); }
+EXPORT void f0_V_DS_PII(double p0, struct S_PII p1,  void (*cb)(double, struct S_PII)) { cb(p0,p1); }
+EXPORT void f0_V_DS_PIF(double p0, struct S_PIF p1,  void (*cb)(double, struct S_PIF)) { cb(p0,p1); }
+EXPORT void f0_V_DS_PID(double p0, struct S_PID p1,  void (*cb)(double, struct S_PID)) { cb(p0,p1); }
+EXPORT void f0_V_DS_PIP(double p0, struct S_PIP p1,  void (*cb)(double, struct S_PIP)) { cb(p0,p1); }
+EXPORT void f0_V_DS_PFI(double p0, struct S_PFI p1,  void (*cb)(double, struct S_PFI)) { cb(p0,p1); }
+EXPORT void f0_V_DS_PFF(double p0, struct S_PFF p1,  void (*cb)(double, struct S_PFF)) { cb(p0,p1); }
+EXPORT void f0_V_DS_PFD(double p0, struct S_PFD p1,  void (*cb)(double, struct S_PFD)) { cb(p0,p1); }
+EXPORT void f0_V_DS_PFP(double p0, struct S_PFP p1,  void (*cb)(double, struct S_PFP)) { cb(p0,p1); }
+EXPORT void f0_V_DS_PDI(double p0, struct S_PDI p1,  void (*cb)(double, struct S_PDI)) { cb(p0,p1); }
+EXPORT void f0_V_DS_PDF(double p0, struct S_PDF p1,  void (*cb)(double, struct S_PDF)) { cb(p0,p1); }
+EXPORT void f0_V_DS_PDD(double p0, struct S_PDD p1,  void (*cb)(double, struct S_PDD)) { cb(p0,p1); }
+EXPORT void f0_V_DS_PDP(double p0, struct S_PDP p1,  void (*cb)(double, struct S_PDP)) { cb(p0,p1); }
+EXPORT void f0_V_DS_PPI(double p0, struct S_PPI p1,  void (*cb)(double, struct S_PPI)) { cb(p0,p1); }
+EXPORT void f0_V_DS_PPF(double p0, struct S_PPF p1,  void (*cb)(double, struct S_PPF)) { cb(p0,p1); }
+EXPORT void f0_V_DS_PPD(double p0, struct S_PPD p1,  void (*cb)(double, struct S_PPD)) { cb(p0,p1); }
+EXPORT void f0_V_DS_PPP(double p0, struct S_PPP p1,  void (*cb)(double, struct S_PPP)) { cb(p0,p1); }
+EXPORT void f0_V_PI_(void* p0, int p1,  void (*cb)(void*, int)) { cb(p0,p1); }
+EXPORT void f0_V_PF_(void* p0, float p1,  void (*cb)(void*, float)) { cb(p0,p1); }
+EXPORT void f0_V_PD_(void* p0, double p1,  void (*cb)(void*, double)) { cb(p0,p1); }
+EXPORT void f0_V_PP_(void* p0, void* p1,  void (*cb)(void*, void*)) { cb(p0,p1); }
+EXPORT void f0_V_PS_I(void* p0, struct S_I p1,  void (*cb)(void*, struct S_I)) { cb(p0,p1); }
+EXPORT void f0_V_PS_F(void* p0, struct S_F p1,  void (*cb)(void*, struct S_F)) { cb(p0,p1); }
+EXPORT void f0_V_PS_D(void* p0, struct S_D p1,  void (*cb)(void*, struct S_D)) { cb(p0,p1); }
+EXPORT void f0_V_PS_P(void* p0, struct S_P p1,  void (*cb)(void*, struct S_P)) { cb(p0,p1); }
+EXPORT void f0_V_PS_II(void* p0, struct S_II p1,  void (*cb)(void*, struct S_II)) { cb(p0,p1); }
+EXPORT void f0_V_PS_IF(void* p0, struct S_IF p1,  void (*cb)(void*, struct S_IF)) { cb(p0,p1); }
+EXPORT void f0_V_PS_ID(void* p0, struct S_ID p1,  void (*cb)(void*, struct S_ID)) { cb(p0,p1); }
+EXPORT void f0_V_PS_IP(void* p0, struct S_IP p1,  void (*cb)(void*, struct S_IP)) { cb(p0,p1); }
+EXPORT void f0_V_PS_FI(void* p0, struct S_FI p1,  void (*cb)(void*, struct S_FI)) { cb(p0,p1); }
+EXPORT void f0_V_PS_FF(void* p0, struct S_FF p1,  void (*cb)(void*, struct S_FF)) { cb(p0,p1); }
+EXPORT void f0_V_PS_FD(void* p0, struct S_FD p1,  void (*cb)(void*, struct S_FD)) { cb(p0,p1); }
+EXPORT void f0_V_PS_FP(void* p0, struct S_FP p1,  void (*cb)(void*, struct S_FP)) { cb(p0,p1); }
+EXPORT void f0_V_PS_DI(void* p0, struct S_DI p1,  void (*cb)(void*, struct S_DI)) { cb(p0,p1); }
+EXPORT void f0_V_PS_DF(void* p0, struct S_DF p1,  void (*cb)(void*, struct S_DF)) { cb(p0,p1); }
+EXPORT void f0_V_PS_DD(void* p0, struct S_DD p1,  void (*cb)(void*, struct S_DD)) { cb(p0,p1); }
+EXPORT void f0_V_PS_DP(void* p0, struct S_DP p1,  void (*cb)(void*, struct S_DP)) { cb(p0,p1); }
+EXPORT void f0_V_PS_PI(void* p0, struct S_PI p1,  void (*cb)(void*, struct S_PI)) { cb(p0,p1); }
+EXPORT void f0_V_PS_PF(void* p0, struct S_PF p1,  void (*cb)(void*, struct S_PF)) { cb(p0,p1); }
+EXPORT void f0_V_PS_PD(void* p0, struct S_PD p1,  void (*cb)(void*, struct S_PD)) { cb(p0,p1); }
+EXPORT void f0_V_PS_PP(void* p0, struct S_PP p1,  void (*cb)(void*, struct S_PP)) { cb(p0,p1); }
+EXPORT void f0_V_PS_III(void* p0, struct S_III p1,  void (*cb)(void*, struct S_III)) { cb(p0,p1); }
+EXPORT void f0_V_PS_IIF(void* p0, struct S_IIF p1,  void (*cb)(void*, struct S_IIF)) { cb(p0,p1); }
+EXPORT void f0_V_PS_IID(void* p0, struct S_IID p1,  void (*cb)(void*, struct S_IID)) { cb(p0,p1); }
+EXPORT void f0_V_PS_IIP(void* p0, struct S_IIP p1,  void (*cb)(void*, struct S_IIP)) { cb(p0,p1); }
+EXPORT void f0_V_PS_IFI(void* p0, struct S_IFI p1,  void (*cb)(void*, struct S_IFI)) { cb(p0,p1); }
+EXPORT void f0_V_PS_IFF(void* p0, struct S_IFF p1,  void (*cb)(void*, struct S_IFF)) { cb(p0,p1); }
+EXPORT void f0_V_PS_IFD(void* p0, struct S_IFD p1,  void (*cb)(void*, struct S_IFD)) { cb(p0,p1); }
+EXPORT void f0_V_PS_IFP(void* p0, struct S_IFP p1,  void (*cb)(void*, struct S_IFP)) { cb(p0,p1); }
+EXPORT void f0_V_PS_IDI(void* p0, struct S_IDI p1,  void (*cb)(void*, struct S_IDI)) { cb(p0,p1); }
+EXPORT void f0_V_PS_IDF(void* p0, struct S_IDF p1,  void (*cb)(void*, struct S_IDF)) { cb(p0,p1); }
+EXPORT void f0_V_PS_IDD(void* p0, struct S_IDD p1,  void (*cb)(void*, struct S_IDD)) { cb(p0,p1); }
+EXPORT void f0_V_PS_IDP(void* p0, struct S_IDP p1,  void (*cb)(void*, struct S_IDP)) { cb(p0,p1); }
+EXPORT void f0_V_PS_IPI(void* p0, struct S_IPI p1,  void (*cb)(void*, struct S_IPI)) { cb(p0,p1); }
+EXPORT void f0_V_PS_IPF(void* p0, struct S_IPF p1,  void (*cb)(void*, struct S_IPF)) { cb(p0,p1); }
+EXPORT void f0_V_PS_IPD(void* p0, struct S_IPD p1,  void (*cb)(void*, struct S_IPD)) { cb(p0,p1); }
+EXPORT void f0_V_PS_IPP(void* p0, struct S_IPP p1,  void (*cb)(void*, struct S_IPP)) { cb(p0,p1); }
+EXPORT void f0_V_PS_FII(void* p0, struct S_FII p1,  void (*cb)(void*, struct S_FII)) { cb(p0,p1); }
+EXPORT void f0_V_PS_FIF(void* p0, struct S_FIF p1,  void (*cb)(void*, struct S_FIF)) { cb(p0,p1); }
+EXPORT void f0_V_PS_FID(void* p0, struct S_FID p1,  void (*cb)(void*, struct S_FID)) { cb(p0,p1); }
+EXPORT void f0_V_PS_FIP(void* p0, struct S_FIP p1,  void (*cb)(void*, struct S_FIP)) { cb(p0,p1); }
+EXPORT void f0_V_PS_FFI(void* p0, struct S_FFI p1,  void (*cb)(void*, struct S_FFI)) { cb(p0,p1); }
+EXPORT void f0_V_PS_FFF(void* p0, struct S_FFF p1,  void (*cb)(void*, struct S_FFF)) { cb(p0,p1); }
+EXPORT void f0_V_PS_FFD(void* p0, struct S_FFD p1,  void (*cb)(void*, struct S_FFD)) { cb(p0,p1); }
+EXPORT void f0_V_PS_FFP(void* p0, struct S_FFP p1,  void (*cb)(void*, struct S_FFP)) { cb(p0,p1); }
+EXPORT void f0_V_PS_FDI(void* p0, struct S_FDI p1,  void (*cb)(void*, struct S_FDI)) { cb(p0,p1); }
+EXPORT void f0_V_PS_FDF(void* p0, struct S_FDF p1,  void (*cb)(void*, struct S_FDF)) { cb(p0,p1); }
+EXPORT void f0_V_PS_FDD(void* p0, struct S_FDD p1,  void (*cb)(void*, struct S_FDD)) { cb(p0,p1); }
+EXPORT void f0_V_PS_FDP(void* p0, struct S_FDP p1,  void (*cb)(void*, struct S_FDP)) { cb(p0,p1); }
+EXPORT void f0_V_PS_FPI(void* p0, struct S_FPI p1,  void (*cb)(void*, struct S_FPI)) { cb(p0,p1); }
+EXPORT void f0_V_PS_FPF(void* p0, struct S_FPF p1,  void (*cb)(void*, struct S_FPF)) { cb(p0,p1); }
+EXPORT void f0_V_PS_FPD(void* p0, struct S_FPD p1,  void (*cb)(void*, struct S_FPD)) { cb(p0,p1); }
+EXPORT void f0_V_PS_FPP(void* p0, struct S_FPP p1,  void (*cb)(void*, struct S_FPP)) { cb(p0,p1); }
+EXPORT void f0_V_PS_DII(void* p0, struct S_DII p1,  void (*cb)(void*, struct S_DII)) { cb(p0,p1); }
+EXPORT void f0_V_PS_DIF(void* p0, struct S_DIF p1,  void (*cb)(void*, struct S_DIF)) { cb(p0,p1); }
+EXPORT void f0_V_PS_DID(void* p0, struct S_DID p1,  void (*cb)(void*, struct S_DID)) { cb(p0,p1); }
+EXPORT void f0_V_PS_DIP(void* p0, struct S_DIP p1,  void (*cb)(void*, struct S_DIP)) { cb(p0,p1); }
+EXPORT void f0_V_PS_DFI(void* p0, struct S_DFI p1,  void (*cb)(void*, struct S_DFI)) { cb(p0,p1); }
+EXPORT void f0_V_PS_DFF(void* p0, struct S_DFF p1,  void (*cb)(void*, struct S_DFF)) { cb(p0,p1); }
+EXPORT void f0_V_PS_DFD(void* p0, struct S_DFD p1,  void (*cb)(void*, struct S_DFD)) { cb(p0,p1); }
+EXPORT void f0_V_PS_DFP(void* p0, struct S_DFP p1,  void (*cb)(void*, struct S_DFP)) { cb(p0,p1); }
+EXPORT void f0_V_PS_DDI(void* p0, struct S_DDI p1,  void (*cb)(void*, struct S_DDI)) { cb(p0,p1); }
+EXPORT void f0_V_PS_DDF(void* p0, struct S_DDF p1,  void (*cb)(void*, struct S_DDF)) { cb(p0,p1); }
+EXPORT void f0_V_PS_DDD(void* p0, struct S_DDD p1,  void (*cb)(void*, struct S_DDD)) { cb(p0,p1); }
+EXPORT void f0_V_PS_DDP(void* p0, struct S_DDP p1,  void (*cb)(void*, struct S_DDP)) { cb(p0,p1); }
+EXPORT void f0_V_PS_DPI(void* p0, struct S_DPI p1,  void (*cb)(void*, struct S_DPI)) { cb(p0,p1); }
+EXPORT void f0_V_PS_DPF(void* p0, struct S_DPF p1,  void (*cb)(void*, struct S_DPF)) { cb(p0,p1); }
+EXPORT void f0_V_PS_DPD(void* p0, struct S_DPD p1,  void (*cb)(void*, struct S_DPD)) { cb(p0,p1); }
+EXPORT void f0_V_PS_DPP(void* p0, struct S_DPP p1,  void (*cb)(void*, struct S_DPP)) { cb(p0,p1); }
+EXPORT void f0_V_PS_PII(void* p0, struct S_PII p1,  void (*cb)(void*, struct S_PII)) { cb(p0,p1); }
+EXPORT void f0_V_PS_PIF(void* p0, struct S_PIF p1,  void (*cb)(void*, struct S_PIF)) { cb(p0,p1); }
+EXPORT void f0_V_PS_PID(void* p0, struct S_PID p1,  void (*cb)(void*, struct S_PID)) { cb(p0,p1); }
+EXPORT void f0_V_PS_PIP(void* p0, struct S_PIP p1,  void (*cb)(void*, struct S_PIP)) { cb(p0,p1); }
+EXPORT void f0_V_PS_PFI(void* p0, struct S_PFI p1,  void (*cb)(void*, struct S_PFI)) { cb(p0,p1); }
+EXPORT void f0_V_PS_PFF(void* p0, struct S_PFF p1,  void (*cb)(void*, struct S_PFF)) { cb(p0,p1); }
+EXPORT void f0_V_PS_PFD(void* p0, struct S_PFD p1,  void (*cb)(void*, struct S_PFD)) { cb(p0,p1); }
+EXPORT void f0_V_PS_PFP(void* p0, struct S_PFP p1,  void (*cb)(void*, struct S_PFP)) { cb(p0,p1); }
+EXPORT void f0_V_PS_PDI(void* p0, struct S_PDI p1,  void (*cb)(void*, struct S_PDI)) { cb(p0,p1); }
+EXPORT void f0_V_PS_PDF(void* p0, struct S_PDF p1,  void (*cb)(void*, struct S_PDF)) { cb(p0,p1); }
+EXPORT void f0_V_PS_PDD(void* p0, struct S_PDD p1,  void (*cb)(void*, struct S_PDD)) { cb(p0,p1); }
+EXPORT void f0_V_PS_PDP(void* p0, struct S_PDP p1,  void (*cb)(void*, struct S_PDP)) { cb(p0,p1); }
+EXPORT void f0_V_PS_PPI(void* p0, struct S_PPI p1,  void (*cb)(void*, struct S_PPI)) { cb(p0,p1); }
+EXPORT void f0_V_PS_PPF(void* p0, struct S_PPF p1,  void (*cb)(void*, struct S_PPF)) { cb(p0,p1); }
+EXPORT void f0_V_PS_PPD(void* p0, struct S_PPD p1,  void (*cb)(void*, struct S_PPD)) { cb(p0,p1); }
+EXPORT void f0_V_PS_PPP(void* p0, struct S_PPP p1,  void (*cb)(void*, struct S_PPP)) { cb(p0,p1); }
+EXPORT void f0_V_SI_I(struct S_I p0, int p1,  void (*cb)(struct S_I, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_F(struct S_F p0, int p1,  void (*cb)(struct S_F, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_D(struct S_D p0, int p1,  void (*cb)(struct S_D, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_P(struct S_P p0, int p1,  void (*cb)(struct S_P, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_II(struct S_II p0, int p1,  void (*cb)(struct S_II, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_IF(struct S_IF p0, int p1,  void (*cb)(struct S_IF, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_ID(struct S_ID p0, int p1,  void (*cb)(struct S_ID, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_IP(struct S_IP p0, int p1,  void (*cb)(struct S_IP, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_FI(struct S_FI p0, int p1,  void (*cb)(struct S_FI, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_FF(struct S_FF p0, int p1,  void (*cb)(struct S_FF, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_FD(struct S_FD p0, int p1,  void (*cb)(struct S_FD, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_FP(struct S_FP p0, int p1,  void (*cb)(struct S_FP, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_DI(struct S_DI p0, int p1,  void (*cb)(struct S_DI, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_DF(struct S_DF p0, int p1,  void (*cb)(struct S_DF, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_DD(struct S_DD p0, int p1,  void (*cb)(struct S_DD, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_DP(struct S_DP p0, int p1,  void (*cb)(struct S_DP, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_PI(struct S_PI p0, int p1,  void (*cb)(struct S_PI, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_PF(struct S_PF p0, int p1,  void (*cb)(struct S_PF, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_PD(struct S_PD p0, int p1,  void (*cb)(struct S_PD, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_PP(struct S_PP p0, int p1,  void (*cb)(struct S_PP, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_III(struct S_III p0, int p1,  void (*cb)(struct S_III, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_IIF(struct S_IIF p0, int p1,  void (*cb)(struct S_IIF, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_IID(struct S_IID p0, int p1,  void (*cb)(struct S_IID, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_IIP(struct S_IIP p0, int p1,  void (*cb)(struct S_IIP, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_IFI(struct S_IFI p0, int p1,  void (*cb)(struct S_IFI, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_IFF(struct S_IFF p0, int p1,  void (*cb)(struct S_IFF, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_IFD(struct S_IFD p0, int p1,  void (*cb)(struct S_IFD, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_IFP(struct S_IFP p0, int p1,  void (*cb)(struct S_IFP, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_IDI(struct S_IDI p0, int p1,  void (*cb)(struct S_IDI, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_IDF(struct S_IDF p0, int p1,  void (*cb)(struct S_IDF, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_IDD(struct S_IDD p0, int p1,  void (*cb)(struct S_IDD, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_IDP(struct S_IDP p0, int p1,  void (*cb)(struct S_IDP, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_IPI(struct S_IPI p0, int p1,  void (*cb)(struct S_IPI, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_IPF(struct S_IPF p0, int p1,  void (*cb)(struct S_IPF, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_IPD(struct S_IPD p0, int p1,  void (*cb)(struct S_IPD, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_IPP(struct S_IPP p0, int p1,  void (*cb)(struct S_IPP, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_FII(struct S_FII p0, int p1,  void (*cb)(struct S_FII, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_FIF(struct S_FIF p0, int p1,  void (*cb)(struct S_FIF, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_FID(struct S_FID p0, int p1,  void (*cb)(struct S_FID, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_FIP(struct S_FIP p0, int p1,  void (*cb)(struct S_FIP, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_FFI(struct S_FFI p0, int p1,  void (*cb)(struct S_FFI, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_FFF(struct S_FFF p0, int p1,  void (*cb)(struct S_FFF, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_FFD(struct S_FFD p0, int p1,  void (*cb)(struct S_FFD, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_FFP(struct S_FFP p0, int p1,  void (*cb)(struct S_FFP, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_FDI(struct S_FDI p0, int p1,  void (*cb)(struct S_FDI, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_FDF(struct S_FDF p0, int p1,  void (*cb)(struct S_FDF, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_FDD(struct S_FDD p0, int p1,  void (*cb)(struct S_FDD, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_FDP(struct S_FDP p0, int p1,  void (*cb)(struct S_FDP, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_FPI(struct S_FPI p0, int p1,  void (*cb)(struct S_FPI, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_FPF(struct S_FPF p0, int p1,  void (*cb)(struct S_FPF, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_FPD(struct S_FPD p0, int p1,  void (*cb)(struct S_FPD, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_FPP(struct S_FPP p0, int p1,  void (*cb)(struct S_FPP, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_DII(struct S_DII p0, int p1,  void (*cb)(struct S_DII, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_DIF(struct S_DIF p0, int p1,  void (*cb)(struct S_DIF, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_DID(struct S_DID p0, int p1,  void (*cb)(struct S_DID, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_DIP(struct S_DIP p0, int p1,  void (*cb)(struct S_DIP, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_DFI(struct S_DFI p0, int p1,  void (*cb)(struct S_DFI, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_DFF(struct S_DFF p0, int p1,  void (*cb)(struct S_DFF, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_DFD(struct S_DFD p0, int p1,  void (*cb)(struct S_DFD, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_DFP(struct S_DFP p0, int p1,  void (*cb)(struct S_DFP, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_DDI(struct S_DDI p0, int p1,  void (*cb)(struct S_DDI, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_DDF(struct S_DDF p0, int p1,  void (*cb)(struct S_DDF, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_DDD(struct S_DDD p0, int p1,  void (*cb)(struct S_DDD, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_DDP(struct S_DDP p0, int p1,  void (*cb)(struct S_DDP, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_DPI(struct S_DPI p0, int p1,  void (*cb)(struct S_DPI, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_DPF(struct S_DPF p0, int p1,  void (*cb)(struct S_DPF, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_DPD(struct S_DPD p0, int p1,  void (*cb)(struct S_DPD, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_DPP(struct S_DPP p0, int p1,  void (*cb)(struct S_DPP, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_PII(struct S_PII p0, int p1,  void (*cb)(struct S_PII, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_PIF(struct S_PIF p0, int p1,  void (*cb)(struct S_PIF, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_PID(struct S_PID p0, int p1,  void (*cb)(struct S_PID, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_PIP(struct S_PIP p0, int p1,  void (*cb)(struct S_PIP, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_PFI(struct S_PFI p0, int p1,  void (*cb)(struct S_PFI, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_PFF(struct S_PFF p0, int p1,  void (*cb)(struct S_PFF, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_PFD(struct S_PFD p0, int p1,  void (*cb)(struct S_PFD, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_PFP(struct S_PFP p0, int p1,  void (*cb)(struct S_PFP, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_PDI(struct S_PDI p0, int p1,  void (*cb)(struct S_PDI, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_PDF(struct S_PDF p0, int p1,  void (*cb)(struct S_PDF, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_PDD(struct S_PDD p0, int p1,  void (*cb)(struct S_PDD, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_PDP(struct S_PDP p0, int p1,  void (*cb)(struct S_PDP, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_PPI(struct S_PPI p0, int p1,  void (*cb)(struct S_PPI, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_PPF(struct S_PPF p0, int p1,  void (*cb)(struct S_PPF, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_PPD(struct S_PPD p0, int p1,  void (*cb)(struct S_PPD, int)) { cb(p0,p1); }
+EXPORT void f0_V_SI_PPP(struct S_PPP p0, int p1,  void (*cb)(struct S_PPP, int)) { cb(p0,p1); }
+EXPORT void f0_V_SF_I(struct S_I p0, float p1,  void (*cb)(struct S_I, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_F(struct S_F p0, float p1,  void (*cb)(struct S_F, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_D(struct S_D p0, float p1,  void (*cb)(struct S_D, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_P(struct S_P p0, float p1,  void (*cb)(struct S_P, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_II(struct S_II p0, float p1,  void (*cb)(struct S_II, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_IF(struct S_IF p0, float p1,  void (*cb)(struct S_IF, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_ID(struct S_ID p0, float p1,  void (*cb)(struct S_ID, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_IP(struct S_IP p0, float p1,  void (*cb)(struct S_IP, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_FI(struct S_FI p0, float p1,  void (*cb)(struct S_FI, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_FF(struct S_FF p0, float p1,  void (*cb)(struct S_FF, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_FD(struct S_FD p0, float p1,  void (*cb)(struct S_FD, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_FP(struct S_FP p0, float p1,  void (*cb)(struct S_FP, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_DI(struct S_DI p0, float p1,  void (*cb)(struct S_DI, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_DF(struct S_DF p0, float p1,  void (*cb)(struct S_DF, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_DD(struct S_DD p0, float p1,  void (*cb)(struct S_DD, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_DP(struct S_DP p0, float p1,  void (*cb)(struct S_DP, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_PI(struct S_PI p0, float p1,  void (*cb)(struct S_PI, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_PF(struct S_PF p0, float p1,  void (*cb)(struct S_PF, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_PD(struct S_PD p0, float p1,  void (*cb)(struct S_PD, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_PP(struct S_PP p0, float p1,  void (*cb)(struct S_PP, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_III(struct S_III p0, float p1,  void (*cb)(struct S_III, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_IIF(struct S_IIF p0, float p1,  void (*cb)(struct S_IIF, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_IID(struct S_IID p0, float p1,  void (*cb)(struct S_IID, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_IIP(struct S_IIP p0, float p1,  void (*cb)(struct S_IIP, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_IFI(struct S_IFI p0, float p1,  void (*cb)(struct S_IFI, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_IFF(struct S_IFF p0, float p1,  void (*cb)(struct S_IFF, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_IFD(struct S_IFD p0, float p1,  void (*cb)(struct S_IFD, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_IFP(struct S_IFP p0, float p1,  void (*cb)(struct S_IFP, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_IDI(struct S_IDI p0, float p1,  void (*cb)(struct S_IDI, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_IDF(struct S_IDF p0, float p1,  void (*cb)(struct S_IDF, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_IDD(struct S_IDD p0, float p1,  void (*cb)(struct S_IDD, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_IDP(struct S_IDP p0, float p1,  void (*cb)(struct S_IDP, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_IPI(struct S_IPI p0, float p1,  void (*cb)(struct S_IPI, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_IPF(struct S_IPF p0, float p1,  void (*cb)(struct S_IPF, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_IPD(struct S_IPD p0, float p1,  void (*cb)(struct S_IPD, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_IPP(struct S_IPP p0, float p1,  void (*cb)(struct S_IPP, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_FII(struct S_FII p0, float p1,  void (*cb)(struct S_FII, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_FIF(struct S_FIF p0, float p1,  void (*cb)(struct S_FIF, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_FID(struct S_FID p0, float p1,  void (*cb)(struct S_FID, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_FIP(struct S_FIP p0, float p1,  void (*cb)(struct S_FIP, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_FFI(struct S_FFI p0, float p1,  void (*cb)(struct S_FFI, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_FFF(struct S_FFF p0, float p1,  void (*cb)(struct S_FFF, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_FFD(struct S_FFD p0, float p1,  void (*cb)(struct S_FFD, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_FFP(struct S_FFP p0, float p1,  void (*cb)(struct S_FFP, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_FDI(struct S_FDI p0, float p1,  void (*cb)(struct S_FDI, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_FDF(struct S_FDF p0, float p1,  void (*cb)(struct S_FDF, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_FDD(struct S_FDD p0, float p1,  void (*cb)(struct S_FDD, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_FDP(struct S_FDP p0, float p1,  void (*cb)(struct S_FDP, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_FPI(struct S_FPI p0, float p1,  void (*cb)(struct S_FPI, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_FPF(struct S_FPF p0, float p1,  void (*cb)(struct S_FPF, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_FPD(struct S_FPD p0, float p1,  void (*cb)(struct S_FPD, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_FPP(struct S_FPP p0, float p1,  void (*cb)(struct S_FPP, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_DII(struct S_DII p0, float p1,  void (*cb)(struct S_DII, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_DIF(struct S_DIF p0, float p1,  void (*cb)(struct S_DIF, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_DID(struct S_DID p0, float p1,  void (*cb)(struct S_DID, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_DIP(struct S_DIP p0, float p1,  void (*cb)(struct S_DIP, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_DFI(struct S_DFI p0, float p1,  void (*cb)(struct S_DFI, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_DFF(struct S_DFF p0, float p1,  void (*cb)(struct S_DFF, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_DFD(struct S_DFD p0, float p1,  void (*cb)(struct S_DFD, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_DFP(struct S_DFP p0, float p1,  void (*cb)(struct S_DFP, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_DDI(struct S_DDI p0, float p1,  void (*cb)(struct S_DDI, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_DDF(struct S_DDF p0, float p1,  void (*cb)(struct S_DDF, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_DDD(struct S_DDD p0, float p1,  void (*cb)(struct S_DDD, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_DDP(struct S_DDP p0, float p1,  void (*cb)(struct S_DDP, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_DPI(struct S_DPI p0, float p1,  void (*cb)(struct S_DPI, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_DPF(struct S_DPF p0, float p1,  void (*cb)(struct S_DPF, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_DPD(struct S_DPD p0, float p1,  void (*cb)(struct S_DPD, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_DPP(struct S_DPP p0, float p1,  void (*cb)(struct S_DPP, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_PII(struct S_PII p0, float p1,  void (*cb)(struct S_PII, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_PIF(struct S_PIF p0, float p1,  void (*cb)(struct S_PIF, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_PID(struct S_PID p0, float p1,  void (*cb)(struct S_PID, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_PIP(struct S_PIP p0, float p1,  void (*cb)(struct S_PIP, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_PFI(struct S_PFI p0, float p1,  void (*cb)(struct S_PFI, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_PFF(struct S_PFF p0, float p1,  void (*cb)(struct S_PFF, float)) { cb(p0,p1); }
+EXPORT void f0_V_SF_PFD(struct S_PFD p0, float p1,  void (*cb)(struct S_PFD, float)) { cb(p0,p1); }
+EXPORT void f1_V_SF_PFP(struct S_PFP p0, float p1,  void (*cb)(struct S_PFP, float)) { cb(p0,p1); }
+EXPORT void f1_V_SF_PDI(struct S_PDI p0, float p1,  void (*cb)(struct S_PDI, float)) { cb(p0,p1); }
+EXPORT void f1_V_SF_PDF(struct S_PDF p0, float p1,  void (*cb)(struct S_PDF, float)) { cb(p0,p1); }
+EXPORT void f1_V_SF_PDD(struct S_PDD p0, float p1,  void (*cb)(struct S_PDD, float)) { cb(p0,p1); }
+EXPORT void f1_V_SF_PDP(struct S_PDP p0, float p1,  void (*cb)(struct S_PDP, float)) { cb(p0,p1); }
+EXPORT void f1_V_SF_PPI(struct S_PPI p0, float p1,  void (*cb)(struct S_PPI, float)) { cb(p0,p1); }
+EXPORT void f1_V_SF_PPF(struct S_PPF p0, float p1,  void (*cb)(struct S_PPF, float)) { cb(p0,p1); }
+EXPORT void f1_V_SF_PPD(struct S_PPD p0, float p1,  void (*cb)(struct S_PPD, float)) { cb(p0,p1); }
+EXPORT void f1_V_SF_PPP(struct S_PPP p0, float p1,  void (*cb)(struct S_PPP, float)) { cb(p0,p1); }
+EXPORT void f1_V_SD_I(struct S_I p0, double p1,  void (*cb)(struct S_I, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_F(struct S_F p0, double p1,  void (*cb)(struct S_F, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_D(struct S_D p0, double p1,  void (*cb)(struct S_D, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_P(struct S_P p0, double p1,  void (*cb)(struct S_P, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_II(struct S_II p0, double p1,  void (*cb)(struct S_II, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_IF(struct S_IF p0, double p1,  void (*cb)(struct S_IF, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_ID(struct S_ID p0, double p1,  void (*cb)(struct S_ID, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_IP(struct S_IP p0, double p1,  void (*cb)(struct S_IP, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_FI(struct S_FI p0, double p1,  void (*cb)(struct S_FI, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_FF(struct S_FF p0, double p1,  void (*cb)(struct S_FF, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_FD(struct S_FD p0, double p1,  void (*cb)(struct S_FD, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_FP(struct S_FP p0, double p1,  void (*cb)(struct S_FP, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_DI(struct S_DI p0, double p1,  void (*cb)(struct S_DI, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_DF(struct S_DF p0, double p1,  void (*cb)(struct S_DF, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_DD(struct S_DD p0, double p1,  void (*cb)(struct S_DD, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_DP(struct S_DP p0, double p1,  void (*cb)(struct S_DP, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_PI(struct S_PI p0, double p1,  void (*cb)(struct S_PI, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_PF(struct S_PF p0, double p1,  void (*cb)(struct S_PF, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_PD(struct S_PD p0, double p1,  void (*cb)(struct S_PD, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_PP(struct S_PP p0, double p1,  void (*cb)(struct S_PP, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_III(struct S_III p0, double p1,  void (*cb)(struct S_III, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_IIF(struct S_IIF p0, double p1,  void (*cb)(struct S_IIF, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_IID(struct S_IID p0, double p1,  void (*cb)(struct S_IID, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_IIP(struct S_IIP p0, double p1,  void (*cb)(struct S_IIP, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_IFI(struct S_IFI p0, double p1,  void (*cb)(struct S_IFI, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_IFF(struct S_IFF p0, double p1,  void (*cb)(struct S_IFF, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_IFD(struct S_IFD p0, double p1,  void (*cb)(struct S_IFD, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_IFP(struct S_IFP p0, double p1,  void (*cb)(struct S_IFP, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_IDI(struct S_IDI p0, double p1,  void (*cb)(struct S_IDI, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_IDF(struct S_IDF p0, double p1,  void (*cb)(struct S_IDF, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_IDD(struct S_IDD p0, double p1,  void (*cb)(struct S_IDD, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_IDP(struct S_IDP p0, double p1,  void (*cb)(struct S_IDP, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_IPI(struct S_IPI p0, double p1,  void (*cb)(struct S_IPI, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_IPF(struct S_IPF p0, double p1,  void (*cb)(struct S_IPF, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_IPD(struct S_IPD p0, double p1,  void (*cb)(struct S_IPD, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_IPP(struct S_IPP p0, double p1,  void (*cb)(struct S_IPP, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_FII(struct S_FII p0, double p1,  void (*cb)(struct S_FII, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_FIF(struct S_FIF p0, double p1,  void (*cb)(struct S_FIF, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_FID(struct S_FID p0, double p1,  void (*cb)(struct S_FID, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_FIP(struct S_FIP p0, double p1,  void (*cb)(struct S_FIP, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_FFI(struct S_FFI p0, double p1,  void (*cb)(struct S_FFI, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_FFF(struct S_FFF p0, double p1,  void (*cb)(struct S_FFF, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_FFD(struct S_FFD p0, double p1,  void (*cb)(struct S_FFD, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_FFP(struct S_FFP p0, double p1,  void (*cb)(struct S_FFP, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_FDI(struct S_FDI p0, double p1,  void (*cb)(struct S_FDI, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_FDF(struct S_FDF p0, double p1,  void (*cb)(struct S_FDF, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_FDD(struct S_FDD p0, double p1,  void (*cb)(struct S_FDD, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_FDP(struct S_FDP p0, double p1,  void (*cb)(struct S_FDP, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_FPI(struct S_FPI p0, double p1,  void (*cb)(struct S_FPI, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_FPF(struct S_FPF p0, double p1,  void (*cb)(struct S_FPF, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_FPD(struct S_FPD p0, double p1,  void (*cb)(struct S_FPD, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_FPP(struct S_FPP p0, double p1,  void (*cb)(struct S_FPP, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_DII(struct S_DII p0, double p1,  void (*cb)(struct S_DII, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_DIF(struct S_DIF p0, double p1,  void (*cb)(struct S_DIF, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_DID(struct S_DID p0, double p1,  void (*cb)(struct S_DID, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_DIP(struct S_DIP p0, double p1,  void (*cb)(struct S_DIP, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_DFI(struct S_DFI p0, double p1,  void (*cb)(struct S_DFI, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_DFF(struct S_DFF p0, double p1,  void (*cb)(struct S_DFF, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_DFD(struct S_DFD p0, double p1,  void (*cb)(struct S_DFD, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_DFP(struct S_DFP p0, double p1,  void (*cb)(struct S_DFP, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_DDI(struct S_DDI p0, double p1,  void (*cb)(struct S_DDI, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_DDF(struct S_DDF p0, double p1,  void (*cb)(struct S_DDF, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_DDD(struct S_DDD p0, double p1,  void (*cb)(struct S_DDD, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_DDP(struct S_DDP p0, double p1,  void (*cb)(struct S_DDP, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_DPI(struct S_DPI p0, double p1,  void (*cb)(struct S_DPI, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_DPF(struct S_DPF p0, double p1,  void (*cb)(struct S_DPF, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_DPD(struct S_DPD p0, double p1,  void (*cb)(struct S_DPD, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_DPP(struct S_DPP p0, double p1,  void (*cb)(struct S_DPP, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_PII(struct S_PII p0, double p1,  void (*cb)(struct S_PII, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_PIF(struct S_PIF p0, double p1,  void (*cb)(struct S_PIF, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_PID(struct S_PID p0, double p1,  void (*cb)(struct S_PID, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_PIP(struct S_PIP p0, double p1,  void (*cb)(struct S_PIP, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_PFI(struct S_PFI p0, double p1,  void (*cb)(struct S_PFI, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_PFF(struct S_PFF p0, double p1,  void (*cb)(struct S_PFF, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_PFD(struct S_PFD p0, double p1,  void (*cb)(struct S_PFD, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_PFP(struct S_PFP p0, double p1,  void (*cb)(struct S_PFP, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_PDI(struct S_PDI p0, double p1,  void (*cb)(struct S_PDI, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_PDF(struct S_PDF p0, double p1,  void (*cb)(struct S_PDF, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_PDD(struct S_PDD p0, double p1,  void (*cb)(struct S_PDD, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_PDP(struct S_PDP p0, double p1,  void (*cb)(struct S_PDP, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_PPI(struct S_PPI p0, double p1,  void (*cb)(struct S_PPI, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_PPF(struct S_PPF p0, double p1,  void (*cb)(struct S_PPF, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_PPD(struct S_PPD p0, double p1,  void (*cb)(struct S_PPD, double)) { cb(p0,p1); }
+EXPORT void f1_V_SD_PPP(struct S_PPP p0, double p1,  void (*cb)(struct S_PPP, double)) { cb(p0,p1); }
+EXPORT void f1_V_SP_I(struct S_I p0, void* p1,  void (*cb)(struct S_I, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_F(struct S_F p0, void* p1,  void (*cb)(struct S_F, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_D(struct S_D p0, void* p1,  void (*cb)(struct S_D, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_P(struct S_P p0, void* p1,  void (*cb)(struct S_P, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_II(struct S_II p0, void* p1,  void (*cb)(struct S_II, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_IF(struct S_IF p0, void* p1,  void (*cb)(struct S_IF, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_ID(struct S_ID p0, void* p1,  void (*cb)(struct S_ID, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_IP(struct S_IP p0, void* p1,  void (*cb)(struct S_IP, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_FI(struct S_FI p0, void* p1,  void (*cb)(struct S_FI, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_FF(struct S_FF p0, void* p1,  void (*cb)(struct S_FF, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_FD(struct S_FD p0, void* p1,  void (*cb)(struct S_FD, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_FP(struct S_FP p0, void* p1,  void (*cb)(struct S_FP, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_DI(struct S_DI p0, void* p1,  void (*cb)(struct S_DI, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_DF(struct S_DF p0, void* p1,  void (*cb)(struct S_DF, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_DD(struct S_DD p0, void* p1,  void (*cb)(struct S_DD, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_DP(struct S_DP p0, void* p1,  void (*cb)(struct S_DP, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_PI(struct S_PI p0, void* p1,  void (*cb)(struct S_PI, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_PF(struct S_PF p0, void* p1,  void (*cb)(struct S_PF, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_PD(struct S_PD p0, void* p1,  void (*cb)(struct S_PD, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_PP(struct S_PP p0, void* p1,  void (*cb)(struct S_PP, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_III(struct S_III p0, void* p1,  void (*cb)(struct S_III, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_IIF(struct S_IIF p0, void* p1,  void (*cb)(struct S_IIF, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_IID(struct S_IID p0, void* p1,  void (*cb)(struct S_IID, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_IIP(struct S_IIP p0, void* p1,  void (*cb)(struct S_IIP, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_IFI(struct S_IFI p0, void* p1,  void (*cb)(struct S_IFI, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_IFF(struct S_IFF p0, void* p1,  void (*cb)(struct S_IFF, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_IFD(struct S_IFD p0, void* p1,  void (*cb)(struct S_IFD, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_IFP(struct S_IFP p0, void* p1,  void (*cb)(struct S_IFP, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_IDI(struct S_IDI p0, void* p1,  void (*cb)(struct S_IDI, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_IDF(struct S_IDF p0, void* p1,  void (*cb)(struct S_IDF, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_IDD(struct S_IDD p0, void* p1,  void (*cb)(struct S_IDD, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_IDP(struct S_IDP p0, void* p1,  void (*cb)(struct S_IDP, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_IPI(struct S_IPI p0, void* p1,  void (*cb)(struct S_IPI, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_IPF(struct S_IPF p0, void* p1,  void (*cb)(struct S_IPF, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_IPD(struct S_IPD p0, void* p1,  void (*cb)(struct S_IPD, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_IPP(struct S_IPP p0, void* p1,  void (*cb)(struct S_IPP, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_FII(struct S_FII p0, void* p1,  void (*cb)(struct S_FII, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_FIF(struct S_FIF p0, void* p1,  void (*cb)(struct S_FIF, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_FID(struct S_FID p0, void* p1,  void (*cb)(struct S_FID, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_FIP(struct S_FIP p0, void* p1,  void (*cb)(struct S_FIP, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_FFI(struct S_FFI p0, void* p1,  void (*cb)(struct S_FFI, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_FFF(struct S_FFF p0, void* p1,  void (*cb)(struct S_FFF, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_FFD(struct S_FFD p0, void* p1,  void (*cb)(struct S_FFD, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_FFP(struct S_FFP p0, void* p1,  void (*cb)(struct S_FFP, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_FDI(struct S_FDI p0, void* p1,  void (*cb)(struct S_FDI, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_FDF(struct S_FDF p0, void* p1,  void (*cb)(struct S_FDF, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_FDD(struct S_FDD p0, void* p1,  void (*cb)(struct S_FDD, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_FDP(struct S_FDP p0, void* p1,  void (*cb)(struct S_FDP, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_FPI(struct S_FPI p0, void* p1,  void (*cb)(struct S_FPI, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_FPF(struct S_FPF p0, void* p1,  void (*cb)(struct S_FPF, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_FPD(struct S_FPD p0, void* p1,  void (*cb)(struct S_FPD, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_FPP(struct S_FPP p0, void* p1,  void (*cb)(struct S_FPP, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_DII(struct S_DII p0, void* p1,  void (*cb)(struct S_DII, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_DIF(struct S_DIF p0, void* p1,  void (*cb)(struct S_DIF, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_DID(struct S_DID p0, void* p1,  void (*cb)(struct S_DID, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_DIP(struct S_DIP p0, void* p1,  void (*cb)(struct S_DIP, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_DFI(struct S_DFI p0, void* p1,  void (*cb)(struct S_DFI, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_DFF(struct S_DFF p0, void* p1,  void (*cb)(struct S_DFF, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_DFD(struct S_DFD p0, void* p1,  void (*cb)(struct S_DFD, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_DFP(struct S_DFP p0, void* p1,  void (*cb)(struct S_DFP, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_DDI(struct S_DDI p0, void* p1,  void (*cb)(struct S_DDI, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_DDF(struct S_DDF p0, void* p1,  void (*cb)(struct S_DDF, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_DDD(struct S_DDD p0, void* p1,  void (*cb)(struct S_DDD, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_DDP(struct S_DDP p0, void* p1,  void (*cb)(struct S_DDP, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_DPI(struct S_DPI p0, void* p1,  void (*cb)(struct S_DPI, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_DPF(struct S_DPF p0, void* p1,  void (*cb)(struct S_DPF, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_DPD(struct S_DPD p0, void* p1,  void (*cb)(struct S_DPD, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_DPP(struct S_DPP p0, void* p1,  void (*cb)(struct S_DPP, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_PII(struct S_PII p0, void* p1,  void (*cb)(struct S_PII, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_PIF(struct S_PIF p0, void* p1,  void (*cb)(struct S_PIF, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_PID(struct S_PID p0, void* p1,  void (*cb)(struct S_PID, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_PIP(struct S_PIP p0, void* p1,  void (*cb)(struct S_PIP, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_PFI(struct S_PFI p0, void* p1,  void (*cb)(struct S_PFI, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_PFF(struct S_PFF p0, void* p1,  void (*cb)(struct S_PFF, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_PFD(struct S_PFD p0, void* p1,  void (*cb)(struct S_PFD, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_PFP(struct S_PFP p0, void* p1,  void (*cb)(struct S_PFP, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_PDI(struct S_PDI p0, void* p1,  void (*cb)(struct S_PDI, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_PDF(struct S_PDF p0, void* p1,  void (*cb)(struct S_PDF, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_PDD(struct S_PDD p0, void* p1,  void (*cb)(struct S_PDD, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_PDP(struct S_PDP p0, void* p1,  void (*cb)(struct S_PDP, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_PPI(struct S_PPI p0, void* p1,  void (*cb)(struct S_PPI, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_PPF(struct S_PPF p0, void* p1,  void (*cb)(struct S_PPF, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_PPD(struct S_PPD p0, void* p1,  void (*cb)(struct S_PPD, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SP_PPP(struct S_PPP p0, void* p1,  void (*cb)(struct S_PPP, void*)) { cb(p0,p1); }
+EXPORT void f1_V_SS_I(struct S_I p0, struct S_I p1,  void (*cb)(struct S_I, struct S_I)) { cb(p0,p1); }
+EXPORT void f1_V_SS_F(struct S_F p0, struct S_F p1,  void (*cb)(struct S_F, struct S_F)) { cb(p0,p1); }
+EXPORT void f1_V_SS_D(struct S_D p0, struct S_D p1,  void (*cb)(struct S_D, struct S_D)) { cb(p0,p1); }
+EXPORT void f1_V_SS_P(struct S_P p0, struct S_P p1,  void (*cb)(struct S_P, struct S_P)) { cb(p0,p1); }
+EXPORT void f1_V_SS_II(struct S_II p0, struct S_II p1,  void (*cb)(struct S_II, struct S_II)) { cb(p0,p1); }
+EXPORT void f1_V_SS_IF(struct S_IF p0, struct S_IF p1,  void (*cb)(struct S_IF, struct S_IF)) { cb(p0,p1); }
+EXPORT void f1_V_SS_ID(struct S_ID p0, struct S_ID p1,  void (*cb)(struct S_ID, struct S_ID)) { cb(p0,p1); }
+EXPORT void f1_V_SS_IP(struct S_IP p0, struct S_IP p1,  void (*cb)(struct S_IP, struct S_IP)) { cb(p0,p1); }
+EXPORT void f1_V_SS_FI(struct S_FI p0, struct S_FI p1,  void (*cb)(struct S_FI, struct S_FI)) { cb(p0,p1); }
+EXPORT void f1_V_SS_FF(struct S_FF p0, struct S_FF p1,  void (*cb)(struct S_FF, struct S_FF)) { cb(p0,p1); }
+EXPORT void f1_V_SS_FD(struct S_FD p0, struct S_FD p1,  void (*cb)(struct S_FD, struct S_FD)) { cb(p0,p1); }
+EXPORT void f1_V_SS_FP(struct S_FP p0, struct S_FP p1,  void (*cb)(struct S_FP, struct S_FP)) { cb(p0,p1); }
+EXPORT void f1_V_SS_DI(struct S_DI p0, struct S_DI p1,  void (*cb)(struct S_DI, struct S_DI)) { cb(p0,p1); }
+EXPORT void f1_V_SS_DF(struct S_DF p0, struct S_DF p1,  void (*cb)(struct S_DF, struct S_DF)) { cb(p0,p1); }
+EXPORT void f1_V_SS_DD(struct S_DD p0, struct S_DD p1,  void (*cb)(struct S_DD, struct S_DD)) { cb(p0,p1); }
+EXPORT void f1_V_SS_DP(struct S_DP p0, struct S_DP p1,  void (*cb)(struct S_DP, struct S_DP)) { cb(p0,p1); }
+EXPORT void f1_V_SS_PI(struct S_PI p0, struct S_PI p1,  void (*cb)(struct S_PI, struct S_PI)) { cb(p0,p1); }
+EXPORT void f1_V_SS_PF(struct S_PF p0, struct S_PF p1,  void (*cb)(struct S_PF, struct S_PF)) { cb(p0,p1); }
+EXPORT void f1_V_SS_PD(struct S_PD p0, struct S_PD p1,  void (*cb)(struct S_PD, struct S_PD)) { cb(p0,p1); }
+EXPORT void f1_V_SS_PP(struct S_PP p0, struct S_PP p1,  void (*cb)(struct S_PP, struct S_PP)) { cb(p0,p1); }
+EXPORT void f1_V_SS_III(struct S_III p0, struct S_III p1,  void (*cb)(struct S_III, struct S_III)) { cb(p0,p1); }
+EXPORT void f1_V_SS_IIF(struct S_IIF p0, struct S_IIF p1,  void (*cb)(struct S_IIF, struct S_IIF)) { cb(p0,p1); }
+EXPORT void f1_V_SS_IID(struct S_IID p0, struct S_IID p1,  void (*cb)(struct S_IID, struct S_IID)) { cb(p0,p1); }
+EXPORT void f1_V_SS_IIP(struct S_IIP p0, struct S_IIP p1,  void (*cb)(struct S_IIP, struct S_IIP)) { cb(p0,p1); }
+EXPORT void f1_V_SS_IFI(struct S_IFI p0, struct S_IFI p1,  void (*cb)(struct S_IFI, struct S_IFI)) { cb(p0,p1); }
+EXPORT void f1_V_SS_IFF(struct S_IFF p0, struct S_IFF p1,  void (*cb)(struct S_IFF, struct S_IFF)) { cb(p0,p1); }
+EXPORT void f1_V_SS_IFD(struct S_IFD p0, struct S_IFD p1,  void (*cb)(struct S_IFD, struct S_IFD)) { cb(p0,p1); }
+EXPORT void f1_V_SS_IFP(struct S_IFP p0, struct S_IFP p1,  void (*cb)(struct S_IFP, struct S_IFP)) { cb(p0,p1); }
+EXPORT void f1_V_SS_IDI(struct S_IDI p0, struct S_IDI p1,  void (*cb)(struct S_IDI, struct S_IDI)) { cb(p0,p1); }
+EXPORT void f1_V_SS_IDF(struct S_IDF p0, struct S_IDF p1,  void (*cb)(struct S_IDF, struct S_IDF)) { cb(p0,p1); }
+EXPORT void f1_V_SS_IDD(struct S_IDD p0, struct S_IDD p1,  void (*cb)(struct S_IDD, struct S_IDD)) { cb(p0,p1); }
+EXPORT void f1_V_SS_IDP(struct S_IDP p0, struct S_IDP p1,  void (*cb)(struct S_IDP, struct S_IDP)) { cb(p0,p1); }
+EXPORT void f1_V_SS_IPI(struct S_IPI p0, struct S_IPI p1,  void (*cb)(struct S_IPI, struct S_IPI)) { cb(p0,p1); }
+EXPORT void f1_V_SS_IPF(struct S_IPF p0, struct S_IPF p1,  void (*cb)(struct S_IPF, struct S_IPF)) { cb(p0,p1); }
+EXPORT void f1_V_SS_IPD(struct S_IPD p0, struct S_IPD p1,  void (*cb)(struct S_IPD, struct S_IPD)) { cb(p0,p1); }
+EXPORT void f1_V_SS_IPP(struct S_IPP p0, struct S_IPP p1,  void (*cb)(struct S_IPP, struct S_IPP)) { cb(p0,p1); }
+EXPORT void f1_V_SS_FII(struct S_FII p0, struct S_FII p1,  void (*cb)(struct S_FII, struct S_FII)) { cb(p0,p1); }
+EXPORT void f1_V_SS_FIF(struct S_FIF p0, struct S_FIF p1,  void (*cb)(struct S_FIF, struct S_FIF)) { cb(p0,p1); }
+EXPORT void f1_V_SS_FID(struct S_FID p0, struct S_FID p1,  void (*cb)(struct S_FID, struct S_FID)) { cb(p0,p1); }
+EXPORT void f1_V_SS_FIP(struct S_FIP p0, struct S_FIP p1,  void (*cb)(struct S_FIP, struct S_FIP)) { cb(p0,p1); }
+EXPORT void f1_V_SS_FFI(struct S_FFI p0, struct S_FFI p1,  void (*cb)(struct S_FFI, struct S_FFI)) { cb(p0,p1); }
+EXPORT void f1_V_SS_FFF(struct S_FFF p0, struct S_FFF p1,  void (*cb)(struct S_FFF, struct S_FFF)) { cb(p0,p1); }
+EXPORT void f1_V_SS_FFD(struct S_FFD p0, struct S_FFD p1,  void (*cb)(struct S_FFD, struct S_FFD)) { cb(p0,p1); }
+EXPORT void f1_V_SS_FFP(struct S_FFP p0, struct S_FFP p1,  void (*cb)(struct S_FFP, struct S_FFP)) { cb(p0,p1); }
+EXPORT void f1_V_SS_FDI(struct S_FDI p0, struct S_FDI p1,  void (*cb)(struct S_FDI, struct S_FDI)) { cb(p0,p1); }
+EXPORT void f1_V_SS_FDF(struct S_FDF p0, struct S_FDF p1,  void (*cb)(struct S_FDF, struct S_FDF)) { cb(p0,p1); }
+EXPORT void f1_V_SS_FDD(struct S_FDD p0, struct S_FDD p1,  void (*cb)(struct S_FDD, struct S_FDD)) { cb(p0,p1); }
+EXPORT void f1_V_SS_FDP(struct S_FDP p0, struct S_FDP p1,  void (*cb)(struct S_FDP, struct S_FDP)) { cb(p0,p1); }
+EXPORT void f1_V_SS_FPI(struct S_FPI p0, struct S_FPI p1,  void (*cb)(struct S_FPI, struct S_FPI)) { cb(p0,p1); }
+EXPORT void f1_V_SS_FPF(struct S_FPF p0, struct S_FPF p1,  void (*cb)(struct S_FPF, struct S_FPF)) { cb(p0,p1); }
+EXPORT void f1_V_SS_FPD(struct S_FPD p0, struct S_FPD p1,  void (*cb)(struct S_FPD, struct S_FPD)) { cb(p0,p1); }
+EXPORT void f1_V_SS_FPP(struct S_FPP p0, struct S_FPP p1,  void (*cb)(struct S_FPP, struct S_FPP)) { cb(p0,p1); }
+EXPORT void f1_V_SS_DII(struct S_DII p0, struct S_DII p1,  void (*cb)(struct S_DII, struct S_DII)) { cb(p0,p1); }
+EXPORT void f1_V_SS_DIF(struct S_DIF p0, struct S_DIF p1,  void (*cb)(struct S_DIF, struct S_DIF)) { cb(p0,p1); }
+EXPORT void f1_V_SS_DID(struct S_DID p0, struct S_DID p1,  void (*cb)(struct S_DID, struct S_DID)) { cb(p0,p1); }
+EXPORT void f1_V_SS_DIP(struct S_DIP p0, struct S_DIP p1,  void (*cb)(struct S_DIP, struct S_DIP)) { cb(p0,p1); }
+EXPORT void f1_V_SS_DFI(struct S_DFI p0, struct S_DFI p1,  void (*cb)(struct S_DFI, struct S_DFI)) { cb(p0,p1); }
+EXPORT void f1_V_SS_DFF(struct S_DFF p0, struct S_DFF p1,  void (*cb)(struct S_DFF, struct S_DFF)) { cb(p0,p1); }
+EXPORT void f1_V_SS_DFD(struct S_DFD p0, struct S_DFD p1,  void (*cb)(struct S_DFD, struct S_DFD)) { cb(p0,p1); }
+EXPORT void f1_V_SS_DFP(struct S_DFP p0, struct S_DFP p1,  void (*cb)(struct S_DFP, struct S_DFP)) { cb(p0,p1); }
+EXPORT void f1_V_SS_DDI(struct S_DDI p0, struct S_DDI p1,  void (*cb)(struct S_DDI, struct S_DDI)) { cb(p0,p1); }
+EXPORT void f1_V_SS_DDF(struct S_DDF p0, struct S_DDF p1,  void (*cb)(struct S_DDF, struct S_DDF)) { cb(p0,p1); }
+EXPORT void f1_V_SS_DDD(struct S_DDD p0, struct S_DDD p1,  void (*cb)(struct S_DDD, struct S_DDD)) { cb(p0,p1); }
+EXPORT void f1_V_SS_DDP(struct S_DDP p0, struct S_DDP p1,  void (*cb)(struct S_DDP, struct S_DDP)) { cb(p0,p1); }
+EXPORT void f1_V_SS_DPI(struct S_DPI p0, struct S_DPI p1,  void (*cb)(struct S_DPI, struct S_DPI)) { cb(p0,p1); }
+EXPORT void f1_V_SS_DPF(struct S_DPF p0, struct S_DPF p1,  void (*cb)(struct S_DPF, struct S_DPF)) { cb(p0,p1); }
+EXPORT void f1_V_SS_DPD(struct S_DPD p0, struct S_DPD p1,  void (*cb)(struct S_DPD, struct S_DPD)) { cb(p0,p1); }
+EXPORT void f1_V_SS_DPP(struct S_DPP p0, struct S_DPP p1,  void (*cb)(struct S_DPP, struct S_DPP)) { cb(p0,p1); }
+EXPORT void f1_V_SS_PII(struct S_PII p0, struct S_PII p1,  void (*cb)(struct S_PII, struct S_PII)) { cb(p0,p1); }
+EXPORT void f1_V_SS_PIF(struct S_PIF p0, struct S_PIF p1,  void (*cb)(struct S_PIF, struct S_PIF)) { cb(p0,p1); }
+EXPORT void f1_V_SS_PID(struct S_PID p0, struct S_PID p1,  void (*cb)(struct S_PID, struct S_PID)) { cb(p0,p1); }
+EXPORT void f1_V_SS_PIP(struct S_PIP p0, struct S_PIP p1,  void (*cb)(struct S_PIP, struct S_PIP)) { cb(p0,p1); }
+EXPORT void f1_V_SS_PFI(struct S_PFI p0, struct S_PFI p1,  void (*cb)(struct S_PFI, struct S_PFI)) { cb(p0,p1); }
+EXPORT void f1_V_SS_PFF(struct S_PFF p0, struct S_PFF p1,  void (*cb)(struct S_PFF, struct S_PFF)) { cb(p0,p1); }
+EXPORT void f1_V_SS_PFD(struct S_PFD p0, struct S_PFD p1,  void (*cb)(struct S_PFD, struct S_PFD)) { cb(p0,p1); }
+EXPORT void f1_V_SS_PFP(struct S_PFP p0, struct S_PFP p1,  void (*cb)(struct S_PFP, struct S_PFP)) { cb(p0,p1); }
+EXPORT void f1_V_SS_PDI(struct S_PDI p0, struct S_PDI p1,  void (*cb)(struct S_PDI, struct S_PDI)) { cb(p0,p1); }
+EXPORT void f1_V_SS_PDF(struct S_PDF p0, struct S_PDF p1,  void (*cb)(struct S_PDF, struct S_PDF)) { cb(p0,p1); }
+EXPORT void f1_V_SS_PDD(struct S_PDD p0, struct S_PDD p1,  void (*cb)(struct S_PDD, struct S_PDD)) { cb(p0,p1); }
+EXPORT void f1_V_SS_PDP(struct S_PDP p0, struct S_PDP p1,  void (*cb)(struct S_PDP, struct S_PDP)) { cb(p0,p1); }
+EXPORT void f1_V_SS_PPI(struct S_PPI p0, struct S_PPI p1,  void (*cb)(struct S_PPI, struct S_PPI)) { cb(p0,p1); }
+EXPORT void f1_V_SS_PPF(struct S_PPF p0, struct S_PPF p1,  void (*cb)(struct S_PPF, struct S_PPF)) { cb(p0,p1); }
+EXPORT void f1_V_SS_PPD(struct S_PPD p0, struct S_PPD p1,  void (*cb)(struct S_PPD, struct S_PPD)) { cb(p0,p1); }
+EXPORT void f1_V_SS_PPP(struct S_PPP p0, struct S_PPP p1,  void (*cb)(struct S_PPP, struct S_PPP)) { cb(p0,p1); }
+EXPORT void f1_V_III_(int p0, int p1, int p2,  void (*cb)(int, int, int)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIF_(int p0, int p1, float p2,  void (*cb)(int, int, float)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IID_(int p0, int p1, double p2,  void (*cb)(int, int, double)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIP_(int p0, int p1, void* p2,  void (*cb)(int, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_I(int p0, int p1, struct S_I p2,  void (*cb)(int, int, struct S_I)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_F(int p0, int p1, struct S_F p2,  void (*cb)(int, int, struct S_F)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_D(int p0, int p1, struct S_D p2,  void (*cb)(int, int, struct S_D)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_P(int p0, int p1, struct S_P p2,  void (*cb)(int, int, struct S_P)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_II(int p0, int p1, struct S_II p2,  void (*cb)(int, int, struct S_II)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_IF(int p0, int p1, struct S_IF p2,  void (*cb)(int, int, struct S_IF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_ID(int p0, int p1, struct S_ID p2,  void (*cb)(int, int, struct S_ID)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_IP(int p0, int p1, struct S_IP p2,  void (*cb)(int, int, struct S_IP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_FI(int p0, int p1, struct S_FI p2,  void (*cb)(int, int, struct S_FI)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_FF(int p0, int p1, struct S_FF p2,  void (*cb)(int, int, struct S_FF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_FD(int p0, int p1, struct S_FD p2,  void (*cb)(int, int, struct S_FD)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_FP(int p0, int p1, struct S_FP p2,  void (*cb)(int, int, struct S_FP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_DI(int p0, int p1, struct S_DI p2,  void (*cb)(int, int, struct S_DI)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_DF(int p0, int p1, struct S_DF p2,  void (*cb)(int, int, struct S_DF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_DD(int p0, int p1, struct S_DD p2,  void (*cb)(int, int, struct S_DD)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_DP(int p0, int p1, struct S_DP p2,  void (*cb)(int, int, struct S_DP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_PI(int p0, int p1, struct S_PI p2,  void (*cb)(int, int, struct S_PI)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_PF(int p0, int p1, struct S_PF p2,  void (*cb)(int, int, struct S_PF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_PD(int p0, int p1, struct S_PD p2,  void (*cb)(int, int, struct S_PD)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_PP(int p0, int p1, struct S_PP p2,  void (*cb)(int, int, struct S_PP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_III(int p0, int p1, struct S_III p2,  void (*cb)(int, int, struct S_III)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_IIF(int p0, int p1, struct S_IIF p2,  void (*cb)(int, int, struct S_IIF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_IID(int p0, int p1, struct S_IID p2,  void (*cb)(int, int, struct S_IID)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_IIP(int p0, int p1, struct S_IIP p2,  void (*cb)(int, int, struct S_IIP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_IFI(int p0, int p1, struct S_IFI p2,  void (*cb)(int, int, struct S_IFI)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_IFF(int p0, int p1, struct S_IFF p2,  void (*cb)(int, int, struct S_IFF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_IFD(int p0, int p1, struct S_IFD p2,  void (*cb)(int, int, struct S_IFD)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_IFP(int p0, int p1, struct S_IFP p2,  void (*cb)(int, int, struct S_IFP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_IDI(int p0, int p1, struct S_IDI p2,  void (*cb)(int, int, struct S_IDI)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_IDF(int p0, int p1, struct S_IDF p2,  void (*cb)(int, int, struct S_IDF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_IDD(int p0, int p1, struct S_IDD p2,  void (*cb)(int, int, struct S_IDD)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_IDP(int p0, int p1, struct S_IDP p2,  void (*cb)(int, int, struct S_IDP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_IPI(int p0, int p1, struct S_IPI p2,  void (*cb)(int, int, struct S_IPI)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_IPF(int p0, int p1, struct S_IPF p2,  void (*cb)(int, int, struct S_IPF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_IPD(int p0, int p1, struct S_IPD p2,  void (*cb)(int, int, struct S_IPD)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_IPP(int p0, int p1, struct S_IPP p2,  void (*cb)(int, int, struct S_IPP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_FII(int p0, int p1, struct S_FII p2,  void (*cb)(int, int, struct S_FII)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_FIF(int p0, int p1, struct S_FIF p2,  void (*cb)(int, int, struct S_FIF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_FID(int p0, int p1, struct S_FID p2,  void (*cb)(int, int, struct S_FID)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_FIP(int p0, int p1, struct S_FIP p2,  void (*cb)(int, int, struct S_FIP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_FFI(int p0, int p1, struct S_FFI p2,  void (*cb)(int, int, struct S_FFI)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_FFF(int p0, int p1, struct S_FFF p2,  void (*cb)(int, int, struct S_FFF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_FFD(int p0, int p1, struct S_FFD p2,  void (*cb)(int, int, struct S_FFD)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_FFP(int p0, int p1, struct S_FFP p2,  void (*cb)(int, int, struct S_FFP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_FDI(int p0, int p1, struct S_FDI p2,  void (*cb)(int, int, struct S_FDI)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_FDF(int p0, int p1, struct S_FDF p2,  void (*cb)(int, int, struct S_FDF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_FDD(int p0, int p1, struct S_FDD p2,  void (*cb)(int, int, struct S_FDD)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_FDP(int p0, int p1, struct S_FDP p2,  void (*cb)(int, int, struct S_FDP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_FPI(int p0, int p1, struct S_FPI p2,  void (*cb)(int, int, struct S_FPI)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_FPF(int p0, int p1, struct S_FPF p2,  void (*cb)(int, int, struct S_FPF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_FPD(int p0, int p1, struct S_FPD p2,  void (*cb)(int, int, struct S_FPD)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_FPP(int p0, int p1, struct S_FPP p2,  void (*cb)(int, int, struct S_FPP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_DII(int p0, int p1, struct S_DII p2,  void (*cb)(int, int, struct S_DII)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_DIF(int p0, int p1, struct S_DIF p2,  void (*cb)(int, int, struct S_DIF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_DID(int p0, int p1, struct S_DID p2,  void (*cb)(int, int, struct S_DID)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_DIP(int p0, int p1, struct S_DIP p2,  void (*cb)(int, int, struct S_DIP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_DFI(int p0, int p1, struct S_DFI p2,  void (*cb)(int, int, struct S_DFI)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_DFF(int p0, int p1, struct S_DFF p2,  void (*cb)(int, int, struct S_DFF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_DFD(int p0, int p1, struct S_DFD p2,  void (*cb)(int, int, struct S_DFD)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_DFP(int p0, int p1, struct S_DFP p2,  void (*cb)(int, int, struct S_DFP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_DDI(int p0, int p1, struct S_DDI p2,  void (*cb)(int, int, struct S_DDI)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_DDF(int p0, int p1, struct S_DDF p2,  void (*cb)(int, int, struct S_DDF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_DDD(int p0, int p1, struct S_DDD p2,  void (*cb)(int, int, struct S_DDD)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_DDP(int p0, int p1, struct S_DDP p2,  void (*cb)(int, int, struct S_DDP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_DPI(int p0, int p1, struct S_DPI p2,  void (*cb)(int, int, struct S_DPI)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_DPF(int p0, int p1, struct S_DPF p2,  void (*cb)(int, int, struct S_DPF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_DPD(int p0, int p1, struct S_DPD p2,  void (*cb)(int, int, struct S_DPD)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_DPP(int p0, int p1, struct S_DPP p2,  void (*cb)(int, int, struct S_DPP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_PII(int p0, int p1, struct S_PII p2,  void (*cb)(int, int, struct S_PII)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_PIF(int p0, int p1, struct S_PIF p2,  void (*cb)(int, int, struct S_PIF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_PID(int p0, int p1, struct S_PID p2,  void (*cb)(int, int, struct S_PID)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_PIP(int p0, int p1, struct S_PIP p2,  void (*cb)(int, int, struct S_PIP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_PFI(int p0, int p1, struct S_PFI p2,  void (*cb)(int, int, struct S_PFI)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_PFF(int p0, int p1, struct S_PFF p2,  void (*cb)(int, int, struct S_PFF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_PFD(int p0, int p1, struct S_PFD p2,  void (*cb)(int, int, struct S_PFD)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_PFP(int p0, int p1, struct S_PFP p2,  void (*cb)(int, int, struct S_PFP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_PDI(int p0, int p1, struct S_PDI p2,  void (*cb)(int, int, struct S_PDI)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_PDF(int p0, int p1, struct S_PDF p2,  void (*cb)(int, int, struct S_PDF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_PDD(int p0, int p1, struct S_PDD p2,  void (*cb)(int, int, struct S_PDD)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_PDP(int p0, int p1, struct S_PDP p2,  void (*cb)(int, int, struct S_PDP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_PPI(int p0, int p1, struct S_PPI p2,  void (*cb)(int, int, struct S_PPI)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_PPF(int p0, int p1, struct S_PPF p2,  void (*cb)(int, int, struct S_PPF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_PPD(int p0, int p1, struct S_PPD p2,  void (*cb)(int, int, struct S_PPD)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IIS_PPP(int p0, int p1, struct S_PPP p2,  void (*cb)(int, int, struct S_PPP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFI_(int p0, float p1, int p2,  void (*cb)(int, float, int)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFF_(int p0, float p1, float p2,  void (*cb)(int, float, float)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFD_(int p0, float p1, double p2,  void (*cb)(int, float, double)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFP_(int p0, float p1, void* p2,  void (*cb)(int, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_I(int p0, float p1, struct S_I p2,  void (*cb)(int, float, struct S_I)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_F(int p0, float p1, struct S_F p2,  void (*cb)(int, float, struct S_F)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_D(int p0, float p1, struct S_D p2,  void (*cb)(int, float, struct S_D)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_P(int p0, float p1, struct S_P p2,  void (*cb)(int, float, struct S_P)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_II(int p0, float p1, struct S_II p2,  void (*cb)(int, float, struct S_II)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_IF(int p0, float p1, struct S_IF p2,  void (*cb)(int, float, struct S_IF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_ID(int p0, float p1, struct S_ID p2,  void (*cb)(int, float, struct S_ID)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_IP(int p0, float p1, struct S_IP p2,  void (*cb)(int, float, struct S_IP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_FI(int p0, float p1, struct S_FI p2,  void (*cb)(int, float, struct S_FI)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_FF(int p0, float p1, struct S_FF p2,  void (*cb)(int, float, struct S_FF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_FD(int p0, float p1, struct S_FD p2,  void (*cb)(int, float, struct S_FD)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_FP(int p0, float p1, struct S_FP p2,  void (*cb)(int, float, struct S_FP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_DI(int p0, float p1, struct S_DI p2,  void (*cb)(int, float, struct S_DI)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_DF(int p0, float p1, struct S_DF p2,  void (*cb)(int, float, struct S_DF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_DD(int p0, float p1, struct S_DD p2,  void (*cb)(int, float, struct S_DD)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_DP(int p0, float p1, struct S_DP p2,  void (*cb)(int, float, struct S_DP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_PI(int p0, float p1, struct S_PI p2,  void (*cb)(int, float, struct S_PI)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_PF(int p0, float p1, struct S_PF p2,  void (*cb)(int, float, struct S_PF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_PD(int p0, float p1, struct S_PD p2,  void (*cb)(int, float, struct S_PD)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_PP(int p0, float p1, struct S_PP p2,  void (*cb)(int, float, struct S_PP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_III(int p0, float p1, struct S_III p2,  void (*cb)(int, float, struct S_III)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_IIF(int p0, float p1, struct S_IIF p2,  void (*cb)(int, float, struct S_IIF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_IID(int p0, float p1, struct S_IID p2,  void (*cb)(int, float, struct S_IID)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_IIP(int p0, float p1, struct S_IIP p2,  void (*cb)(int, float, struct S_IIP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_IFI(int p0, float p1, struct S_IFI p2,  void (*cb)(int, float, struct S_IFI)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_IFF(int p0, float p1, struct S_IFF p2,  void (*cb)(int, float, struct S_IFF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_IFD(int p0, float p1, struct S_IFD p2,  void (*cb)(int, float, struct S_IFD)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_IFP(int p0, float p1, struct S_IFP p2,  void (*cb)(int, float, struct S_IFP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_IDI(int p0, float p1, struct S_IDI p2,  void (*cb)(int, float, struct S_IDI)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_IDF(int p0, float p1, struct S_IDF p2,  void (*cb)(int, float, struct S_IDF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_IDD(int p0, float p1, struct S_IDD p2,  void (*cb)(int, float, struct S_IDD)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_IDP(int p0, float p1, struct S_IDP p2,  void (*cb)(int, float, struct S_IDP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_IPI(int p0, float p1, struct S_IPI p2,  void (*cb)(int, float, struct S_IPI)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_IPF(int p0, float p1, struct S_IPF p2,  void (*cb)(int, float, struct S_IPF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_IPD(int p0, float p1, struct S_IPD p2,  void (*cb)(int, float, struct S_IPD)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_IPP(int p0, float p1, struct S_IPP p2,  void (*cb)(int, float, struct S_IPP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_FII(int p0, float p1, struct S_FII p2,  void (*cb)(int, float, struct S_FII)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_FIF(int p0, float p1, struct S_FIF p2,  void (*cb)(int, float, struct S_FIF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_FID(int p0, float p1, struct S_FID p2,  void (*cb)(int, float, struct S_FID)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_FIP(int p0, float p1, struct S_FIP p2,  void (*cb)(int, float, struct S_FIP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_FFI(int p0, float p1, struct S_FFI p2,  void (*cb)(int, float, struct S_FFI)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_FFF(int p0, float p1, struct S_FFF p2,  void (*cb)(int, float, struct S_FFF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_FFD(int p0, float p1, struct S_FFD p2,  void (*cb)(int, float, struct S_FFD)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_FFP(int p0, float p1, struct S_FFP p2,  void (*cb)(int, float, struct S_FFP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_FDI(int p0, float p1, struct S_FDI p2,  void (*cb)(int, float, struct S_FDI)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_FDF(int p0, float p1, struct S_FDF p2,  void (*cb)(int, float, struct S_FDF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_FDD(int p0, float p1, struct S_FDD p2,  void (*cb)(int, float, struct S_FDD)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_FDP(int p0, float p1, struct S_FDP p2,  void (*cb)(int, float, struct S_FDP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_FPI(int p0, float p1, struct S_FPI p2,  void (*cb)(int, float, struct S_FPI)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_FPF(int p0, float p1, struct S_FPF p2,  void (*cb)(int, float, struct S_FPF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_FPD(int p0, float p1, struct S_FPD p2,  void (*cb)(int, float, struct S_FPD)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_FPP(int p0, float p1, struct S_FPP p2,  void (*cb)(int, float, struct S_FPP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_DII(int p0, float p1, struct S_DII p2,  void (*cb)(int, float, struct S_DII)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_DIF(int p0, float p1, struct S_DIF p2,  void (*cb)(int, float, struct S_DIF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_DID(int p0, float p1, struct S_DID p2,  void (*cb)(int, float, struct S_DID)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_DIP(int p0, float p1, struct S_DIP p2,  void (*cb)(int, float, struct S_DIP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_DFI(int p0, float p1, struct S_DFI p2,  void (*cb)(int, float, struct S_DFI)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_DFF(int p0, float p1, struct S_DFF p2,  void (*cb)(int, float, struct S_DFF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_DFD(int p0, float p1, struct S_DFD p2,  void (*cb)(int, float, struct S_DFD)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_DFP(int p0, float p1, struct S_DFP p2,  void (*cb)(int, float, struct S_DFP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_DDI(int p0, float p1, struct S_DDI p2,  void (*cb)(int, float, struct S_DDI)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_DDF(int p0, float p1, struct S_DDF p2,  void (*cb)(int, float, struct S_DDF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_DDD(int p0, float p1, struct S_DDD p2,  void (*cb)(int, float, struct S_DDD)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_DDP(int p0, float p1, struct S_DDP p2,  void (*cb)(int, float, struct S_DDP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_DPI(int p0, float p1, struct S_DPI p2,  void (*cb)(int, float, struct S_DPI)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_DPF(int p0, float p1, struct S_DPF p2,  void (*cb)(int, float, struct S_DPF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_DPD(int p0, float p1, struct S_DPD p2,  void (*cb)(int, float, struct S_DPD)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_DPP(int p0, float p1, struct S_DPP p2,  void (*cb)(int, float, struct S_DPP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_PII(int p0, float p1, struct S_PII p2,  void (*cb)(int, float, struct S_PII)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_PIF(int p0, float p1, struct S_PIF p2,  void (*cb)(int, float, struct S_PIF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_PID(int p0, float p1, struct S_PID p2,  void (*cb)(int, float, struct S_PID)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_PIP(int p0, float p1, struct S_PIP p2,  void (*cb)(int, float, struct S_PIP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_PFI(int p0, float p1, struct S_PFI p2,  void (*cb)(int, float, struct S_PFI)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_PFF(int p0, float p1, struct S_PFF p2,  void (*cb)(int, float, struct S_PFF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_PFD(int p0, float p1, struct S_PFD p2,  void (*cb)(int, float, struct S_PFD)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_PFP(int p0, float p1, struct S_PFP p2,  void (*cb)(int, float, struct S_PFP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_PDI(int p0, float p1, struct S_PDI p2,  void (*cb)(int, float, struct S_PDI)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_PDF(int p0, float p1, struct S_PDF p2,  void (*cb)(int, float, struct S_PDF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_PDD(int p0, float p1, struct S_PDD p2,  void (*cb)(int, float, struct S_PDD)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_PDP(int p0, float p1, struct S_PDP p2,  void (*cb)(int, float, struct S_PDP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_PPI(int p0, float p1, struct S_PPI p2,  void (*cb)(int, float, struct S_PPI)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_PPF(int p0, float p1, struct S_PPF p2,  void (*cb)(int, float, struct S_PPF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_PPD(int p0, float p1, struct S_PPD p2,  void (*cb)(int, float, struct S_PPD)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IFS_PPP(int p0, float p1, struct S_PPP p2,  void (*cb)(int, float, struct S_PPP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDI_(int p0, double p1, int p2,  void (*cb)(int, double, int)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDF_(int p0, double p1, float p2,  void (*cb)(int, double, float)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDD_(int p0, double p1, double p2,  void (*cb)(int, double, double)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDP_(int p0, double p1, void* p2,  void (*cb)(int, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_I(int p0, double p1, struct S_I p2,  void (*cb)(int, double, struct S_I)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_F(int p0, double p1, struct S_F p2,  void (*cb)(int, double, struct S_F)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_D(int p0, double p1, struct S_D p2,  void (*cb)(int, double, struct S_D)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_P(int p0, double p1, struct S_P p2,  void (*cb)(int, double, struct S_P)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_II(int p0, double p1, struct S_II p2,  void (*cb)(int, double, struct S_II)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_IF(int p0, double p1, struct S_IF p2,  void (*cb)(int, double, struct S_IF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_ID(int p0, double p1, struct S_ID p2,  void (*cb)(int, double, struct S_ID)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_IP(int p0, double p1, struct S_IP p2,  void (*cb)(int, double, struct S_IP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_FI(int p0, double p1, struct S_FI p2,  void (*cb)(int, double, struct S_FI)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_FF(int p0, double p1, struct S_FF p2,  void (*cb)(int, double, struct S_FF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_FD(int p0, double p1, struct S_FD p2,  void (*cb)(int, double, struct S_FD)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_FP(int p0, double p1, struct S_FP p2,  void (*cb)(int, double, struct S_FP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_DI(int p0, double p1, struct S_DI p2,  void (*cb)(int, double, struct S_DI)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_DF(int p0, double p1, struct S_DF p2,  void (*cb)(int, double, struct S_DF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_DD(int p0, double p1, struct S_DD p2,  void (*cb)(int, double, struct S_DD)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_DP(int p0, double p1, struct S_DP p2,  void (*cb)(int, double, struct S_DP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_PI(int p0, double p1, struct S_PI p2,  void (*cb)(int, double, struct S_PI)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_PF(int p0, double p1, struct S_PF p2,  void (*cb)(int, double, struct S_PF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_PD(int p0, double p1, struct S_PD p2,  void (*cb)(int, double, struct S_PD)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_PP(int p0, double p1, struct S_PP p2,  void (*cb)(int, double, struct S_PP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_III(int p0, double p1, struct S_III p2,  void (*cb)(int, double, struct S_III)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_IIF(int p0, double p1, struct S_IIF p2,  void (*cb)(int, double, struct S_IIF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_IID(int p0, double p1, struct S_IID p2,  void (*cb)(int, double, struct S_IID)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_IIP(int p0, double p1, struct S_IIP p2,  void (*cb)(int, double, struct S_IIP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_IFI(int p0, double p1, struct S_IFI p2,  void (*cb)(int, double, struct S_IFI)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_IFF(int p0, double p1, struct S_IFF p2,  void (*cb)(int, double, struct S_IFF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_IFD(int p0, double p1, struct S_IFD p2,  void (*cb)(int, double, struct S_IFD)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_IFP(int p0, double p1, struct S_IFP p2,  void (*cb)(int, double, struct S_IFP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_IDI(int p0, double p1, struct S_IDI p2,  void (*cb)(int, double, struct S_IDI)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_IDF(int p0, double p1, struct S_IDF p2,  void (*cb)(int, double, struct S_IDF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_IDD(int p0, double p1, struct S_IDD p2,  void (*cb)(int, double, struct S_IDD)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_IDP(int p0, double p1, struct S_IDP p2,  void (*cb)(int, double, struct S_IDP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_IPI(int p0, double p1, struct S_IPI p2,  void (*cb)(int, double, struct S_IPI)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_IPF(int p0, double p1, struct S_IPF p2,  void (*cb)(int, double, struct S_IPF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_IPD(int p0, double p1, struct S_IPD p2,  void (*cb)(int, double, struct S_IPD)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_IPP(int p0, double p1, struct S_IPP p2,  void (*cb)(int, double, struct S_IPP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_FII(int p0, double p1, struct S_FII p2,  void (*cb)(int, double, struct S_FII)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_FIF(int p0, double p1, struct S_FIF p2,  void (*cb)(int, double, struct S_FIF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_FID(int p0, double p1, struct S_FID p2,  void (*cb)(int, double, struct S_FID)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_FIP(int p0, double p1, struct S_FIP p2,  void (*cb)(int, double, struct S_FIP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_FFI(int p0, double p1, struct S_FFI p2,  void (*cb)(int, double, struct S_FFI)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_FFF(int p0, double p1, struct S_FFF p2,  void (*cb)(int, double, struct S_FFF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_FFD(int p0, double p1, struct S_FFD p2,  void (*cb)(int, double, struct S_FFD)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_FFP(int p0, double p1, struct S_FFP p2,  void (*cb)(int, double, struct S_FFP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_FDI(int p0, double p1, struct S_FDI p2,  void (*cb)(int, double, struct S_FDI)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_FDF(int p0, double p1, struct S_FDF p2,  void (*cb)(int, double, struct S_FDF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_FDD(int p0, double p1, struct S_FDD p2,  void (*cb)(int, double, struct S_FDD)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_FDP(int p0, double p1, struct S_FDP p2,  void (*cb)(int, double, struct S_FDP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_FPI(int p0, double p1, struct S_FPI p2,  void (*cb)(int, double, struct S_FPI)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_FPF(int p0, double p1, struct S_FPF p2,  void (*cb)(int, double, struct S_FPF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_FPD(int p0, double p1, struct S_FPD p2,  void (*cb)(int, double, struct S_FPD)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_FPP(int p0, double p1, struct S_FPP p2,  void (*cb)(int, double, struct S_FPP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_DII(int p0, double p1, struct S_DII p2,  void (*cb)(int, double, struct S_DII)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_DIF(int p0, double p1, struct S_DIF p2,  void (*cb)(int, double, struct S_DIF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_DID(int p0, double p1, struct S_DID p2,  void (*cb)(int, double, struct S_DID)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_DIP(int p0, double p1, struct S_DIP p2,  void (*cb)(int, double, struct S_DIP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_DFI(int p0, double p1, struct S_DFI p2,  void (*cb)(int, double, struct S_DFI)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_DFF(int p0, double p1, struct S_DFF p2,  void (*cb)(int, double, struct S_DFF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_DFD(int p0, double p1, struct S_DFD p2,  void (*cb)(int, double, struct S_DFD)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_DFP(int p0, double p1, struct S_DFP p2,  void (*cb)(int, double, struct S_DFP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_DDI(int p0, double p1, struct S_DDI p2,  void (*cb)(int, double, struct S_DDI)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_DDF(int p0, double p1, struct S_DDF p2,  void (*cb)(int, double, struct S_DDF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_DDD(int p0, double p1, struct S_DDD p2,  void (*cb)(int, double, struct S_DDD)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_DDP(int p0, double p1, struct S_DDP p2,  void (*cb)(int, double, struct S_DDP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_DPI(int p0, double p1, struct S_DPI p2,  void (*cb)(int, double, struct S_DPI)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_DPF(int p0, double p1, struct S_DPF p2,  void (*cb)(int, double, struct S_DPF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_DPD(int p0, double p1, struct S_DPD p2,  void (*cb)(int, double, struct S_DPD)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_DPP(int p0, double p1, struct S_DPP p2,  void (*cb)(int, double, struct S_DPP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_PII(int p0, double p1, struct S_PII p2,  void (*cb)(int, double, struct S_PII)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_PIF(int p0, double p1, struct S_PIF p2,  void (*cb)(int, double, struct S_PIF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_PID(int p0, double p1, struct S_PID p2,  void (*cb)(int, double, struct S_PID)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_PIP(int p0, double p1, struct S_PIP p2,  void (*cb)(int, double, struct S_PIP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_PFI(int p0, double p1, struct S_PFI p2,  void (*cb)(int, double, struct S_PFI)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_PFF(int p0, double p1, struct S_PFF p2,  void (*cb)(int, double, struct S_PFF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_PFD(int p0, double p1, struct S_PFD p2,  void (*cb)(int, double, struct S_PFD)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_PFP(int p0, double p1, struct S_PFP p2,  void (*cb)(int, double, struct S_PFP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_PDI(int p0, double p1, struct S_PDI p2,  void (*cb)(int, double, struct S_PDI)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_PDF(int p0, double p1, struct S_PDF p2,  void (*cb)(int, double, struct S_PDF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_PDD(int p0, double p1, struct S_PDD p2,  void (*cb)(int, double, struct S_PDD)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_PDP(int p0, double p1, struct S_PDP p2,  void (*cb)(int, double, struct S_PDP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_PPI(int p0, double p1, struct S_PPI p2,  void (*cb)(int, double, struct S_PPI)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_PPF(int p0, double p1, struct S_PPF p2,  void (*cb)(int, double, struct S_PPF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_PPD(int p0, double p1, struct S_PPD p2,  void (*cb)(int, double, struct S_PPD)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IDS_PPP(int p0, double p1, struct S_PPP p2,  void (*cb)(int, double, struct S_PPP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPI_(int p0, void* p1, int p2,  void (*cb)(int, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPF_(int p0, void* p1, float p2,  void (*cb)(int, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPD_(int p0, void* p1, double p2,  void (*cb)(int, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPP_(int p0, void* p1, void* p2,  void (*cb)(int, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_I(int p0, void* p1, struct S_I p2,  void (*cb)(int, void*, struct S_I)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_F(int p0, void* p1, struct S_F p2,  void (*cb)(int, void*, struct S_F)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_D(int p0, void* p1, struct S_D p2,  void (*cb)(int, void*, struct S_D)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_P(int p0, void* p1, struct S_P p2,  void (*cb)(int, void*, struct S_P)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_II(int p0, void* p1, struct S_II p2,  void (*cb)(int, void*, struct S_II)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_IF(int p0, void* p1, struct S_IF p2,  void (*cb)(int, void*, struct S_IF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_ID(int p0, void* p1, struct S_ID p2,  void (*cb)(int, void*, struct S_ID)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_IP(int p0, void* p1, struct S_IP p2,  void (*cb)(int, void*, struct S_IP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_FI(int p0, void* p1, struct S_FI p2,  void (*cb)(int, void*, struct S_FI)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_FF(int p0, void* p1, struct S_FF p2,  void (*cb)(int, void*, struct S_FF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_FD(int p0, void* p1, struct S_FD p2,  void (*cb)(int, void*, struct S_FD)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_FP(int p0, void* p1, struct S_FP p2,  void (*cb)(int, void*, struct S_FP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_DI(int p0, void* p1, struct S_DI p2,  void (*cb)(int, void*, struct S_DI)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_DF(int p0, void* p1, struct S_DF p2,  void (*cb)(int, void*, struct S_DF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_DD(int p0, void* p1, struct S_DD p2,  void (*cb)(int, void*, struct S_DD)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_DP(int p0, void* p1, struct S_DP p2,  void (*cb)(int, void*, struct S_DP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_PI(int p0, void* p1, struct S_PI p2,  void (*cb)(int, void*, struct S_PI)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_PF(int p0, void* p1, struct S_PF p2,  void (*cb)(int, void*, struct S_PF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_PD(int p0, void* p1, struct S_PD p2,  void (*cb)(int, void*, struct S_PD)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_PP(int p0, void* p1, struct S_PP p2,  void (*cb)(int, void*, struct S_PP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_III(int p0, void* p1, struct S_III p2,  void (*cb)(int, void*, struct S_III)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_IIF(int p0, void* p1, struct S_IIF p2,  void (*cb)(int, void*, struct S_IIF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_IID(int p0, void* p1, struct S_IID p2,  void (*cb)(int, void*, struct S_IID)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_IIP(int p0, void* p1, struct S_IIP p2,  void (*cb)(int, void*, struct S_IIP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_IFI(int p0, void* p1, struct S_IFI p2,  void (*cb)(int, void*, struct S_IFI)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_IFF(int p0, void* p1, struct S_IFF p2,  void (*cb)(int, void*, struct S_IFF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_IFD(int p0, void* p1, struct S_IFD p2,  void (*cb)(int, void*, struct S_IFD)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_IFP(int p0, void* p1, struct S_IFP p2,  void (*cb)(int, void*, struct S_IFP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_IDI(int p0, void* p1, struct S_IDI p2,  void (*cb)(int, void*, struct S_IDI)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_IDF(int p0, void* p1, struct S_IDF p2,  void (*cb)(int, void*, struct S_IDF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_IDD(int p0, void* p1, struct S_IDD p2,  void (*cb)(int, void*, struct S_IDD)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_IDP(int p0, void* p1, struct S_IDP p2,  void (*cb)(int, void*, struct S_IDP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_IPI(int p0, void* p1, struct S_IPI p2,  void (*cb)(int, void*, struct S_IPI)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_IPF(int p0, void* p1, struct S_IPF p2,  void (*cb)(int, void*, struct S_IPF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_IPD(int p0, void* p1, struct S_IPD p2,  void (*cb)(int, void*, struct S_IPD)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_IPP(int p0, void* p1, struct S_IPP p2,  void (*cb)(int, void*, struct S_IPP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_FII(int p0, void* p1, struct S_FII p2,  void (*cb)(int, void*, struct S_FII)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_FIF(int p0, void* p1, struct S_FIF p2,  void (*cb)(int, void*, struct S_FIF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_FID(int p0, void* p1, struct S_FID p2,  void (*cb)(int, void*, struct S_FID)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_FIP(int p0, void* p1, struct S_FIP p2,  void (*cb)(int, void*, struct S_FIP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_FFI(int p0, void* p1, struct S_FFI p2,  void (*cb)(int, void*, struct S_FFI)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_FFF(int p0, void* p1, struct S_FFF p2,  void (*cb)(int, void*, struct S_FFF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_FFD(int p0, void* p1, struct S_FFD p2,  void (*cb)(int, void*, struct S_FFD)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_FFP(int p0, void* p1, struct S_FFP p2,  void (*cb)(int, void*, struct S_FFP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_FDI(int p0, void* p1, struct S_FDI p2,  void (*cb)(int, void*, struct S_FDI)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_FDF(int p0, void* p1, struct S_FDF p2,  void (*cb)(int, void*, struct S_FDF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_FDD(int p0, void* p1, struct S_FDD p2,  void (*cb)(int, void*, struct S_FDD)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_FDP(int p0, void* p1, struct S_FDP p2,  void (*cb)(int, void*, struct S_FDP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_FPI(int p0, void* p1, struct S_FPI p2,  void (*cb)(int, void*, struct S_FPI)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_FPF(int p0, void* p1, struct S_FPF p2,  void (*cb)(int, void*, struct S_FPF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_FPD(int p0, void* p1, struct S_FPD p2,  void (*cb)(int, void*, struct S_FPD)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_FPP(int p0, void* p1, struct S_FPP p2,  void (*cb)(int, void*, struct S_FPP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_DII(int p0, void* p1, struct S_DII p2,  void (*cb)(int, void*, struct S_DII)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_DIF(int p0, void* p1, struct S_DIF p2,  void (*cb)(int, void*, struct S_DIF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_DID(int p0, void* p1, struct S_DID p2,  void (*cb)(int, void*, struct S_DID)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_DIP(int p0, void* p1, struct S_DIP p2,  void (*cb)(int, void*, struct S_DIP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_DFI(int p0, void* p1, struct S_DFI p2,  void (*cb)(int, void*, struct S_DFI)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_DFF(int p0, void* p1, struct S_DFF p2,  void (*cb)(int, void*, struct S_DFF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_DFD(int p0, void* p1, struct S_DFD p2,  void (*cb)(int, void*, struct S_DFD)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_DFP(int p0, void* p1, struct S_DFP p2,  void (*cb)(int, void*, struct S_DFP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_DDI(int p0, void* p1, struct S_DDI p2,  void (*cb)(int, void*, struct S_DDI)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_DDF(int p0, void* p1, struct S_DDF p2,  void (*cb)(int, void*, struct S_DDF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_DDD(int p0, void* p1, struct S_DDD p2,  void (*cb)(int, void*, struct S_DDD)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_DDP(int p0, void* p1, struct S_DDP p2,  void (*cb)(int, void*, struct S_DDP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_DPI(int p0, void* p1, struct S_DPI p2,  void (*cb)(int, void*, struct S_DPI)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_DPF(int p0, void* p1, struct S_DPF p2,  void (*cb)(int, void*, struct S_DPF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_DPD(int p0, void* p1, struct S_DPD p2,  void (*cb)(int, void*, struct S_DPD)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_DPP(int p0, void* p1, struct S_DPP p2,  void (*cb)(int, void*, struct S_DPP)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_PII(int p0, void* p1, struct S_PII p2,  void (*cb)(int, void*, struct S_PII)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_PIF(int p0, void* p1, struct S_PIF p2,  void (*cb)(int, void*, struct S_PIF)) { cb(p0,p1,p2); }
+EXPORT void f1_V_IPS_PID(int p0, void* p1, struct S_PID p2,  void (*cb)(int, void*, struct S_PID)) { cb(p0,p1,p2); }
+EXPORT void f2_V_IPS_PIP(int p0, void* p1, struct S_PIP p2,  void (*cb)(int, void*, struct S_PIP)) { cb(p0,p1,p2); }
+EXPORT void f2_V_IPS_PFI(int p0, void* p1, struct S_PFI p2,  void (*cb)(int, void*, struct S_PFI)) { cb(p0,p1,p2); }
+EXPORT void f2_V_IPS_PFF(int p0, void* p1, struct S_PFF p2,  void (*cb)(int, void*, struct S_PFF)) { cb(p0,p1,p2); }
+EXPORT void f2_V_IPS_PFD(int p0, void* p1, struct S_PFD p2,  void (*cb)(int, void*, struct S_PFD)) { cb(p0,p1,p2); }
+EXPORT void f2_V_IPS_PFP(int p0, void* p1, struct S_PFP p2,  void (*cb)(int, void*, struct S_PFP)) { cb(p0,p1,p2); }
+EXPORT void f2_V_IPS_PDI(int p0, void* p1, struct S_PDI p2,  void (*cb)(int, void*, struct S_PDI)) { cb(p0,p1,p2); }
+EXPORT void f2_V_IPS_PDF(int p0, void* p1, struct S_PDF p2,  void (*cb)(int, void*, struct S_PDF)) { cb(p0,p1,p2); }
+EXPORT void f2_V_IPS_PDD(int p0, void* p1, struct S_PDD p2,  void (*cb)(int, void*, struct S_PDD)) { cb(p0,p1,p2); }
+EXPORT void f2_V_IPS_PDP(int p0, void* p1, struct S_PDP p2,  void (*cb)(int, void*, struct S_PDP)) { cb(p0,p1,p2); }
+EXPORT void f2_V_IPS_PPI(int p0, void* p1, struct S_PPI p2,  void (*cb)(int, void*, struct S_PPI)) { cb(p0,p1,p2); }
+EXPORT void f2_V_IPS_PPF(int p0, void* p1, struct S_PPF p2,  void (*cb)(int, void*, struct S_PPF)) { cb(p0,p1,p2); }
+EXPORT void f2_V_IPS_PPD(int p0, void* p1, struct S_PPD p2,  void (*cb)(int, void*, struct S_PPD)) { cb(p0,p1,p2); }
+EXPORT void f2_V_IPS_PPP(int p0, void* p1, struct S_PPP p2,  void (*cb)(int, void*, struct S_PPP)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_I(int p0, struct S_I p1, int p2,  void (*cb)(int, struct S_I, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_F(int p0, struct S_F p1, int p2,  void (*cb)(int, struct S_F, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_D(int p0, struct S_D p1, int p2,  void (*cb)(int, struct S_D, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_P(int p0, struct S_P p1, int p2,  void (*cb)(int, struct S_P, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_II(int p0, struct S_II p1, int p2,  void (*cb)(int, struct S_II, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_IF(int p0, struct S_IF p1, int p2,  void (*cb)(int, struct S_IF, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_ID(int p0, struct S_ID p1, int p2,  void (*cb)(int, struct S_ID, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_IP(int p0, struct S_IP p1, int p2,  void (*cb)(int, struct S_IP, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_FI(int p0, struct S_FI p1, int p2,  void (*cb)(int, struct S_FI, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_FF(int p0, struct S_FF p1, int p2,  void (*cb)(int, struct S_FF, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_FD(int p0, struct S_FD p1, int p2,  void (*cb)(int, struct S_FD, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_FP(int p0, struct S_FP p1, int p2,  void (*cb)(int, struct S_FP, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_DI(int p0, struct S_DI p1, int p2,  void (*cb)(int, struct S_DI, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_DF(int p0, struct S_DF p1, int p2,  void (*cb)(int, struct S_DF, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_DD(int p0, struct S_DD p1, int p2,  void (*cb)(int, struct S_DD, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_DP(int p0, struct S_DP p1, int p2,  void (*cb)(int, struct S_DP, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_PI(int p0, struct S_PI p1, int p2,  void (*cb)(int, struct S_PI, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_PF(int p0, struct S_PF p1, int p2,  void (*cb)(int, struct S_PF, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_PD(int p0, struct S_PD p1, int p2,  void (*cb)(int, struct S_PD, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_PP(int p0, struct S_PP p1, int p2,  void (*cb)(int, struct S_PP, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_III(int p0, struct S_III p1, int p2,  void (*cb)(int, struct S_III, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_IIF(int p0, struct S_IIF p1, int p2,  void (*cb)(int, struct S_IIF, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_IID(int p0, struct S_IID p1, int p2,  void (*cb)(int, struct S_IID, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_IIP(int p0, struct S_IIP p1, int p2,  void (*cb)(int, struct S_IIP, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_IFI(int p0, struct S_IFI p1, int p2,  void (*cb)(int, struct S_IFI, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_IFF(int p0, struct S_IFF p1, int p2,  void (*cb)(int, struct S_IFF, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_IFD(int p0, struct S_IFD p1, int p2,  void (*cb)(int, struct S_IFD, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_IFP(int p0, struct S_IFP p1, int p2,  void (*cb)(int, struct S_IFP, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_IDI(int p0, struct S_IDI p1, int p2,  void (*cb)(int, struct S_IDI, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_IDF(int p0, struct S_IDF p1, int p2,  void (*cb)(int, struct S_IDF, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_IDD(int p0, struct S_IDD p1, int p2,  void (*cb)(int, struct S_IDD, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_IDP(int p0, struct S_IDP p1, int p2,  void (*cb)(int, struct S_IDP, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_IPI(int p0, struct S_IPI p1, int p2,  void (*cb)(int, struct S_IPI, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_IPF(int p0, struct S_IPF p1, int p2,  void (*cb)(int, struct S_IPF, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_IPD(int p0, struct S_IPD p1, int p2,  void (*cb)(int, struct S_IPD, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_IPP(int p0, struct S_IPP p1, int p2,  void (*cb)(int, struct S_IPP, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_FII(int p0, struct S_FII p1, int p2,  void (*cb)(int, struct S_FII, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_FIF(int p0, struct S_FIF p1, int p2,  void (*cb)(int, struct S_FIF, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_FID(int p0, struct S_FID p1, int p2,  void (*cb)(int, struct S_FID, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_FIP(int p0, struct S_FIP p1, int p2,  void (*cb)(int, struct S_FIP, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_FFI(int p0, struct S_FFI p1, int p2,  void (*cb)(int, struct S_FFI, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_FFF(int p0, struct S_FFF p1, int p2,  void (*cb)(int, struct S_FFF, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_FFD(int p0, struct S_FFD p1, int p2,  void (*cb)(int, struct S_FFD, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_FFP(int p0, struct S_FFP p1, int p2,  void (*cb)(int, struct S_FFP, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_FDI(int p0, struct S_FDI p1, int p2,  void (*cb)(int, struct S_FDI, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_FDF(int p0, struct S_FDF p1, int p2,  void (*cb)(int, struct S_FDF, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_FDD(int p0, struct S_FDD p1, int p2,  void (*cb)(int, struct S_FDD, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_FDP(int p0, struct S_FDP p1, int p2,  void (*cb)(int, struct S_FDP, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_FPI(int p0, struct S_FPI p1, int p2,  void (*cb)(int, struct S_FPI, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_FPF(int p0, struct S_FPF p1, int p2,  void (*cb)(int, struct S_FPF, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_FPD(int p0, struct S_FPD p1, int p2,  void (*cb)(int, struct S_FPD, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_FPP(int p0, struct S_FPP p1, int p2,  void (*cb)(int, struct S_FPP, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_DII(int p0, struct S_DII p1, int p2,  void (*cb)(int, struct S_DII, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_DIF(int p0, struct S_DIF p1, int p2,  void (*cb)(int, struct S_DIF, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_DID(int p0, struct S_DID p1, int p2,  void (*cb)(int, struct S_DID, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_DIP(int p0, struct S_DIP p1, int p2,  void (*cb)(int, struct S_DIP, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_DFI(int p0, struct S_DFI p1, int p2,  void (*cb)(int, struct S_DFI, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_DFF(int p0, struct S_DFF p1, int p2,  void (*cb)(int, struct S_DFF, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_DFD(int p0, struct S_DFD p1, int p2,  void (*cb)(int, struct S_DFD, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_DFP(int p0, struct S_DFP p1, int p2,  void (*cb)(int, struct S_DFP, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_DDI(int p0, struct S_DDI p1, int p2,  void (*cb)(int, struct S_DDI, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_DDF(int p0, struct S_DDF p1, int p2,  void (*cb)(int, struct S_DDF, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_DDD(int p0, struct S_DDD p1, int p2,  void (*cb)(int, struct S_DDD, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_DDP(int p0, struct S_DDP p1, int p2,  void (*cb)(int, struct S_DDP, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_DPI(int p0, struct S_DPI p1, int p2,  void (*cb)(int, struct S_DPI, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_DPF(int p0, struct S_DPF p1, int p2,  void (*cb)(int, struct S_DPF, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_DPD(int p0, struct S_DPD p1, int p2,  void (*cb)(int, struct S_DPD, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_DPP(int p0, struct S_DPP p1, int p2,  void (*cb)(int, struct S_DPP, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_PII(int p0, struct S_PII p1, int p2,  void (*cb)(int, struct S_PII, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_PIF(int p0, struct S_PIF p1, int p2,  void (*cb)(int, struct S_PIF, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_PID(int p0, struct S_PID p1, int p2,  void (*cb)(int, struct S_PID, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_PIP(int p0, struct S_PIP p1, int p2,  void (*cb)(int, struct S_PIP, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_PFI(int p0, struct S_PFI p1, int p2,  void (*cb)(int, struct S_PFI, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_PFF(int p0, struct S_PFF p1, int p2,  void (*cb)(int, struct S_PFF, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_PFD(int p0, struct S_PFD p1, int p2,  void (*cb)(int, struct S_PFD, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_PFP(int p0, struct S_PFP p1, int p2,  void (*cb)(int, struct S_PFP, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_PDI(int p0, struct S_PDI p1, int p2,  void (*cb)(int, struct S_PDI, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_PDF(int p0, struct S_PDF p1, int p2,  void (*cb)(int, struct S_PDF, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_PDD(int p0, struct S_PDD p1, int p2,  void (*cb)(int, struct S_PDD, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_PDP(int p0, struct S_PDP p1, int p2,  void (*cb)(int, struct S_PDP, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_PPI(int p0, struct S_PPI p1, int p2,  void (*cb)(int, struct S_PPI, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_PPF(int p0, struct S_PPF p1, int p2,  void (*cb)(int, struct S_PPF, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_PPD(int p0, struct S_PPD p1, int p2,  void (*cb)(int, struct S_PPD, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISI_PPP(int p0, struct S_PPP p1, int p2,  void (*cb)(int, struct S_PPP, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_I(int p0, struct S_I p1, float p2,  void (*cb)(int, struct S_I, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_F(int p0, struct S_F p1, float p2,  void (*cb)(int, struct S_F, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_D(int p0, struct S_D p1, float p2,  void (*cb)(int, struct S_D, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_P(int p0, struct S_P p1, float p2,  void (*cb)(int, struct S_P, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_II(int p0, struct S_II p1, float p2,  void (*cb)(int, struct S_II, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_IF(int p0, struct S_IF p1, float p2,  void (*cb)(int, struct S_IF, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_ID(int p0, struct S_ID p1, float p2,  void (*cb)(int, struct S_ID, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_IP(int p0, struct S_IP p1, float p2,  void (*cb)(int, struct S_IP, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_FI(int p0, struct S_FI p1, float p2,  void (*cb)(int, struct S_FI, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_FF(int p0, struct S_FF p1, float p2,  void (*cb)(int, struct S_FF, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_FD(int p0, struct S_FD p1, float p2,  void (*cb)(int, struct S_FD, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_FP(int p0, struct S_FP p1, float p2,  void (*cb)(int, struct S_FP, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_DI(int p0, struct S_DI p1, float p2,  void (*cb)(int, struct S_DI, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_DF(int p0, struct S_DF p1, float p2,  void (*cb)(int, struct S_DF, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_DD(int p0, struct S_DD p1, float p2,  void (*cb)(int, struct S_DD, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_DP(int p0, struct S_DP p1, float p2,  void (*cb)(int, struct S_DP, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_PI(int p0, struct S_PI p1, float p2,  void (*cb)(int, struct S_PI, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_PF(int p0, struct S_PF p1, float p2,  void (*cb)(int, struct S_PF, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_PD(int p0, struct S_PD p1, float p2,  void (*cb)(int, struct S_PD, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_PP(int p0, struct S_PP p1, float p2,  void (*cb)(int, struct S_PP, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_III(int p0, struct S_III p1, float p2,  void (*cb)(int, struct S_III, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_IIF(int p0, struct S_IIF p1, float p2,  void (*cb)(int, struct S_IIF, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_IID(int p0, struct S_IID p1, float p2,  void (*cb)(int, struct S_IID, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_IIP(int p0, struct S_IIP p1, float p2,  void (*cb)(int, struct S_IIP, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_IFI(int p0, struct S_IFI p1, float p2,  void (*cb)(int, struct S_IFI, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_IFF(int p0, struct S_IFF p1, float p2,  void (*cb)(int, struct S_IFF, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_IFD(int p0, struct S_IFD p1, float p2,  void (*cb)(int, struct S_IFD, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_IFP(int p0, struct S_IFP p1, float p2,  void (*cb)(int, struct S_IFP, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_IDI(int p0, struct S_IDI p1, float p2,  void (*cb)(int, struct S_IDI, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_IDF(int p0, struct S_IDF p1, float p2,  void (*cb)(int, struct S_IDF, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_IDD(int p0, struct S_IDD p1, float p2,  void (*cb)(int, struct S_IDD, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_IDP(int p0, struct S_IDP p1, float p2,  void (*cb)(int, struct S_IDP, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_IPI(int p0, struct S_IPI p1, float p2,  void (*cb)(int, struct S_IPI, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_IPF(int p0, struct S_IPF p1, float p2,  void (*cb)(int, struct S_IPF, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_IPD(int p0, struct S_IPD p1, float p2,  void (*cb)(int, struct S_IPD, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_IPP(int p0, struct S_IPP p1, float p2,  void (*cb)(int, struct S_IPP, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_FII(int p0, struct S_FII p1, float p2,  void (*cb)(int, struct S_FII, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_FIF(int p0, struct S_FIF p1, float p2,  void (*cb)(int, struct S_FIF, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_FID(int p0, struct S_FID p1, float p2,  void (*cb)(int, struct S_FID, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_FIP(int p0, struct S_FIP p1, float p2,  void (*cb)(int, struct S_FIP, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_FFI(int p0, struct S_FFI p1, float p2,  void (*cb)(int, struct S_FFI, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_FFF(int p0, struct S_FFF p1, float p2,  void (*cb)(int, struct S_FFF, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_FFD(int p0, struct S_FFD p1, float p2,  void (*cb)(int, struct S_FFD, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_FFP(int p0, struct S_FFP p1, float p2,  void (*cb)(int, struct S_FFP, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_FDI(int p0, struct S_FDI p1, float p2,  void (*cb)(int, struct S_FDI, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_FDF(int p0, struct S_FDF p1, float p2,  void (*cb)(int, struct S_FDF, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_FDD(int p0, struct S_FDD p1, float p2,  void (*cb)(int, struct S_FDD, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_FDP(int p0, struct S_FDP p1, float p2,  void (*cb)(int, struct S_FDP, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_FPI(int p0, struct S_FPI p1, float p2,  void (*cb)(int, struct S_FPI, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_FPF(int p0, struct S_FPF p1, float p2,  void (*cb)(int, struct S_FPF, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_FPD(int p0, struct S_FPD p1, float p2,  void (*cb)(int, struct S_FPD, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_FPP(int p0, struct S_FPP p1, float p2,  void (*cb)(int, struct S_FPP, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_DII(int p0, struct S_DII p1, float p2,  void (*cb)(int, struct S_DII, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_DIF(int p0, struct S_DIF p1, float p2,  void (*cb)(int, struct S_DIF, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_DID(int p0, struct S_DID p1, float p2,  void (*cb)(int, struct S_DID, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_DIP(int p0, struct S_DIP p1, float p2,  void (*cb)(int, struct S_DIP, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_DFI(int p0, struct S_DFI p1, float p2,  void (*cb)(int, struct S_DFI, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_DFF(int p0, struct S_DFF p1, float p2,  void (*cb)(int, struct S_DFF, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_DFD(int p0, struct S_DFD p1, float p2,  void (*cb)(int, struct S_DFD, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_DFP(int p0, struct S_DFP p1, float p2,  void (*cb)(int, struct S_DFP, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_DDI(int p0, struct S_DDI p1, float p2,  void (*cb)(int, struct S_DDI, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_DDF(int p0, struct S_DDF p1, float p2,  void (*cb)(int, struct S_DDF, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_DDD(int p0, struct S_DDD p1, float p2,  void (*cb)(int, struct S_DDD, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_DDP(int p0, struct S_DDP p1, float p2,  void (*cb)(int, struct S_DDP, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_DPI(int p0, struct S_DPI p1, float p2,  void (*cb)(int, struct S_DPI, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_DPF(int p0, struct S_DPF p1, float p2,  void (*cb)(int, struct S_DPF, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_DPD(int p0, struct S_DPD p1, float p2,  void (*cb)(int, struct S_DPD, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_DPP(int p0, struct S_DPP p1, float p2,  void (*cb)(int, struct S_DPP, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_PII(int p0, struct S_PII p1, float p2,  void (*cb)(int, struct S_PII, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_PIF(int p0, struct S_PIF p1, float p2,  void (*cb)(int, struct S_PIF, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_PID(int p0, struct S_PID p1, float p2,  void (*cb)(int, struct S_PID, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_PIP(int p0, struct S_PIP p1, float p2,  void (*cb)(int, struct S_PIP, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_PFI(int p0, struct S_PFI p1, float p2,  void (*cb)(int, struct S_PFI, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_PFF(int p0, struct S_PFF p1, float p2,  void (*cb)(int, struct S_PFF, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_PFD(int p0, struct S_PFD p1, float p2,  void (*cb)(int, struct S_PFD, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_PFP(int p0, struct S_PFP p1, float p2,  void (*cb)(int, struct S_PFP, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_PDI(int p0, struct S_PDI p1, float p2,  void (*cb)(int, struct S_PDI, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_PDF(int p0, struct S_PDF p1, float p2,  void (*cb)(int, struct S_PDF, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_PDD(int p0, struct S_PDD p1, float p2,  void (*cb)(int, struct S_PDD, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_PDP(int p0, struct S_PDP p1, float p2,  void (*cb)(int, struct S_PDP, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_PPI(int p0, struct S_PPI p1, float p2,  void (*cb)(int, struct S_PPI, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_PPF(int p0, struct S_PPF p1, float p2,  void (*cb)(int, struct S_PPF, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_PPD(int p0, struct S_PPD p1, float p2,  void (*cb)(int, struct S_PPD, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISF_PPP(int p0, struct S_PPP p1, float p2,  void (*cb)(int, struct S_PPP, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_I(int p0, struct S_I p1, double p2,  void (*cb)(int, struct S_I, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_F(int p0, struct S_F p1, double p2,  void (*cb)(int, struct S_F, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_D(int p0, struct S_D p1, double p2,  void (*cb)(int, struct S_D, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_P(int p0, struct S_P p1, double p2,  void (*cb)(int, struct S_P, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_II(int p0, struct S_II p1, double p2,  void (*cb)(int, struct S_II, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_IF(int p0, struct S_IF p1, double p2,  void (*cb)(int, struct S_IF, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_ID(int p0, struct S_ID p1, double p2,  void (*cb)(int, struct S_ID, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_IP(int p0, struct S_IP p1, double p2,  void (*cb)(int, struct S_IP, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_FI(int p0, struct S_FI p1, double p2,  void (*cb)(int, struct S_FI, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_FF(int p0, struct S_FF p1, double p2,  void (*cb)(int, struct S_FF, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_FD(int p0, struct S_FD p1, double p2,  void (*cb)(int, struct S_FD, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_FP(int p0, struct S_FP p1, double p2,  void (*cb)(int, struct S_FP, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_DI(int p0, struct S_DI p1, double p2,  void (*cb)(int, struct S_DI, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_DF(int p0, struct S_DF p1, double p2,  void (*cb)(int, struct S_DF, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_DD(int p0, struct S_DD p1, double p2,  void (*cb)(int, struct S_DD, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_DP(int p0, struct S_DP p1, double p2,  void (*cb)(int, struct S_DP, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_PI(int p0, struct S_PI p1, double p2,  void (*cb)(int, struct S_PI, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_PF(int p0, struct S_PF p1, double p2,  void (*cb)(int, struct S_PF, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_PD(int p0, struct S_PD p1, double p2,  void (*cb)(int, struct S_PD, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_PP(int p0, struct S_PP p1, double p2,  void (*cb)(int, struct S_PP, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_III(int p0, struct S_III p1, double p2,  void (*cb)(int, struct S_III, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_IIF(int p0, struct S_IIF p1, double p2,  void (*cb)(int, struct S_IIF, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_IID(int p0, struct S_IID p1, double p2,  void (*cb)(int, struct S_IID, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_IIP(int p0, struct S_IIP p1, double p2,  void (*cb)(int, struct S_IIP, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_IFI(int p0, struct S_IFI p1, double p2,  void (*cb)(int, struct S_IFI, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_IFF(int p0, struct S_IFF p1, double p2,  void (*cb)(int, struct S_IFF, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_IFD(int p0, struct S_IFD p1, double p2,  void (*cb)(int, struct S_IFD, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_IFP(int p0, struct S_IFP p1, double p2,  void (*cb)(int, struct S_IFP, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_IDI(int p0, struct S_IDI p1, double p2,  void (*cb)(int, struct S_IDI, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_IDF(int p0, struct S_IDF p1, double p2,  void (*cb)(int, struct S_IDF, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_IDD(int p0, struct S_IDD p1, double p2,  void (*cb)(int, struct S_IDD, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_IDP(int p0, struct S_IDP p1, double p2,  void (*cb)(int, struct S_IDP, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_IPI(int p0, struct S_IPI p1, double p2,  void (*cb)(int, struct S_IPI, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_IPF(int p0, struct S_IPF p1, double p2,  void (*cb)(int, struct S_IPF, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_IPD(int p0, struct S_IPD p1, double p2,  void (*cb)(int, struct S_IPD, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_IPP(int p0, struct S_IPP p1, double p2,  void (*cb)(int, struct S_IPP, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_FII(int p0, struct S_FII p1, double p2,  void (*cb)(int, struct S_FII, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_FIF(int p0, struct S_FIF p1, double p2,  void (*cb)(int, struct S_FIF, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_FID(int p0, struct S_FID p1, double p2,  void (*cb)(int, struct S_FID, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_FIP(int p0, struct S_FIP p1, double p2,  void (*cb)(int, struct S_FIP, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_FFI(int p0, struct S_FFI p1, double p2,  void (*cb)(int, struct S_FFI, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_FFF(int p0, struct S_FFF p1, double p2,  void (*cb)(int, struct S_FFF, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_FFD(int p0, struct S_FFD p1, double p2,  void (*cb)(int, struct S_FFD, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_FFP(int p0, struct S_FFP p1, double p2,  void (*cb)(int, struct S_FFP, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_FDI(int p0, struct S_FDI p1, double p2,  void (*cb)(int, struct S_FDI, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_FDF(int p0, struct S_FDF p1, double p2,  void (*cb)(int, struct S_FDF, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_FDD(int p0, struct S_FDD p1, double p2,  void (*cb)(int, struct S_FDD, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_FDP(int p0, struct S_FDP p1, double p2,  void (*cb)(int, struct S_FDP, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_FPI(int p0, struct S_FPI p1, double p2,  void (*cb)(int, struct S_FPI, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_FPF(int p0, struct S_FPF p1, double p2,  void (*cb)(int, struct S_FPF, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_FPD(int p0, struct S_FPD p1, double p2,  void (*cb)(int, struct S_FPD, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_FPP(int p0, struct S_FPP p1, double p2,  void (*cb)(int, struct S_FPP, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_DII(int p0, struct S_DII p1, double p2,  void (*cb)(int, struct S_DII, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_DIF(int p0, struct S_DIF p1, double p2,  void (*cb)(int, struct S_DIF, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_DID(int p0, struct S_DID p1, double p2,  void (*cb)(int, struct S_DID, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_DIP(int p0, struct S_DIP p1, double p2,  void (*cb)(int, struct S_DIP, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_DFI(int p0, struct S_DFI p1, double p2,  void (*cb)(int, struct S_DFI, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_DFF(int p0, struct S_DFF p1, double p2,  void (*cb)(int, struct S_DFF, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_DFD(int p0, struct S_DFD p1, double p2,  void (*cb)(int, struct S_DFD, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_DFP(int p0, struct S_DFP p1, double p2,  void (*cb)(int, struct S_DFP, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_DDI(int p0, struct S_DDI p1, double p2,  void (*cb)(int, struct S_DDI, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_DDF(int p0, struct S_DDF p1, double p2,  void (*cb)(int, struct S_DDF, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_DDD(int p0, struct S_DDD p1, double p2,  void (*cb)(int, struct S_DDD, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_DDP(int p0, struct S_DDP p1, double p2,  void (*cb)(int, struct S_DDP, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_DPI(int p0, struct S_DPI p1, double p2,  void (*cb)(int, struct S_DPI, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_DPF(int p0, struct S_DPF p1, double p2,  void (*cb)(int, struct S_DPF, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_DPD(int p0, struct S_DPD p1, double p2,  void (*cb)(int, struct S_DPD, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_DPP(int p0, struct S_DPP p1, double p2,  void (*cb)(int, struct S_DPP, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_PII(int p0, struct S_PII p1, double p2,  void (*cb)(int, struct S_PII, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_PIF(int p0, struct S_PIF p1, double p2,  void (*cb)(int, struct S_PIF, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_PID(int p0, struct S_PID p1, double p2,  void (*cb)(int, struct S_PID, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_PIP(int p0, struct S_PIP p1, double p2,  void (*cb)(int, struct S_PIP, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_PFI(int p0, struct S_PFI p1, double p2,  void (*cb)(int, struct S_PFI, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_PFF(int p0, struct S_PFF p1, double p2,  void (*cb)(int, struct S_PFF, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_PFD(int p0, struct S_PFD p1, double p2,  void (*cb)(int, struct S_PFD, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_PFP(int p0, struct S_PFP p1, double p2,  void (*cb)(int, struct S_PFP, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_PDI(int p0, struct S_PDI p1, double p2,  void (*cb)(int, struct S_PDI, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_PDF(int p0, struct S_PDF p1, double p2,  void (*cb)(int, struct S_PDF, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_PDD(int p0, struct S_PDD p1, double p2,  void (*cb)(int, struct S_PDD, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_PDP(int p0, struct S_PDP p1, double p2,  void (*cb)(int, struct S_PDP, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_PPI(int p0, struct S_PPI p1, double p2,  void (*cb)(int, struct S_PPI, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_PPF(int p0, struct S_PPF p1, double p2,  void (*cb)(int, struct S_PPF, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_PPD(int p0, struct S_PPD p1, double p2,  void (*cb)(int, struct S_PPD, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISD_PPP(int p0, struct S_PPP p1, double p2,  void (*cb)(int, struct S_PPP, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_I(int p0, struct S_I p1, void* p2,  void (*cb)(int, struct S_I, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_F(int p0, struct S_F p1, void* p2,  void (*cb)(int, struct S_F, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_D(int p0, struct S_D p1, void* p2,  void (*cb)(int, struct S_D, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_P(int p0, struct S_P p1, void* p2,  void (*cb)(int, struct S_P, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_II(int p0, struct S_II p1, void* p2,  void (*cb)(int, struct S_II, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_IF(int p0, struct S_IF p1, void* p2,  void (*cb)(int, struct S_IF, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_ID(int p0, struct S_ID p1, void* p2,  void (*cb)(int, struct S_ID, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_IP(int p0, struct S_IP p1, void* p2,  void (*cb)(int, struct S_IP, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_FI(int p0, struct S_FI p1, void* p2,  void (*cb)(int, struct S_FI, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_FF(int p0, struct S_FF p1, void* p2,  void (*cb)(int, struct S_FF, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_FD(int p0, struct S_FD p1, void* p2,  void (*cb)(int, struct S_FD, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_FP(int p0, struct S_FP p1, void* p2,  void (*cb)(int, struct S_FP, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_DI(int p0, struct S_DI p1, void* p2,  void (*cb)(int, struct S_DI, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_DF(int p0, struct S_DF p1, void* p2,  void (*cb)(int, struct S_DF, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_DD(int p0, struct S_DD p1, void* p2,  void (*cb)(int, struct S_DD, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_DP(int p0, struct S_DP p1, void* p2,  void (*cb)(int, struct S_DP, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_PI(int p0, struct S_PI p1, void* p2,  void (*cb)(int, struct S_PI, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_PF(int p0, struct S_PF p1, void* p2,  void (*cb)(int, struct S_PF, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_PD(int p0, struct S_PD p1, void* p2,  void (*cb)(int, struct S_PD, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_PP(int p0, struct S_PP p1, void* p2,  void (*cb)(int, struct S_PP, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_III(int p0, struct S_III p1, void* p2,  void (*cb)(int, struct S_III, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_IIF(int p0, struct S_IIF p1, void* p2,  void (*cb)(int, struct S_IIF, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_IID(int p0, struct S_IID p1, void* p2,  void (*cb)(int, struct S_IID, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_IIP(int p0, struct S_IIP p1, void* p2,  void (*cb)(int, struct S_IIP, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_IFI(int p0, struct S_IFI p1, void* p2,  void (*cb)(int, struct S_IFI, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_IFF(int p0, struct S_IFF p1, void* p2,  void (*cb)(int, struct S_IFF, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_IFD(int p0, struct S_IFD p1, void* p2,  void (*cb)(int, struct S_IFD, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_IFP(int p0, struct S_IFP p1, void* p2,  void (*cb)(int, struct S_IFP, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_IDI(int p0, struct S_IDI p1, void* p2,  void (*cb)(int, struct S_IDI, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_IDF(int p0, struct S_IDF p1, void* p2,  void (*cb)(int, struct S_IDF, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_IDD(int p0, struct S_IDD p1, void* p2,  void (*cb)(int, struct S_IDD, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_IDP(int p0, struct S_IDP p1, void* p2,  void (*cb)(int, struct S_IDP, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_IPI(int p0, struct S_IPI p1, void* p2,  void (*cb)(int, struct S_IPI, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_IPF(int p0, struct S_IPF p1, void* p2,  void (*cb)(int, struct S_IPF, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_IPD(int p0, struct S_IPD p1, void* p2,  void (*cb)(int, struct S_IPD, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_IPP(int p0, struct S_IPP p1, void* p2,  void (*cb)(int, struct S_IPP, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_FII(int p0, struct S_FII p1, void* p2,  void (*cb)(int, struct S_FII, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_FIF(int p0, struct S_FIF p1, void* p2,  void (*cb)(int, struct S_FIF, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_FID(int p0, struct S_FID p1, void* p2,  void (*cb)(int, struct S_FID, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_FIP(int p0, struct S_FIP p1, void* p2,  void (*cb)(int, struct S_FIP, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_FFI(int p0, struct S_FFI p1, void* p2,  void (*cb)(int, struct S_FFI, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_FFF(int p0, struct S_FFF p1, void* p2,  void (*cb)(int, struct S_FFF, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_FFD(int p0, struct S_FFD p1, void* p2,  void (*cb)(int, struct S_FFD, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_FFP(int p0, struct S_FFP p1, void* p2,  void (*cb)(int, struct S_FFP, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_FDI(int p0, struct S_FDI p1, void* p2,  void (*cb)(int, struct S_FDI, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_FDF(int p0, struct S_FDF p1, void* p2,  void (*cb)(int, struct S_FDF, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_FDD(int p0, struct S_FDD p1, void* p2,  void (*cb)(int, struct S_FDD, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_FDP(int p0, struct S_FDP p1, void* p2,  void (*cb)(int, struct S_FDP, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_FPI(int p0, struct S_FPI p1, void* p2,  void (*cb)(int, struct S_FPI, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_FPF(int p0, struct S_FPF p1, void* p2,  void (*cb)(int, struct S_FPF, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_FPD(int p0, struct S_FPD p1, void* p2,  void (*cb)(int, struct S_FPD, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_FPP(int p0, struct S_FPP p1, void* p2,  void (*cb)(int, struct S_FPP, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_DII(int p0, struct S_DII p1, void* p2,  void (*cb)(int, struct S_DII, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_DIF(int p0, struct S_DIF p1, void* p2,  void (*cb)(int, struct S_DIF, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_DID(int p0, struct S_DID p1, void* p2,  void (*cb)(int, struct S_DID, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_DIP(int p0, struct S_DIP p1, void* p2,  void (*cb)(int, struct S_DIP, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_DFI(int p0, struct S_DFI p1, void* p2,  void (*cb)(int, struct S_DFI, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_DFF(int p0, struct S_DFF p1, void* p2,  void (*cb)(int, struct S_DFF, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_DFD(int p0, struct S_DFD p1, void* p2,  void (*cb)(int, struct S_DFD, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_DFP(int p0, struct S_DFP p1, void* p2,  void (*cb)(int, struct S_DFP, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_DDI(int p0, struct S_DDI p1, void* p2,  void (*cb)(int, struct S_DDI, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_DDF(int p0, struct S_DDF p1, void* p2,  void (*cb)(int, struct S_DDF, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_DDD(int p0, struct S_DDD p1, void* p2,  void (*cb)(int, struct S_DDD, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_DDP(int p0, struct S_DDP p1, void* p2,  void (*cb)(int, struct S_DDP, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_DPI(int p0, struct S_DPI p1, void* p2,  void (*cb)(int, struct S_DPI, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_DPF(int p0, struct S_DPF p1, void* p2,  void (*cb)(int, struct S_DPF, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_DPD(int p0, struct S_DPD p1, void* p2,  void (*cb)(int, struct S_DPD, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_DPP(int p0, struct S_DPP p1, void* p2,  void (*cb)(int, struct S_DPP, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_PII(int p0, struct S_PII p1, void* p2,  void (*cb)(int, struct S_PII, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_PIF(int p0, struct S_PIF p1, void* p2,  void (*cb)(int, struct S_PIF, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_PID(int p0, struct S_PID p1, void* p2,  void (*cb)(int, struct S_PID, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_PIP(int p0, struct S_PIP p1, void* p2,  void (*cb)(int, struct S_PIP, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_PFI(int p0, struct S_PFI p1, void* p2,  void (*cb)(int, struct S_PFI, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_PFF(int p0, struct S_PFF p1, void* p2,  void (*cb)(int, struct S_PFF, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_PFD(int p0, struct S_PFD p1, void* p2,  void (*cb)(int, struct S_PFD, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_PFP(int p0, struct S_PFP p1, void* p2,  void (*cb)(int, struct S_PFP, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_PDI(int p0, struct S_PDI p1, void* p2,  void (*cb)(int, struct S_PDI, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_PDF(int p0, struct S_PDF p1, void* p2,  void (*cb)(int, struct S_PDF, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_PDD(int p0, struct S_PDD p1, void* p2,  void (*cb)(int, struct S_PDD, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_PDP(int p0, struct S_PDP p1, void* p2,  void (*cb)(int, struct S_PDP, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_PPI(int p0, struct S_PPI p1, void* p2,  void (*cb)(int, struct S_PPI, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_PPF(int p0, struct S_PPF p1, void* p2,  void (*cb)(int, struct S_PPF, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_PPD(int p0, struct S_PPD p1, void* p2,  void (*cb)(int, struct S_PPD, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISP_PPP(int p0, struct S_PPP p1, void* p2,  void (*cb)(int, struct S_PPP, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_I(int p0, struct S_I p1, struct S_I p2,  void (*cb)(int, struct S_I, struct S_I)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_F(int p0, struct S_F p1, struct S_F p2,  void (*cb)(int, struct S_F, struct S_F)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_D(int p0, struct S_D p1, struct S_D p2,  void (*cb)(int, struct S_D, struct S_D)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_P(int p0, struct S_P p1, struct S_P p2,  void (*cb)(int, struct S_P, struct S_P)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_II(int p0, struct S_II p1, struct S_II p2,  void (*cb)(int, struct S_II, struct S_II)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_IF(int p0, struct S_IF p1, struct S_IF p2,  void (*cb)(int, struct S_IF, struct S_IF)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_ID(int p0, struct S_ID p1, struct S_ID p2,  void (*cb)(int, struct S_ID, struct S_ID)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_IP(int p0, struct S_IP p1, struct S_IP p2,  void (*cb)(int, struct S_IP, struct S_IP)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_FI(int p0, struct S_FI p1, struct S_FI p2,  void (*cb)(int, struct S_FI, struct S_FI)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_FF(int p0, struct S_FF p1, struct S_FF p2,  void (*cb)(int, struct S_FF, struct S_FF)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_FD(int p0, struct S_FD p1, struct S_FD p2,  void (*cb)(int, struct S_FD, struct S_FD)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_FP(int p0, struct S_FP p1, struct S_FP p2,  void (*cb)(int, struct S_FP, struct S_FP)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_DI(int p0, struct S_DI p1, struct S_DI p2,  void (*cb)(int, struct S_DI, struct S_DI)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_DF(int p0, struct S_DF p1, struct S_DF p2,  void (*cb)(int, struct S_DF, struct S_DF)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_DD(int p0, struct S_DD p1, struct S_DD p2,  void (*cb)(int, struct S_DD, struct S_DD)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_DP(int p0, struct S_DP p1, struct S_DP p2,  void (*cb)(int, struct S_DP, struct S_DP)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_PI(int p0, struct S_PI p1, struct S_PI p2,  void (*cb)(int, struct S_PI, struct S_PI)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_PF(int p0, struct S_PF p1, struct S_PF p2,  void (*cb)(int, struct S_PF, struct S_PF)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_PD(int p0, struct S_PD p1, struct S_PD p2,  void (*cb)(int, struct S_PD, struct S_PD)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_PP(int p0, struct S_PP p1, struct S_PP p2,  void (*cb)(int, struct S_PP, struct S_PP)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_III(int p0, struct S_III p1, struct S_III p2,  void (*cb)(int, struct S_III, struct S_III)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_IIF(int p0, struct S_IIF p1, struct S_IIF p2,  void (*cb)(int, struct S_IIF, struct S_IIF)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_IID(int p0, struct S_IID p1, struct S_IID p2,  void (*cb)(int, struct S_IID, struct S_IID)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_IIP(int p0, struct S_IIP p1, struct S_IIP p2,  void (*cb)(int, struct S_IIP, struct S_IIP)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_IFI(int p0, struct S_IFI p1, struct S_IFI p2,  void (*cb)(int, struct S_IFI, struct S_IFI)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_IFF(int p0, struct S_IFF p1, struct S_IFF p2,  void (*cb)(int, struct S_IFF, struct S_IFF)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_IFD(int p0, struct S_IFD p1, struct S_IFD p2,  void (*cb)(int, struct S_IFD, struct S_IFD)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_IFP(int p0, struct S_IFP p1, struct S_IFP p2,  void (*cb)(int, struct S_IFP, struct S_IFP)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_IDI(int p0, struct S_IDI p1, struct S_IDI p2,  void (*cb)(int, struct S_IDI, struct S_IDI)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_IDF(int p0, struct S_IDF p1, struct S_IDF p2,  void (*cb)(int, struct S_IDF, struct S_IDF)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_IDD(int p0, struct S_IDD p1, struct S_IDD p2,  void (*cb)(int, struct S_IDD, struct S_IDD)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_IDP(int p0, struct S_IDP p1, struct S_IDP p2,  void (*cb)(int, struct S_IDP, struct S_IDP)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_IPI(int p0, struct S_IPI p1, struct S_IPI p2,  void (*cb)(int, struct S_IPI, struct S_IPI)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_IPF(int p0, struct S_IPF p1, struct S_IPF p2,  void (*cb)(int, struct S_IPF, struct S_IPF)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_IPD(int p0, struct S_IPD p1, struct S_IPD p2,  void (*cb)(int, struct S_IPD, struct S_IPD)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_IPP(int p0, struct S_IPP p1, struct S_IPP p2,  void (*cb)(int, struct S_IPP, struct S_IPP)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_FII(int p0, struct S_FII p1, struct S_FII p2,  void (*cb)(int, struct S_FII, struct S_FII)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_FIF(int p0, struct S_FIF p1, struct S_FIF p2,  void (*cb)(int, struct S_FIF, struct S_FIF)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_FID(int p0, struct S_FID p1, struct S_FID p2,  void (*cb)(int, struct S_FID, struct S_FID)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_FIP(int p0, struct S_FIP p1, struct S_FIP p2,  void (*cb)(int, struct S_FIP, struct S_FIP)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_FFI(int p0, struct S_FFI p1, struct S_FFI p2,  void (*cb)(int, struct S_FFI, struct S_FFI)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_FFF(int p0, struct S_FFF p1, struct S_FFF p2,  void (*cb)(int, struct S_FFF, struct S_FFF)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_FFD(int p0, struct S_FFD p1, struct S_FFD p2,  void (*cb)(int, struct S_FFD, struct S_FFD)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_FFP(int p0, struct S_FFP p1, struct S_FFP p2,  void (*cb)(int, struct S_FFP, struct S_FFP)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_FDI(int p0, struct S_FDI p1, struct S_FDI p2,  void (*cb)(int, struct S_FDI, struct S_FDI)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_FDF(int p0, struct S_FDF p1, struct S_FDF p2,  void (*cb)(int, struct S_FDF, struct S_FDF)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_FDD(int p0, struct S_FDD p1, struct S_FDD p2,  void (*cb)(int, struct S_FDD, struct S_FDD)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_FDP(int p0, struct S_FDP p1, struct S_FDP p2,  void (*cb)(int, struct S_FDP, struct S_FDP)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_FPI(int p0, struct S_FPI p1, struct S_FPI p2,  void (*cb)(int, struct S_FPI, struct S_FPI)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_FPF(int p0, struct S_FPF p1, struct S_FPF p2,  void (*cb)(int, struct S_FPF, struct S_FPF)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_FPD(int p0, struct S_FPD p1, struct S_FPD p2,  void (*cb)(int, struct S_FPD, struct S_FPD)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_FPP(int p0, struct S_FPP p1, struct S_FPP p2,  void (*cb)(int, struct S_FPP, struct S_FPP)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_DII(int p0, struct S_DII p1, struct S_DII p2,  void (*cb)(int, struct S_DII, struct S_DII)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_DIF(int p0, struct S_DIF p1, struct S_DIF p2,  void (*cb)(int, struct S_DIF, struct S_DIF)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_DID(int p0, struct S_DID p1, struct S_DID p2,  void (*cb)(int, struct S_DID, struct S_DID)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_DIP(int p0, struct S_DIP p1, struct S_DIP p2,  void (*cb)(int, struct S_DIP, struct S_DIP)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_DFI(int p0, struct S_DFI p1, struct S_DFI p2,  void (*cb)(int, struct S_DFI, struct S_DFI)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_DFF(int p0, struct S_DFF p1, struct S_DFF p2,  void (*cb)(int, struct S_DFF, struct S_DFF)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_DFD(int p0, struct S_DFD p1, struct S_DFD p2,  void (*cb)(int, struct S_DFD, struct S_DFD)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_DFP(int p0, struct S_DFP p1, struct S_DFP p2,  void (*cb)(int, struct S_DFP, struct S_DFP)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_DDI(int p0, struct S_DDI p1, struct S_DDI p2,  void (*cb)(int, struct S_DDI, struct S_DDI)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_DDF(int p0, struct S_DDF p1, struct S_DDF p2,  void (*cb)(int, struct S_DDF, struct S_DDF)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_DDD(int p0, struct S_DDD p1, struct S_DDD p2,  void (*cb)(int, struct S_DDD, struct S_DDD)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_DDP(int p0, struct S_DDP p1, struct S_DDP p2,  void (*cb)(int, struct S_DDP, struct S_DDP)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_DPI(int p0, struct S_DPI p1, struct S_DPI p2,  void (*cb)(int, struct S_DPI, struct S_DPI)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_DPF(int p0, struct S_DPF p1, struct S_DPF p2,  void (*cb)(int, struct S_DPF, struct S_DPF)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_DPD(int p0, struct S_DPD p1, struct S_DPD p2,  void (*cb)(int, struct S_DPD, struct S_DPD)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_DPP(int p0, struct S_DPP p1, struct S_DPP p2,  void (*cb)(int, struct S_DPP, struct S_DPP)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_PII(int p0, struct S_PII p1, struct S_PII p2,  void (*cb)(int, struct S_PII, struct S_PII)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_PIF(int p0, struct S_PIF p1, struct S_PIF p2,  void (*cb)(int, struct S_PIF, struct S_PIF)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_PID(int p0, struct S_PID p1, struct S_PID p2,  void (*cb)(int, struct S_PID, struct S_PID)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_PIP(int p0, struct S_PIP p1, struct S_PIP p2,  void (*cb)(int, struct S_PIP, struct S_PIP)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_PFI(int p0, struct S_PFI p1, struct S_PFI p2,  void (*cb)(int, struct S_PFI, struct S_PFI)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_PFF(int p0, struct S_PFF p1, struct S_PFF p2,  void (*cb)(int, struct S_PFF, struct S_PFF)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_PFD(int p0, struct S_PFD p1, struct S_PFD p2,  void (*cb)(int, struct S_PFD, struct S_PFD)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_PFP(int p0, struct S_PFP p1, struct S_PFP p2,  void (*cb)(int, struct S_PFP, struct S_PFP)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_PDI(int p0, struct S_PDI p1, struct S_PDI p2,  void (*cb)(int, struct S_PDI, struct S_PDI)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_PDF(int p0, struct S_PDF p1, struct S_PDF p2,  void (*cb)(int, struct S_PDF, struct S_PDF)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_PDD(int p0, struct S_PDD p1, struct S_PDD p2,  void (*cb)(int, struct S_PDD, struct S_PDD)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_PDP(int p0, struct S_PDP p1, struct S_PDP p2,  void (*cb)(int, struct S_PDP, struct S_PDP)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_PPI(int p0, struct S_PPI p1, struct S_PPI p2,  void (*cb)(int, struct S_PPI, struct S_PPI)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_PPF(int p0, struct S_PPF p1, struct S_PPF p2,  void (*cb)(int, struct S_PPF, struct S_PPF)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_PPD(int p0, struct S_PPD p1, struct S_PPD p2,  void (*cb)(int, struct S_PPD, struct S_PPD)) { cb(p0,p1,p2); }
+EXPORT void f2_V_ISS_PPP(int p0, struct S_PPP p1, struct S_PPP p2,  void (*cb)(int, struct S_PPP, struct S_PPP)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FII_(float p0, int p1, int p2,  void (*cb)(float, int, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIF_(float p0, int p1, float p2,  void (*cb)(float, int, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FID_(float p0, int p1, double p2,  void (*cb)(float, int, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIP_(float p0, int p1, void* p2,  void (*cb)(float, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_I(float p0, int p1, struct S_I p2,  void (*cb)(float, int, struct S_I)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_F(float p0, int p1, struct S_F p2,  void (*cb)(float, int, struct S_F)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_D(float p0, int p1, struct S_D p2,  void (*cb)(float, int, struct S_D)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_P(float p0, int p1, struct S_P p2,  void (*cb)(float, int, struct S_P)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_II(float p0, int p1, struct S_II p2,  void (*cb)(float, int, struct S_II)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_IF(float p0, int p1, struct S_IF p2,  void (*cb)(float, int, struct S_IF)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_ID(float p0, int p1, struct S_ID p2,  void (*cb)(float, int, struct S_ID)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_IP(float p0, int p1, struct S_IP p2,  void (*cb)(float, int, struct S_IP)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_FI(float p0, int p1, struct S_FI p2,  void (*cb)(float, int, struct S_FI)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_FF(float p0, int p1, struct S_FF p2,  void (*cb)(float, int, struct S_FF)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_FD(float p0, int p1, struct S_FD p2,  void (*cb)(float, int, struct S_FD)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_FP(float p0, int p1, struct S_FP p2,  void (*cb)(float, int, struct S_FP)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_DI(float p0, int p1, struct S_DI p2,  void (*cb)(float, int, struct S_DI)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_DF(float p0, int p1, struct S_DF p2,  void (*cb)(float, int, struct S_DF)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_DD(float p0, int p1, struct S_DD p2,  void (*cb)(float, int, struct S_DD)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_DP(float p0, int p1, struct S_DP p2,  void (*cb)(float, int, struct S_DP)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_PI(float p0, int p1, struct S_PI p2,  void (*cb)(float, int, struct S_PI)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_PF(float p0, int p1, struct S_PF p2,  void (*cb)(float, int, struct S_PF)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_PD(float p0, int p1, struct S_PD p2,  void (*cb)(float, int, struct S_PD)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_PP(float p0, int p1, struct S_PP p2,  void (*cb)(float, int, struct S_PP)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_III(float p0, int p1, struct S_III p2,  void (*cb)(float, int, struct S_III)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_IIF(float p0, int p1, struct S_IIF p2,  void (*cb)(float, int, struct S_IIF)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_IID(float p0, int p1, struct S_IID p2,  void (*cb)(float, int, struct S_IID)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_IIP(float p0, int p1, struct S_IIP p2,  void (*cb)(float, int, struct S_IIP)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_IFI(float p0, int p1, struct S_IFI p2,  void (*cb)(float, int, struct S_IFI)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_IFF(float p0, int p1, struct S_IFF p2,  void (*cb)(float, int, struct S_IFF)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_IFD(float p0, int p1, struct S_IFD p2,  void (*cb)(float, int, struct S_IFD)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_IFP(float p0, int p1, struct S_IFP p2,  void (*cb)(float, int, struct S_IFP)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_IDI(float p0, int p1, struct S_IDI p2,  void (*cb)(float, int, struct S_IDI)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_IDF(float p0, int p1, struct S_IDF p2,  void (*cb)(float, int, struct S_IDF)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_IDD(float p0, int p1, struct S_IDD p2,  void (*cb)(float, int, struct S_IDD)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_IDP(float p0, int p1, struct S_IDP p2,  void (*cb)(float, int, struct S_IDP)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_IPI(float p0, int p1, struct S_IPI p2,  void (*cb)(float, int, struct S_IPI)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_IPF(float p0, int p1, struct S_IPF p2,  void (*cb)(float, int, struct S_IPF)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_IPD(float p0, int p1, struct S_IPD p2,  void (*cb)(float, int, struct S_IPD)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_IPP(float p0, int p1, struct S_IPP p2,  void (*cb)(float, int, struct S_IPP)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_FII(float p0, int p1, struct S_FII p2,  void (*cb)(float, int, struct S_FII)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_FIF(float p0, int p1, struct S_FIF p2,  void (*cb)(float, int, struct S_FIF)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_FID(float p0, int p1, struct S_FID p2,  void (*cb)(float, int, struct S_FID)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_FIP(float p0, int p1, struct S_FIP p2,  void (*cb)(float, int, struct S_FIP)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_FFI(float p0, int p1, struct S_FFI p2,  void (*cb)(float, int, struct S_FFI)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_FFF(float p0, int p1, struct S_FFF p2,  void (*cb)(float, int, struct S_FFF)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_FFD(float p0, int p1, struct S_FFD p2,  void (*cb)(float, int, struct S_FFD)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_FFP(float p0, int p1, struct S_FFP p2,  void (*cb)(float, int, struct S_FFP)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_FDI(float p0, int p1, struct S_FDI p2,  void (*cb)(float, int, struct S_FDI)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_FDF(float p0, int p1, struct S_FDF p2,  void (*cb)(float, int, struct S_FDF)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_FDD(float p0, int p1, struct S_FDD p2,  void (*cb)(float, int, struct S_FDD)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_FDP(float p0, int p1, struct S_FDP p2,  void (*cb)(float, int, struct S_FDP)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_FPI(float p0, int p1, struct S_FPI p2,  void (*cb)(float, int, struct S_FPI)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_FPF(float p0, int p1, struct S_FPF p2,  void (*cb)(float, int, struct S_FPF)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_FPD(float p0, int p1, struct S_FPD p2,  void (*cb)(float, int, struct S_FPD)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_FPP(float p0, int p1, struct S_FPP p2,  void (*cb)(float, int, struct S_FPP)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_DII(float p0, int p1, struct S_DII p2,  void (*cb)(float, int, struct S_DII)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_DIF(float p0, int p1, struct S_DIF p2,  void (*cb)(float, int, struct S_DIF)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_DID(float p0, int p1, struct S_DID p2,  void (*cb)(float, int, struct S_DID)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_DIP(float p0, int p1, struct S_DIP p2,  void (*cb)(float, int, struct S_DIP)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_DFI(float p0, int p1, struct S_DFI p2,  void (*cb)(float, int, struct S_DFI)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_DFF(float p0, int p1, struct S_DFF p2,  void (*cb)(float, int, struct S_DFF)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_DFD(float p0, int p1, struct S_DFD p2,  void (*cb)(float, int, struct S_DFD)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_DFP(float p0, int p1, struct S_DFP p2,  void (*cb)(float, int, struct S_DFP)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_DDI(float p0, int p1, struct S_DDI p2,  void (*cb)(float, int, struct S_DDI)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_DDF(float p0, int p1, struct S_DDF p2,  void (*cb)(float, int, struct S_DDF)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_DDD(float p0, int p1, struct S_DDD p2,  void (*cb)(float, int, struct S_DDD)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_DDP(float p0, int p1, struct S_DDP p2,  void (*cb)(float, int, struct S_DDP)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_DPI(float p0, int p1, struct S_DPI p2,  void (*cb)(float, int, struct S_DPI)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_DPF(float p0, int p1, struct S_DPF p2,  void (*cb)(float, int, struct S_DPF)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_DPD(float p0, int p1, struct S_DPD p2,  void (*cb)(float, int, struct S_DPD)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_DPP(float p0, int p1, struct S_DPP p2,  void (*cb)(float, int, struct S_DPP)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_PII(float p0, int p1, struct S_PII p2,  void (*cb)(float, int, struct S_PII)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_PIF(float p0, int p1, struct S_PIF p2,  void (*cb)(float, int, struct S_PIF)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_PID(float p0, int p1, struct S_PID p2,  void (*cb)(float, int, struct S_PID)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_PIP(float p0, int p1, struct S_PIP p2,  void (*cb)(float, int, struct S_PIP)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_PFI(float p0, int p1, struct S_PFI p2,  void (*cb)(float, int, struct S_PFI)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_PFF(float p0, int p1, struct S_PFF p2,  void (*cb)(float, int, struct S_PFF)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_PFD(float p0, int p1, struct S_PFD p2,  void (*cb)(float, int, struct S_PFD)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_PFP(float p0, int p1, struct S_PFP p2,  void (*cb)(float, int, struct S_PFP)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_PDI(float p0, int p1, struct S_PDI p2,  void (*cb)(float, int, struct S_PDI)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_PDF(float p0, int p1, struct S_PDF p2,  void (*cb)(float, int, struct S_PDF)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_PDD(float p0, int p1, struct S_PDD p2,  void (*cb)(float, int, struct S_PDD)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_PDP(float p0, int p1, struct S_PDP p2,  void (*cb)(float, int, struct S_PDP)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_PPI(float p0, int p1, struct S_PPI p2,  void (*cb)(float, int, struct S_PPI)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_PPF(float p0, int p1, struct S_PPF p2,  void (*cb)(float, int, struct S_PPF)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_PPD(float p0, int p1, struct S_PPD p2,  void (*cb)(float, int, struct S_PPD)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FIS_PPP(float p0, int p1, struct S_PPP p2,  void (*cb)(float, int, struct S_PPP)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFI_(float p0, float p1, int p2,  void (*cb)(float, float, int)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFF_(float p0, float p1, float p2,  void (*cb)(float, float, float)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFD_(float p0, float p1, double p2,  void (*cb)(float, float, double)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFP_(float p0, float p1, void* p2,  void (*cb)(float, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_I(float p0, float p1, struct S_I p2,  void (*cb)(float, float, struct S_I)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_F(float p0, float p1, struct S_F p2,  void (*cb)(float, float, struct S_F)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_D(float p0, float p1, struct S_D p2,  void (*cb)(float, float, struct S_D)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_P(float p0, float p1, struct S_P p2,  void (*cb)(float, float, struct S_P)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_II(float p0, float p1, struct S_II p2,  void (*cb)(float, float, struct S_II)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_IF(float p0, float p1, struct S_IF p2,  void (*cb)(float, float, struct S_IF)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_ID(float p0, float p1, struct S_ID p2,  void (*cb)(float, float, struct S_ID)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_IP(float p0, float p1, struct S_IP p2,  void (*cb)(float, float, struct S_IP)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_FI(float p0, float p1, struct S_FI p2,  void (*cb)(float, float, struct S_FI)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_FF(float p0, float p1, struct S_FF p2,  void (*cb)(float, float, struct S_FF)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_FD(float p0, float p1, struct S_FD p2,  void (*cb)(float, float, struct S_FD)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_FP(float p0, float p1, struct S_FP p2,  void (*cb)(float, float, struct S_FP)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_DI(float p0, float p1, struct S_DI p2,  void (*cb)(float, float, struct S_DI)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_DF(float p0, float p1, struct S_DF p2,  void (*cb)(float, float, struct S_DF)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_DD(float p0, float p1, struct S_DD p2,  void (*cb)(float, float, struct S_DD)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_DP(float p0, float p1, struct S_DP p2,  void (*cb)(float, float, struct S_DP)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_PI(float p0, float p1, struct S_PI p2,  void (*cb)(float, float, struct S_PI)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_PF(float p0, float p1, struct S_PF p2,  void (*cb)(float, float, struct S_PF)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_PD(float p0, float p1, struct S_PD p2,  void (*cb)(float, float, struct S_PD)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_PP(float p0, float p1, struct S_PP p2,  void (*cb)(float, float, struct S_PP)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_III(float p0, float p1, struct S_III p2,  void (*cb)(float, float, struct S_III)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_IIF(float p0, float p1, struct S_IIF p2,  void (*cb)(float, float, struct S_IIF)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_IID(float p0, float p1, struct S_IID p2,  void (*cb)(float, float, struct S_IID)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_IIP(float p0, float p1, struct S_IIP p2,  void (*cb)(float, float, struct S_IIP)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_IFI(float p0, float p1, struct S_IFI p2,  void (*cb)(float, float, struct S_IFI)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_IFF(float p0, float p1, struct S_IFF p2,  void (*cb)(float, float, struct S_IFF)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_IFD(float p0, float p1, struct S_IFD p2,  void (*cb)(float, float, struct S_IFD)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_IFP(float p0, float p1, struct S_IFP p2,  void (*cb)(float, float, struct S_IFP)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_IDI(float p0, float p1, struct S_IDI p2,  void (*cb)(float, float, struct S_IDI)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_IDF(float p0, float p1, struct S_IDF p2,  void (*cb)(float, float, struct S_IDF)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_IDD(float p0, float p1, struct S_IDD p2,  void (*cb)(float, float, struct S_IDD)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_IDP(float p0, float p1, struct S_IDP p2,  void (*cb)(float, float, struct S_IDP)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_IPI(float p0, float p1, struct S_IPI p2,  void (*cb)(float, float, struct S_IPI)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_IPF(float p0, float p1, struct S_IPF p2,  void (*cb)(float, float, struct S_IPF)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_IPD(float p0, float p1, struct S_IPD p2,  void (*cb)(float, float, struct S_IPD)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_IPP(float p0, float p1, struct S_IPP p2,  void (*cb)(float, float, struct S_IPP)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_FII(float p0, float p1, struct S_FII p2,  void (*cb)(float, float, struct S_FII)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_FIF(float p0, float p1, struct S_FIF p2,  void (*cb)(float, float, struct S_FIF)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_FID(float p0, float p1, struct S_FID p2,  void (*cb)(float, float, struct S_FID)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_FIP(float p0, float p1, struct S_FIP p2,  void (*cb)(float, float, struct S_FIP)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_FFI(float p0, float p1, struct S_FFI p2,  void (*cb)(float, float, struct S_FFI)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_FFF(float p0, float p1, struct S_FFF p2,  void (*cb)(float, float, struct S_FFF)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_FFD(float p0, float p1, struct S_FFD p2,  void (*cb)(float, float, struct S_FFD)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_FFP(float p0, float p1, struct S_FFP p2,  void (*cb)(float, float, struct S_FFP)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_FDI(float p0, float p1, struct S_FDI p2,  void (*cb)(float, float, struct S_FDI)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_FDF(float p0, float p1, struct S_FDF p2,  void (*cb)(float, float, struct S_FDF)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_FDD(float p0, float p1, struct S_FDD p2,  void (*cb)(float, float, struct S_FDD)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_FDP(float p0, float p1, struct S_FDP p2,  void (*cb)(float, float, struct S_FDP)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_FPI(float p0, float p1, struct S_FPI p2,  void (*cb)(float, float, struct S_FPI)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_FPF(float p0, float p1, struct S_FPF p2,  void (*cb)(float, float, struct S_FPF)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_FPD(float p0, float p1, struct S_FPD p2,  void (*cb)(float, float, struct S_FPD)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_FPP(float p0, float p1, struct S_FPP p2,  void (*cb)(float, float, struct S_FPP)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_DII(float p0, float p1, struct S_DII p2,  void (*cb)(float, float, struct S_DII)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_DIF(float p0, float p1, struct S_DIF p2,  void (*cb)(float, float, struct S_DIF)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_DID(float p0, float p1, struct S_DID p2,  void (*cb)(float, float, struct S_DID)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_DIP(float p0, float p1, struct S_DIP p2,  void (*cb)(float, float, struct S_DIP)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_DFI(float p0, float p1, struct S_DFI p2,  void (*cb)(float, float, struct S_DFI)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_DFF(float p0, float p1, struct S_DFF p2,  void (*cb)(float, float, struct S_DFF)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_DFD(float p0, float p1, struct S_DFD p2,  void (*cb)(float, float, struct S_DFD)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_DFP(float p0, float p1, struct S_DFP p2,  void (*cb)(float, float, struct S_DFP)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_DDI(float p0, float p1, struct S_DDI p2,  void (*cb)(float, float, struct S_DDI)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_DDF(float p0, float p1, struct S_DDF p2,  void (*cb)(float, float, struct S_DDF)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_DDD(float p0, float p1, struct S_DDD p2,  void (*cb)(float, float, struct S_DDD)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_DDP(float p0, float p1, struct S_DDP p2,  void (*cb)(float, float, struct S_DDP)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_DPI(float p0, float p1, struct S_DPI p2,  void (*cb)(float, float, struct S_DPI)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_DPF(float p0, float p1, struct S_DPF p2,  void (*cb)(float, float, struct S_DPF)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_DPD(float p0, float p1, struct S_DPD p2,  void (*cb)(float, float, struct S_DPD)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_DPP(float p0, float p1, struct S_DPP p2,  void (*cb)(float, float, struct S_DPP)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_PII(float p0, float p1, struct S_PII p2,  void (*cb)(float, float, struct S_PII)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_PIF(float p0, float p1, struct S_PIF p2,  void (*cb)(float, float, struct S_PIF)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_PID(float p0, float p1, struct S_PID p2,  void (*cb)(float, float, struct S_PID)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_PIP(float p0, float p1, struct S_PIP p2,  void (*cb)(float, float, struct S_PIP)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_PFI(float p0, float p1, struct S_PFI p2,  void (*cb)(float, float, struct S_PFI)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_PFF(float p0, float p1, struct S_PFF p2,  void (*cb)(float, float, struct S_PFF)) { cb(p0,p1,p2); }
+EXPORT void f2_V_FFS_PFD(float p0, float p1, struct S_PFD p2,  void (*cb)(float, float, struct S_PFD)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FFS_PFP(float p0, float p1, struct S_PFP p2,  void (*cb)(float, float, struct S_PFP)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FFS_PDI(float p0, float p1, struct S_PDI p2,  void (*cb)(float, float, struct S_PDI)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FFS_PDF(float p0, float p1, struct S_PDF p2,  void (*cb)(float, float, struct S_PDF)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FFS_PDD(float p0, float p1, struct S_PDD p2,  void (*cb)(float, float, struct S_PDD)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FFS_PDP(float p0, float p1, struct S_PDP p2,  void (*cb)(float, float, struct S_PDP)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FFS_PPI(float p0, float p1, struct S_PPI p2,  void (*cb)(float, float, struct S_PPI)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FFS_PPF(float p0, float p1, struct S_PPF p2,  void (*cb)(float, float, struct S_PPF)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FFS_PPD(float p0, float p1, struct S_PPD p2,  void (*cb)(float, float, struct S_PPD)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FFS_PPP(float p0, float p1, struct S_PPP p2,  void (*cb)(float, float, struct S_PPP)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDI_(float p0, double p1, int p2,  void (*cb)(float, double, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDF_(float p0, double p1, float p2,  void (*cb)(float, double, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDD_(float p0, double p1, double p2,  void (*cb)(float, double, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDP_(float p0, double p1, void* p2,  void (*cb)(float, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_I(float p0, double p1, struct S_I p2,  void (*cb)(float, double, struct S_I)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_F(float p0, double p1, struct S_F p2,  void (*cb)(float, double, struct S_F)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_D(float p0, double p1, struct S_D p2,  void (*cb)(float, double, struct S_D)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_P(float p0, double p1, struct S_P p2,  void (*cb)(float, double, struct S_P)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_II(float p0, double p1, struct S_II p2,  void (*cb)(float, double, struct S_II)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_IF(float p0, double p1, struct S_IF p2,  void (*cb)(float, double, struct S_IF)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_ID(float p0, double p1, struct S_ID p2,  void (*cb)(float, double, struct S_ID)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_IP(float p0, double p1, struct S_IP p2,  void (*cb)(float, double, struct S_IP)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_FI(float p0, double p1, struct S_FI p2,  void (*cb)(float, double, struct S_FI)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_FF(float p0, double p1, struct S_FF p2,  void (*cb)(float, double, struct S_FF)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_FD(float p0, double p1, struct S_FD p2,  void (*cb)(float, double, struct S_FD)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_FP(float p0, double p1, struct S_FP p2,  void (*cb)(float, double, struct S_FP)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_DI(float p0, double p1, struct S_DI p2,  void (*cb)(float, double, struct S_DI)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_DF(float p0, double p1, struct S_DF p2,  void (*cb)(float, double, struct S_DF)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_DD(float p0, double p1, struct S_DD p2,  void (*cb)(float, double, struct S_DD)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_DP(float p0, double p1, struct S_DP p2,  void (*cb)(float, double, struct S_DP)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_PI(float p0, double p1, struct S_PI p2,  void (*cb)(float, double, struct S_PI)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_PF(float p0, double p1, struct S_PF p2,  void (*cb)(float, double, struct S_PF)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_PD(float p0, double p1, struct S_PD p2,  void (*cb)(float, double, struct S_PD)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_PP(float p0, double p1, struct S_PP p2,  void (*cb)(float, double, struct S_PP)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_III(float p0, double p1, struct S_III p2,  void (*cb)(float, double, struct S_III)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_IIF(float p0, double p1, struct S_IIF p2,  void (*cb)(float, double, struct S_IIF)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_IID(float p0, double p1, struct S_IID p2,  void (*cb)(float, double, struct S_IID)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_IIP(float p0, double p1, struct S_IIP p2,  void (*cb)(float, double, struct S_IIP)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_IFI(float p0, double p1, struct S_IFI p2,  void (*cb)(float, double, struct S_IFI)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_IFF(float p0, double p1, struct S_IFF p2,  void (*cb)(float, double, struct S_IFF)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_IFD(float p0, double p1, struct S_IFD p2,  void (*cb)(float, double, struct S_IFD)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_IFP(float p0, double p1, struct S_IFP p2,  void (*cb)(float, double, struct S_IFP)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_IDI(float p0, double p1, struct S_IDI p2,  void (*cb)(float, double, struct S_IDI)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_IDF(float p0, double p1, struct S_IDF p2,  void (*cb)(float, double, struct S_IDF)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_IDD(float p0, double p1, struct S_IDD p2,  void (*cb)(float, double, struct S_IDD)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_IDP(float p0, double p1, struct S_IDP p2,  void (*cb)(float, double, struct S_IDP)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_IPI(float p0, double p1, struct S_IPI p2,  void (*cb)(float, double, struct S_IPI)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_IPF(float p0, double p1, struct S_IPF p2,  void (*cb)(float, double, struct S_IPF)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_IPD(float p0, double p1, struct S_IPD p2,  void (*cb)(float, double, struct S_IPD)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_IPP(float p0, double p1, struct S_IPP p2,  void (*cb)(float, double, struct S_IPP)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_FII(float p0, double p1, struct S_FII p2,  void (*cb)(float, double, struct S_FII)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_FIF(float p0, double p1, struct S_FIF p2,  void (*cb)(float, double, struct S_FIF)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_FID(float p0, double p1, struct S_FID p2,  void (*cb)(float, double, struct S_FID)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_FIP(float p0, double p1, struct S_FIP p2,  void (*cb)(float, double, struct S_FIP)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_FFI(float p0, double p1, struct S_FFI p2,  void (*cb)(float, double, struct S_FFI)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_FFF(float p0, double p1, struct S_FFF p2,  void (*cb)(float, double, struct S_FFF)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_FFD(float p0, double p1, struct S_FFD p2,  void (*cb)(float, double, struct S_FFD)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_FFP(float p0, double p1, struct S_FFP p2,  void (*cb)(float, double, struct S_FFP)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_FDI(float p0, double p1, struct S_FDI p2,  void (*cb)(float, double, struct S_FDI)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_FDF(float p0, double p1, struct S_FDF p2,  void (*cb)(float, double, struct S_FDF)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_FDD(float p0, double p1, struct S_FDD p2,  void (*cb)(float, double, struct S_FDD)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_FDP(float p0, double p1, struct S_FDP p2,  void (*cb)(float, double, struct S_FDP)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_FPI(float p0, double p1, struct S_FPI p2,  void (*cb)(float, double, struct S_FPI)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_FPF(float p0, double p1, struct S_FPF p2,  void (*cb)(float, double, struct S_FPF)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_FPD(float p0, double p1, struct S_FPD p2,  void (*cb)(float, double, struct S_FPD)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_FPP(float p0, double p1, struct S_FPP p2,  void (*cb)(float, double, struct S_FPP)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_DII(float p0, double p1, struct S_DII p2,  void (*cb)(float, double, struct S_DII)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_DIF(float p0, double p1, struct S_DIF p2,  void (*cb)(float, double, struct S_DIF)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_DID(float p0, double p1, struct S_DID p2,  void (*cb)(float, double, struct S_DID)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_DIP(float p0, double p1, struct S_DIP p2,  void (*cb)(float, double, struct S_DIP)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_DFI(float p0, double p1, struct S_DFI p2,  void (*cb)(float, double, struct S_DFI)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_DFF(float p0, double p1, struct S_DFF p2,  void (*cb)(float, double, struct S_DFF)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_DFD(float p0, double p1, struct S_DFD p2,  void (*cb)(float, double, struct S_DFD)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_DFP(float p0, double p1, struct S_DFP p2,  void (*cb)(float, double, struct S_DFP)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_DDI(float p0, double p1, struct S_DDI p2,  void (*cb)(float, double, struct S_DDI)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_DDF(float p0, double p1, struct S_DDF p2,  void (*cb)(float, double, struct S_DDF)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_DDD(float p0, double p1, struct S_DDD p2,  void (*cb)(float, double, struct S_DDD)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_DDP(float p0, double p1, struct S_DDP p2,  void (*cb)(float, double, struct S_DDP)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_DPI(float p0, double p1, struct S_DPI p2,  void (*cb)(float, double, struct S_DPI)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_DPF(float p0, double p1, struct S_DPF p2,  void (*cb)(float, double, struct S_DPF)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_DPD(float p0, double p1, struct S_DPD p2,  void (*cb)(float, double, struct S_DPD)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_DPP(float p0, double p1, struct S_DPP p2,  void (*cb)(float, double, struct S_DPP)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_PII(float p0, double p1, struct S_PII p2,  void (*cb)(float, double, struct S_PII)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_PIF(float p0, double p1, struct S_PIF p2,  void (*cb)(float, double, struct S_PIF)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_PID(float p0, double p1, struct S_PID p2,  void (*cb)(float, double, struct S_PID)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_PIP(float p0, double p1, struct S_PIP p2,  void (*cb)(float, double, struct S_PIP)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_PFI(float p0, double p1, struct S_PFI p2,  void (*cb)(float, double, struct S_PFI)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_PFF(float p0, double p1, struct S_PFF p2,  void (*cb)(float, double, struct S_PFF)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_PFD(float p0, double p1, struct S_PFD p2,  void (*cb)(float, double, struct S_PFD)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_PFP(float p0, double p1, struct S_PFP p2,  void (*cb)(float, double, struct S_PFP)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_PDI(float p0, double p1, struct S_PDI p2,  void (*cb)(float, double, struct S_PDI)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_PDF(float p0, double p1, struct S_PDF p2,  void (*cb)(float, double, struct S_PDF)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_PDD(float p0, double p1, struct S_PDD p2,  void (*cb)(float, double, struct S_PDD)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_PDP(float p0, double p1, struct S_PDP p2,  void (*cb)(float, double, struct S_PDP)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_PPI(float p0, double p1, struct S_PPI p2,  void (*cb)(float, double, struct S_PPI)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_PPF(float p0, double p1, struct S_PPF p2,  void (*cb)(float, double, struct S_PPF)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_PPD(float p0, double p1, struct S_PPD p2,  void (*cb)(float, double, struct S_PPD)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FDS_PPP(float p0, double p1, struct S_PPP p2,  void (*cb)(float, double, struct S_PPP)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPI_(float p0, void* p1, int p2,  void (*cb)(float, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPF_(float p0, void* p1, float p2,  void (*cb)(float, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPD_(float p0, void* p1, double p2,  void (*cb)(float, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPP_(float p0, void* p1, void* p2,  void (*cb)(float, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_I(float p0, void* p1, struct S_I p2,  void (*cb)(float, void*, struct S_I)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_F(float p0, void* p1, struct S_F p2,  void (*cb)(float, void*, struct S_F)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_D(float p0, void* p1, struct S_D p2,  void (*cb)(float, void*, struct S_D)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_P(float p0, void* p1, struct S_P p2,  void (*cb)(float, void*, struct S_P)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_II(float p0, void* p1, struct S_II p2,  void (*cb)(float, void*, struct S_II)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_IF(float p0, void* p1, struct S_IF p2,  void (*cb)(float, void*, struct S_IF)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_ID(float p0, void* p1, struct S_ID p2,  void (*cb)(float, void*, struct S_ID)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_IP(float p0, void* p1, struct S_IP p2,  void (*cb)(float, void*, struct S_IP)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_FI(float p0, void* p1, struct S_FI p2,  void (*cb)(float, void*, struct S_FI)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_FF(float p0, void* p1, struct S_FF p2,  void (*cb)(float, void*, struct S_FF)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_FD(float p0, void* p1, struct S_FD p2,  void (*cb)(float, void*, struct S_FD)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_FP(float p0, void* p1, struct S_FP p2,  void (*cb)(float, void*, struct S_FP)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_DI(float p0, void* p1, struct S_DI p2,  void (*cb)(float, void*, struct S_DI)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_DF(float p0, void* p1, struct S_DF p2,  void (*cb)(float, void*, struct S_DF)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_DD(float p0, void* p1, struct S_DD p2,  void (*cb)(float, void*, struct S_DD)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_DP(float p0, void* p1, struct S_DP p2,  void (*cb)(float, void*, struct S_DP)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_PI(float p0, void* p1, struct S_PI p2,  void (*cb)(float, void*, struct S_PI)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_PF(float p0, void* p1, struct S_PF p2,  void (*cb)(float, void*, struct S_PF)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_PD(float p0, void* p1, struct S_PD p2,  void (*cb)(float, void*, struct S_PD)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_PP(float p0, void* p1, struct S_PP p2,  void (*cb)(float, void*, struct S_PP)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_III(float p0, void* p1, struct S_III p2,  void (*cb)(float, void*, struct S_III)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_IIF(float p0, void* p1, struct S_IIF p2,  void (*cb)(float, void*, struct S_IIF)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_IID(float p0, void* p1, struct S_IID p2,  void (*cb)(float, void*, struct S_IID)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_IIP(float p0, void* p1, struct S_IIP p2,  void (*cb)(float, void*, struct S_IIP)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_IFI(float p0, void* p1, struct S_IFI p2,  void (*cb)(float, void*, struct S_IFI)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_IFF(float p0, void* p1, struct S_IFF p2,  void (*cb)(float, void*, struct S_IFF)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_IFD(float p0, void* p1, struct S_IFD p2,  void (*cb)(float, void*, struct S_IFD)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_IFP(float p0, void* p1, struct S_IFP p2,  void (*cb)(float, void*, struct S_IFP)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_IDI(float p0, void* p1, struct S_IDI p2,  void (*cb)(float, void*, struct S_IDI)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_IDF(float p0, void* p1, struct S_IDF p2,  void (*cb)(float, void*, struct S_IDF)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_IDD(float p0, void* p1, struct S_IDD p2,  void (*cb)(float, void*, struct S_IDD)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_IDP(float p0, void* p1, struct S_IDP p2,  void (*cb)(float, void*, struct S_IDP)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_IPI(float p0, void* p1, struct S_IPI p2,  void (*cb)(float, void*, struct S_IPI)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_IPF(float p0, void* p1, struct S_IPF p2,  void (*cb)(float, void*, struct S_IPF)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_IPD(float p0, void* p1, struct S_IPD p2,  void (*cb)(float, void*, struct S_IPD)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_IPP(float p0, void* p1, struct S_IPP p2,  void (*cb)(float, void*, struct S_IPP)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_FII(float p0, void* p1, struct S_FII p2,  void (*cb)(float, void*, struct S_FII)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_FIF(float p0, void* p1, struct S_FIF p2,  void (*cb)(float, void*, struct S_FIF)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_FID(float p0, void* p1, struct S_FID p2,  void (*cb)(float, void*, struct S_FID)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_FIP(float p0, void* p1, struct S_FIP p2,  void (*cb)(float, void*, struct S_FIP)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_FFI(float p0, void* p1, struct S_FFI p2,  void (*cb)(float, void*, struct S_FFI)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_FFF(float p0, void* p1, struct S_FFF p2,  void (*cb)(float, void*, struct S_FFF)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_FFD(float p0, void* p1, struct S_FFD p2,  void (*cb)(float, void*, struct S_FFD)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_FFP(float p0, void* p1, struct S_FFP p2,  void (*cb)(float, void*, struct S_FFP)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_FDI(float p0, void* p1, struct S_FDI p2,  void (*cb)(float, void*, struct S_FDI)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_FDF(float p0, void* p1, struct S_FDF p2,  void (*cb)(float, void*, struct S_FDF)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_FDD(float p0, void* p1, struct S_FDD p2,  void (*cb)(float, void*, struct S_FDD)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_FDP(float p0, void* p1, struct S_FDP p2,  void (*cb)(float, void*, struct S_FDP)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_FPI(float p0, void* p1, struct S_FPI p2,  void (*cb)(float, void*, struct S_FPI)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_FPF(float p0, void* p1, struct S_FPF p2,  void (*cb)(float, void*, struct S_FPF)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_FPD(float p0, void* p1, struct S_FPD p2,  void (*cb)(float, void*, struct S_FPD)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_FPP(float p0, void* p1, struct S_FPP p2,  void (*cb)(float, void*, struct S_FPP)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_DII(float p0, void* p1, struct S_DII p2,  void (*cb)(float, void*, struct S_DII)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_DIF(float p0, void* p1, struct S_DIF p2,  void (*cb)(float, void*, struct S_DIF)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_DID(float p0, void* p1, struct S_DID p2,  void (*cb)(float, void*, struct S_DID)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_DIP(float p0, void* p1, struct S_DIP p2,  void (*cb)(float, void*, struct S_DIP)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_DFI(float p0, void* p1, struct S_DFI p2,  void (*cb)(float, void*, struct S_DFI)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_DFF(float p0, void* p1, struct S_DFF p2,  void (*cb)(float, void*, struct S_DFF)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_DFD(float p0, void* p1, struct S_DFD p2,  void (*cb)(float, void*, struct S_DFD)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_DFP(float p0, void* p1, struct S_DFP p2,  void (*cb)(float, void*, struct S_DFP)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_DDI(float p0, void* p1, struct S_DDI p2,  void (*cb)(float, void*, struct S_DDI)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_DDF(float p0, void* p1, struct S_DDF p2,  void (*cb)(float, void*, struct S_DDF)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_DDD(float p0, void* p1, struct S_DDD p2,  void (*cb)(float, void*, struct S_DDD)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_DDP(float p0, void* p1, struct S_DDP p2,  void (*cb)(float, void*, struct S_DDP)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_DPI(float p0, void* p1, struct S_DPI p2,  void (*cb)(float, void*, struct S_DPI)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_DPF(float p0, void* p1, struct S_DPF p2,  void (*cb)(float, void*, struct S_DPF)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_DPD(float p0, void* p1, struct S_DPD p2,  void (*cb)(float, void*, struct S_DPD)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_DPP(float p0, void* p1, struct S_DPP p2,  void (*cb)(float, void*, struct S_DPP)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_PII(float p0, void* p1, struct S_PII p2,  void (*cb)(float, void*, struct S_PII)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_PIF(float p0, void* p1, struct S_PIF p2,  void (*cb)(float, void*, struct S_PIF)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_PID(float p0, void* p1, struct S_PID p2,  void (*cb)(float, void*, struct S_PID)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_PIP(float p0, void* p1, struct S_PIP p2,  void (*cb)(float, void*, struct S_PIP)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_PFI(float p0, void* p1, struct S_PFI p2,  void (*cb)(float, void*, struct S_PFI)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_PFF(float p0, void* p1, struct S_PFF p2,  void (*cb)(float, void*, struct S_PFF)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_PFD(float p0, void* p1, struct S_PFD p2,  void (*cb)(float, void*, struct S_PFD)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_PFP(float p0, void* p1, struct S_PFP p2,  void (*cb)(float, void*, struct S_PFP)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_PDI(float p0, void* p1, struct S_PDI p2,  void (*cb)(float, void*, struct S_PDI)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_PDF(float p0, void* p1, struct S_PDF p2,  void (*cb)(float, void*, struct S_PDF)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_PDD(float p0, void* p1, struct S_PDD p2,  void (*cb)(float, void*, struct S_PDD)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_PDP(float p0, void* p1, struct S_PDP p2,  void (*cb)(float, void*, struct S_PDP)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_PPI(float p0, void* p1, struct S_PPI p2,  void (*cb)(float, void*, struct S_PPI)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_PPF(float p0, void* p1, struct S_PPF p2,  void (*cb)(float, void*, struct S_PPF)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_PPD(float p0, void* p1, struct S_PPD p2,  void (*cb)(float, void*, struct S_PPD)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FPS_PPP(float p0, void* p1, struct S_PPP p2,  void (*cb)(float, void*, struct S_PPP)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_I(float p0, struct S_I p1, int p2,  void (*cb)(float, struct S_I, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_F(float p0, struct S_F p1, int p2,  void (*cb)(float, struct S_F, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_D(float p0, struct S_D p1, int p2,  void (*cb)(float, struct S_D, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_P(float p0, struct S_P p1, int p2,  void (*cb)(float, struct S_P, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_II(float p0, struct S_II p1, int p2,  void (*cb)(float, struct S_II, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_IF(float p0, struct S_IF p1, int p2,  void (*cb)(float, struct S_IF, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_ID(float p0, struct S_ID p1, int p2,  void (*cb)(float, struct S_ID, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_IP(float p0, struct S_IP p1, int p2,  void (*cb)(float, struct S_IP, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_FI(float p0, struct S_FI p1, int p2,  void (*cb)(float, struct S_FI, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_FF(float p0, struct S_FF p1, int p2,  void (*cb)(float, struct S_FF, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_FD(float p0, struct S_FD p1, int p2,  void (*cb)(float, struct S_FD, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_FP(float p0, struct S_FP p1, int p2,  void (*cb)(float, struct S_FP, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_DI(float p0, struct S_DI p1, int p2,  void (*cb)(float, struct S_DI, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_DF(float p0, struct S_DF p1, int p2,  void (*cb)(float, struct S_DF, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_DD(float p0, struct S_DD p1, int p2,  void (*cb)(float, struct S_DD, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_DP(float p0, struct S_DP p1, int p2,  void (*cb)(float, struct S_DP, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_PI(float p0, struct S_PI p1, int p2,  void (*cb)(float, struct S_PI, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_PF(float p0, struct S_PF p1, int p2,  void (*cb)(float, struct S_PF, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_PD(float p0, struct S_PD p1, int p2,  void (*cb)(float, struct S_PD, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_PP(float p0, struct S_PP p1, int p2,  void (*cb)(float, struct S_PP, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_III(float p0, struct S_III p1, int p2,  void (*cb)(float, struct S_III, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_IIF(float p0, struct S_IIF p1, int p2,  void (*cb)(float, struct S_IIF, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_IID(float p0, struct S_IID p1, int p2,  void (*cb)(float, struct S_IID, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_IIP(float p0, struct S_IIP p1, int p2,  void (*cb)(float, struct S_IIP, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_IFI(float p0, struct S_IFI p1, int p2,  void (*cb)(float, struct S_IFI, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_IFF(float p0, struct S_IFF p1, int p2,  void (*cb)(float, struct S_IFF, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_IFD(float p0, struct S_IFD p1, int p2,  void (*cb)(float, struct S_IFD, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_IFP(float p0, struct S_IFP p1, int p2,  void (*cb)(float, struct S_IFP, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_IDI(float p0, struct S_IDI p1, int p2,  void (*cb)(float, struct S_IDI, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_IDF(float p0, struct S_IDF p1, int p2,  void (*cb)(float, struct S_IDF, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_IDD(float p0, struct S_IDD p1, int p2,  void (*cb)(float, struct S_IDD, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_IDP(float p0, struct S_IDP p1, int p2,  void (*cb)(float, struct S_IDP, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_IPI(float p0, struct S_IPI p1, int p2,  void (*cb)(float, struct S_IPI, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_IPF(float p0, struct S_IPF p1, int p2,  void (*cb)(float, struct S_IPF, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_IPD(float p0, struct S_IPD p1, int p2,  void (*cb)(float, struct S_IPD, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_IPP(float p0, struct S_IPP p1, int p2,  void (*cb)(float, struct S_IPP, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_FII(float p0, struct S_FII p1, int p2,  void (*cb)(float, struct S_FII, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_FIF(float p0, struct S_FIF p1, int p2,  void (*cb)(float, struct S_FIF, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_FID(float p0, struct S_FID p1, int p2,  void (*cb)(float, struct S_FID, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_FIP(float p0, struct S_FIP p1, int p2,  void (*cb)(float, struct S_FIP, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_FFI(float p0, struct S_FFI p1, int p2,  void (*cb)(float, struct S_FFI, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_FFF(float p0, struct S_FFF p1, int p2,  void (*cb)(float, struct S_FFF, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_FFD(float p0, struct S_FFD p1, int p2,  void (*cb)(float, struct S_FFD, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_FFP(float p0, struct S_FFP p1, int p2,  void (*cb)(float, struct S_FFP, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_FDI(float p0, struct S_FDI p1, int p2,  void (*cb)(float, struct S_FDI, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_FDF(float p0, struct S_FDF p1, int p2,  void (*cb)(float, struct S_FDF, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_FDD(float p0, struct S_FDD p1, int p2,  void (*cb)(float, struct S_FDD, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_FDP(float p0, struct S_FDP p1, int p2,  void (*cb)(float, struct S_FDP, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_FPI(float p0, struct S_FPI p1, int p2,  void (*cb)(float, struct S_FPI, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_FPF(float p0, struct S_FPF p1, int p2,  void (*cb)(float, struct S_FPF, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_FPD(float p0, struct S_FPD p1, int p2,  void (*cb)(float, struct S_FPD, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_FPP(float p0, struct S_FPP p1, int p2,  void (*cb)(float, struct S_FPP, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_DII(float p0, struct S_DII p1, int p2,  void (*cb)(float, struct S_DII, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_DIF(float p0, struct S_DIF p1, int p2,  void (*cb)(float, struct S_DIF, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_DID(float p0, struct S_DID p1, int p2,  void (*cb)(float, struct S_DID, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_DIP(float p0, struct S_DIP p1, int p2,  void (*cb)(float, struct S_DIP, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_DFI(float p0, struct S_DFI p1, int p2,  void (*cb)(float, struct S_DFI, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_DFF(float p0, struct S_DFF p1, int p2,  void (*cb)(float, struct S_DFF, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_DFD(float p0, struct S_DFD p1, int p2,  void (*cb)(float, struct S_DFD, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_DFP(float p0, struct S_DFP p1, int p2,  void (*cb)(float, struct S_DFP, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_DDI(float p0, struct S_DDI p1, int p2,  void (*cb)(float, struct S_DDI, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_DDF(float p0, struct S_DDF p1, int p2,  void (*cb)(float, struct S_DDF, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_DDD(float p0, struct S_DDD p1, int p2,  void (*cb)(float, struct S_DDD, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_DDP(float p0, struct S_DDP p1, int p2,  void (*cb)(float, struct S_DDP, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_DPI(float p0, struct S_DPI p1, int p2,  void (*cb)(float, struct S_DPI, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_DPF(float p0, struct S_DPF p1, int p2,  void (*cb)(float, struct S_DPF, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_DPD(float p0, struct S_DPD p1, int p2,  void (*cb)(float, struct S_DPD, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_DPP(float p0, struct S_DPP p1, int p2,  void (*cb)(float, struct S_DPP, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_PII(float p0, struct S_PII p1, int p2,  void (*cb)(float, struct S_PII, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_PIF(float p0, struct S_PIF p1, int p2,  void (*cb)(float, struct S_PIF, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_PID(float p0, struct S_PID p1, int p2,  void (*cb)(float, struct S_PID, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_PIP(float p0, struct S_PIP p1, int p2,  void (*cb)(float, struct S_PIP, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_PFI(float p0, struct S_PFI p1, int p2,  void (*cb)(float, struct S_PFI, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_PFF(float p0, struct S_PFF p1, int p2,  void (*cb)(float, struct S_PFF, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_PFD(float p0, struct S_PFD p1, int p2,  void (*cb)(float, struct S_PFD, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_PFP(float p0, struct S_PFP p1, int p2,  void (*cb)(float, struct S_PFP, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_PDI(float p0, struct S_PDI p1, int p2,  void (*cb)(float, struct S_PDI, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_PDF(float p0, struct S_PDF p1, int p2,  void (*cb)(float, struct S_PDF, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_PDD(float p0, struct S_PDD p1, int p2,  void (*cb)(float, struct S_PDD, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_PDP(float p0, struct S_PDP p1, int p2,  void (*cb)(float, struct S_PDP, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_PPI(float p0, struct S_PPI p1, int p2,  void (*cb)(float, struct S_PPI, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_PPF(float p0, struct S_PPF p1, int p2,  void (*cb)(float, struct S_PPF, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_PPD(float p0, struct S_PPD p1, int p2,  void (*cb)(float, struct S_PPD, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSI_PPP(float p0, struct S_PPP p1, int p2,  void (*cb)(float, struct S_PPP, int)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_I(float p0, struct S_I p1, float p2,  void (*cb)(float, struct S_I, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_F(float p0, struct S_F p1, float p2,  void (*cb)(float, struct S_F, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_D(float p0, struct S_D p1, float p2,  void (*cb)(float, struct S_D, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_P(float p0, struct S_P p1, float p2,  void (*cb)(float, struct S_P, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_II(float p0, struct S_II p1, float p2,  void (*cb)(float, struct S_II, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_IF(float p0, struct S_IF p1, float p2,  void (*cb)(float, struct S_IF, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_ID(float p0, struct S_ID p1, float p2,  void (*cb)(float, struct S_ID, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_IP(float p0, struct S_IP p1, float p2,  void (*cb)(float, struct S_IP, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_FI(float p0, struct S_FI p1, float p2,  void (*cb)(float, struct S_FI, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_FF(float p0, struct S_FF p1, float p2,  void (*cb)(float, struct S_FF, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_FD(float p0, struct S_FD p1, float p2,  void (*cb)(float, struct S_FD, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_FP(float p0, struct S_FP p1, float p2,  void (*cb)(float, struct S_FP, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_DI(float p0, struct S_DI p1, float p2,  void (*cb)(float, struct S_DI, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_DF(float p0, struct S_DF p1, float p2,  void (*cb)(float, struct S_DF, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_DD(float p0, struct S_DD p1, float p2,  void (*cb)(float, struct S_DD, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_DP(float p0, struct S_DP p1, float p2,  void (*cb)(float, struct S_DP, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_PI(float p0, struct S_PI p1, float p2,  void (*cb)(float, struct S_PI, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_PF(float p0, struct S_PF p1, float p2,  void (*cb)(float, struct S_PF, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_PD(float p0, struct S_PD p1, float p2,  void (*cb)(float, struct S_PD, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_PP(float p0, struct S_PP p1, float p2,  void (*cb)(float, struct S_PP, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_III(float p0, struct S_III p1, float p2,  void (*cb)(float, struct S_III, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_IIF(float p0, struct S_IIF p1, float p2,  void (*cb)(float, struct S_IIF, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_IID(float p0, struct S_IID p1, float p2,  void (*cb)(float, struct S_IID, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_IIP(float p0, struct S_IIP p1, float p2,  void (*cb)(float, struct S_IIP, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_IFI(float p0, struct S_IFI p1, float p2,  void (*cb)(float, struct S_IFI, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_IFF(float p0, struct S_IFF p1, float p2,  void (*cb)(float, struct S_IFF, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_IFD(float p0, struct S_IFD p1, float p2,  void (*cb)(float, struct S_IFD, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_IFP(float p0, struct S_IFP p1, float p2,  void (*cb)(float, struct S_IFP, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_IDI(float p0, struct S_IDI p1, float p2,  void (*cb)(float, struct S_IDI, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_IDF(float p0, struct S_IDF p1, float p2,  void (*cb)(float, struct S_IDF, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_IDD(float p0, struct S_IDD p1, float p2,  void (*cb)(float, struct S_IDD, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_IDP(float p0, struct S_IDP p1, float p2,  void (*cb)(float, struct S_IDP, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_IPI(float p0, struct S_IPI p1, float p2,  void (*cb)(float, struct S_IPI, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_IPF(float p0, struct S_IPF p1, float p2,  void (*cb)(float, struct S_IPF, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_IPD(float p0, struct S_IPD p1, float p2,  void (*cb)(float, struct S_IPD, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_IPP(float p0, struct S_IPP p1, float p2,  void (*cb)(float, struct S_IPP, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_FII(float p0, struct S_FII p1, float p2,  void (*cb)(float, struct S_FII, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_FIF(float p0, struct S_FIF p1, float p2,  void (*cb)(float, struct S_FIF, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_FID(float p0, struct S_FID p1, float p2,  void (*cb)(float, struct S_FID, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_FIP(float p0, struct S_FIP p1, float p2,  void (*cb)(float, struct S_FIP, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_FFI(float p0, struct S_FFI p1, float p2,  void (*cb)(float, struct S_FFI, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_FFF(float p0, struct S_FFF p1, float p2,  void (*cb)(float, struct S_FFF, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_FFD(float p0, struct S_FFD p1, float p2,  void (*cb)(float, struct S_FFD, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_FFP(float p0, struct S_FFP p1, float p2,  void (*cb)(float, struct S_FFP, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_FDI(float p0, struct S_FDI p1, float p2,  void (*cb)(float, struct S_FDI, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_FDF(float p0, struct S_FDF p1, float p2,  void (*cb)(float, struct S_FDF, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_FDD(float p0, struct S_FDD p1, float p2,  void (*cb)(float, struct S_FDD, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_FDP(float p0, struct S_FDP p1, float p2,  void (*cb)(float, struct S_FDP, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_FPI(float p0, struct S_FPI p1, float p2,  void (*cb)(float, struct S_FPI, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_FPF(float p0, struct S_FPF p1, float p2,  void (*cb)(float, struct S_FPF, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_FPD(float p0, struct S_FPD p1, float p2,  void (*cb)(float, struct S_FPD, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_FPP(float p0, struct S_FPP p1, float p2,  void (*cb)(float, struct S_FPP, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_DII(float p0, struct S_DII p1, float p2,  void (*cb)(float, struct S_DII, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_DIF(float p0, struct S_DIF p1, float p2,  void (*cb)(float, struct S_DIF, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_DID(float p0, struct S_DID p1, float p2,  void (*cb)(float, struct S_DID, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_DIP(float p0, struct S_DIP p1, float p2,  void (*cb)(float, struct S_DIP, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_DFI(float p0, struct S_DFI p1, float p2,  void (*cb)(float, struct S_DFI, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_DFF(float p0, struct S_DFF p1, float p2,  void (*cb)(float, struct S_DFF, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_DFD(float p0, struct S_DFD p1, float p2,  void (*cb)(float, struct S_DFD, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_DFP(float p0, struct S_DFP p1, float p2,  void (*cb)(float, struct S_DFP, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_DDI(float p0, struct S_DDI p1, float p2,  void (*cb)(float, struct S_DDI, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_DDF(float p0, struct S_DDF p1, float p2,  void (*cb)(float, struct S_DDF, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_DDD(float p0, struct S_DDD p1, float p2,  void (*cb)(float, struct S_DDD, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_DDP(float p0, struct S_DDP p1, float p2,  void (*cb)(float, struct S_DDP, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_DPI(float p0, struct S_DPI p1, float p2,  void (*cb)(float, struct S_DPI, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_DPF(float p0, struct S_DPF p1, float p2,  void (*cb)(float, struct S_DPF, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_DPD(float p0, struct S_DPD p1, float p2,  void (*cb)(float, struct S_DPD, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_DPP(float p0, struct S_DPP p1, float p2,  void (*cb)(float, struct S_DPP, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_PII(float p0, struct S_PII p1, float p2,  void (*cb)(float, struct S_PII, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_PIF(float p0, struct S_PIF p1, float p2,  void (*cb)(float, struct S_PIF, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_PID(float p0, struct S_PID p1, float p2,  void (*cb)(float, struct S_PID, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_PIP(float p0, struct S_PIP p1, float p2,  void (*cb)(float, struct S_PIP, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_PFI(float p0, struct S_PFI p1, float p2,  void (*cb)(float, struct S_PFI, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_PFF(float p0, struct S_PFF p1, float p2,  void (*cb)(float, struct S_PFF, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_PFD(float p0, struct S_PFD p1, float p2,  void (*cb)(float, struct S_PFD, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_PFP(float p0, struct S_PFP p1, float p2,  void (*cb)(float, struct S_PFP, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_PDI(float p0, struct S_PDI p1, float p2,  void (*cb)(float, struct S_PDI, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_PDF(float p0, struct S_PDF p1, float p2,  void (*cb)(float, struct S_PDF, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_PDD(float p0, struct S_PDD p1, float p2,  void (*cb)(float, struct S_PDD, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_PDP(float p0, struct S_PDP p1, float p2,  void (*cb)(float, struct S_PDP, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_PPI(float p0, struct S_PPI p1, float p2,  void (*cb)(float, struct S_PPI, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_PPF(float p0, struct S_PPF p1, float p2,  void (*cb)(float, struct S_PPF, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_PPD(float p0, struct S_PPD p1, float p2,  void (*cb)(float, struct S_PPD, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSF_PPP(float p0, struct S_PPP p1, float p2,  void (*cb)(float, struct S_PPP, float)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_I(float p0, struct S_I p1, double p2,  void (*cb)(float, struct S_I, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_F(float p0, struct S_F p1, double p2,  void (*cb)(float, struct S_F, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_D(float p0, struct S_D p1, double p2,  void (*cb)(float, struct S_D, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_P(float p0, struct S_P p1, double p2,  void (*cb)(float, struct S_P, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_II(float p0, struct S_II p1, double p2,  void (*cb)(float, struct S_II, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_IF(float p0, struct S_IF p1, double p2,  void (*cb)(float, struct S_IF, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_ID(float p0, struct S_ID p1, double p2,  void (*cb)(float, struct S_ID, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_IP(float p0, struct S_IP p1, double p2,  void (*cb)(float, struct S_IP, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_FI(float p0, struct S_FI p1, double p2,  void (*cb)(float, struct S_FI, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_FF(float p0, struct S_FF p1, double p2,  void (*cb)(float, struct S_FF, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_FD(float p0, struct S_FD p1, double p2,  void (*cb)(float, struct S_FD, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_FP(float p0, struct S_FP p1, double p2,  void (*cb)(float, struct S_FP, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_DI(float p0, struct S_DI p1, double p2,  void (*cb)(float, struct S_DI, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_DF(float p0, struct S_DF p1, double p2,  void (*cb)(float, struct S_DF, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_DD(float p0, struct S_DD p1, double p2,  void (*cb)(float, struct S_DD, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_DP(float p0, struct S_DP p1, double p2,  void (*cb)(float, struct S_DP, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_PI(float p0, struct S_PI p1, double p2,  void (*cb)(float, struct S_PI, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_PF(float p0, struct S_PF p1, double p2,  void (*cb)(float, struct S_PF, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_PD(float p0, struct S_PD p1, double p2,  void (*cb)(float, struct S_PD, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_PP(float p0, struct S_PP p1, double p2,  void (*cb)(float, struct S_PP, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_III(float p0, struct S_III p1, double p2,  void (*cb)(float, struct S_III, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_IIF(float p0, struct S_IIF p1, double p2,  void (*cb)(float, struct S_IIF, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_IID(float p0, struct S_IID p1, double p2,  void (*cb)(float, struct S_IID, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_IIP(float p0, struct S_IIP p1, double p2,  void (*cb)(float, struct S_IIP, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_IFI(float p0, struct S_IFI p1, double p2,  void (*cb)(float, struct S_IFI, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_IFF(float p0, struct S_IFF p1, double p2,  void (*cb)(float, struct S_IFF, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_IFD(float p0, struct S_IFD p1, double p2,  void (*cb)(float, struct S_IFD, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_IFP(float p0, struct S_IFP p1, double p2,  void (*cb)(float, struct S_IFP, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_IDI(float p0, struct S_IDI p1, double p2,  void (*cb)(float, struct S_IDI, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_IDF(float p0, struct S_IDF p1, double p2,  void (*cb)(float, struct S_IDF, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_IDD(float p0, struct S_IDD p1, double p2,  void (*cb)(float, struct S_IDD, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_IDP(float p0, struct S_IDP p1, double p2,  void (*cb)(float, struct S_IDP, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_IPI(float p0, struct S_IPI p1, double p2,  void (*cb)(float, struct S_IPI, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_IPF(float p0, struct S_IPF p1, double p2,  void (*cb)(float, struct S_IPF, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_IPD(float p0, struct S_IPD p1, double p2,  void (*cb)(float, struct S_IPD, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_IPP(float p0, struct S_IPP p1, double p2,  void (*cb)(float, struct S_IPP, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_FII(float p0, struct S_FII p1, double p2,  void (*cb)(float, struct S_FII, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_FIF(float p0, struct S_FIF p1, double p2,  void (*cb)(float, struct S_FIF, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_FID(float p0, struct S_FID p1, double p2,  void (*cb)(float, struct S_FID, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_FIP(float p0, struct S_FIP p1, double p2,  void (*cb)(float, struct S_FIP, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_FFI(float p0, struct S_FFI p1, double p2,  void (*cb)(float, struct S_FFI, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_FFF(float p0, struct S_FFF p1, double p2,  void (*cb)(float, struct S_FFF, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_FFD(float p0, struct S_FFD p1, double p2,  void (*cb)(float, struct S_FFD, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_FFP(float p0, struct S_FFP p1, double p2,  void (*cb)(float, struct S_FFP, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_FDI(float p0, struct S_FDI p1, double p2,  void (*cb)(float, struct S_FDI, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_FDF(float p0, struct S_FDF p1, double p2,  void (*cb)(float, struct S_FDF, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_FDD(float p0, struct S_FDD p1, double p2,  void (*cb)(float, struct S_FDD, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_FDP(float p0, struct S_FDP p1, double p2,  void (*cb)(float, struct S_FDP, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_FPI(float p0, struct S_FPI p1, double p2,  void (*cb)(float, struct S_FPI, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_FPF(float p0, struct S_FPF p1, double p2,  void (*cb)(float, struct S_FPF, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_FPD(float p0, struct S_FPD p1, double p2,  void (*cb)(float, struct S_FPD, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_FPP(float p0, struct S_FPP p1, double p2,  void (*cb)(float, struct S_FPP, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_DII(float p0, struct S_DII p1, double p2,  void (*cb)(float, struct S_DII, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_DIF(float p0, struct S_DIF p1, double p2,  void (*cb)(float, struct S_DIF, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_DID(float p0, struct S_DID p1, double p2,  void (*cb)(float, struct S_DID, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_DIP(float p0, struct S_DIP p1, double p2,  void (*cb)(float, struct S_DIP, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_DFI(float p0, struct S_DFI p1, double p2,  void (*cb)(float, struct S_DFI, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_DFF(float p0, struct S_DFF p1, double p2,  void (*cb)(float, struct S_DFF, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_DFD(float p0, struct S_DFD p1, double p2,  void (*cb)(float, struct S_DFD, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_DFP(float p0, struct S_DFP p1, double p2,  void (*cb)(float, struct S_DFP, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_DDI(float p0, struct S_DDI p1, double p2,  void (*cb)(float, struct S_DDI, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_DDF(float p0, struct S_DDF p1, double p2,  void (*cb)(float, struct S_DDF, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_DDD(float p0, struct S_DDD p1, double p2,  void (*cb)(float, struct S_DDD, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_DDP(float p0, struct S_DDP p1, double p2,  void (*cb)(float, struct S_DDP, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_DPI(float p0, struct S_DPI p1, double p2,  void (*cb)(float, struct S_DPI, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_DPF(float p0, struct S_DPF p1, double p2,  void (*cb)(float, struct S_DPF, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_DPD(float p0, struct S_DPD p1, double p2,  void (*cb)(float, struct S_DPD, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_DPP(float p0, struct S_DPP p1, double p2,  void (*cb)(float, struct S_DPP, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_PII(float p0, struct S_PII p1, double p2,  void (*cb)(float, struct S_PII, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_PIF(float p0, struct S_PIF p1, double p2,  void (*cb)(float, struct S_PIF, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_PID(float p0, struct S_PID p1, double p2,  void (*cb)(float, struct S_PID, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_PIP(float p0, struct S_PIP p1, double p2,  void (*cb)(float, struct S_PIP, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_PFI(float p0, struct S_PFI p1, double p2,  void (*cb)(float, struct S_PFI, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_PFF(float p0, struct S_PFF p1, double p2,  void (*cb)(float, struct S_PFF, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_PFD(float p0, struct S_PFD p1, double p2,  void (*cb)(float, struct S_PFD, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_PFP(float p0, struct S_PFP p1, double p2,  void (*cb)(float, struct S_PFP, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_PDI(float p0, struct S_PDI p1, double p2,  void (*cb)(float, struct S_PDI, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_PDF(float p0, struct S_PDF p1, double p2,  void (*cb)(float, struct S_PDF, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_PDD(float p0, struct S_PDD p1, double p2,  void (*cb)(float, struct S_PDD, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_PDP(float p0, struct S_PDP p1, double p2,  void (*cb)(float, struct S_PDP, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_PPI(float p0, struct S_PPI p1, double p2,  void (*cb)(float, struct S_PPI, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_PPF(float p0, struct S_PPF p1, double p2,  void (*cb)(float, struct S_PPF, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_PPD(float p0, struct S_PPD p1, double p2,  void (*cb)(float, struct S_PPD, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSD_PPP(float p0, struct S_PPP p1, double p2,  void (*cb)(float, struct S_PPP, double)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_I(float p0, struct S_I p1, void* p2,  void (*cb)(float, struct S_I, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_F(float p0, struct S_F p1, void* p2,  void (*cb)(float, struct S_F, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_D(float p0, struct S_D p1, void* p2,  void (*cb)(float, struct S_D, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_P(float p0, struct S_P p1, void* p2,  void (*cb)(float, struct S_P, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_II(float p0, struct S_II p1, void* p2,  void (*cb)(float, struct S_II, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_IF(float p0, struct S_IF p1, void* p2,  void (*cb)(float, struct S_IF, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_ID(float p0, struct S_ID p1, void* p2,  void (*cb)(float, struct S_ID, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_IP(float p0, struct S_IP p1, void* p2,  void (*cb)(float, struct S_IP, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_FI(float p0, struct S_FI p1, void* p2,  void (*cb)(float, struct S_FI, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_FF(float p0, struct S_FF p1, void* p2,  void (*cb)(float, struct S_FF, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_FD(float p0, struct S_FD p1, void* p2,  void (*cb)(float, struct S_FD, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_FP(float p0, struct S_FP p1, void* p2,  void (*cb)(float, struct S_FP, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_DI(float p0, struct S_DI p1, void* p2,  void (*cb)(float, struct S_DI, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_DF(float p0, struct S_DF p1, void* p2,  void (*cb)(float, struct S_DF, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_DD(float p0, struct S_DD p1, void* p2,  void (*cb)(float, struct S_DD, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_DP(float p0, struct S_DP p1, void* p2,  void (*cb)(float, struct S_DP, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_PI(float p0, struct S_PI p1, void* p2,  void (*cb)(float, struct S_PI, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_PF(float p0, struct S_PF p1, void* p2,  void (*cb)(float, struct S_PF, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_PD(float p0, struct S_PD p1, void* p2,  void (*cb)(float, struct S_PD, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_PP(float p0, struct S_PP p1, void* p2,  void (*cb)(float, struct S_PP, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_III(float p0, struct S_III p1, void* p2,  void (*cb)(float, struct S_III, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_IIF(float p0, struct S_IIF p1, void* p2,  void (*cb)(float, struct S_IIF, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_IID(float p0, struct S_IID p1, void* p2,  void (*cb)(float, struct S_IID, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_IIP(float p0, struct S_IIP p1, void* p2,  void (*cb)(float, struct S_IIP, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_IFI(float p0, struct S_IFI p1, void* p2,  void (*cb)(float, struct S_IFI, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_IFF(float p0, struct S_IFF p1, void* p2,  void (*cb)(float, struct S_IFF, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_IFD(float p0, struct S_IFD p1, void* p2,  void (*cb)(float, struct S_IFD, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_IFP(float p0, struct S_IFP p1, void* p2,  void (*cb)(float, struct S_IFP, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_IDI(float p0, struct S_IDI p1, void* p2,  void (*cb)(float, struct S_IDI, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_IDF(float p0, struct S_IDF p1, void* p2,  void (*cb)(float, struct S_IDF, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_IDD(float p0, struct S_IDD p1, void* p2,  void (*cb)(float, struct S_IDD, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_IDP(float p0, struct S_IDP p1, void* p2,  void (*cb)(float, struct S_IDP, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_IPI(float p0, struct S_IPI p1, void* p2,  void (*cb)(float, struct S_IPI, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_IPF(float p0, struct S_IPF p1, void* p2,  void (*cb)(float, struct S_IPF, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_IPD(float p0, struct S_IPD p1, void* p2,  void (*cb)(float, struct S_IPD, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_IPP(float p0, struct S_IPP p1, void* p2,  void (*cb)(float, struct S_IPP, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_FII(float p0, struct S_FII p1, void* p2,  void (*cb)(float, struct S_FII, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_FIF(float p0, struct S_FIF p1, void* p2,  void (*cb)(float, struct S_FIF, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_FID(float p0, struct S_FID p1, void* p2,  void (*cb)(float, struct S_FID, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_FIP(float p0, struct S_FIP p1, void* p2,  void (*cb)(float, struct S_FIP, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_FFI(float p0, struct S_FFI p1, void* p2,  void (*cb)(float, struct S_FFI, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_FFF(float p0, struct S_FFF p1, void* p2,  void (*cb)(float, struct S_FFF, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_FFD(float p0, struct S_FFD p1, void* p2,  void (*cb)(float, struct S_FFD, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_FFP(float p0, struct S_FFP p1, void* p2,  void (*cb)(float, struct S_FFP, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_FDI(float p0, struct S_FDI p1, void* p2,  void (*cb)(float, struct S_FDI, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_FDF(float p0, struct S_FDF p1, void* p2,  void (*cb)(float, struct S_FDF, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_FDD(float p0, struct S_FDD p1, void* p2,  void (*cb)(float, struct S_FDD, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_FDP(float p0, struct S_FDP p1, void* p2,  void (*cb)(float, struct S_FDP, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_FPI(float p0, struct S_FPI p1, void* p2,  void (*cb)(float, struct S_FPI, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_FPF(float p0, struct S_FPF p1, void* p2,  void (*cb)(float, struct S_FPF, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_FPD(float p0, struct S_FPD p1, void* p2,  void (*cb)(float, struct S_FPD, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_FPP(float p0, struct S_FPP p1, void* p2,  void (*cb)(float, struct S_FPP, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_DII(float p0, struct S_DII p1, void* p2,  void (*cb)(float, struct S_DII, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_DIF(float p0, struct S_DIF p1, void* p2,  void (*cb)(float, struct S_DIF, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_DID(float p0, struct S_DID p1, void* p2,  void (*cb)(float, struct S_DID, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_DIP(float p0, struct S_DIP p1, void* p2,  void (*cb)(float, struct S_DIP, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_DFI(float p0, struct S_DFI p1, void* p2,  void (*cb)(float, struct S_DFI, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_DFF(float p0, struct S_DFF p1, void* p2,  void (*cb)(float, struct S_DFF, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_DFD(float p0, struct S_DFD p1, void* p2,  void (*cb)(float, struct S_DFD, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_DFP(float p0, struct S_DFP p1, void* p2,  void (*cb)(float, struct S_DFP, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_DDI(float p0, struct S_DDI p1, void* p2,  void (*cb)(float, struct S_DDI, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_DDF(float p0, struct S_DDF p1, void* p2,  void (*cb)(float, struct S_DDF, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_DDD(float p0, struct S_DDD p1, void* p2,  void (*cb)(float, struct S_DDD, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_DDP(float p0, struct S_DDP p1, void* p2,  void (*cb)(float, struct S_DDP, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_DPI(float p0, struct S_DPI p1, void* p2,  void (*cb)(float, struct S_DPI, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_DPF(float p0, struct S_DPF p1, void* p2,  void (*cb)(float, struct S_DPF, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_DPD(float p0, struct S_DPD p1, void* p2,  void (*cb)(float, struct S_DPD, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_DPP(float p0, struct S_DPP p1, void* p2,  void (*cb)(float, struct S_DPP, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_PII(float p0, struct S_PII p1, void* p2,  void (*cb)(float, struct S_PII, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_PIF(float p0, struct S_PIF p1, void* p2,  void (*cb)(float, struct S_PIF, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_PID(float p0, struct S_PID p1, void* p2,  void (*cb)(float, struct S_PID, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_PIP(float p0, struct S_PIP p1, void* p2,  void (*cb)(float, struct S_PIP, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_PFI(float p0, struct S_PFI p1, void* p2,  void (*cb)(float, struct S_PFI, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_PFF(float p0, struct S_PFF p1, void* p2,  void (*cb)(float, struct S_PFF, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_PFD(float p0, struct S_PFD p1, void* p2,  void (*cb)(float, struct S_PFD, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_PFP(float p0, struct S_PFP p1, void* p2,  void (*cb)(float, struct S_PFP, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_PDI(float p0, struct S_PDI p1, void* p2,  void (*cb)(float, struct S_PDI, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_PDF(float p0, struct S_PDF p1, void* p2,  void (*cb)(float, struct S_PDF, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_PDD(float p0, struct S_PDD p1, void* p2,  void (*cb)(float, struct S_PDD, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_PDP(float p0, struct S_PDP p1, void* p2,  void (*cb)(float, struct S_PDP, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_PPI(float p0, struct S_PPI p1, void* p2,  void (*cb)(float, struct S_PPI, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_PPF(float p0, struct S_PPF p1, void* p2,  void (*cb)(float, struct S_PPF, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_PPD(float p0, struct S_PPD p1, void* p2,  void (*cb)(float, struct S_PPD, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSP_PPP(float p0, struct S_PPP p1, void* p2,  void (*cb)(float, struct S_PPP, void*)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_I(float p0, struct S_I p1, struct S_I p2,  void (*cb)(float, struct S_I, struct S_I)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_F(float p0, struct S_F p1, struct S_F p2,  void (*cb)(float, struct S_F, struct S_F)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_D(float p0, struct S_D p1, struct S_D p2,  void (*cb)(float, struct S_D, struct S_D)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_P(float p0, struct S_P p1, struct S_P p2,  void (*cb)(float, struct S_P, struct S_P)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_II(float p0, struct S_II p1, struct S_II p2,  void (*cb)(float, struct S_II, struct S_II)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_IF(float p0, struct S_IF p1, struct S_IF p2,  void (*cb)(float, struct S_IF, struct S_IF)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_ID(float p0, struct S_ID p1, struct S_ID p2,  void (*cb)(float, struct S_ID, struct S_ID)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_IP(float p0, struct S_IP p1, struct S_IP p2,  void (*cb)(float, struct S_IP, struct S_IP)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_FI(float p0, struct S_FI p1, struct S_FI p2,  void (*cb)(float, struct S_FI, struct S_FI)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_FF(float p0, struct S_FF p1, struct S_FF p2,  void (*cb)(float, struct S_FF, struct S_FF)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_FD(float p0, struct S_FD p1, struct S_FD p2,  void (*cb)(float, struct S_FD, struct S_FD)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_FP(float p0, struct S_FP p1, struct S_FP p2,  void (*cb)(float, struct S_FP, struct S_FP)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_DI(float p0, struct S_DI p1, struct S_DI p2,  void (*cb)(float, struct S_DI, struct S_DI)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_DF(float p0, struct S_DF p1, struct S_DF p2,  void (*cb)(float, struct S_DF, struct S_DF)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_DD(float p0, struct S_DD p1, struct S_DD p2,  void (*cb)(float, struct S_DD, struct S_DD)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_DP(float p0, struct S_DP p1, struct S_DP p2,  void (*cb)(float, struct S_DP, struct S_DP)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_PI(float p0, struct S_PI p1, struct S_PI p2,  void (*cb)(float, struct S_PI, struct S_PI)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_PF(float p0, struct S_PF p1, struct S_PF p2,  void (*cb)(float, struct S_PF, struct S_PF)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_PD(float p0, struct S_PD p1, struct S_PD p2,  void (*cb)(float, struct S_PD, struct S_PD)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_PP(float p0, struct S_PP p1, struct S_PP p2,  void (*cb)(float, struct S_PP, struct S_PP)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_III(float p0, struct S_III p1, struct S_III p2,  void (*cb)(float, struct S_III, struct S_III)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_IIF(float p0, struct S_IIF p1, struct S_IIF p2,  void (*cb)(float, struct S_IIF, struct S_IIF)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_IID(float p0, struct S_IID p1, struct S_IID p2,  void (*cb)(float, struct S_IID, struct S_IID)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_IIP(float p0, struct S_IIP p1, struct S_IIP p2,  void (*cb)(float, struct S_IIP, struct S_IIP)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_IFI(float p0, struct S_IFI p1, struct S_IFI p2,  void (*cb)(float, struct S_IFI, struct S_IFI)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_IFF(float p0, struct S_IFF p1, struct S_IFF p2,  void (*cb)(float, struct S_IFF, struct S_IFF)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_IFD(float p0, struct S_IFD p1, struct S_IFD p2,  void (*cb)(float, struct S_IFD, struct S_IFD)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_IFP(float p0, struct S_IFP p1, struct S_IFP p2,  void (*cb)(float, struct S_IFP, struct S_IFP)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_IDI(float p0, struct S_IDI p1, struct S_IDI p2,  void (*cb)(float, struct S_IDI, struct S_IDI)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_IDF(float p0, struct S_IDF p1, struct S_IDF p2,  void (*cb)(float, struct S_IDF, struct S_IDF)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_IDD(float p0, struct S_IDD p1, struct S_IDD p2,  void (*cb)(float, struct S_IDD, struct S_IDD)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_IDP(float p0, struct S_IDP p1, struct S_IDP p2,  void (*cb)(float, struct S_IDP, struct S_IDP)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_IPI(float p0, struct S_IPI p1, struct S_IPI p2,  void (*cb)(float, struct S_IPI, struct S_IPI)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_IPF(float p0, struct S_IPF p1, struct S_IPF p2,  void (*cb)(float, struct S_IPF, struct S_IPF)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_IPD(float p0, struct S_IPD p1, struct S_IPD p2,  void (*cb)(float, struct S_IPD, struct S_IPD)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_IPP(float p0, struct S_IPP p1, struct S_IPP p2,  void (*cb)(float, struct S_IPP, struct S_IPP)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_FII(float p0, struct S_FII p1, struct S_FII p2,  void (*cb)(float, struct S_FII, struct S_FII)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_FIF(float p0, struct S_FIF p1, struct S_FIF p2,  void (*cb)(float, struct S_FIF, struct S_FIF)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_FID(float p0, struct S_FID p1, struct S_FID p2,  void (*cb)(float, struct S_FID, struct S_FID)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_FIP(float p0, struct S_FIP p1, struct S_FIP p2,  void (*cb)(float, struct S_FIP, struct S_FIP)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_FFI(float p0, struct S_FFI p1, struct S_FFI p2,  void (*cb)(float, struct S_FFI, struct S_FFI)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_FFF(float p0, struct S_FFF p1, struct S_FFF p2,  void (*cb)(float, struct S_FFF, struct S_FFF)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_FFD(float p0, struct S_FFD p1, struct S_FFD p2,  void (*cb)(float, struct S_FFD, struct S_FFD)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_FFP(float p0, struct S_FFP p1, struct S_FFP p2,  void (*cb)(float, struct S_FFP, struct S_FFP)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_FDI(float p0, struct S_FDI p1, struct S_FDI p2,  void (*cb)(float, struct S_FDI, struct S_FDI)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_FDF(float p0, struct S_FDF p1, struct S_FDF p2,  void (*cb)(float, struct S_FDF, struct S_FDF)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_FDD(float p0, struct S_FDD p1, struct S_FDD p2,  void (*cb)(float, struct S_FDD, struct S_FDD)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_FDP(float p0, struct S_FDP p1, struct S_FDP p2,  void (*cb)(float, struct S_FDP, struct S_FDP)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_FPI(float p0, struct S_FPI p1, struct S_FPI p2,  void (*cb)(float, struct S_FPI, struct S_FPI)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_FPF(float p0, struct S_FPF p1, struct S_FPF p2,  void (*cb)(float, struct S_FPF, struct S_FPF)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_FPD(float p0, struct S_FPD p1, struct S_FPD p2,  void (*cb)(float, struct S_FPD, struct S_FPD)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_FPP(float p0, struct S_FPP p1, struct S_FPP p2,  void (*cb)(float, struct S_FPP, struct S_FPP)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_DII(float p0, struct S_DII p1, struct S_DII p2,  void (*cb)(float, struct S_DII, struct S_DII)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_DIF(float p0, struct S_DIF p1, struct S_DIF p2,  void (*cb)(float, struct S_DIF, struct S_DIF)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_DID(float p0, struct S_DID p1, struct S_DID p2,  void (*cb)(float, struct S_DID, struct S_DID)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_DIP(float p0, struct S_DIP p1, struct S_DIP p2,  void (*cb)(float, struct S_DIP, struct S_DIP)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_DFI(float p0, struct S_DFI p1, struct S_DFI p2,  void (*cb)(float, struct S_DFI, struct S_DFI)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_DFF(float p0, struct S_DFF p1, struct S_DFF p2,  void (*cb)(float, struct S_DFF, struct S_DFF)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_DFD(float p0, struct S_DFD p1, struct S_DFD p2,  void (*cb)(float, struct S_DFD, struct S_DFD)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_DFP(float p0, struct S_DFP p1, struct S_DFP p2,  void (*cb)(float, struct S_DFP, struct S_DFP)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_DDI(float p0, struct S_DDI p1, struct S_DDI p2,  void (*cb)(float, struct S_DDI, struct S_DDI)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_DDF(float p0, struct S_DDF p1, struct S_DDF p2,  void (*cb)(float, struct S_DDF, struct S_DDF)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_DDD(float p0, struct S_DDD p1, struct S_DDD p2,  void (*cb)(float, struct S_DDD, struct S_DDD)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_DDP(float p0, struct S_DDP p1, struct S_DDP p2,  void (*cb)(float, struct S_DDP, struct S_DDP)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_DPI(float p0, struct S_DPI p1, struct S_DPI p2,  void (*cb)(float, struct S_DPI, struct S_DPI)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_DPF(float p0, struct S_DPF p1, struct S_DPF p2,  void (*cb)(float, struct S_DPF, struct S_DPF)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_DPD(float p0, struct S_DPD p1, struct S_DPD p2,  void (*cb)(float, struct S_DPD, struct S_DPD)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_DPP(float p0, struct S_DPP p1, struct S_DPP p2,  void (*cb)(float, struct S_DPP, struct S_DPP)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_PII(float p0, struct S_PII p1, struct S_PII p2,  void (*cb)(float, struct S_PII, struct S_PII)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_PIF(float p0, struct S_PIF p1, struct S_PIF p2,  void (*cb)(float, struct S_PIF, struct S_PIF)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_PID(float p0, struct S_PID p1, struct S_PID p2,  void (*cb)(float, struct S_PID, struct S_PID)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_PIP(float p0, struct S_PIP p1, struct S_PIP p2,  void (*cb)(float, struct S_PIP, struct S_PIP)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_PFI(float p0, struct S_PFI p1, struct S_PFI p2,  void (*cb)(float, struct S_PFI, struct S_PFI)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_PFF(float p0, struct S_PFF p1, struct S_PFF p2,  void (*cb)(float, struct S_PFF, struct S_PFF)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_PFD(float p0, struct S_PFD p1, struct S_PFD p2,  void (*cb)(float, struct S_PFD, struct S_PFD)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_PFP(float p0, struct S_PFP p1, struct S_PFP p2,  void (*cb)(float, struct S_PFP, struct S_PFP)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_PDI(float p0, struct S_PDI p1, struct S_PDI p2,  void (*cb)(float, struct S_PDI, struct S_PDI)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_PDF(float p0, struct S_PDF p1, struct S_PDF p2,  void (*cb)(float, struct S_PDF, struct S_PDF)) { cb(p0,p1,p2); }
+EXPORT void f3_V_FSS_PDD(float p0, struct S_PDD p1, struct S_PDD p2,  void (*cb)(float, struct S_PDD, struct S_PDD)) { cb(p0,p1,p2); }
+EXPORT void f4_V_FSS_PDP(float p0, struct S_PDP p1, struct S_PDP p2,  void (*cb)(float, struct S_PDP, struct S_PDP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_FSS_PPI(float p0, struct S_PPI p1, struct S_PPI p2,  void (*cb)(float, struct S_PPI, struct S_PPI)) { cb(p0,p1,p2); }
+EXPORT void f4_V_FSS_PPF(float p0, struct S_PPF p1, struct S_PPF p2,  void (*cb)(float, struct S_PPF, struct S_PPF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_FSS_PPD(float p0, struct S_PPD p1, struct S_PPD p2,  void (*cb)(float, struct S_PPD, struct S_PPD)) { cb(p0,p1,p2); }
+EXPORT void f4_V_FSS_PPP(float p0, struct S_PPP p1, struct S_PPP p2,  void (*cb)(float, struct S_PPP, struct S_PPP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DII_(double p0, int p1, int p2,  void (*cb)(double, int, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIF_(double p0, int p1, float p2,  void (*cb)(double, int, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DID_(double p0, int p1, double p2,  void (*cb)(double, int, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIP_(double p0, int p1, void* p2,  void (*cb)(double, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_I(double p0, int p1, struct S_I p2,  void (*cb)(double, int, struct S_I)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_F(double p0, int p1, struct S_F p2,  void (*cb)(double, int, struct S_F)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_D(double p0, int p1, struct S_D p2,  void (*cb)(double, int, struct S_D)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_P(double p0, int p1, struct S_P p2,  void (*cb)(double, int, struct S_P)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_II(double p0, int p1, struct S_II p2,  void (*cb)(double, int, struct S_II)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_IF(double p0, int p1, struct S_IF p2,  void (*cb)(double, int, struct S_IF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_ID(double p0, int p1, struct S_ID p2,  void (*cb)(double, int, struct S_ID)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_IP(double p0, int p1, struct S_IP p2,  void (*cb)(double, int, struct S_IP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_FI(double p0, int p1, struct S_FI p2,  void (*cb)(double, int, struct S_FI)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_FF(double p0, int p1, struct S_FF p2,  void (*cb)(double, int, struct S_FF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_FD(double p0, int p1, struct S_FD p2,  void (*cb)(double, int, struct S_FD)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_FP(double p0, int p1, struct S_FP p2,  void (*cb)(double, int, struct S_FP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_DI(double p0, int p1, struct S_DI p2,  void (*cb)(double, int, struct S_DI)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_DF(double p0, int p1, struct S_DF p2,  void (*cb)(double, int, struct S_DF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_DD(double p0, int p1, struct S_DD p2,  void (*cb)(double, int, struct S_DD)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_DP(double p0, int p1, struct S_DP p2,  void (*cb)(double, int, struct S_DP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_PI(double p0, int p1, struct S_PI p2,  void (*cb)(double, int, struct S_PI)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_PF(double p0, int p1, struct S_PF p2,  void (*cb)(double, int, struct S_PF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_PD(double p0, int p1, struct S_PD p2,  void (*cb)(double, int, struct S_PD)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_PP(double p0, int p1, struct S_PP p2,  void (*cb)(double, int, struct S_PP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_III(double p0, int p1, struct S_III p2,  void (*cb)(double, int, struct S_III)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_IIF(double p0, int p1, struct S_IIF p2,  void (*cb)(double, int, struct S_IIF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_IID(double p0, int p1, struct S_IID p2,  void (*cb)(double, int, struct S_IID)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_IIP(double p0, int p1, struct S_IIP p2,  void (*cb)(double, int, struct S_IIP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_IFI(double p0, int p1, struct S_IFI p2,  void (*cb)(double, int, struct S_IFI)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_IFF(double p0, int p1, struct S_IFF p2,  void (*cb)(double, int, struct S_IFF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_IFD(double p0, int p1, struct S_IFD p2,  void (*cb)(double, int, struct S_IFD)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_IFP(double p0, int p1, struct S_IFP p2,  void (*cb)(double, int, struct S_IFP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_IDI(double p0, int p1, struct S_IDI p2,  void (*cb)(double, int, struct S_IDI)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_IDF(double p0, int p1, struct S_IDF p2,  void (*cb)(double, int, struct S_IDF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_IDD(double p0, int p1, struct S_IDD p2,  void (*cb)(double, int, struct S_IDD)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_IDP(double p0, int p1, struct S_IDP p2,  void (*cb)(double, int, struct S_IDP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_IPI(double p0, int p1, struct S_IPI p2,  void (*cb)(double, int, struct S_IPI)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_IPF(double p0, int p1, struct S_IPF p2,  void (*cb)(double, int, struct S_IPF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_IPD(double p0, int p1, struct S_IPD p2,  void (*cb)(double, int, struct S_IPD)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_IPP(double p0, int p1, struct S_IPP p2,  void (*cb)(double, int, struct S_IPP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_FII(double p0, int p1, struct S_FII p2,  void (*cb)(double, int, struct S_FII)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_FIF(double p0, int p1, struct S_FIF p2,  void (*cb)(double, int, struct S_FIF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_FID(double p0, int p1, struct S_FID p2,  void (*cb)(double, int, struct S_FID)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_FIP(double p0, int p1, struct S_FIP p2,  void (*cb)(double, int, struct S_FIP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_FFI(double p0, int p1, struct S_FFI p2,  void (*cb)(double, int, struct S_FFI)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_FFF(double p0, int p1, struct S_FFF p2,  void (*cb)(double, int, struct S_FFF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_FFD(double p0, int p1, struct S_FFD p2,  void (*cb)(double, int, struct S_FFD)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_FFP(double p0, int p1, struct S_FFP p2,  void (*cb)(double, int, struct S_FFP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_FDI(double p0, int p1, struct S_FDI p2,  void (*cb)(double, int, struct S_FDI)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_FDF(double p0, int p1, struct S_FDF p2,  void (*cb)(double, int, struct S_FDF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_FDD(double p0, int p1, struct S_FDD p2,  void (*cb)(double, int, struct S_FDD)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_FDP(double p0, int p1, struct S_FDP p2,  void (*cb)(double, int, struct S_FDP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_FPI(double p0, int p1, struct S_FPI p2,  void (*cb)(double, int, struct S_FPI)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_FPF(double p0, int p1, struct S_FPF p2,  void (*cb)(double, int, struct S_FPF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_FPD(double p0, int p1, struct S_FPD p2,  void (*cb)(double, int, struct S_FPD)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_FPP(double p0, int p1, struct S_FPP p2,  void (*cb)(double, int, struct S_FPP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_DII(double p0, int p1, struct S_DII p2,  void (*cb)(double, int, struct S_DII)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_DIF(double p0, int p1, struct S_DIF p2,  void (*cb)(double, int, struct S_DIF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_DID(double p0, int p1, struct S_DID p2,  void (*cb)(double, int, struct S_DID)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_DIP(double p0, int p1, struct S_DIP p2,  void (*cb)(double, int, struct S_DIP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_DFI(double p0, int p1, struct S_DFI p2,  void (*cb)(double, int, struct S_DFI)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_DFF(double p0, int p1, struct S_DFF p2,  void (*cb)(double, int, struct S_DFF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_DFD(double p0, int p1, struct S_DFD p2,  void (*cb)(double, int, struct S_DFD)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_DFP(double p0, int p1, struct S_DFP p2,  void (*cb)(double, int, struct S_DFP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_DDI(double p0, int p1, struct S_DDI p2,  void (*cb)(double, int, struct S_DDI)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_DDF(double p0, int p1, struct S_DDF p2,  void (*cb)(double, int, struct S_DDF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_DDD(double p0, int p1, struct S_DDD p2,  void (*cb)(double, int, struct S_DDD)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_DDP(double p0, int p1, struct S_DDP p2,  void (*cb)(double, int, struct S_DDP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_DPI(double p0, int p1, struct S_DPI p2,  void (*cb)(double, int, struct S_DPI)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_DPF(double p0, int p1, struct S_DPF p2,  void (*cb)(double, int, struct S_DPF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_DPD(double p0, int p1, struct S_DPD p2,  void (*cb)(double, int, struct S_DPD)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_DPP(double p0, int p1, struct S_DPP p2,  void (*cb)(double, int, struct S_DPP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_PII(double p0, int p1, struct S_PII p2,  void (*cb)(double, int, struct S_PII)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_PIF(double p0, int p1, struct S_PIF p2,  void (*cb)(double, int, struct S_PIF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_PID(double p0, int p1, struct S_PID p2,  void (*cb)(double, int, struct S_PID)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_PIP(double p0, int p1, struct S_PIP p2,  void (*cb)(double, int, struct S_PIP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_PFI(double p0, int p1, struct S_PFI p2,  void (*cb)(double, int, struct S_PFI)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_PFF(double p0, int p1, struct S_PFF p2,  void (*cb)(double, int, struct S_PFF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_PFD(double p0, int p1, struct S_PFD p2,  void (*cb)(double, int, struct S_PFD)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_PFP(double p0, int p1, struct S_PFP p2,  void (*cb)(double, int, struct S_PFP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_PDI(double p0, int p1, struct S_PDI p2,  void (*cb)(double, int, struct S_PDI)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_PDF(double p0, int p1, struct S_PDF p2,  void (*cb)(double, int, struct S_PDF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_PDD(double p0, int p1, struct S_PDD p2,  void (*cb)(double, int, struct S_PDD)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_PDP(double p0, int p1, struct S_PDP p2,  void (*cb)(double, int, struct S_PDP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_PPI(double p0, int p1, struct S_PPI p2,  void (*cb)(double, int, struct S_PPI)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_PPF(double p0, int p1, struct S_PPF p2,  void (*cb)(double, int, struct S_PPF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_PPD(double p0, int p1, struct S_PPD p2,  void (*cb)(double, int, struct S_PPD)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DIS_PPP(double p0, int p1, struct S_PPP p2,  void (*cb)(double, int, struct S_PPP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFI_(double p0, float p1, int p2,  void (*cb)(double, float, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFF_(double p0, float p1, float p2,  void (*cb)(double, float, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFD_(double p0, float p1, double p2,  void (*cb)(double, float, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFP_(double p0, float p1, void* p2,  void (*cb)(double, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_I(double p0, float p1, struct S_I p2,  void (*cb)(double, float, struct S_I)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_F(double p0, float p1, struct S_F p2,  void (*cb)(double, float, struct S_F)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_D(double p0, float p1, struct S_D p2,  void (*cb)(double, float, struct S_D)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_P(double p0, float p1, struct S_P p2,  void (*cb)(double, float, struct S_P)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_II(double p0, float p1, struct S_II p2,  void (*cb)(double, float, struct S_II)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_IF(double p0, float p1, struct S_IF p2,  void (*cb)(double, float, struct S_IF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_ID(double p0, float p1, struct S_ID p2,  void (*cb)(double, float, struct S_ID)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_IP(double p0, float p1, struct S_IP p2,  void (*cb)(double, float, struct S_IP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_FI(double p0, float p1, struct S_FI p2,  void (*cb)(double, float, struct S_FI)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_FF(double p0, float p1, struct S_FF p2,  void (*cb)(double, float, struct S_FF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_FD(double p0, float p1, struct S_FD p2,  void (*cb)(double, float, struct S_FD)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_FP(double p0, float p1, struct S_FP p2,  void (*cb)(double, float, struct S_FP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_DI(double p0, float p1, struct S_DI p2,  void (*cb)(double, float, struct S_DI)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_DF(double p0, float p1, struct S_DF p2,  void (*cb)(double, float, struct S_DF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_DD(double p0, float p1, struct S_DD p2,  void (*cb)(double, float, struct S_DD)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_DP(double p0, float p1, struct S_DP p2,  void (*cb)(double, float, struct S_DP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_PI(double p0, float p1, struct S_PI p2,  void (*cb)(double, float, struct S_PI)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_PF(double p0, float p1, struct S_PF p2,  void (*cb)(double, float, struct S_PF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_PD(double p0, float p1, struct S_PD p2,  void (*cb)(double, float, struct S_PD)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_PP(double p0, float p1, struct S_PP p2,  void (*cb)(double, float, struct S_PP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_III(double p0, float p1, struct S_III p2,  void (*cb)(double, float, struct S_III)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_IIF(double p0, float p1, struct S_IIF p2,  void (*cb)(double, float, struct S_IIF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_IID(double p0, float p1, struct S_IID p2,  void (*cb)(double, float, struct S_IID)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_IIP(double p0, float p1, struct S_IIP p2,  void (*cb)(double, float, struct S_IIP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_IFI(double p0, float p1, struct S_IFI p2,  void (*cb)(double, float, struct S_IFI)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_IFF(double p0, float p1, struct S_IFF p2,  void (*cb)(double, float, struct S_IFF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_IFD(double p0, float p1, struct S_IFD p2,  void (*cb)(double, float, struct S_IFD)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_IFP(double p0, float p1, struct S_IFP p2,  void (*cb)(double, float, struct S_IFP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_IDI(double p0, float p1, struct S_IDI p2,  void (*cb)(double, float, struct S_IDI)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_IDF(double p0, float p1, struct S_IDF p2,  void (*cb)(double, float, struct S_IDF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_IDD(double p0, float p1, struct S_IDD p2,  void (*cb)(double, float, struct S_IDD)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_IDP(double p0, float p1, struct S_IDP p2,  void (*cb)(double, float, struct S_IDP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_IPI(double p0, float p1, struct S_IPI p2,  void (*cb)(double, float, struct S_IPI)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_IPF(double p0, float p1, struct S_IPF p2,  void (*cb)(double, float, struct S_IPF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_IPD(double p0, float p1, struct S_IPD p2,  void (*cb)(double, float, struct S_IPD)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_IPP(double p0, float p1, struct S_IPP p2,  void (*cb)(double, float, struct S_IPP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_FII(double p0, float p1, struct S_FII p2,  void (*cb)(double, float, struct S_FII)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_FIF(double p0, float p1, struct S_FIF p2,  void (*cb)(double, float, struct S_FIF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_FID(double p0, float p1, struct S_FID p2,  void (*cb)(double, float, struct S_FID)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_FIP(double p0, float p1, struct S_FIP p2,  void (*cb)(double, float, struct S_FIP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_FFI(double p0, float p1, struct S_FFI p2,  void (*cb)(double, float, struct S_FFI)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_FFF(double p0, float p1, struct S_FFF p2,  void (*cb)(double, float, struct S_FFF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_FFD(double p0, float p1, struct S_FFD p2,  void (*cb)(double, float, struct S_FFD)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_FFP(double p0, float p1, struct S_FFP p2,  void (*cb)(double, float, struct S_FFP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_FDI(double p0, float p1, struct S_FDI p2,  void (*cb)(double, float, struct S_FDI)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_FDF(double p0, float p1, struct S_FDF p2,  void (*cb)(double, float, struct S_FDF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_FDD(double p0, float p1, struct S_FDD p2,  void (*cb)(double, float, struct S_FDD)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_FDP(double p0, float p1, struct S_FDP p2,  void (*cb)(double, float, struct S_FDP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_FPI(double p0, float p1, struct S_FPI p2,  void (*cb)(double, float, struct S_FPI)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_FPF(double p0, float p1, struct S_FPF p2,  void (*cb)(double, float, struct S_FPF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_FPD(double p0, float p1, struct S_FPD p2,  void (*cb)(double, float, struct S_FPD)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_FPP(double p0, float p1, struct S_FPP p2,  void (*cb)(double, float, struct S_FPP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_DII(double p0, float p1, struct S_DII p2,  void (*cb)(double, float, struct S_DII)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_DIF(double p0, float p1, struct S_DIF p2,  void (*cb)(double, float, struct S_DIF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_DID(double p0, float p1, struct S_DID p2,  void (*cb)(double, float, struct S_DID)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_DIP(double p0, float p1, struct S_DIP p2,  void (*cb)(double, float, struct S_DIP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_DFI(double p0, float p1, struct S_DFI p2,  void (*cb)(double, float, struct S_DFI)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_DFF(double p0, float p1, struct S_DFF p2,  void (*cb)(double, float, struct S_DFF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_DFD(double p0, float p1, struct S_DFD p2,  void (*cb)(double, float, struct S_DFD)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_DFP(double p0, float p1, struct S_DFP p2,  void (*cb)(double, float, struct S_DFP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_DDI(double p0, float p1, struct S_DDI p2,  void (*cb)(double, float, struct S_DDI)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_DDF(double p0, float p1, struct S_DDF p2,  void (*cb)(double, float, struct S_DDF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_DDD(double p0, float p1, struct S_DDD p2,  void (*cb)(double, float, struct S_DDD)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_DDP(double p0, float p1, struct S_DDP p2,  void (*cb)(double, float, struct S_DDP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_DPI(double p0, float p1, struct S_DPI p2,  void (*cb)(double, float, struct S_DPI)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_DPF(double p0, float p1, struct S_DPF p2,  void (*cb)(double, float, struct S_DPF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_DPD(double p0, float p1, struct S_DPD p2,  void (*cb)(double, float, struct S_DPD)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_DPP(double p0, float p1, struct S_DPP p2,  void (*cb)(double, float, struct S_DPP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_PII(double p0, float p1, struct S_PII p2,  void (*cb)(double, float, struct S_PII)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_PIF(double p0, float p1, struct S_PIF p2,  void (*cb)(double, float, struct S_PIF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_PID(double p0, float p1, struct S_PID p2,  void (*cb)(double, float, struct S_PID)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_PIP(double p0, float p1, struct S_PIP p2,  void (*cb)(double, float, struct S_PIP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_PFI(double p0, float p1, struct S_PFI p2,  void (*cb)(double, float, struct S_PFI)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_PFF(double p0, float p1, struct S_PFF p2,  void (*cb)(double, float, struct S_PFF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_PFD(double p0, float p1, struct S_PFD p2,  void (*cb)(double, float, struct S_PFD)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_PFP(double p0, float p1, struct S_PFP p2,  void (*cb)(double, float, struct S_PFP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_PDI(double p0, float p1, struct S_PDI p2,  void (*cb)(double, float, struct S_PDI)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_PDF(double p0, float p1, struct S_PDF p2,  void (*cb)(double, float, struct S_PDF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_PDD(double p0, float p1, struct S_PDD p2,  void (*cb)(double, float, struct S_PDD)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_PDP(double p0, float p1, struct S_PDP p2,  void (*cb)(double, float, struct S_PDP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_PPI(double p0, float p1, struct S_PPI p2,  void (*cb)(double, float, struct S_PPI)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_PPF(double p0, float p1, struct S_PPF p2,  void (*cb)(double, float, struct S_PPF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_PPD(double p0, float p1, struct S_PPD p2,  void (*cb)(double, float, struct S_PPD)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DFS_PPP(double p0, float p1, struct S_PPP p2,  void (*cb)(double, float, struct S_PPP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDI_(double p0, double p1, int p2,  void (*cb)(double, double, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDF_(double p0, double p1, float p2,  void (*cb)(double, double, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDD_(double p0, double p1, double p2,  void (*cb)(double, double, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDP_(double p0, double p1, void* p2,  void (*cb)(double, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_I(double p0, double p1, struct S_I p2,  void (*cb)(double, double, struct S_I)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_F(double p0, double p1, struct S_F p2,  void (*cb)(double, double, struct S_F)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_D(double p0, double p1, struct S_D p2,  void (*cb)(double, double, struct S_D)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_P(double p0, double p1, struct S_P p2,  void (*cb)(double, double, struct S_P)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_II(double p0, double p1, struct S_II p2,  void (*cb)(double, double, struct S_II)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_IF(double p0, double p1, struct S_IF p2,  void (*cb)(double, double, struct S_IF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_ID(double p0, double p1, struct S_ID p2,  void (*cb)(double, double, struct S_ID)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_IP(double p0, double p1, struct S_IP p2,  void (*cb)(double, double, struct S_IP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_FI(double p0, double p1, struct S_FI p2,  void (*cb)(double, double, struct S_FI)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_FF(double p0, double p1, struct S_FF p2,  void (*cb)(double, double, struct S_FF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_FD(double p0, double p1, struct S_FD p2,  void (*cb)(double, double, struct S_FD)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_FP(double p0, double p1, struct S_FP p2,  void (*cb)(double, double, struct S_FP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_DI(double p0, double p1, struct S_DI p2,  void (*cb)(double, double, struct S_DI)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_DF(double p0, double p1, struct S_DF p2,  void (*cb)(double, double, struct S_DF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_DD(double p0, double p1, struct S_DD p2,  void (*cb)(double, double, struct S_DD)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_DP(double p0, double p1, struct S_DP p2,  void (*cb)(double, double, struct S_DP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_PI(double p0, double p1, struct S_PI p2,  void (*cb)(double, double, struct S_PI)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_PF(double p0, double p1, struct S_PF p2,  void (*cb)(double, double, struct S_PF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_PD(double p0, double p1, struct S_PD p2,  void (*cb)(double, double, struct S_PD)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_PP(double p0, double p1, struct S_PP p2,  void (*cb)(double, double, struct S_PP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_III(double p0, double p1, struct S_III p2,  void (*cb)(double, double, struct S_III)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_IIF(double p0, double p1, struct S_IIF p2,  void (*cb)(double, double, struct S_IIF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_IID(double p0, double p1, struct S_IID p2,  void (*cb)(double, double, struct S_IID)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_IIP(double p0, double p1, struct S_IIP p2,  void (*cb)(double, double, struct S_IIP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_IFI(double p0, double p1, struct S_IFI p2,  void (*cb)(double, double, struct S_IFI)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_IFF(double p0, double p1, struct S_IFF p2,  void (*cb)(double, double, struct S_IFF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_IFD(double p0, double p1, struct S_IFD p2,  void (*cb)(double, double, struct S_IFD)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_IFP(double p0, double p1, struct S_IFP p2,  void (*cb)(double, double, struct S_IFP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_IDI(double p0, double p1, struct S_IDI p2,  void (*cb)(double, double, struct S_IDI)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_IDF(double p0, double p1, struct S_IDF p2,  void (*cb)(double, double, struct S_IDF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_IDD(double p0, double p1, struct S_IDD p2,  void (*cb)(double, double, struct S_IDD)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_IDP(double p0, double p1, struct S_IDP p2,  void (*cb)(double, double, struct S_IDP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_IPI(double p0, double p1, struct S_IPI p2,  void (*cb)(double, double, struct S_IPI)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_IPF(double p0, double p1, struct S_IPF p2,  void (*cb)(double, double, struct S_IPF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_IPD(double p0, double p1, struct S_IPD p2,  void (*cb)(double, double, struct S_IPD)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_IPP(double p0, double p1, struct S_IPP p2,  void (*cb)(double, double, struct S_IPP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_FII(double p0, double p1, struct S_FII p2,  void (*cb)(double, double, struct S_FII)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_FIF(double p0, double p1, struct S_FIF p2,  void (*cb)(double, double, struct S_FIF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_FID(double p0, double p1, struct S_FID p2,  void (*cb)(double, double, struct S_FID)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_FIP(double p0, double p1, struct S_FIP p2,  void (*cb)(double, double, struct S_FIP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_FFI(double p0, double p1, struct S_FFI p2,  void (*cb)(double, double, struct S_FFI)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_FFF(double p0, double p1, struct S_FFF p2,  void (*cb)(double, double, struct S_FFF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_FFD(double p0, double p1, struct S_FFD p2,  void (*cb)(double, double, struct S_FFD)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_FFP(double p0, double p1, struct S_FFP p2,  void (*cb)(double, double, struct S_FFP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_FDI(double p0, double p1, struct S_FDI p2,  void (*cb)(double, double, struct S_FDI)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_FDF(double p0, double p1, struct S_FDF p2,  void (*cb)(double, double, struct S_FDF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_FDD(double p0, double p1, struct S_FDD p2,  void (*cb)(double, double, struct S_FDD)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_FDP(double p0, double p1, struct S_FDP p2,  void (*cb)(double, double, struct S_FDP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_FPI(double p0, double p1, struct S_FPI p2,  void (*cb)(double, double, struct S_FPI)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_FPF(double p0, double p1, struct S_FPF p2,  void (*cb)(double, double, struct S_FPF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_FPD(double p0, double p1, struct S_FPD p2,  void (*cb)(double, double, struct S_FPD)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_FPP(double p0, double p1, struct S_FPP p2,  void (*cb)(double, double, struct S_FPP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_DII(double p0, double p1, struct S_DII p2,  void (*cb)(double, double, struct S_DII)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_DIF(double p0, double p1, struct S_DIF p2,  void (*cb)(double, double, struct S_DIF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_DID(double p0, double p1, struct S_DID p2,  void (*cb)(double, double, struct S_DID)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_DIP(double p0, double p1, struct S_DIP p2,  void (*cb)(double, double, struct S_DIP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_DFI(double p0, double p1, struct S_DFI p2,  void (*cb)(double, double, struct S_DFI)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_DFF(double p0, double p1, struct S_DFF p2,  void (*cb)(double, double, struct S_DFF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_DFD(double p0, double p1, struct S_DFD p2,  void (*cb)(double, double, struct S_DFD)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_DFP(double p0, double p1, struct S_DFP p2,  void (*cb)(double, double, struct S_DFP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_DDI(double p0, double p1, struct S_DDI p2,  void (*cb)(double, double, struct S_DDI)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_DDF(double p0, double p1, struct S_DDF p2,  void (*cb)(double, double, struct S_DDF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_DDD(double p0, double p1, struct S_DDD p2,  void (*cb)(double, double, struct S_DDD)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_DDP(double p0, double p1, struct S_DDP p2,  void (*cb)(double, double, struct S_DDP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_DPI(double p0, double p1, struct S_DPI p2,  void (*cb)(double, double, struct S_DPI)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_DPF(double p0, double p1, struct S_DPF p2,  void (*cb)(double, double, struct S_DPF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_DPD(double p0, double p1, struct S_DPD p2,  void (*cb)(double, double, struct S_DPD)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_DPP(double p0, double p1, struct S_DPP p2,  void (*cb)(double, double, struct S_DPP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_PII(double p0, double p1, struct S_PII p2,  void (*cb)(double, double, struct S_PII)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_PIF(double p0, double p1, struct S_PIF p2,  void (*cb)(double, double, struct S_PIF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_PID(double p0, double p1, struct S_PID p2,  void (*cb)(double, double, struct S_PID)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_PIP(double p0, double p1, struct S_PIP p2,  void (*cb)(double, double, struct S_PIP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_PFI(double p0, double p1, struct S_PFI p2,  void (*cb)(double, double, struct S_PFI)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_PFF(double p0, double p1, struct S_PFF p2,  void (*cb)(double, double, struct S_PFF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_PFD(double p0, double p1, struct S_PFD p2,  void (*cb)(double, double, struct S_PFD)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_PFP(double p0, double p1, struct S_PFP p2,  void (*cb)(double, double, struct S_PFP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_PDI(double p0, double p1, struct S_PDI p2,  void (*cb)(double, double, struct S_PDI)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_PDF(double p0, double p1, struct S_PDF p2,  void (*cb)(double, double, struct S_PDF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_PDD(double p0, double p1, struct S_PDD p2,  void (*cb)(double, double, struct S_PDD)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_PDP(double p0, double p1, struct S_PDP p2,  void (*cb)(double, double, struct S_PDP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_PPI(double p0, double p1, struct S_PPI p2,  void (*cb)(double, double, struct S_PPI)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_PPF(double p0, double p1, struct S_PPF p2,  void (*cb)(double, double, struct S_PPF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_PPD(double p0, double p1, struct S_PPD p2,  void (*cb)(double, double, struct S_PPD)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DDS_PPP(double p0, double p1, struct S_PPP p2,  void (*cb)(double, double, struct S_PPP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPI_(double p0, void* p1, int p2,  void (*cb)(double, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPF_(double p0, void* p1, float p2,  void (*cb)(double, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPD_(double p0, void* p1, double p2,  void (*cb)(double, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPP_(double p0, void* p1, void* p2,  void (*cb)(double, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_I(double p0, void* p1, struct S_I p2,  void (*cb)(double, void*, struct S_I)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_F(double p0, void* p1, struct S_F p2,  void (*cb)(double, void*, struct S_F)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_D(double p0, void* p1, struct S_D p2,  void (*cb)(double, void*, struct S_D)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_P(double p0, void* p1, struct S_P p2,  void (*cb)(double, void*, struct S_P)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_II(double p0, void* p1, struct S_II p2,  void (*cb)(double, void*, struct S_II)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_IF(double p0, void* p1, struct S_IF p2,  void (*cb)(double, void*, struct S_IF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_ID(double p0, void* p1, struct S_ID p2,  void (*cb)(double, void*, struct S_ID)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_IP(double p0, void* p1, struct S_IP p2,  void (*cb)(double, void*, struct S_IP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_FI(double p0, void* p1, struct S_FI p2,  void (*cb)(double, void*, struct S_FI)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_FF(double p0, void* p1, struct S_FF p2,  void (*cb)(double, void*, struct S_FF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_FD(double p0, void* p1, struct S_FD p2,  void (*cb)(double, void*, struct S_FD)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_FP(double p0, void* p1, struct S_FP p2,  void (*cb)(double, void*, struct S_FP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_DI(double p0, void* p1, struct S_DI p2,  void (*cb)(double, void*, struct S_DI)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_DF(double p0, void* p1, struct S_DF p2,  void (*cb)(double, void*, struct S_DF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_DD(double p0, void* p1, struct S_DD p2,  void (*cb)(double, void*, struct S_DD)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_DP(double p0, void* p1, struct S_DP p2,  void (*cb)(double, void*, struct S_DP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_PI(double p0, void* p1, struct S_PI p2,  void (*cb)(double, void*, struct S_PI)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_PF(double p0, void* p1, struct S_PF p2,  void (*cb)(double, void*, struct S_PF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_PD(double p0, void* p1, struct S_PD p2,  void (*cb)(double, void*, struct S_PD)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_PP(double p0, void* p1, struct S_PP p2,  void (*cb)(double, void*, struct S_PP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_III(double p0, void* p1, struct S_III p2,  void (*cb)(double, void*, struct S_III)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_IIF(double p0, void* p1, struct S_IIF p2,  void (*cb)(double, void*, struct S_IIF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_IID(double p0, void* p1, struct S_IID p2,  void (*cb)(double, void*, struct S_IID)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_IIP(double p0, void* p1, struct S_IIP p2,  void (*cb)(double, void*, struct S_IIP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_IFI(double p0, void* p1, struct S_IFI p2,  void (*cb)(double, void*, struct S_IFI)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_IFF(double p0, void* p1, struct S_IFF p2,  void (*cb)(double, void*, struct S_IFF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_IFD(double p0, void* p1, struct S_IFD p2,  void (*cb)(double, void*, struct S_IFD)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_IFP(double p0, void* p1, struct S_IFP p2,  void (*cb)(double, void*, struct S_IFP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_IDI(double p0, void* p1, struct S_IDI p2,  void (*cb)(double, void*, struct S_IDI)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_IDF(double p0, void* p1, struct S_IDF p2,  void (*cb)(double, void*, struct S_IDF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_IDD(double p0, void* p1, struct S_IDD p2,  void (*cb)(double, void*, struct S_IDD)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_IDP(double p0, void* p1, struct S_IDP p2,  void (*cb)(double, void*, struct S_IDP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_IPI(double p0, void* p1, struct S_IPI p2,  void (*cb)(double, void*, struct S_IPI)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_IPF(double p0, void* p1, struct S_IPF p2,  void (*cb)(double, void*, struct S_IPF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_IPD(double p0, void* p1, struct S_IPD p2,  void (*cb)(double, void*, struct S_IPD)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_IPP(double p0, void* p1, struct S_IPP p2,  void (*cb)(double, void*, struct S_IPP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_FII(double p0, void* p1, struct S_FII p2,  void (*cb)(double, void*, struct S_FII)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_FIF(double p0, void* p1, struct S_FIF p2,  void (*cb)(double, void*, struct S_FIF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_FID(double p0, void* p1, struct S_FID p2,  void (*cb)(double, void*, struct S_FID)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_FIP(double p0, void* p1, struct S_FIP p2,  void (*cb)(double, void*, struct S_FIP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_FFI(double p0, void* p1, struct S_FFI p2,  void (*cb)(double, void*, struct S_FFI)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_FFF(double p0, void* p1, struct S_FFF p2,  void (*cb)(double, void*, struct S_FFF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_FFD(double p0, void* p1, struct S_FFD p2,  void (*cb)(double, void*, struct S_FFD)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_FFP(double p0, void* p1, struct S_FFP p2,  void (*cb)(double, void*, struct S_FFP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_FDI(double p0, void* p1, struct S_FDI p2,  void (*cb)(double, void*, struct S_FDI)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_FDF(double p0, void* p1, struct S_FDF p2,  void (*cb)(double, void*, struct S_FDF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_FDD(double p0, void* p1, struct S_FDD p2,  void (*cb)(double, void*, struct S_FDD)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_FDP(double p0, void* p1, struct S_FDP p2,  void (*cb)(double, void*, struct S_FDP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_FPI(double p0, void* p1, struct S_FPI p2,  void (*cb)(double, void*, struct S_FPI)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_FPF(double p0, void* p1, struct S_FPF p2,  void (*cb)(double, void*, struct S_FPF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_FPD(double p0, void* p1, struct S_FPD p2,  void (*cb)(double, void*, struct S_FPD)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_FPP(double p0, void* p1, struct S_FPP p2,  void (*cb)(double, void*, struct S_FPP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_DII(double p0, void* p1, struct S_DII p2,  void (*cb)(double, void*, struct S_DII)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_DIF(double p0, void* p1, struct S_DIF p2,  void (*cb)(double, void*, struct S_DIF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_DID(double p0, void* p1, struct S_DID p2,  void (*cb)(double, void*, struct S_DID)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_DIP(double p0, void* p1, struct S_DIP p2,  void (*cb)(double, void*, struct S_DIP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_DFI(double p0, void* p1, struct S_DFI p2,  void (*cb)(double, void*, struct S_DFI)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_DFF(double p0, void* p1, struct S_DFF p2,  void (*cb)(double, void*, struct S_DFF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_DFD(double p0, void* p1, struct S_DFD p2,  void (*cb)(double, void*, struct S_DFD)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_DFP(double p0, void* p1, struct S_DFP p2,  void (*cb)(double, void*, struct S_DFP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_DDI(double p0, void* p1, struct S_DDI p2,  void (*cb)(double, void*, struct S_DDI)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_DDF(double p0, void* p1, struct S_DDF p2,  void (*cb)(double, void*, struct S_DDF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_DDD(double p0, void* p1, struct S_DDD p2,  void (*cb)(double, void*, struct S_DDD)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_DDP(double p0, void* p1, struct S_DDP p2,  void (*cb)(double, void*, struct S_DDP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_DPI(double p0, void* p1, struct S_DPI p2,  void (*cb)(double, void*, struct S_DPI)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_DPF(double p0, void* p1, struct S_DPF p2,  void (*cb)(double, void*, struct S_DPF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_DPD(double p0, void* p1, struct S_DPD p2,  void (*cb)(double, void*, struct S_DPD)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_DPP(double p0, void* p1, struct S_DPP p2,  void (*cb)(double, void*, struct S_DPP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_PII(double p0, void* p1, struct S_PII p2,  void (*cb)(double, void*, struct S_PII)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_PIF(double p0, void* p1, struct S_PIF p2,  void (*cb)(double, void*, struct S_PIF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_PID(double p0, void* p1, struct S_PID p2,  void (*cb)(double, void*, struct S_PID)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_PIP(double p0, void* p1, struct S_PIP p2,  void (*cb)(double, void*, struct S_PIP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_PFI(double p0, void* p1, struct S_PFI p2,  void (*cb)(double, void*, struct S_PFI)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_PFF(double p0, void* p1, struct S_PFF p2,  void (*cb)(double, void*, struct S_PFF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_PFD(double p0, void* p1, struct S_PFD p2,  void (*cb)(double, void*, struct S_PFD)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_PFP(double p0, void* p1, struct S_PFP p2,  void (*cb)(double, void*, struct S_PFP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_PDI(double p0, void* p1, struct S_PDI p2,  void (*cb)(double, void*, struct S_PDI)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_PDF(double p0, void* p1, struct S_PDF p2,  void (*cb)(double, void*, struct S_PDF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_PDD(double p0, void* p1, struct S_PDD p2,  void (*cb)(double, void*, struct S_PDD)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_PDP(double p0, void* p1, struct S_PDP p2,  void (*cb)(double, void*, struct S_PDP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_PPI(double p0, void* p1, struct S_PPI p2,  void (*cb)(double, void*, struct S_PPI)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_PPF(double p0, void* p1, struct S_PPF p2,  void (*cb)(double, void*, struct S_PPF)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_PPD(double p0, void* p1, struct S_PPD p2,  void (*cb)(double, void*, struct S_PPD)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DPS_PPP(double p0, void* p1, struct S_PPP p2,  void (*cb)(double, void*, struct S_PPP)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_I(double p0, struct S_I p1, int p2,  void (*cb)(double, struct S_I, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_F(double p0, struct S_F p1, int p2,  void (*cb)(double, struct S_F, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_D(double p0, struct S_D p1, int p2,  void (*cb)(double, struct S_D, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_P(double p0, struct S_P p1, int p2,  void (*cb)(double, struct S_P, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_II(double p0, struct S_II p1, int p2,  void (*cb)(double, struct S_II, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_IF(double p0, struct S_IF p1, int p2,  void (*cb)(double, struct S_IF, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_ID(double p0, struct S_ID p1, int p2,  void (*cb)(double, struct S_ID, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_IP(double p0, struct S_IP p1, int p2,  void (*cb)(double, struct S_IP, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_FI(double p0, struct S_FI p1, int p2,  void (*cb)(double, struct S_FI, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_FF(double p0, struct S_FF p1, int p2,  void (*cb)(double, struct S_FF, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_FD(double p0, struct S_FD p1, int p2,  void (*cb)(double, struct S_FD, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_FP(double p0, struct S_FP p1, int p2,  void (*cb)(double, struct S_FP, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_DI(double p0, struct S_DI p1, int p2,  void (*cb)(double, struct S_DI, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_DF(double p0, struct S_DF p1, int p2,  void (*cb)(double, struct S_DF, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_DD(double p0, struct S_DD p1, int p2,  void (*cb)(double, struct S_DD, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_DP(double p0, struct S_DP p1, int p2,  void (*cb)(double, struct S_DP, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_PI(double p0, struct S_PI p1, int p2,  void (*cb)(double, struct S_PI, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_PF(double p0, struct S_PF p1, int p2,  void (*cb)(double, struct S_PF, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_PD(double p0, struct S_PD p1, int p2,  void (*cb)(double, struct S_PD, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_PP(double p0, struct S_PP p1, int p2,  void (*cb)(double, struct S_PP, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_III(double p0, struct S_III p1, int p2,  void (*cb)(double, struct S_III, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_IIF(double p0, struct S_IIF p1, int p2,  void (*cb)(double, struct S_IIF, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_IID(double p0, struct S_IID p1, int p2,  void (*cb)(double, struct S_IID, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_IIP(double p0, struct S_IIP p1, int p2,  void (*cb)(double, struct S_IIP, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_IFI(double p0, struct S_IFI p1, int p2,  void (*cb)(double, struct S_IFI, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_IFF(double p0, struct S_IFF p1, int p2,  void (*cb)(double, struct S_IFF, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_IFD(double p0, struct S_IFD p1, int p2,  void (*cb)(double, struct S_IFD, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_IFP(double p0, struct S_IFP p1, int p2,  void (*cb)(double, struct S_IFP, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_IDI(double p0, struct S_IDI p1, int p2,  void (*cb)(double, struct S_IDI, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_IDF(double p0, struct S_IDF p1, int p2,  void (*cb)(double, struct S_IDF, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_IDD(double p0, struct S_IDD p1, int p2,  void (*cb)(double, struct S_IDD, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_IDP(double p0, struct S_IDP p1, int p2,  void (*cb)(double, struct S_IDP, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_IPI(double p0, struct S_IPI p1, int p2,  void (*cb)(double, struct S_IPI, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_IPF(double p0, struct S_IPF p1, int p2,  void (*cb)(double, struct S_IPF, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_IPD(double p0, struct S_IPD p1, int p2,  void (*cb)(double, struct S_IPD, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_IPP(double p0, struct S_IPP p1, int p2,  void (*cb)(double, struct S_IPP, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_FII(double p0, struct S_FII p1, int p2,  void (*cb)(double, struct S_FII, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_FIF(double p0, struct S_FIF p1, int p2,  void (*cb)(double, struct S_FIF, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_FID(double p0, struct S_FID p1, int p2,  void (*cb)(double, struct S_FID, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_FIP(double p0, struct S_FIP p1, int p2,  void (*cb)(double, struct S_FIP, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_FFI(double p0, struct S_FFI p1, int p2,  void (*cb)(double, struct S_FFI, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_FFF(double p0, struct S_FFF p1, int p2,  void (*cb)(double, struct S_FFF, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_FFD(double p0, struct S_FFD p1, int p2,  void (*cb)(double, struct S_FFD, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_FFP(double p0, struct S_FFP p1, int p2,  void (*cb)(double, struct S_FFP, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_FDI(double p0, struct S_FDI p1, int p2,  void (*cb)(double, struct S_FDI, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_FDF(double p0, struct S_FDF p1, int p2,  void (*cb)(double, struct S_FDF, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_FDD(double p0, struct S_FDD p1, int p2,  void (*cb)(double, struct S_FDD, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_FDP(double p0, struct S_FDP p1, int p2,  void (*cb)(double, struct S_FDP, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_FPI(double p0, struct S_FPI p1, int p2,  void (*cb)(double, struct S_FPI, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_FPF(double p0, struct S_FPF p1, int p2,  void (*cb)(double, struct S_FPF, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_FPD(double p0, struct S_FPD p1, int p2,  void (*cb)(double, struct S_FPD, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_FPP(double p0, struct S_FPP p1, int p2,  void (*cb)(double, struct S_FPP, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_DII(double p0, struct S_DII p1, int p2,  void (*cb)(double, struct S_DII, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_DIF(double p0, struct S_DIF p1, int p2,  void (*cb)(double, struct S_DIF, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_DID(double p0, struct S_DID p1, int p2,  void (*cb)(double, struct S_DID, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_DIP(double p0, struct S_DIP p1, int p2,  void (*cb)(double, struct S_DIP, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_DFI(double p0, struct S_DFI p1, int p2,  void (*cb)(double, struct S_DFI, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_DFF(double p0, struct S_DFF p1, int p2,  void (*cb)(double, struct S_DFF, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_DFD(double p0, struct S_DFD p1, int p2,  void (*cb)(double, struct S_DFD, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_DFP(double p0, struct S_DFP p1, int p2,  void (*cb)(double, struct S_DFP, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_DDI(double p0, struct S_DDI p1, int p2,  void (*cb)(double, struct S_DDI, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_DDF(double p0, struct S_DDF p1, int p2,  void (*cb)(double, struct S_DDF, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_DDD(double p0, struct S_DDD p1, int p2,  void (*cb)(double, struct S_DDD, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_DDP(double p0, struct S_DDP p1, int p2,  void (*cb)(double, struct S_DDP, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_DPI(double p0, struct S_DPI p1, int p2,  void (*cb)(double, struct S_DPI, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_DPF(double p0, struct S_DPF p1, int p2,  void (*cb)(double, struct S_DPF, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_DPD(double p0, struct S_DPD p1, int p2,  void (*cb)(double, struct S_DPD, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_DPP(double p0, struct S_DPP p1, int p2,  void (*cb)(double, struct S_DPP, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_PII(double p0, struct S_PII p1, int p2,  void (*cb)(double, struct S_PII, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_PIF(double p0, struct S_PIF p1, int p2,  void (*cb)(double, struct S_PIF, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_PID(double p0, struct S_PID p1, int p2,  void (*cb)(double, struct S_PID, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_PIP(double p0, struct S_PIP p1, int p2,  void (*cb)(double, struct S_PIP, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_PFI(double p0, struct S_PFI p1, int p2,  void (*cb)(double, struct S_PFI, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_PFF(double p0, struct S_PFF p1, int p2,  void (*cb)(double, struct S_PFF, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_PFD(double p0, struct S_PFD p1, int p2,  void (*cb)(double, struct S_PFD, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_PFP(double p0, struct S_PFP p1, int p2,  void (*cb)(double, struct S_PFP, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_PDI(double p0, struct S_PDI p1, int p2,  void (*cb)(double, struct S_PDI, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_PDF(double p0, struct S_PDF p1, int p2,  void (*cb)(double, struct S_PDF, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_PDD(double p0, struct S_PDD p1, int p2,  void (*cb)(double, struct S_PDD, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_PDP(double p0, struct S_PDP p1, int p2,  void (*cb)(double, struct S_PDP, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_PPI(double p0, struct S_PPI p1, int p2,  void (*cb)(double, struct S_PPI, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_PPF(double p0, struct S_PPF p1, int p2,  void (*cb)(double, struct S_PPF, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_PPD(double p0, struct S_PPD p1, int p2,  void (*cb)(double, struct S_PPD, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSI_PPP(double p0, struct S_PPP p1, int p2,  void (*cb)(double, struct S_PPP, int)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_I(double p0, struct S_I p1, float p2,  void (*cb)(double, struct S_I, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_F(double p0, struct S_F p1, float p2,  void (*cb)(double, struct S_F, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_D(double p0, struct S_D p1, float p2,  void (*cb)(double, struct S_D, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_P(double p0, struct S_P p1, float p2,  void (*cb)(double, struct S_P, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_II(double p0, struct S_II p1, float p2,  void (*cb)(double, struct S_II, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_IF(double p0, struct S_IF p1, float p2,  void (*cb)(double, struct S_IF, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_ID(double p0, struct S_ID p1, float p2,  void (*cb)(double, struct S_ID, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_IP(double p0, struct S_IP p1, float p2,  void (*cb)(double, struct S_IP, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_FI(double p0, struct S_FI p1, float p2,  void (*cb)(double, struct S_FI, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_FF(double p0, struct S_FF p1, float p2,  void (*cb)(double, struct S_FF, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_FD(double p0, struct S_FD p1, float p2,  void (*cb)(double, struct S_FD, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_FP(double p0, struct S_FP p1, float p2,  void (*cb)(double, struct S_FP, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_DI(double p0, struct S_DI p1, float p2,  void (*cb)(double, struct S_DI, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_DF(double p0, struct S_DF p1, float p2,  void (*cb)(double, struct S_DF, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_DD(double p0, struct S_DD p1, float p2,  void (*cb)(double, struct S_DD, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_DP(double p0, struct S_DP p1, float p2,  void (*cb)(double, struct S_DP, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_PI(double p0, struct S_PI p1, float p2,  void (*cb)(double, struct S_PI, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_PF(double p0, struct S_PF p1, float p2,  void (*cb)(double, struct S_PF, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_PD(double p0, struct S_PD p1, float p2,  void (*cb)(double, struct S_PD, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_PP(double p0, struct S_PP p1, float p2,  void (*cb)(double, struct S_PP, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_III(double p0, struct S_III p1, float p2,  void (*cb)(double, struct S_III, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_IIF(double p0, struct S_IIF p1, float p2,  void (*cb)(double, struct S_IIF, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_IID(double p0, struct S_IID p1, float p2,  void (*cb)(double, struct S_IID, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_IIP(double p0, struct S_IIP p1, float p2,  void (*cb)(double, struct S_IIP, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_IFI(double p0, struct S_IFI p1, float p2,  void (*cb)(double, struct S_IFI, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_IFF(double p0, struct S_IFF p1, float p2,  void (*cb)(double, struct S_IFF, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_IFD(double p0, struct S_IFD p1, float p2,  void (*cb)(double, struct S_IFD, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_IFP(double p0, struct S_IFP p1, float p2,  void (*cb)(double, struct S_IFP, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_IDI(double p0, struct S_IDI p1, float p2,  void (*cb)(double, struct S_IDI, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_IDF(double p0, struct S_IDF p1, float p2,  void (*cb)(double, struct S_IDF, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_IDD(double p0, struct S_IDD p1, float p2,  void (*cb)(double, struct S_IDD, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_IDP(double p0, struct S_IDP p1, float p2,  void (*cb)(double, struct S_IDP, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_IPI(double p0, struct S_IPI p1, float p2,  void (*cb)(double, struct S_IPI, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_IPF(double p0, struct S_IPF p1, float p2,  void (*cb)(double, struct S_IPF, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_IPD(double p0, struct S_IPD p1, float p2,  void (*cb)(double, struct S_IPD, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_IPP(double p0, struct S_IPP p1, float p2,  void (*cb)(double, struct S_IPP, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_FII(double p0, struct S_FII p1, float p2,  void (*cb)(double, struct S_FII, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_FIF(double p0, struct S_FIF p1, float p2,  void (*cb)(double, struct S_FIF, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_FID(double p0, struct S_FID p1, float p2,  void (*cb)(double, struct S_FID, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_FIP(double p0, struct S_FIP p1, float p2,  void (*cb)(double, struct S_FIP, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_FFI(double p0, struct S_FFI p1, float p2,  void (*cb)(double, struct S_FFI, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_FFF(double p0, struct S_FFF p1, float p2,  void (*cb)(double, struct S_FFF, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_FFD(double p0, struct S_FFD p1, float p2,  void (*cb)(double, struct S_FFD, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_FFP(double p0, struct S_FFP p1, float p2,  void (*cb)(double, struct S_FFP, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_FDI(double p0, struct S_FDI p1, float p2,  void (*cb)(double, struct S_FDI, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_FDF(double p0, struct S_FDF p1, float p2,  void (*cb)(double, struct S_FDF, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_FDD(double p0, struct S_FDD p1, float p2,  void (*cb)(double, struct S_FDD, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_FDP(double p0, struct S_FDP p1, float p2,  void (*cb)(double, struct S_FDP, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_FPI(double p0, struct S_FPI p1, float p2,  void (*cb)(double, struct S_FPI, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_FPF(double p0, struct S_FPF p1, float p2,  void (*cb)(double, struct S_FPF, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_FPD(double p0, struct S_FPD p1, float p2,  void (*cb)(double, struct S_FPD, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_FPP(double p0, struct S_FPP p1, float p2,  void (*cb)(double, struct S_FPP, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_DII(double p0, struct S_DII p1, float p2,  void (*cb)(double, struct S_DII, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_DIF(double p0, struct S_DIF p1, float p2,  void (*cb)(double, struct S_DIF, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_DID(double p0, struct S_DID p1, float p2,  void (*cb)(double, struct S_DID, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_DIP(double p0, struct S_DIP p1, float p2,  void (*cb)(double, struct S_DIP, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_DFI(double p0, struct S_DFI p1, float p2,  void (*cb)(double, struct S_DFI, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_DFF(double p0, struct S_DFF p1, float p2,  void (*cb)(double, struct S_DFF, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_DFD(double p0, struct S_DFD p1, float p2,  void (*cb)(double, struct S_DFD, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_DFP(double p0, struct S_DFP p1, float p2,  void (*cb)(double, struct S_DFP, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_DDI(double p0, struct S_DDI p1, float p2,  void (*cb)(double, struct S_DDI, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_DDF(double p0, struct S_DDF p1, float p2,  void (*cb)(double, struct S_DDF, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_DDD(double p0, struct S_DDD p1, float p2,  void (*cb)(double, struct S_DDD, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_DDP(double p0, struct S_DDP p1, float p2,  void (*cb)(double, struct S_DDP, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_DPI(double p0, struct S_DPI p1, float p2,  void (*cb)(double, struct S_DPI, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_DPF(double p0, struct S_DPF p1, float p2,  void (*cb)(double, struct S_DPF, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_DPD(double p0, struct S_DPD p1, float p2,  void (*cb)(double, struct S_DPD, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_DPP(double p0, struct S_DPP p1, float p2,  void (*cb)(double, struct S_DPP, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_PII(double p0, struct S_PII p1, float p2,  void (*cb)(double, struct S_PII, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_PIF(double p0, struct S_PIF p1, float p2,  void (*cb)(double, struct S_PIF, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_PID(double p0, struct S_PID p1, float p2,  void (*cb)(double, struct S_PID, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_PIP(double p0, struct S_PIP p1, float p2,  void (*cb)(double, struct S_PIP, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_PFI(double p0, struct S_PFI p1, float p2,  void (*cb)(double, struct S_PFI, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_PFF(double p0, struct S_PFF p1, float p2,  void (*cb)(double, struct S_PFF, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_PFD(double p0, struct S_PFD p1, float p2,  void (*cb)(double, struct S_PFD, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_PFP(double p0, struct S_PFP p1, float p2,  void (*cb)(double, struct S_PFP, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_PDI(double p0, struct S_PDI p1, float p2,  void (*cb)(double, struct S_PDI, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_PDF(double p0, struct S_PDF p1, float p2,  void (*cb)(double, struct S_PDF, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_PDD(double p0, struct S_PDD p1, float p2,  void (*cb)(double, struct S_PDD, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_PDP(double p0, struct S_PDP p1, float p2,  void (*cb)(double, struct S_PDP, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_PPI(double p0, struct S_PPI p1, float p2,  void (*cb)(double, struct S_PPI, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_PPF(double p0, struct S_PPF p1, float p2,  void (*cb)(double, struct S_PPF, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_PPD(double p0, struct S_PPD p1, float p2,  void (*cb)(double, struct S_PPD, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSF_PPP(double p0, struct S_PPP p1, float p2,  void (*cb)(double, struct S_PPP, float)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_I(double p0, struct S_I p1, double p2,  void (*cb)(double, struct S_I, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_F(double p0, struct S_F p1, double p2,  void (*cb)(double, struct S_F, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_D(double p0, struct S_D p1, double p2,  void (*cb)(double, struct S_D, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_P(double p0, struct S_P p1, double p2,  void (*cb)(double, struct S_P, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_II(double p0, struct S_II p1, double p2,  void (*cb)(double, struct S_II, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_IF(double p0, struct S_IF p1, double p2,  void (*cb)(double, struct S_IF, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_ID(double p0, struct S_ID p1, double p2,  void (*cb)(double, struct S_ID, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_IP(double p0, struct S_IP p1, double p2,  void (*cb)(double, struct S_IP, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_FI(double p0, struct S_FI p1, double p2,  void (*cb)(double, struct S_FI, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_FF(double p0, struct S_FF p1, double p2,  void (*cb)(double, struct S_FF, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_FD(double p0, struct S_FD p1, double p2,  void (*cb)(double, struct S_FD, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_FP(double p0, struct S_FP p1, double p2,  void (*cb)(double, struct S_FP, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_DI(double p0, struct S_DI p1, double p2,  void (*cb)(double, struct S_DI, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_DF(double p0, struct S_DF p1, double p2,  void (*cb)(double, struct S_DF, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_DD(double p0, struct S_DD p1, double p2,  void (*cb)(double, struct S_DD, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_DP(double p0, struct S_DP p1, double p2,  void (*cb)(double, struct S_DP, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_PI(double p0, struct S_PI p1, double p2,  void (*cb)(double, struct S_PI, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_PF(double p0, struct S_PF p1, double p2,  void (*cb)(double, struct S_PF, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_PD(double p0, struct S_PD p1, double p2,  void (*cb)(double, struct S_PD, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_PP(double p0, struct S_PP p1, double p2,  void (*cb)(double, struct S_PP, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_III(double p0, struct S_III p1, double p2,  void (*cb)(double, struct S_III, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_IIF(double p0, struct S_IIF p1, double p2,  void (*cb)(double, struct S_IIF, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_IID(double p0, struct S_IID p1, double p2,  void (*cb)(double, struct S_IID, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_IIP(double p0, struct S_IIP p1, double p2,  void (*cb)(double, struct S_IIP, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_IFI(double p0, struct S_IFI p1, double p2,  void (*cb)(double, struct S_IFI, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_IFF(double p0, struct S_IFF p1, double p2,  void (*cb)(double, struct S_IFF, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_IFD(double p0, struct S_IFD p1, double p2,  void (*cb)(double, struct S_IFD, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_IFP(double p0, struct S_IFP p1, double p2,  void (*cb)(double, struct S_IFP, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_IDI(double p0, struct S_IDI p1, double p2,  void (*cb)(double, struct S_IDI, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_IDF(double p0, struct S_IDF p1, double p2,  void (*cb)(double, struct S_IDF, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_IDD(double p0, struct S_IDD p1, double p2,  void (*cb)(double, struct S_IDD, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_IDP(double p0, struct S_IDP p1, double p2,  void (*cb)(double, struct S_IDP, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_IPI(double p0, struct S_IPI p1, double p2,  void (*cb)(double, struct S_IPI, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_IPF(double p0, struct S_IPF p1, double p2,  void (*cb)(double, struct S_IPF, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_IPD(double p0, struct S_IPD p1, double p2,  void (*cb)(double, struct S_IPD, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_IPP(double p0, struct S_IPP p1, double p2,  void (*cb)(double, struct S_IPP, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_FII(double p0, struct S_FII p1, double p2,  void (*cb)(double, struct S_FII, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_FIF(double p0, struct S_FIF p1, double p2,  void (*cb)(double, struct S_FIF, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_FID(double p0, struct S_FID p1, double p2,  void (*cb)(double, struct S_FID, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_FIP(double p0, struct S_FIP p1, double p2,  void (*cb)(double, struct S_FIP, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_FFI(double p0, struct S_FFI p1, double p2,  void (*cb)(double, struct S_FFI, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_FFF(double p0, struct S_FFF p1, double p2,  void (*cb)(double, struct S_FFF, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_FFD(double p0, struct S_FFD p1, double p2,  void (*cb)(double, struct S_FFD, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_FFP(double p0, struct S_FFP p1, double p2,  void (*cb)(double, struct S_FFP, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_FDI(double p0, struct S_FDI p1, double p2,  void (*cb)(double, struct S_FDI, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_FDF(double p0, struct S_FDF p1, double p2,  void (*cb)(double, struct S_FDF, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_FDD(double p0, struct S_FDD p1, double p2,  void (*cb)(double, struct S_FDD, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_FDP(double p0, struct S_FDP p1, double p2,  void (*cb)(double, struct S_FDP, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_FPI(double p0, struct S_FPI p1, double p2,  void (*cb)(double, struct S_FPI, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_FPF(double p0, struct S_FPF p1, double p2,  void (*cb)(double, struct S_FPF, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_FPD(double p0, struct S_FPD p1, double p2,  void (*cb)(double, struct S_FPD, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_FPP(double p0, struct S_FPP p1, double p2,  void (*cb)(double, struct S_FPP, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_DII(double p0, struct S_DII p1, double p2,  void (*cb)(double, struct S_DII, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_DIF(double p0, struct S_DIF p1, double p2,  void (*cb)(double, struct S_DIF, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_DID(double p0, struct S_DID p1, double p2,  void (*cb)(double, struct S_DID, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_DIP(double p0, struct S_DIP p1, double p2,  void (*cb)(double, struct S_DIP, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_DFI(double p0, struct S_DFI p1, double p2,  void (*cb)(double, struct S_DFI, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_DFF(double p0, struct S_DFF p1, double p2,  void (*cb)(double, struct S_DFF, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_DFD(double p0, struct S_DFD p1, double p2,  void (*cb)(double, struct S_DFD, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_DFP(double p0, struct S_DFP p1, double p2,  void (*cb)(double, struct S_DFP, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_DDI(double p0, struct S_DDI p1, double p2,  void (*cb)(double, struct S_DDI, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_DDF(double p0, struct S_DDF p1, double p2,  void (*cb)(double, struct S_DDF, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_DDD(double p0, struct S_DDD p1, double p2,  void (*cb)(double, struct S_DDD, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_DDP(double p0, struct S_DDP p1, double p2,  void (*cb)(double, struct S_DDP, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_DPI(double p0, struct S_DPI p1, double p2,  void (*cb)(double, struct S_DPI, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_DPF(double p0, struct S_DPF p1, double p2,  void (*cb)(double, struct S_DPF, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_DPD(double p0, struct S_DPD p1, double p2,  void (*cb)(double, struct S_DPD, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_DPP(double p0, struct S_DPP p1, double p2,  void (*cb)(double, struct S_DPP, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_PII(double p0, struct S_PII p1, double p2,  void (*cb)(double, struct S_PII, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_PIF(double p0, struct S_PIF p1, double p2,  void (*cb)(double, struct S_PIF, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_PID(double p0, struct S_PID p1, double p2,  void (*cb)(double, struct S_PID, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_PIP(double p0, struct S_PIP p1, double p2,  void (*cb)(double, struct S_PIP, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_PFI(double p0, struct S_PFI p1, double p2,  void (*cb)(double, struct S_PFI, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_PFF(double p0, struct S_PFF p1, double p2,  void (*cb)(double, struct S_PFF, double)) { cb(p0,p1,p2); }
+EXPORT void f4_V_DSD_PFD(double p0, struct S_PFD p1, double p2,  void (*cb)(double, struct S_PFD, double)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSD_PFP(double p0, struct S_PFP p1, double p2,  void (*cb)(double, struct S_PFP, double)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSD_PDI(double p0, struct S_PDI p1, double p2,  void (*cb)(double, struct S_PDI, double)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSD_PDF(double p0, struct S_PDF p1, double p2,  void (*cb)(double, struct S_PDF, double)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSD_PDD(double p0, struct S_PDD p1, double p2,  void (*cb)(double, struct S_PDD, double)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSD_PDP(double p0, struct S_PDP p1, double p2,  void (*cb)(double, struct S_PDP, double)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSD_PPI(double p0, struct S_PPI p1, double p2,  void (*cb)(double, struct S_PPI, double)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSD_PPF(double p0, struct S_PPF p1, double p2,  void (*cb)(double, struct S_PPF, double)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSD_PPD(double p0, struct S_PPD p1, double p2,  void (*cb)(double, struct S_PPD, double)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSD_PPP(double p0, struct S_PPP p1, double p2,  void (*cb)(double, struct S_PPP, double)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_I(double p0, struct S_I p1, void* p2,  void (*cb)(double, struct S_I, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_F(double p0, struct S_F p1, void* p2,  void (*cb)(double, struct S_F, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_D(double p0, struct S_D p1, void* p2,  void (*cb)(double, struct S_D, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_P(double p0, struct S_P p1, void* p2,  void (*cb)(double, struct S_P, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_II(double p0, struct S_II p1, void* p2,  void (*cb)(double, struct S_II, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_IF(double p0, struct S_IF p1, void* p2,  void (*cb)(double, struct S_IF, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_ID(double p0, struct S_ID p1, void* p2,  void (*cb)(double, struct S_ID, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_IP(double p0, struct S_IP p1, void* p2,  void (*cb)(double, struct S_IP, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_FI(double p0, struct S_FI p1, void* p2,  void (*cb)(double, struct S_FI, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_FF(double p0, struct S_FF p1, void* p2,  void (*cb)(double, struct S_FF, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_FD(double p0, struct S_FD p1, void* p2,  void (*cb)(double, struct S_FD, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_FP(double p0, struct S_FP p1, void* p2,  void (*cb)(double, struct S_FP, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_DI(double p0, struct S_DI p1, void* p2,  void (*cb)(double, struct S_DI, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_DF(double p0, struct S_DF p1, void* p2,  void (*cb)(double, struct S_DF, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_DD(double p0, struct S_DD p1, void* p2,  void (*cb)(double, struct S_DD, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_DP(double p0, struct S_DP p1, void* p2,  void (*cb)(double, struct S_DP, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_PI(double p0, struct S_PI p1, void* p2,  void (*cb)(double, struct S_PI, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_PF(double p0, struct S_PF p1, void* p2,  void (*cb)(double, struct S_PF, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_PD(double p0, struct S_PD p1, void* p2,  void (*cb)(double, struct S_PD, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_PP(double p0, struct S_PP p1, void* p2,  void (*cb)(double, struct S_PP, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_III(double p0, struct S_III p1, void* p2,  void (*cb)(double, struct S_III, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_IIF(double p0, struct S_IIF p1, void* p2,  void (*cb)(double, struct S_IIF, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_IID(double p0, struct S_IID p1, void* p2,  void (*cb)(double, struct S_IID, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_IIP(double p0, struct S_IIP p1, void* p2,  void (*cb)(double, struct S_IIP, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_IFI(double p0, struct S_IFI p1, void* p2,  void (*cb)(double, struct S_IFI, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_IFF(double p0, struct S_IFF p1, void* p2,  void (*cb)(double, struct S_IFF, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_IFD(double p0, struct S_IFD p1, void* p2,  void (*cb)(double, struct S_IFD, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_IFP(double p0, struct S_IFP p1, void* p2,  void (*cb)(double, struct S_IFP, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_IDI(double p0, struct S_IDI p1, void* p2,  void (*cb)(double, struct S_IDI, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_IDF(double p0, struct S_IDF p1, void* p2,  void (*cb)(double, struct S_IDF, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_IDD(double p0, struct S_IDD p1, void* p2,  void (*cb)(double, struct S_IDD, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_IDP(double p0, struct S_IDP p1, void* p2,  void (*cb)(double, struct S_IDP, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_IPI(double p0, struct S_IPI p1, void* p2,  void (*cb)(double, struct S_IPI, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_IPF(double p0, struct S_IPF p1, void* p2,  void (*cb)(double, struct S_IPF, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_IPD(double p0, struct S_IPD p1, void* p2,  void (*cb)(double, struct S_IPD, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_IPP(double p0, struct S_IPP p1, void* p2,  void (*cb)(double, struct S_IPP, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_FII(double p0, struct S_FII p1, void* p2,  void (*cb)(double, struct S_FII, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_FIF(double p0, struct S_FIF p1, void* p2,  void (*cb)(double, struct S_FIF, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_FID(double p0, struct S_FID p1, void* p2,  void (*cb)(double, struct S_FID, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_FIP(double p0, struct S_FIP p1, void* p2,  void (*cb)(double, struct S_FIP, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_FFI(double p0, struct S_FFI p1, void* p2,  void (*cb)(double, struct S_FFI, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_FFF(double p0, struct S_FFF p1, void* p2,  void (*cb)(double, struct S_FFF, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_FFD(double p0, struct S_FFD p1, void* p2,  void (*cb)(double, struct S_FFD, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_FFP(double p0, struct S_FFP p1, void* p2,  void (*cb)(double, struct S_FFP, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_FDI(double p0, struct S_FDI p1, void* p2,  void (*cb)(double, struct S_FDI, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_FDF(double p0, struct S_FDF p1, void* p2,  void (*cb)(double, struct S_FDF, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_FDD(double p0, struct S_FDD p1, void* p2,  void (*cb)(double, struct S_FDD, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_FDP(double p0, struct S_FDP p1, void* p2,  void (*cb)(double, struct S_FDP, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_FPI(double p0, struct S_FPI p1, void* p2,  void (*cb)(double, struct S_FPI, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_FPF(double p0, struct S_FPF p1, void* p2,  void (*cb)(double, struct S_FPF, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_FPD(double p0, struct S_FPD p1, void* p2,  void (*cb)(double, struct S_FPD, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_FPP(double p0, struct S_FPP p1, void* p2,  void (*cb)(double, struct S_FPP, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_DII(double p0, struct S_DII p1, void* p2,  void (*cb)(double, struct S_DII, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_DIF(double p0, struct S_DIF p1, void* p2,  void (*cb)(double, struct S_DIF, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_DID(double p0, struct S_DID p1, void* p2,  void (*cb)(double, struct S_DID, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_DIP(double p0, struct S_DIP p1, void* p2,  void (*cb)(double, struct S_DIP, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_DFI(double p0, struct S_DFI p1, void* p2,  void (*cb)(double, struct S_DFI, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_DFF(double p0, struct S_DFF p1, void* p2,  void (*cb)(double, struct S_DFF, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_DFD(double p0, struct S_DFD p1, void* p2,  void (*cb)(double, struct S_DFD, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_DFP(double p0, struct S_DFP p1, void* p2,  void (*cb)(double, struct S_DFP, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_DDI(double p0, struct S_DDI p1, void* p2,  void (*cb)(double, struct S_DDI, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_DDF(double p0, struct S_DDF p1, void* p2,  void (*cb)(double, struct S_DDF, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_DDD(double p0, struct S_DDD p1, void* p2,  void (*cb)(double, struct S_DDD, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_DDP(double p0, struct S_DDP p1, void* p2,  void (*cb)(double, struct S_DDP, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_DPI(double p0, struct S_DPI p1, void* p2,  void (*cb)(double, struct S_DPI, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_DPF(double p0, struct S_DPF p1, void* p2,  void (*cb)(double, struct S_DPF, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_DPD(double p0, struct S_DPD p1, void* p2,  void (*cb)(double, struct S_DPD, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_DPP(double p0, struct S_DPP p1, void* p2,  void (*cb)(double, struct S_DPP, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_PII(double p0, struct S_PII p1, void* p2,  void (*cb)(double, struct S_PII, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_PIF(double p0, struct S_PIF p1, void* p2,  void (*cb)(double, struct S_PIF, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_PID(double p0, struct S_PID p1, void* p2,  void (*cb)(double, struct S_PID, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_PIP(double p0, struct S_PIP p1, void* p2,  void (*cb)(double, struct S_PIP, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_PFI(double p0, struct S_PFI p1, void* p2,  void (*cb)(double, struct S_PFI, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_PFF(double p0, struct S_PFF p1, void* p2,  void (*cb)(double, struct S_PFF, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_PFD(double p0, struct S_PFD p1, void* p2,  void (*cb)(double, struct S_PFD, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_PFP(double p0, struct S_PFP p1, void* p2,  void (*cb)(double, struct S_PFP, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_PDI(double p0, struct S_PDI p1, void* p2,  void (*cb)(double, struct S_PDI, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_PDF(double p0, struct S_PDF p1, void* p2,  void (*cb)(double, struct S_PDF, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_PDD(double p0, struct S_PDD p1, void* p2,  void (*cb)(double, struct S_PDD, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_PDP(double p0, struct S_PDP p1, void* p2,  void (*cb)(double, struct S_PDP, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_PPI(double p0, struct S_PPI p1, void* p2,  void (*cb)(double, struct S_PPI, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_PPF(double p0, struct S_PPF p1, void* p2,  void (*cb)(double, struct S_PPF, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_PPD(double p0, struct S_PPD p1, void* p2,  void (*cb)(double, struct S_PPD, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSP_PPP(double p0, struct S_PPP p1, void* p2,  void (*cb)(double, struct S_PPP, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_I(double p0, struct S_I p1, struct S_I p2,  void (*cb)(double, struct S_I, struct S_I)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_F(double p0, struct S_F p1, struct S_F p2,  void (*cb)(double, struct S_F, struct S_F)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_D(double p0, struct S_D p1, struct S_D p2,  void (*cb)(double, struct S_D, struct S_D)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_P(double p0, struct S_P p1, struct S_P p2,  void (*cb)(double, struct S_P, struct S_P)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_II(double p0, struct S_II p1, struct S_II p2,  void (*cb)(double, struct S_II, struct S_II)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_IF(double p0, struct S_IF p1, struct S_IF p2,  void (*cb)(double, struct S_IF, struct S_IF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_ID(double p0, struct S_ID p1, struct S_ID p2,  void (*cb)(double, struct S_ID, struct S_ID)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_IP(double p0, struct S_IP p1, struct S_IP p2,  void (*cb)(double, struct S_IP, struct S_IP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_FI(double p0, struct S_FI p1, struct S_FI p2,  void (*cb)(double, struct S_FI, struct S_FI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_FF(double p0, struct S_FF p1, struct S_FF p2,  void (*cb)(double, struct S_FF, struct S_FF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_FD(double p0, struct S_FD p1, struct S_FD p2,  void (*cb)(double, struct S_FD, struct S_FD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_FP(double p0, struct S_FP p1, struct S_FP p2,  void (*cb)(double, struct S_FP, struct S_FP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_DI(double p0, struct S_DI p1, struct S_DI p2,  void (*cb)(double, struct S_DI, struct S_DI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_DF(double p0, struct S_DF p1, struct S_DF p2,  void (*cb)(double, struct S_DF, struct S_DF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_DD(double p0, struct S_DD p1, struct S_DD p2,  void (*cb)(double, struct S_DD, struct S_DD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_DP(double p0, struct S_DP p1, struct S_DP p2,  void (*cb)(double, struct S_DP, struct S_DP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_PI(double p0, struct S_PI p1, struct S_PI p2,  void (*cb)(double, struct S_PI, struct S_PI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_PF(double p0, struct S_PF p1, struct S_PF p2,  void (*cb)(double, struct S_PF, struct S_PF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_PD(double p0, struct S_PD p1, struct S_PD p2,  void (*cb)(double, struct S_PD, struct S_PD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_PP(double p0, struct S_PP p1, struct S_PP p2,  void (*cb)(double, struct S_PP, struct S_PP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_III(double p0, struct S_III p1, struct S_III p2,  void (*cb)(double, struct S_III, struct S_III)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_IIF(double p0, struct S_IIF p1, struct S_IIF p2,  void (*cb)(double, struct S_IIF, struct S_IIF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_IID(double p0, struct S_IID p1, struct S_IID p2,  void (*cb)(double, struct S_IID, struct S_IID)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_IIP(double p0, struct S_IIP p1, struct S_IIP p2,  void (*cb)(double, struct S_IIP, struct S_IIP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_IFI(double p0, struct S_IFI p1, struct S_IFI p2,  void (*cb)(double, struct S_IFI, struct S_IFI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_IFF(double p0, struct S_IFF p1, struct S_IFF p2,  void (*cb)(double, struct S_IFF, struct S_IFF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_IFD(double p0, struct S_IFD p1, struct S_IFD p2,  void (*cb)(double, struct S_IFD, struct S_IFD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_IFP(double p0, struct S_IFP p1, struct S_IFP p2,  void (*cb)(double, struct S_IFP, struct S_IFP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_IDI(double p0, struct S_IDI p1, struct S_IDI p2,  void (*cb)(double, struct S_IDI, struct S_IDI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_IDF(double p0, struct S_IDF p1, struct S_IDF p2,  void (*cb)(double, struct S_IDF, struct S_IDF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_IDD(double p0, struct S_IDD p1, struct S_IDD p2,  void (*cb)(double, struct S_IDD, struct S_IDD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_IDP(double p0, struct S_IDP p1, struct S_IDP p2,  void (*cb)(double, struct S_IDP, struct S_IDP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_IPI(double p0, struct S_IPI p1, struct S_IPI p2,  void (*cb)(double, struct S_IPI, struct S_IPI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_IPF(double p0, struct S_IPF p1, struct S_IPF p2,  void (*cb)(double, struct S_IPF, struct S_IPF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_IPD(double p0, struct S_IPD p1, struct S_IPD p2,  void (*cb)(double, struct S_IPD, struct S_IPD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_IPP(double p0, struct S_IPP p1, struct S_IPP p2,  void (*cb)(double, struct S_IPP, struct S_IPP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_FII(double p0, struct S_FII p1, struct S_FII p2,  void (*cb)(double, struct S_FII, struct S_FII)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_FIF(double p0, struct S_FIF p1, struct S_FIF p2,  void (*cb)(double, struct S_FIF, struct S_FIF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_FID(double p0, struct S_FID p1, struct S_FID p2,  void (*cb)(double, struct S_FID, struct S_FID)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_FIP(double p0, struct S_FIP p1, struct S_FIP p2,  void (*cb)(double, struct S_FIP, struct S_FIP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_FFI(double p0, struct S_FFI p1, struct S_FFI p2,  void (*cb)(double, struct S_FFI, struct S_FFI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_FFF(double p0, struct S_FFF p1, struct S_FFF p2,  void (*cb)(double, struct S_FFF, struct S_FFF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_FFD(double p0, struct S_FFD p1, struct S_FFD p2,  void (*cb)(double, struct S_FFD, struct S_FFD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_FFP(double p0, struct S_FFP p1, struct S_FFP p2,  void (*cb)(double, struct S_FFP, struct S_FFP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_FDI(double p0, struct S_FDI p1, struct S_FDI p2,  void (*cb)(double, struct S_FDI, struct S_FDI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_FDF(double p0, struct S_FDF p1, struct S_FDF p2,  void (*cb)(double, struct S_FDF, struct S_FDF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_FDD(double p0, struct S_FDD p1, struct S_FDD p2,  void (*cb)(double, struct S_FDD, struct S_FDD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_FDP(double p0, struct S_FDP p1, struct S_FDP p2,  void (*cb)(double, struct S_FDP, struct S_FDP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_FPI(double p0, struct S_FPI p1, struct S_FPI p2,  void (*cb)(double, struct S_FPI, struct S_FPI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_FPF(double p0, struct S_FPF p1, struct S_FPF p2,  void (*cb)(double, struct S_FPF, struct S_FPF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_FPD(double p0, struct S_FPD p1, struct S_FPD p2,  void (*cb)(double, struct S_FPD, struct S_FPD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_FPP(double p0, struct S_FPP p1, struct S_FPP p2,  void (*cb)(double, struct S_FPP, struct S_FPP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_DII(double p0, struct S_DII p1, struct S_DII p2,  void (*cb)(double, struct S_DII, struct S_DII)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_DIF(double p0, struct S_DIF p1, struct S_DIF p2,  void (*cb)(double, struct S_DIF, struct S_DIF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_DID(double p0, struct S_DID p1, struct S_DID p2,  void (*cb)(double, struct S_DID, struct S_DID)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_DIP(double p0, struct S_DIP p1, struct S_DIP p2,  void (*cb)(double, struct S_DIP, struct S_DIP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_DFI(double p0, struct S_DFI p1, struct S_DFI p2,  void (*cb)(double, struct S_DFI, struct S_DFI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_DFF(double p0, struct S_DFF p1, struct S_DFF p2,  void (*cb)(double, struct S_DFF, struct S_DFF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_DFD(double p0, struct S_DFD p1, struct S_DFD p2,  void (*cb)(double, struct S_DFD, struct S_DFD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_DFP(double p0, struct S_DFP p1, struct S_DFP p2,  void (*cb)(double, struct S_DFP, struct S_DFP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_DDI(double p0, struct S_DDI p1, struct S_DDI p2,  void (*cb)(double, struct S_DDI, struct S_DDI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_DDF(double p0, struct S_DDF p1, struct S_DDF p2,  void (*cb)(double, struct S_DDF, struct S_DDF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_DDD(double p0, struct S_DDD p1, struct S_DDD p2,  void (*cb)(double, struct S_DDD, struct S_DDD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_DDP(double p0, struct S_DDP p1, struct S_DDP p2,  void (*cb)(double, struct S_DDP, struct S_DDP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_DPI(double p0, struct S_DPI p1, struct S_DPI p2,  void (*cb)(double, struct S_DPI, struct S_DPI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_DPF(double p0, struct S_DPF p1, struct S_DPF p2,  void (*cb)(double, struct S_DPF, struct S_DPF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_DPD(double p0, struct S_DPD p1, struct S_DPD p2,  void (*cb)(double, struct S_DPD, struct S_DPD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_DPP(double p0, struct S_DPP p1, struct S_DPP p2,  void (*cb)(double, struct S_DPP, struct S_DPP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_PII(double p0, struct S_PII p1, struct S_PII p2,  void (*cb)(double, struct S_PII, struct S_PII)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_PIF(double p0, struct S_PIF p1, struct S_PIF p2,  void (*cb)(double, struct S_PIF, struct S_PIF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_PID(double p0, struct S_PID p1, struct S_PID p2,  void (*cb)(double, struct S_PID, struct S_PID)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_PIP(double p0, struct S_PIP p1, struct S_PIP p2,  void (*cb)(double, struct S_PIP, struct S_PIP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_PFI(double p0, struct S_PFI p1, struct S_PFI p2,  void (*cb)(double, struct S_PFI, struct S_PFI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_PFF(double p0, struct S_PFF p1, struct S_PFF p2,  void (*cb)(double, struct S_PFF, struct S_PFF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_PFD(double p0, struct S_PFD p1, struct S_PFD p2,  void (*cb)(double, struct S_PFD, struct S_PFD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_PFP(double p0, struct S_PFP p1, struct S_PFP p2,  void (*cb)(double, struct S_PFP, struct S_PFP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_PDI(double p0, struct S_PDI p1, struct S_PDI p2,  void (*cb)(double, struct S_PDI, struct S_PDI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_PDF(double p0, struct S_PDF p1, struct S_PDF p2,  void (*cb)(double, struct S_PDF, struct S_PDF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_PDD(double p0, struct S_PDD p1, struct S_PDD p2,  void (*cb)(double, struct S_PDD, struct S_PDD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_PDP(double p0, struct S_PDP p1, struct S_PDP p2,  void (*cb)(double, struct S_PDP, struct S_PDP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_PPI(double p0, struct S_PPI p1, struct S_PPI p2,  void (*cb)(double, struct S_PPI, struct S_PPI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_PPF(double p0, struct S_PPF p1, struct S_PPF p2,  void (*cb)(double, struct S_PPF, struct S_PPF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_PPD(double p0, struct S_PPD p1, struct S_PPD p2,  void (*cb)(double, struct S_PPD, struct S_PPD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_DSS_PPP(double p0, struct S_PPP p1, struct S_PPP p2,  void (*cb)(double, struct S_PPP, struct S_PPP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PII_(void* p0, int p1, int p2,  void (*cb)(void*, int, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIF_(void* p0, int p1, float p2,  void (*cb)(void*, int, float)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PID_(void* p0, int p1, double p2,  void (*cb)(void*, int, double)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIP_(void* p0, int p1, void* p2,  void (*cb)(void*, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_I(void* p0, int p1, struct S_I p2,  void (*cb)(void*, int, struct S_I)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_F(void* p0, int p1, struct S_F p2,  void (*cb)(void*, int, struct S_F)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_D(void* p0, int p1, struct S_D p2,  void (*cb)(void*, int, struct S_D)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_P(void* p0, int p1, struct S_P p2,  void (*cb)(void*, int, struct S_P)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_II(void* p0, int p1, struct S_II p2,  void (*cb)(void*, int, struct S_II)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_IF(void* p0, int p1, struct S_IF p2,  void (*cb)(void*, int, struct S_IF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_ID(void* p0, int p1, struct S_ID p2,  void (*cb)(void*, int, struct S_ID)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_IP(void* p0, int p1, struct S_IP p2,  void (*cb)(void*, int, struct S_IP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_FI(void* p0, int p1, struct S_FI p2,  void (*cb)(void*, int, struct S_FI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_FF(void* p0, int p1, struct S_FF p2,  void (*cb)(void*, int, struct S_FF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_FD(void* p0, int p1, struct S_FD p2,  void (*cb)(void*, int, struct S_FD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_FP(void* p0, int p1, struct S_FP p2,  void (*cb)(void*, int, struct S_FP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_DI(void* p0, int p1, struct S_DI p2,  void (*cb)(void*, int, struct S_DI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_DF(void* p0, int p1, struct S_DF p2,  void (*cb)(void*, int, struct S_DF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_DD(void* p0, int p1, struct S_DD p2,  void (*cb)(void*, int, struct S_DD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_DP(void* p0, int p1, struct S_DP p2,  void (*cb)(void*, int, struct S_DP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_PI(void* p0, int p1, struct S_PI p2,  void (*cb)(void*, int, struct S_PI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_PF(void* p0, int p1, struct S_PF p2,  void (*cb)(void*, int, struct S_PF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_PD(void* p0, int p1, struct S_PD p2,  void (*cb)(void*, int, struct S_PD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_PP(void* p0, int p1, struct S_PP p2,  void (*cb)(void*, int, struct S_PP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_III(void* p0, int p1, struct S_III p2,  void (*cb)(void*, int, struct S_III)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_IIF(void* p0, int p1, struct S_IIF p2,  void (*cb)(void*, int, struct S_IIF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_IID(void* p0, int p1, struct S_IID p2,  void (*cb)(void*, int, struct S_IID)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_IIP(void* p0, int p1, struct S_IIP p2,  void (*cb)(void*, int, struct S_IIP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_IFI(void* p0, int p1, struct S_IFI p2,  void (*cb)(void*, int, struct S_IFI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_IFF(void* p0, int p1, struct S_IFF p2,  void (*cb)(void*, int, struct S_IFF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_IFD(void* p0, int p1, struct S_IFD p2,  void (*cb)(void*, int, struct S_IFD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_IFP(void* p0, int p1, struct S_IFP p2,  void (*cb)(void*, int, struct S_IFP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_IDI(void* p0, int p1, struct S_IDI p2,  void (*cb)(void*, int, struct S_IDI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_IDF(void* p0, int p1, struct S_IDF p2,  void (*cb)(void*, int, struct S_IDF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_IDD(void* p0, int p1, struct S_IDD p2,  void (*cb)(void*, int, struct S_IDD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_IDP(void* p0, int p1, struct S_IDP p2,  void (*cb)(void*, int, struct S_IDP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_IPI(void* p0, int p1, struct S_IPI p2,  void (*cb)(void*, int, struct S_IPI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_IPF(void* p0, int p1, struct S_IPF p2,  void (*cb)(void*, int, struct S_IPF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_IPD(void* p0, int p1, struct S_IPD p2,  void (*cb)(void*, int, struct S_IPD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_IPP(void* p0, int p1, struct S_IPP p2,  void (*cb)(void*, int, struct S_IPP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_FII(void* p0, int p1, struct S_FII p2,  void (*cb)(void*, int, struct S_FII)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_FIF(void* p0, int p1, struct S_FIF p2,  void (*cb)(void*, int, struct S_FIF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_FID(void* p0, int p1, struct S_FID p2,  void (*cb)(void*, int, struct S_FID)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_FIP(void* p0, int p1, struct S_FIP p2,  void (*cb)(void*, int, struct S_FIP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_FFI(void* p0, int p1, struct S_FFI p2,  void (*cb)(void*, int, struct S_FFI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_FFF(void* p0, int p1, struct S_FFF p2,  void (*cb)(void*, int, struct S_FFF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_FFD(void* p0, int p1, struct S_FFD p2,  void (*cb)(void*, int, struct S_FFD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_FFP(void* p0, int p1, struct S_FFP p2,  void (*cb)(void*, int, struct S_FFP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_FDI(void* p0, int p1, struct S_FDI p2,  void (*cb)(void*, int, struct S_FDI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_FDF(void* p0, int p1, struct S_FDF p2,  void (*cb)(void*, int, struct S_FDF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_FDD(void* p0, int p1, struct S_FDD p2,  void (*cb)(void*, int, struct S_FDD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_FDP(void* p0, int p1, struct S_FDP p2,  void (*cb)(void*, int, struct S_FDP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_FPI(void* p0, int p1, struct S_FPI p2,  void (*cb)(void*, int, struct S_FPI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_FPF(void* p0, int p1, struct S_FPF p2,  void (*cb)(void*, int, struct S_FPF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_FPD(void* p0, int p1, struct S_FPD p2,  void (*cb)(void*, int, struct S_FPD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_FPP(void* p0, int p1, struct S_FPP p2,  void (*cb)(void*, int, struct S_FPP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_DII(void* p0, int p1, struct S_DII p2,  void (*cb)(void*, int, struct S_DII)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_DIF(void* p0, int p1, struct S_DIF p2,  void (*cb)(void*, int, struct S_DIF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_DID(void* p0, int p1, struct S_DID p2,  void (*cb)(void*, int, struct S_DID)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_DIP(void* p0, int p1, struct S_DIP p2,  void (*cb)(void*, int, struct S_DIP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_DFI(void* p0, int p1, struct S_DFI p2,  void (*cb)(void*, int, struct S_DFI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_DFF(void* p0, int p1, struct S_DFF p2,  void (*cb)(void*, int, struct S_DFF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_DFD(void* p0, int p1, struct S_DFD p2,  void (*cb)(void*, int, struct S_DFD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_DFP(void* p0, int p1, struct S_DFP p2,  void (*cb)(void*, int, struct S_DFP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_DDI(void* p0, int p1, struct S_DDI p2,  void (*cb)(void*, int, struct S_DDI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_DDF(void* p0, int p1, struct S_DDF p2,  void (*cb)(void*, int, struct S_DDF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_DDD(void* p0, int p1, struct S_DDD p2,  void (*cb)(void*, int, struct S_DDD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_DDP(void* p0, int p1, struct S_DDP p2,  void (*cb)(void*, int, struct S_DDP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_DPI(void* p0, int p1, struct S_DPI p2,  void (*cb)(void*, int, struct S_DPI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_DPF(void* p0, int p1, struct S_DPF p2,  void (*cb)(void*, int, struct S_DPF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_DPD(void* p0, int p1, struct S_DPD p2,  void (*cb)(void*, int, struct S_DPD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_DPP(void* p0, int p1, struct S_DPP p2,  void (*cb)(void*, int, struct S_DPP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_PII(void* p0, int p1, struct S_PII p2,  void (*cb)(void*, int, struct S_PII)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_PIF(void* p0, int p1, struct S_PIF p2,  void (*cb)(void*, int, struct S_PIF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_PID(void* p0, int p1, struct S_PID p2,  void (*cb)(void*, int, struct S_PID)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_PIP(void* p0, int p1, struct S_PIP p2,  void (*cb)(void*, int, struct S_PIP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_PFI(void* p0, int p1, struct S_PFI p2,  void (*cb)(void*, int, struct S_PFI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_PFF(void* p0, int p1, struct S_PFF p2,  void (*cb)(void*, int, struct S_PFF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_PFD(void* p0, int p1, struct S_PFD p2,  void (*cb)(void*, int, struct S_PFD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_PFP(void* p0, int p1, struct S_PFP p2,  void (*cb)(void*, int, struct S_PFP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_PDI(void* p0, int p1, struct S_PDI p2,  void (*cb)(void*, int, struct S_PDI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_PDF(void* p0, int p1, struct S_PDF p2,  void (*cb)(void*, int, struct S_PDF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_PDD(void* p0, int p1, struct S_PDD p2,  void (*cb)(void*, int, struct S_PDD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_PDP(void* p0, int p1, struct S_PDP p2,  void (*cb)(void*, int, struct S_PDP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_PPI(void* p0, int p1, struct S_PPI p2,  void (*cb)(void*, int, struct S_PPI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_PPF(void* p0, int p1, struct S_PPF p2,  void (*cb)(void*, int, struct S_PPF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_PPD(void* p0, int p1, struct S_PPD p2,  void (*cb)(void*, int, struct S_PPD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PIS_PPP(void* p0, int p1, struct S_PPP p2,  void (*cb)(void*, int, struct S_PPP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFI_(void* p0, float p1, int p2,  void (*cb)(void*, float, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFF_(void* p0, float p1, float p2,  void (*cb)(void*, float, float)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFD_(void* p0, float p1, double p2,  void (*cb)(void*, float, double)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFP_(void* p0, float p1, void* p2,  void (*cb)(void*, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_I(void* p0, float p1, struct S_I p2,  void (*cb)(void*, float, struct S_I)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_F(void* p0, float p1, struct S_F p2,  void (*cb)(void*, float, struct S_F)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_D(void* p0, float p1, struct S_D p2,  void (*cb)(void*, float, struct S_D)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_P(void* p0, float p1, struct S_P p2,  void (*cb)(void*, float, struct S_P)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_II(void* p0, float p1, struct S_II p2,  void (*cb)(void*, float, struct S_II)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_IF(void* p0, float p1, struct S_IF p2,  void (*cb)(void*, float, struct S_IF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_ID(void* p0, float p1, struct S_ID p2,  void (*cb)(void*, float, struct S_ID)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_IP(void* p0, float p1, struct S_IP p2,  void (*cb)(void*, float, struct S_IP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_FI(void* p0, float p1, struct S_FI p2,  void (*cb)(void*, float, struct S_FI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_FF(void* p0, float p1, struct S_FF p2,  void (*cb)(void*, float, struct S_FF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_FD(void* p0, float p1, struct S_FD p2,  void (*cb)(void*, float, struct S_FD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_FP(void* p0, float p1, struct S_FP p2,  void (*cb)(void*, float, struct S_FP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_DI(void* p0, float p1, struct S_DI p2,  void (*cb)(void*, float, struct S_DI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_DF(void* p0, float p1, struct S_DF p2,  void (*cb)(void*, float, struct S_DF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_DD(void* p0, float p1, struct S_DD p2,  void (*cb)(void*, float, struct S_DD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_DP(void* p0, float p1, struct S_DP p2,  void (*cb)(void*, float, struct S_DP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_PI(void* p0, float p1, struct S_PI p2,  void (*cb)(void*, float, struct S_PI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_PF(void* p0, float p1, struct S_PF p2,  void (*cb)(void*, float, struct S_PF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_PD(void* p0, float p1, struct S_PD p2,  void (*cb)(void*, float, struct S_PD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_PP(void* p0, float p1, struct S_PP p2,  void (*cb)(void*, float, struct S_PP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_III(void* p0, float p1, struct S_III p2,  void (*cb)(void*, float, struct S_III)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_IIF(void* p0, float p1, struct S_IIF p2,  void (*cb)(void*, float, struct S_IIF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_IID(void* p0, float p1, struct S_IID p2,  void (*cb)(void*, float, struct S_IID)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_IIP(void* p0, float p1, struct S_IIP p2,  void (*cb)(void*, float, struct S_IIP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_IFI(void* p0, float p1, struct S_IFI p2,  void (*cb)(void*, float, struct S_IFI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_IFF(void* p0, float p1, struct S_IFF p2,  void (*cb)(void*, float, struct S_IFF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_IFD(void* p0, float p1, struct S_IFD p2,  void (*cb)(void*, float, struct S_IFD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_IFP(void* p0, float p1, struct S_IFP p2,  void (*cb)(void*, float, struct S_IFP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_IDI(void* p0, float p1, struct S_IDI p2,  void (*cb)(void*, float, struct S_IDI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_IDF(void* p0, float p1, struct S_IDF p2,  void (*cb)(void*, float, struct S_IDF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_IDD(void* p0, float p1, struct S_IDD p2,  void (*cb)(void*, float, struct S_IDD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_IDP(void* p0, float p1, struct S_IDP p2,  void (*cb)(void*, float, struct S_IDP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_IPI(void* p0, float p1, struct S_IPI p2,  void (*cb)(void*, float, struct S_IPI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_IPF(void* p0, float p1, struct S_IPF p2,  void (*cb)(void*, float, struct S_IPF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_IPD(void* p0, float p1, struct S_IPD p2,  void (*cb)(void*, float, struct S_IPD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_IPP(void* p0, float p1, struct S_IPP p2,  void (*cb)(void*, float, struct S_IPP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_FII(void* p0, float p1, struct S_FII p2,  void (*cb)(void*, float, struct S_FII)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_FIF(void* p0, float p1, struct S_FIF p2,  void (*cb)(void*, float, struct S_FIF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_FID(void* p0, float p1, struct S_FID p2,  void (*cb)(void*, float, struct S_FID)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_FIP(void* p0, float p1, struct S_FIP p2,  void (*cb)(void*, float, struct S_FIP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_FFI(void* p0, float p1, struct S_FFI p2,  void (*cb)(void*, float, struct S_FFI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_FFF(void* p0, float p1, struct S_FFF p2,  void (*cb)(void*, float, struct S_FFF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_FFD(void* p0, float p1, struct S_FFD p2,  void (*cb)(void*, float, struct S_FFD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_FFP(void* p0, float p1, struct S_FFP p2,  void (*cb)(void*, float, struct S_FFP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_FDI(void* p0, float p1, struct S_FDI p2,  void (*cb)(void*, float, struct S_FDI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_FDF(void* p0, float p1, struct S_FDF p2,  void (*cb)(void*, float, struct S_FDF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_FDD(void* p0, float p1, struct S_FDD p2,  void (*cb)(void*, float, struct S_FDD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_FDP(void* p0, float p1, struct S_FDP p2,  void (*cb)(void*, float, struct S_FDP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_FPI(void* p0, float p1, struct S_FPI p2,  void (*cb)(void*, float, struct S_FPI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_FPF(void* p0, float p1, struct S_FPF p2,  void (*cb)(void*, float, struct S_FPF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_FPD(void* p0, float p1, struct S_FPD p2,  void (*cb)(void*, float, struct S_FPD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_FPP(void* p0, float p1, struct S_FPP p2,  void (*cb)(void*, float, struct S_FPP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_DII(void* p0, float p1, struct S_DII p2,  void (*cb)(void*, float, struct S_DII)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_DIF(void* p0, float p1, struct S_DIF p2,  void (*cb)(void*, float, struct S_DIF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_DID(void* p0, float p1, struct S_DID p2,  void (*cb)(void*, float, struct S_DID)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_DIP(void* p0, float p1, struct S_DIP p2,  void (*cb)(void*, float, struct S_DIP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_DFI(void* p0, float p1, struct S_DFI p2,  void (*cb)(void*, float, struct S_DFI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_DFF(void* p0, float p1, struct S_DFF p2,  void (*cb)(void*, float, struct S_DFF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_DFD(void* p0, float p1, struct S_DFD p2,  void (*cb)(void*, float, struct S_DFD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_DFP(void* p0, float p1, struct S_DFP p2,  void (*cb)(void*, float, struct S_DFP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_DDI(void* p0, float p1, struct S_DDI p2,  void (*cb)(void*, float, struct S_DDI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_DDF(void* p0, float p1, struct S_DDF p2,  void (*cb)(void*, float, struct S_DDF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_DDD(void* p0, float p1, struct S_DDD p2,  void (*cb)(void*, float, struct S_DDD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_DDP(void* p0, float p1, struct S_DDP p2,  void (*cb)(void*, float, struct S_DDP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_DPI(void* p0, float p1, struct S_DPI p2,  void (*cb)(void*, float, struct S_DPI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_DPF(void* p0, float p1, struct S_DPF p2,  void (*cb)(void*, float, struct S_DPF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_DPD(void* p0, float p1, struct S_DPD p2,  void (*cb)(void*, float, struct S_DPD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_DPP(void* p0, float p1, struct S_DPP p2,  void (*cb)(void*, float, struct S_DPP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_PII(void* p0, float p1, struct S_PII p2,  void (*cb)(void*, float, struct S_PII)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_PIF(void* p0, float p1, struct S_PIF p2,  void (*cb)(void*, float, struct S_PIF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_PID(void* p0, float p1, struct S_PID p2,  void (*cb)(void*, float, struct S_PID)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_PIP(void* p0, float p1, struct S_PIP p2,  void (*cb)(void*, float, struct S_PIP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_PFI(void* p0, float p1, struct S_PFI p2,  void (*cb)(void*, float, struct S_PFI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_PFF(void* p0, float p1, struct S_PFF p2,  void (*cb)(void*, float, struct S_PFF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_PFD(void* p0, float p1, struct S_PFD p2,  void (*cb)(void*, float, struct S_PFD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_PFP(void* p0, float p1, struct S_PFP p2,  void (*cb)(void*, float, struct S_PFP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_PDI(void* p0, float p1, struct S_PDI p2,  void (*cb)(void*, float, struct S_PDI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_PDF(void* p0, float p1, struct S_PDF p2,  void (*cb)(void*, float, struct S_PDF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_PDD(void* p0, float p1, struct S_PDD p2,  void (*cb)(void*, float, struct S_PDD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_PDP(void* p0, float p1, struct S_PDP p2,  void (*cb)(void*, float, struct S_PDP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_PPI(void* p0, float p1, struct S_PPI p2,  void (*cb)(void*, float, struct S_PPI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_PPF(void* p0, float p1, struct S_PPF p2,  void (*cb)(void*, float, struct S_PPF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_PPD(void* p0, float p1, struct S_PPD p2,  void (*cb)(void*, float, struct S_PPD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PFS_PPP(void* p0, float p1, struct S_PPP p2,  void (*cb)(void*, float, struct S_PPP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDI_(void* p0, double p1, int p2,  void (*cb)(void*, double, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDF_(void* p0, double p1, float p2,  void (*cb)(void*, double, float)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDD_(void* p0, double p1, double p2,  void (*cb)(void*, double, double)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDP_(void* p0, double p1, void* p2,  void (*cb)(void*, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_I(void* p0, double p1, struct S_I p2,  void (*cb)(void*, double, struct S_I)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_F(void* p0, double p1, struct S_F p2,  void (*cb)(void*, double, struct S_F)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_D(void* p0, double p1, struct S_D p2,  void (*cb)(void*, double, struct S_D)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_P(void* p0, double p1, struct S_P p2,  void (*cb)(void*, double, struct S_P)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_II(void* p0, double p1, struct S_II p2,  void (*cb)(void*, double, struct S_II)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_IF(void* p0, double p1, struct S_IF p2,  void (*cb)(void*, double, struct S_IF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_ID(void* p0, double p1, struct S_ID p2,  void (*cb)(void*, double, struct S_ID)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_IP(void* p0, double p1, struct S_IP p2,  void (*cb)(void*, double, struct S_IP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_FI(void* p0, double p1, struct S_FI p2,  void (*cb)(void*, double, struct S_FI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_FF(void* p0, double p1, struct S_FF p2,  void (*cb)(void*, double, struct S_FF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_FD(void* p0, double p1, struct S_FD p2,  void (*cb)(void*, double, struct S_FD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_FP(void* p0, double p1, struct S_FP p2,  void (*cb)(void*, double, struct S_FP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_DI(void* p0, double p1, struct S_DI p2,  void (*cb)(void*, double, struct S_DI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_DF(void* p0, double p1, struct S_DF p2,  void (*cb)(void*, double, struct S_DF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_DD(void* p0, double p1, struct S_DD p2,  void (*cb)(void*, double, struct S_DD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_DP(void* p0, double p1, struct S_DP p2,  void (*cb)(void*, double, struct S_DP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_PI(void* p0, double p1, struct S_PI p2,  void (*cb)(void*, double, struct S_PI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_PF(void* p0, double p1, struct S_PF p2,  void (*cb)(void*, double, struct S_PF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_PD(void* p0, double p1, struct S_PD p2,  void (*cb)(void*, double, struct S_PD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_PP(void* p0, double p1, struct S_PP p2,  void (*cb)(void*, double, struct S_PP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_III(void* p0, double p1, struct S_III p2,  void (*cb)(void*, double, struct S_III)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_IIF(void* p0, double p1, struct S_IIF p2,  void (*cb)(void*, double, struct S_IIF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_IID(void* p0, double p1, struct S_IID p2,  void (*cb)(void*, double, struct S_IID)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_IIP(void* p0, double p1, struct S_IIP p2,  void (*cb)(void*, double, struct S_IIP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_IFI(void* p0, double p1, struct S_IFI p2,  void (*cb)(void*, double, struct S_IFI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_IFF(void* p0, double p1, struct S_IFF p2,  void (*cb)(void*, double, struct S_IFF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_IFD(void* p0, double p1, struct S_IFD p2,  void (*cb)(void*, double, struct S_IFD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_IFP(void* p0, double p1, struct S_IFP p2,  void (*cb)(void*, double, struct S_IFP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_IDI(void* p0, double p1, struct S_IDI p2,  void (*cb)(void*, double, struct S_IDI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_IDF(void* p0, double p1, struct S_IDF p2,  void (*cb)(void*, double, struct S_IDF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_IDD(void* p0, double p1, struct S_IDD p2,  void (*cb)(void*, double, struct S_IDD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_IDP(void* p0, double p1, struct S_IDP p2,  void (*cb)(void*, double, struct S_IDP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_IPI(void* p0, double p1, struct S_IPI p2,  void (*cb)(void*, double, struct S_IPI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_IPF(void* p0, double p1, struct S_IPF p2,  void (*cb)(void*, double, struct S_IPF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_IPD(void* p0, double p1, struct S_IPD p2,  void (*cb)(void*, double, struct S_IPD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_IPP(void* p0, double p1, struct S_IPP p2,  void (*cb)(void*, double, struct S_IPP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_FII(void* p0, double p1, struct S_FII p2,  void (*cb)(void*, double, struct S_FII)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_FIF(void* p0, double p1, struct S_FIF p2,  void (*cb)(void*, double, struct S_FIF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_FID(void* p0, double p1, struct S_FID p2,  void (*cb)(void*, double, struct S_FID)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_FIP(void* p0, double p1, struct S_FIP p2,  void (*cb)(void*, double, struct S_FIP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_FFI(void* p0, double p1, struct S_FFI p2,  void (*cb)(void*, double, struct S_FFI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_FFF(void* p0, double p1, struct S_FFF p2,  void (*cb)(void*, double, struct S_FFF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_FFD(void* p0, double p1, struct S_FFD p2,  void (*cb)(void*, double, struct S_FFD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_FFP(void* p0, double p1, struct S_FFP p2,  void (*cb)(void*, double, struct S_FFP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_FDI(void* p0, double p1, struct S_FDI p2,  void (*cb)(void*, double, struct S_FDI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_FDF(void* p0, double p1, struct S_FDF p2,  void (*cb)(void*, double, struct S_FDF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_FDD(void* p0, double p1, struct S_FDD p2,  void (*cb)(void*, double, struct S_FDD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_FDP(void* p0, double p1, struct S_FDP p2,  void (*cb)(void*, double, struct S_FDP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_FPI(void* p0, double p1, struct S_FPI p2,  void (*cb)(void*, double, struct S_FPI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_FPF(void* p0, double p1, struct S_FPF p2,  void (*cb)(void*, double, struct S_FPF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_FPD(void* p0, double p1, struct S_FPD p2,  void (*cb)(void*, double, struct S_FPD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_FPP(void* p0, double p1, struct S_FPP p2,  void (*cb)(void*, double, struct S_FPP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_DII(void* p0, double p1, struct S_DII p2,  void (*cb)(void*, double, struct S_DII)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_DIF(void* p0, double p1, struct S_DIF p2,  void (*cb)(void*, double, struct S_DIF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_DID(void* p0, double p1, struct S_DID p2,  void (*cb)(void*, double, struct S_DID)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_DIP(void* p0, double p1, struct S_DIP p2,  void (*cb)(void*, double, struct S_DIP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_DFI(void* p0, double p1, struct S_DFI p2,  void (*cb)(void*, double, struct S_DFI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_DFF(void* p0, double p1, struct S_DFF p2,  void (*cb)(void*, double, struct S_DFF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_DFD(void* p0, double p1, struct S_DFD p2,  void (*cb)(void*, double, struct S_DFD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_DFP(void* p0, double p1, struct S_DFP p2,  void (*cb)(void*, double, struct S_DFP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_DDI(void* p0, double p1, struct S_DDI p2,  void (*cb)(void*, double, struct S_DDI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_DDF(void* p0, double p1, struct S_DDF p2,  void (*cb)(void*, double, struct S_DDF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_DDD(void* p0, double p1, struct S_DDD p2,  void (*cb)(void*, double, struct S_DDD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_DDP(void* p0, double p1, struct S_DDP p2,  void (*cb)(void*, double, struct S_DDP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_DPI(void* p0, double p1, struct S_DPI p2,  void (*cb)(void*, double, struct S_DPI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_DPF(void* p0, double p1, struct S_DPF p2,  void (*cb)(void*, double, struct S_DPF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_DPD(void* p0, double p1, struct S_DPD p2,  void (*cb)(void*, double, struct S_DPD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_DPP(void* p0, double p1, struct S_DPP p2,  void (*cb)(void*, double, struct S_DPP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_PII(void* p0, double p1, struct S_PII p2,  void (*cb)(void*, double, struct S_PII)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_PIF(void* p0, double p1, struct S_PIF p2,  void (*cb)(void*, double, struct S_PIF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_PID(void* p0, double p1, struct S_PID p2,  void (*cb)(void*, double, struct S_PID)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_PIP(void* p0, double p1, struct S_PIP p2,  void (*cb)(void*, double, struct S_PIP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_PFI(void* p0, double p1, struct S_PFI p2,  void (*cb)(void*, double, struct S_PFI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_PFF(void* p0, double p1, struct S_PFF p2,  void (*cb)(void*, double, struct S_PFF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_PFD(void* p0, double p1, struct S_PFD p2,  void (*cb)(void*, double, struct S_PFD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_PFP(void* p0, double p1, struct S_PFP p2,  void (*cb)(void*, double, struct S_PFP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_PDI(void* p0, double p1, struct S_PDI p2,  void (*cb)(void*, double, struct S_PDI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_PDF(void* p0, double p1, struct S_PDF p2,  void (*cb)(void*, double, struct S_PDF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_PDD(void* p0, double p1, struct S_PDD p2,  void (*cb)(void*, double, struct S_PDD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_PDP(void* p0, double p1, struct S_PDP p2,  void (*cb)(void*, double, struct S_PDP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_PPI(void* p0, double p1, struct S_PPI p2,  void (*cb)(void*, double, struct S_PPI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_PPF(void* p0, double p1, struct S_PPF p2,  void (*cb)(void*, double, struct S_PPF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_PPD(void* p0, double p1, struct S_PPD p2,  void (*cb)(void*, double, struct S_PPD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PDS_PPP(void* p0, double p1, struct S_PPP p2,  void (*cb)(void*, double, struct S_PPP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPI_(void* p0, void* p1, int p2,  void (*cb)(void*, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPF_(void* p0, void* p1, float p2,  void (*cb)(void*, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPD_(void* p0, void* p1, double p2,  void (*cb)(void*, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPP_(void* p0, void* p1, void* p2,  void (*cb)(void*, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_I(void* p0, void* p1, struct S_I p2,  void (*cb)(void*, void*, struct S_I)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_F(void* p0, void* p1, struct S_F p2,  void (*cb)(void*, void*, struct S_F)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_D(void* p0, void* p1, struct S_D p2,  void (*cb)(void*, void*, struct S_D)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_P(void* p0, void* p1, struct S_P p2,  void (*cb)(void*, void*, struct S_P)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_II(void* p0, void* p1, struct S_II p2,  void (*cb)(void*, void*, struct S_II)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_IF(void* p0, void* p1, struct S_IF p2,  void (*cb)(void*, void*, struct S_IF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_ID(void* p0, void* p1, struct S_ID p2,  void (*cb)(void*, void*, struct S_ID)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_IP(void* p0, void* p1, struct S_IP p2,  void (*cb)(void*, void*, struct S_IP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_FI(void* p0, void* p1, struct S_FI p2,  void (*cb)(void*, void*, struct S_FI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_FF(void* p0, void* p1, struct S_FF p2,  void (*cb)(void*, void*, struct S_FF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_FD(void* p0, void* p1, struct S_FD p2,  void (*cb)(void*, void*, struct S_FD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_FP(void* p0, void* p1, struct S_FP p2,  void (*cb)(void*, void*, struct S_FP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_DI(void* p0, void* p1, struct S_DI p2,  void (*cb)(void*, void*, struct S_DI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_DF(void* p0, void* p1, struct S_DF p2,  void (*cb)(void*, void*, struct S_DF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_DD(void* p0, void* p1, struct S_DD p2,  void (*cb)(void*, void*, struct S_DD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_DP(void* p0, void* p1, struct S_DP p2,  void (*cb)(void*, void*, struct S_DP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_PI(void* p0, void* p1, struct S_PI p2,  void (*cb)(void*, void*, struct S_PI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_PF(void* p0, void* p1, struct S_PF p2,  void (*cb)(void*, void*, struct S_PF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_PD(void* p0, void* p1, struct S_PD p2,  void (*cb)(void*, void*, struct S_PD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_PP(void* p0, void* p1, struct S_PP p2,  void (*cb)(void*, void*, struct S_PP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_III(void* p0, void* p1, struct S_III p2,  void (*cb)(void*, void*, struct S_III)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_IIF(void* p0, void* p1, struct S_IIF p2,  void (*cb)(void*, void*, struct S_IIF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_IID(void* p0, void* p1, struct S_IID p2,  void (*cb)(void*, void*, struct S_IID)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_IIP(void* p0, void* p1, struct S_IIP p2,  void (*cb)(void*, void*, struct S_IIP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_IFI(void* p0, void* p1, struct S_IFI p2,  void (*cb)(void*, void*, struct S_IFI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_IFF(void* p0, void* p1, struct S_IFF p2,  void (*cb)(void*, void*, struct S_IFF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_IFD(void* p0, void* p1, struct S_IFD p2,  void (*cb)(void*, void*, struct S_IFD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_IFP(void* p0, void* p1, struct S_IFP p2,  void (*cb)(void*, void*, struct S_IFP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_IDI(void* p0, void* p1, struct S_IDI p2,  void (*cb)(void*, void*, struct S_IDI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_IDF(void* p0, void* p1, struct S_IDF p2,  void (*cb)(void*, void*, struct S_IDF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_IDD(void* p0, void* p1, struct S_IDD p2,  void (*cb)(void*, void*, struct S_IDD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_IDP(void* p0, void* p1, struct S_IDP p2,  void (*cb)(void*, void*, struct S_IDP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_IPI(void* p0, void* p1, struct S_IPI p2,  void (*cb)(void*, void*, struct S_IPI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_IPF(void* p0, void* p1, struct S_IPF p2,  void (*cb)(void*, void*, struct S_IPF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_IPD(void* p0, void* p1, struct S_IPD p2,  void (*cb)(void*, void*, struct S_IPD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_IPP(void* p0, void* p1, struct S_IPP p2,  void (*cb)(void*, void*, struct S_IPP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_FII(void* p0, void* p1, struct S_FII p2,  void (*cb)(void*, void*, struct S_FII)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_FIF(void* p0, void* p1, struct S_FIF p2,  void (*cb)(void*, void*, struct S_FIF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_FID(void* p0, void* p1, struct S_FID p2,  void (*cb)(void*, void*, struct S_FID)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_FIP(void* p0, void* p1, struct S_FIP p2,  void (*cb)(void*, void*, struct S_FIP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_FFI(void* p0, void* p1, struct S_FFI p2,  void (*cb)(void*, void*, struct S_FFI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_FFF(void* p0, void* p1, struct S_FFF p2,  void (*cb)(void*, void*, struct S_FFF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_FFD(void* p0, void* p1, struct S_FFD p2,  void (*cb)(void*, void*, struct S_FFD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_FFP(void* p0, void* p1, struct S_FFP p2,  void (*cb)(void*, void*, struct S_FFP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_FDI(void* p0, void* p1, struct S_FDI p2,  void (*cb)(void*, void*, struct S_FDI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_FDF(void* p0, void* p1, struct S_FDF p2,  void (*cb)(void*, void*, struct S_FDF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_FDD(void* p0, void* p1, struct S_FDD p2,  void (*cb)(void*, void*, struct S_FDD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_FDP(void* p0, void* p1, struct S_FDP p2,  void (*cb)(void*, void*, struct S_FDP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_FPI(void* p0, void* p1, struct S_FPI p2,  void (*cb)(void*, void*, struct S_FPI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_FPF(void* p0, void* p1, struct S_FPF p2,  void (*cb)(void*, void*, struct S_FPF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_FPD(void* p0, void* p1, struct S_FPD p2,  void (*cb)(void*, void*, struct S_FPD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_FPP(void* p0, void* p1, struct S_FPP p2,  void (*cb)(void*, void*, struct S_FPP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_DII(void* p0, void* p1, struct S_DII p2,  void (*cb)(void*, void*, struct S_DII)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_DIF(void* p0, void* p1, struct S_DIF p2,  void (*cb)(void*, void*, struct S_DIF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_DID(void* p0, void* p1, struct S_DID p2,  void (*cb)(void*, void*, struct S_DID)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_DIP(void* p0, void* p1, struct S_DIP p2,  void (*cb)(void*, void*, struct S_DIP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_DFI(void* p0, void* p1, struct S_DFI p2,  void (*cb)(void*, void*, struct S_DFI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_DFF(void* p0, void* p1, struct S_DFF p2,  void (*cb)(void*, void*, struct S_DFF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_DFD(void* p0, void* p1, struct S_DFD p2,  void (*cb)(void*, void*, struct S_DFD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_DFP(void* p0, void* p1, struct S_DFP p2,  void (*cb)(void*, void*, struct S_DFP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_DDI(void* p0, void* p1, struct S_DDI p2,  void (*cb)(void*, void*, struct S_DDI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_DDF(void* p0, void* p1, struct S_DDF p2,  void (*cb)(void*, void*, struct S_DDF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_DDD(void* p0, void* p1, struct S_DDD p2,  void (*cb)(void*, void*, struct S_DDD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_DDP(void* p0, void* p1, struct S_DDP p2,  void (*cb)(void*, void*, struct S_DDP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_DPI(void* p0, void* p1, struct S_DPI p2,  void (*cb)(void*, void*, struct S_DPI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_DPF(void* p0, void* p1, struct S_DPF p2,  void (*cb)(void*, void*, struct S_DPF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_DPD(void* p0, void* p1, struct S_DPD p2,  void (*cb)(void*, void*, struct S_DPD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_DPP(void* p0, void* p1, struct S_DPP p2,  void (*cb)(void*, void*, struct S_DPP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_PII(void* p0, void* p1, struct S_PII p2,  void (*cb)(void*, void*, struct S_PII)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_PIF(void* p0, void* p1, struct S_PIF p2,  void (*cb)(void*, void*, struct S_PIF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_PID(void* p0, void* p1, struct S_PID p2,  void (*cb)(void*, void*, struct S_PID)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_PIP(void* p0, void* p1, struct S_PIP p2,  void (*cb)(void*, void*, struct S_PIP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_PFI(void* p0, void* p1, struct S_PFI p2,  void (*cb)(void*, void*, struct S_PFI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_PFF(void* p0, void* p1, struct S_PFF p2,  void (*cb)(void*, void*, struct S_PFF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_PFD(void* p0, void* p1, struct S_PFD p2,  void (*cb)(void*, void*, struct S_PFD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_PFP(void* p0, void* p1, struct S_PFP p2,  void (*cb)(void*, void*, struct S_PFP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_PDI(void* p0, void* p1, struct S_PDI p2,  void (*cb)(void*, void*, struct S_PDI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_PDF(void* p0, void* p1, struct S_PDF p2,  void (*cb)(void*, void*, struct S_PDF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_PDD(void* p0, void* p1, struct S_PDD p2,  void (*cb)(void*, void*, struct S_PDD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_PDP(void* p0, void* p1, struct S_PDP p2,  void (*cb)(void*, void*, struct S_PDP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_PPI(void* p0, void* p1, struct S_PPI p2,  void (*cb)(void*, void*, struct S_PPI)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_PPF(void* p0, void* p1, struct S_PPF p2,  void (*cb)(void*, void*, struct S_PPF)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_PPD(void* p0, void* p1, struct S_PPD p2,  void (*cb)(void*, void*, struct S_PPD)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PPS_PPP(void* p0, void* p1, struct S_PPP p2,  void (*cb)(void*, void*, struct S_PPP)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_I(void* p0, struct S_I p1, int p2,  void (*cb)(void*, struct S_I, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_F(void* p0, struct S_F p1, int p2,  void (*cb)(void*, struct S_F, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_D(void* p0, struct S_D p1, int p2,  void (*cb)(void*, struct S_D, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_P(void* p0, struct S_P p1, int p2,  void (*cb)(void*, struct S_P, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_II(void* p0, struct S_II p1, int p2,  void (*cb)(void*, struct S_II, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_IF(void* p0, struct S_IF p1, int p2,  void (*cb)(void*, struct S_IF, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_ID(void* p0, struct S_ID p1, int p2,  void (*cb)(void*, struct S_ID, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_IP(void* p0, struct S_IP p1, int p2,  void (*cb)(void*, struct S_IP, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_FI(void* p0, struct S_FI p1, int p2,  void (*cb)(void*, struct S_FI, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_FF(void* p0, struct S_FF p1, int p2,  void (*cb)(void*, struct S_FF, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_FD(void* p0, struct S_FD p1, int p2,  void (*cb)(void*, struct S_FD, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_FP(void* p0, struct S_FP p1, int p2,  void (*cb)(void*, struct S_FP, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_DI(void* p0, struct S_DI p1, int p2,  void (*cb)(void*, struct S_DI, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_DF(void* p0, struct S_DF p1, int p2,  void (*cb)(void*, struct S_DF, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_DD(void* p0, struct S_DD p1, int p2,  void (*cb)(void*, struct S_DD, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_DP(void* p0, struct S_DP p1, int p2,  void (*cb)(void*, struct S_DP, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_PI(void* p0, struct S_PI p1, int p2,  void (*cb)(void*, struct S_PI, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_PF(void* p0, struct S_PF p1, int p2,  void (*cb)(void*, struct S_PF, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_PD(void* p0, struct S_PD p1, int p2,  void (*cb)(void*, struct S_PD, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_PP(void* p0, struct S_PP p1, int p2,  void (*cb)(void*, struct S_PP, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_III(void* p0, struct S_III p1, int p2,  void (*cb)(void*, struct S_III, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_IIF(void* p0, struct S_IIF p1, int p2,  void (*cb)(void*, struct S_IIF, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_IID(void* p0, struct S_IID p1, int p2,  void (*cb)(void*, struct S_IID, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_IIP(void* p0, struct S_IIP p1, int p2,  void (*cb)(void*, struct S_IIP, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_IFI(void* p0, struct S_IFI p1, int p2,  void (*cb)(void*, struct S_IFI, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_IFF(void* p0, struct S_IFF p1, int p2,  void (*cb)(void*, struct S_IFF, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_IFD(void* p0, struct S_IFD p1, int p2,  void (*cb)(void*, struct S_IFD, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_IFP(void* p0, struct S_IFP p1, int p2,  void (*cb)(void*, struct S_IFP, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_IDI(void* p0, struct S_IDI p1, int p2,  void (*cb)(void*, struct S_IDI, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_IDF(void* p0, struct S_IDF p1, int p2,  void (*cb)(void*, struct S_IDF, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_IDD(void* p0, struct S_IDD p1, int p2,  void (*cb)(void*, struct S_IDD, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_IDP(void* p0, struct S_IDP p1, int p2,  void (*cb)(void*, struct S_IDP, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_IPI(void* p0, struct S_IPI p1, int p2,  void (*cb)(void*, struct S_IPI, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_IPF(void* p0, struct S_IPF p1, int p2,  void (*cb)(void*, struct S_IPF, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_IPD(void* p0, struct S_IPD p1, int p2,  void (*cb)(void*, struct S_IPD, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_IPP(void* p0, struct S_IPP p1, int p2,  void (*cb)(void*, struct S_IPP, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_FII(void* p0, struct S_FII p1, int p2,  void (*cb)(void*, struct S_FII, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_FIF(void* p0, struct S_FIF p1, int p2,  void (*cb)(void*, struct S_FIF, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_FID(void* p0, struct S_FID p1, int p2,  void (*cb)(void*, struct S_FID, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_FIP(void* p0, struct S_FIP p1, int p2,  void (*cb)(void*, struct S_FIP, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_FFI(void* p0, struct S_FFI p1, int p2,  void (*cb)(void*, struct S_FFI, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_FFF(void* p0, struct S_FFF p1, int p2,  void (*cb)(void*, struct S_FFF, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_FFD(void* p0, struct S_FFD p1, int p2,  void (*cb)(void*, struct S_FFD, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_FFP(void* p0, struct S_FFP p1, int p2,  void (*cb)(void*, struct S_FFP, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_FDI(void* p0, struct S_FDI p1, int p2,  void (*cb)(void*, struct S_FDI, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_FDF(void* p0, struct S_FDF p1, int p2,  void (*cb)(void*, struct S_FDF, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_FDD(void* p0, struct S_FDD p1, int p2,  void (*cb)(void*, struct S_FDD, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_FDP(void* p0, struct S_FDP p1, int p2,  void (*cb)(void*, struct S_FDP, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_FPI(void* p0, struct S_FPI p1, int p2,  void (*cb)(void*, struct S_FPI, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_FPF(void* p0, struct S_FPF p1, int p2,  void (*cb)(void*, struct S_FPF, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_FPD(void* p0, struct S_FPD p1, int p2,  void (*cb)(void*, struct S_FPD, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_FPP(void* p0, struct S_FPP p1, int p2,  void (*cb)(void*, struct S_FPP, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_DII(void* p0, struct S_DII p1, int p2,  void (*cb)(void*, struct S_DII, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_DIF(void* p0, struct S_DIF p1, int p2,  void (*cb)(void*, struct S_DIF, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_DID(void* p0, struct S_DID p1, int p2,  void (*cb)(void*, struct S_DID, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_DIP(void* p0, struct S_DIP p1, int p2,  void (*cb)(void*, struct S_DIP, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_DFI(void* p0, struct S_DFI p1, int p2,  void (*cb)(void*, struct S_DFI, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_DFF(void* p0, struct S_DFF p1, int p2,  void (*cb)(void*, struct S_DFF, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_DFD(void* p0, struct S_DFD p1, int p2,  void (*cb)(void*, struct S_DFD, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_DFP(void* p0, struct S_DFP p1, int p2,  void (*cb)(void*, struct S_DFP, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_DDI(void* p0, struct S_DDI p1, int p2,  void (*cb)(void*, struct S_DDI, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_DDF(void* p0, struct S_DDF p1, int p2,  void (*cb)(void*, struct S_DDF, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_DDD(void* p0, struct S_DDD p1, int p2,  void (*cb)(void*, struct S_DDD, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_DDP(void* p0, struct S_DDP p1, int p2,  void (*cb)(void*, struct S_DDP, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_DPI(void* p0, struct S_DPI p1, int p2,  void (*cb)(void*, struct S_DPI, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_DPF(void* p0, struct S_DPF p1, int p2,  void (*cb)(void*, struct S_DPF, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_DPD(void* p0, struct S_DPD p1, int p2,  void (*cb)(void*, struct S_DPD, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_DPP(void* p0, struct S_DPP p1, int p2,  void (*cb)(void*, struct S_DPP, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_PII(void* p0, struct S_PII p1, int p2,  void (*cb)(void*, struct S_PII, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_PIF(void* p0, struct S_PIF p1, int p2,  void (*cb)(void*, struct S_PIF, int)) { cb(p0,p1,p2); }
+EXPORT void f5_V_PSI_PID(void* p0, struct S_PID p1, int p2,  void (*cb)(void*, struct S_PID, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSI_PIP(void* p0, struct S_PIP p1, int p2,  void (*cb)(void*, struct S_PIP, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSI_PFI(void* p0, struct S_PFI p1, int p2,  void (*cb)(void*, struct S_PFI, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSI_PFF(void* p0, struct S_PFF p1, int p2,  void (*cb)(void*, struct S_PFF, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSI_PFD(void* p0, struct S_PFD p1, int p2,  void (*cb)(void*, struct S_PFD, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSI_PFP(void* p0, struct S_PFP p1, int p2,  void (*cb)(void*, struct S_PFP, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSI_PDI(void* p0, struct S_PDI p1, int p2,  void (*cb)(void*, struct S_PDI, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSI_PDF(void* p0, struct S_PDF p1, int p2,  void (*cb)(void*, struct S_PDF, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSI_PDD(void* p0, struct S_PDD p1, int p2,  void (*cb)(void*, struct S_PDD, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSI_PDP(void* p0, struct S_PDP p1, int p2,  void (*cb)(void*, struct S_PDP, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSI_PPI(void* p0, struct S_PPI p1, int p2,  void (*cb)(void*, struct S_PPI, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSI_PPF(void* p0, struct S_PPF p1, int p2,  void (*cb)(void*, struct S_PPF, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSI_PPD(void* p0, struct S_PPD p1, int p2,  void (*cb)(void*, struct S_PPD, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSI_PPP(void* p0, struct S_PPP p1, int p2,  void (*cb)(void*, struct S_PPP, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_I(void* p0, struct S_I p1, float p2,  void (*cb)(void*, struct S_I, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_F(void* p0, struct S_F p1, float p2,  void (*cb)(void*, struct S_F, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_D(void* p0, struct S_D p1, float p2,  void (*cb)(void*, struct S_D, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_P(void* p0, struct S_P p1, float p2,  void (*cb)(void*, struct S_P, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_II(void* p0, struct S_II p1, float p2,  void (*cb)(void*, struct S_II, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_IF(void* p0, struct S_IF p1, float p2,  void (*cb)(void*, struct S_IF, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_ID(void* p0, struct S_ID p1, float p2,  void (*cb)(void*, struct S_ID, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_IP(void* p0, struct S_IP p1, float p2,  void (*cb)(void*, struct S_IP, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_FI(void* p0, struct S_FI p1, float p2,  void (*cb)(void*, struct S_FI, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_FF(void* p0, struct S_FF p1, float p2,  void (*cb)(void*, struct S_FF, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_FD(void* p0, struct S_FD p1, float p2,  void (*cb)(void*, struct S_FD, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_FP(void* p0, struct S_FP p1, float p2,  void (*cb)(void*, struct S_FP, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_DI(void* p0, struct S_DI p1, float p2,  void (*cb)(void*, struct S_DI, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_DF(void* p0, struct S_DF p1, float p2,  void (*cb)(void*, struct S_DF, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_DD(void* p0, struct S_DD p1, float p2,  void (*cb)(void*, struct S_DD, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_DP(void* p0, struct S_DP p1, float p2,  void (*cb)(void*, struct S_DP, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_PI(void* p0, struct S_PI p1, float p2,  void (*cb)(void*, struct S_PI, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_PF(void* p0, struct S_PF p1, float p2,  void (*cb)(void*, struct S_PF, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_PD(void* p0, struct S_PD p1, float p2,  void (*cb)(void*, struct S_PD, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_PP(void* p0, struct S_PP p1, float p2,  void (*cb)(void*, struct S_PP, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_III(void* p0, struct S_III p1, float p2,  void (*cb)(void*, struct S_III, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_IIF(void* p0, struct S_IIF p1, float p2,  void (*cb)(void*, struct S_IIF, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_IID(void* p0, struct S_IID p1, float p2,  void (*cb)(void*, struct S_IID, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_IIP(void* p0, struct S_IIP p1, float p2,  void (*cb)(void*, struct S_IIP, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_IFI(void* p0, struct S_IFI p1, float p2,  void (*cb)(void*, struct S_IFI, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_IFF(void* p0, struct S_IFF p1, float p2,  void (*cb)(void*, struct S_IFF, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_IFD(void* p0, struct S_IFD p1, float p2,  void (*cb)(void*, struct S_IFD, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_IFP(void* p0, struct S_IFP p1, float p2,  void (*cb)(void*, struct S_IFP, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_IDI(void* p0, struct S_IDI p1, float p2,  void (*cb)(void*, struct S_IDI, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_IDF(void* p0, struct S_IDF p1, float p2,  void (*cb)(void*, struct S_IDF, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_IDD(void* p0, struct S_IDD p1, float p2,  void (*cb)(void*, struct S_IDD, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_IDP(void* p0, struct S_IDP p1, float p2,  void (*cb)(void*, struct S_IDP, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_IPI(void* p0, struct S_IPI p1, float p2,  void (*cb)(void*, struct S_IPI, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_IPF(void* p0, struct S_IPF p1, float p2,  void (*cb)(void*, struct S_IPF, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_IPD(void* p0, struct S_IPD p1, float p2,  void (*cb)(void*, struct S_IPD, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_IPP(void* p0, struct S_IPP p1, float p2,  void (*cb)(void*, struct S_IPP, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_FII(void* p0, struct S_FII p1, float p2,  void (*cb)(void*, struct S_FII, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_FIF(void* p0, struct S_FIF p1, float p2,  void (*cb)(void*, struct S_FIF, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_FID(void* p0, struct S_FID p1, float p2,  void (*cb)(void*, struct S_FID, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_FIP(void* p0, struct S_FIP p1, float p2,  void (*cb)(void*, struct S_FIP, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_FFI(void* p0, struct S_FFI p1, float p2,  void (*cb)(void*, struct S_FFI, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_FFF(void* p0, struct S_FFF p1, float p2,  void (*cb)(void*, struct S_FFF, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_FFD(void* p0, struct S_FFD p1, float p2,  void (*cb)(void*, struct S_FFD, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_FFP(void* p0, struct S_FFP p1, float p2,  void (*cb)(void*, struct S_FFP, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_FDI(void* p0, struct S_FDI p1, float p2,  void (*cb)(void*, struct S_FDI, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_FDF(void* p0, struct S_FDF p1, float p2,  void (*cb)(void*, struct S_FDF, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_FDD(void* p0, struct S_FDD p1, float p2,  void (*cb)(void*, struct S_FDD, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_FDP(void* p0, struct S_FDP p1, float p2,  void (*cb)(void*, struct S_FDP, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_FPI(void* p0, struct S_FPI p1, float p2,  void (*cb)(void*, struct S_FPI, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_FPF(void* p0, struct S_FPF p1, float p2,  void (*cb)(void*, struct S_FPF, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_FPD(void* p0, struct S_FPD p1, float p2,  void (*cb)(void*, struct S_FPD, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_FPP(void* p0, struct S_FPP p1, float p2,  void (*cb)(void*, struct S_FPP, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_DII(void* p0, struct S_DII p1, float p2,  void (*cb)(void*, struct S_DII, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_DIF(void* p0, struct S_DIF p1, float p2,  void (*cb)(void*, struct S_DIF, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_DID(void* p0, struct S_DID p1, float p2,  void (*cb)(void*, struct S_DID, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_DIP(void* p0, struct S_DIP p1, float p2,  void (*cb)(void*, struct S_DIP, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_DFI(void* p0, struct S_DFI p1, float p2,  void (*cb)(void*, struct S_DFI, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_DFF(void* p0, struct S_DFF p1, float p2,  void (*cb)(void*, struct S_DFF, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_DFD(void* p0, struct S_DFD p1, float p2,  void (*cb)(void*, struct S_DFD, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_DFP(void* p0, struct S_DFP p1, float p2,  void (*cb)(void*, struct S_DFP, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_DDI(void* p0, struct S_DDI p1, float p2,  void (*cb)(void*, struct S_DDI, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_DDF(void* p0, struct S_DDF p1, float p2,  void (*cb)(void*, struct S_DDF, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_DDD(void* p0, struct S_DDD p1, float p2,  void (*cb)(void*, struct S_DDD, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_DDP(void* p0, struct S_DDP p1, float p2,  void (*cb)(void*, struct S_DDP, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_DPI(void* p0, struct S_DPI p1, float p2,  void (*cb)(void*, struct S_DPI, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_DPF(void* p0, struct S_DPF p1, float p2,  void (*cb)(void*, struct S_DPF, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_DPD(void* p0, struct S_DPD p1, float p2,  void (*cb)(void*, struct S_DPD, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_DPP(void* p0, struct S_DPP p1, float p2,  void (*cb)(void*, struct S_DPP, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_PII(void* p0, struct S_PII p1, float p2,  void (*cb)(void*, struct S_PII, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_PIF(void* p0, struct S_PIF p1, float p2,  void (*cb)(void*, struct S_PIF, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_PID(void* p0, struct S_PID p1, float p2,  void (*cb)(void*, struct S_PID, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_PIP(void* p0, struct S_PIP p1, float p2,  void (*cb)(void*, struct S_PIP, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_PFI(void* p0, struct S_PFI p1, float p2,  void (*cb)(void*, struct S_PFI, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_PFF(void* p0, struct S_PFF p1, float p2,  void (*cb)(void*, struct S_PFF, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_PFD(void* p0, struct S_PFD p1, float p2,  void (*cb)(void*, struct S_PFD, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_PFP(void* p0, struct S_PFP p1, float p2,  void (*cb)(void*, struct S_PFP, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_PDI(void* p0, struct S_PDI p1, float p2,  void (*cb)(void*, struct S_PDI, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_PDF(void* p0, struct S_PDF p1, float p2,  void (*cb)(void*, struct S_PDF, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_PDD(void* p0, struct S_PDD p1, float p2,  void (*cb)(void*, struct S_PDD, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_PDP(void* p0, struct S_PDP p1, float p2,  void (*cb)(void*, struct S_PDP, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_PPI(void* p0, struct S_PPI p1, float p2,  void (*cb)(void*, struct S_PPI, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_PPF(void* p0, struct S_PPF p1, float p2,  void (*cb)(void*, struct S_PPF, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_PPD(void* p0, struct S_PPD p1, float p2,  void (*cb)(void*, struct S_PPD, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSF_PPP(void* p0, struct S_PPP p1, float p2,  void (*cb)(void*, struct S_PPP, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_I(void* p0, struct S_I p1, double p2,  void (*cb)(void*, struct S_I, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_F(void* p0, struct S_F p1, double p2,  void (*cb)(void*, struct S_F, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_D(void* p0, struct S_D p1, double p2,  void (*cb)(void*, struct S_D, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_P(void* p0, struct S_P p1, double p2,  void (*cb)(void*, struct S_P, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_II(void* p0, struct S_II p1, double p2,  void (*cb)(void*, struct S_II, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_IF(void* p0, struct S_IF p1, double p2,  void (*cb)(void*, struct S_IF, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_ID(void* p0, struct S_ID p1, double p2,  void (*cb)(void*, struct S_ID, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_IP(void* p0, struct S_IP p1, double p2,  void (*cb)(void*, struct S_IP, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_FI(void* p0, struct S_FI p1, double p2,  void (*cb)(void*, struct S_FI, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_FF(void* p0, struct S_FF p1, double p2,  void (*cb)(void*, struct S_FF, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_FD(void* p0, struct S_FD p1, double p2,  void (*cb)(void*, struct S_FD, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_FP(void* p0, struct S_FP p1, double p2,  void (*cb)(void*, struct S_FP, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_DI(void* p0, struct S_DI p1, double p2,  void (*cb)(void*, struct S_DI, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_DF(void* p0, struct S_DF p1, double p2,  void (*cb)(void*, struct S_DF, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_DD(void* p0, struct S_DD p1, double p2,  void (*cb)(void*, struct S_DD, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_DP(void* p0, struct S_DP p1, double p2,  void (*cb)(void*, struct S_DP, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_PI(void* p0, struct S_PI p1, double p2,  void (*cb)(void*, struct S_PI, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_PF(void* p0, struct S_PF p1, double p2,  void (*cb)(void*, struct S_PF, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_PD(void* p0, struct S_PD p1, double p2,  void (*cb)(void*, struct S_PD, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_PP(void* p0, struct S_PP p1, double p2,  void (*cb)(void*, struct S_PP, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_III(void* p0, struct S_III p1, double p2,  void (*cb)(void*, struct S_III, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_IIF(void* p0, struct S_IIF p1, double p2,  void (*cb)(void*, struct S_IIF, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_IID(void* p0, struct S_IID p1, double p2,  void (*cb)(void*, struct S_IID, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_IIP(void* p0, struct S_IIP p1, double p2,  void (*cb)(void*, struct S_IIP, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_IFI(void* p0, struct S_IFI p1, double p2,  void (*cb)(void*, struct S_IFI, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_IFF(void* p0, struct S_IFF p1, double p2,  void (*cb)(void*, struct S_IFF, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_IFD(void* p0, struct S_IFD p1, double p2,  void (*cb)(void*, struct S_IFD, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_IFP(void* p0, struct S_IFP p1, double p2,  void (*cb)(void*, struct S_IFP, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_IDI(void* p0, struct S_IDI p1, double p2,  void (*cb)(void*, struct S_IDI, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_IDF(void* p0, struct S_IDF p1, double p2,  void (*cb)(void*, struct S_IDF, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_IDD(void* p0, struct S_IDD p1, double p2,  void (*cb)(void*, struct S_IDD, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_IDP(void* p0, struct S_IDP p1, double p2,  void (*cb)(void*, struct S_IDP, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_IPI(void* p0, struct S_IPI p1, double p2,  void (*cb)(void*, struct S_IPI, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_IPF(void* p0, struct S_IPF p1, double p2,  void (*cb)(void*, struct S_IPF, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_IPD(void* p0, struct S_IPD p1, double p2,  void (*cb)(void*, struct S_IPD, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_IPP(void* p0, struct S_IPP p1, double p2,  void (*cb)(void*, struct S_IPP, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_FII(void* p0, struct S_FII p1, double p2,  void (*cb)(void*, struct S_FII, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_FIF(void* p0, struct S_FIF p1, double p2,  void (*cb)(void*, struct S_FIF, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_FID(void* p0, struct S_FID p1, double p2,  void (*cb)(void*, struct S_FID, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_FIP(void* p0, struct S_FIP p1, double p2,  void (*cb)(void*, struct S_FIP, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_FFI(void* p0, struct S_FFI p1, double p2,  void (*cb)(void*, struct S_FFI, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_FFF(void* p0, struct S_FFF p1, double p2,  void (*cb)(void*, struct S_FFF, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_FFD(void* p0, struct S_FFD p1, double p2,  void (*cb)(void*, struct S_FFD, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_FFP(void* p0, struct S_FFP p1, double p2,  void (*cb)(void*, struct S_FFP, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_FDI(void* p0, struct S_FDI p1, double p2,  void (*cb)(void*, struct S_FDI, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_FDF(void* p0, struct S_FDF p1, double p2,  void (*cb)(void*, struct S_FDF, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_FDD(void* p0, struct S_FDD p1, double p2,  void (*cb)(void*, struct S_FDD, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_FDP(void* p0, struct S_FDP p1, double p2,  void (*cb)(void*, struct S_FDP, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_FPI(void* p0, struct S_FPI p1, double p2,  void (*cb)(void*, struct S_FPI, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_FPF(void* p0, struct S_FPF p1, double p2,  void (*cb)(void*, struct S_FPF, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_FPD(void* p0, struct S_FPD p1, double p2,  void (*cb)(void*, struct S_FPD, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_FPP(void* p0, struct S_FPP p1, double p2,  void (*cb)(void*, struct S_FPP, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_DII(void* p0, struct S_DII p1, double p2,  void (*cb)(void*, struct S_DII, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_DIF(void* p0, struct S_DIF p1, double p2,  void (*cb)(void*, struct S_DIF, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_DID(void* p0, struct S_DID p1, double p2,  void (*cb)(void*, struct S_DID, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_DIP(void* p0, struct S_DIP p1, double p2,  void (*cb)(void*, struct S_DIP, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_DFI(void* p0, struct S_DFI p1, double p2,  void (*cb)(void*, struct S_DFI, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_DFF(void* p0, struct S_DFF p1, double p2,  void (*cb)(void*, struct S_DFF, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_DFD(void* p0, struct S_DFD p1, double p2,  void (*cb)(void*, struct S_DFD, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_DFP(void* p0, struct S_DFP p1, double p2,  void (*cb)(void*, struct S_DFP, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_DDI(void* p0, struct S_DDI p1, double p2,  void (*cb)(void*, struct S_DDI, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_DDF(void* p0, struct S_DDF p1, double p2,  void (*cb)(void*, struct S_DDF, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_DDD(void* p0, struct S_DDD p1, double p2,  void (*cb)(void*, struct S_DDD, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_DDP(void* p0, struct S_DDP p1, double p2,  void (*cb)(void*, struct S_DDP, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_DPI(void* p0, struct S_DPI p1, double p2,  void (*cb)(void*, struct S_DPI, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_DPF(void* p0, struct S_DPF p1, double p2,  void (*cb)(void*, struct S_DPF, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_DPD(void* p0, struct S_DPD p1, double p2,  void (*cb)(void*, struct S_DPD, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_DPP(void* p0, struct S_DPP p1, double p2,  void (*cb)(void*, struct S_DPP, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_PII(void* p0, struct S_PII p1, double p2,  void (*cb)(void*, struct S_PII, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_PIF(void* p0, struct S_PIF p1, double p2,  void (*cb)(void*, struct S_PIF, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_PID(void* p0, struct S_PID p1, double p2,  void (*cb)(void*, struct S_PID, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_PIP(void* p0, struct S_PIP p1, double p2,  void (*cb)(void*, struct S_PIP, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_PFI(void* p0, struct S_PFI p1, double p2,  void (*cb)(void*, struct S_PFI, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_PFF(void* p0, struct S_PFF p1, double p2,  void (*cb)(void*, struct S_PFF, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_PFD(void* p0, struct S_PFD p1, double p2,  void (*cb)(void*, struct S_PFD, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_PFP(void* p0, struct S_PFP p1, double p2,  void (*cb)(void*, struct S_PFP, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_PDI(void* p0, struct S_PDI p1, double p2,  void (*cb)(void*, struct S_PDI, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_PDF(void* p0, struct S_PDF p1, double p2,  void (*cb)(void*, struct S_PDF, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_PDD(void* p0, struct S_PDD p1, double p2,  void (*cb)(void*, struct S_PDD, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_PDP(void* p0, struct S_PDP p1, double p2,  void (*cb)(void*, struct S_PDP, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_PPI(void* p0, struct S_PPI p1, double p2,  void (*cb)(void*, struct S_PPI, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_PPF(void* p0, struct S_PPF p1, double p2,  void (*cb)(void*, struct S_PPF, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_PPD(void* p0, struct S_PPD p1, double p2,  void (*cb)(void*, struct S_PPD, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSD_PPP(void* p0, struct S_PPP p1, double p2,  void (*cb)(void*, struct S_PPP, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_I(void* p0, struct S_I p1, void* p2,  void (*cb)(void*, struct S_I, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_F(void* p0, struct S_F p1, void* p2,  void (*cb)(void*, struct S_F, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_D(void* p0, struct S_D p1, void* p2,  void (*cb)(void*, struct S_D, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_P(void* p0, struct S_P p1, void* p2,  void (*cb)(void*, struct S_P, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_II(void* p0, struct S_II p1, void* p2,  void (*cb)(void*, struct S_II, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_IF(void* p0, struct S_IF p1, void* p2,  void (*cb)(void*, struct S_IF, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_ID(void* p0, struct S_ID p1, void* p2,  void (*cb)(void*, struct S_ID, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_IP(void* p0, struct S_IP p1, void* p2,  void (*cb)(void*, struct S_IP, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_FI(void* p0, struct S_FI p1, void* p2,  void (*cb)(void*, struct S_FI, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_FF(void* p0, struct S_FF p1, void* p2,  void (*cb)(void*, struct S_FF, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_FD(void* p0, struct S_FD p1, void* p2,  void (*cb)(void*, struct S_FD, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_FP(void* p0, struct S_FP p1, void* p2,  void (*cb)(void*, struct S_FP, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_DI(void* p0, struct S_DI p1, void* p2,  void (*cb)(void*, struct S_DI, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_DF(void* p0, struct S_DF p1, void* p2,  void (*cb)(void*, struct S_DF, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_DD(void* p0, struct S_DD p1, void* p2,  void (*cb)(void*, struct S_DD, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_DP(void* p0, struct S_DP p1, void* p2,  void (*cb)(void*, struct S_DP, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_PI(void* p0, struct S_PI p1, void* p2,  void (*cb)(void*, struct S_PI, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_PF(void* p0, struct S_PF p1, void* p2,  void (*cb)(void*, struct S_PF, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_PD(void* p0, struct S_PD p1, void* p2,  void (*cb)(void*, struct S_PD, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_PP(void* p0, struct S_PP p1, void* p2,  void (*cb)(void*, struct S_PP, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_III(void* p0, struct S_III p1, void* p2,  void (*cb)(void*, struct S_III, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_IIF(void* p0, struct S_IIF p1, void* p2,  void (*cb)(void*, struct S_IIF, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_IID(void* p0, struct S_IID p1, void* p2,  void (*cb)(void*, struct S_IID, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_IIP(void* p0, struct S_IIP p1, void* p2,  void (*cb)(void*, struct S_IIP, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_IFI(void* p0, struct S_IFI p1, void* p2,  void (*cb)(void*, struct S_IFI, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_IFF(void* p0, struct S_IFF p1, void* p2,  void (*cb)(void*, struct S_IFF, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_IFD(void* p0, struct S_IFD p1, void* p2,  void (*cb)(void*, struct S_IFD, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_IFP(void* p0, struct S_IFP p1, void* p2,  void (*cb)(void*, struct S_IFP, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_IDI(void* p0, struct S_IDI p1, void* p2,  void (*cb)(void*, struct S_IDI, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_IDF(void* p0, struct S_IDF p1, void* p2,  void (*cb)(void*, struct S_IDF, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_IDD(void* p0, struct S_IDD p1, void* p2,  void (*cb)(void*, struct S_IDD, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_IDP(void* p0, struct S_IDP p1, void* p2,  void (*cb)(void*, struct S_IDP, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_IPI(void* p0, struct S_IPI p1, void* p2,  void (*cb)(void*, struct S_IPI, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_IPF(void* p0, struct S_IPF p1, void* p2,  void (*cb)(void*, struct S_IPF, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_IPD(void* p0, struct S_IPD p1, void* p2,  void (*cb)(void*, struct S_IPD, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_IPP(void* p0, struct S_IPP p1, void* p2,  void (*cb)(void*, struct S_IPP, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_FII(void* p0, struct S_FII p1, void* p2,  void (*cb)(void*, struct S_FII, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_FIF(void* p0, struct S_FIF p1, void* p2,  void (*cb)(void*, struct S_FIF, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_FID(void* p0, struct S_FID p1, void* p2,  void (*cb)(void*, struct S_FID, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_FIP(void* p0, struct S_FIP p1, void* p2,  void (*cb)(void*, struct S_FIP, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_FFI(void* p0, struct S_FFI p1, void* p2,  void (*cb)(void*, struct S_FFI, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_FFF(void* p0, struct S_FFF p1, void* p2,  void (*cb)(void*, struct S_FFF, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_FFD(void* p0, struct S_FFD p1, void* p2,  void (*cb)(void*, struct S_FFD, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_FFP(void* p0, struct S_FFP p1, void* p2,  void (*cb)(void*, struct S_FFP, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_FDI(void* p0, struct S_FDI p1, void* p2,  void (*cb)(void*, struct S_FDI, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_FDF(void* p0, struct S_FDF p1, void* p2,  void (*cb)(void*, struct S_FDF, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_FDD(void* p0, struct S_FDD p1, void* p2,  void (*cb)(void*, struct S_FDD, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_FDP(void* p0, struct S_FDP p1, void* p2,  void (*cb)(void*, struct S_FDP, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_FPI(void* p0, struct S_FPI p1, void* p2,  void (*cb)(void*, struct S_FPI, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_FPF(void* p0, struct S_FPF p1, void* p2,  void (*cb)(void*, struct S_FPF, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_FPD(void* p0, struct S_FPD p1, void* p2,  void (*cb)(void*, struct S_FPD, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_FPP(void* p0, struct S_FPP p1, void* p2,  void (*cb)(void*, struct S_FPP, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_DII(void* p0, struct S_DII p1, void* p2,  void (*cb)(void*, struct S_DII, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_DIF(void* p0, struct S_DIF p1, void* p2,  void (*cb)(void*, struct S_DIF, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_DID(void* p0, struct S_DID p1, void* p2,  void (*cb)(void*, struct S_DID, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_DIP(void* p0, struct S_DIP p1, void* p2,  void (*cb)(void*, struct S_DIP, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_DFI(void* p0, struct S_DFI p1, void* p2,  void (*cb)(void*, struct S_DFI, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_DFF(void* p0, struct S_DFF p1, void* p2,  void (*cb)(void*, struct S_DFF, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_DFD(void* p0, struct S_DFD p1, void* p2,  void (*cb)(void*, struct S_DFD, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_DFP(void* p0, struct S_DFP p1, void* p2,  void (*cb)(void*, struct S_DFP, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_DDI(void* p0, struct S_DDI p1, void* p2,  void (*cb)(void*, struct S_DDI, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_DDF(void* p0, struct S_DDF p1, void* p2,  void (*cb)(void*, struct S_DDF, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_DDD(void* p0, struct S_DDD p1, void* p2,  void (*cb)(void*, struct S_DDD, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_DDP(void* p0, struct S_DDP p1, void* p2,  void (*cb)(void*, struct S_DDP, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_DPI(void* p0, struct S_DPI p1, void* p2,  void (*cb)(void*, struct S_DPI, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_DPF(void* p0, struct S_DPF p1, void* p2,  void (*cb)(void*, struct S_DPF, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_DPD(void* p0, struct S_DPD p1, void* p2,  void (*cb)(void*, struct S_DPD, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_DPP(void* p0, struct S_DPP p1, void* p2,  void (*cb)(void*, struct S_DPP, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_PII(void* p0, struct S_PII p1, void* p2,  void (*cb)(void*, struct S_PII, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_PIF(void* p0, struct S_PIF p1, void* p2,  void (*cb)(void*, struct S_PIF, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_PID(void* p0, struct S_PID p1, void* p2,  void (*cb)(void*, struct S_PID, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_PIP(void* p0, struct S_PIP p1, void* p2,  void (*cb)(void*, struct S_PIP, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_PFI(void* p0, struct S_PFI p1, void* p2,  void (*cb)(void*, struct S_PFI, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_PFF(void* p0, struct S_PFF p1, void* p2,  void (*cb)(void*, struct S_PFF, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_PFD(void* p0, struct S_PFD p1, void* p2,  void (*cb)(void*, struct S_PFD, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_PFP(void* p0, struct S_PFP p1, void* p2,  void (*cb)(void*, struct S_PFP, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_PDI(void* p0, struct S_PDI p1, void* p2,  void (*cb)(void*, struct S_PDI, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_PDF(void* p0, struct S_PDF p1, void* p2,  void (*cb)(void*, struct S_PDF, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_PDD(void* p0, struct S_PDD p1, void* p2,  void (*cb)(void*, struct S_PDD, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_PDP(void* p0, struct S_PDP p1, void* p2,  void (*cb)(void*, struct S_PDP, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_PPI(void* p0, struct S_PPI p1, void* p2,  void (*cb)(void*, struct S_PPI, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_PPF(void* p0, struct S_PPF p1, void* p2,  void (*cb)(void*, struct S_PPF, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_PPD(void* p0, struct S_PPD p1, void* p2,  void (*cb)(void*, struct S_PPD, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSP_PPP(void* p0, struct S_PPP p1, void* p2,  void (*cb)(void*, struct S_PPP, void*)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_I(void* p0, struct S_I p1, struct S_I p2,  void (*cb)(void*, struct S_I, struct S_I)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_F(void* p0, struct S_F p1, struct S_F p2,  void (*cb)(void*, struct S_F, struct S_F)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_D(void* p0, struct S_D p1, struct S_D p2,  void (*cb)(void*, struct S_D, struct S_D)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_P(void* p0, struct S_P p1, struct S_P p2,  void (*cb)(void*, struct S_P, struct S_P)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_II(void* p0, struct S_II p1, struct S_II p2,  void (*cb)(void*, struct S_II, struct S_II)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_IF(void* p0, struct S_IF p1, struct S_IF p2,  void (*cb)(void*, struct S_IF, struct S_IF)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_ID(void* p0, struct S_ID p1, struct S_ID p2,  void (*cb)(void*, struct S_ID, struct S_ID)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_IP(void* p0, struct S_IP p1, struct S_IP p2,  void (*cb)(void*, struct S_IP, struct S_IP)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_FI(void* p0, struct S_FI p1, struct S_FI p2,  void (*cb)(void*, struct S_FI, struct S_FI)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_FF(void* p0, struct S_FF p1, struct S_FF p2,  void (*cb)(void*, struct S_FF, struct S_FF)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_FD(void* p0, struct S_FD p1, struct S_FD p2,  void (*cb)(void*, struct S_FD, struct S_FD)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_FP(void* p0, struct S_FP p1, struct S_FP p2,  void (*cb)(void*, struct S_FP, struct S_FP)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_DI(void* p0, struct S_DI p1, struct S_DI p2,  void (*cb)(void*, struct S_DI, struct S_DI)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_DF(void* p0, struct S_DF p1, struct S_DF p2,  void (*cb)(void*, struct S_DF, struct S_DF)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_DD(void* p0, struct S_DD p1, struct S_DD p2,  void (*cb)(void*, struct S_DD, struct S_DD)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_DP(void* p0, struct S_DP p1, struct S_DP p2,  void (*cb)(void*, struct S_DP, struct S_DP)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_PI(void* p0, struct S_PI p1, struct S_PI p2,  void (*cb)(void*, struct S_PI, struct S_PI)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_PF(void* p0, struct S_PF p1, struct S_PF p2,  void (*cb)(void*, struct S_PF, struct S_PF)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_PD(void* p0, struct S_PD p1, struct S_PD p2,  void (*cb)(void*, struct S_PD, struct S_PD)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_PP(void* p0, struct S_PP p1, struct S_PP p2,  void (*cb)(void*, struct S_PP, struct S_PP)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_III(void* p0, struct S_III p1, struct S_III p2,  void (*cb)(void*, struct S_III, struct S_III)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_IIF(void* p0, struct S_IIF p1, struct S_IIF p2,  void (*cb)(void*, struct S_IIF, struct S_IIF)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_IID(void* p0, struct S_IID p1, struct S_IID p2,  void (*cb)(void*, struct S_IID, struct S_IID)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_IIP(void* p0, struct S_IIP p1, struct S_IIP p2,  void (*cb)(void*, struct S_IIP, struct S_IIP)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_IFI(void* p0, struct S_IFI p1, struct S_IFI p2,  void (*cb)(void*, struct S_IFI, struct S_IFI)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_IFF(void* p0, struct S_IFF p1, struct S_IFF p2,  void (*cb)(void*, struct S_IFF, struct S_IFF)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_IFD(void* p0, struct S_IFD p1, struct S_IFD p2,  void (*cb)(void*, struct S_IFD, struct S_IFD)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_IFP(void* p0, struct S_IFP p1, struct S_IFP p2,  void (*cb)(void*, struct S_IFP, struct S_IFP)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_IDI(void* p0, struct S_IDI p1, struct S_IDI p2,  void (*cb)(void*, struct S_IDI, struct S_IDI)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_IDF(void* p0, struct S_IDF p1, struct S_IDF p2,  void (*cb)(void*, struct S_IDF, struct S_IDF)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_IDD(void* p0, struct S_IDD p1, struct S_IDD p2,  void (*cb)(void*, struct S_IDD, struct S_IDD)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_IDP(void* p0, struct S_IDP p1, struct S_IDP p2,  void (*cb)(void*, struct S_IDP, struct S_IDP)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_IPI(void* p0, struct S_IPI p1, struct S_IPI p2,  void (*cb)(void*, struct S_IPI, struct S_IPI)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_IPF(void* p0, struct S_IPF p1, struct S_IPF p2,  void (*cb)(void*, struct S_IPF, struct S_IPF)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_IPD(void* p0, struct S_IPD p1, struct S_IPD p2,  void (*cb)(void*, struct S_IPD, struct S_IPD)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_IPP(void* p0, struct S_IPP p1, struct S_IPP p2,  void (*cb)(void*, struct S_IPP, struct S_IPP)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_FII(void* p0, struct S_FII p1, struct S_FII p2,  void (*cb)(void*, struct S_FII, struct S_FII)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_FIF(void* p0, struct S_FIF p1, struct S_FIF p2,  void (*cb)(void*, struct S_FIF, struct S_FIF)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_FID(void* p0, struct S_FID p1, struct S_FID p2,  void (*cb)(void*, struct S_FID, struct S_FID)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_FIP(void* p0, struct S_FIP p1, struct S_FIP p2,  void (*cb)(void*, struct S_FIP, struct S_FIP)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_FFI(void* p0, struct S_FFI p1, struct S_FFI p2,  void (*cb)(void*, struct S_FFI, struct S_FFI)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_FFF(void* p0, struct S_FFF p1, struct S_FFF p2,  void (*cb)(void*, struct S_FFF, struct S_FFF)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_FFD(void* p0, struct S_FFD p1, struct S_FFD p2,  void (*cb)(void*, struct S_FFD, struct S_FFD)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_FFP(void* p0, struct S_FFP p1, struct S_FFP p2,  void (*cb)(void*, struct S_FFP, struct S_FFP)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_FDI(void* p0, struct S_FDI p1, struct S_FDI p2,  void (*cb)(void*, struct S_FDI, struct S_FDI)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_FDF(void* p0, struct S_FDF p1, struct S_FDF p2,  void (*cb)(void*, struct S_FDF, struct S_FDF)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_FDD(void* p0, struct S_FDD p1, struct S_FDD p2,  void (*cb)(void*, struct S_FDD, struct S_FDD)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_FDP(void* p0, struct S_FDP p1, struct S_FDP p2,  void (*cb)(void*, struct S_FDP, struct S_FDP)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_FPI(void* p0, struct S_FPI p1, struct S_FPI p2,  void (*cb)(void*, struct S_FPI, struct S_FPI)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_FPF(void* p0, struct S_FPF p1, struct S_FPF p2,  void (*cb)(void*, struct S_FPF, struct S_FPF)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_FPD(void* p0, struct S_FPD p1, struct S_FPD p2,  void (*cb)(void*, struct S_FPD, struct S_FPD)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_FPP(void* p0, struct S_FPP p1, struct S_FPP p2,  void (*cb)(void*, struct S_FPP, struct S_FPP)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_DII(void* p0, struct S_DII p1, struct S_DII p2,  void (*cb)(void*, struct S_DII, struct S_DII)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_DIF(void* p0, struct S_DIF p1, struct S_DIF p2,  void (*cb)(void*, struct S_DIF, struct S_DIF)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_DID(void* p0, struct S_DID p1, struct S_DID p2,  void (*cb)(void*, struct S_DID, struct S_DID)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_DIP(void* p0, struct S_DIP p1, struct S_DIP p2,  void (*cb)(void*, struct S_DIP, struct S_DIP)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_DFI(void* p0, struct S_DFI p1, struct S_DFI p2,  void (*cb)(void*, struct S_DFI, struct S_DFI)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_DFF(void* p0, struct S_DFF p1, struct S_DFF p2,  void (*cb)(void*, struct S_DFF, struct S_DFF)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_DFD(void* p0, struct S_DFD p1, struct S_DFD p2,  void (*cb)(void*, struct S_DFD, struct S_DFD)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_DFP(void* p0, struct S_DFP p1, struct S_DFP p2,  void (*cb)(void*, struct S_DFP, struct S_DFP)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_DDI(void* p0, struct S_DDI p1, struct S_DDI p2,  void (*cb)(void*, struct S_DDI, struct S_DDI)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_DDF(void* p0, struct S_DDF p1, struct S_DDF p2,  void (*cb)(void*, struct S_DDF, struct S_DDF)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_DDD(void* p0, struct S_DDD p1, struct S_DDD p2,  void (*cb)(void*, struct S_DDD, struct S_DDD)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_DDP(void* p0, struct S_DDP p1, struct S_DDP p2,  void (*cb)(void*, struct S_DDP, struct S_DDP)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_DPI(void* p0, struct S_DPI p1, struct S_DPI p2,  void (*cb)(void*, struct S_DPI, struct S_DPI)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_DPF(void* p0, struct S_DPF p1, struct S_DPF p2,  void (*cb)(void*, struct S_DPF, struct S_DPF)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_DPD(void* p0, struct S_DPD p1, struct S_DPD p2,  void (*cb)(void*, struct S_DPD, struct S_DPD)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_DPP(void* p0, struct S_DPP p1, struct S_DPP p2,  void (*cb)(void*, struct S_DPP, struct S_DPP)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_PII(void* p0, struct S_PII p1, struct S_PII p2,  void (*cb)(void*, struct S_PII, struct S_PII)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_PIF(void* p0, struct S_PIF p1, struct S_PIF p2,  void (*cb)(void*, struct S_PIF, struct S_PIF)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_PID(void* p0, struct S_PID p1, struct S_PID p2,  void (*cb)(void*, struct S_PID, struct S_PID)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_PIP(void* p0, struct S_PIP p1, struct S_PIP p2,  void (*cb)(void*, struct S_PIP, struct S_PIP)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_PFI(void* p0, struct S_PFI p1, struct S_PFI p2,  void (*cb)(void*, struct S_PFI, struct S_PFI)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_PFF(void* p0, struct S_PFF p1, struct S_PFF p2,  void (*cb)(void*, struct S_PFF, struct S_PFF)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_PFD(void* p0, struct S_PFD p1, struct S_PFD p2,  void (*cb)(void*, struct S_PFD, struct S_PFD)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_PFP(void* p0, struct S_PFP p1, struct S_PFP p2,  void (*cb)(void*, struct S_PFP, struct S_PFP)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_PDI(void* p0, struct S_PDI p1, struct S_PDI p2,  void (*cb)(void*, struct S_PDI, struct S_PDI)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_PDF(void* p0, struct S_PDF p1, struct S_PDF p2,  void (*cb)(void*, struct S_PDF, struct S_PDF)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_PDD(void* p0, struct S_PDD p1, struct S_PDD p2,  void (*cb)(void*, struct S_PDD, struct S_PDD)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_PDP(void* p0, struct S_PDP p1, struct S_PDP p2,  void (*cb)(void*, struct S_PDP, struct S_PDP)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_PPI(void* p0, struct S_PPI p1, struct S_PPI p2,  void (*cb)(void*, struct S_PPI, struct S_PPI)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_PPF(void* p0, struct S_PPF p1, struct S_PPF p2,  void (*cb)(void*, struct S_PPF, struct S_PPF)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_PPD(void* p0, struct S_PPD p1, struct S_PPD p2,  void (*cb)(void*, struct S_PPD, struct S_PPD)) { cb(p0,p1,p2); }
+EXPORT void f6_V_PSS_PPP(void* p0, struct S_PPP p1, struct S_PPP p2,  void (*cb)(void*, struct S_PPP, struct S_PPP)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_I(struct S_I p0, int p1, int p2,  void (*cb)(struct S_I, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_F(struct S_F p0, int p1, int p2,  void (*cb)(struct S_F, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_D(struct S_D p0, int p1, int p2,  void (*cb)(struct S_D, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_P(struct S_P p0, int p1, int p2,  void (*cb)(struct S_P, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_II(struct S_II p0, int p1, int p2,  void (*cb)(struct S_II, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_IF(struct S_IF p0, int p1, int p2,  void (*cb)(struct S_IF, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_ID(struct S_ID p0, int p1, int p2,  void (*cb)(struct S_ID, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_IP(struct S_IP p0, int p1, int p2,  void (*cb)(struct S_IP, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_FI(struct S_FI p0, int p1, int p2,  void (*cb)(struct S_FI, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_FF(struct S_FF p0, int p1, int p2,  void (*cb)(struct S_FF, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_FD(struct S_FD p0, int p1, int p2,  void (*cb)(struct S_FD, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_FP(struct S_FP p0, int p1, int p2,  void (*cb)(struct S_FP, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_DI(struct S_DI p0, int p1, int p2,  void (*cb)(struct S_DI, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_DF(struct S_DF p0, int p1, int p2,  void (*cb)(struct S_DF, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_DD(struct S_DD p0, int p1, int p2,  void (*cb)(struct S_DD, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_DP(struct S_DP p0, int p1, int p2,  void (*cb)(struct S_DP, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_PI(struct S_PI p0, int p1, int p2,  void (*cb)(struct S_PI, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_PF(struct S_PF p0, int p1, int p2,  void (*cb)(struct S_PF, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_PD(struct S_PD p0, int p1, int p2,  void (*cb)(struct S_PD, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_PP(struct S_PP p0, int p1, int p2,  void (*cb)(struct S_PP, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_III(struct S_III p0, int p1, int p2,  void (*cb)(struct S_III, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_IIF(struct S_IIF p0, int p1, int p2,  void (*cb)(struct S_IIF, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_IID(struct S_IID p0, int p1, int p2,  void (*cb)(struct S_IID, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_IIP(struct S_IIP p0, int p1, int p2,  void (*cb)(struct S_IIP, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_IFI(struct S_IFI p0, int p1, int p2,  void (*cb)(struct S_IFI, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_IFF(struct S_IFF p0, int p1, int p2,  void (*cb)(struct S_IFF, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_IFD(struct S_IFD p0, int p1, int p2,  void (*cb)(struct S_IFD, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_IFP(struct S_IFP p0, int p1, int p2,  void (*cb)(struct S_IFP, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_IDI(struct S_IDI p0, int p1, int p2,  void (*cb)(struct S_IDI, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_IDF(struct S_IDF p0, int p1, int p2,  void (*cb)(struct S_IDF, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_IDD(struct S_IDD p0, int p1, int p2,  void (*cb)(struct S_IDD, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_IDP(struct S_IDP p0, int p1, int p2,  void (*cb)(struct S_IDP, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_IPI(struct S_IPI p0, int p1, int p2,  void (*cb)(struct S_IPI, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_IPF(struct S_IPF p0, int p1, int p2,  void (*cb)(struct S_IPF, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_IPD(struct S_IPD p0, int p1, int p2,  void (*cb)(struct S_IPD, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_IPP(struct S_IPP p0, int p1, int p2,  void (*cb)(struct S_IPP, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_FII(struct S_FII p0, int p1, int p2,  void (*cb)(struct S_FII, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_FIF(struct S_FIF p0, int p1, int p2,  void (*cb)(struct S_FIF, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_FID(struct S_FID p0, int p1, int p2,  void (*cb)(struct S_FID, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_FIP(struct S_FIP p0, int p1, int p2,  void (*cb)(struct S_FIP, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_FFI(struct S_FFI p0, int p1, int p2,  void (*cb)(struct S_FFI, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_FFF(struct S_FFF p0, int p1, int p2,  void (*cb)(struct S_FFF, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_FFD(struct S_FFD p0, int p1, int p2,  void (*cb)(struct S_FFD, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_FFP(struct S_FFP p0, int p1, int p2,  void (*cb)(struct S_FFP, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_FDI(struct S_FDI p0, int p1, int p2,  void (*cb)(struct S_FDI, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_FDF(struct S_FDF p0, int p1, int p2,  void (*cb)(struct S_FDF, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_FDD(struct S_FDD p0, int p1, int p2,  void (*cb)(struct S_FDD, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_FDP(struct S_FDP p0, int p1, int p2,  void (*cb)(struct S_FDP, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_FPI(struct S_FPI p0, int p1, int p2,  void (*cb)(struct S_FPI, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_FPF(struct S_FPF p0, int p1, int p2,  void (*cb)(struct S_FPF, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_FPD(struct S_FPD p0, int p1, int p2,  void (*cb)(struct S_FPD, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_FPP(struct S_FPP p0, int p1, int p2,  void (*cb)(struct S_FPP, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_DII(struct S_DII p0, int p1, int p2,  void (*cb)(struct S_DII, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_DIF(struct S_DIF p0, int p1, int p2,  void (*cb)(struct S_DIF, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_DID(struct S_DID p0, int p1, int p2,  void (*cb)(struct S_DID, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_DIP(struct S_DIP p0, int p1, int p2,  void (*cb)(struct S_DIP, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_DFI(struct S_DFI p0, int p1, int p2,  void (*cb)(struct S_DFI, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_DFF(struct S_DFF p0, int p1, int p2,  void (*cb)(struct S_DFF, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_DFD(struct S_DFD p0, int p1, int p2,  void (*cb)(struct S_DFD, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_DFP(struct S_DFP p0, int p1, int p2,  void (*cb)(struct S_DFP, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_DDI(struct S_DDI p0, int p1, int p2,  void (*cb)(struct S_DDI, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_DDF(struct S_DDF p0, int p1, int p2,  void (*cb)(struct S_DDF, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_DDD(struct S_DDD p0, int p1, int p2,  void (*cb)(struct S_DDD, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_DDP(struct S_DDP p0, int p1, int p2,  void (*cb)(struct S_DDP, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_DPI(struct S_DPI p0, int p1, int p2,  void (*cb)(struct S_DPI, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_DPF(struct S_DPF p0, int p1, int p2,  void (*cb)(struct S_DPF, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_DPD(struct S_DPD p0, int p1, int p2,  void (*cb)(struct S_DPD, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_DPP(struct S_DPP p0, int p1, int p2,  void (*cb)(struct S_DPP, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_PII(struct S_PII p0, int p1, int p2,  void (*cb)(struct S_PII, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_PIF(struct S_PIF p0, int p1, int p2,  void (*cb)(struct S_PIF, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_PID(struct S_PID p0, int p1, int p2,  void (*cb)(struct S_PID, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_PIP(struct S_PIP p0, int p1, int p2,  void (*cb)(struct S_PIP, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_PFI(struct S_PFI p0, int p1, int p2,  void (*cb)(struct S_PFI, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_PFF(struct S_PFF p0, int p1, int p2,  void (*cb)(struct S_PFF, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_PFD(struct S_PFD p0, int p1, int p2,  void (*cb)(struct S_PFD, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_PFP(struct S_PFP p0, int p1, int p2,  void (*cb)(struct S_PFP, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_PDI(struct S_PDI p0, int p1, int p2,  void (*cb)(struct S_PDI, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_PDF(struct S_PDF p0, int p1, int p2,  void (*cb)(struct S_PDF, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_PDD(struct S_PDD p0, int p1, int p2,  void (*cb)(struct S_PDD, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_PDP(struct S_PDP p0, int p1, int p2,  void (*cb)(struct S_PDP, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_PPI(struct S_PPI p0, int p1, int p2,  void (*cb)(struct S_PPI, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_PPF(struct S_PPF p0, int p1, int p2,  void (*cb)(struct S_PPF, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_PPD(struct S_PPD p0, int p1, int p2,  void (*cb)(struct S_PPD, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SII_PPP(struct S_PPP p0, int p1, int p2,  void (*cb)(struct S_PPP, int, int)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_I(struct S_I p0, int p1, float p2,  void (*cb)(struct S_I, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_F(struct S_F p0, int p1, float p2,  void (*cb)(struct S_F, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_D(struct S_D p0, int p1, float p2,  void (*cb)(struct S_D, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_P(struct S_P p0, int p1, float p2,  void (*cb)(struct S_P, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_II(struct S_II p0, int p1, float p2,  void (*cb)(struct S_II, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_IF(struct S_IF p0, int p1, float p2,  void (*cb)(struct S_IF, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_ID(struct S_ID p0, int p1, float p2,  void (*cb)(struct S_ID, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_IP(struct S_IP p0, int p1, float p2,  void (*cb)(struct S_IP, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_FI(struct S_FI p0, int p1, float p2,  void (*cb)(struct S_FI, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_FF(struct S_FF p0, int p1, float p2,  void (*cb)(struct S_FF, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_FD(struct S_FD p0, int p1, float p2,  void (*cb)(struct S_FD, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_FP(struct S_FP p0, int p1, float p2,  void (*cb)(struct S_FP, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_DI(struct S_DI p0, int p1, float p2,  void (*cb)(struct S_DI, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_DF(struct S_DF p0, int p1, float p2,  void (*cb)(struct S_DF, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_DD(struct S_DD p0, int p1, float p2,  void (*cb)(struct S_DD, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_DP(struct S_DP p0, int p1, float p2,  void (*cb)(struct S_DP, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_PI(struct S_PI p0, int p1, float p2,  void (*cb)(struct S_PI, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_PF(struct S_PF p0, int p1, float p2,  void (*cb)(struct S_PF, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_PD(struct S_PD p0, int p1, float p2,  void (*cb)(struct S_PD, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_PP(struct S_PP p0, int p1, float p2,  void (*cb)(struct S_PP, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_III(struct S_III p0, int p1, float p2,  void (*cb)(struct S_III, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_IIF(struct S_IIF p0, int p1, float p2,  void (*cb)(struct S_IIF, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_IID(struct S_IID p0, int p1, float p2,  void (*cb)(struct S_IID, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_IIP(struct S_IIP p0, int p1, float p2,  void (*cb)(struct S_IIP, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_IFI(struct S_IFI p0, int p1, float p2,  void (*cb)(struct S_IFI, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_IFF(struct S_IFF p0, int p1, float p2,  void (*cb)(struct S_IFF, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_IFD(struct S_IFD p0, int p1, float p2,  void (*cb)(struct S_IFD, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_IFP(struct S_IFP p0, int p1, float p2,  void (*cb)(struct S_IFP, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_IDI(struct S_IDI p0, int p1, float p2,  void (*cb)(struct S_IDI, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_IDF(struct S_IDF p0, int p1, float p2,  void (*cb)(struct S_IDF, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_IDD(struct S_IDD p0, int p1, float p2,  void (*cb)(struct S_IDD, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_IDP(struct S_IDP p0, int p1, float p2,  void (*cb)(struct S_IDP, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_IPI(struct S_IPI p0, int p1, float p2,  void (*cb)(struct S_IPI, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_IPF(struct S_IPF p0, int p1, float p2,  void (*cb)(struct S_IPF, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_IPD(struct S_IPD p0, int p1, float p2,  void (*cb)(struct S_IPD, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_IPP(struct S_IPP p0, int p1, float p2,  void (*cb)(struct S_IPP, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_FII(struct S_FII p0, int p1, float p2,  void (*cb)(struct S_FII, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_FIF(struct S_FIF p0, int p1, float p2,  void (*cb)(struct S_FIF, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_FID(struct S_FID p0, int p1, float p2,  void (*cb)(struct S_FID, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_FIP(struct S_FIP p0, int p1, float p2,  void (*cb)(struct S_FIP, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_FFI(struct S_FFI p0, int p1, float p2,  void (*cb)(struct S_FFI, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_FFF(struct S_FFF p0, int p1, float p2,  void (*cb)(struct S_FFF, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_FFD(struct S_FFD p0, int p1, float p2,  void (*cb)(struct S_FFD, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_FFP(struct S_FFP p0, int p1, float p2,  void (*cb)(struct S_FFP, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_FDI(struct S_FDI p0, int p1, float p2,  void (*cb)(struct S_FDI, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_FDF(struct S_FDF p0, int p1, float p2,  void (*cb)(struct S_FDF, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_FDD(struct S_FDD p0, int p1, float p2,  void (*cb)(struct S_FDD, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_FDP(struct S_FDP p0, int p1, float p2,  void (*cb)(struct S_FDP, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_FPI(struct S_FPI p0, int p1, float p2,  void (*cb)(struct S_FPI, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_FPF(struct S_FPF p0, int p1, float p2,  void (*cb)(struct S_FPF, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_FPD(struct S_FPD p0, int p1, float p2,  void (*cb)(struct S_FPD, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_FPP(struct S_FPP p0, int p1, float p2,  void (*cb)(struct S_FPP, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_DII(struct S_DII p0, int p1, float p2,  void (*cb)(struct S_DII, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_DIF(struct S_DIF p0, int p1, float p2,  void (*cb)(struct S_DIF, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_DID(struct S_DID p0, int p1, float p2,  void (*cb)(struct S_DID, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_DIP(struct S_DIP p0, int p1, float p2,  void (*cb)(struct S_DIP, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_DFI(struct S_DFI p0, int p1, float p2,  void (*cb)(struct S_DFI, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_DFF(struct S_DFF p0, int p1, float p2,  void (*cb)(struct S_DFF, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_DFD(struct S_DFD p0, int p1, float p2,  void (*cb)(struct S_DFD, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_DFP(struct S_DFP p0, int p1, float p2,  void (*cb)(struct S_DFP, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_DDI(struct S_DDI p0, int p1, float p2,  void (*cb)(struct S_DDI, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_DDF(struct S_DDF p0, int p1, float p2,  void (*cb)(struct S_DDF, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_DDD(struct S_DDD p0, int p1, float p2,  void (*cb)(struct S_DDD, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_DDP(struct S_DDP p0, int p1, float p2,  void (*cb)(struct S_DDP, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_DPI(struct S_DPI p0, int p1, float p2,  void (*cb)(struct S_DPI, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_DPF(struct S_DPF p0, int p1, float p2,  void (*cb)(struct S_DPF, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_DPD(struct S_DPD p0, int p1, float p2,  void (*cb)(struct S_DPD, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_DPP(struct S_DPP p0, int p1, float p2,  void (*cb)(struct S_DPP, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_PII(struct S_PII p0, int p1, float p2,  void (*cb)(struct S_PII, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_PIF(struct S_PIF p0, int p1, float p2,  void (*cb)(struct S_PIF, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_PID(struct S_PID p0, int p1, float p2,  void (*cb)(struct S_PID, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_PIP(struct S_PIP p0, int p1, float p2,  void (*cb)(struct S_PIP, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_PFI(struct S_PFI p0, int p1, float p2,  void (*cb)(struct S_PFI, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_PFF(struct S_PFF p0, int p1, float p2,  void (*cb)(struct S_PFF, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_PFD(struct S_PFD p0, int p1, float p2,  void (*cb)(struct S_PFD, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_PFP(struct S_PFP p0, int p1, float p2,  void (*cb)(struct S_PFP, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_PDI(struct S_PDI p0, int p1, float p2,  void (*cb)(struct S_PDI, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_PDF(struct S_PDF p0, int p1, float p2,  void (*cb)(struct S_PDF, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_PDD(struct S_PDD p0, int p1, float p2,  void (*cb)(struct S_PDD, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_PDP(struct S_PDP p0, int p1, float p2,  void (*cb)(struct S_PDP, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_PPI(struct S_PPI p0, int p1, float p2,  void (*cb)(struct S_PPI, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_PPF(struct S_PPF p0, int p1, float p2,  void (*cb)(struct S_PPF, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_PPD(struct S_PPD p0, int p1, float p2,  void (*cb)(struct S_PPD, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SIF_PPP(struct S_PPP p0, int p1, float p2,  void (*cb)(struct S_PPP, int, float)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_I(struct S_I p0, int p1, double p2,  void (*cb)(struct S_I, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_F(struct S_F p0, int p1, double p2,  void (*cb)(struct S_F, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_D(struct S_D p0, int p1, double p2,  void (*cb)(struct S_D, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_P(struct S_P p0, int p1, double p2,  void (*cb)(struct S_P, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_II(struct S_II p0, int p1, double p2,  void (*cb)(struct S_II, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_IF(struct S_IF p0, int p1, double p2,  void (*cb)(struct S_IF, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_ID(struct S_ID p0, int p1, double p2,  void (*cb)(struct S_ID, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_IP(struct S_IP p0, int p1, double p2,  void (*cb)(struct S_IP, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_FI(struct S_FI p0, int p1, double p2,  void (*cb)(struct S_FI, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_FF(struct S_FF p0, int p1, double p2,  void (*cb)(struct S_FF, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_FD(struct S_FD p0, int p1, double p2,  void (*cb)(struct S_FD, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_FP(struct S_FP p0, int p1, double p2,  void (*cb)(struct S_FP, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_DI(struct S_DI p0, int p1, double p2,  void (*cb)(struct S_DI, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_DF(struct S_DF p0, int p1, double p2,  void (*cb)(struct S_DF, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_DD(struct S_DD p0, int p1, double p2,  void (*cb)(struct S_DD, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_DP(struct S_DP p0, int p1, double p2,  void (*cb)(struct S_DP, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_PI(struct S_PI p0, int p1, double p2,  void (*cb)(struct S_PI, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_PF(struct S_PF p0, int p1, double p2,  void (*cb)(struct S_PF, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_PD(struct S_PD p0, int p1, double p2,  void (*cb)(struct S_PD, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_PP(struct S_PP p0, int p1, double p2,  void (*cb)(struct S_PP, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_III(struct S_III p0, int p1, double p2,  void (*cb)(struct S_III, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_IIF(struct S_IIF p0, int p1, double p2,  void (*cb)(struct S_IIF, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_IID(struct S_IID p0, int p1, double p2,  void (*cb)(struct S_IID, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_IIP(struct S_IIP p0, int p1, double p2,  void (*cb)(struct S_IIP, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_IFI(struct S_IFI p0, int p1, double p2,  void (*cb)(struct S_IFI, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_IFF(struct S_IFF p0, int p1, double p2,  void (*cb)(struct S_IFF, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_IFD(struct S_IFD p0, int p1, double p2,  void (*cb)(struct S_IFD, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_IFP(struct S_IFP p0, int p1, double p2,  void (*cb)(struct S_IFP, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_IDI(struct S_IDI p0, int p1, double p2,  void (*cb)(struct S_IDI, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_IDF(struct S_IDF p0, int p1, double p2,  void (*cb)(struct S_IDF, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_IDD(struct S_IDD p0, int p1, double p2,  void (*cb)(struct S_IDD, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_IDP(struct S_IDP p0, int p1, double p2,  void (*cb)(struct S_IDP, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_IPI(struct S_IPI p0, int p1, double p2,  void (*cb)(struct S_IPI, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_IPF(struct S_IPF p0, int p1, double p2,  void (*cb)(struct S_IPF, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_IPD(struct S_IPD p0, int p1, double p2,  void (*cb)(struct S_IPD, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_IPP(struct S_IPP p0, int p1, double p2,  void (*cb)(struct S_IPP, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_FII(struct S_FII p0, int p1, double p2,  void (*cb)(struct S_FII, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_FIF(struct S_FIF p0, int p1, double p2,  void (*cb)(struct S_FIF, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_FID(struct S_FID p0, int p1, double p2,  void (*cb)(struct S_FID, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_FIP(struct S_FIP p0, int p1, double p2,  void (*cb)(struct S_FIP, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_FFI(struct S_FFI p0, int p1, double p2,  void (*cb)(struct S_FFI, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_FFF(struct S_FFF p0, int p1, double p2,  void (*cb)(struct S_FFF, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_FFD(struct S_FFD p0, int p1, double p2,  void (*cb)(struct S_FFD, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_FFP(struct S_FFP p0, int p1, double p2,  void (*cb)(struct S_FFP, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_FDI(struct S_FDI p0, int p1, double p2,  void (*cb)(struct S_FDI, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_FDF(struct S_FDF p0, int p1, double p2,  void (*cb)(struct S_FDF, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_FDD(struct S_FDD p0, int p1, double p2,  void (*cb)(struct S_FDD, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_FDP(struct S_FDP p0, int p1, double p2,  void (*cb)(struct S_FDP, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_FPI(struct S_FPI p0, int p1, double p2,  void (*cb)(struct S_FPI, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_FPF(struct S_FPF p0, int p1, double p2,  void (*cb)(struct S_FPF, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_FPD(struct S_FPD p0, int p1, double p2,  void (*cb)(struct S_FPD, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_FPP(struct S_FPP p0, int p1, double p2,  void (*cb)(struct S_FPP, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_DII(struct S_DII p0, int p1, double p2,  void (*cb)(struct S_DII, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_DIF(struct S_DIF p0, int p1, double p2,  void (*cb)(struct S_DIF, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_DID(struct S_DID p0, int p1, double p2,  void (*cb)(struct S_DID, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_DIP(struct S_DIP p0, int p1, double p2,  void (*cb)(struct S_DIP, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_DFI(struct S_DFI p0, int p1, double p2,  void (*cb)(struct S_DFI, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_DFF(struct S_DFF p0, int p1, double p2,  void (*cb)(struct S_DFF, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_DFD(struct S_DFD p0, int p1, double p2,  void (*cb)(struct S_DFD, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_DFP(struct S_DFP p0, int p1, double p2,  void (*cb)(struct S_DFP, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_DDI(struct S_DDI p0, int p1, double p2,  void (*cb)(struct S_DDI, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_DDF(struct S_DDF p0, int p1, double p2,  void (*cb)(struct S_DDF, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_DDD(struct S_DDD p0, int p1, double p2,  void (*cb)(struct S_DDD, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_DDP(struct S_DDP p0, int p1, double p2,  void (*cb)(struct S_DDP, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_DPI(struct S_DPI p0, int p1, double p2,  void (*cb)(struct S_DPI, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_DPF(struct S_DPF p0, int p1, double p2,  void (*cb)(struct S_DPF, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_DPD(struct S_DPD p0, int p1, double p2,  void (*cb)(struct S_DPD, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_DPP(struct S_DPP p0, int p1, double p2,  void (*cb)(struct S_DPP, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_PII(struct S_PII p0, int p1, double p2,  void (*cb)(struct S_PII, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_PIF(struct S_PIF p0, int p1, double p2,  void (*cb)(struct S_PIF, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_PID(struct S_PID p0, int p1, double p2,  void (*cb)(struct S_PID, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_PIP(struct S_PIP p0, int p1, double p2,  void (*cb)(struct S_PIP, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_PFI(struct S_PFI p0, int p1, double p2,  void (*cb)(struct S_PFI, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_PFF(struct S_PFF p0, int p1, double p2,  void (*cb)(struct S_PFF, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_PFD(struct S_PFD p0, int p1, double p2,  void (*cb)(struct S_PFD, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_PFP(struct S_PFP p0, int p1, double p2,  void (*cb)(struct S_PFP, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_PDI(struct S_PDI p0, int p1, double p2,  void (*cb)(struct S_PDI, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_PDF(struct S_PDF p0, int p1, double p2,  void (*cb)(struct S_PDF, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_PDD(struct S_PDD p0, int p1, double p2,  void (*cb)(struct S_PDD, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_PDP(struct S_PDP p0, int p1, double p2,  void (*cb)(struct S_PDP, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_PPI(struct S_PPI p0, int p1, double p2,  void (*cb)(struct S_PPI, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_PPF(struct S_PPF p0, int p1, double p2,  void (*cb)(struct S_PPF, int, double)) { cb(p0,p1,p2); }
+EXPORT void f6_V_SID_PPD(struct S_PPD p0, int p1, double p2,  void (*cb)(struct S_PPD, int, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SID_PPP(struct S_PPP p0, int p1, double p2,  void (*cb)(struct S_PPP, int, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_I(struct S_I p0, int p1, void* p2,  void (*cb)(struct S_I, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_F(struct S_F p0, int p1, void* p2,  void (*cb)(struct S_F, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_D(struct S_D p0, int p1, void* p2,  void (*cb)(struct S_D, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_P(struct S_P p0, int p1, void* p2,  void (*cb)(struct S_P, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_II(struct S_II p0, int p1, void* p2,  void (*cb)(struct S_II, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_IF(struct S_IF p0, int p1, void* p2,  void (*cb)(struct S_IF, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_ID(struct S_ID p0, int p1, void* p2,  void (*cb)(struct S_ID, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_IP(struct S_IP p0, int p1, void* p2,  void (*cb)(struct S_IP, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_FI(struct S_FI p0, int p1, void* p2,  void (*cb)(struct S_FI, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_FF(struct S_FF p0, int p1, void* p2,  void (*cb)(struct S_FF, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_FD(struct S_FD p0, int p1, void* p2,  void (*cb)(struct S_FD, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_FP(struct S_FP p0, int p1, void* p2,  void (*cb)(struct S_FP, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_DI(struct S_DI p0, int p1, void* p2,  void (*cb)(struct S_DI, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_DF(struct S_DF p0, int p1, void* p2,  void (*cb)(struct S_DF, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_DD(struct S_DD p0, int p1, void* p2,  void (*cb)(struct S_DD, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_DP(struct S_DP p0, int p1, void* p2,  void (*cb)(struct S_DP, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_PI(struct S_PI p0, int p1, void* p2,  void (*cb)(struct S_PI, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_PF(struct S_PF p0, int p1, void* p2,  void (*cb)(struct S_PF, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_PD(struct S_PD p0, int p1, void* p2,  void (*cb)(struct S_PD, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_PP(struct S_PP p0, int p1, void* p2,  void (*cb)(struct S_PP, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_III(struct S_III p0, int p1, void* p2,  void (*cb)(struct S_III, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_IIF(struct S_IIF p0, int p1, void* p2,  void (*cb)(struct S_IIF, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_IID(struct S_IID p0, int p1, void* p2,  void (*cb)(struct S_IID, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_IIP(struct S_IIP p0, int p1, void* p2,  void (*cb)(struct S_IIP, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_IFI(struct S_IFI p0, int p1, void* p2,  void (*cb)(struct S_IFI, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_IFF(struct S_IFF p0, int p1, void* p2,  void (*cb)(struct S_IFF, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_IFD(struct S_IFD p0, int p1, void* p2,  void (*cb)(struct S_IFD, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_IFP(struct S_IFP p0, int p1, void* p2,  void (*cb)(struct S_IFP, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_IDI(struct S_IDI p0, int p1, void* p2,  void (*cb)(struct S_IDI, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_IDF(struct S_IDF p0, int p1, void* p2,  void (*cb)(struct S_IDF, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_IDD(struct S_IDD p0, int p1, void* p2,  void (*cb)(struct S_IDD, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_IDP(struct S_IDP p0, int p1, void* p2,  void (*cb)(struct S_IDP, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_IPI(struct S_IPI p0, int p1, void* p2,  void (*cb)(struct S_IPI, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_IPF(struct S_IPF p0, int p1, void* p2,  void (*cb)(struct S_IPF, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_IPD(struct S_IPD p0, int p1, void* p2,  void (*cb)(struct S_IPD, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_IPP(struct S_IPP p0, int p1, void* p2,  void (*cb)(struct S_IPP, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_FII(struct S_FII p0, int p1, void* p2,  void (*cb)(struct S_FII, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_FIF(struct S_FIF p0, int p1, void* p2,  void (*cb)(struct S_FIF, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_FID(struct S_FID p0, int p1, void* p2,  void (*cb)(struct S_FID, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_FIP(struct S_FIP p0, int p1, void* p2,  void (*cb)(struct S_FIP, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_FFI(struct S_FFI p0, int p1, void* p2,  void (*cb)(struct S_FFI, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_FFF(struct S_FFF p0, int p1, void* p2,  void (*cb)(struct S_FFF, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_FFD(struct S_FFD p0, int p1, void* p2,  void (*cb)(struct S_FFD, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_FFP(struct S_FFP p0, int p1, void* p2,  void (*cb)(struct S_FFP, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_FDI(struct S_FDI p0, int p1, void* p2,  void (*cb)(struct S_FDI, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_FDF(struct S_FDF p0, int p1, void* p2,  void (*cb)(struct S_FDF, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_FDD(struct S_FDD p0, int p1, void* p2,  void (*cb)(struct S_FDD, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_FDP(struct S_FDP p0, int p1, void* p2,  void (*cb)(struct S_FDP, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_FPI(struct S_FPI p0, int p1, void* p2,  void (*cb)(struct S_FPI, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_FPF(struct S_FPF p0, int p1, void* p2,  void (*cb)(struct S_FPF, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_FPD(struct S_FPD p0, int p1, void* p2,  void (*cb)(struct S_FPD, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_FPP(struct S_FPP p0, int p1, void* p2,  void (*cb)(struct S_FPP, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_DII(struct S_DII p0, int p1, void* p2,  void (*cb)(struct S_DII, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_DIF(struct S_DIF p0, int p1, void* p2,  void (*cb)(struct S_DIF, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_DID(struct S_DID p0, int p1, void* p2,  void (*cb)(struct S_DID, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_DIP(struct S_DIP p0, int p1, void* p2,  void (*cb)(struct S_DIP, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_DFI(struct S_DFI p0, int p1, void* p2,  void (*cb)(struct S_DFI, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_DFF(struct S_DFF p0, int p1, void* p2,  void (*cb)(struct S_DFF, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_DFD(struct S_DFD p0, int p1, void* p2,  void (*cb)(struct S_DFD, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_DFP(struct S_DFP p0, int p1, void* p2,  void (*cb)(struct S_DFP, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_DDI(struct S_DDI p0, int p1, void* p2,  void (*cb)(struct S_DDI, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_DDF(struct S_DDF p0, int p1, void* p2,  void (*cb)(struct S_DDF, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_DDD(struct S_DDD p0, int p1, void* p2,  void (*cb)(struct S_DDD, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_DDP(struct S_DDP p0, int p1, void* p2,  void (*cb)(struct S_DDP, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_DPI(struct S_DPI p0, int p1, void* p2,  void (*cb)(struct S_DPI, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_DPF(struct S_DPF p0, int p1, void* p2,  void (*cb)(struct S_DPF, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_DPD(struct S_DPD p0, int p1, void* p2,  void (*cb)(struct S_DPD, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_DPP(struct S_DPP p0, int p1, void* p2,  void (*cb)(struct S_DPP, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_PII(struct S_PII p0, int p1, void* p2,  void (*cb)(struct S_PII, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_PIF(struct S_PIF p0, int p1, void* p2,  void (*cb)(struct S_PIF, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_PID(struct S_PID p0, int p1, void* p2,  void (*cb)(struct S_PID, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_PIP(struct S_PIP p0, int p1, void* p2,  void (*cb)(struct S_PIP, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_PFI(struct S_PFI p0, int p1, void* p2,  void (*cb)(struct S_PFI, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_PFF(struct S_PFF p0, int p1, void* p2,  void (*cb)(struct S_PFF, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_PFD(struct S_PFD p0, int p1, void* p2,  void (*cb)(struct S_PFD, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_PFP(struct S_PFP p0, int p1, void* p2,  void (*cb)(struct S_PFP, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_PDI(struct S_PDI p0, int p1, void* p2,  void (*cb)(struct S_PDI, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_PDF(struct S_PDF p0, int p1, void* p2,  void (*cb)(struct S_PDF, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_PDD(struct S_PDD p0, int p1, void* p2,  void (*cb)(struct S_PDD, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_PDP(struct S_PDP p0, int p1, void* p2,  void (*cb)(struct S_PDP, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_PPI(struct S_PPI p0, int p1, void* p2,  void (*cb)(struct S_PPI, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_PPF(struct S_PPF p0, int p1, void* p2,  void (*cb)(struct S_PPF, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_PPD(struct S_PPD p0, int p1, void* p2,  void (*cb)(struct S_PPD, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIP_PPP(struct S_PPP p0, int p1, void* p2,  void (*cb)(struct S_PPP, int, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_I(struct S_I p0, int p1, struct S_I p2,  void (*cb)(struct S_I, int, struct S_I)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_F(struct S_F p0, int p1, struct S_F p2,  void (*cb)(struct S_F, int, struct S_F)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_D(struct S_D p0, int p1, struct S_D p2,  void (*cb)(struct S_D, int, struct S_D)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_P(struct S_P p0, int p1, struct S_P p2,  void (*cb)(struct S_P, int, struct S_P)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_II(struct S_II p0, int p1, struct S_II p2,  void (*cb)(struct S_II, int, struct S_II)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_IF(struct S_IF p0, int p1, struct S_IF p2,  void (*cb)(struct S_IF, int, struct S_IF)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_ID(struct S_ID p0, int p1, struct S_ID p2,  void (*cb)(struct S_ID, int, struct S_ID)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_IP(struct S_IP p0, int p1, struct S_IP p2,  void (*cb)(struct S_IP, int, struct S_IP)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_FI(struct S_FI p0, int p1, struct S_FI p2,  void (*cb)(struct S_FI, int, struct S_FI)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_FF(struct S_FF p0, int p1, struct S_FF p2,  void (*cb)(struct S_FF, int, struct S_FF)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_FD(struct S_FD p0, int p1, struct S_FD p2,  void (*cb)(struct S_FD, int, struct S_FD)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_FP(struct S_FP p0, int p1, struct S_FP p2,  void (*cb)(struct S_FP, int, struct S_FP)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_DI(struct S_DI p0, int p1, struct S_DI p2,  void (*cb)(struct S_DI, int, struct S_DI)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_DF(struct S_DF p0, int p1, struct S_DF p2,  void (*cb)(struct S_DF, int, struct S_DF)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_DD(struct S_DD p0, int p1, struct S_DD p2,  void (*cb)(struct S_DD, int, struct S_DD)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_DP(struct S_DP p0, int p1, struct S_DP p2,  void (*cb)(struct S_DP, int, struct S_DP)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_PI(struct S_PI p0, int p1, struct S_PI p2,  void (*cb)(struct S_PI, int, struct S_PI)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_PF(struct S_PF p0, int p1, struct S_PF p2,  void (*cb)(struct S_PF, int, struct S_PF)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_PD(struct S_PD p0, int p1, struct S_PD p2,  void (*cb)(struct S_PD, int, struct S_PD)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_PP(struct S_PP p0, int p1, struct S_PP p2,  void (*cb)(struct S_PP, int, struct S_PP)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_III(struct S_III p0, int p1, struct S_III p2,  void (*cb)(struct S_III, int, struct S_III)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_IIF(struct S_IIF p0, int p1, struct S_IIF p2,  void (*cb)(struct S_IIF, int, struct S_IIF)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_IID(struct S_IID p0, int p1, struct S_IID p2,  void (*cb)(struct S_IID, int, struct S_IID)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_IIP(struct S_IIP p0, int p1, struct S_IIP p2,  void (*cb)(struct S_IIP, int, struct S_IIP)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_IFI(struct S_IFI p0, int p1, struct S_IFI p2,  void (*cb)(struct S_IFI, int, struct S_IFI)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_IFF(struct S_IFF p0, int p1, struct S_IFF p2,  void (*cb)(struct S_IFF, int, struct S_IFF)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_IFD(struct S_IFD p0, int p1, struct S_IFD p2,  void (*cb)(struct S_IFD, int, struct S_IFD)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_IFP(struct S_IFP p0, int p1, struct S_IFP p2,  void (*cb)(struct S_IFP, int, struct S_IFP)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_IDI(struct S_IDI p0, int p1, struct S_IDI p2,  void (*cb)(struct S_IDI, int, struct S_IDI)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_IDF(struct S_IDF p0, int p1, struct S_IDF p2,  void (*cb)(struct S_IDF, int, struct S_IDF)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_IDD(struct S_IDD p0, int p1, struct S_IDD p2,  void (*cb)(struct S_IDD, int, struct S_IDD)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_IDP(struct S_IDP p0, int p1, struct S_IDP p2,  void (*cb)(struct S_IDP, int, struct S_IDP)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_IPI(struct S_IPI p0, int p1, struct S_IPI p2,  void (*cb)(struct S_IPI, int, struct S_IPI)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_IPF(struct S_IPF p0, int p1, struct S_IPF p2,  void (*cb)(struct S_IPF, int, struct S_IPF)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_IPD(struct S_IPD p0, int p1, struct S_IPD p2,  void (*cb)(struct S_IPD, int, struct S_IPD)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_IPP(struct S_IPP p0, int p1, struct S_IPP p2,  void (*cb)(struct S_IPP, int, struct S_IPP)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_FII(struct S_FII p0, int p1, struct S_FII p2,  void (*cb)(struct S_FII, int, struct S_FII)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_FIF(struct S_FIF p0, int p1, struct S_FIF p2,  void (*cb)(struct S_FIF, int, struct S_FIF)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_FID(struct S_FID p0, int p1, struct S_FID p2,  void (*cb)(struct S_FID, int, struct S_FID)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_FIP(struct S_FIP p0, int p1, struct S_FIP p2,  void (*cb)(struct S_FIP, int, struct S_FIP)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_FFI(struct S_FFI p0, int p1, struct S_FFI p2,  void (*cb)(struct S_FFI, int, struct S_FFI)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_FFF(struct S_FFF p0, int p1, struct S_FFF p2,  void (*cb)(struct S_FFF, int, struct S_FFF)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_FFD(struct S_FFD p0, int p1, struct S_FFD p2,  void (*cb)(struct S_FFD, int, struct S_FFD)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_FFP(struct S_FFP p0, int p1, struct S_FFP p2,  void (*cb)(struct S_FFP, int, struct S_FFP)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_FDI(struct S_FDI p0, int p1, struct S_FDI p2,  void (*cb)(struct S_FDI, int, struct S_FDI)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_FDF(struct S_FDF p0, int p1, struct S_FDF p2,  void (*cb)(struct S_FDF, int, struct S_FDF)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_FDD(struct S_FDD p0, int p1, struct S_FDD p2,  void (*cb)(struct S_FDD, int, struct S_FDD)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_FDP(struct S_FDP p0, int p1, struct S_FDP p2,  void (*cb)(struct S_FDP, int, struct S_FDP)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_FPI(struct S_FPI p0, int p1, struct S_FPI p2,  void (*cb)(struct S_FPI, int, struct S_FPI)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_FPF(struct S_FPF p0, int p1, struct S_FPF p2,  void (*cb)(struct S_FPF, int, struct S_FPF)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_FPD(struct S_FPD p0, int p1, struct S_FPD p2,  void (*cb)(struct S_FPD, int, struct S_FPD)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_FPP(struct S_FPP p0, int p1, struct S_FPP p2,  void (*cb)(struct S_FPP, int, struct S_FPP)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_DII(struct S_DII p0, int p1, struct S_DII p2,  void (*cb)(struct S_DII, int, struct S_DII)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_DIF(struct S_DIF p0, int p1, struct S_DIF p2,  void (*cb)(struct S_DIF, int, struct S_DIF)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_DID(struct S_DID p0, int p1, struct S_DID p2,  void (*cb)(struct S_DID, int, struct S_DID)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_DIP(struct S_DIP p0, int p1, struct S_DIP p2,  void (*cb)(struct S_DIP, int, struct S_DIP)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_DFI(struct S_DFI p0, int p1, struct S_DFI p2,  void (*cb)(struct S_DFI, int, struct S_DFI)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_DFF(struct S_DFF p0, int p1, struct S_DFF p2,  void (*cb)(struct S_DFF, int, struct S_DFF)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_DFD(struct S_DFD p0, int p1, struct S_DFD p2,  void (*cb)(struct S_DFD, int, struct S_DFD)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_DFP(struct S_DFP p0, int p1, struct S_DFP p2,  void (*cb)(struct S_DFP, int, struct S_DFP)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_DDI(struct S_DDI p0, int p1, struct S_DDI p2,  void (*cb)(struct S_DDI, int, struct S_DDI)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_DDF(struct S_DDF p0, int p1, struct S_DDF p2,  void (*cb)(struct S_DDF, int, struct S_DDF)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_DDD(struct S_DDD p0, int p1, struct S_DDD p2,  void (*cb)(struct S_DDD, int, struct S_DDD)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_DDP(struct S_DDP p0, int p1, struct S_DDP p2,  void (*cb)(struct S_DDP, int, struct S_DDP)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_DPI(struct S_DPI p0, int p1, struct S_DPI p2,  void (*cb)(struct S_DPI, int, struct S_DPI)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_DPF(struct S_DPF p0, int p1, struct S_DPF p2,  void (*cb)(struct S_DPF, int, struct S_DPF)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_DPD(struct S_DPD p0, int p1, struct S_DPD p2,  void (*cb)(struct S_DPD, int, struct S_DPD)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_DPP(struct S_DPP p0, int p1, struct S_DPP p2,  void (*cb)(struct S_DPP, int, struct S_DPP)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_PII(struct S_PII p0, int p1, struct S_PII p2,  void (*cb)(struct S_PII, int, struct S_PII)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_PIF(struct S_PIF p0, int p1, struct S_PIF p2,  void (*cb)(struct S_PIF, int, struct S_PIF)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_PID(struct S_PID p0, int p1, struct S_PID p2,  void (*cb)(struct S_PID, int, struct S_PID)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_PIP(struct S_PIP p0, int p1, struct S_PIP p2,  void (*cb)(struct S_PIP, int, struct S_PIP)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_PFI(struct S_PFI p0, int p1, struct S_PFI p2,  void (*cb)(struct S_PFI, int, struct S_PFI)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_PFF(struct S_PFF p0, int p1, struct S_PFF p2,  void (*cb)(struct S_PFF, int, struct S_PFF)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_PFD(struct S_PFD p0, int p1, struct S_PFD p2,  void (*cb)(struct S_PFD, int, struct S_PFD)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_PFP(struct S_PFP p0, int p1, struct S_PFP p2,  void (*cb)(struct S_PFP, int, struct S_PFP)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_PDI(struct S_PDI p0, int p1, struct S_PDI p2,  void (*cb)(struct S_PDI, int, struct S_PDI)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_PDF(struct S_PDF p0, int p1, struct S_PDF p2,  void (*cb)(struct S_PDF, int, struct S_PDF)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_PDD(struct S_PDD p0, int p1, struct S_PDD p2,  void (*cb)(struct S_PDD, int, struct S_PDD)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_PDP(struct S_PDP p0, int p1, struct S_PDP p2,  void (*cb)(struct S_PDP, int, struct S_PDP)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_PPI(struct S_PPI p0, int p1, struct S_PPI p2,  void (*cb)(struct S_PPI, int, struct S_PPI)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_PPF(struct S_PPF p0, int p1, struct S_PPF p2,  void (*cb)(struct S_PPF, int, struct S_PPF)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_PPD(struct S_PPD p0, int p1, struct S_PPD p2,  void (*cb)(struct S_PPD, int, struct S_PPD)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SIS_PPP(struct S_PPP p0, int p1, struct S_PPP p2,  void (*cb)(struct S_PPP, int, struct S_PPP)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_I(struct S_I p0, float p1, int p2,  void (*cb)(struct S_I, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_F(struct S_F p0, float p1, int p2,  void (*cb)(struct S_F, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_D(struct S_D p0, float p1, int p2,  void (*cb)(struct S_D, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_P(struct S_P p0, float p1, int p2,  void (*cb)(struct S_P, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_II(struct S_II p0, float p1, int p2,  void (*cb)(struct S_II, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_IF(struct S_IF p0, float p1, int p2,  void (*cb)(struct S_IF, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_ID(struct S_ID p0, float p1, int p2,  void (*cb)(struct S_ID, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_IP(struct S_IP p0, float p1, int p2,  void (*cb)(struct S_IP, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_FI(struct S_FI p0, float p1, int p2,  void (*cb)(struct S_FI, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_FF(struct S_FF p0, float p1, int p2,  void (*cb)(struct S_FF, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_FD(struct S_FD p0, float p1, int p2,  void (*cb)(struct S_FD, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_FP(struct S_FP p0, float p1, int p2,  void (*cb)(struct S_FP, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_DI(struct S_DI p0, float p1, int p2,  void (*cb)(struct S_DI, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_DF(struct S_DF p0, float p1, int p2,  void (*cb)(struct S_DF, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_DD(struct S_DD p0, float p1, int p2,  void (*cb)(struct S_DD, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_DP(struct S_DP p0, float p1, int p2,  void (*cb)(struct S_DP, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_PI(struct S_PI p0, float p1, int p2,  void (*cb)(struct S_PI, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_PF(struct S_PF p0, float p1, int p2,  void (*cb)(struct S_PF, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_PD(struct S_PD p0, float p1, int p2,  void (*cb)(struct S_PD, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_PP(struct S_PP p0, float p1, int p2,  void (*cb)(struct S_PP, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_III(struct S_III p0, float p1, int p2,  void (*cb)(struct S_III, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_IIF(struct S_IIF p0, float p1, int p2,  void (*cb)(struct S_IIF, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_IID(struct S_IID p0, float p1, int p2,  void (*cb)(struct S_IID, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_IIP(struct S_IIP p0, float p1, int p2,  void (*cb)(struct S_IIP, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_IFI(struct S_IFI p0, float p1, int p2,  void (*cb)(struct S_IFI, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_IFF(struct S_IFF p0, float p1, int p2,  void (*cb)(struct S_IFF, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_IFD(struct S_IFD p0, float p1, int p2,  void (*cb)(struct S_IFD, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_IFP(struct S_IFP p0, float p1, int p2,  void (*cb)(struct S_IFP, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_IDI(struct S_IDI p0, float p1, int p2,  void (*cb)(struct S_IDI, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_IDF(struct S_IDF p0, float p1, int p2,  void (*cb)(struct S_IDF, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_IDD(struct S_IDD p0, float p1, int p2,  void (*cb)(struct S_IDD, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_IDP(struct S_IDP p0, float p1, int p2,  void (*cb)(struct S_IDP, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_IPI(struct S_IPI p0, float p1, int p2,  void (*cb)(struct S_IPI, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_IPF(struct S_IPF p0, float p1, int p2,  void (*cb)(struct S_IPF, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_IPD(struct S_IPD p0, float p1, int p2,  void (*cb)(struct S_IPD, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_IPP(struct S_IPP p0, float p1, int p2,  void (*cb)(struct S_IPP, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_FII(struct S_FII p0, float p1, int p2,  void (*cb)(struct S_FII, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_FIF(struct S_FIF p0, float p1, int p2,  void (*cb)(struct S_FIF, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_FID(struct S_FID p0, float p1, int p2,  void (*cb)(struct S_FID, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_FIP(struct S_FIP p0, float p1, int p2,  void (*cb)(struct S_FIP, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_FFI(struct S_FFI p0, float p1, int p2,  void (*cb)(struct S_FFI, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_FFF(struct S_FFF p0, float p1, int p2,  void (*cb)(struct S_FFF, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_FFD(struct S_FFD p0, float p1, int p2,  void (*cb)(struct S_FFD, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_FFP(struct S_FFP p0, float p1, int p2,  void (*cb)(struct S_FFP, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_FDI(struct S_FDI p0, float p1, int p2,  void (*cb)(struct S_FDI, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_FDF(struct S_FDF p0, float p1, int p2,  void (*cb)(struct S_FDF, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_FDD(struct S_FDD p0, float p1, int p2,  void (*cb)(struct S_FDD, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_FDP(struct S_FDP p0, float p1, int p2,  void (*cb)(struct S_FDP, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_FPI(struct S_FPI p0, float p1, int p2,  void (*cb)(struct S_FPI, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_FPF(struct S_FPF p0, float p1, int p2,  void (*cb)(struct S_FPF, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_FPD(struct S_FPD p0, float p1, int p2,  void (*cb)(struct S_FPD, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_FPP(struct S_FPP p0, float p1, int p2,  void (*cb)(struct S_FPP, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_DII(struct S_DII p0, float p1, int p2,  void (*cb)(struct S_DII, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_DIF(struct S_DIF p0, float p1, int p2,  void (*cb)(struct S_DIF, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_DID(struct S_DID p0, float p1, int p2,  void (*cb)(struct S_DID, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_DIP(struct S_DIP p0, float p1, int p2,  void (*cb)(struct S_DIP, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_DFI(struct S_DFI p0, float p1, int p2,  void (*cb)(struct S_DFI, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_DFF(struct S_DFF p0, float p1, int p2,  void (*cb)(struct S_DFF, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_DFD(struct S_DFD p0, float p1, int p2,  void (*cb)(struct S_DFD, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_DFP(struct S_DFP p0, float p1, int p2,  void (*cb)(struct S_DFP, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_DDI(struct S_DDI p0, float p1, int p2,  void (*cb)(struct S_DDI, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_DDF(struct S_DDF p0, float p1, int p2,  void (*cb)(struct S_DDF, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_DDD(struct S_DDD p0, float p1, int p2,  void (*cb)(struct S_DDD, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_DDP(struct S_DDP p0, float p1, int p2,  void (*cb)(struct S_DDP, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_DPI(struct S_DPI p0, float p1, int p2,  void (*cb)(struct S_DPI, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_DPF(struct S_DPF p0, float p1, int p2,  void (*cb)(struct S_DPF, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_DPD(struct S_DPD p0, float p1, int p2,  void (*cb)(struct S_DPD, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_DPP(struct S_DPP p0, float p1, int p2,  void (*cb)(struct S_DPP, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_PII(struct S_PII p0, float p1, int p2,  void (*cb)(struct S_PII, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_PIF(struct S_PIF p0, float p1, int p2,  void (*cb)(struct S_PIF, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_PID(struct S_PID p0, float p1, int p2,  void (*cb)(struct S_PID, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_PIP(struct S_PIP p0, float p1, int p2,  void (*cb)(struct S_PIP, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_PFI(struct S_PFI p0, float p1, int p2,  void (*cb)(struct S_PFI, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_PFF(struct S_PFF p0, float p1, int p2,  void (*cb)(struct S_PFF, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_PFD(struct S_PFD p0, float p1, int p2,  void (*cb)(struct S_PFD, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_PFP(struct S_PFP p0, float p1, int p2,  void (*cb)(struct S_PFP, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_PDI(struct S_PDI p0, float p1, int p2,  void (*cb)(struct S_PDI, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_PDF(struct S_PDF p0, float p1, int p2,  void (*cb)(struct S_PDF, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_PDD(struct S_PDD p0, float p1, int p2,  void (*cb)(struct S_PDD, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_PDP(struct S_PDP p0, float p1, int p2,  void (*cb)(struct S_PDP, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_PPI(struct S_PPI p0, float p1, int p2,  void (*cb)(struct S_PPI, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_PPF(struct S_PPF p0, float p1, int p2,  void (*cb)(struct S_PPF, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_PPD(struct S_PPD p0, float p1, int p2,  void (*cb)(struct S_PPD, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFI_PPP(struct S_PPP p0, float p1, int p2,  void (*cb)(struct S_PPP, float, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_I(struct S_I p0, float p1, float p2,  void (*cb)(struct S_I, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_F(struct S_F p0, float p1, float p2,  void (*cb)(struct S_F, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_D(struct S_D p0, float p1, float p2,  void (*cb)(struct S_D, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_P(struct S_P p0, float p1, float p2,  void (*cb)(struct S_P, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_II(struct S_II p0, float p1, float p2,  void (*cb)(struct S_II, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_IF(struct S_IF p0, float p1, float p2,  void (*cb)(struct S_IF, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_ID(struct S_ID p0, float p1, float p2,  void (*cb)(struct S_ID, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_IP(struct S_IP p0, float p1, float p2,  void (*cb)(struct S_IP, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_FI(struct S_FI p0, float p1, float p2,  void (*cb)(struct S_FI, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_FF(struct S_FF p0, float p1, float p2,  void (*cb)(struct S_FF, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_FD(struct S_FD p0, float p1, float p2,  void (*cb)(struct S_FD, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_FP(struct S_FP p0, float p1, float p2,  void (*cb)(struct S_FP, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_DI(struct S_DI p0, float p1, float p2,  void (*cb)(struct S_DI, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_DF(struct S_DF p0, float p1, float p2,  void (*cb)(struct S_DF, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_DD(struct S_DD p0, float p1, float p2,  void (*cb)(struct S_DD, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_DP(struct S_DP p0, float p1, float p2,  void (*cb)(struct S_DP, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_PI(struct S_PI p0, float p1, float p2,  void (*cb)(struct S_PI, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_PF(struct S_PF p0, float p1, float p2,  void (*cb)(struct S_PF, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_PD(struct S_PD p0, float p1, float p2,  void (*cb)(struct S_PD, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_PP(struct S_PP p0, float p1, float p2,  void (*cb)(struct S_PP, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_III(struct S_III p0, float p1, float p2,  void (*cb)(struct S_III, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_IIF(struct S_IIF p0, float p1, float p2,  void (*cb)(struct S_IIF, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_IID(struct S_IID p0, float p1, float p2,  void (*cb)(struct S_IID, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_IIP(struct S_IIP p0, float p1, float p2,  void (*cb)(struct S_IIP, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_IFI(struct S_IFI p0, float p1, float p2,  void (*cb)(struct S_IFI, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_IFF(struct S_IFF p0, float p1, float p2,  void (*cb)(struct S_IFF, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_IFD(struct S_IFD p0, float p1, float p2,  void (*cb)(struct S_IFD, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_IFP(struct S_IFP p0, float p1, float p2,  void (*cb)(struct S_IFP, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_IDI(struct S_IDI p0, float p1, float p2,  void (*cb)(struct S_IDI, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_IDF(struct S_IDF p0, float p1, float p2,  void (*cb)(struct S_IDF, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_IDD(struct S_IDD p0, float p1, float p2,  void (*cb)(struct S_IDD, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_IDP(struct S_IDP p0, float p1, float p2,  void (*cb)(struct S_IDP, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_IPI(struct S_IPI p0, float p1, float p2,  void (*cb)(struct S_IPI, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_IPF(struct S_IPF p0, float p1, float p2,  void (*cb)(struct S_IPF, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_IPD(struct S_IPD p0, float p1, float p2,  void (*cb)(struct S_IPD, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_IPP(struct S_IPP p0, float p1, float p2,  void (*cb)(struct S_IPP, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_FII(struct S_FII p0, float p1, float p2,  void (*cb)(struct S_FII, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_FIF(struct S_FIF p0, float p1, float p2,  void (*cb)(struct S_FIF, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_FID(struct S_FID p0, float p1, float p2,  void (*cb)(struct S_FID, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_FIP(struct S_FIP p0, float p1, float p2,  void (*cb)(struct S_FIP, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_FFI(struct S_FFI p0, float p1, float p2,  void (*cb)(struct S_FFI, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_FFF(struct S_FFF p0, float p1, float p2,  void (*cb)(struct S_FFF, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_FFD(struct S_FFD p0, float p1, float p2,  void (*cb)(struct S_FFD, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_FFP(struct S_FFP p0, float p1, float p2,  void (*cb)(struct S_FFP, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_FDI(struct S_FDI p0, float p1, float p2,  void (*cb)(struct S_FDI, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_FDF(struct S_FDF p0, float p1, float p2,  void (*cb)(struct S_FDF, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_FDD(struct S_FDD p0, float p1, float p2,  void (*cb)(struct S_FDD, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_FDP(struct S_FDP p0, float p1, float p2,  void (*cb)(struct S_FDP, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_FPI(struct S_FPI p0, float p1, float p2,  void (*cb)(struct S_FPI, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_FPF(struct S_FPF p0, float p1, float p2,  void (*cb)(struct S_FPF, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_FPD(struct S_FPD p0, float p1, float p2,  void (*cb)(struct S_FPD, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_FPP(struct S_FPP p0, float p1, float p2,  void (*cb)(struct S_FPP, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_DII(struct S_DII p0, float p1, float p2,  void (*cb)(struct S_DII, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_DIF(struct S_DIF p0, float p1, float p2,  void (*cb)(struct S_DIF, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_DID(struct S_DID p0, float p1, float p2,  void (*cb)(struct S_DID, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_DIP(struct S_DIP p0, float p1, float p2,  void (*cb)(struct S_DIP, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_DFI(struct S_DFI p0, float p1, float p2,  void (*cb)(struct S_DFI, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_DFF(struct S_DFF p0, float p1, float p2,  void (*cb)(struct S_DFF, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_DFD(struct S_DFD p0, float p1, float p2,  void (*cb)(struct S_DFD, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_DFP(struct S_DFP p0, float p1, float p2,  void (*cb)(struct S_DFP, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_DDI(struct S_DDI p0, float p1, float p2,  void (*cb)(struct S_DDI, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_DDF(struct S_DDF p0, float p1, float p2,  void (*cb)(struct S_DDF, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_DDD(struct S_DDD p0, float p1, float p2,  void (*cb)(struct S_DDD, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_DDP(struct S_DDP p0, float p1, float p2,  void (*cb)(struct S_DDP, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_DPI(struct S_DPI p0, float p1, float p2,  void (*cb)(struct S_DPI, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_DPF(struct S_DPF p0, float p1, float p2,  void (*cb)(struct S_DPF, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_DPD(struct S_DPD p0, float p1, float p2,  void (*cb)(struct S_DPD, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_DPP(struct S_DPP p0, float p1, float p2,  void (*cb)(struct S_DPP, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_PII(struct S_PII p0, float p1, float p2,  void (*cb)(struct S_PII, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_PIF(struct S_PIF p0, float p1, float p2,  void (*cb)(struct S_PIF, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_PID(struct S_PID p0, float p1, float p2,  void (*cb)(struct S_PID, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_PIP(struct S_PIP p0, float p1, float p2,  void (*cb)(struct S_PIP, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_PFI(struct S_PFI p0, float p1, float p2,  void (*cb)(struct S_PFI, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_PFF(struct S_PFF p0, float p1, float p2,  void (*cb)(struct S_PFF, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_PFD(struct S_PFD p0, float p1, float p2,  void (*cb)(struct S_PFD, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_PFP(struct S_PFP p0, float p1, float p2,  void (*cb)(struct S_PFP, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_PDI(struct S_PDI p0, float p1, float p2,  void (*cb)(struct S_PDI, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_PDF(struct S_PDF p0, float p1, float p2,  void (*cb)(struct S_PDF, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_PDD(struct S_PDD p0, float p1, float p2,  void (*cb)(struct S_PDD, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_PDP(struct S_PDP p0, float p1, float p2,  void (*cb)(struct S_PDP, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_PPI(struct S_PPI p0, float p1, float p2,  void (*cb)(struct S_PPI, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_PPF(struct S_PPF p0, float p1, float p2,  void (*cb)(struct S_PPF, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_PPD(struct S_PPD p0, float p1, float p2,  void (*cb)(struct S_PPD, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFF_PPP(struct S_PPP p0, float p1, float p2,  void (*cb)(struct S_PPP, float, float)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_I(struct S_I p0, float p1, double p2,  void (*cb)(struct S_I, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_F(struct S_F p0, float p1, double p2,  void (*cb)(struct S_F, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_D(struct S_D p0, float p1, double p2,  void (*cb)(struct S_D, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_P(struct S_P p0, float p1, double p2,  void (*cb)(struct S_P, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_II(struct S_II p0, float p1, double p2,  void (*cb)(struct S_II, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_IF(struct S_IF p0, float p1, double p2,  void (*cb)(struct S_IF, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_ID(struct S_ID p0, float p1, double p2,  void (*cb)(struct S_ID, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_IP(struct S_IP p0, float p1, double p2,  void (*cb)(struct S_IP, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_FI(struct S_FI p0, float p1, double p2,  void (*cb)(struct S_FI, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_FF(struct S_FF p0, float p1, double p2,  void (*cb)(struct S_FF, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_FD(struct S_FD p0, float p1, double p2,  void (*cb)(struct S_FD, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_FP(struct S_FP p0, float p1, double p2,  void (*cb)(struct S_FP, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_DI(struct S_DI p0, float p1, double p2,  void (*cb)(struct S_DI, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_DF(struct S_DF p0, float p1, double p2,  void (*cb)(struct S_DF, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_DD(struct S_DD p0, float p1, double p2,  void (*cb)(struct S_DD, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_DP(struct S_DP p0, float p1, double p2,  void (*cb)(struct S_DP, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_PI(struct S_PI p0, float p1, double p2,  void (*cb)(struct S_PI, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_PF(struct S_PF p0, float p1, double p2,  void (*cb)(struct S_PF, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_PD(struct S_PD p0, float p1, double p2,  void (*cb)(struct S_PD, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_PP(struct S_PP p0, float p1, double p2,  void (*cb)(struct S_PP, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_III(struct S_III p0, float p1, double p2,  void (*cb)(struct S_III, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_IIF(struct S_IIF p0, float p1, double p2,  void (*cb)(struct S_IIF, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_IID(struct S_IID p0, float p1, double p2,  void (*cb)(struct S_IID, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_IIP(struct S_IIP p0, float p1, double p2,  void (*cb)(struct S_IIP, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_IFI(struct S_IFI p0, float p1, double p2,  void (*cb)(struct S_IFI, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_IFF(struct S_IFF p0, float p1, double p2,  void (*cb)(struct S_IFF, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_IFD(struct S_IFD p0, float p1, double p2,  void (*cb)(struct S_IFD, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_IFP(struct S_IFP p0, float p1, double p2,  void (*cb)(struct S_IFP, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_IDI(struct S_IDI p0, float p1, double p2,  void (*cb)(struct S_IDI, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_IDF(struct S_IDF p0, float p1, double p2,  void (*cb)(struct S_IDF, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_IDD(struct S_IDD p0, float p1, double p2,  void (*cb)(struct S_IDD, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_IDP(struct S_IDP p0, float p1, double p2,  void (*cb)(struct S_IDP, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_IPI(struct S_IPI p0, float p1, double p2,  void (*cb)(struct S_IPI, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_IPF(struct S_IPF p0, float p1, double p2,  void (*cb)(struct S_IPF, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_IPD(struct S_IPD p0, float p1, double p2,  void (*cb)(struct S_IPD, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_IPP(struct S_IPP p0, float p1, double p2,  void (*cb)(struct S_IPP, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_FII(struct S_FII p0, float p1, double p2,  void (*cb)(struct S_FII, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_FIF(struct S_FIF p0, float p1, double p2,  void (*cb)(struct S_FIF, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_FID(struct S_FID p0, float p1, double p2,  void (*cb)(struct S_FID, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_FIP(struct S_FIP p0, float p1, double p2,  void (*cb)(struct S_FIP, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_FFI(struct S_FFI p0, float p1, double p2,  void (*cb)(struct S_FFI, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_FFF(struct S_FFF p0, float p1, double p2,  void (*cb)(struct S_FFF, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_FFD(struct S_FFD p0, float p1, double p2,  void (*cb)(struct S_FFD, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_FFP(struct S_FFP p0, float p1, double p2,  void (*cb)(struct S_FFP, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_FDI(struct S_FDI p0, float p1, double p2,  void (*cb)(struct S_FDI, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_FDF(struct S_FDF p0, float p1, double p2,  void (*cb)(struct S_FDF, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_FDD(struct S_FDD p0, float p1, double p2,  void (*cb)(struct S_FDD, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_FDP(struct S_FDP p0, float p1, double p2,  void (*cb)(struct S_FDP, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_FPI(struct S_FPI p0, float p1, double p2,  void (*cb)(struct S_FPI, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_FPF(struct S_FPF p0, float p1, double p2,  void (*cb)(struct S_FPF, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_FPD(struct S_FPD p0, float p1, double p2,  void (*cb)(struct S_FPD, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_FPP(struct S_FPP p0, float p1, double p2,  void (*cb)(struct S_FPP, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_DII(struct S_DII p0, float p1, double p2,  void (*cb)(struct S_DII, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_DIF(struct S_DIF p0, float p1, double p2,  void (*cb)(struct S_DIF, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_DID(struct S_DID p0, float p1, double p2,  void (*cb)(struct S_DID, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_DIP(struct S_DIP p0, float p1, double p2,  void (*cb)(struct S_DIP, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_DFI(struct S_DFI p0, float p1, double p2,  void (*cb)(struct S_DFI, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_DFF(struct S_DFF p0, float p1, double p2,  void (*cb)(struct S_DFF, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_DFD(struct S_DFD p0, float p1, double p2,  void (*cb)(struct S_DFD, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_DFP(struct S_DFP p0, float p1, double p2,  void (*cb)(struct S_DFP, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_DDI(struct S_DDI p0, float p1, double p2,  void (*cb)(struct S_DDI, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_DDF(struct S_DDF p0, float p1, double p2,  void (*cb)(struct S_DDF, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_DDD(struct S_DDD p0, float p1, double p2,  void (*cb)(struct S_DDD, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_DDP(struct S_DDP p0, float p1, double p2,  void (*cb)(struct S_DDP, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_DPI(struct S_DPI p0, float p1, double p2,  void (*cb)(struct S_DPI, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_DPF(struct S_DPF p0, float p1, double p2,  void (*cb)(struct S_DPF, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_DPD(struct S_DPD p0, float p1, double p2,  void (*cb)(struct S_DPD, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_DPP(struct S_DPP p0, float p1, double p2,  void (*cb)(struct S_DPP, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_PII(struct S_PII p0, float p1, double p2,  void (*cb)(struct S_PII, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_PIF(struct S_PIF p0, float p1, double p2,  void (*cb)(struct S_PIF, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_PID(struct S_PID p0, float p1, double p2,  void (*cb)(struct S_PID, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_PIP(struct S_PIP p0, float p1, double p2,  void (*cb)(struct S_PIP, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_PFI(struct S_PFI p0, float p1, double p2,  void (*cb)(struct S_PFI, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_PFF(struct S_PFF p0, float p1, double p2,  void (*cb)(struct S_PFF, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_PFD(struct S_PFD p0, float p1, double p2,  void (*cb)(struct S_PFD, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_PFP(struct S_PFP p0, float p1, double p2,  void (*cb)(struct S_PFP, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_PDI(struct S_PDI p0, float p1, double p2,  void (*cb)(struct S_PDI, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_PDF(struct S_PDF p0, float p1, double p2,  void (*cb)(struct S_PDF, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_PDD(struct S_PDD p0, float p1, double p2,  void (*cb)(struct S_PDD, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_PDP(struct S_PDP p0, float p1, double p2,  void (*cb)(struct S_PDP, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_PPI(struct S_PPI p0, float p1, double p2,  void (*cb)(struct S_PPI, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_PPF(struct S_PPF p0, float p1, double p2,  void (*cb)(struct S_PPF, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_PPD(struct S_PPD p0, float p1, double p2,  void (*cb)(struct S_PPD, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFD_PPP(struct S_PPP p0, float p1, double p2,  void (*cb)(struct S_PPP, float, double)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_I(struct S_I p0, float p1, void* p2,  void (*cb)(struct S_I, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_F(struct S_F p0, float p1, void* p2,  void (*cb)(struct S_F, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_D(struct S_D p0, float p1, void* p2,  void (*cb)(struct S_D, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_P(struct S_P p0, float p1, void* p2,  void (*cb)(struct S_P, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_II(struct S_II p0, float p1, void* p2,  void (*cb)(struct S_II, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_IF(struct S_IF p0, float p1, void* p2,  void (*cb)(struct S_IF, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_ID(struct S_ID p0, float p1, void* p2,  void (*cb)(struct S_ID, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_IP(struct S_IP p0, float p1, void* p2,  void (*cb)(struct S_IP, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_FI(struct S_FI p0, float p1, void* p2,  void (*cb)(struct S_FI, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_FF(struct S_FF p0, float p1, void* p2,  void (*cb)(struct S_FF, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_FD(struct S_FD p0, float p1, void* p2,  void (*cb)(struct S_FD, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_FP(struct S_FP p0, float p1, void* p2,  void (*cb)(struct S_FP, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_DI(struct S_DI p0, float p1, void* p2,  void (*cb)(struct S_DI, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_DF(struct S_DF p0, float p1, void* p2,  void (*cb)(struct S_DF, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_DD(struct S_DD p0, float p1, void* p2,  void (*cb)(struct S_DD, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_DP(struct S_DP p0, float p1, void* p2,  void (*cb)(struct S_DP, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_PI(struct S_PI p0, float p1, void* p2,  void (*cb)(struct S_PI, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_PF(struct S_PF p0, float p1, void* p2,  void (*cb)(struct S_PF, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_PD(struct S_PD p0, float p1, void* p2,  void (*cb)(struct S_PD, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_PP(struct S_PP p0, float p1, void* p2,  void (*cb)(struct S_PP, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_III(struct S_III p0, float p1, void* p2,  void (*cb)(struct S_III, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_IIF(struct S_IIF p0, float p1, void* p2,  void (*cb)(struct S_IIF, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_IID(struct S_IID p0, float p1, void* p2,  void (*cb)(struct S_IID, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_IIP(struct S_IIP p0, float p1, void* p2,  void (*cb)(struct S_IIP, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_IFI(struct S_IFI p0, float p1, void* p2,  void (*cb)(struct S_IFI, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_IFF(struct S_IFF p0, float p1, void* p2,  void (*cb)(struct S_IFF, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_IFD(struct S_IFD p0, float p1, void* p2,  void (*cb)(struct S_IFD, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_IFP(struct S_IFP p0, float p1, void* p2,  void (*cb)(struct S_IFP, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_IDI(struct S_IDI p0, float p1, void* p2,  void (*cb)(struct S_IDI, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_IDF(struct S_IDF p0, float p1, void* p2,  void (*cb)(struct S_IDF, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_IDD(struct S_IDD p0, float p1, void* p2,  void (*cb)(struct S_IDD, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_IDP(struct S_IDP p0, float p1, void* p2,  void (*cb)(struct S_IDP, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_IPI(struct S_IPI p0, float p1, void* p2,  void (*cb)(struct S_IPI, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_IPF(struct S_IPF p0, float p1, void* p2,  void (*cb)(struct S_IPF, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_IPD(struct S_IPD p0, float p1, void* p2,  void (*cb)(struct S_IPD, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_IPP(struct S_IPP p0, float p1, void* p2,  void (*cb)(struct S_IPP, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_FII(struct S_FII p0, float p1, void* p2,  void (*cb)(struct S_FII, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_FIF(struct S_FIF p0, float p1, void* p2,  void (*cb)(struct S_FIF, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_FID(struct S_FID p0, float p1, void* p2,  void (*cb)(struct S_FID, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_FIP(struct S_FIP p0, float p1, void* p2,  void (*cb)(struct S_FIP, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_FFI(struct S_FFI p0, float p1, void* p2,  void (*cb)(struct S_FFI, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_FFF(struct S_FFF p0, float p1, void* p2,  void (*cb)(struct S_FFF, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_FFD(struct S_FFD p0, float p1, void* p2,  void (*cb)(struct S_FFD, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_FFP(struct S_FFP p0, float p1, void* p2,  void (*cb)(struct S_FFP, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_FDI(struct S_FDI p0, float p1, void* p2,  void (*cb)(struct S_FDI, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_FDF(struct S_FDF p0, float p1, void* p2,  void (*cb)(struct S_FDF, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_FDD(struct S_FDD p0, float p1, void* p2,  void (*cb)(struct S_FDD, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_FDP(struct S_FDP p0, float p1, void* p2,  void (*cb)(struct S_FDP, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_FPI(struct S_FPI p0, float p1, void* p2,  void (*cb)(struct S_FPI, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_FPF(struct S_FPF p0, float p1, void* p2,  void (*cb)(struct S_FPF, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_FPD(struct S_FPD p0, float p1, void* p2,  void (*cb)(struct S_FPD, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_FPP(struct S_FPP p0, float p1, void* p2,  void (*cb)(struct S_FPP, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_DII(struct S_DII p0, float p1, void* p2,  void (*cb)(struct S_DII, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_DIF(struct S_DIF p0, float p1, void* p2,  void (*cb)(struct S_DIF, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_DID(struct S_DID p0, float p1, void* p2,  void (*cb)(struct S_DID, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_DIP(struct S_DIP p0, float p1, void* p2,  void (*cb)(struct S_DIP, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_DFI(struct S_DFI p0, float p1, void* p2,  void (*cb)(struct S_DFI, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_DFF(struct S_DFF p0, float p1, void* p2,  void (*cb)(struct S_DFF, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_DFD(struct S_DFD p0, float p1, void* p2,  void (*cb)(struct S_DFD, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_DFP(struct S_DFP p0, float p1, void* p2,  void (*cb)(struct S_DFP, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_DDI(struct S_DDI p0, float p1, void* p2,  void (*cb)(struct S_DDI, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_DDF(struct S_DDF p0, float p1, void* p2,  void (*cb)(struct S_DDF, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_DDD(struct S_DDD p0, float p1, void* p2,  void (*cb)(struct S_DDD, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_DDP(struct S_DDP p0, float p1, void* p2,  void (*cb)(struct S_DDP, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_DPI(struct S_DPI p0, float p1, void* p2,  void (*cb)(struct S_DPI, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_DPF(struct S_DPF p0, float p1, void* p2,  void (*cb)(struct S_DPF, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_DPD(struct S_DPD p0, float p1, void* p2,  void (*cb)(struct S_DPD, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_DPP(struct S_DPP p0, float p1, void* p2,  void (*cb)(struct S_DPP, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_PII(struct S_PII p0, float p1, void* p2,  void (*cb)(struct S_PII, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_PIF(struct S_PIF p0, float p1, void* p2,  void (*cb)(struct S_PIF, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_PID(struct S_PID p0, float p1, void* p2,  void (*cb)(struct S_PID, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_PIP(struct S_PIP p0, float p1, void* p2,  void (*cb)(struct S_PIP, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_PFI(struct S_PFI p0, float p1, void* p2,  void (*cb)(struct S_PFI, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_PFF(struct S_PFF p0, float p1, void* p2,  void (*cb)(struct S_PFF, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_PFD(struct S_PFD p0, float p1, void* p2,  void (*cb)(struct S_PFD, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_PFP(struct S_PFP p0, float p1, void* p2,  void (*cb)(struct S_PFP, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_PDI(struct S_PDI p0, float p1, void* p2,  void (*cb)(struct S_PDI, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_PDF(struct S_PDF p0, float p1, void* p2,  void (*cb)(struct S_PDF, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_PDD(struct S_PDD p0, float p1, void* p2,  void (*cb)(struct S_PDD, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_PDP(struct S_PDP p0, float p1, void* p2,  void (*cb)(struct S_PDP, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_PPI(struct S_PPI p0, float p1, void* p2,  void (*cb)(struct S_PPI, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_PPF(struct S_PPF p0, float p1, void* p2,  void (*cb)(struct S_PPF, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_PPD(struct S_PPD p0, float p1, void* p2,  void (*cb)(struct S_PPD, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFP_PPP(struct S_PPP p0, float p1, void* p2,  void (*cb)(struct S_PPP, float, void*)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_I(struct S_I p0, float p1, struct S_I p2,  void (*cb)(struct S_I, float, struct S_I)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_F(struct S_F p0, float p1, struct S_F p2,  void (*cb)(struct S_F, float, struct S_F)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_D(struct S_D p0, float p1, struct S_D p2,  void (*cb)(struct S_D, float, struct S_D)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_P(struct S_P p0, float p1, struct S_P p2,  void (*cb)(struct S_P, float, struct S_P)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_II(struct S_II p0, float p1, struct S_II p2,  void (*cb)(struct S_II, float, struct S_II)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_IF(struct S_IF p0, float p1, struct S_IF p2,  void (*cb)(struct S_IF, float, struct S_IF)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_ID(struct S_ID p0, float p1, struct S_ID p2,  void (*cb)(struct S_ID, float, struct S_ID)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_IP(struct S_IP p0, float p1, struct S_IP p2,  void (*cb)(struct S_IP, float, struct S_IP)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_FI(struct S_FI p0, float p1, struct S_FI p2,  void (*cb)(struct S_FI, float, struct S_FI)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_FF(struct S_FF p0, float p1, struct S_FF p2,  void (*cb)(struct S_FF, float, struct S_FF)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_FD(struct S_FD p0, float p1, struct S_FD p2,  void (*cb)(struct S_FD, float, struct S_FD)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_FP(struct S_FP p0, float p1, struct S_FP p2,  void (*cb)(struct S_FP, float, struct S_FP)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_DI(struct S_DI p0, float p1, struct S_DI p2,  void (*cb)(struct S_DI, float, struct S_DI)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_DF(struct S_DF p0, float p1, struct S_DF p2,  void (*cb)(struct S_DF, float, struct S_DF)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_DD(struct S_DD p0, float p1, struct S_DD p2,  void (*cb)(struct S_DD, float, struct S_DD)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_DP(struct S_DP p0, float p1, struct S_DP p2,  void (*cb)(struct S_DP, float, struct S_DP)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_PI(struct S_PI p0, float p1, struct S_PI p2,  void (*cb)(struct S_PI, float, struct S_PI)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_PF(struct S_PF p0, float p1, struct S_PF p2,  void (*cb)(struct S_PF, float, struct S_PF)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_PD(struct S_PD p0, float p1, struct S_PD p2,  void (*cb)(struct S_PD, float, struct S_PD)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_PP(struct S_PP p0, float p1, struct S_PP p2,  void (*cb)(struct S_PP, float, struct S_PP)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_III(struct S_III p0, float p1, struct S_III p2,  void (*cb)(struct S_III, float, struct S_III)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_IIF(struct S_IIF p0, float p1, struct S_IIF p2,  void (*cb)(struct S_IIF, float, struct S_IIF)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_IID(struct S_IID p0, float p1, struct S_IID p2,  void (*cb)(struct S_IID, float, struct S_IID)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_IIP(struct S_IIP p0, float p1, struct S_IIP p2,  void (*cb)(struct S_IIP, float, struct S_IIP)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_IFI(struct S_IFI p0, float p1, struct S_IFI p2,  void (*cb)(struct S_IFI, float, struct S_IFI)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_IFF(struct S_IFF p0, float p1, struct S_IFF p2,  void (*cb)(struct S_IFF, float, struct S_IFF)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_IFD(struct S_IFD p0, float p1, struct S_IFD p2,  void (*cb)(struct S_IFD, float, struct S_IFD)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_IFP(struct S_IFP p0, float p1, struct S_IFP p2,  void (*cb)(struct S_IFP, float, struct S_IFP)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_IDI(struct S_IDI p0, float p1, struct S_IDI p2,  void (*cb)(struct S_IDI, float, struct S_IDI)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_IDF(struct S_IDF p0, float p1, struct S_IDF p2,  void (*cb)(struct S_IDF, float, struct S_IDF)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_IDD(struct S_IDD p0, float p1, struct S_IDD p2,  void (*cb)(struct S_IDD, float, struct S_IDD)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_IDP(struct S_IDP p0, float p1, struct S_IDP p2,  void (*cb)(struct S_IDP, float, struct S_IDP)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_IPI(struct S_IPI p0, float p1, struct S_IPI p2,  void (*cb)(struct S_IPI, float, struct S_IPI)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_IPF(struct S_IPF p0, float p1, struct S_IPF p2,  void (*cb)(struct S_IPF, float, struct S_IPF)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_IPD(struct S_IPD p0, float p1, struct S_IPD p2,  void (*cb)(struct S_IPD, float, struct S_IPD)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_IPP(struct S_IPP p0, float p1, struct S_IPP p2,  void (*cb)(struct S_IPP, float, struct S_IPP)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_FII(struct S_FII p0, float p1, struct S_FII p2,  void (*cb)(struct S_FII, float, struct S_FII)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_FIF(struct S_FIF p0, float p1, struct S_FIF p2,  void (*cb)(struct S_FIF, float, struct S_FIF)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_FID(struct S_FID p0, float p1, struct S_FID p2,  void (*cb)(struct S_FID, float, struct S_FID)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_FIP(struct S_FIP p0, float p1, struct S_FIP p2,  void (*cb)(struct S_FIP, float, struct S_FIP)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_FFI(struct S_FFI p0, float p1, struct S_FFI p2,  void (*cb)(struct S_FFI, float, struct S_FFI)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_FFF(struct S_FFF p0, float p1, struct S_FFF p2,  void (*cb)(struct S_FFF, float, struct S_FFF)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_FFD(struct S_FFD p0, float p1, struct S_FFD p2,  void (*cb)(struct S_FFD, float, struct S_FFD)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_FFP(struct S_FFP p0, float p1, struct S_FFP p2,  void (*cb)(struct S_FFP, float, struct S_FFP)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_FDI(struct S_FDI p0, float p1, struct S_FDI p2,  void (*cb)(struct S_FDI, float, struct S_FDI)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_FDF(struct S_FDF p0, float p1, struct S_FDF p2,  void (*cb)(struct S_FDF, float, struct S_FDF)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_FDD(struct S_FDD p0, float p1, struct S_FDD p2,  void (*cb)(struct S_FDD, float, struct S_FDD)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_FDP(struct S_FDP p0, float p1, struct S_FDP p2,  void (*cb)(struct S_FDP, float, struct S_FDP)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_FPI(struct S_FPI p0, float p1, struct S_FPI p2,  void (*cb)(struct S_FPI, float, struct S_FPI)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_FPF(struct S_FPF p0, float p1, struct S_FPF p2,  void (*cb)(struct S_FPF, float, struct S_FPF)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_FPD(struct S_FPD p0, float p1, struct S_FPD p2,  void (*cb)(struct S_FPD, float, struct S_FPD)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_FPP(struct S_FPP p0, float p1, struct S_FPP p2,  void (*cb)(struct S_FPP, float, struct S_FPP)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_DII(struct S_DII p0, float p1, struct S_DII p2,  void (*cb)(struct S_DII, float, struct S_DII)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_DIF(struct S_DIF p0, float p1, struct S_DIF p2,  void (*cb)(struct S_DIF, float, struct S_DIF)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_DID(struct S_DID p0, float p1, struct S_DID p2,  void (*cb)(struct S_DID, float, struct S_DID)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_DIP(struct S_DIP p0, float p1, struct S_DIP p2,  void (*cb)(struct S_DIP, float, struct S_DIP)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_DFI(struct S_DFI p0, float p1, struct S_DFI p2,  void (*cb)(struct S_DFI, float, struct S_DFI)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_DFF(struct S_DFF p0, float p1, struct S_DFF p2,  void (*cb)(struct S_DFF, float, struct S_DFF)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_DFD(struct S_DFD p0, float p1, struct S_DFD p2,  void (*cb)(struct S_DFD, float, struct S_DFD)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_DFP(struct S_DFP p0, float p1, struct S_DFP p2,  void (*cb)(struct S_DFP, float, struct S_DFP)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_DDI(struct S_DDI p0, float p1, struct S_DDI p2,  void (*cb)(struct S_DDI, float, struct S_DDI)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_DDF(struct S_DDF p0, float p1, struct S_DDF p2,  void (*cb)(struct S_DDF, float, struct S_DDF)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_DDD(struct S_DDD p0, float p1, struct S_DDD p2,  void (*cb)(struct S_DDD, float, struct S_DDD)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_DDP(struct S_DDP p0, float p1, struct S_DDP p2,  void (*cb)(struct S_DDP, float, struct S_DDP)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_DPI(struct S_DPI p0, float p1, struct S_DPI p2,  void (*cb)(struct S_DPI, float, struct S_DPI)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_DPF(struct S_DPF p0, float p1, struct S_DPF p2,  void (*cb)(struct S_DPF, float, struct S_DPF)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_DPD(struct S_DPD p0, float p1, struct S_DPD p2,  void (*cb)(struct S_DPD, float, struct S_DPD)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_DPP(struct S_DPP p0, float p1, struct S_DPP p2,  void (*cb)(struct S_DPP, float, struct S_DPP)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_PII(struct S_PII p0, float p1, struct S_PII p2,  void (*cb)(struct S_PII, float, struct S_PII)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_PIF(struct S_PIF p0, float p1, struct S_PIF p2,  void (*cb)(struct S_PIF, float, struct S_PIF)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_PID(struct S_PID p0, float p1, struct S_PID p2,  void (*cb)(struct S_PID, float, struct S_PID)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_PIP(struct S_PIP p0, float p1, struct S_PIP p2,  void (*cb)(struct S_PIP, float, struct S_PIP)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_PFI(struct S_PFI p0, float p1, struct S_PFI p2,  void (*cb)(struct S_PFI, float, struct S_PFI)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_PFF(struct S_PFF p0, float p1, struct S_PFF p2,  void (*cb)(struct S_PFF, float, struct S_PFF)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_PFD(struct S_PFD p0, float p1, struct S_PFD p2,  void (*cb)(struct S_PFD, float, struct S_PFD)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_PFP(struct S_PFP p0, float p1, struct S_PFP p2,  void (*cb)(struct S_PFP, float, struct S_PFP)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_PDI(struct S_PDI p0, float p1, struct S_PDI p2,  void (*cb)(struct S_PDI, float, struct S_PDI)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_PDF(struct S_PDF p0, float p1, struct S_PDF p2,  void (*cb)(struct S_PDF, float, struct S_PDF)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_PDD(struct S_PDD p0, float p1, struct S_PDD p2,  void (*cb)(struct S_PDD, float, struct S_PDD)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_PDP(struct S_PDP p0, float p1, struct S_PDP p2,  void (*cb)(struct S_PDP, float, struct S_PDP)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_PPI(struct S_PPI p0, float p1, struct S_PPI p2,  void (*cb)(struct S_PPI, float, struct S_PPI)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_PPF(struct S_PPF p0, float p1, struct S_PPF p2,  void (*cb)(struct S_PPF, float, struct S_PPF)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_PPD(struct S_PPD p0, float p1, struct S_PPD p2,  void (*cb)(struct S_PPD, float, struct S_PPD)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SFS_PPP(struct S_PPP p0, float p1, struct S_PPP p2,  void (*cb)(struct S_PPP, float, struct S_PPP)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SDI_I(struct S_I p0, double p1, int p2,  void (*cb)(struct S_I, double, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SDI_F(struct S_F p0, double p1, int p2,  void (*cb)(struct S_F, double, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SDI_D(struct S_D p0, double p1, int p2,  void (*cb)(struct S_D, double, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SDI_P(struct S_P p0, double p1, int p2,  void (*cb)(struct S_P, double, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SDI_II(struct S_II p0, double p1, int p2,  void (*cb)(struct S_II, double, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SDI_IF(struct S_IF p0, double p1, int p2,  void (*cb)(struct S_IF, double, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SDI_ID(struct S_ID p0, double p1, int p2,  void (*cb)(struct S_ID, double, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SDI_IP(struct S_IP p0, double p1, int p2,  void (*cb)(struct S_IP, double, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SDI_FI(struct S_FI p0, double p1, int p2,  void (*cb)(struct S_FI, double, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SDI_FF(struct S_FF p0, double p1, int p2,  void (*cb)(struct S_FF, double, int)) { cb(p0,p1,p2); }
+EXPORT void f7_V_SDI_FD(struct S_FD p0, double p1, int p2,  void (*cb)(struct S_FD, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_FP(struct S_FP p0, double p1, int p2,  void (*cb)(struct S_FP, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_DI(struct S_DI p0, double p1, int p2,  void (*cb)(struct S_DI, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_DF(struct S_DF p0, double p1, int p2,  void (*cb)(struct S_DF, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_DD(struct S_DD p0, double p1, int p2,  void (*cb)(struct S_DD, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_DP(struct S_DP p0, double p1, int p2,  void (*cb)(struct S_DP, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_PI(struct S_PI p0, double p1, int p2,  void (*cb)(struct S_PI, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_PF(struct S_PF p0, double p1, int p2,  void (*cb)(struct S_PF, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_PD(struct S_PD p0, double p1, int p2,  void (*cb)(struct S_PD, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_PP(struct S_PP p0, double p1, int p2,  void (*cb)(struct S_PP, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_III(struct S_III p0, double p1, int p2,  void (*cb)(struct S_III, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_IIF(struct S_IIF p0, double p1, int p2,  void (*cb)(struct S_IIF, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_IID(struct S_IID p0, double p1, int p2,  void (*cb)(struct S_IID, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_IIP(struct S_IIP p0, double p1, int p2,  void (*cb)(struct S_IIP, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_IFI(struct S_IFI p0, double p1, int p2,  void (*cb)(struct S_IFI, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_IFF(struct S_IFF p0, double p1, int p2,  void (*cb)(struct S_IFF, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_IFD(struct S_IFD p0, double p1, int p2,  void (*cb)(struct S_IFD, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_IFP(struct S_IFP p0, double p1, int p2,  void (*cb)(struct S_IFP, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_IDI(struct S_IDI p0, double p1, int p2,  void (*cb)(struct S_IDI, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_IDF(struct S_IDF p0, double p1, int p2,  void (*cb)(struct S_IDF, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_IDD(struct S_IDD p0, double p1, int p2,  void (*cb)(struct S_IDD, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_IDP(struct S_IDP p0, double p1, int p2,  void (*cb)(struct S_IDP, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_IPI(struct S_IPI p0, double p1, int p2,  void (*cb)(struct S_IPI, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_IPF(struct S_IPF p0, double p1, int p2,  void (*cb)(struct S_IPF, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_IPD(struct S_IPD p0, double p1, int p2,  void (*cb)(struct S_IPD, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_IPP(struct S_IPP p0, double p1, int p2,  void (*cb)(struct S_IPP, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_FII(struct S_FII p0, double p1, int p2,  void (*cb)(struct S_FII, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_FIF(struct S_FIF p0, double p1, int p2,  void (*cb)(struct S_FIF, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_FID(struct S_FID p0, double p1, int p2,  void (*cb)(struct S_FID, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_FIP(struct S_FIP p0, double p1, int p2,  void (*cb)(struct S_FIP, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_FFI(struct S_FFI p0, double p1, int p2,  void (*cb)(struct S_FFI, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_FFF(struct S_FFF p0, double p1, int p2,  void (*cb)(struct S_FFF, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_FFD(struct S_FFD p0, double p1, int p2,  void (*cb)(struct S_FFD, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_FFP(struct S_FFP p0, double p1, int p2,  void (*cb)(struct S_FFP, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_FDI(struct S_FDI p0, double p1, int p2,  void (*cb)(struct S_FDI, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_FDF(struct S_FDF p0, double p1, int p2,  void (*cb)(struct S_FDF, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_FDD(struct S_FDD p0, double p1, int p2,  void (*cb)(struct S_FDD, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_FDP(struct S_FDP p0, double p1, int p2,  void (*cb)(struct S_FDP, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_FPI(struct S_FPI p0, double p1, int p2,  void (*cb)(struct S_FPI, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_FPF(struct S_FPF p0, double p1, int p2,  void (*cb)(struct S_FPF, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_FPD(struct S_FPD p0, double p1, int p2,  void (*cb)(struct S_FPD, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_FPP(struct S_FPP p0, double p1, int p2,  void (*cb)(struct S_FPP, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_DII(struct S_DII p0, double p1, int p2,  void (*cb)(struct S_DII, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_DIF(struct S_DIF p0, double p1, int p2,  void (*cb)(struct S_DIF, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_DID(struct S_DID p0, double p1, int p2,  void (*cb)(struct S_DID, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_DIP(struct S_DIP p0, double p1, int p2,  void (*cb)(struct S_DIP, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_DFI(struct S_DFI p0, double p1, int p2,  void (*cb)(struct S_DFI, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_DFF(struct S_DFF p0, double p1, int p2,  void (*cb)(struct S_DFF, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_DFD(struct S_DFD p0, double p1, int p2,  void (*cb)(struct S_DFD, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_DFP(struct S_DFP p0, double p1, int p2,  void (*cb)(struct S_DFP, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_DDI(struct S_DDI p0, double p1, int p2,  void (*cb)(struct S_DDI, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_DDF(struct S_DDF p0, double p1, int p2,  void (*cb)(struct S_DDF, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_DDD(struct S_DDD p0, double p1, int p2,  void (*cb)(struct S_DDD, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_DDP(struct S_DDP p0, double p1, int p2,  void (*cb)(struct S_DDP, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_DPI(struct S_DPI p0, double p1, int p2,  void (*cb)(struct S_DPI, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_DPF(struct S_DPF p0, double p1, int p2,  void (*cb)(struct S_DPF, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_DPD(struct S_DPD p0, double p1, int p2,  void (*cb)(struct S_DPD, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_DPP(struct S_DPP p0, double p1, int p2,  void (*cb)(struct S_DPP, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_PII(struct S_PII p0, double p1, int p2,  void (*cb)(struct S_PII, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_PIF(struct S_PIF p0, double p1, int p2,  void (*cb)(struct S_PIF, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_PID(struct S_PID p0, double p1, int p2,  void (*cb)(struct S_PID, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_PIP(struct S_PIP p0, double p1, int p2,  void (*cb)(struct S_PIP, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_PFI(struct S_PFI p0, double p1, int p2,  void (*cb)(struct S_PFI, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_PFF(struct S_PFF p0, double p1, int p2,  void (*cb)(struct S_PFF, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_PFD(struct S_PFD p0, double p1, int p2,  void (*cb)(struct S_PFD, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_PFP(struct S_PFP p0, double p1, int p2,  void (*cb)(struct S_PFP, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_PDI(struct S_PDI p0, double p1, int p2,  void (*cb)(struct S_PDI, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_PDF(struct S_PDF p0, double p1, int p2,  void (*cb)(struct S_PDF, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_PDD(struct S_PDD p0, double p1, int p2,  void (*cb)(struct S_PDD, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_PDP(struct S_PDP p0, double p1, int p2,  void (*cb)(struct S_PDP, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_PPI(struct S_PPI p0, double p1, int p2,  void (*cb)(struct S_PPI, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_PPF(struct S_PPF p0, double p1, int p2,  void (*cb)(struct S_PPF, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_PPD(struct S_PPD p0, double p1, int p2,  void (*cb)(struct S_PPD, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDI_PPP(struct S_PPP p0, double p1, int p2,  void (*cb)(struct S_PPP, double, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_I(struct S_I p0, double p1, float p2,  void (*cb)(struct S_I, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_F(struct S_F p0, double p1, float p2,  void (*cb)(struct S_F, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_D(struct S_D p0, double p1, float p2,  void (*cb)(struct S_D, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_P(struct S_P p0, double p1, float p2,  void (*cb)(struct S_P, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_II(struct S_II p0, double p1, float p2,  void (*cb)(struct S_II, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_IF(struct S_IF p0, double p1, float p2,  void (*cb)(struct S_IF, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_ID(struct S_ID p0, double p1, float p2,  void (*cb)(struct S_ID, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_IP(struct S_IP p0, double p1, float p2,  void (*cb)(struct S_IP, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_FI(struct S_FI p0, double p1, float p2,  void (*cb)(struct S_FI, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_FF(struct S_FF p0, double p1, float p2,  void (*cb)(struct S_FF, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_FD(struct S_FD p0, double p1, float p2,  void (*cb)(struct S_FD, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_FP(struct S_FP p0, double p1, float p2,  void (*cb)(struct S_FP, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_DI(struct S_DI p0, double p1, float p2,  void (*cb)(struct S_DI, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_DF(struct S_DF p0, double p1, float p2,  void (*cb)(struct S_DF, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_DD(struct S_DD p0, double p1, float p2,  void (*cb)(struct S_DD, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_DP(struct S_DP p0, double p1, float p2,  void (*cb)(struct S_DP, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_PI(struct S_PI p0, double p1, float p2,  void (*cb)(struct S_PI, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_PF(struct S_PF p0, double p1, float p2,  void (*cb)(struct S_PF, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_PD(struct S_PD p0, double p1, float p2,  void (*cb)(struct S_PD, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_PP(struct S_PP p0, double p1, float p2,  void (*cb)(struct S_PP, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_III(struct S_III p0, double p1, float p2,  void (*cb)(struct S_III, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_IIF(struct S_IIF p0, double p1, float p2,  void (*cb)(struct S_IIF, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_IID(struct S_IID p0, double p1, float p2,  void (*cb)(struct S_IID, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_IIP(struct S_IIP p0, double p1, float p2,  void (*cb)(struct S_IIP, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_IFI(struct S_IFI p0, double p1, float p2,  void (*cb)(struct S_IFI, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_IFF(struct S_IFF p0, double p1, float p2,  void (*cb)(struct S_IFF, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_IFD(struct S_IFD p0, double p1, float p2,  void (*cb)(struct S_IFD, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_IFP(struct S_IFP p0, double p1, float p2,  void (*cb)(struct S_IFP, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_IDI(struct S_IDI p0, double p1, float p2,  void (*cb)(struct S_IDI, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_IDF(struct S_IDF p0, double p1, float p2,  void (*cb)(struct S_IDF, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_IDD(struct S_IDD p0, double p1, float p2,  void (*cb)(struct S_IDD, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_IDP(struct S_IDP p0, double p1, float p2,  void (*cb)(struct S_IDP, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_IPI(struct S_IPI p0, double p1, float p2,  void (*cb)(struct S_IPI, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_IPF(struct S_IPF p0, double p1, float p2,  void (*cb)(struct S_IPF, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_IPD(struct S_IPD p0, double p1, float p2,  void (*cb)(struct S_IPD, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_IPP(struct S_IPP p0, double p1, float p2,  void (*cb)(struct S_IPP, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_FII(struct S_FII p0, double p1, float p2,  void (*cb)(struct S_FII, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_FIF(struct S_FIF p0, double p1, float p2,  void (*cb)(struct S_FIF, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_FID(struct S_FID p0, double p1, float p2,  void (*cb)(struct S_FID, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_FIP(struct S_FIP p0, double p1, float p2,  void (*cb)(struct S_FIP, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_FFI(struct S_FFI p0, double p1, float p2,  void (*cb)(struct S_FFI, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_FFF(struct S_FFF p0, double p1, float p2,  void (*cb)(struct S_FFF, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_FFD(struct S_FFD p0, double p1, float p2,  void (*cb)(struct S_FFD, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_FFP(struct S_FFP p0, double p1, float p2,  void (*cb)(struct S_FFP, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_FDI(struct S_FDI p0, double p1, float p2,  void (*cb)(struct S_FDI, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_FDF(struct S_FDF p0, double p1, float p2,  void (*cb)(struct S_FDF, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_FDD(struct S_FDD p0, double p1, float p2,  void (*cb)(struct S_FDD, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_FDP(struct S_FDP p0, double p1, float p2,  void (*cb)(struct S_FDP, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_FPI(struct S_FPI p0, double p1, float p2,  void (*cb)(struct S_FPI, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_FPF(struct S_FPF p0, double p1, float p2,  void (*cb)(struct S_FPF, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_FPD(struct S_FPD p0, double p1, float p2,  void (*cb)(struct S_FPD, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_FPP(struct S_FPP p0, double p1, float p2,  void (*cb)(struct S_FPP, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_DII(struct S_DII p0, double p1, float p2,  void (*cb)(struct S_DII, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_DIF(struct S_DIF p0, double p1, float p2,  void (*cb)(struct S_DIF, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_DID(struct S_DID p0, double p1, float p2,  void (*cb)(struct S_DID, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_DIP(struct S_DIP p0, double p1, float p2,  void (*cb)(struct S_DIP, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_DFI(struct S_DFI p0, double p1, float p2,  void (*cb)(struct S_DFI, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_DFF(struct S_DFF p0, double p1, float p2,  void (*cb)(struct S_DFF, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_DFD(struct S_DFD p0, double p1, float p2,  void (*cb)(struct S_DFD, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_DFP(struct S_DFP p0, double p1, float p2,  void (*cb)(struct S_DFP, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_DDI(struct S_DDI p0, double p1, float p2,  void (*cb)(struct S_DDI, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_DDF(struct S_DDF p0, double p1, float p2,  void (*cb)(struct S_DDF, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_DDD(struct S_DDD p0, double p1, float p2,  void (*cb)(struct S_DDD, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_DDP(struct S_DDP p0, double p1, float p2,  void (*cb)(struct S_DDP, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_DPI(struct S_DPI p0, double p1, float p2,  void (*cb)(struct S_DPI, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_DPF(struct S_DPF p0, double p1, float p2,  void (*cb)(struct S_DPF, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_DPD(struct S_DPD p0, double p1, float p2,  void (*cb)(struct S_DPD, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_DPP(struct S_DPP p0, double p1, float p2,  void (*cb)(struct S_DPP, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_PII(struct S_PII p0, double p1, float p2,  void (*cb)(struct S_PII, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_PIF(struct S_PIF p0, double p1, float p2,  void (*cb)(struct S_PIF, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_PID(struct S_PID p0, double p1, float p2,  void (*cb)(struct S_PID, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_PIP(struct S_PIP p0, double p1, float p2,  void (*cb)(struct S_PIP, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_PFI(struct S_PFI p0, double p1, float p2,  void (*cb)(struct S_PFI, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_PFF(struct S_PFF p0, double p1, float p2,  void (*cb)(struct S_PFF, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_PFD(struct S_PFD p0, double p1, float p2,  void (*cb)(struct S_PFD, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_PFP(struct S_PFP p0, double p1, float p2,  void (*cb)(struct S_PFP, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_PDI(struct S_PDI p0, double p1, float p2,  void (*cb)(struct S_PDI, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_PDF(struct S_PDF p0, double p1, float p2,  void (*cb)(struct S_PDF, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_PDD(struct S_PDD p0, double p1, float p2,  void (*cb)(struct S_PDD, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_PDP(struct S_PDP p0, double p1, float p2,  void (*cb)(struct S_PDP, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_PPI(struct S_PPI p0, double p1, float p2,  void (*cb)(struct S_PPI, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_PPF(struct S_PPF p0, double p1, float p2,  void (*cb)(struct S_PPF, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_PPD(struct S_PPD p0, double p1, float p2,  void (*cb)(struct S_PPD, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDF_PPP(struct S_PPP p0, double p1, float p2,  void (*cb)(struct S_PPP, double, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_I(struct S_I p0, double p1, double p2,  void (*cb)(struct S_I, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_F(struct S_F p0, double p1, double p2,  void (*cb)(struct S_F, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_D(struct S_D p0, double p1, double p2,  void (*cb)(struct S_D, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_P(struct S_P p0, double p1, double p2,  void (*cb)(struct S_P, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_II(struct S_II p0, double p1, double p2,  void (*cb)(struct S_II, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_IF(struct S_IF p0, double p1, double p2,  void (*cb)(struct S_IF, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_ID(struct S_ID p0, double p1, double p2,  void (*cb)(struct S_ID, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_IP(struct S_IP p0, double p1, double p2,  void (*cb)(struct S_IP, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_FI(struct S_FI p0, double p1, double p2,  void (*cb)(struct S_FI, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_FF(struct S_FF p0, double p1, double p2,  void (*cb)(struct S_FF, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_FD(struct S_FD p0, double p1, double p2,  void (*cb)(struct S_FD, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_FP(struct S_FP p0, double p1, double p2,  void (*cb)(struct S_FP, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_DI(struct S_DI p0, double p1, double p2,  void (*cb)(struct S_DI, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_DF(struct S_DF p0, double p1, double p2,  void (*cb)(struct S_DF, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_DD(struct S_DD p0, double p1, double p2,  void (*cb)(struct S_DD, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_DP(struct S_DP p0, double p1, double p2,  void (*cb)(struct S_DP, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_PI(struct S_PI p0, double p1, double p2,  void (*cb)(struct S_PI, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_PF(struct S_PF p0, double p1, double p2,  void (*cb)(struct S_PF, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_PD(struct S_PD p0, double p1, double p2,  void (*cb)(struct S_PD, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_PP(struct S_PP p0, double p1, double p2,  void (*cb)(struct S_PP, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_III(struct S_III p0, double p1, double p2,  void (*cb)(struct S_III, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_IIF(struct S_IIF p0, double p1, double p2,  void (*cb)(struct S_IIF, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_IID(struct S_IID p0, double p1, double p2,  void (*cb)(struct S_IID, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_IIP(struct S_IIP p0, double p1, double p2,  void (*cb)(struct S_IIP, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_IFI(struct S_IFI p0, double p1, double p2,  void (*cb)(struct S_IFI, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_IFF(struct S_IFF p0, double p1, double p2,  void (*cb)(struct S_IFF, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_IFD(struct S_IFD p0, double p1, double p2,  void (*cb)(struct S_IFD, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_IFP(struct S_IFP p0, double p1, double p2,  void (*cb)(struct S_IFP, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_IDI(struct S_IDI p0, double p1, double p2,  void (*cb)(struct S_IDI, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_IDF(struct S_IDF p0, double p1, double p2,  void (*cb)(struct S_IDF, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_IDD(struct S_IDD p0, double p1, double p2,  void (*cb)(struct S_IDD, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_IDP(struct S_IDP p0, double p1, double p2,  void (*cb)(struct S_IDP, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_IPI(struct S_IPI p0, double p1, double p2,  void (*cb)(struct S_IPI, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_IPF(struct S_IPF p0, double p1, double p2,  void (*cb)(struct S_IPF, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_IPD(struct S_IPD p0, double p1, double p2,  void (*cb)(struct S_IPD, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_IPP(struct S_IPP p0, double p1, double p2,  void (*cb)(struct S_IPP, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_FII(struct S_FII p0, double p1, double p2,  void (*cb)(struct S_FII, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_FIF(struct S_FIF p0, double p1, double p2,  void (*cb)(struct S_FIF, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_FID(struct S_FID p0, double p1, double p2,  void (*cb)(struct S_FID, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_FIP(struct S_FIP p0, double p1, double p2,  void (*cb)(struct S_FIP, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_FFI(struct S_FFI p0, double p1, double p2,  void (*cb)(struct S_FFI, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_FFF(struct S_FFF p0, double p1, double p2,  void (*cb)(struct S_FFF, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_FFD(struct S_FFD p0, double p1, double p2,  void (*cb)(struct S_FFD, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_FFP(struct S_FFP p0, double p1, double p2,  void (*cb)(struct S_FFP, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_FDI(struct S_FDI p0, double p1, double p2,  void (*cb)(struct S_FDI, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_FDF(struct S_FDF p0, double p1, double p2,  void (*cb)(struct S_FDF, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_FDD(struct S_FDD p0, double p1, double p2,  void (*cb)(struct S_FDD, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_FDP(struct S_FDP p0, double p1, double p2,  void (*cb)(struct S_FDP, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_FPI(struct S_FPI p0, double p1, double p2,  void (*cb)(struct S_FPI, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_FPF(struct S_FPF p0, double p1, double p2,  void (*cb)(struct S_FPF, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_FPD(struct S_FPD p0, double p1, double p2,  void (*cb)(struct S_FPD, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_FPP(struct S_FPP p0, double p1, double p2,  void (*cb)(struct S_FPP, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_DII(struct S_DII p0, double p1, double p2,  void (*cb)(struct S_DII, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_DIF(struct S_DIF p0, double p1, double p2,  void (*cb)(struct S_DIF, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_DID(struct S_DID p0, double p1, double p2,  void (*cb)(struct S_DID, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_DIP(struct S_DIP p0, double p1, double p2,  void (*cb)(struct S_DIP, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_DFI(struct S_DFI p0, double p1, double p2,  void (*cb)(struct S_DFI, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_DFF(struct S_DFF p0, double p1, double p2,  void (*cb)(struct S_DFF, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_DFD(struct S_DFD p0, double p1, double p2,  void (*cb)(struct S_DFD, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_DFP(struct S_DFP p0, double p1, double p2,  void (*cb)(struct S_DFP, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_DDI(struct S_DDI p0, double p1, double p2,  void (*cb)(struct S_DDI, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_DDF(struct S_DDF p0, double p1, double p2,  void (*cb)(struct S_DDF, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_DDD(struct S_DDD p0, double p1, double p2,  void (*cb)(struct S_DDD, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_DDP(struct S_DDP p0, double p1, double p2,  void (*cb)(struct S_DDP, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_DPI(struct S_DPI p0, double p1, double p2,  void (*cb)(struct S_DPI, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_DPF(struct S_DPF p0, double p1, double p2,  void (*cb)(struct S_DPF, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_DPD(struct S_DPD p0, double p1, double p2,  void (*cb)(struct S_DPD, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_DPP(struct S_DPP p0, double p1, double p2,  void (*cb)(struct S_DPP, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_PII(struct S_PII p0, double p1, double p2,  void (*cb)(struct S_PII, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_PIF(struct S_PIF p0, double p1, double p2,  void (*cb)(struct S_PIF, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_PID(struct S_PID p0, double p1, double p2,  void (*cb)(struct S_PID, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_PIP(struct S_PIP p0, double p1, double p2,  void (*cb)(struct S_PIP, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_PFI(struct S_PFI p0, double p1, double p2,  void (*cb)(struct S_PFI, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_PFF(struct S_PFF p0, double p1, double p2,  void (*cb)(struct S_PFF, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_PFD(struct S_PFD p0, double p1, double p2,  void (*cb)(struct S_PFD, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_PFP(struct S_PFP p0, double p1, double p2,  void (*cb)(struct S_PFP, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_PDI(struct S_PDI p0, double p1, double p2,  void (*cb)(struct S_PDI, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_PDF(struct S_PDF p0, double p1, double p2,  void (*cb)(struct S_PDF, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_PDD(struct S_PDD p0, double p1, double p2,  void (*cb)(struct S_PDD, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_PDP(struct S_PDP p0, double p1, double p2,  void (*cb)(struct S_PDP, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_PPI(struct S_PPI p0, double p1, double p2,  void (*cb)(struct S_PPI, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_PPF(struct S_PPF p0, double p1, double p2,  void (*cb)(struct S_PPF, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_PPD(struct S_PPD p0, double p1, double p2,  void (*cb)(struct S_PPD, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDD_PPP(struct S_PPP p0, double p1, double p2,  void (*cb)(struct S_PPP, double, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_I(struct S_I p0, double p1, void* p2,  void (*cb)(struct S_I, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_F(struct S_F p0, double p1, void* p2,  void (*cb)(struct S_F, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_D(struct S_D p0, double p1, void* p2,  void (*cb)(struct S_D, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_P(struct S_P p0, double p1, void* p2,  void (*cb)(struct S_P, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_II(struct S_II p0, double p1, void* p2,  void (*cb)(struct S_II, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_IF(struct S_IF p0, double p1, void* p2,  void (*cb)(struct S_IF, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_ID(struct S_ID p0, double p1, void* p2,  void (*cb)(struct S_ID, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_IP(struct S_IP p0, double p1, void* p2,  void (*cb)(struct S_IP, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_FI(struct S_FI p0, double p1, void* p2,  void (*cb)(struct S_FI, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_FF(struct S_FF p0, double p1, void* p2,  void (*cb)(struct S_FF, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_FD(struct S_FD p0, double p1, void* p2,  void (*cb)(struct S_FD, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_FP(struct S_FP p0, double p1, void* p2,  void (*cb)(struct S_FP, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_DI(struct S_DI p0, double p1, void* p2,  void (*cb)(struct S_DI, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_DF(struct S_DF p0, double p1, void* p2,  void (*cb)(struct S_DF, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_DD(struct S_DD p0, double p1, void* p2,  void (*cb)(struct S_DD, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_DP(struct S_DP p0, double p1, void* p2,  void (*cb)(struct S_DP, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_PI(struct S_PI p0, double p1, void* p2,  void (*cb)(struct S_PI, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_PF(struct S_PF p0, double p1, void* p2,  void (*cb)(struct S_PF, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_PD(struct S_PD p0, double p1, void* p2,  void (*cb)(struct S_PD, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_PP(struct S_PP p0, double p1, void* p2,  void (*cb)(struct S_PP, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_III(struct S_III p0, double p1, void* p2,  void (*cb)(struct S_III, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_IIF(struct S_IIF p0, double p1, void* p2,  void (*cb)(struct S_IIF, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_IID(struct S_IID p0, double p1, void* p2,  void (*cb)(struct S_IID, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_IIP(struct S_IIP p0, double p1, void* p2,  void (*cb)(struct S_IIP, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_IFI(struct S_IFI p0, double p1, void* p2,  void (*cb)(struct S_IFI, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_IFF(struct S_IFF p0, double p1, void* p2,  void (*cb)(struct S_IFF, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_IFD(struct S_IFD p0, double p1, void* p2,  void (*cb)(struct S_IFD, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_IFP(struct S_IFP p0, double p1, void* p2,  void (*cb)(struct S_IFP, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_IDI(struct S_IDI p0, double p1, void* p2,  void (*cb)(struct S_IDI, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_IDF(struct S_IDF p0, double p1, void* p2,  void (*cb)(struct S_IDF, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_IDD(struct S_IDD p0, double p1, void* p2,  void (*cb)(struct S_IDD, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_IDP(struct S_IDP p0, double p1, void* p2,  void (*cb)(struct S_IDP, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_IPI(struct S_IPI p0, double p1, void* p2,  void (*cb)(struct S_IPI, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_IPF(struct S_IPF p0, double p1, void* p2,  void (*cb)(struct S_IPF, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_IPD(struct S_IPD p0, double p1, void* p2,  void (*cb)(struct S_IPD, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_IPP(struct S_IPP p0, double p1, void* p2,  void (*cb)(struct S_IPP, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_FII(struct S_FII p0, double p1, void* p2,  void (*cb)(struct S_FII, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_FIF(struct S_FIF p0, double p1, void* p2,  void (*cb)(struct S_FIF, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_FID(struct S_FID p0, double p1, void* p2,  void (*cb)(struct S_FID, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_FIP(struct S_FIP p0, double p1, void* p2,  void (*cb)(struct S_FIP, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_FFI(struct S_FFI p0, double p1, void* p2,  void (*cb)(struct S_FFI, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_FFF(struct S_FFF p0, double p1, void* p2,  void (*cb)(struct S_FFF, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_FFD(struct S_FFD p0, double p1, void* p2,  void (*cb)(struct S_FFD, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_FFP(struct S_FFP p0, double p1, void* p2,  void (*cb)(struct S_FFP, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_FDI(struct S_FDI p0, double p1, void* p2,  void (*cb)(struct S_FDI, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_FDF(struct S_FDF p0, double p1, void* p2,  void (*cb)(struct S_FDF, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_FDD(struct S_FDD p0, double p1, void* p2,  void (*cb)(struct S_FDD, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_FDP(struct S_FDP p0, double p1, void* p2,  void (*cb)(struct S_FDP, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_FPI(struct S_FPI p0, double p1, void* p2,  void (*cb)(struct S_FPI, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_FPF(struct S_FPF p0, double p1, void* p2,  void (*cb)(struct S_FPF, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_FPD(struct S_FPD p0, double p1, void* p2,  void (*cb)(struct S_FPD, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_FPP(struct S_FPP p0, double p1, void* p2,  void (*cb)(struct S_FPP, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_DII(struct S_DII p0, double p1, void* p2,  void (*cb)(struct S_DII, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_DIF(struct S_DIF p0, double p1, void* p2,  void (*cb)(struct S_DIF, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_DID(struct S_DID p0, double p1, void* p2,  void (*cb)(struct S_DID, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_DIP(struct S_DIP p0, double p1, void* p2,  void (*cb)(struct S_DIP, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_DFI(struct S_DFI p0, double p1, void* p2,  void (*cb)(struct S_DFI, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_DFF(struct S_DFF p0, double p1, void* p2,  void (*cb)(struct S_DFF, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_DFD(struct S_DFD p0, double p1, void* p2,  void (*cb)(struct S_DFD, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_DFP(struct S_DFP p0, double p1, void* p2,  void (*cb)(struct S_DFP, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_DDI(struct S_DDI p0, double p1, void* p2,  void (*cb)(struct S_DDI, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_DDF(struct S_DDF p0, double p1, void* p2,  void (*cb)(struct S_DDF, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_DDD(struct S_DDD p0, double p1, void* p2,  void (*cb)(struct S_DDD, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_DDP(struct S_DDP p0, double p1, void* p2,  void (*cb)(struct S_DDP, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_DPI(struct S_DPI p0, double p1, void* p2,  void (*cb)(struct S_DPI, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_DPF(struct S_DPF p0, double p1, void* p2,  void (*cb)(struct S_DPF, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_DPD(struct S_DPD p0, double p1, void* p2,  void (*cb)(struct S_DPD, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_DPP(struct S_DPP p0, double p1, void* p2,  void (*cb)(struct S_DPP, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_PII(struct S_PII p0, double p1, void* p2,  void (*cb)(struct S_PII, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_PIF(struct S_PIF p0, double p1, void* p2,  void (*cb)(struct S_PIF, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_PID(struct S_PID p0, double p1, void* p2,  void (*cb)(struct S_PID, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_PIP(struct S_PIP p0, double p1, void* p2,  void (*cb)(struct S_PIP, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_PFI(struct S_PFI p0, double p1, void* p2,  void (*cb)(struct S_PFI, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_PFF(struct S_PFF p0, double p1, void* p2,  void (*cb)(struct S_PFF, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_PFD(struct S_PFD p0, double p1, void* p2,  void (*cb)(struct S_PFD, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_PFP(struct S_PFP p0, double p1, void* p2,  void (*cb)(struct S_PFP, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_PDI(struct S_PDI p0, double p1, void* p2,  void (*cb)(struct S_PDI, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_PDF(struct S_PDF p0, double p1, void* p2,  void (*cb)(struct S_PDF, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_PDD(struct S_PDD p0, double p1, void* p2,  void (*cb)(struct S_PDD, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_PDP(struct S_PDP p0, double p1, void* p2,  void (*cb)(struct S_PDP, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_PPI(struct S_PPI p0, double p1, void* p2,  void (*cb)(struct S_PPI, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_PPF(struct S_PPF p0, double p1, void* p2,  void (*cb)(struct S_PPF, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_PPD(struct S_PPD p0, double p1, void* p2,  void (*cb)(struct S_PPD, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDP_PPP(struct S_PPP p0, double p1, void* p2,  void (*cb)(struct S_PPP, double, void*)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_I(struct S_I p0, double p1, struct S_I p2,  void (*cb)(struct S_I, double, struct S_I)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_F(struct S_F p0, double p1, struct S_F p2,  void (*cb)(struct S_F, double, struct S_F)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_D(struct S_D p0, double p1, struct S_D p2,  void (*cb)(struct S_D, double, struct S_D)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_P(struct S_P p0, double p1, struct S_P p2,  void (*cb)(struct S_P, double, struct S_P)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_II(struct S_II p0, double p1, struct S_II p2,  void (*cb)(struct S_II, double, struct S_II)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_IF(struct S_IF p0, double p1, struct S_IF p2,  void (*cb)(struct S_IF, double, struct S_IF)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_ID(struct S_ID p0, double p1, struct S_ID p2,  void (*cb)(struct S_ID, double, struct S_ID)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_IP(struct S_IP p0, double p1, struct S_IP p2,  void (*cb)(struct S_IP, double, struct S_IP)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_FI(struct S_FI p0, double p1, struct S_FI p2,  void (*cb)(struct S_FI, double, struct S_FI)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_FF(struct S_FF p0, double p1, struct S_FF p2,  void (*cb)(struct S_FF, double, struct S_FF)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_FD(struct S_FD p0, double p1, struct S_FD p2,  void (*cb)(struct S_FD, double, struct S_FD)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_FP(struct S_FP p0, double p1, struct S_FP p2,  void (*cb)(struct S_FP, double, struct S_FP)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_DI(struct S_DI p0, double p1, struct S_DI p2,  void (*cb)(struct S_DI, double, struct S_DI)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_DF(struct S_DF p0, double p1, struct S_DF p2,  void (*cb)(struct S_DF, double, struct S_DF)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_DD(struct S_DD p0, double p1, struct S_DD p2,  void (*cb)(struct S_DD, double, struct S_DD)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_DP(struct S_DP p0, double p1, struct S_DP p2,  void (*cb)(struct S_DP, double, struct S_DP)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_PI(struct S_PI p0, double p1, struct S_PI p2,  void (*cb)(struct S_PI, double, struct S_PI)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_PF(struct S_PF p0, double p1, struct S_PF p2,  void (*cb)(struct S_PF, double, struct S_PF)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_PD(struct S_PD p0, double p1, struct S_PD p2,  void (*cb)(struct S_PD, double, struct S_PD)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_PP(struct S_PP p0, double p1, struct S_PP p2,  void (*cb)(struct S_PP, double, struct S_PP)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_III(struct S_III p0, double p1, struct S_III p2,  void (*cb)(struct S_III, double, struct S_III)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_IIF(struct S_IIF p0, double p1, struct S_IIF p2,  void (*cb)(struct S_IIF, double, struct S_IIF)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_IID(struct S_IID p0, double p1, struct S_IID p2,  void (*cb)(struct S_IID, double, struct S_IID)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_IIP(struct S_IIP p0, double p1, struct S_IIP p2,  void (*cb)(struct S_IIP, double, struct S_IIP)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_IFI(struct S_IFI p0, double p1, struct S_IFI p2,  void (*cb)(struct S_IFI, double, struct S_IFI)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_IFF(struct S_IFF p0, double p1, struct S_IFF p2,  void (*cb)(struct S_IFF, double, struct S_IFF)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_IFD(struct S_IFD p0, double p1, struct S_IFD p2,  void (*cb)(struct S_IFD, double, struct S_IFD)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_IFP(struct S_IFP p0, double p1, struct S_IFP p2,  void (*cb)(struct S_IFP, double, struct S_IFP)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_IDI(struct S_IDI p0, double p1, struct S_IDI p2,  void (*cb)(struct S_IDI, double, struct S_IDI)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_IDF(struct S_IDF p0, double p1, struct S_IDF p2,  void (*cb)(struct S_IDF, double, struct S_IDF)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_IDD(struct S_IDD p0, double p1, struct S_IDD p2,  void (*cb)(struct S_IDD, double, struct S_IDD)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_IDP(struct S_IDP p0, double p1, struct S_IDP p2,  void (*cb)(struct S_IDP, double, struct S_IDP)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_IPI(struct S_IPI p0, double p1, struct S_IPI p2,  void (*cb)(struct S_IPI, double, struct S_IPI)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_IPF(struct S_IPF p0, double p1, struct S_IPF p2,  void (*cb)(struct S_IPF, double, struct S_IPF)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_IPD(struct S_IPD p0, double p1, struct S_IPD p2,  void (*cb)(struct S_IPD, double, struct S_IPD)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_IPP(struct S_IPP p0, double p1, struct S_IPP p2,  void (*cb)(struct S_IPP, double, struct S_IPP)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_FII(struct S_FII p0, double p1, struct S_FII p2,  void (*cb)(struct S_FII, double, struct S_FII)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_FIF(struct S_FIF p0, double p1, struct S_FIF p2,  void (*cb)(struct S_FIF, double, struct S_FIF)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_FID(struct S_FID p0, double p1, struct S_FID p2,  void (*cb)(struct S_FID, double, struct S_FID)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_FIP(struct S_FIP p0, double p1, struct S_FIP p2,  void (*cb)(struct S_FIP, double, struct S_FIP)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_FFI(struct S_FFI p0, double p1, struct S_FFI p2,  void (*cb)(struct S_FFI, double, struct S_FFI)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_FFF(struct S_FFF p0, double p1, struct S_FFF p2,  void (*cb)(struct S_FFF, double, struct S_FFF)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_FFD(struct S_FFD p0, double p1, struct S_FFD p2,  void (*cb)(struct S_FFD, double, struct S_FFD)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_FFP(struct S_FFP p0, double p1, struct S_FFP p2,  void (*cb)(struct S_FFP, double, struct S_FFP)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_FDI(struct S_FDI p0, double p1, struct S_FDI p2,  void (*cb)(struct S_FDI, double, struct S_FDI)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_FDF(struct S_FDF p0, double p1, struct S_FDF p2,  void (*cb)(struct S_FDF, double, struct S_FDF)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_FDD(struct S_FDD p0, double p1, struct S_FDD p2,  void (*cb)(struct S_FDD, double, struct S_FDD)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_FDP(struct S_FDP p0, double p1, struct S_FDP p2,  void (*cb)(struct S_FDP, double, struct S_FDP)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_FPI(struct S_FPI p0, double p1, struct S_FPI p2,  void (*cb)(struct S_FPI, double, struct S_FPI)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_FPF(struct S_FPF p0, double p1, struct S_FPF p2,  void (*cb)(struct S_FPF, double, struct S_FPF)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_FPD(struct S_FPD p0, double p1, struct S_FPD p2,  void (*cb)(struct S_FPD, double, struct S_FPD)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_FPP(struct S_FPP p0, double p1, struct S_FPP p2,  void (*cb)(struct S_FPP, double, struct S_FPP)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_DII(struct S_DII p0, double p1, struct S_DII p2,  void (*cb)(struct S_DII, double, struct S_DII)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_DIF(struct S_DIF p0, double p1, struct S_DIF p2,  void (*cb)(struct S_DIF, double, struct S_DIF)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_DID(struct S_DID p0, double p1, struct S_DID p2,  void (*cb)(struct S_DID, double, struct S_DID)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_DIP(struct S_DIP p0, double p1, struct S_DIP p2,  void (*cb)(struct S_DIP, double, struct S_DIP)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_DFI(struct S_DFI p0, double p1, struct S_DFI p2,  void (*cb)(struct S_DFI, double, struct S_DFI)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_DFF(struct S_DFF p0, double p1, struct S_DFF p2,  void (*cb)(struct S_DFF, double, struct S_DFF)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_DFD(struct S_DFD p0, double p1, struct S_DFD p2,  void (*cb)(struct S_DFD, double, struct S_DFD)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_DFP(struct S_DFP p0, double p1, struct S_DFP p2,  void (*cb)(struct S_DFP, double, struct S_DFP)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_DDI(struct S_DDI p0, double p1, struct S_DDI p2,  void (*cb)(struct S_DDI, double, struct S_DDI)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_DDF(struct S_DDF p0, double p1, struct S_DDF p2,  void (*cb)(struct S_DDF, double, struct S_DDF)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_DDD(struct S_DDD p0, double p1, struct S_DDD p2,  void (*cb)(struct S_DDD, double, struct S_DDD)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_DDP(struct S_DDP p0, double p1, struct S_DDP p2,  void (*cb)(struct S_DDP, double, struct S_DDP)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_DPI(struct S_DPI p0, double p1, struct S_DPI p2,  void (*cb)(struct S_DPI, double, struct S_DPI)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_DPF(struct S_DPF p0, double p1, struct S_DPF p2,  void (*cb)(struct S_DPF, double, struct S_DPF)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_DPD(struct S_DPD p0, double p1, struct S_DPD p2,  void (*cb)(struct S_DPD, double, struct S_DPD)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_DPP(struct S_DPP p0, double p1, struct S_DPP p2,  void (*cb)(struct S_DPP, double, struct S_DPP)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_PII(struct S_PII p0, double p1, struct S_PII p2,  void (*cb)(struct S_PII, double, struct S_PII)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_PIF(struct S_PIF p0, double p1, struct S_PIF p2,  void (*cb)(struct S_PIF, double, struct S_PIF)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_PID(struct S_PID p0, double p1, struct S_PID p2,  void (*cb)(struct S_PID, double, struct S_PID)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_PIP(struct S_PIP p0, double p1, struct S_PIP p2,  void (*cb)(struct S_PIP, double, struct S_PIP)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_PFI(struct S_PFI p0, double p1, struct S_PFI p2,  void (*cb)(struct S_PFI, double, struct S_PFI)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_PFF(struct S_PFF p0, double p1, struct S_PFF p2,  void (*cb)(struct S_PFF, double, struct S_PFF)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_PFD(struct S_PFD p0, double p1, struct S_PFD p2,  void (*cb)(struct S_PFD, double, struct S_PFD)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_PFP(struct S_PFP p0, double p1, struct S_PFP p2,  void (*cb)(struct S_PFP, double, struct S_PFP)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_PDI(struct S_PDI p0, double p1, struct S_PDI p2,  void (*cb)(struct S_PDI, double, struct S_PDI)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_PDF(struct S_PDF p0, double p1, struct S_PDF p2,  void (*cb)(struct S_PDF, double, struct S_PDF)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_PDD(struct S_PDD p0, double p1, struct S_PDD p2,  void (*cb)(struct S_PDD, double, struct S_PDD)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_PDP(struct S_PDP p0, double p1, struct S_PDP p2,  void (*cb)(struct S_PDP, double, struct S_PDP)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_PPI(struct S_PPI p0, double p1, struct S_PPI p2,  void (*cb)(struct S_PPI, double, struct S_PPI)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_PPF(struct S_PPF p0, double p1, struct S_PPF p2,  void (*cb)(struct S_PPF, double, struct S_PPF)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_PPD(struct S_PPD p0, double p1, struct S_PPD p2,  void (*cb)(struct S_PPD, double, struct S_PPD)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SDS_PPP(struct S_PPP p0, double p1, struct S_PPP p2,  void (*cb)(struct S_PPP, double, struct S_PPP)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_I(struct S_I p0, void* p1, int p2,  void (*cb)(struct S_I, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_F(struct S_F p0, void* p1, int p2,  void (*cb)(struct S_F, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_D(struct S_D p0, void* p1, int p2,  void (*cb)(struct S_D, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_P(struct S_P p0, void* p1, int p2,  void (*cb)(struct S_P, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_II(struct S_II p0, void* p1, int p2,  void (*cb)(struct S_II, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_IF(struct S_IF p0, void* p1, int p2,  void (*cb)(struct S_IF, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_ID(struct S_ID p0, void* p1, int p2,  void (*cb)(struct S_ID, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_IP(struct S_IP p0, void* p1, int p2,  void (*cb)(struct S_IP, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_FI(struct S_FI p0, void* p1, int p2,  void (*cb)(struct S_FI, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_FF(struct S_FF p0, void* p1, int p2,  void (*cb)(struct S_FF, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_FD(struct S_FD p0, void* p1, int p2,  void (*cb)(struct S_FD, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_FP(struct S_FP p0, void* p1, int p2,  void (*cb)(struct S_FP, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_DI(struct S_DI p0, void* p1, int p2,  void (*cb)(struct S_DI, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_DF(struct S_DF p0, void* p1, int p2,  void (*cb)(struct S_DF, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_DD(struct S_DD p0, void* p1, int p2,  void (*cb)(struct S_DD, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_DP(struct S_DP p0, void* p1, int p2,  void (*cb)(struct S_DP, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_PI(struct S_PI p0, void* p1, int p2,  void (*cb)(struct S_PI, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_PF(struct S_PF p0, void* p1, int p2,  void (*cb)(struct S_PF, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_PD(struct S_PD p0, void* p1, int p2,  void (*cb)(struct S_PD, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_PP(struct S_PP p0, void* p1, int p2,  void (*cb)(struct S_PP, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_III(struct S_III p0, void* p1, int p2,  void (*cb)(struct S_III, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_IIF(struct S_IIF p0, void* p1, int p2,  void (*cb)(struct S_IIF, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_IID(struct S_IID p0, void* p1, int p2,  void (*cb)(struct S_IID, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_IIP(struct S_IIP p0, void* p1, int p2,  void (*cb)(struct S_IIP, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_IFI(struct S_IFI p0, void* p1, int p2,  void (*cb)(struct S_IFI, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_IFF(struct S_IFF p0, void* p1, int p2,  void (*cb)(struct S_IFF, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_IFD(struct S_IFD p0, void* p1, int p2,  void (*cb)(struct S_IFD, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_IFP(struct S_IFP p0, void* p1, int p2,  void (*cb)(struct S_IFP, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_IDI(struct S_IDI p0, void* p1, int p2,  void (*cb)(struct S_IDI, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_IDF(struct S_IDF p0, void* p1, int p2,  void (*cb)(struct S_IDF, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_IDD(struct S_IDD p0, void* p1, int p2,  void (*cb)(struct S_IDD, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_IDP(struct S_IDP p0, void* p1, int p2,  void (*cb)(struct S_IDP, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_IPI(struct S_IPI p0, void* p1, int p2,  void (*cb)(struct S_IPI, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_IPF(struct S_IPF p0, void* p1, int p2,  void (*cb)(struct S_IPF, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_IPD(struct S_IPD p0, void* p1, int p2,  void (*cb)(struct S_IPD, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_IPP(struct S_IPP p0, void* p1, int p2,  void (*cb)(struct S_IPP, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_FII(struct S_FII p0, void* p1, int p2,  void (*cb)(struct S_FII, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_FIF(struct S_FIF p0, void* p1, int p2,  void (*cb)(struct S_FIF, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_FID(struct S_FID p0, void* p1, int p2,  void (*cb)(struct S_FID, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_FIP(struct S_FIP p0, void* p1, int p2,  void (*cb)(struct S_FIP, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_FFI(struct S_FFI p0, void* p1, int p2,  void (*cb)(struct S_FFI, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_FFF(struct S_FFF p0, void* p1, int p2,  void (*cb)(struct S_FFF, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_FFD(struct S_FFD p0, void* p1, int p2,  void (*cb)(struct S_FFD, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_FFP(struct S_FFP p0, void* p1, int p2,  void (*cb)(struct S_FFP, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_FDI(struct S_FDI p0, void* p1, int p2,  void (*cb)(struct S_FDI, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_FDF(struct S_FDF p0, void* p1, int p2,  void (*cb)(struct S_FDF, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_FDD(struct S_FDD p0, void* p1, int p2,  void (*cb)(struct S_FDD, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_FDP(struct S_FDP p0, void* p1, int p2,  void (*cb)(struct S_FDP, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_FPI(struct S_FPI p0, void* p1, int p2,  void (*cb)(struct S_FPI, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_FPF(struct S_FPF p0, void* p1, int p2,  void (*cb)(struct S_FPF, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_FPD(struct S_FPD p0, void* p1, int p2,  void (*cb)(struct S_FPD, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_FPP(struct S_FPP p0, void* p1, int p2,  void (*cb)(struct S_FPP, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_DII(struct S_DII p0, void* p1, int p2,  void (*cb)(struct S_DII, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_DIF(struct S_DIF p0, void* p1, int p2,  void (*cb)(struct S_DIF, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_DID(struct S_DID p0, void* p1, int p2,  void (*cb)(struct S_DID, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_DIP(struct S_DIP p0, void* p1, int p2,  void (*cb)(struct S_DIP, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_DFI(struct S_DFI p0, void* p1, int p2,  void (*cb)(struct S_DFI, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_DFF(struct S_DFF p0, void* p1, int p2,  void (*cb)(struct S_DFF, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_DFD(struct S_DFD p0, void* p1, int p2,  void (*cb)(struct S_DFD, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_DFP(struct S_DFP p0, void* p1, int p2,  void (*cb)(struct S_DFP, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_DDI(struct S_DDI p0, void* p1, int p2,  void (*cb)(struct S_DDI, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_DDF(struct S_DDF p0, void* p1, int p2,  void (*cb)(struct S_DDF, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_DDD(struct S_DDD p0, void* p1, int p2,  void (*cb)(struct S_DDD, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_DDP(struct S_DDP p0, void* p1, int p2,  void (*cb)(struct S_DDP, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_DPI(struct S_DPI p0, void* p1, int p2,  void (*cb)(struct S_DPI, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_DPF(struct S_DPF p0, void* p1, int p2,  void (*cb)(struct S_DPF, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_DPD(struct S_DPD p0, void* p1, int p2,  void (*cb)(struct S_DPD, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_DPP(struct S_DPP p0, void* p1, int p2,  void (*cb)(struct S_DPP, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_PII(struct S_PII p0, void* p1, int p2,  void (*cb)(struct S_PII, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_PIF(struct S_PIF p0, void* p1, int p2,  void (*cb)(struct S_PIF, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_PID(struct S_PID p0, void* p1, int p2,  void (*cb)(struct S_PID, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_PIP(struct S_PIP p0, void* p1, int p2,  void (*cb)(struct S_PIP, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_PFI(struct S_PFI p0, void* p1, int p2,  void (*cb)(struct S_PFI, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_PFF(struct S_PFF p0, void* p1, int p2,  void (*cb)(struct S_PFF, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_PFD(struct S_PFD p0, void* p1, int p2,  void (*cb)(struct S_PFD, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_PFP(struct S_PFP p0, void* p1, int p2,  void (*cb)(struct S_PFP, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_PDI(struct S_PDI p0, void* p1, int p2,  void (*cb)(struct S_PDI, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_PDF(struct S_PDF p0, void* p1, int p2,  void (*cb)(struct S_PDF, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_PDD(struct S_PDD p0, void* p1, int p2,  void (*cb)(struct S_PDD, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_PDP(struct S_PDP p0, void* p1, int p2,  void (*cb)(struct S_PDP, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_PPI(struct S_PPI p0, void* p1, int p2,  void (*cb)(struct S_PPI, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_PPF(struct S_PPF p0, void* p1, int p2,  void (*cb)(struct S_PPF, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_PPD(struct S_PPD p0, void* p1, int p2,  void (*cb)(struct S_PPD, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPI_PPP(struct S_PPP p0, void* p1, int p2,  void (*cb)(struct S_PPP, void*, int)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_I(struct S_I p0, void* p1, float p2,  void (*cb)(struct S_I, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_F(struct S_F p0, void* p1, float p2,  void (*cb)(struct S_F, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_D(struct S_D p0, void* p1, float p2,  void (*cb)(struct S_D, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_P(struct S_P p0, void* p1, float p2,  void (*cb)(struct S_P, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_II(struct S_II p0, void* p1, float p2,  void (*cb)(struct S_II, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_IF(struct S_IF p0, void* p1, float p2,  void (*cb)(struct S_IF, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_ID(struct S_ID p0, void* p1, float p2,  void (*cb)(struct S_ID, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_IP(struct S_IP p0, void* p1, float p2,  void (*cb)(struct S_IP, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_FI(struct S_FI p0, void* p1, float p2,  void (*cb)(struct S_FI, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_FF(struct S_FF p0, void* p1, float p2,  void (*cb)(struct S_FF, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_FD(struct S_FD p0, void* p1, float p2,  void (*cb)(struct S_FD, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_FP(struct S_FP p0, void* p1, float p2,  void (*cb)(struct S_FP, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_DI(struct S_DI p0, void* p1, float p2,  void (*cb)(struct S_DI, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_DF(struct S_DF p0, void* p1, float p2,  void (*cb)(struct S_DF, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_DD(struct S_DD p0, void* p1, float p2,  void (*cb)(struct S_DD, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_DP(struct S_DP p0, void* p1, float p2,  void (*cb)(struct S_DP, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_PI(struct S_PI p0, void* p1, float p2,  void (*cb)(struct S_PI, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_PF(struct S_PF p0, void* p1, float p2,  void (*cb)(struct S_PF, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_PD(struct S_PD p0, void* p1, float p2,  void (*cb)(struct S_PD, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_PP(struct S_PP p0, void* p1, float p2,  void (*cb)(struct S_PP, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_III(struct S_III p0, void* p1, float p2,  void (*cb)(struct S_III, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_IIF(struct S_IIF p0, void* p1, float p2,  void (*cb)(struct S_IIF, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_IID(struct S_IID p0, void* p1, float p2,  void (*cb)(struct S_IID, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_IIP(struct S_IIP p0, void* p1, float p2,  void (*cb)(struct S_IIP, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_IFI(struct S_IFI p0, void* p1, float p2,  void (*cb)(struct S_IFI, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_IFF(struct S_IFF p0, void* p1, float p2,  void (*cb)(struct S_IFF, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_IFD(struct S_IFD p0, void* p1, float p2,  void (*cb)(struct S_IFD, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_IFP(struct S_IFP p0, void* p1, float p2,  void (*cb)(struct S_IFP, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_IDI(struct S_IDI p0, void* p1, float p2,  void (*cb)(struct S_IDI, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_IDF(struct S_IDF p0, void* p1, float p2,  void (*cb)(struct S_IDF, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_IDD(struct S_IDD p0, void* p1, float p2,  void (*cb)(struct S_IDD, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_IDP(struct S_IDP p0, void* p1, float p2,  void (*cb)(struct S_IDP, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_IPI(struct S_IPI p0, void* p1, float p2,  void (*cb)(struct S_IPI, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_IPF(struct S_IPF p0, void* p1, float p2,  void (*cb)(struct S_IPF, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_IPD(struct S_IPD p0, void* p1, float p2,  void (*cb)(struct S_IPD, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_IPP(struct S_IPP p0, void* p1, float p2,  void (*cb)(struct S_IPP, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_FII(struct S_FII p0, void* p1, float p2,  void (*cb)(struct S_FII, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_FIF(struct S_FIF p0, void* p1, float p2,  void (*cb)(struct S_FIF, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_FID(struct S_FID p0, void* p1, float p2,  void (*cb)(struct S_FID, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_FIP(struct S_FIP p0, void* p1, float p2,  void (*cb)(struct S_FIP, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_FFI(struct S_FFI p0, void* p1, float p2,  void (*cb)(struct S_FFI, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_FFF(struct S_FFF p0, void* p1, float p2,  void (*cb)(struct S_FFF, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_FFD(struct S_FFD p0, void* p1, float p2,  void (*cb)(struct S_FFD, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_FFP(struct S_FFP p0, void* p1, float p2,  void (*cb)(struct S_FFP, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_FDI(struct S_FDI p0, void* p1, float p2,  void (*cb)(struct S_FDI, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_FDF(struct S_FDF p0, void* p1, float p2,  void (*cb)(struct S_FDF, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_FDD(struct S_FDD p0, void* p1, float p2,  void (*cb)(struct S_FDD, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_FDP(struct S_FDP p0, void* p1, float p2,  void (*cb)(struct S_FDP, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_FPI(struct S_FPI p0, void* p1, float p2,  void (*cb)(struct S_FPI, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_FPF(struct S_FPF p0, void* p1, float p2,  void (*cb)(struct S_FPF, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_FPD(struct S_FPD p0, void* p1, float p2,  void (*cb)(struct S_FPD, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_FPP(struct S_FPP p0, void* p1, float p2,  void (*cb)(struct S_FPP, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_DII(struct S_DII p0, void* p1, float p2,  void (*cb)(struct S_DII, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_DIF(struct S_DIF p0, void* p1, float p2,  void (*cb)(struct S_DIF, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_DID(struct S_DID p0, void* p1, float p2,  void (*cb)(struct S_DID, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_DIP(struct S_DIP p0, void* p1, float p2,  void (*cb)(struct S_DIP, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_DFI(struct S_DFI p0, void* p1, float p2,  void (*cb)(struct S_DFI, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_DFF(struct S_DFF p0, void* p1, float p2,  void (*cb)(struct S_DFF, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_DFD(struct S_DFD p0, void* p1, float p2,  void (*cb)(struct S_DFD, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_DFP(struct S_DFP p0, void* p1, float p2,  void (*cb)(struct S_DFP, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_DDI(struct S_DDI p0, void* p1, float p2,  void (*cb)(struct S_DDI, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_DDF(struct S_DDF p0, void* p1, float p2,  void (*cb)(struct S_DDF, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_DDD(struct S_DDD p0, void* p1, float p2,  void (*cb)(struct S_DDD, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_DDP(struct S_DDP p0, void* p1, float p2,  void (*cb)(struct S_DDP, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_DPI(struct S_DPI p0, void* p1, float p2,  void (*cb)(struct S_DPI, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_DPF(struct S_DPF p0, void* p1, float p2,  void (*cb)(struct S_DPF, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_DPD(struct S_DPD p0, void* p1, float p2,  void (*cb)(struct S_DPD, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_DPP(struct S_DPP p0, void* p1, float p2,  void (*cb)(struct S_DPP, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_PII(struct S_PII p0, void* p1, float p2,  void (*cb)(struct S_PII, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_PIF(struct S_PIF p0, void* p1, float p2,  void (*cb)(struct S_PIF, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_PID(struct S_PID p0, void* p1, float p2,  void (*cb)(struct S_PID, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_PIP(struct S_PIP p0, void* p1, float p2,  void (*cb)(struct S_PIP, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_PFI(struct S_PFI p0, void* p1, float p2,  void (*cb)(struct S_PFI, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_PFF(struct S_PFF p0, void* p1, float p2,  void (*cb)(struct S_PFF, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_PFD(struct S_PFD p0, void* p1, float p2,  void (*cb)(struct S_PFD, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_PFP(struct S_PFP p0, void* p1, float p2,  void (*cb)(struct S_PFP, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_PDI(struct S_PDI p0, void* p1, float p2,  void (*cb)(struct S_PDI, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_PDF(struct S_PDF p0, void* p1, float p2,  void (*cb)(struct S_PDF, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_PDD(struct S_PDD p0, void* p1, float p2,  void (*cb)(struct S_PDD, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_PDP(struct S_PDP p0, void* p1, float p2,  void (*cb)(struct S_PDP, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_PPI(struct S_PPI p0, void* p1, float p2,  void (*cb)(struct S_PPI, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_PPF(struct S_PPF p0, void* p1, float p2,  void (*cb)(struct S_PPF, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_PPD(struct S_PPD p0, void* p1, float p2,  void (*cb)(struct S_PPD, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPF_PPP(struct S_PPP p0, void* p1, float p2,  void (*cb)(struct S_PPP, void*, float)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPD_I(struct S_I p0, void* p1, double p2,  void (*cb)(struct S_I, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPD_F(struct S_F p0, void* p1, double p2,  void (*cb)(struct S_F, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPD_D(struct S_D p0, void* p1, double p2,  void (*cb)(struct S_D, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPD_P(struct S_P p0, void* p1, double p2,  void (*cb)(struct S_P, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPD_II(struct S_II p0, void* p1, double p2,  void (*cb)(struct S_II, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPD_IF(struct S_IF p0, void* p1, double p2,  void (*cb)(struct S_IF, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPD_ID(struct S_ID p0, void* p1, double p2,  void (*cb)(struct S_ID, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPD_IP(struct S_IP p0, void* p1, double p2,  void (*cb)(struct S_IP, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPD_FI(struct S_FI p0, void* p1, double p2,  void (*cb)(struct S_FI, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPD_FF(struct S_FF p0, void* p1, double p2,  void (*cb)(struct S_FF, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPD_FD(struct S_FD p0, void* p1, double p2,  void (*cb)(struct S_FD, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPD_FP(struct S_FP p0, void* p1, double p2,  void (*cb)(struct S_FP, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPD_DI(struct S_DI p0, void* p1, double p2,  void (*cb)(struct S_DI, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPD_DF(struct S_DF p0, void* p1, double p2,  void (*cb)(struct S_DF, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPD_DD(struct S_DD p0, void* p1, double p2,  void (*cb)(struct S_DD, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPD_DP(struct S_DP p0, void* p1, double p2,  void (*cb)(struct S_DP, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPD_PI(struct S_PI p0, void* p1, double p2,  void (*cb)(struct S_PI, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPD_PF(struct S_PF p0, void* p1, double p2,  void (*cb)(struct S_PF, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPD_PD(struct S_PD p0, void* p1, double p2,  void (*cb)(struct S_PD, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPD_PP(struct S_PP p0, void* p1, double p2,  void (*cb)(struct S_PP, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPD_III(struct S_III p0, void* p1, double p2,  void (*cb)(struct S_III, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPD_IIF(struct S_IIF p0, void* p1, double p2,  void (*cb)(struct S_IIF, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f8_V_SPD_IID(struct S_IID p0, void* p1, double p2,  void (*cb)(struct S_IID, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPD_IIP(struct S_IIP p0, void* p1, double p2,  void (*cb)(struct S_IIP, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPD_IFI(struct S_IFI p0, void* p1, double p2,  void (*cb)(struct S_IFI, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPD_IFF(struct S_IFF p0, void* p1, double p2,  void (*cb)(struct S_IFF, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPD_IFD(struct S_IFD p0, void* p1, double p2,  void (*cb)(struct S_IFD, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPD_IFP(struct S_IFP p0, void* p1, double p2,  void (*cb)(struct S_IFP, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPD_IDI(struct S_IDI p0, void* p1, double p2,  void (*cb)(struct S_IDI, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPD_IDF(struct S_IDF p0, void* p1, double p2,  void (*cb)(struct S_IDF, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPD_IDD(struct S_IDD p0, void* p1, double p2,  void (*cb)(struct S_IDD, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPD_IDP(struct S_IDP p0, void* p1, double p2,  void (*cb)(struct S_IDP, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPD_IPI(struct S_IPI p0, void* p1, double p2,  void (*cb)(struct S_IPI, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPD_IPF(struct S_IPF p0, void* p1, double p2,  void (*cb)(struct S_IPF, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPD_IPD(struct S_IPD p0, void* p1, double p2,  void (*cb)(struct S_IPD, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPD_IPP(struct S_IPP p0, void* p1, double p2,  void (*cb)(struct S_IPP, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPD_FII(struct S_FII p0, void* p1, double p2,  void (*cb)(struct S_FII, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPD_FIF(struct S_FIF p0, void* p1, double p2,  void (*cb)(struct S_FIF, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPD_FID(struct S_FID p0, void* p1, double p2,  void (*cb)(struct S_FID, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPD_FIP(struct S_FIP p0, void* p1, double p2,  void (*cb)(struct S_FIP, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPD_FFI(struct S_FFI p0, void* p1, double p2,  void (*cb)(struct S_FFI, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPD_FFF(struct S_FFF p0, void* p1, double p2,  void (*cb)(struct S_FFF, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPD_FFD(struct S_FFD p0, void* p1, double p2,  void (*cb)(struct S_FFD, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPD_FFP(struct S_FFP p0, void* p1, double p2,  void (*cb)(struct S_FFP, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPD_FDI(struct S_FDI p0, void* p1, double p2,  void (*cb)(struct S_FDI, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPD_FDF(struct S_FDF p0, void* p1, double p2,  void (*cb)(struct S_FDF, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPD_FDD(struct S_FDD p0, void* p1, double p2,  void (*cb)(struct S_FDD, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPD_FDP(struct S_FDP p0, void* p1, double p2,  void (*cb)(struct S_FDP, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPD_FPI(struct S_FPI p0, void* p1, double p2,  void (*cb)(struct S_FPI, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPD_FPF(struct S_FPF p0, void* p1, double p2,  void (*cb)(struct S_FPF, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPD_FPD(struct S_FPD p0, void* p1, double p2,  void (*cb)(struct S_FPD, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPD_FPP(struct S_FPP p0, void* p1, double p2,  void (*cb)(struct S_FPP, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPD_DII(struct S_DII p0, void* p1, double p2,  void (*cb)(struct S_DII, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPD_DIF(struct S_DIF p0, void* p1, double p2,  void (*cb)(struct S_DIF, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPD_DID(struct S_DID p0, void* p1, double p2,  void (*cb)(struct S_DID, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPD_DIP(struct S_DIP p0, void* p1, double p2,  void (*cb)(struct S_DIP, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPD_DFI(struct S_DFI p0, void* p1, double p2,  void (*cb)(struct S_DFI, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPD_DFF(struct S_DFF p0, void* p1, double p2,  void (*cb)(struct S_DFF, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPD_DFD(struct S_DFD p0, void* p1, double p2,  void (*cb)(struct S_DFD, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPD_DFP(struct S_DFP p0, void* p1, double p2,  void (*cb)(struct S_DFP, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPD_DDI(struct S_DDI p0, void* p1, double p2,  void (*cb)(struct S_DDI, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPD_DDF(struct S_DDF p0, void* p1, double p2,  void (*cb)(struct S_DDF, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPD_DDD(struct S_DDD p0, void* p1, double p2,  void (*cb)(struct S_DDD, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPD_DDP(struct S_DDP p0, void* p1, double p2,  void (*cb)(struct S_DDP, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPD_DPI(struct S_DPI p0, void* p1, double p2,  void (*cb)(struct S_DPI, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPD_DPF(struct S_DPF p0, void* p1, double p2,  void (*cb)(struct S_DPF, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPD_DPD(struct S_DPD p0, void* p1, double p2,  void (*cb)(struct S_DPD, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPD_DPP(struct S_DPP p0, void* p1, double p2,  void (*cb)(struct S_DPP, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPD_PII(struct S_PII p0, void* p1, double p2,  void (*cb)(struct S_PII, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPD_PIF(struct S_PIF p0, void* p1, double p2,  void (*cb)(struct S_PIF, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPD_PID(struct S_PID p0, void* p1, double p2,  void (*cb)(struct S_PID, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPD_PIP(struct S_PIP p0, void* p1, double p2,  void (*cb)(struct S_PIP, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPD_PFI(struct S_PFI p0, void* p1, double p2,  void (*cb)(struct S_PFI, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPD_PFF(struct S_PFF p0, void* p1, double p2,  void (*cb)(struct S_PFF, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPD_PFD(struct S_PFD p0, void* p1, double p2,  void (*cb)(struct S_PFD, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPD_PFP(struct S_PFP p0, void* p1, double p2,  void (*cb)(struct S_PFP, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPD_PDI(struct S_PDI p0, void* p1, double p2,  void (*cb)(struct S_PDI, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPD_PDF(struct S_PDF p0, void* p1, double p2,  void (*cb)(struct S_PDF, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPD_PDD(struct S_PDD p0, void* p1, double p2,  void (*cb)(struct S_PDD, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPD_PDP(struct S_PDP p0, void* p1, double p2,  void (*cb)(struct S_PDP, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPD_PPI(struct S_PPI p0, void* p1, double p2,  void (*cb)(struct S_PPI, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPD_PPF(struct S_PPF p0, void* p1, double p2,  void (*cb)(struct S_PPF, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPD_PPD(struct S_PPD p0, void* p1, double p2,  void (*cb)(struct S_PPD, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPD_PPP(struct S_PPP p0, void* p1, double p2,  void (*cb)(struct S_PPP, void*, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_I(struct S_I p0, void* p1, void* p2,  void (*cb)(struct S_I, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_F(struct S_F p0, void* p1, void* p2,  void (*cb)(struct S_F, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_D(struct S_D p0, void* p1, void* p2,  void (*cb)(struct S_D, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_P(struct S_P p0, void* p1, void* p2,  void (*cb)(struct S_P, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_II(struct S_II p0, void* p1, void* p2,  void (*cb)(struct S_II, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_IF(struct S_IF p0, void* p1, void* p2,  void (*cb)(struct S_IF, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_ID(struct S_ID p0, void* p1, void* p2,  void (*cb)(struct S_ID, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_IP(struct S_IP p0, void* p1, void* p2,  void (*cb)(struct S_IP, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_FI(struct S_FI p0, void* p1, void* p2,  void (*cb)(struct S_FI, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_FF(struct S_FF p0, void* p1, void* p2,  void (*cb)(struct S_FF, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_FD(struct S_FD p0, void* p1, void* p2,  void (*cb)(struct S_FD, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_FP(struct S_FP p0, void* p1, void* p2,  void (*cb)(struct S_FP, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_DI(struct S_DI p0, void* p1, void* p2,  void (*cb)(struct S_DI, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_DF(struct S_DF p0, void* p1, void* p2,  void (*cb)(struct S_DF, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_DD(struct S_DD p0, void* p1, void* p2,  void (*cb)(struct S_DD, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_DP(struct S_DP p0, void* p1, void* p2,  void (*cb)(struct S_DP, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_PI(struct S_PI p0, void* p1, void* p2,  void (*cb)(struct S_PI, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_PF(struct S_PF p0, void* p1, void* p2,  void (*cb)(struct S_PF, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_PD(struct S_PD p0, void* p1, void* p2,  void (*cb)(struct S_PD, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_PP(struct S_PP p0, void* p1, void* p2,  void (*cb)(struct S_PP, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_III(struct S_III p0, void* p1, void* p2,  void (*cb)(struct S_III, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_IIF(struct S_IIF p0, void* p1, void* p2,  void (*cb)(struct S_IIF, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_IID(struct S_IID p0, void* p1, void* p2,  void (*cb)(struct S_IID, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_IIP(struct S_IIP p0, void* p1, void* p2,  void (*cb)(struct S_IIP, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_IFI(struct S_IFI p0, void* p1, void* p2,  void (*cb)(struct S_IFI, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_IFF(struct S_IFF p0, void* p1, void* p2,  void (*cb)(struct S_IFF, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_IFD(struct S_IFD p0, void* p1, void* p2,  void (*cb)(struct S_IFD, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_IFP(struct S_IFP p0, void* p1, void* p2,  void (*cb)(struct S_IFP, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_IDI(struct S_IDI p0, void* p1, void* p2,  void (*cb)(struct S_IDI, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_IDF(struct S_IDF p0, void* p1, void* p2,  void (*cb)(struct S_IDF, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_IDD(struct S_IDD p0, void* p1, void* p2,  void (*cb)(struct S_IDD, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_IDP(struct S_IDP p0, void* p1, void* p2,  void (*cb)(struct S_IDP, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_IPI(struct S_IPI p0, void* p1, void* p2,  void (*cb)(struct S_IPI, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_IPF(struct S_IPF p0, void* p1, void* p2,  void (*cb)(struct S_IPF, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_IPD(struct S_IPD p0, void* p1, void* p2,  void (*cb)(struct S_IPD, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_IPP(struct S_IPP p0, void* p1, void* p2,  void (*cb)(struct S_IPP, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_FII(struct S_FII p0, void* p1, void* p2,  void (*cb)(struct S_FII, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_FIF(struct S_FIF p0, void* p1, void* p2,  void (*cb)(struct S_FIF, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_FID(struct S_FID p0, void* p1, void* p2,  void (*cb)(struct S_FID, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_FIP(struct S_FIP p0, void* p1, void* p2,  void (*cb)(struct S_FIP, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_FFI(struct S_FFI p0, void* p1, void* p2,  void (*cb)(struct S_FFI, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_FFF(struct S_FFF p0, void* p1, void* p2,  void (*cb)(struct S_FFF, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_FFD(struct S_FFD p0, void* p1, void* p2,  void (*cb)(struct S_FFD, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_FFP(struct S_FFP p0, void* p1, void* p2,  void (*cb)(struct S_FFP, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_FDI(struct S_FDI p0, void* p1, void* p2,  void (*cb)(struct S_FDI, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_FDF(struct S_FDF p0, void* p1, void* p2,  void (*cb)(struct S_FDF, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_FDD(struct S_FDD p0, void* p1, void* p2,  void (*cb)(struct S_FDD, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_FDP(struct S_FDP p0, void* p1, void* p2,  void (*cb)(struct S_FDP, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_FPI(struct S_FPI p0, void* p1, void* p2,  void (*cb)(struct S_FPI, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_FPF(struct S_FPF p0, void* p1, void* p2,  void (*cb)(struct S_FPF, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_FPD(struct S_FPD p0, void* p1, void* p2,  void (*cb)(struct S_FPD, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_FPP(struct S_FPP p0, void* p1, void* p2,  void (*cb)(struct S_FPP, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_DII(struct S_DII p0, void* p1, void* p2,  void (*cb)(struct S_DII, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_DIF(struct S_DIF p0, void* p1, void* p2,  void (*cb)(struct S_DIF, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_DID(struct S_DID p0, void* p1, void* p2,  void (*cb)(struct S_DID, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_DIP(struct S_DIP p0, void* p1, void* p2,  void (*cb)(struct S_DIP, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_DFI(struct S_DFI p0, void* p1, void* p2,  void (*cb)(struct S_DFI, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_DFF(struct S_DFF p0, void* p1, void* p2,  void (*cb)(struct S_DFF, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_DFD(struct S_DFD p0, void* p1, void* p2,  void (*cb)(struct S_DFD, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_DFP(struct S_DFP p0, void* p1, void* p2,  void (*cb)(struct S_DFP, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_DDI(struct S_DDI p0, void* p1, void* p2,  void (*cb)(struct S_DDI, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_DDF(struct S_DDF p0, void* p1, void* p2,  void (*cb)(struct S_DDF, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_DDD(struct S_DDD p0, void* p1, void* p2,  void (*cb)(struct S_DDD, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_DDP(struct S_DDP p0, void* p1, void* p2,  void (*cb)(struct S_DDP, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_DPI(struct S_DPI p0, void* p1, void* p2,  void (*cb)(struct S_DPI, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_DPF(struct S_DPF p0, void* p1, void* p2,  void (*cb)(struct S_DPF, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_DPD(struct S_DPD p0, void* p1, void* p2,  void (*cb)(struct S_DPD, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_DPP(struct S_DPP p0, void* p1, void* p2,  void (*cb)(struct S_DPP, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_PII(struct S_PII p0, void* p1, void* p2,  void (*cb)(struct S_PII, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_PIF(struct S_PIF p0, void* p1, void* p2,  void (*cb)(struct S_PIF, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_PID(struct S_PID p0, void* p1, void* p2,  void (*cb)(struct S_PID, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_PIP(struct S_PIP p0, void* p1, void* p2,  void (*cb)(struct S_PIP, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_PFI(struct S_PFI p0, void* p1, void* p2,  void (*cb)(struct S_PFI, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_PFF(struct S_PFF p0, void* p1, void* p2,  void (*cb)(struct S_PFF, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_PFD(struct S_PFD p0, void* p1, void* p2,  void (*cb)(struct S_PFD, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_PFP(struct S_PFP p0, void* p1, void* p2,  void (*cb)(struct S_PFP, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_PDI(struct S_PDI p0, void* p1, void* p2,  void (*cb)(struct S_PDI, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_PDF(struct S_PDF p0, void* p1, void* p2,  void (*cb)(struct S_PDF, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_PDD(struct S_PDD p0, void* p1, void* p2,  void (*cb)(struct S_PDD, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_PDP(struct S_PDP p0, void* p1, void* p2,  void (*cb)(struct S_PDP, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_PPI(struct S_PPI p0, void* p1, void* p2,  void (*cb)(struct S_PPI, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_PPF(struct S_PPF p0, void* p1, void* p2,  void (*cb)(struct S_PPF, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_PPD(struct S_PPD p0, void* p1, void* p2,  void (*cb)(struct S_PPD, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPP_PPP(struct S_PPP p0, void* p1, void* p2,  void (*cb)(struct S_PPP, void*, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_I(struct S_I p0, void* p1, struct S_I p2,  void (*cb)(struct S_I, void*, struct S_I)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_F(struct S_F p0, void* p1, struct S_F p2,  void (*cb)(struct S_F, void*, struct S_F)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_D(struct S_D p0, void* p1, struct S_D p2,  void (*cb)(struct S_D, void*, struct S_D)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_P(struct S_P p0, void* p1, struct S_P p2,  void (*cb)(struct S_P, void*, struct S_P)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_II(struct S_II p0, void* p1, struct S_II p2,  void (*cb)(struct S_II, void*, struct S_II)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_IF(struct S_IF p0, void* p1, struct S_IF p2,  void (*cb)(struct S_IF, void*, struct S_IF)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_ID(struct S_ID p0, void* p1, struct S_ID p2,  void (*cb)(struct S_ID, void*, struct S_ID)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_IP(struct S_IP p0, void* p1, struct S_IP p2,  void (*cb)(struct S_IP, void*, struct S_IP)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_FI(struct S_FI p0, void* p1, struct S_FI p2,  void (*cb)(struct S_FI, void*, struct S_FI)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_FF(struct S_FF p0, void* p1, struct S_FF p2,  void (*cb)(struct S_FF, void*, struct S_FF)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_FD(struct S_FD p0, void* p1, struct S_FD p2,  void (*cb)(struct S_FD, void*, struct S_FD)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_FP(struct S_FP p0, void* p1, struct S_FP p2,  void (*cb)(struct S_FP, void*, struct S_FP)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_DI(struct S_DI p0, void* p1, struct S_DI p2,  void (*cb)(struct S_DI, void*, struct S_DI)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_DF(struct S_DF p0, void* p1, struct S_DF p2,  void (*cb)(struct S_DF, void*, struct S_DF)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_DD(struct S_DD p0, void* p1, struct S_DD p2,  void (*cb)(struct S_DD, void*, struct S_DD)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_DP(struct S_DP p0, void* p1, struct S_DP p2,  void (*cb)(struct S_DP, void*, struct S_DP)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_PI(struct S_PI p0, void* p1, struct S_PI p2,  void (*cb)(struct S_PI, void*, struct S_PI)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_PF(struct S_PF p0, void* p1, struct S_PF p2,  void (*cb)(struct S_PF, void*, struct S_PF)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_PD(struct S_PD p0, void* p1, struct S_PD p2,  void (*cb)(struct S_PD, void*, struct S_PD)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_PP(struct S_PP p0, void* p1, struct S_PP p2,  void (*cb)(struct S_PP, void*, struct S_PP)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_III(struct S_III p0, void* p1, struct S_III p2,  void (*cb)(struct S_III, void*, struct S_III)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_IIF(struct S_IIF p0, void* p1, struct S_IIF p2,  void (*cb)(struct S_IIF, void*, struct S_IIF)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_IID(struct S_IID p0, void* p1, struct S_IID p2,  void (*cb)(struct S_IID, void*, struct S_IID)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_IIP(struct S_IIP p0, void* p1, struct S_IIP p2,  void (*cb)(struct S_IIP, void*, struct S_IIP)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_IFI(struct S_IFI p0, void* p1, struct S_IFI p2,  void (*cb)(struct S_IFI, void*, struct S_IFI)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_IFF(struct S_IFF p0, void* p1, struct S_IFF p2,  void (*cb)(struct S_IFF, void*, struct S_IFF)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_IFD(struct S_IFD p0, void* p1, struct S_IFD p2,  void (*cb)(struct S_IFD, void*, struct S_IFD)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_IFP(struct S_IFP p0, void* p1, struct S_IFP p2,  void (*cb)(struct S_IFP, void*, struct S_IFP)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_IDI(struct S_IDI p0, void* p1, struct S_IDI p2,  void (*cb)(struct S_IDI, void*, struct S_IDI)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_IDF(struct S_IDF p0, void* p1, struct S_IDF p2,  void (*cb)(struct S_IDF, void*, struct S_IDF)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_IDD(struct S_IDD p0, void* p1, struct S_IDD p2,  void (*cb)(struct S_IDD, void*, struct S_IDD)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_IDP(struct S_IDP p0, void* p1, struct S_IDP p2,  void (*cb)(struct S_IDP, void*, struct S_IDP)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_IPI(struct S_IPI p0, void* p1, struct S_IPI p2,  void (*cb)(struct S_IPI, void*, struct S_IPI)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_IPF(struct S_IPF p0, void* p1, struct S_IPF p2,  void (*cb)(struct S_IPF, void*, struct S_IPF)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_IPD(struct S_IPD p0, void* p1, struct S_IPD p2,  void (*cb)(struct S_IPD, void*, struct S_IPD)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_IPP(struct S_IPP p0, void* p1, struct S_IPP p2,  void (*cb)(struct S_IPP, void*, struct S_IPP)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_FII(struct S_FII p0, void* p1, struct S_FII p2,  void (*cb)(struct S_FII, void*, struct S_FII)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_FIF(struct S_FIF p0, void* p1, struct S_FIF p2,  void (*cb)(struct S_FIF, void*, struct S_FIF)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_FID(struct S_FID p0, void* p1, struct S_FID p2,  void (*cb)(struct S_FID, void*, struct S_FID)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_FIP(struct S_FIP p0, void* p1, struct S_FIP p2,  void (*cb)(struct S_FIP, void*, struct S_FIP)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_FFI(struct S_FFI p0, void* p1, struct S_FFI p2,  void (*cb)(struct S_FFI, void*, struct S_FFI)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_FFF(struct S_FFF p0, void* p1, struct S_FFF p2,  void (*cb)(struct S_FFF, void*, struct S_FFF)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_FFD(struct S_FFD p0, void* p1, struct S_FFD p2,  void (*cb)(struct S_FFD, void*, struct S_FFD)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_FFP(struct S_FFP p0, void* p1, struct S_FFP p2,  void (*cb)(struct S_FFP, void*, struct S_FFP)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_FDI(struct S_FDI p0, void* p1, struct S_FDI p2,  void (*cb)(struct S_FDI, void*, struct S_FDI)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_FDF(struct S_FDF p0, void* p1, struct S_FDF p2,  void (*cb)(struct S_FDF, void*, struct S_FDF)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_FDD(struct S_FDD p0, void* p1, struct S_FDD p2,  void (*cb)(struct S_FDD, void*, struct S_FDD)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_FDP(struct S_FDP p0, void* p1, struct S_FDP p2,  void (*cb)(struct S_FDP, void*, struct S_FDP)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_FPI(struct S_FPI p0, void* p1, struct S_FPI p2,  void (*cb)(struct S_FPI, void*, struct S_FPI)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_FPF(struct S_FPF p0, void* p1, struct S_FPF p2,  void (*cb)(struct S_FPF, void*, struct S_FPF)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_FPD(struct S_FPD p0, void* p1, struct S_FPD p2,  void (*cb)(struct S_FPD, void*, struct S_FPD)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_FPP(struct S_FPP p0, void* p1, struct S_FPP p2,  void (*cb)(struct S_FPP, void*, struct S_FPP)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_DII(struct S_DII p0, void* p1, struct S_DII p2,  void (*cb)(struct S_DII, void*, struct S_DII)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_DIF(struct S_DIF p0, void* p1, struct S_DIF p2,  void (*cb)(struct S_DIF, void*, struct S_DIF)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_DID(struct S_DID p0, void* p1, struct S_DID p2,  void (*cb)(struct S_DID, void*, struct S_DID)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_DIP(struct S_DIP p0, void* p1, struct S_DIP p2,  void (*cb)(struct S_DIP, void*, struct S_DIP)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_DFI(struct S_DFI p0, void* p1, struct S_DFI p2,  void (*cb)(struct S_DFI, void*, struct S_DFI)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_DFF(struct S_DFF p0, void* p1, struct S_DFF p2,  void (*cb)(struct S_DFF, void*, struct S_DFF)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_DFD(struct S_DFD p0, void* p1, struct S_DFD p2,  void (*cb)(struct S_DFD, void*, struct S_DFD)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_DFP(struct S_DFP p0, void* p1, struct S_DFP p2,  void (*cb)(struct S_DFP, void*, struct S_DFP)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_DDI(struct S_DDI p0, void* p1, struct S_DDI p2,  void (*cb)(struct S_DDI, void*, struct S_DDI)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_DDF(struct S_DDF p0, void* p1, struct S_DDF p2,  void (*cb)(struct S_DDF, void*, struct S_DDF)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_DDD(struct S_DDD p0, void* p1, struct S_DDD p2,  void (*cb)(struct S_DDD, void*, struct S_DDD)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_DDP(struct S_DDP p0, void* p1, struct S_DDP p2,  void (*cb)(struct S_DDP, void*, struct S_DDP)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_DPI(struct S_DPI p0, void* p1, struct S_DPI p2,  void (*cb)(struct S_DPI, void*, struct S_DPI)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_DPF(struct S_DPF p0, void* p1, struct S_DPF p2,  void (*cb)(struct S_DPF, void*, struct S_DPF)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_DPD(struct S_DPD p0, void* p1, struct S_DPD p2,  void (*cb)(struct S_DPD, void*, struct S_DPD)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_DPP(struct S_DPP p0, void* p1, struct S_DPP p2,  void (*cb)(struct S_DPP, void*, struct S_DPP)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_PII(struct S_PII p0, void* p1, struct S_PII p2,  void (*cb)(struct S_PII, void*, struct S_PII)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_PIF(struct S_PIF p0, void* p1, struct S_PIF p2,  void (*cb)(struct S_PIF, void*, struct S_PIF)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_PID(struct S_PID p0, void* p1, struct S_PID p2,  void (*cb)(struct S_PID, void*, struct S_PID)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_PIP(struct S_PIP p0, void* p1, struct S_PIP p2,  void (*cb)(struct S_PIP, void*, struct S_PIP)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_PFI(struct S_PFI p0, void* p1, struct S_PFI p2,  void (*cb)(struct S_PFI, void*, struct S_PFI)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_PFF(struct S_PFF p0, void* p1, struct S_PFF p2,  void (*cb)(struct S_PFF, void*, struct S_PFF)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_PFD(struct S_PFD p0, void* p1, struct S_PFD p2,  void (*cb)(struct S_PFD, void*, struct S_PFD)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_PFP(struct S_PFP p0, void* p1, struct S_PFP p2,  void (*cb)(struct S_PFP, void*, struct S_PFP)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_PDI(struct S_PDI p0, void* p1, struct S_PDI p2,  void (*cb)(struct S_PDI, void*, struct S_PDI)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_PDF(struct S_PDF p0, void* p1, struct S_PDF p2,  void (*cb)(struct S_PDF, void*, struct S_PDF)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_PDD(struct S_PDD p0, void* p1, struct S_PDD p2,  void (*cb)(struct S_PDD, void*, struct S_PDD)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_PDP(struct S_PDP p0, void* p1, struct S_PDP p2,  void (*cb)(struct S_PDP, void*, struct S_PDP)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_PPI(struct S_PPI p0, void* p1, struct S_PPI p2,  void (*cb)(struct S_PPI, void*, struct S_PPI)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_PPF(struct S_PPF p0, void* p1, struct S_PPF p2,  void (*cb)(struct S_PPF, void*, struct S_PPF)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_PPD(struct S_PPD p0, void* p1, struct S_PPD p2,  void (*cb)(struct S_PPD, void*, struct S_PPD)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SPS_PPP(struct S_PPP p0, void* p1, struct S_PPP p2,  void (*cb)(struct S_PPP, void*, struct S_PPP)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_I(struct S_I p0, struct S_I p1, int p2,  void (*cb)(struct S_I, struct S_I, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_F(struct S_F p0, struct S_F p1, int p2,  void (*cb)(struct S_F, struct S_F, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_D(struct S_D p0, struct S_D p1, int p2,  void (*cb)(struct S_D, struct S_D, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_P(struct S_P p0, struct S_P p1, int p2,  void (*cb)(struct S_P, struct S_P, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_II(struct S_II p0, struct S_II p1, int p2,  void (*cb)(struct S_II, struct S_II, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_IF(struct S_IF p0, struct S_IF p1, int p2,  void (*cb)(struct S_IF, struct S_IF, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_ID(struct S_ID p0, struct S_ID p1, int p2,  void (*cb)(struct S_ID, struct S_ID, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_IP(struct S_IP p0, struct S_IP p1, int p2,  void (*cb)(struct S_IP, struct S_IP, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_FI(struct S_FI p0, struct S_FI p1, int p2,  void (*cb)(struct S_FI, struct S_FI, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_FF(struct S_FF p0, struct S_FF p1, int p2,  void (*cb)(struct S_FF, struct S_FF, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_FD(struct S_FD p0, struct S_FD p1, int p2,  void (*cb)(struct S_FD, struct S_FD, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_FP(struct S_FP p0, struct S_FP p1, int p2,  void (*cb)(struct S_FP, struct S_FP, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_DI(struct S_DI p0, struct S_DI p1, int p2,  void (*cb)(struct S_DI, struct S_DI, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_DF(struct S_DF p0, struct S_DF p1, int p2,  void (*cb)(struct S_DF, struct S_DF, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_DD(struct S_DD p0, struct S_DD p1, int p2,  void (*cb)(struct S_DD, struct S_DD, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_DP(struct S_DP p0, struct S_DP p1, int p2,  void (*cb)(struct S_DP, struct S_DP, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_PI(struct S_PI p0, struct S_PI p1, int p2,  void (*cb)(struct S_PI, struct S_PI, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_PF(struct S_PF p0, struct S_PF p1, int p2,  void (*cb)(struct S_PF, struct S_PF, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_PD(struct S_PD p0, struct S_PD p1, int p2,  void (*cb)(struct S_PD, struct S_PD, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_PP(struct S_PP p0, struct S_PP p1, int p2,  void (*cb)(struct S_PP, struct S_PP, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_III(struct S_III p0, struct S_III p1, int p2,  void (*cb)(struct S_III, struct S_III, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_IIF(struct S_IIF p0, struct S_IIF p1, int p2,  void (*cb)(struct S_IIF, struct S_IIF, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_IID(struct S_IID p0, struct S_IID p1, int p2,  void (*cb)(struct S_IID, struct S_IID, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_IIP(struct S_IIP p0, struct S_IIP p1, int p2,  void (*cb)(struct S_IIP, struct S_IIP, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_IFI(struct S_IFI p0, struct S_IFI p1, int p2,  void (*cb)(struct S_IFI, struct S_IFI, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_IFF(struct S_IFF p0, struct S_IFF p1, int p2,  void (*cb)(struct S_IFF, struct S_IFF, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_IFD(struct S_IFD p0, struct S_IFD p1, int p2,  void (*cb)(struct S_IFD, struct S_IFD, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_IFP(struct S_IFP p0, struct S_IFP p1, int p2,  void (*cb)(struct S_IFP, struct S_IFP, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_IDI(struct S_IDI p0, struct S_IDI p1, int p2,  void (*cb)(struct S_IDI, struct S_IDI, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_IDF(struct S_IDF p0, struct S_IDF p1, int p2,  void (*cb)(struct S_IDF, struct S_IDF, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_IDD(struct S_IDD p0, struct S_IDD p1, int p2,  void (*cb)(struct S_IDD, struct S_IDD, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_IDP(struct S_IDP p0, struct S_IDP p1, int p2,  void (*cb)(struct S_IDP, struct S_IDP, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_IPI(struct S_IPI p0, struct S_IPI p1, int p2,  void (*cb)(struct S_IPI, struct S_IPI, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_IPF(struct S_IPF p0, struct S_IPF p1, int p2,  void (*cb)(struct S_IPF, struct S_IPF, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_IPD(struct S_IPD p0, struct S_IPD p1, int p2,  void (*cb)(struct S_IPD, struct S_IPD, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_IPP(struct S_IPP p0, struct S_IPP p1, int p2,  void (*cb)(struct S_IPP, struct S_IPP, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_FII(struct S_FII p0, struct S_FII p1, int p2,  void (*cb)(struct S_FII, struct S_FII, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_FIF(struct S_FIF p0, struct S_FIF p1, int p2,  void (*cb)(struct S_FIF, struct S_FIF, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_FID(struct S_FID p0, struct S_FID p1, int p2,  void (*cb)(struct S_FID, struct S_FID, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_FIP(struct S_FIP p0, struct S_FIP p1, int p2,  void (*cb)(struct S_FIP, struct S_FIP, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_FFI(struct S_FFI p0, struct S_FFI p1, int p2,  void (*cb)(struct S_FFI, struct S_FFI, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_FFF(struct S_FFF p0, struct S_FFF p1, int p2,  void (*cb)(struct S_FFF, struct S_FFF, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_FFD(struct S_FFD p0, struct S_FFD p1, int p2,  void (*cb)(struct S_FFD, struct S_FFD, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_FFP(struct S_FFP p0, struct S_FFP p1, int p2,  void (*cb)(struct S_FFP, struct S_FFP, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_FDI(struct S_FDI p0, struct S_FDI p1, int p2,  void (*cb)(struct S_FDI, struct S_FDI, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_FDF(struct S_FDF p0, struct S_FDF p1, int p2,  void (*cb)(struct S_FDF, struct S_FDF, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_FDD(struct S_FDD p0, struct S_FDD p1, int p2,  void (*cb)(struct S_FDD, struct S_FDD, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_FDP(struct S_FDP p0, struct S_FDP p1, int p2,  void (*cb)(struct S_FDP, struct S_FDP, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_FPI(struct S_FPI p0, struct S_FPI p1, int p2,  void (*cb)(struct S_FPI, struct S_FPI, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_FPF(struct S_FPF p0, struct S_FPF p1, int p2,  void (*cb)(struct S_FPF, struct S_FPF, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_FPD(struct S_FPD p0, struct S_FPD p1, int p2,  void (*cb)(struct S_FPD, struct S_FPD, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_FPP(struct S_FPP p0, struct S_FPP p1, int p2,  void (*cb)(struct S_FPP, struct S_FPP, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_DII(struct S_DII p0, struct S_DII p1, int p2,  void (*cb)(struct S_DII, struct S_DII, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_DIF(struct S_DIF p0, struct S_DIF p1, int p2,  void (*cb)(struct S_DIF, struct S_DIF, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_DID(struct S_DID p0, struct S_DID p1, int p2,  void (*cb)(struct S_DID, struct S_DID, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_DIP(struct S_DIP p0, struct S_DIP p1, int p2,  void (*cb)(struct S_DIP, struct S_DIP, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_DFI(struct S_DFI p0, struct S_DFI p1, int p2,  void (*cb)(struct S_DFI, struct S_DFI, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_DFF(struct S_DFF p0, struct S_DFF p1, int p2,  void (*cb)(struct S_DFF, struct S_DFF, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_DFD(struct S_DFD p0, struct S_DFD p1, int p2,  void (*cb)(struct S_DFD, struct S_DFD, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_DFP(struct S_DFP p0, struct S_DFP p1, int p2,  void (*cb)(struct S_DFP, struct S_DFP, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_DDI(struct S_DDI p0, struct S_DDI p1, int p2,  void (*cb)(struct S_DDI, struct S_DDI, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_DDF(struct S_DDF p0, struct S_DDF p1, int p2,  void (*cb)(struct S_DDF, struct S_DDF, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_DDD(struct S_DDD p0, struct S_DDD p1, int p2,  void (*cb)(struct S_DDD, struct S_DDD, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_DDP(struct S_DDP p0, struct S_DDP p1, int p2,  void (*cb)(struct S_DDP, struct S_DDP, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_DPI(struct S_DPI p0, struct S_DPI p1, int p2,  void (*cb)(struct S_DPI, struct S_DPI, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_DPF(struct S_DPF p0, struct S_DPF p1, int p2,  void (*cb)(struct S_DPF, struct S_DPF, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_DPD(struct S_DPD p0, struct S_DPD p1, int p2,  void (*cb)(struct S_DPD, struct S_DPD, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_DPP(struct S_DPP p0, struct S_DPP p1, int p2,  void (*cb)(struct S_DPP, struct S_DPP, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_PII(struct S_PII p0, struct S_PII p1, int p2,  void (*cb)(struct S_PII, struct S_PII, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_PIF(struct S_PIF p0, struct S_PIF p1, int p2,  void (*cb)(struct S_PIF, struct S_PIF, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_PID(struct S_PID p0, struct S_PID p1, int p2,  void (*cb)(struct S_PID, struct S_PID, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_PIP(struct S_PIP p0, struct S_PIP p1, int p2,  void (*cb)(struct S_PIP, struct S_PIP, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_PFI(struct S_PFI p0, struct S_PFI p1, int p2,  void (*cb)(struct S_PFI, struct S_PFI, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_PFF(struct S_PFF p0, struct S_PFF p1, int p2,  void (*cb)(struct S_PFF, struct S_PFF, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_PFD(struct S_PFD p0, struct S_PFD p1, int p2,  void (*cb)(struct S_PFD, struct S_PFD, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_PFP(struct S_PFP p0, struct S_PFP p1, int p2,  void (*cb)(struct S_PFP, struct S_PFP, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_PDI(struct S_PDI p0, struct S_PDI p1, int p2,  void (*cb)(struct S_PDI, struct S_PDI, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_PDF(struct S_PDF p0, struct S_PDF p1, int p2,  void (*cb)(struct S_PDF, struct S_PDF, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_PDD(struct S_PDD p0, struct S_PDD p1, int p2,  void (*cb)(struct S_PDD, struct S_PDD, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_PDP(struct S_PDP p0, struct S_PDP p1, int p2,  void (*cb)(struct S_PDP, struct S_PDP, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_PPI(struct S_PPI p0, struct S_PPI p1, int p2,  void (*cb)(struct S_PPI, struct S_PPI, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_PPF(struct S_PPF p0, struct S_PPF p1, int p2,  void (*cb)(struct S_PPF, struct S_PPF, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_PPD(struct S_PPD p0, struct S_PPD p1, int p2,  void (*cb)(struct S_PPD, struct S_PPD, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSI_PPP(struct S_PPP p0, struct S_PPP p1, int p2,  void (*cb)(struct S_PPP, struct S_PPP, int)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_I(struct S_I p0, struct S_I p1, float p2,  void (*cb)(struct S_I, struct S_I, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_F(struct S_F p0, struct S_F p1, float p2,  void (*cb)(struct S_F, struct S_F, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_D(struct S_D p0, struct S_D p1, float p2,  void (*cb)(struct S_D, struct S_D, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_P(struct S_P p0, struct S_P p1, float p2,  void (*cb)(struct S_P, struct S_P, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_II(struct S_II p0, struct S_II p1, float p2,  void (*cb)(struct S_II, struct S_II, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_IF(struct S_IF p0, struct S_IF p1, float p2,  void (*cb)(struct S_IF, struct S_IF, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_ID(struct S_ID p0, struct S_ID p1, float p2,  void (*cb)(struct S_ID, struct S_ID, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_IP(struct S_IP p0, struct S_IP p1, float p2,  void (*cb)(struct S_IP, struct S_IP, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_FI(struct S_FI p0, struct S_FI p1, float p2,  void (*cb)(struct S_FI, struct S_FI, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_FF(struct S_FF p0, struct S_FF p1, float p2,  void (*cb)(struct S_FF, struct S_FF, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_FD(struct S_FD p0, struct S_FD p1, float p2,  void (*cb)(struct S_FD, struct S_FD, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_FP(struct S_FP p0, struct S_FP p1, float p2,  void (*cb)(struct S_FP, struct S_FP, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_DI(struct S_DI p0, struct S_DI p1, float p2,  void (*cb)(struct S_DI, struct S_DI, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_DF(struct S_DF p0, struct S_DF p1, float p2,  void (*cb)(struct S_DF, struct S_DF, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_DD(struct S_DD p0, struct S_DD p1, float p2,  void (*cb)(struct S_DD, struct S_DD, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_DP(struct S_DP p0, struct S_DP p1, float p2,  void (*cb)(struct S_DP, struct S_DP, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_PI(struct S_PI p0, struct S_PI p1, float p2,  void (*cb)(struct S_PI, struct S_PI, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_PF(struct S_PF p0, struct S_PF p1, float p2,  void (*cb)(struct S_PF, struct S_PF, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_PD(struct S_PD p0, struct S_PD p1, float p2,  void (*cb)(struct S_PD, struct S_PD, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_PP(struct S_PP p0, struct S_PP p1, float p2,  void (*cb)(struct S_PP, struct S_PP, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_III(struct S_III p0, struct S_III p1, float p2,  void (*cb)(struct S_III, struct S_III, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_IIF(struct S_IIF p0, struct S_IIF p1, float p2,  void (*cb)(struct S_IIF, struct S_IIF, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_IID(struct S_IID p0, struct S_IID p1, float p2,  void (*cb)(struct S_IID, struct S_IID, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_IIP(struct S_IIP p0, struct S_IIP p1, float p2,  void (*cb)(struct S_IIP, struct S_IIP, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_IFI(struct S_IFI p0, struct S_IFI p1, float p2,  void (*cb)(struct S_IFI, struct S_IFI, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_IFF(struct S_IFF p0, struct S_IFF p1, float p2,  void (*cb)(struct S_IFF, struct S_IFF, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_IFD(struct S_IFD p0, struct S_IFD p1, float p2,  void (*cb)(struct S_IFD, struct S_IFD, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_IFP(struct S_IFP p0, struct S_IFP p1, float p2,  void (*cb)(struct S_IFP, struct S_IFP, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_IDI(struct S_IDI p0, struct S_IDI p1, float p2,  void (*cb)(struct S_IDI, struct S_IDI, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_IDF(struct S_IDF p0, struct S_IDF p1, float p2,  void (*cb)(struct S_IDF, struct S_IDF, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_IDD(struct S_IDD p0, struct S_IDD p1, float p2,  void (*cb)(struct S_IDD, struct S_IDD, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_IDP(struct S_IDP p0, struct S_IDP p1, float p2,  void (*cb)(struct S_IDP, struct S_IDP, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_IPI(struct S_IPI p0, struct S_IPI p1, float p2,  void (*cb)(struct S_IPI, struct S_IPI, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_IPF(struct S_IPF p0, struct S_IPF p1, float p2,  void (*cb)(struct S_IPF, struct S_IPF, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_IPD(struct S_IPD p0, struct S_IPD p1, float p2,  void (*cb)(struct S_IPD, struct S_IPD, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_IPP(struct S_IPP p0, struct S_IPP p1, float p2,  void (*cb)(struct S_IPP, struct S_IPP, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_FII(struct S_FII p0, struct S_FII p1, float p2,  void (*cb)(struct S_FII, struct S_FII, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_FIF(struct S_FIF p0, struct S_FIF p1, float p2,  void (*cb)(struct S_FIF, struct S_FIF, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_FID(struct S_FID p0, struct S_FID p1, float p2,  void (*cb)(struct S_FID, struct S_FID, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_FIP(struct S_FIP p0, struct S_FIP p1, float p2,  void (*cb)(struct S_FIP, struct S_FIP, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_FFI(struct S_FFI p0, struct S_FFI p1, float p2,  void (*cb)(struct S_FFI, struct S_FFI, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_FFF(struct S_FFF p0, struct S_FFF p1, float p2,  void (*cb)(struct S_FFF, struct S_FFF, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_FFD(struct S_FFD p0, struct S_FFD p1, float p2,  void (*cb)(struct S_FFD, struct S_FFD, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_FFP(struct S_FFP p0, struct S_FFP p1, float p2,  void (*cb)(struct S_FFP, struct S_FFP, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_FDI(struct S_FDI p0, struct S_FDI p1, float p2,  void (*cb)(struct S_FDI, struct S_FDI, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_FDF(struct S_FDF p0, struct S_FDF p1, float p2,  void (*cb)(struct S_FDF, struct S_FDF, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_FDD(struct S_FDD p0, struct S_FDD p1, float p2,  void (*cb)(struct S_FDD, struct S_FDD, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_FDP(struct S_FDP p0, struct S_FDP p1, float p2,  void (*cb)(struct S_FDP, struct S_FDP, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_FPI(struct S_FPI p0, struct S_FPI p1, float p2,  void (*cb)(struct S_FPI, struct S_FPI, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_FPF(struct S_FPF p0, struct S_FPF p1, float p2,  void (*cb)(struct S_FPF, struct S_FPF, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_FPD(struct S_FPD p0, struct S_FPD p1, float p2,  void (*cb)(struct S_FPD, struct S_FPD, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_FPP(struct S_FPP p0, struct S_FPP p1, float p2,  void (*cb)(struct S_FPP, struct S_FPP, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_DII(struct S_DII p0, struct S_DII p1, float p2,  void (*cb)(struct S_DII, struct S_DII, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_DIF(struct S_DIF p0, struct S_DIF p1, float p2,  void (*cb)(struct S_DIF, struct S_DIF, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_DID(struct S_DID p0, struct S_DID p1, float p2,  void (*cb)(struct S_DID, struct S_DID, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_DIP(struct S_DIP p0, struct S_DIP p1, float p2,  void (*cb)(struct S_DIP, struct S_DIP, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_DFI(struct S_DFI p0, struct S_DFI p1, float p2,  void (*cb)(struct S_DFI, struct S_DFI, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_DFF(struct S_DFF p0, struct S_DFF p1, float p2,  void (*cb)(struct S_DFF, struct S_DFF, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_DFD(struct S_DFD p0, struct S_DFD p1, float p2,  void (*cb)(struct S_DFD, struct S_DFD, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_DFP(struct S_DFP p0, struct S_DFP p1, float p2,  void (*cb)(struct S_DFP, struct S_DFP, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_DDI(struct S_DDI p0, struct S_DDI p1, float p2,  void (*cb)(struct S_DDI, struct S_DDI, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_DDF(struct S_DDF p0, struct S_DDF p1, float p2,  void (*cb)(struct S_DDF, struct S_DDF, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_DDD(struct S_DDD p0, struct S_DDD p1, float p2,  void (*cb)(struct S_DDD, struct S_DDD, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_DDP(struct S_DDP p0, struct S_DDP p1, float p2,  void (*cb)(struct S_DDP, struct S_DDP, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_DPI(struct S_DPI p0, struct S_DPI p1, float p2,  void (*cb)(struct S_DPI, struct S_DPI, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_DPF(struct S_DPF p0, struct S_DPF p1, float p2,  void (*cb)(struct S_DPF, struct S_DPF, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_DPD(struct S_DPD p0, struct S_DPD p1, float p2,  void (*cb)(struct S_DPD, struct S_DPD, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_DPP(struct S_DPP p0, struct S_DPP p1, float p2,  void (*cb)(struct S_DPP, struct S_DPP, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_PII(struct S_PII p0, struct S_PII p1, float p2,  void (*cb)(struct S_PII, struct S_PII, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_PIF(struct S_PIF p0, struct S_PIF p1, float p2,  void (*cb)(struct S_PIF, struct S_PIF, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_PID(struct S_PID p0, struct S_PID p1, float p2,  void (*cb)(struct S_PID, struct S_PID, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_PIP(struct S_PIP p0, struct S_PIP p1, float p2,  void (*cb)(struct S_PIP, struct S_PIP, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_PFI(struct S_PFI p0, struct S_PFI p1, float p2,  void (*cb)(struct S_PFI, struct S_PFI, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_PFF(struct S_PFF p0, struct S_PFF p1, float p2,  void (*cb)(struct S_PFF, struct S_PFF, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_PFD(struct S_PFD p0, struct S_PFD p1, float p2,  void (*cb)(struct S_PFD, struct S_PFD, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_PFP(struct S_PFP p0, struct S_PFP p1, float p2,  void (*cb)(struct S_PFP, struct S_PFP, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_PDI(struct S_PDI p0, struct S_PDI p1, float p2,  void (*cb)(struct S_PDI, struct S_PDI, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_PDF(struct S_PDF p0, struct S_PDF p1, float p2,  void (*cb)(struct S_PDF, struct S_PDF, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_PDD(struct S_PDD p0, struct S_PDD p1, float p2,  void (*cb)(struct S_PDD, struct S_PDD, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_PDP(struct S_PDP p0, struct S_PDP p1, float p2,  void (*cb)(struct S_PDP, struct S_PDP, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_PPI(struct S_PPI p0, struct S_PPI p1, float p2,  void (*cb)(struct S_PPI, struct S_PPI, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_PPF(struct S_PPF p0, struct S_PPF p1, float p2,  void (*cb)(struct S_PPF, struct S_PPF, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_PPD(struct S_PPD p0, struct S_PPD p1, float p2,  void (*cb)(struct S_PPD, struct S_PPD, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSF_PPP(struct S_PPP p0, struct S_PPP p1, float p2,  void (*cb)(struct S_PPP, struct S_PPP, float)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_I(struct S_I p0, struct S_I p1, double p2,  void (*cb)(struct S_I, struct S_I, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_F(struct S_F p0, struct S_F p1, double p2,  void (*cb)(struct S_F, struct S_F, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_D(struct S_D p0, struct S_D p1, double p2,  void (*cb)(struct S_D, struct S_D, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_P(struct S_P p0, struct S_P p1, double p2,  void (*cb)(struct S_P, struct S_P, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_II(struct S_II p0, struct S_II p1, double p2,  void (*cb)(struct S_II, struct S_II, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_IF(struct S_IF p0, struct S_IF p1, double p2,  void (*cb)(struct S_IF, struct S_IF, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_ID(struct S_ID p0, struct S_ID p1, double p2,  void (*cb)(struct S_ID, struct S_ID, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_IP(struct S_IP p0, struct S_IP p1, double p2,  void (*cb)(struct S_IP, struct S_IP, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_FI(struct S_FI p0, struct S_FI p1, double p2,  void (*cb)(struct S_FI, struct S_FI, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_FF(struct S_FF p0, struct S_FF p1, double p2,  void (*cb)(struct S_FF, struct S_FF, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_FD(struct S_FD p0, struct S_FD p1, double p2,  void (*cb)(struct S_FD, struct S_FD, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_FP(struct S_FP p0, struct S_FP p1, double p2,  void (*cb)(struct S_FP, struct S_FP, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_DI(struct S_DI p0, struct S_DI p1, double p2,  void (*cb)(struct S_DI, struct S_DI, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_DF(struct S_DF p0, struct S_DF p1, double p2,  void (*cb)(struct S_DF, struct S_DF, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_DD(struct S_DD p0, struct S_DD p1, double p2,  void (*cb)(struct S_DD, struct S_DD, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_DP(struct S_DP p0, struct S_DP p1, double p2,  void (*cb)(struct S_DP, struct S_DP, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_PI(struct S_PI p0, struct S_PI p1, double p2,  void (*cb)(struct S_PI, struct S_PI, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_PF(struct S_PF p0, struct S_PF p1, double p2,  void (*cb)(struct S_PF, struct S_PF, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_PD(struct S_PD p0, struct S_PD p1, double p2,  void (*cb)(struct S_PD, struct S_PD, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_PP(struct S_PP p0, struct S_PP p1, double p2,  void (*cb)(struct S_PP, struct S_PP, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_III(struct S_III p0, struct S_III p1, double p2,  void (*cb)(struct S_III, struct S_III, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_IIF(struct S_IIF p0, struct S_IIF p1, double p2,  void (*cb)(struct S_IIF, struct S_IIF, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_IID(struct S_IID p0, struct S_IID p1, double p2,  void (*cb)(struct S_IID, struct S_IID, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_IIP(struct S_IIP p0, struct S_IIP p1, double p2,  void (*cb)(struct S_IIP, struct S_IIP, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_IFI(struct S_IFI p0, struct S_IFI p1, double p2,  void (*cb)(struct S_IFI, struct S_IFI, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_IFF(struct S_IFF p0, struct S_IFF p1, double p2,  void (*cb)(struct S_IFF, struct S_IFF, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_IFD(struct S_IFD p0, struct S_IFD p1, double p2,  void (*cb)(struct S_IFD, struct S_IFD, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_IFP(struct S_IFP p0, struct S_IFP p1, double p2,  void (*cb)(struct S_IFP, struct S_IFP, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_IDI(struct S_IDI p0, struct S_IDI p1, double p2,  void (*cb)(struct S_IDI, struct S_IDI, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_IDF(struct S_IDF p0, struct S_IDF p1, double p2,  void (*cb)(struct S_IDF, struct S_IDF, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_IDD(struct S_IDD p0, struct S_IDD p1, double p2,  void (*cb)(struct S_IDD, struct S_IDD, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_IDP(struct S_IDP p0, struct S_IDP p1, double p2,  void (*cb)(struct S_IDP, struct S_IDP, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_IPI(struct S_IPI p0, struct S_IPI p1, double p2,  void (*cb)(struct S_IPI, struct S_IPI, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_IPF(struct S_IPF p0, struct S_IPF p1, double p2,  void (*cb)(struct S_IPF, struct S_IPF, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_IPD(struct S_IPD p0, struct S_IPD p1, double p2,  void (*cb)(struct S_IPD, struct S_IPD, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_IPP(struct S_IPP p0, struct S_IPP p1, double p2,  void (*cb)(struct S_IPP, struct S_IPP, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_FII(struct S_FII p0, struct S_FII p1, double p2,  void (*cb)(struct S_FII, struct S_FII, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_FIF(struct S_FIF p0, struct S_FIF p1, double p2,  void (*cb)(struct S_FIF, struct S_FIF, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_FID(struct S_FID p0, struct S_FID p1, double p2,  void (*cb)(struct S_FID, struct S_FID, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_FIP(struct S_FIP p0, struct S_FIP p1, double p2,  void (*cb)(struct S_FIP, struct S_FIP, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_FFI(struct S_FFI p0, struct S_FFI p1, double p2,  void (*cb)(struct S_FFI, struct S_FFI, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_FFF(struct S_FFF p0, struct S_FFF p1, double p2,  void (*cb)(struct S_FFF, struct S_FFF, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_FFD(struct S_FFD p0, struct S_FFD p1, double p2,  void (*cb)(struct S_FFD, struct S_FFD, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_FFP(struct S_FFP p0, struct S_FFP p1, double p2,  void (*cb)(struct S_FFP, struct S_FFP, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_FDI(struct S_FDI p0, struct S_FDI p1, double p2,  void (*cb)(struct S_FDI, struct S_FDI, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_FDF(struct S_FDF p0, struct S_FDF p1, double p2,  void (*cb)(struct S_FDF, struct S_FDF, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_FDD(struct S_FDD p0, struct S_FDD p1, double p2,  void (*cb)(struct S_FDD, struct S_FDD, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_FDP(struct S_FDP p0, struct S_FDP p1, double p2,  void (*cb)(struct S_FDP, struct S_FDP, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_FPI(struct S_FPI p0, struct S_FPI p1, double p2,  void (*cb)(struct S_FPI, struct S_FPI, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_FPF(struct S_FPF p0, struct S_FPF p1, double p2,  void (*cb)(struct S_FPF, struct S_FPF, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_FPD(struct S_FPD p0, struct S_FPD p1, double p2,  void (*cb)(struct S_FPD, struct S_FPD, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_FPP(struct S_FPP p0, struct S_FPP p1, double p2,  void (*cb)(struct S_FPP, struct S_FPP, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_DII(struct S_DII p0, struct S_DII p1, double p2,  void (*cb)(struct S_DII, struct S_DII, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_DIF(struct S_DIF p0, struct S_DIF p1, double p2,  void (*cb)(struct S_DIF, struct S_DIF, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_DID(struct S_DID p0, struct S_DID p1, double p2,  void (*cb)(struct S_DID, struct S_DID, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_DIP(struct S_DIP p0, struct S_DIP p1, double p2,  void (*cb)(struct S_DIP, struct S_DIP, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_DFI(struct S_DFI p0, struct S_DFI p1, double p2,  void (*cb)(struct S_DFI, struct S_DFI, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_DFF(struct S_DFF p0, struct S_DFF p1, double p2,  void (*cb)(struct S_DFF, struct S_DFF, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_DFD(struct S_DFD p0, struct S_DFD p1, double p2,  void (*cb)(struct S_DFD, struct S_DFD, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_DFP(struct S_DFP p0, struct S_DFP p1, double p2,  void (*cb)(struct S_DFP, struct S_DFP, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_DDI(struct S_DDI p0, struct S_DDI p1, double p2,  void (*cb)(struct S_DDI, struct S_DDI, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_DDF(struct S_DDF p0, struct S_DDF p1, double p2,  void (*cb)(struct S_DDF, struct S_DDF, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_DDD(struct S_DDD p0, struct S_DDD p1, double p2,  void (*cb)(struct S_DDD, struct S_DDD, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_DDP(struct S_DDP p0, struct S_DDP p1, double p2,  void (*cb)(struct S_DDP, struct S_DDP, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_DPI(struct S_DPI p0, struct S_DPI p1, double p2,  void (*cb)(struct S_DPI, struct S_DPI, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_DPF(struct S_DPF p0, struct S_DPF p1, double p2,  void (*cb)(struct S_DPF, struct S_DPF, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_DPD(struct S_DPD p0, struct S_DPD p1, double p2,  void (*cb)(struct S_DPD, struct S_DPD, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_DPP(struct S_DPP p0, struct S_DPP p1, double p2,  void (*cb)(struct S_DPP, struct S_DPP, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_PII(struct S_PII p0, struct S_PII p1, double p2,  void (*cb)(struct S_PII, struct S_PII, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_PIF(struct S_PIF p0, struct S_PIF p1, double p2,  void (*cb)(struct S_PIF, struct S_PIF, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_PID(struct S_PID p0, struct S_PID p1, double p2,  void (*cb)(struct S_PID, struct S_PID, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_PIP(struct S_PIP p0, struct S_PIP p1, double p2,  void (*cb)(struct S_PIP, struct S_PIP, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_PFI(struct S_PFI p0, struct S_PFI p1, double p2,  void (*cb)(struct S_PFI, struct S_PFI, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_PFF(struct S_PFF p0, struct S_PFF p1, double p2,  void (*cb)(struct S_PFF, struct S_PFF, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_PFD(struct S_PFD p0, struct S_PFD p1, double p2,  void (*cb)(struct S_PFD, struct S_PFD, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_PFP(struct S_PFP p0, struct S_PFP p1, double p2,  void (*cb)(struct S_PFP, struct S_PFP, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_PDI(struct S_PDI p0, struct S_PDI p1, double p2,  void (*cb)(struct S_PDI, struct S_PDI, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_PDF(struct S_PDF p0, struct S_PDF p1, double p2,  void (*cb)(struct S_PDF, struct S_PDF, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_PDD(struct S_PDD p0, struct S_PDD p1, double p2,  void (*cb)(struct S_PDD, struct S_PDD, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_PDP(struct S_PDP p0, struct S_PDP p1, double p2,  void (*cb)(struct S_PDP, struct S_PDP, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_PPI(struct S_PPI p0, struct S_PPI p1, double p2,  void (*cb)(struct S_PPI, struct S_PPI, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_PPF(struct S_PPF p0, struct S_PPF p1, double p2,  void (*cb)(struct S_PPF, struct S_PPF, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_PPD(struct S_PPD p0, struct S_PPD p1, double p2,  void (*cb)(struct S_PPD, struct S_PPD, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSD_PPP(struct S_PPP p0, struct S_PPP p1, double p2,  void (*cb)(struct S_PPP, struct S_PPP, double)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_I(struct S_I p0, struct S_I p1, void* p2,  void (*cb)(struct S_I, struct S_I, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_F(struct S_F p0, struct S_F p1, void* p2,  void (*cb)(struct S_F, struct S_F, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_D(struct S_D p0, struct S_D p1, void* p2,  void (*cb)(struct S_D, struct S_D, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_P(struct S_P p0, struct S_P p1, void* p2,  void (*cb)(struct S_P, struct S_P, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_II(struct S_II p0, struct S_II p1, void* p2,  void (*cb)(struct S_II, struct S_II, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_IF(struct S_IF p0, struct S_IF p1, void* p2,  void (*cb)(struct S_IF, struct S_IF, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_ID(struct S_ID p0, struct S_ID p1, void* p2,  void (*cb)(struct S_ID, struct S_ID, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_IP(struct S_IP p0, struct S_IP p1, void* p2,  void (*cb)(struct S_IP, struct S_IP, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_FI(struct S_FI p0, struct S_FI p1, void* p2,  void (*cb)(struct S_FI, struct S_FI, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_FF(struct S_FF p0, struct S_FF p1, void* p2,  void (*cb)(struct S_FF, struct S_FF, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_FD(struct S_FD p0, struct S_FD p1, void* p2,  void (*cb)(struct S_FD, struct S_FD, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_FP(struct S_FP p0, struct S_FP p1, void* p2,  void (*cb)(struct S_FP, struct S_FP, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_DI(struct S_DI p0, struct S_DI p1, void* p2,  void (*cb)(struct S_DI, struct S_DI, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_DF(struct S_DF p0, struct S_DF p1, void* p2,  void (*cb)(struct S_DF, struct S_DF, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_DD(struct S_DD p0, struct S_DD p1, void* p2,  void (*cb)(struct S_DD, struct S_DD, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_DP(struct S_DP p0, struct S_DP p1, void* p2,  void (*cb)(struct S_DP, struct S_DP, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_PI(struct S_PI p0, struct S_PI p1, void* p2,  void (*cb)(struct S_PI, struct S_PI, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_PF(struct S_PF p0, struct S_PF p1, void* p2,  void (*cb)(struct S_PF, struct S_PF, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_PD(struct S_PD p0, struct S_PD p1, void* p2,  void (*cb)(struct S_PD, struct S_PD, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_PP(struct S_PP p0, struct S_PP p1, void* p2,  void (*cb)(struct S_PP, struct S_PP, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_III(struct S_III p0, struct S_III p1, void* p2,  void (*cb)(struct S_III, struct S_III, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_IIF(struct S_IIF p0, struct S_IIF p1, void* p2,  void (*cb)(struct S_IIF, struct S_IIF, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_IID(struct S_IID p0, struct S_IID p1, void* p2,  void (*cb)(struct S_IID, struct S_IID, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_IIP(struct S_IIP p0, struct S_IIP p1, void* p2,  void (*cb)(struct S_IIP, struct S_IIP, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_IFI(struct S_IFI p0, struct S_IFI p1, void* p2,  void (*cb)(struct S_IFI, struct S_IFI, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_IFF(struct S_IFF p0, struct S_IFF p1, void* p2,  void (*cb)(struct S_IFF, struct S_IFF, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_IFD(struct S_IFD p0, struct S_IFD p1, void* p2,  void (*cb)(struct S_IFD, struct S_IFD, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_IFP(struct S_IFP p0, struct S_IFP p1, void* p2,  void (*cb)(struct S_IFP, struct S_IFP, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_IDI(struct S_IDI p0, struct S_IDI p1, void* p2,  void (*cb)(struct S_IDI, struct S_IDI, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_IDF(struct S_IDF p0, struct S_IDF p1, void* p2,  void (*cb)(struct S_IDF, struct S_IDF, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_IDD(struct S_IDD p0, struct S_IDD p1, void* p2,  void (*cb)(struct S_IDD, struct S_IDD, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_IDP(struct S_IDP p0, struct S_IDP p1, void* p2,  void (*cb)(struct S_IDP, struct S_IDP, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_IPI(struct S_IPI p0, struct S_IPI p1, void* p2,  void (*cb)(struct S_IPI, struct S_IPI, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_IPF(struct S_IPF p0, struct S_IPF p1, void* p2,  void (*cb)(struct S_IPF, struct S_IPF, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_IPD(struct S_IPD p0, struct S_IPD p1, void* p2,  void (*cb)(struct S_IPD, struct S_IPD, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_IPP(struct S_IPP p0, struct S_IPP p1, void* p2,  void (*cb)(struct S_IPP, struct S_IPP, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_FII(struct S_FII p0, struct S_FII p1, void* p2,  void (*cb)(struct S_FII, struct S_FII, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_FIF(struct S_FIF p0, struct S_FIF p1, void* p2,  void (*cb)(struct S_FIF, struct S_FIF, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_FID(struct S_FID p0, struct S_FID p1, void* p2,  void (*cb)(struct S_FID, struct S_FID, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_FIP(struct S_FIP p0, struct S_FIP p1, void* p2,  void (*cb)(struct S_FIP, struct S_FIP, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_FFI(struct S_FFI p0, struct S_FFI p1, void* p2,  void (*cb)(struct S_FFI, struct S_FFI, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_FFF(struct S_FFF p0, struct S_FFF p1, void* p2,  void (*cb)(struct S_FFF, struct S_FFF, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_FFD(struct S_FFD p0, struct S_FFD p1, void* p2,  void (*cb)(struct S_FFD, struct S_FFD, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_FFP(struct S_FFP p0, struct S_FFP p1, void* p2,  void (*cb)(struct S_FFP, struct S_FFP, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_FDI(struct S_FDI p0, struct S_FDI p1, void* p2,  void (*cb)(struct S_FDI, struct S_FDI, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_FDF(struct S_FDF p0, struct S_FDF p1, void* p2,  void (*cb)(struct S_FDF, struct S_FDF, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_FDD(struct S_FDD p0, struct S_FDD p1, void* p2,  void (*cb)(struct S_FDD, struct S_FDD, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_FDP(struct S_FDP p0, struct S_FDP p1, void* p2,  void (*cb)(struct S_FDP, struct S_FDP, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_FPI(struct S_FPI p0, struct S_FPI p1, void* p2,  void (*cb)(struct S_FPI, struct S_FPI, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_FPF(struct S_FPF p0, struct S_FPF p1, void* p2,  void (*cb)(struct S_FPF, struct S_FPF, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_FPD(struct S_FPD p0, struct S_FPD p1, void* p2,  void (*cb)(struct S_FPD, struct S_FPD, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_FPP(struct S_FPP p0, struct S_FPP p1, void* p2,  void (*cb)(struct S_FPP, struct S_FPP, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_DII(struct S_DII p0, struct S_DII p1, void* p2,  void (*cb)(struct S_DII, struct S_DII, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_DIF(struct S_DIF p0, struct S_DIF p1, void* p2,  void (*cb)(struct S_DIF, struct S_DIF, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_DID(struct S_DID p0, struct S_DID p1, void* p2,  void (*cb)(struct S_DID, struct S_DID, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_DIP(struct S_DIP p0, struct S_DIP p1, void* p2,  void (*cb)(struct S_DIP, struct S_DIP, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_DFI(struct S_DFI p0, struct S_DFI p1, void* p2,  void (*cb)(struct S_DFI, struct S_DFI, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_DFF(struct S_DFF p0, struct S_DFF p1, void* p2,  void (*cb)(struct S_DFF, struct S_DFF, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_DFD(struct S_DFD p0, struct S_DFD p1, void* p2,  void (*cb)(struct S_DFD, struct S_DFD, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_DFP(struct S_DFP p0, struct S_DFP p1, void* p2,  void (*cb)(struct S_DFP, struct S_DFP, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_DDI(struct S_DDI p0, struct S_DDI p1, void* p2,  void (*cb)(struct S_DDI, struct S_DDI, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_DDF(struct S_DDF p0, struct S_DDF p1, void* p2,  void (*cb)(struct S_DDF, struct S_DDF, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_DDD(struct S_DDD p0, struct S_DDD p1, void* p2,  void (*cb)(struct S_DDD, struct S_DDD, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_DDP(struct S_DDP p0, struct S_DDP p1, void* p2,  void (*cb)(struct S_DDP, struct S_DDP, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_DPI(struct S_DPI p0, struct S_DPI p1, void* p2,  void (*cb)(struct S_DPI, struct S_DPI, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_DPF(struct S_DPF p0, struct S_DPF p1, void* p2,  void (*cb)(struct S_DPF, struct S_DPF, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_DPD(struct S_DPD p0, struct S_DPD p1, void* p2,  void (*cb)(struct S_DPD, struct S_DPD, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_DPP(struct S_DPP p0, struct S_DPP p1, void* p2,  void (*cb)(struct S_DPP, struct S_DPP, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_PII(struct S_PII p0, struct S_PII p1, void* p2,  void (*cb)(struct S_PII, struct S_PII, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_PIF(struct S_PIF p0, struct S_PIF p1, void* p2,  void (*cb)(struct S_PIF, struct S_PIF, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_PID(struct S_PID p0, struct S_PID p1, void* p2,  void (*cb)(struct S_PID, struct S_PID, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_PIP(struct S_PIP p0, struct S_PIP p1, void* p2,  void (*cb)(struct S_PIP, struct S_PIP, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_PFI(struct S_PFI p0, struct S_PFI p1, void* p2,  void (*cb)(struct S_PFI, struct S_PFI, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_PFF(struct S_PFF p0, struct S_PFF p1, void* p2,  void (*cb)(struct S_PFF, struct S_PFF, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_PFD(struct S_PFD p0, struct S_PFD p1, void* p2,  void (*cb)(struct S_PFD, struct S_PFD, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_PFP(struct S_PFP p0, struct S_PFP p1, void* p2,  void (*cb)(struct S_PFP, struct S_PFP, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_PDI(struct S_PDI p0, struct S_PDI p1, void* p2,  void (*cb)(struct S_PDI, struct S_PDI, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_PDF(struct S_PDF p0, struct S_PDF p1, void* p2,  void (*cb)(struct S_PDF, struct S_PDF, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_PDD(struct S_PDD p0, struct S_PDD p1, void* p2,  void (*cb)(struct S_PDD, struct S_PDD, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_PDP(struct S_PDP p0, struct S_PDP p1, void* p2,  void (*cb)(struct S_PDP, struct S_PDP, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_PPI(struct S_PPI p0, struct S_PPI p1, void* p2,  void (*cb)(struct S_PPI, struct S_PPI, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_PPF(struct S_PPF p0, struct S_PPF p1, void* p2,  void (*cb)(struct S_PPF, struct S_PPF, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_PPD(struct S_PPD p0, struct S_PPD p1, void* p2,  void (*cb)(struct S_PPD, struct S_PPD, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSP_PPP(struct S_PPP p0, struct S_PPP p1, void* p2,  void (*cb)(struct S_PPP, struct S_PPP, void*)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSS_I(struct S_I p0, struct S_I p1, struct S_I p2,  void (*cb)(struct S_I, struct S_I, struct S_I)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSS_F(struct S_F p0, struct S_F p1, struct S_F p2,  void (*cb)(struct S_F, struct S_F, struct S_F)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSS_D(struct S_D p0, struct S_D p1, struct S_D p2,  void (*cb)(struct S_D, struct S_D, struct S_D)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSS_P(struct S_P p0, struct S_P p1, struct S_P p2,  void (*cb)(struct S_P, struct S_P, struct S_P)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSS_II(struct S_II p0, struct S_II p1, struct S_II p2,  void (*cb)(struct S_II, struct S_II, struct S_II)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSS_IF(struct S_IF p0, struct S_IF p1, struct S_IF p2,  void (*cb)(struct S_IF, struct S_IF, struct S_IF)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSS_ID(struct S_ID p0, struct S_ID p1, struct S_ID p2,  void (*cb)(struct S_ID, struct S_ID, struct S_ID)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSS_IP(struct S_IP p0, struct S_IP p1, struct S_IP p2,  void (*cb)(struct S_IP, struct S_IP, struct S_IP)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSS_FI(struct S_FI p0, struct S_FI p1, struct S_FI p2,  void (*cb)(struct S_FI, struct S_FI, struct S_FI)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSS_FF(struct S_FF p0, struct S_FF p1, struct S_FF p2,  void (*cb)(struct S_FF, struct S_FF, struct S_FF)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSS_FD(struct S_FD p0, struct S_FD p1, struct S_FD p2,  void (*cb)(struct S_FD, struct S_FD, struct S_FD)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSS_FP(struct S_FP p0, struct S_FP p1, struct S_FP p2,  void (*cb)(struct S_FP, struct S_FP, struct S_FP)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSS_DI(struct S_DI p0, struct S_DI p1, struct S_DI p2,  void (*cb)(struct S_DI, struct S_DI, struct S_DI)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSS_DF(struct S_DF p0, struct S_DF p1, struct S_DF p2,  void (*cb)(struct S_DF, struct S_DF, struct S_DF)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSS_DD(struct S_DD p0, struct S_DD p1, struct S_DD p2,  void (*cb)(struct S_DD, struct S_DD, struct S_DD)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSS_DP(struct S_DP p0, struct S_DP p1, struct S_DP p2,  void (*cb)(struct S_DP, struct S_DP, struct S_DP)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSS_PI(struct S_PI p0, struct S_PI p1, struct S_PI p2,  void (*cb)(struct S_PI, struct S_PI, struct S_PI)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSS_PF(struct S_PF p0, struct S_PF p1, struct S_PF p2,  void (*cb)(struct S_PF, struct S_PF, struct S_PF)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSS_PD(struct S_PD p0, struct S_PD p1, struct S_PD p2,  void (*cb)(struct S_PD, struct S_PD, struct S_PD)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSS_PP(struct S_PP p0, struct S_PP p1, struct S_PP p2,  void (*cb)(struct S_PP, struct S_PP, struct S_PP)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSS_III(struct S_III p0, struct S_III p1, struct S_III p2,  void (*cb)(struct S_III, struct S_III, struct S_III)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSS_IIF(struct S_IIF p0, struct S_IIF p1, struct S_IIF p2,  void (*cb)(struct S_IIF, struct S_IIF, struct S_IIF)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSS_IID(struct S_IID p0, struct S_IID p1, struct S_IID p2,  void (*cb)(struct S_IID, struct S_IID, struct S_IID)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSS_IIP(struct S_IIP p0, struct S_IIP p1, struct S_IIP p2,  void (*cb)(struct S_IIP, struct S_IIP, struct S_IIP)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSS_IFI(struct S_IFI p0, struct S_IFI p1, struct S_IFI p2,  void (*cb)(struct S_IFI, struct S_IFI, struct S_IFI)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSS_IFF(struct S_IFF p0, struct S_IFF p1, struct S_IFF p2,  void (*cb)(struct S_IFF, struct S_IFF, struct S_IFF)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSS_IFD(struct S_IFD p0, struct S_IFD p1, struct S_IFD p2,  void (*cb)(struct S_IFD, struct S_IFD, struct S_IFD)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSS_IFP(struct S_IFP p0, struct S_IFP p1, struct S_IFP p2,  void (*cb)(struct S_IFP, struct S_IFP, struct S_IFP)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSS_IDI(struct S_IDI p0, struct S_IDI p1, struct S_IDI p2,  void (*cb)(struct S_IDI, struct S_IDI, struct S_IDI)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSS_IDF(struct S_IDF p0, struct S_IDF p1, struct S_IDF p2,  void (*cb)(struct S_IDF, struct S_IDF, struct S_IDF)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSS_IDD(struct S_IDD p0, struct S_IDD p1, struct S_IDD p2,  void (*cb)(struct S_IDD, struct S_IDD, struct S_IDD)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSS_IDP(struct S_IDP p0, struct S_IDP p1, struct S_IDP p2,  void (*cb)(struct S_IDP, struct S_IDP, struct S_IDP)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSS_IPI(struct S_IPI p0, struct S_IPI p1, struct S_IPI p2,  void (*cb)(struct S_IPI, struct S_IPI, struct S_IPI)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSS_IPF(struct S_IPF p0, struct S_IPF p1, struct S_IPF p2,  void (*cb)(struct S_IPF, struct S_IPF, struct S_IPF)) { cb(p0,p1,p2); }
+EXPORT void f9_V_SSS_IPD(struct S_IPD p0, struct S_IPD p1, struct S_IPD p2,  void (*cb)(struct S_IPD, struct S_IPD, struct S_IPD)) { cb(p0,p1,p2); }
+EXPORT void f10_V_SSS_IPP(struct S_IPP p0, struct S_IPP p1, struct S_IPP p2,  void (*cb)(struct S_IPP, struct S_IPP, struct S_IPP)) { cb(p0,p1,p2); }
+EXPORT void f10_V_SSS_FII(struct S_FII p0, struct S_FII p1, struct S_FII p2,  void (*cb)(struct S_FII, struct S_FII, struct S_FII)) { cb(p0,p1,p2); }
+EXPORT void f10_V_SSS_FIF(struct S_FIF p0, struct S_FIF p1, struct S_FIF p2,  void (*cb)(struct S_FIF, struct S_FIF, struct S_FIF)) { cb(p0,p1,p2); }
+EXPORT void f10_V_SSS_FID(struct S_FID p0, struct S_FID p1, struct S_FID p2,  void (*cb)(struct S_FID, struct S_FID, struct S_FID)) { cb(p0,p1,p2); }
+EXPORT void f10_V_SSS_FIP(struct S_FIP p0, struct S_FIP p1, struct S_FIP p2,  void (*cb)(struct S_FIP, struct S_FIP, struct S_FIP)) { cb(p0,p1,p2); }
+EXPORT void f10_V_SSS_FFI(struct S_FFI p0, struct S_FFI p1, struct S_FFI p2,  void (*cb)(struct S_FFI, struct S_FFI, struct S_FFI)) { cb(p0,p1,p2); }
+EXPORT void f10_V_SSS_FFF(struct S_FFF p0, struct S_FFF p1, struct S_FFF p2,  void (*cb)(struct S_FFF, struct S_FFF, struct S_FFF)) { cb(p0,p1,p2); }
+EXPORT void f10_V_SSS_FFD(struct S_FFD p0, struct S_FFD p1, struct S_FFD p2,  void (*cb)(struct S_FFD, struct S_FFD, struct S_FFD)) { cb(p0,p1,p2); }
+EXPORT void f10_V_SSS_FFP(struct S_FFP p0, struct S_FFP p1, struct S_FFP p2,  void (*cb)(struct S_FFP, struct S_FFP, struct S_FFP)) { cb(p0,p1,p2); }
+EXPORT void f10_V_SSS_FDI(struct S_FDI p0, struct S_FDI p1, struct S_FDI p2,  void (*cb)(struct S_FDI, struct S_FDI, struct S_FDI)) { cb(p0,p1,p2); }
+EXPORT void f10_V_SSS_FDF(struct S_FDF p0, struct S_FDF p1, struct S_FDF p2,  void (*cb)(struct S_FDF, struct S_FDF, struct S_FDF)) { cb(p0,p1,p2); }
+EXPORT void f10_V_SSS_FDD(struct S_FDD p0, struct S_FDD p1, struct S_FDD p2,  void (*cb)(struct S_FDD, struct S_FDD, struct S_FDD)) { cb(p0,p1,p2); }
+EXPORT void f10_V_SSS_FDP(struct S_FDP p0, struct S_FDP p1, struct S_FDP p2,  void (*cb)(struct S_FDP, struct S_FDP, struct S_FDP)) { cb(p0,p1,p2); }
+EXPORT void f10_V_SSS_FPI(struct S_FPI p0, struct S_FPI p1, struct S_FPI p2,  void (*cb)(struct S_FPI, struct S_FPI, struct S_FPI)) { cb(p0,p1,p2); }
+EXPORT void f10_V_SSS_FPF(struct S_FPF p0, struct S_FPF p1, struct S_FPF p2,  void (*cb)(struct S_FPF, struct S_FPF, struct S_FPF)) { cb(p0,p1,p2); }
+EXPORT void f10_V_SSS_FPD(struct S_FPD p0, struct S_FPD p1, struct S_FPD p2,  void (*cb)(struct S_FPD, struct S_FPD, struct S_FPD)) { cb(p0,p1,p2); }
+EXPORT void f10_V_SSS_FPP(struct S_FPP p0, struct S_FPP p1, struct S_FPP p2,  void (*cb)(struct S_FPP, struct S_FPP, struct S_FPP)) { cb(p0,p1,p2); }
+EXPORT void f10_V_SSS_DII(struct S_DII p0, struct S_DII p1, struct S_DII p2,  void (*cb)(struct S_DII, struct S_DII, struct S_DII)) { cb(p0,p1,p2); }
+EXPORT void f10_V_SSS_DIF(struct S_DIF p0, struct S_DIF p1, struct S_DIF p2,  void (*cb)(struct S_DIF, struct S_DIF, struct S_DIF)) { cb(p0,p1,p2); }
+EXPORT void f10_V_SSS_DID(struct S_DID p0, struct S_DID p1, struct S_DID p2,  void (*cb)(struct S_DID, struct S_DID, struct S_DID)) { cb(p0,p1,p2); }
+EXPORT void f10_V_SSS_DIP(struct S_DIP p0, struct S_DIP p1, struct S_DIP p2,  void (*cb)(struct S_DIP, struct S_DIP, struct S_DIP)) { cb(p0,p1,p2); }
+EXPORT void f10_V_SSS_DFI(struct S_DFI p0, struct S_DFI p1, struct S_DFI p2,  void (*cb)(struct S_DFI, struct S_DFI, struct S_DFI)) { cb(p0,p1,p2); }
+EXPORT void f10_V_SSS_DFF(struct S_DFF p0, struct S_DFF p1, struct S_DFF p2,  void (*cb)(struct S_DFF, struct S_DFF, struct S_DFF)) { cb(p0,p1,p2); }
+EXPORT void f10_V_SSS_DFD(struct S_DFD p0, struct S_DFD p1, struct S_DFD p2,  void (*cb)(struct S_DFD, struct S_DFD, struct S_DFD)) { cb(p0,p1,p2); }
+EXPORT void f10_V_SSS_DFP(struct S_DFP p0, struct S_DFP p1, struct S_DFP p2,  void (*cb)(struct S_DFP, struct S_DFP, struct S_DFP)) { cb(p0,p1,p2); }
+EXPORT void f10_V_SSS_DDI(struct S_DDI p0, struct S_DDI p1, struct S_DDI p2,  void (*cb)(struct S_DDI, struct S_DDI, struct S_DDI)) { cb(p0,p1,p2); }
+EXPORT void f10_V_SSS_DDF(struct S_DDF p0, struct S_DDF p1, struct S_DDF p2,  void (*cb)(struct S_DDF, struct S_DDF, struct S_DDF)) { cb(p0,p1,p2); }
+EXPORT void f10_V_SSS_DDD(struct S_DDD p0, struct S_DDD p1, struct S_DDD p2,  void (*cb)(struct S_DDD, struct S_DDD, struct S_DDD)) { cb(p0,p1,p2); }
+EXPORT void f10_V_SSS_DDP(struct S_DDP p0, struct S_DDP p1, struct S_DDP p2,  void (*cb)(struct S_DDP, struct S_DDP, struct S_DDP)) { cb(p0,p1,p2); }
+EXPORT void f10_V_SSS_DPI(struct S_DPI p0, struct S_DPI p1, struct S_DPI p2,  void (*cb)(struct S_DPI, struct S_DPI, struct S_DPI)) { cb(p0,p1,p2); }
+EXPORT void f10_V_SSS_DPF(struct S_DPF p0, struct S_DPF p1, struct S_DPF p2,  void (*cb)(struct S_DPF, struct S_DPF, struct S_DPF)) { cb(p0,p1,p2); }
+EXPORT void f10_V_SSS_DPD(struct S_DPD p0, struct S_DPD p1, struct S_DPD p2,  void (*cb)(struct S_DPD, struct S_DPD, struct S_DPD)) { cb(p0,p1,p2); }
+EXPORT void f10_V_SSS_DPP(struct S_DPP p0, struct S_DPP p1, struct S_DPP p2,  void (*cb)(struct S_DPP, struct S_DPP, struct S_DPP)) { cb(p0,p1,p2); }
+EXPORT void f10_V_SSS_PII(struct S_PII p0, struct S_PII p1, struct S_PII p2,  void (*cb)(struct S_PII, struct S_PII, struct S_PII)) { cb(p0,p1,p2); }
+EXPORT void f10_V_SSS_PIF(struct S_PIF p0, struct S_PIF p1, struct S_PIF p2,  void (*cb)(struct S_PIF, struct S_PIF, struct S_PIF)) { cb(p0,p1,p2); }
+EXPORT void f10_V_SSS_PID(struct S_PID p0, struct S_PID p1, struct S_PID p2,  void (*cb)(struct S_PID, struct S_PID, struct S_PID)) { cb(p0,p1,p2); }
+EXPORT void f10_V_SSS_PIP(struct S_PIP p0, struct S_PIP p1, struct S_PIP p2,  void (*cb)(struct S_PIP, struct S_PIP, struct S_PIP)) { cb(p0,p1,p2); }
+EXPORT void f10_V_SSS_PFI(struct S_PFI p0, struct S_PFI p1, struct S_PFI p2,  void (*cb)(struct S_PFI, struct S_PFI, struct S_PFI)) { cb(p0,p1,p2); }
+EXPORT void f10_V_SSS_PFF(struct S_PFF p0, struct S_PFF p1, struct S_PFF p2,  void (*cb)(struct S_PFF, struct S_PFF, struct S_PFF)) { cb(p0,p1,p2); }
+EXPORT void f10_V_SSS_PFD(struct S_PFD p0, struct S_PFD p1, struct S_PFD p2,  void (*cb)(struct S_PFD, struct S_PFD, struct S_PFD)) { cb(p0,p1,p2); }
+EXPORT void f10_V_SSS_PFP(struct S_PFP p0, struct S_PFP p1, struct S_PFP p2,  void (*cb)(struct S_PFP, struct S_PFP, struct S_PFP)) { cb(p0,p1,p2); }
+EXPORT void f10_V_SSS_PDI(struct S_PDI p0, struct S_PDI p1, struct S_PDI p2,  void (*cb)(struct S_PDI, struct S_PDI, struct S_PDI)) { cb(p0,p1,p2); }
+EXPORT void f10_V_SSS_PDF(struct S_PDF p0, struct S_PDF p1, struct S_PDF p2,  void (*cb)(struct S_PDF, struct S_PDF, struct S_PDF)) { cb(p0,p1,p2); }
+EXPORT void f10_V_SSS_PDD(struct S_PDD p0, struct S_PDD p1, struct S_PDD p2,  void (*cb)(struct S_PDD, struct S_PDD, struct S_PDD)) { cb(p0,p1,p2); }
+EXPORT void f10_V_SSS_PDP(struct S_PDP p0, struct S_PDP p1, struct S_PDP p2,  void (*cb)(struct S_PDP, struct S_PDP, struct S_PDP)) { cb(p0,p1,p2); }
+EXPORT void f10_V_SSS_PPI(struct S_PPI p0, struct S_PPI p1, struct S_PPI p2,  void (*cb)(struct S_PPI, struct S_PPI, struct S_PPI)) { cb(p0,p1,p2); }
+EXPORT void f10_V_SSS_PPF(struct S_PPF p0, struct S_PPF p1, struct S_PPF p2,  void (*cb)(struct S_PPF, struct S_PPF, struct S_PPF)) { cb(p0,p1,p2); }
+EXPORT void f10_V_SSS_PPD(struct S_PPD p0, struct S_PPD p1, struct S_PPD p2,  void (*cb)(struct S_PPD, struct S_PPD, struct S_PPD)) { cb(p0,p1,p2); }
+EXPORT void f10_V_SSS_PPP(struct S_PPP p0, struct S_PPP p1, struct S_PPP p2,  void (*cb)(struct S_PPP, struct S_PPP, struct S_PPP)) { cb(p0,p1,p2); }
+EXPORT int f10_I_I_(int p0,  int (*cb)(int)) { return cb(p0); }
+EXPORT float f10_F_F_(float p0,  float (*cb)(float)) { return cb(p0); }
+EXPORT double f10_D_D_(double p0,  double (*cb)(double)) { return cb(p0); }
+EXPORT void* f10_P_P_(void* p0,  void* (*cb)(void*)) { return cb(p0); }
+EXPORT struct S_I f10_S_S_I(struct S_I p0,  struct S_I (*cb)(struct S_I)) { return cb(p0); }
+EXPORT struct S_F f10_S_S_F(struct S_F p0,  struct S_F (*cb)(struct S_F)) { return cb(p0); }
+EXPORT struct S_D f10_S_S_D(struct S_D p0,  struct S_D (*cb)(struct S_D)) { return cb(p0); }
+EXPORT struct S_P f10_S_S_P(struct S_P p0,  struct S_P (*cb)(struct S_P)) { return cb(p0); }
+EXPORT struct S_II f10_S_S_II(struct S_II p0,  struct S_II (*cb)(struct S_II)) { return cb(p0); }
+EXPORT struct S_IF f10_S_S_IF(struct S_IF p0,  struct S_IF (*cb)(struct S_IF)) { return cb(p0); }
+EXPORT struct S_ID f10_S_S_ID(struct S_ID p0,  struct S_ID (*cb)(struct S_ID)) { return cb(p0); }
+EXPORT struct S_IP f10_S_S_IP(struct S_IP p0,  struct S_IP (*cb)(struct S_IP)) { return cb(p0); }
+EXPORT struct S_FI f10_S_S_FI(struct S_FI p0,  struct S_FI (*cb)(struct S_FI)) { return cb(p0); }
+EXPORT struct S_FF f10_S_S_FF(struct S_FF p0,  struct S_FF (*cb)(struct S_FF)) { return cb(p0); }
+EXPORT struct S_FD f10_S_S_FD(struct S_FD p0,  struct S_FD (*cb)(struct S_FD)) { return cb(p0); }
+EXPORT struct S_FP f10_S_S_FP(struct S_FP p0,  struct S_FP (*cb)(struct S_FP)) { return cb(p0); }
+EXPORT struct S_DI f10_S_S_DI(struct S_DI p0,  struct S_DI (*cb)(struct S_DI)) { return cb(p0); }
+EXPORT struct S_DF f10_S_S_DF(struct S_DF p0,  struct S_DF (*cb)(struct S_DF)) { return cb(p0); }
+EXPORT struct S_DD f10_S_S_DD(struct S_DD p0,  struct S_DD (*cb)(struct S_DD)) { return cb(p0); }
+EXPORT struct S_DP f10_S_S_DP(struct S_DP p0,  struct S_DP (*cb)(struct S_DP)) { return cb(p0); }
+EXPORT struct S_PI f10_S_S_PI(struct S_PI p0,  struct S_PI (*cb)(struct S_PI)) { return cb(p0); }
+EXPORT struct S_PF f10_S_S_PF(struct S_PF p0,  struct S_PF (*cb)(struct S_PF)) { return cb(p0); }
+EXPORT struct S_PD f10_S_S_PD(struct S_PD p0,  struct S_PD (*cb)(struct S_PD)) { return cb(p0); }
+EXPORT struct S_PP f10_S_S_PP(struct S_PP p0,  struct S_PP (*cb)(struct S_PP)) { return cb(p0); }
+EXPORT struct S_III f10_S_S_III(struct S_III p0,  struct S_III (*cb)(struct S_III)) { return cb(p0); }
+EXPORT struct S_IIF f10_S_S_IIF(struct S_IIF p0,  struct S_IIF (*cb)(struct S_IIF)) { return cb(p0); }
+EXPORT struct S_IID f10_S_S_IID(struct S_IID p0,  struct S_IID (*cb)(struct S_IID)) { return cb(p0); }
+EXPORT struct S_IIP f10_S_S_IIP(struct S_IIP p0,  struct S_IIP (*cb)(struct S_IIP)) { return cb(p0); }
+EXPORT struct S_IFI f10_S_S_IFI(struct S_IFI p0,  struct S_IFI (*cb)(struct S_IFI)) { return cb(p0); }
+EXPORT struct S_IFF f10_S_S_IFF(struct S_IFF p0,  struct S_IFF (*cb)(struct S_IFF)) { return cb(p0); }
+EXPORT struct S_IFD f10_S_S_IFD(struct S_IFD p0,  struct S_IFD (*cb)(struct S_IFD)) { return cb(p0); }
+EXPORT struct S_IFP f10_S_S_IFP(struct S_IFP p0,  struct S_IFP (*cb)(struct S_IFP)) { return cb(p0); }
+EXPORT struct S_IDI f10_S_S_IDI(struct S_IDI p0,  struct S_IDI (*cb)(struct S_IDI)) { return cb(p0); }
+EXPORT struct S_IDF f10_S_S_IDF(struct S_IDF p0,  struct S_IDF (*cb)(struct S_IDF)) { return cb(p0); }
+EXPORT struct S_IDD f10_S_S_IDD(struct S_IDD p0,  struct S_IDD (*cb)(struct S_IDD)) { return cb(p0); }
+EXPORT struct S_IDP f10_S_S_IDP(struct S_IDP p0,  struct S_IDP (*cb)(struct S_IDP)) { return cb(p0); }
+EXPORT struct S_IPI f10_S_S_IPI(struct S_IPI p0,  struct S_IPI (*cb)(struct S_IPI)) { return cb(p0); }
+EXPORT struct S_IPF f10_S_S_IPF(struct S_IPF p0,  struct S_IPF (*cb)(struct S_IPF)) { return cb(p0); }
+EXPORT struct S_IPD f10_S_S_IPD(struct S_IPD p0,  struct S_IPD (*cb)(struct S_IPD)) { return cb(p0); }
+EXPORT struct S_IPP f10_S_S_IPP(struct S_IPP p0,  struct S_IPP (*cb)(struct S_IPP)) { return cb(p0); }
+EXPORT struct S_FII f10_S_S_FII(struct S_FII p0,  struct S_FII (*cb)(struct S_FII)) { return cb(p0); }
+EXPORT struct S_FIF f10_S_S_FIF(struct S_FIF p0,  struct S_FIF (*cb)(struct S_FIF)) { return cb(p0); }
+EXPORT struct S_FID f10_S_S_FID(struct S_FID p0,  struct S_FID (*cb)(struct S_FID)) { return cb(p0); }
+EXPORT struct S_FIP f10_S_S_FIP(struct S_FIP p0,  struct S_FIP (*cb)(struct S_FIP)) { return cb(p0); }
+EXPORT struct S_FFI f10_S_S_FFI(struct S_FFI p0,  struct S_FFI (*cb)(struct S_FFI)) { return cb(p0); }
+EXPORT struct S_FFF f10_S_S_FFF(struct S_FFF p0,  struct S_FFF (*cb)(struct S_FFF)) { return cb(p0); }
+EXPORT struct S_FFD f10_S_S_FFD(struct S_FFD p0,  struct S_FFD (*cb)(struct S_FFD)) { return cb(p0); }
+EXPORT struct S_FFP f10_S_S_FFP(struct S_FFP p0,  struct S_FFP (*cb)(struct S_FFP)) { return cb(p0); }
+EXPORT struct S_FDI f10_S_S_FDI(struct S_FDI p0,  struct S_FDI (*cb)(struct S_FDI)) { return cb(p0); }
+EXPORT struct S_FDF f10_S_S_FDF(struct S_FDF p0,  struct S_FDF (*cb)(struct S_FDF)) { return cb(p0); }
+EXPORT struct S_FDD f10_S_S_FDD(struct S_FDD p0,  struct S_FDD (*cb)(struct S_FDD)) { return cb(p0); }
+EXPORT struct S_FDP f10_S_S_FDP(struct S_FDP p0,  struct S_FDP (*cb)(struct S_FDP)) { return cb(p0); }
+EXPORT struct S_FPI f10_S_S_FPI(struct S_FPI p0,  struct S_FPI (*cb)(struct S_FPI)) { return cb(p0); }
+EXPORT struct S_FPF f10_S_S_FPF(struct S_FPF p0,  struct S_FPF (*cb)(struct S_FPF)) { return cb(p0); }
+EXPORT struct S_FPD f10_S_S_FPD(struct S_FPD p0,  struct S_FPD (*cb)(struct S_FPD)) { return cb(p0); }
+EXPORT struct S_FPP f10_S_S_FPP(struct S_FPP p0,  struct S_FPP (*cb)(struct S_FPP)) { return cb(p0); }
+EXPORT struct S_DII f10_S_S_DII(struct S_DII p0,  struct S_DII (*cb)(struct S_DII)) { return cb(p0); }
+EXPORT struct S_DIF f10_S_S_DIF(struct S_DIF p0,  struct S_DIF (*cb)(struct S_DIF)) { return cb(p0); }
+EXPORT struct S_DID f10_S_S_DID(struct S_DID p0,  struct S_DID (*cb)(struct S_DID)) { return cb(p0); }
+EXPORT struct S_DIP f10_S_S_DIP(struct S_DIP p0,  struct S_DIP (*cb)(struct S_DIP)) { return cb(p0); }
+EXPORT struct S_DFI f10_S_S_DFI(struct S_DFI p0,  struct S_DFI (*cb)(struct S_DFI)) { return cb(p0); }
+EXPORT struct S_DFF f10_S_S_DFF(struct S_DFF p0,  struct S_DFF (*cb)(struct S_DFF)) { return cb(p0); }
+EXPORT struct S_DFD f10_S_S_DFD(struct S_DFD p0,  struct S_DFD (*cb)(struct S_DFD)) { return cb(p0); }
+EXPORT struct S_DFP f10_S_S_DFP(struct S_DFP p0,  struct S_DFP (*cb)(struct S_DFP)) { return cb(p0); }
+EXPORT struct S_DDI f10_S_S_DDI(struct S_DDI p0,  struct S_DDI (*cb)(struct S_DDI)) { return cb(p0); }
+EXPORT struct S_DDF f10_S_S_DDF(struct S_DDF p0,  struct S_DDF (*cb)(struct S_DDF)) { return cb(p0); }
+EXPORT struct S_DDD f10_S_S_DDD(struct S_DDD p0,  struct S_DDD (*cb)(struct S_DDD)) { return cb(p0); }
+EXPORT struct S_DDP f10_S_S_DDP(struct S_DDP p0,  struct S_DDP (*cb)(struct S_DDP)) { return cb(p0); }
+EXPORT struct S_DPI f10_S_S_DPI(struct S_DPI p0,  struct S_DPI (*cb)(struct S_DPI)) { return cb(p0); }
+EXPORT struct S_DPF f10_S_S_DPF(struct S_DPF p0,  struct S_DPF (*cb)(struct S_DPF)) { return cb(p0); }
+EXPORT struct S_DPD f10_S_S_DPD(struct S_DPD p0,  struct S_DPD (*cb)(struct S_DPD)) { return cb(p0); }
+EXPORT struct S_DPP f10_S_S_DPP(struct S_DPP p0,  struct S_DPP (*cb)(struct S_DPP)) { return cb(p0); }
+EXPORT struct S_PII f10_S_S_PII(struct S_PII p0,  struct S_PII (*cb)(struct S_PII)) { return cb(p0); }
+EXPORT struct S_PIF f10_S_S_PIF(struct S_PIF p0,  struct S_PIF (*cb)(struct S_PIF)) { return cb(p0); }
+EXPORT struct S_PID f10_S_S_PID(struct S_PID p0,  struct S_PID (*cb)(struct S_PID)) { return cb(p0); }
+EXPORT struct S_PIP f10_S_S_PIP(struct S_PIP p0,  struct S_PIP (*cb)(struct S_PIP)) { return cb(p0); }
+EXPORT struct S_PFI f10_S_S_PFI(struct S_PFI p0,  struct S_PFI (*cb)(struct S_PFI)) { return cb(p0); }
+EXPORT struct S_PFF f10_S_S_PFF(struct S_PFF p0,  struct S_PFF (*cb)(struct S_PFF)) { return cb(p0); }
+EXPORT struct S_PFD f10_S_S_PFD(struct S_PFD p0,  struct S_PFD (*cb)(struct S_PFD)) { return cb(p0); }
+EXPORT struct S_PFP f10_S_S_PFP(struct S_PFP p0,  struct S_PFP (*cb)(struct S_PFP)) { return cb(p0); }
+EXPORT struct S_PDI f10_S_S_PDI(struct S_PDI p0,  struct S_PDI (*cb)(struct S_PDI)) { return cb(p0); }
+EXPORT struct S_PDF f10_S_S_PDF(struct S_PDF p0,  struct S_PDF (*cb)(struct S_PDF)) { return cb(p0); }
+EXPORT struct S_PDD f10_S_S_PDD(struct S_PDD p0,  struct S_PDD (*cb)(struct S_PDD)) { return cb(p0); }
+EXPORT struct S_PDP f10_S_S_PDP(struct S_PDP p0,  struct S_PDP (*cb)(struct S_PDP)) { return cb(p0); }
+EXPORT struct S_PPI f10_S_S_PPI(struct S_PPI p0,  struct S_PPI (*cb)(struct S_PPI)) { return cb(p0); }
+EXPORT struct S_PPF f10_S_S_PPF(struct S_PPF p0,  struct S_PPF (*cb)(struct S_PPF)) { return cb(p0); }
+EXPORT struct S_PPD f10_S_S_PPD(struct S_PPD p0,  struct S_PPD (*cb)(struct S_PPD)) { return cb(p0); }
+EXPORT struct S_PPP f10_S_S_PPP(struct S_PPP p0,  struct S_PPP (*cb)(struct S_PPP)) { return cb(p0); }
+EXPORT int f10_I_II_(int p0, int p1,  int (*cb)(int, int)) { return cb(p0,p1); }
+EXPORT int f10_I_IF_(int p0, float p1,  int (*cb)(int, float)) { return cb(p0,p1); }
+EXPORT int f10_I_ID_(int p0, double p1,  int (*cb)(int, double)) { return cb(p0,p1); }
+EXPORT int f10_I_IP_(int p0, void* p1,  int (*cb)(int, void*)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_I(int p0, struct S_I p1,  int (*cb)(int, struct S_I)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_F(int p0, struct S_F p1,  int (*cb)(int, struct S_F)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_D(int p0, struct S_D p1,  int (*cb)(int, struct S_D)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_P(int p0, struct S_P p1,  int (*cb)(int, struct S_P)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_II(int p0, struct S_II p1,  int (*cb)(int, struct S_II)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_IF(int p0, struct S_IF p1,  int (*cb)(int, struct S_IF)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_ID(int p0, struct S_ID p1,  int (*cb)(int, struct S_ID)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_IP(int p0, struct S_IP p1,  int (*cb)(int, struct S_IP)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_FI(int p0, struct S_FI p1,  int (*cb)(int, struct S_FI)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_FF(int p0, struct S_FF p1,  int (*cb)(int, struct S_FF)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_FD(int p0, struct S_FD p1,  int (*cb)(int, struct S_FD)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_FP(int p0, struct S_FP p1,  int (*cb)(int, struct S_FP)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_DI(int p0, struct S_DI p1,  int (*cb)(int, struct S_DI)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_DF(int p0, struct S_DF p1,  int (*cb)(int, struct S_DF)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_DD(int p0, struct S_DD p1,  int (*cb)(int, struct S_DD)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_DP(int p0, struct S_DP p1,  int (*cb)(int, struct S_DP)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_PI(int p0, struct S_PI p1,  int (*cb)(int, struct S_PI)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_PF(int p0, struct S_PF p1,  int (*cb)(int, struct S_PF)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_PD(int p0, struct S_PD p1,  int (*cb)(int, struct S_PD)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_PP(int p0, struct S_PP p1,  int (*cb)(int, struct S_PP)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_III(int p0, struct S_III p1,  int (*cb)(int, struct S_III)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_IIF(int p0, struct S_IIF p1,  int (*cb)(int, struct S_IIF)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_IID(int p0, struct S_IID p1,  int (*cb)(int, struct S_IID)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_IIP(int p0, struct S_IIP p1,  int (*cb)(int, struct S_IIP)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_IFI(int p0, struct S_IFI p1,  int (*cb)(int, struct S_IFI)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_IFF(int p0, struct S_IFF p1,  int (*cb)(int, struct S_IFF)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_IFD(int p0, struct S_IFD p1,  int (*cb)(int, struct S_IFD)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_IFP(int p0, struct S_IFP p1,  int (*cb)(int, struct S_IFP)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_IDI(int p0, struct S_IDI p1,  int (*cb)(int, struct S_IDI)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_IDF(int p0, struct S_IDF p1,  int (*cb)(int, struct S_IDF)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_IDD(int p0, struct S_IDD p1,  int (*cb)(int, struct S_IDD)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_IDP(int p0, struct S_IDP p1,  int (*cb)(int, struct S_IDP)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_IPI(int p0, struct S_IPI p1,  int (*cb)(int, struct S_IPI)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_IPF(int p0, struct S_IPF p1,  int (*cb)(int, struct S_IPF)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_IPD(int p0, struct S_IPD p1,  int (*cb)(int, struct S_IPD)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_IPP(int p0, struct S_IPP p1,  int (*cb)(int, struct S_IPP)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_FII(int p0, struct S_FII p1,  int (*cb)(int, struct S_FII)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_FIF(int p0, struct S_FIF p1,  int (*cb)(int, struct S_FIF)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_FID(int p0, struct S_FID p1,  int (*cb)(int, struct S_FID)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_FIP(int p0, struct S_FIP p1,  int (*cb)(int, struct S_FIP)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_FFI(int p0, struct S_FFI p1,  int (*cb)(int, struct S_FFI)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_FFF(int p0, struct S_FFF p1,  int (*cb)(int, struct S_FFF)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_FFD(int p0, struct S_FFD p1,  int (*cb)(int, struct S_FFD)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_FFP(int p0, struct S_FFP p1,  int (*cb)(int, struct S_FFP)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_FDI(int p0, struct S_FDI p1,  int (*cb)(int, struct S_FDI)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_FDF(int p0, struct S_FDF p1,  int (*cb)(int, struct S_FDF)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_FDD(int p0, struct S_FDD p1,  int (*cb)(int, struct S_FDD)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_FDP(int p0, struct S_FDP p1,  int (*cb)(int, struct S_FDP)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_FPI(int p0, struct S_FPI p1,  int (*cb)(int, struct S_FPI)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_FPF(int p0, struct S_FPF p1,  int (*cb)(int, struct S_FPF)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_FPD(int p0, struct S_FPD p1,  int (*cb)(int, struct S_FPD)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_FPP(int p0, struct S_FPP p1,  int (*cb)(int, struct S_FPP)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_DII(int p0, struct S_DII p1,  int (*cb)(int, struct S_DII)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_DIF(int p0, struct S_DIF p1,  int (*cb)(int, struct S_DIF)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_DID(int p0, struct S_DID p1,  int (*cb)(int, struct S_DID)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_DIP(int p0, struct S_DIP p1,  int (*cb)(int, struct S_DIP)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_DFI(int p0, struct S_DFI p1,  int (*cb)(int, struct S_DFI)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_DFF(int p0, struct S_DFF p1,  int (*cb)(int, struct S_DFF)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_DFD(int p0, struct S_DFD p1,  int (*cb)(int, struct S_DFD)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_DFP(int p0, struct S_DFP p1,  int (*cb)(int, struct S_DFP)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_DDI(int p0, struct S_DDI p1,  int (*cb)(int, struct S_DDI)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_DDF(int p0, struct S_DDF p1,  int (*cb)(int, struct S_DDF)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_DDD(int p0, struct S_DDD p1,  int (*cb)(int, struct S_DDD)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_DDP(int p0, struct S_DDP p1,  int (*cb)(int, struct S_DDP)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_DPI(int p0, struct S_DPI p1,  int (*cb)(int, struct S_DPI)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_DPF(int p0, struct S_DPF p1,  int (*cb)(int, struct S_DPF)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_DPD(int p0, struct S_DPD p1,  int (*cb)(int, struct S_DPD)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_DPP(int p0, struct S_DPP p1,  int (*cb)(int, struct S_DPP)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_PII(int p0, struct S_PII p1,  int (*cb)(int, struct S_PII)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_PIF(int p0, struct S_PIF p1,  int (*cb)(int, struct S_PIF)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_PID(int p0, struct S_PID p1,  int (*cb)(int, struct S_PID)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_PIP(int p0, struct S_PIP p1,  int (*cb)(int, struct S_PIP)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_PFI(int p0, struct S_PFI p1,  int (*cb)(int, struct S_PFI)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_PFF(int p0, struct S_PFF p1,  int (*cb)(int, struct S_PFF)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_PFD(int p0, struct S_PFD p1,  int (*cb)(int, struct S_PFD)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_PFP(int p0, struct S_PFP p1,  int (*cb)(int, struct S_PFP)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_PDI(int p0, struct S_PDI p1,  int (*cb)(int, struct S_PDI)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_PDF(int p0, struct S_PDF p1,  int (*cb)(int, struct S_PDF)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_PDD(int p0, struct S_PDD p1,  int (*cb)(int, struct S_PDD)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_PDP(int p0, struct S_PDP p1,  int (*cb)(int, struct S_PDP)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_PPI(int p0, struct S_PPI p1,  int (*cb)(int, struct S_PPI)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_PPF(int p0, struct S_PPF p1,  int (*cb)(int, struct S_PPF)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_PPD(int p0, struct S_PPD p1,  int (*cb)(int, struct S_PPD)) { return cb(p0,p1); }
+EXPORT int f10_I_IS_PPP(int p0, struct S_PPP p1,  int (*cb)(int, struct S_PPP)) { return cb(p0,p1); }
+EXPORT float f10_F_FI_(float p0, int p1,  float (*cb)(float, int)) { return cb(p0,p1); }
+EXPORT float f10_F_FF_(float p0, float p1,  float (*cb)(float, float)) { return cb(p0,p1); }
+EXPORT float f10_F_FD_(float p0, double p1,  float (*cb)(float, double)) { return cb(p0,p1); }
+EXPORT float f10_F_FP_(float p0, void* p1,  float (*cb)(float, void*)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_I(float p0, struct S_I p1,  float (*cb)(float, struct S_I)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_F(float p0, struct S_F p1,  float (*cb)(float, struct S_F)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_D(float p0, struct S_D p1,  float (*cb)(float, struct S_D)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_P(float p0, struct S_P p1,  float (*cb)(float, struct S_P)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_II(float p0, struct S_II p1,  float (*cb)(float, struct S_II)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_IF(float p0, struct S_IF p1,  float (*cb)(float, struct S_IF)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_ID(float p0, struct S_ID p1,  float (*cb)(float, struct S_ID)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_IP(float p0, struct S_IP p1,  float (*cb)(float, struct S_IP)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_FI(float p0, struct S_FI p1,  float (*cb)(float, struct S_FI)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_FF(float p0, struct S_FF p1,  float (*cb)(float, struct S_FF)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_FD(float p0, struct S_FD p1,  float (*cb)(float, struct S_FD)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_FP(float p0, struct S_FP p1,  float (*cb)(float, struct S_FP)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_DI(float p0, struct S_DI p1,  float (*cb)(float, struct S_DI)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_DF(float p0, struct S_DF p1,  float (*cb)(float, struct S_DF)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_DD(float p0, struct S_DD p1,  float (*cb)(float, struct S_DD)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_DP(float p0, struct S_DP p1,  float (*cb)(float, struct S_DP)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_PI(float p0, struct S_PI p1,  float (*cb)(float, struct S_PI)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_PF(float p0, struct S_PF p1,  float (*cb)(float, struct S_PF)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_PD(float p0, struct S_PD p1,  float (*cb)(float, struct S_PD)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_PP(float p0, struct S_PP p1,  float (*cb)(float, struct S_PP)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_III(float p0, struct S_III p1,  float (*cb)(float, struct S_III)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_IIF(float p0, struct S_IIF p1,  float (*cb)(float, struct S_IIF)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_IID(float p0, struct S_IID p1,  float (*cb)(float, struct S_IID)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_IIP(float p0, struct S_IIP p1,  float (*cb)(float, struct S_IIP)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_IFI(float p0, struct S_IFI p1,  float (*cb)(float, struct S_IFI)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_IFF(float p0, struct S_IFF p1,  float (*cb)(float, struct S_IFF)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_IFD(float p0, struct S_IFD p1,  float (*cb)(float, struct S_IFD)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_IFP(float p0, struct S_IFP p1,  float (*cb)(float, struct S_IFP)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_IDI(float p0, struct S_IDI p1,  float (*cb)(float, struct S_IDI)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_IDF(float p0, struct S_IDF p1,  float (*cb)(float, struct S_IDF)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_IDD(float p0, struct S_IDD p1,  float (*cb)(float, struct S_IDD)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_IDP(float p0, struct S_IDP p1,  float (*cb)(float, struct S_IDP)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_IPI(float p0, struct S_IPI p1,  float (*cb)(float, struct S_IPI)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_IPF(float p0, struct S_IPF p1,  float (*cb)(float, struct S_IPF)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_IPD(float p0, struct S_IPD p1,  float (*cb)(float, struct S_IPD)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_IPP(float p0, struct S_IPP p1,  float (*cb)(float, struct S_IPP)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_FII(float p0, struct S_FII p1,  float (*cb)(float, struct S_FII)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_FIF(float p0, struct S_FIF p1,  float (*cb)(float, struct S_FIF)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_FID(float p0, struct S_FID p1,  float (*cb)(float, struct S_FID)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_FIP(float p0, struct S_FIP p1,  float (*cb)(float, struct S_FIP)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_FFI(float p0, struct S_FFI p1,  float (*cb)(float, struct S_FFI)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_FFF(float p0, struct S_FFF p1,  float (*cb)(float, struct S_FFF)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_FFD(float p0, struct S_FFD p1,  float (*cb)(float, struct S_FFD)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_FFP(float p0, struct S_FFP p1,  float (*cb)(float, struct S_FFP)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_FDI(float p0, struct S_FDI p1,  float (*cb)(float, struct S_FDI)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_FDF(float p0, struct S_FDF p1,  float (*cb)(float, struct S_FDF)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_FDD(float p0, struct S_FDD p1,  float (*cb)(float, struct S_FDD)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_FDP(float p0, struct S_FDP p1,  float (*cb)(float, struct S_FDP)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_FPI(float p0, struct S_FPI p1,  float (*cb)(float, struct S_FPI)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_FPF(float p0, struct S_FPF p1,  float (*cb)(float, struct S_FPF)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_FPD(float p0, struct S_FPD p1,  float (*cb)(float, struct S_FPD)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_FPP(float p0, struct S_FPP p1,  float (*cb)(float, struct S_FPP)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_DII(float p0, struct S_DII p1,  float (*cb)(float, struct S_DII)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_DIF(float p0, struct S_DIF p1,  float (*cb)(float, struct S_DIF)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_DID(float p0, struct S_DID p1,  float (*cb)(float, struct S_DID)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_DIP(float p0, struct S_DIP p1,  float (*cb)(float, struct S_DIP)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_DFI(float p0, struct S_DFI p1,  float (*cb)(float, struct S_DFI)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_DFF(float p0, struct S_DFF p1,  float (*cb)(float, struct S_DFF)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_DFD(float p0, struct S_DFD p1,  float (*cb)(float, struct S_DFD)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_DFP(float p0, struct S_DFP p1,  float (*cb)(float, struct S_DFP)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_DDI(float p0, struct S_DDI p1,  float (*cb)(float, struct S_DDI)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_DDF(float p0, struct S_DDF p1,  float (*cb)(float, struct S_DDF)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_DDD(float p0, struct S_DDD p1,  float (*cb)(float, struct S_DDD)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_DDP(float p0, struct S_DDP p1,  float (*cb)(float, struct S_DDP)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_DPI(float p0, struct S_DPI p1,  float (*cb)(float, struct S_DPI)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_DPF(float p0, struct S_DPF p1,  float (*cb)(float, struct S_DPF)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_DPD(float p0, struct S_DPD p1,  float (*cb)(float, struct S_DPD)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_DPP(float p0, struct S_DPP p1,  float (*cb)(float, struct S_DPP)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_PII(float p0, struct S_PII p1,  float (*cb)(float, struct S_PII)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_PIF(float p0, struct S_PIF p1,  float (*cb)(float, struct S_PIF)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_PID(float p0, struct S_PID p1,  float (*cb)(float, struct S_PID)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_PIP(float p0, struct S_PIP p1,  float (*cb)(float, struct S_PIP)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_PFI(float p0, struct S_PFI p1,  float (*cb)(float, struct S_PFI)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_PFF(float p0, struct S_PFF p1,  float (*cb)(float, struct S_PFF)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_PFD(float p0, struct S_PFD p1,  float (*cb)(float, struct S_PFD)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_PFP(float p0, struct S_PFP p1,  float (*cb)(float, struct S_PFP)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_PDI(float p0, struct S_PDI p1,  float (*cb)(float, struct S_PDI)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_PDF(float p0, struct S_PDF p1,  float (*cb)(float, struct S_PDF)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_PDD(float p0, struct S_PDD p1,  float (*cb)(float, struct S_PDD)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_PDP(float p0, struct S_PDP p1,  float (*cb)(float, struct S_PDP)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_PPI(float p0, struct S_PPI p1,  float (*cb)(float, struct S_PPI)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_PPF(float p0, struct S_PPF p1,  float (*cb)(float, struct S_PPF)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_PPD(float p0, struct S_PPD p1,  float (*cb)(float, struct S_PPD)) { return cb(p0,p1); }
+EXPORT float f10_F_FS_PPP(float p0, struct S_PPP p1,  float (*cb)(float, struct S_PPP)) { return cb(p0,p1); }
+EXPORT double f10_D_DI_(double p0, int p1,  double (*cb)(double, int)) { return cb(p0,p1); }
+EXPORT double f10_D_DF_(double p0, float p1,  double (*cb)(double, float)) { return cb(p0,p1); }
+EXPORT double f10_D_DD_(double p0, double p1,  double (*cb)(double, double)) { return cb(p0,p1); }
+EXPORT double f10_D_DP_(double p0, void* p1,  double (*cb)(double, void*)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_I(double p0, struct S_I p1,  double (*cb)(double, struct S_I)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_F(double p0, struct S_F p1,  double (*cb)(double, struct S_F)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_D(double p0, struct S_D p1,  double (*cb)(double, struct S_D)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_P(double p0, struct S_P p1,  double (*cb)(double, struct S_P)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_II(double p0, struct S_II p1,  double (*cb)(double, struct S_II)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_IF(double p0, struct S_IF p1,  double (*cb)(double, struct S_IF)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_ID(double p0, struct S_ID p1,  double (*cb)(double, struct S_ID)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_IP(double p0, struct S_IP p1,  double (*cb)(double, struct S_IP)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_FI(double p0, struct S_FI p1,  double (*cb)(double, struct S_FI)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_FF(double p0, struct S_FF p1,  double (*cb)(double, struct S_FF)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_FD(double p0, struct S_FD p1,  double (*cb)(double, struct S_FD)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_FP(double p0, struct S_FP p1,  double (*cb)(double, struct S_FP)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_DI(double p0, struct S_DI p1,  double (*cb)(double, struct S_DI)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_DF(double p0, struct S_DF p1,  double (*cb)(double, struct S_DF)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_DD(double p0, struct S_DD p1,  double (*cb)(double, struct S_DD)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_DP(double p0, struct S_DP p1,  double (*cb)(double, struct S_DP)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_PI(double p0, struct S_PI p1,  double (*cb)(double, struct S_PI)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_PF(double p0, struct S_PF p1,  double (*cb)(double, struct S_PF)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_PD(double p0, struct S_PD p1,  double (*cb)(double, struct S_PD)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_PP(double p0, struct S_PP p1,  double (*cb)(double, struct S_PP)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_III(double p0, struct S_III p1,  double (*cb)(double, struct S_III)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_IIF(double p0, struct S_IIF p1,  double (*cb)(double, struct S_IIF)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_IID(double p0, struct S_IID p1,  double (*cb)(double, struct S_IID)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_IIP(double p0, struct S_IIP p1,  double (*cb)(double, struct S_IIP)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_IFI(double p0, struct S_IFI p1,  double (*cb)(double, struct S_IFI)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_IFF(double p0, struct S_IFF p1,  double (*cb)(double, struct S_IFF)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_IFD(double p0, struct S_IFD p1,  double (*cb)(double, struct S_IFD)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_IFP(double p0, struct S_IFP p1,  double (*cb)(double, struct S_IFP)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_IDI(double p0, struct S_IDI p1,  double (*cb)(double, struct S_IDI)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_IDF(double p0, struct S_IDF p1,  double (*cb)(double, struct S_IDF)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_IDD(double p0, struct S_IDD p1,  double (*cb)(double, struct S_IDD)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_IDP(double p0, struct S_IDP p1,  double (*cb)(double, struct S_IDP)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_IPI(double p0, struct S_IPI p1,  double (*cb)(double, struct S_IPI)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_IPF(double p0, struct S_IPF p1,  double (*cb)(double, struct S_IPF)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_IPD(double p0, struct S_IPD p1,  double (*cb)(double, struct S_IPD)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_IPP(double p0, struct S_IPP p1,  double (*cb)(double, struct S_IPP)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_FII(double p0, struct S_FII p1,  double (*cb)(double, struct S_FII)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_FIF(double p0, struct S_FIF p1,  double (*cb)(double, struct S_FIF)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_FID(double p0, struct S_FID p1,  double (*cb)(double, struct S_FID)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_FIP(double p0, struct S_FIP p1,  double (*cb)(double, struct S_FIP)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_FFI(double p0, struct S_FFI p1,  double (*cb)(double, struct S_FFI)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_FFF(double p0, struct S_FFF p1,  double (*cb)(double, struct S_FFF)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_FFD(double p0, struct S_FFD p1,  double (*cb)(double, struct S_FFD)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_FFP(double p0, struct S_FFP p1,  double (*cb)(double, struct S_FFP)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_FDI(double p0, struct S_FDI p1,  double (*cb)(double, struct S_FDI)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_FDF(double p0, struct S_FDF p1,  double (*cb)(double, struct S_FDF)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_FDD(double p0, struct S_FDD p1,  double (*cb)(double, struct S_FDD)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_FDP(double p0, struct S_FDP p1,  double (*cb)(double, struct S_FDP)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_FPI(double p0, struct S_FPI p1,  double (*cb)(double, struct S_FPI)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_FPF(double p0, struct S_FPF p1,  double (*cb)(double, struct S_FPF)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_FPD(double p0, struct S_FPD p1,  double (*cb)(double, struct S_FPD)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_FPP(double p0, struct S_FPP p1,  double (*cb)(double, struct S_FPP)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_DII(double p0, struct S_DII p1,  double (*cb)(double, struct S_DII)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_DIF(double p0, struct S_DIF p1,  double (*cb)(double, struct S_DIF)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_DID(double p0, struct S_DID p1,  double (*cb)(double, struct S_DID)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_DIP(double p0, struct S_DIP p1,  double (*cb)(double, struct S_DIP)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_DFI(double p0, struct S_DFI p1,  double (*cb)(double, struct S_DFI)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_DFF(double p0, struct S_DFF p1,  double (*cb)(double, struct S_DFF)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_DFD(double p0, struct S_DFD p1,  double (*cb)(double, struct S_DFD)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_DFP(double p0, struct S_DFP p1,  double (*cb)(double, struct S_DFP)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_DDI(double p0, struct S_DDI p1,  double (*cb)(double, struct S_DDI)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_DDF(double p0, struct S_DDF p1,  double (*cb)(double, struct S_DDF)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_DDD(double p0, struct S_DDD p1,  double (*cb)(double, struct S_DDD)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_DDP(double p0, struct S_DDP p1,  double (*cb)(double, struct S_DDP)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_DPI(double p0, struct S_DPI p1,  double (*cb)(double, struct S_DPI)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_DPF(double p0, struct S_DPF p1,  double (*cb)(double, struct S_DPF)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_DPD(double p0, struct S_DPD p1,  double (*cb)(double, struct S_DPD)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_DPP(double p0, struct S_DPP p1,  double (*cb)(double, struct S_DPP)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_PII(double p0, struct S_PII p1,  double (*cb)(double, struct S_PII)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_PIF(double p0, struct S_PIF p1,  double (*cb)(double, struct S_PIF)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_PID(double p0, struct S_PID p1,  double (*cb)(double, struct S_PID)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_PIP(double p0, struct S_PIP p1,  double (*cb)(double, struct S_PIP)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_PFI(double p0, struct S_PFI p1,  double (*cb)(double, struct S_PFI)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_PFF(double p0, struct S_PFF p1,  double (*cb)(double, struct S_PFF)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_PFD(double p0, struct S_PFD p1,  double (*cb)(double, struct S_PFD)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_PFP(double p0, struct S_PFP p1,  double (*cb)(double, struct S_PFP)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_PDI(double p0, struct S_PDI p1,  double (*cb)(double, struct S_PDI)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_PDF(double p0, struct S_PDF p1,  double (*cb)(double, struct S_PDF)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_PDD(double p0, struct S_PDD p1,  double (*cb)(double, struct S_PDD)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_PDP(double p0, struct S_PDP p1,  double (*cb)(double, struct S_PDP)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_PPI(double p0, struct S_PPI p1,  double (*cb)(double, struct S_PPI)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_PPF(double p0, struct S_PPF p1,  double (*cb)(double, struct S_PPF)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_PPD(double p0, struct S_PPD p1,  double (*cb)(double, struct S_PPD)) { return cb(p0,p1); }
+EXPORT double f10_D_DS_PPP(double p0, struct S_PPP p1,  double (*cb)(double, struct S_PPP)) { return cb(p0,p1); }
+EXPORT void* f10_P_PI_(void* p0, int p1,  void* (*cb)(void*, int)) { return cb(p0,p1); }
+EXPORT void* f10_P_PF_(void* p0, float p1,  void* (*cb)(void*, float)) { return cb(p0,p1); }
+EXPORT void* f10_P_PD_(void* p0, double p1,  void* (*cb)(void*, double)) { return cb(p0,p1); }
+EXPORT void* f10_P_PP_(void* p0, void* p1,  void* (*cb)(void*, void*)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_I(void* p0, struct S_I p1,  void* (*cb)(void*, struct S_I)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_F(void* p0, struct S_F p1,  void* (*cb)(void*, struct S_F)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_D(void* p0, struct S_D p1,  void* (*cb)(void*, struct S_D)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_P(void* p0, struct S_P p1,  void* (*cb)(void*, struct S_P)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_II(void* p0, struct S_II p1,  void* (*cb)(void*, struct S_II)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_IF(void* p0, struct S_IF p1,  void* (*cb)(void*, struct S_IF)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_ID(void* p0, struct S_ID p1,  void* (*cb)(void*, struct S_ID)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_IP(void* p0, struct S_IP p1,  void* (*cb)(void*, struct S_IP)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_FI(void* p0, struct S_FI p1,  void* (*cb)(void*, struct S_FI)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_FF(void* p0, struct S_FF p1,  void* (*cb)(void*, struct S_FF)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_FD(void* p0, struct S_FD p1,  void* (*cb)(void*, struct S_FD)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_FP(void* p0, struct S_FP p1,  void* (*cb)(void*, struct S_FP)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_DI(void* p0, struct S_DI p1,  void* (*cb)(void*, struct S_DI)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_DF(void* p0, struct S_DF p1,  void* (*cb)(void*, struct S_DF)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_DD(void* p0, struct S_DD p1,  void* (*cb)(void*, struct S_DD)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_DP(void* p0, struct S_DP p1,  void* (*cb)(void*, struct S_DP)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_PI(void* p0, struct S_PI p1,  void* (*cb)(void*, struct S_PI)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_PF(void* p0, struct S_PF p1,  void* (*cb)(void*, struct S_PF)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_PD(void* p0, struct S_PD p1,  void* (*cb)(void*, struct S_PD)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_PP(void* p0, struct S_PP p1,  void* (*cb)(void*, struct S_PP)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_III(void* p0, struct S_III p1,  void* (*cb)(void*, struct S_III)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_IIF(void* p0, struct S_IIF p1,  void* (*cb)(void*, struct S_IIF)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_IID(void* p0, struct S_IID p1,  void* (*cb)(void*, struct S_IID)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_IIP(void* p0, struct S_IIP p1,  void* (*cb)(void*, struct S_IIP)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_IFI(void* p0, struct S_IFI p1,  void* (*cb)(void*, struct S_IFI)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_IFF(void* p0, struct S_IFF p1,  void* (*cb)(void*, struct S_IFF)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_IFD(void* p0, struct S_IFD p1,  void* (*cb)(void*, struct S_IFD)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_IFP(void* p0, struct S_IFP p1,  void* (*cb)(void*, struct S_IFP)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_IDI(void* p0, struct S_IDI p1,  void* (*cb)(void*, struct S_IDI)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_IDF(void* p0, struct S_IDF p1,  void* (*cb)(void*, struct S_IDF)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_IDD(void* p0, struct S_IDD p1,  void* (*cb)(void*, struct S_IDD)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_IDP(void* p0, struct S_IDP p1,  void* (*cb)(void*, struct S_IDP)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_IPI(void* p0, struct S_IPI p1,  void* (*cb)(void*, struct S_IPI)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_IPF(void* p0, struct S_IPF p1,  void* (*cb)(void*, struct S_IPF)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_IPD(void* p0, struct S_IPD p1,  void* (*cb)(void*, struct S_IPD)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_IPP(void* p0, struct S_IPP p1,  void* (*cb)(void*, struct S_IPP)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_FII(void* p0, struct S_FII p1,  void* (*cb)(void*, struct S_FII)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_FIF(void* p0, struct S_FIF p1,  void* (*cb)(void*, struct S_FIF)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_FID(void* p0, struct S_FID p1,  void* (*cb)(void*, struct S_FID)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_FIP(void* p0, struct S_FIP p1,  void* (*cb)(void*, struct S_FIP)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_FFI(void* p0, struct S_FFI p1,  void* (*cb)(void*, struct S_FFI)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_FFF(void* p0, struct S_FFF p1,  void* (*cb)(void*, struct S_FFF)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_FFD(void* p0, struct S_FFD p1,  void* (*cb)(void*, struct S_FFD)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_FFP(void* p0, struct S_FFP p1,  void* (*cb)(void*, struct S_FFP)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_FDI(void* p0, struct S_FDI p1,  void* (*cb)(void*, struct S_FDI)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_FDF(void* p0, struct S_FDF p1,  void* (*cb)(void*, struct S_FDF)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_FDD(void* p0, struct S_FDD p1,  void* (*cb)(void*, struct S_FDD)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_FDP(void* p0, struct S_FDP p1,  void* (*cb)(void*, struct S_FDP)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_FPI(void* p0, struct S_FPI p1,  void* (*cb)(void*, struct S_FPI)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_FPF(void* p0, struct S_FPF p1,  void* (*cb)(void*, struct S_FPF)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_FPD(void* p0, struct S_FPD p1,  void* (*cb)(void*, struct S_FPD)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_FPP(void* p0, struct S_FPP p1,  void* (*cb)(void*, struct S_FPP)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_DII(void* p0, struct S_DII p1,  void* (*cb)(void*, struct S_DII)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_DIF(void* p0, struct S_DIF p1,  void* (*cb)(void*, struct S_DIF)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_DID(void* p0, struct S_DID p1,  void* (*cb)(void*, struct S_DID)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_DIP(void* p0, struct S_DIP p1,  void* (*cb)(void*, struct S_DIP)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_DFI(void* p0, struct S_DFI p1,  void* (*cb)(void*, struct S_DFI)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_DFF(void* p0, struct S_DFF p1,  void* (*cb)(void*, struct S_DFF)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_DFD(void* p0, struct S_DFD p1,  void* (*cb)(void*, struct S_DFD)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_DFP(void* p0, struct S_DFP p1,  void* (*cb)(void*, struct S_DFP)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_DDI(void* p0, struct S_DDI p1,  void* (*cb)(void*, struct S_DDI)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_DDF(void* p0, struct S_DDF p1,  void* (*cb)(void*, struct S_DDF)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_DDD(void* p0, struct S_DDD p1,  void* (*cb)(void*, struct S_DDD)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_DDP(void* p0, struct S_DDP p1,  void* (*cb)(void*, struct S_DDP)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_DPI(void* p0, struct S_DPI p1,  void* (*cb)(void*, struct S_DPI)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_DPF(void* p0, struct S_DPF p1,  void* (*cb)(void*, struct S_DPF)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_DPD(void* p0, struct S_DPD p1,  void* (*cb)(void*, struct S_DPD)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_DPP(void* p0, struct S_DPP p1,  void* (*cb)(void*, struct S_DPP)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_PII(void* p0, struct S_PII p1,  void* (*cb)(void*, struct S_PII)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_PIF(void* p0, struct S_PIF p1,  void* (*cb)(void*, struct S_PIF)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_PID(void* p0, struct S_PID p1,  void* (*cb)(void*, struct S_PID)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_PIP(void* p0, struct S_PIP p1,  void* (*cb)(void*, struct S_PIP)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_PFI(void* p0, struct S_PFI p1,  void* (*cb)(void*, struct S_PFI)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_PFF(void* p0, struct S_PFF p1,  void* (*cb)(void*, struct S_PFF)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_PFD(void* p0, struct S_PFD p1,  void* (*cb)(void*, struct S_PFD)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_PFP(void* p0, struct S_PFP p1,  void* (*cb)(void*, struct S_PFP)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_PDI(void* p0, struct S_PDI p1,  void* (*cb)(void*, struct S_PDI)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_PDF(void* p0, struct S_PDF p1,  void* (*cb)(void*, struct S_PDF)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_PDD(void* p0, struct S_PDD p1,  void* (*cb)(void*, struct S_PDD)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_PDP(void* p0, struct S_PDP p1,  void* (*cb)(void*, struct S_PDP)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_PPI(void* p0, struct S_PPI p1,  void* (*cb)(void*, struct S_PPI)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_PPF(void* p0, struct S_PPF p1,  void* (*cb)(void*, struct S_PPF)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_PPD(void* p0, struct S_PPD p1,  void* (*cb)(void*, struct S_PPD)) { return cb(p0,p1); }
+EXPORT void* f10_P_PS_PPP(void* p0, struct S_PPP p1,  void* (*cb)(void*, struct S_PPP)) { return cb(p0,p1); }
+EXPORT struct S_I f10_S_SI_I(struct S_I p0, int p1,  struct S_I (*cb)(struct S_I, int)) { return cb(p0,p1); }
+EXPORT struct S_F f10_S_SI_F(struct S_F p0, int p1,  struct S_F (*cb)(struct S_F, int)) { return cb(p0,p1); }
+EXPORT struct S_D f10_S_SI_D(struct S_D p0, int p1,  struct S_D (*cb)(struct S_D, int)) { return cb(p0,p1); }
+EXPORT struct S_P f10_S_SI_P(struct S_P p0, int p1,  struct S_P (*cb)(struct S_P, int)) { return cb(p0,p1); }
+EXPORT struct S_II f10_S_SI_II(struct S_II p0, int p1,  struct S_II (*cb)(struct S_II, int)) { return cb(p0,p1); }
+EXPORT struct S_IF f10_S_SI_IF(struct S_IF p0, int p1,  struct S_IF (*cb)(struct S_IF, int)) { return cb(p0,p1); }
+EXPORT struct S_ID f10_S_SI_ID(struct S_ID p0, int p1,  struct S_ID (*cb)(struct S_ID, int)) { return cb(p0,p1); }
+EXPORT struct S_IP f10_S_SI_IP(struct S_IP p0, int p1,  struct S_IP (*cb)(struct S_IP, int)) { return cb(p0,p1); }
+EXPORT struct S_FI f10_S_SI_FI(struct S_FI p0, int p1,  struct S_FI (*cb)(struct S_FI, int)) { return cb(p0,p1); }
+EXPORT struct S_FF f10_S_SI_FF(struct S_FF p0, int p1,  struct S_FF (*cb)(struct S_FF, int)) { return cb(p0,p1); }
+EXPORT struct S_FD f10_S_SI_FD(struct S_FD p0, int p1,  struct S_FD (*cb)(struct S_FD, int)) { return cb(p0,p1); }
+EXPORT struct S_FP f10_S_SI_FP(struct S_FP p0, int p1,  struct S_FP (*cb)(struct S_FP, int)) { return cb(p0,p1); }
+EXPORT struct S_DI f10_S_SI_DI(struct S_DI p0, int p1,  struct S_DI (*cb)(struct S_DI, int)) { return cb(p0,p1); }
+EXPORT struct S_DF f10_S_SI_DF(struct S_DF p0, int p1,  struct S_DF (*cb)(struct S_DF, int)) { return cb(p0,p1); }
+EXPORT struct S_DD f10_S_SI_DD(struct S_DD p0, int p1,  struct S_DD (*cb)(struct S_DD, int)) { return cb(p0,p1); }
+EXPORT struct S_DP f10_S_SI_DP(struct S_DP p0, int p1,  struct S_DP (*cb)(struct S_DP, int)) { return cb(p0,p1); }
+EXPORT struct S_PI f10_S_SI_PI(struct S_PI p0, int p1,  struct S_PI (*cb)(struct S_PI, int)) { return cb(p0,p1); }
+EXPORT struct S_PF f10_S_SI_PF(struct S_PF p0, int p1,  struct S_PF (*cb)(struct S_PF, int)) { return cb(p0,p1); }
+EXPORT struct S_PD f10_S_SI_PD(struct S_PD p0, int p1,  struct S_PD (*cb)(struct S_PD, int)) { return cb(p0,p1); }
+EXPORT struct S_PP f10_S_SI_PP(struct S_PP p0, int p1,  struct S_PP (*cb)(struct S_PP, int)) { return cb(p0,p1); }
+EXPORT struct S_III f10_S_SI_III(struct S_III p0, int p1,  struct S_III (*cb)(struct S_III, int)) { return cb(p0,p1); }
+EXPORT struct S_IIF f10_S_SI_IIF(struct S_IIF p0, int p1,  struct S_IIF (*cb)(struct S_IIF, int)) { return cb(p0,p1); }
+EXPORT struct S_IID f10_S_SI_IID(struct S_IID p0, int p1,  struct S_IID (*cb)(struct S_IID, int)) { return cb(p0,p1); }
+EXPORT struct S_IIP f10_S_SI_IIP(struct S_IIP p0, int p1,  struct S_IIP (*cb)(struct S_IIP, int)) { return cb(p0,p1); }
+EXPORT struct S_IFI f10_S_SI_IFI(struct S_IFI p0, int p1,  struct S_IFI (*cb)(struct S_IFI, int)) { return cb(p0,p1); }
+EXPORT struct S_IFF f10_S_SI_IFF(struct S_IFF p0, int p1,  struct S_IFF (*cb)(struct S_IFF, int)) { return cb(p0,p1); }
+EXPORT struct S_IFD f10_S_SI_IFD(struct S_IFD p0, int p1,  struct S_IFD (*cb)(struct S_IFD, int)) { return cb(p0,p1); }
+EXPORT struct S_IFP f10_S_SI_IFP(struct S_IFP p0, int p1,  struct S_IFP (*cb)(struct S_IFP, int)) { return cb(p0,p1); }
+EXPORT struct S_IDI f10_S_SI_IDI(struct S_IDI p0, int p1,  struct S_IDI (*cb)(struct S_IDI, int)) { return cb(p0,p1); }
+EXPORT struct S_IDF f10_S_SI_IDF(struct S_IDF p0, int p1,  struct S_IDF (*cb)(struct S_IDF, int)) { return cb(p0,p1); }
+EXPORT struct S_IDD f10_S_SI_IDD(struct S_IDD p0, int p1,  struct S_IDD (*cb)(struct S_IDD, int)) { return cb(p0,p1); }
+EXPORT struct S_IDP f10_S_SI_IDP(struct S_IDP p0, int p1,  struct S_IDP (*cb)(struct S_IDP, int)) { return cb(p0,p1); }
+EXPORT struct S_IPI f10_S_SI_IPI(struct S_IPI p0, int p1,  struct S_IPI (*cb)(struct S_IPI, int)) { return cb(p0,p1); }
+EXPORT struct S_IPF f10_S_SI_IPF(struct S_IPF p0, int p1,  struct S_IPF (*cb)(struct S_IPF, int)) { return cb(p0,p1); }
+EXPORT struct S_IPD f10_S_SI_IPD(struct S_IPD p0, int p1,  struct S_IPD (*cb)(struct S_IPD, int)) { return cb(p0,p1); }
+EXPORT struct S_IPP f10_S_SI_IPP(struct S_IPP p0, int p1,  struct S_IPP (*cb)(struct S_IPP, int)) { return cb(p0,p1); }
+EXPORT struct S_FII f10_S_SI_FII(struct S_FII p0, int p1,  struct S_FII (*cb)(struct S_FII, int)) { return cb(p0,p1); }
+EXPORT struct S_FIF f10_S_SI_FIF(struct S_FIF p0, int p1,  struct S_FIF (*cb)(struct S_FIF, int)) { return cb(p0,p1); }
+EXPORT struct S_FID f10_S_SI_FID(struct S_FID p0, int p1,  struct S_FID (*cb)(struct S_FID, int)) { return cb(p0,p1); }
+EXPORT struct S_FIP f10_S_SI_FIP(struct S_FIP p0, int p1,  struct S_FIP (*cb)(struct S_FIP, int)) { return cb(p0,p1); }
+EXPORT struct S_FFI f10_S_SI_FFI(struct S_FFI p0, int p1,  struct S_FFI (*cb)(struct S_FFI, int)) { return cb(p0,p1); }
+EXPORT struct S_FFF f10_S_SI_FFF(struct S_FFF p0, int p1,  struct S_FFF (*cb)(struct S_FFF, int)) { return cb(p0,p1); }
+EXPORT struct S_FFD f10_S_SI_FFD(struct S_FFD p0, int p1,  struct S_FFD (*cb)(struct S_FFD, int)) { return cb(p0,p1); }
+EXPORT struct S_FFP f10_S_SI_FFP(struct S_FFP p0, int p1,  struct S_FFP (*cb)(struct S_FFP, int)) { return cb(p0,p1); }
+EXPORT struct S_FDI f10_S_SI_FDI(struct S_FDI p0, int p1,  struct S_FDI (*cb)(struct S_FDI, int)) { return cb(p0,p1); }
+EXPORT struct S_FDF f10_S_SI_FDF(struct S_FDF p0, int p1,  struct S_FDF (*cb)(struct S_FDF, int)) { return cb(p0,p1); }
+EXPORT struct S_FDD f10_S_SI_FDD(struct S_FDD p0, int p1,  struct S_FDD (*cb)(struct S_FDD, int)) { return cb(p0,p1); }
+EXPORT struct S_FDP f10_S_SI_FDP(struct S_FDP p0, int p1,  struct S_FDP (*cb)(struct S_FDP, int)) { return cb(p0,p1); }
+EXPORT struct S_FPI f10_S_SI_FPI(struct S_FPI p0, int p1,  struct S_FPI (*cb)(struct S_FPI, int)) { return cb(p0,p1); }
+EXPORT struct S_FPF f10_S_SI_FPF(struct S_FPF p0, int p1,  struct S_FPF (*cb)(struct S_FPF, int)) { return cb(p0,p1); }
+EXPORT struct S_FPD f10_S_SI_FPD(struct S_FPD p0, int p1,  struct S_FPD (*cb)(struct S_FPD, int)) { return cb(p0,p1); }
+EXPORT struct S_FPP f10_S_SI_FPP(struct S_FPP p0, int p1,  struct S_FPP (*cb)(struct S_FPP, int)) { return cb(p0,p1); }
+EXPORT struct S_DII f10_S_SI_DII(struct S_DII p0, int p1,  struct S_DII (*cb)(struct S_DII, int)) { return cb(p0,p1); }
+EXPORT struct S_DIF f10_S_SI_DIF(struct S_DIF p0, int p1,  struct S_DIF (*cb)(struct S_DIF, int)) { return cb(p0,p1); }
+EXPORT struct S_DID f10_S_SI_DID(struct S_DID p0, int p1,  struct S_DID (*cb)(struct S_DID, int)) { return cb(p0,p1); }
+EXPORT struct S_DIP f10_S_SI_DIP(struct S_DIP p0, int p1,  struct S_DIP (*cb)(struct S_DIP, int)) { return cb(p0,p1); }
+EXPORT struct S_DFI f10_S_SI_DFI(struct S_DFI p0, int p1,  struct S_DFI (*cb)(struct S_DFI, int)) { return cb(p0,p1); }
+EXPORT struct S_DFF f10_S_SI_DFF(struct S_DFF p0, int p1,  struct S_DFF (*cb)(struct S_DFF, int)) { return cb(p0,p1); }
+EXPORT struct S_DFD f10_S_SI_DFD(struct S_DFD p0, int p1,  struct S_DFD (*cb)(struct S_DFD, int)) { return cb(p0,p1); }
+EXPORT struct S_DFP f10_S_SI_DFP(struct S_DFP p0, int p1,  struct S_DFP (*cb)(struct S_DFP, int)) { return cb(p0,p1); }
+EXPORT struct S_DDI f10_S_SI_DDI(struct S_DDI p0, int p1,  struct S_DDI (*cb)(struct S_DDI, int)) { return cb(p0,p1); }
+EXPORT struct S_DDF f10_S_SI_DDF(struct S_DDF p0, int p1,  struct S_DDF (*cb)(struct S_DDF, int)) { return cb(p0,p1); }
+EXPORT struct S_DDD f10_S_SI_DDD(struct S_DDD p0, int p1,  struct S_DDD (*cb)(struct S_DDD, int)) { return cb(p0,p1); }
+EXPORT struct S_DDP f10_S_SI_DDP(struct S_DDP p0, int p1,  struct S_DDP (*cb)(struct S_DDP, int)) { return cb(p0,p1); }
+EXPORT struct S_DPI f10_S_SI_DPI(struct S_DPI p0, int p1,  struct S_DPI (*cb)(struct S_DPI, int)) { return cb(p0,p1); }
+EXPORT struct S_DPF f10_S_SI_DPF(struct S_DPF p0, int p1,  struct S_DPF (*cb)(struct S_DPF, int)) { return cb(p0,p1); }
+EXPORT struct S_DPD f10_S_SI_DPD(struct S_DPD p0, int p1,  struct S_DPD (*cb)(struct S_DPD, int)) { return cb(p0,p1); }
+EXPORT struct S_DPP f10_S_SI_DPP(struct S_DPP p0, int p1,  struct S_DPP (*cb)(struct S_DPP, int)) { return cb(p0,p1); }
+EXPORT struct S_PII f10_S_SI_PII(struct S_PII p0, int p1,  struct S_PII (*cb)(struct S_PII, int)) { return cb(p0,p1); }
+EXPORT struct S_PIF f10_S_SI_PIF(struct S_PIF p0, int p1,  struct S_PIF (*cb)(struct S_PIF, int)) { return cb(p0,p1); }
+EXPORT struct S_PID f10_S_SI_PID(struct S_PID p0, int p1,  struct S_PID (*cb)(struct S_PID, int)) { return cb(p0,p1); }
+EXPORT struct S_PIP f10_S_SI_PIP(struct S_PIP p0, int p1,  struct S_PIP (*cb)(struct S_PIP, int)) { return cb(p0,p1); }
+EXPORT struct S_PFI f10_S_SI_PFI(struct S_PFI p0, int p1,  struct S_PFI (*cb)(struct S_PFI, int)) { return cb(p0,p1); }
+EXPORT struct S_PFF f10_S_SI_PFF(struct S_PFF p0, int p1,  struct S_PFF (*cb)(struct S_PFF, int)) { return cb(p0,p1); }
+EXPORT struct S_PFD f10_S_SI_PFD(struct S_PFD p0, int p1,  struct S_PFD (*cb)(struct S_PFD, int)) { return cb(p0,p1); }
+EXPORT struct S_PFP f10_S_SI_PFP(struct S_PFP p0, int p1,  struct S_PFP (*cb)(struct S_PFP, int)) { return cb(p0,p1); }
+EXPORT struct S_PDI f10_S_SI_PDI(struct S_PDI p0, int p1,  struct S_PDI (*cb)(struct S_PDI, int)) { return cb(p0,p1); }
+EXPORT struct S_PDF f10_S_SI_PDF(struct S_PDF p0, int p1,  struct S_PDF (*cb)(struct S_PDF, int)) { return cb(p0,p1); }
+EXPORT struct S_PDD f10_S_SI_PDD(struct S_PDD p0, int p1,  struct S_PDD (*cb)(struct S_PDD, int)) { return cb(p0,p1); }
+EXPORT struct S_PDP f10_S_SI_PDP(struct S_PDP p0, int p1,  struct S_PDP (*cb)(struct S_PDP, int)) { return cb(p0,p1); }
+EXPORT struct S_PPI f10_S_SI_PPI(struct S_PPI p0, int p1,  struct S_PPI (*cb)(struct S_PPI, int)) { return cb(p0,p1); }
+EXPORT struct S_PPF f10_S_SI_PPF(struct S_PPF p0, int p1,  struct S_PPF (*cb)(struct S_PPF, int)) { return cb(p0,p1); }
+EXPORT struct S_PPD f10_S_SI_PPD(struct S_PPD p0, int p1,  struct S_PPD (*cb)(struct S_PPD, int)) { return cb(p0,p1); }
+EXPORT struct S_PPP f10_S_SI_PPP(struct S_PPP p0, int p1,  struct S_PPP (*cb)(struct S_PPP, int)) { return cb(p0,p1); }
+EXPORT struct S_I f10_S_SF_I(struct S_I p0, float p1,  struct S_I (*cb)(struct S_I, float)) { return cb(p0,p1); }
+EXPORT struct S_F f10_S_SF_F(struct S_F p0, float p1,  struct S_F (*cb)(struct S_F, float)) { return cb(p0,p1); }
+EXPORT struct S_D f10_S_SF_D(struct S_D p0, float p1,  struct S_D (*cb)(struct S_D, float)) { return cb(p0,p1); }
+EXPORT struct S_P f10_S_SF_P(struct S_P p0, float p1,  struct S_P (*cb)(struct S_P, float)) { return cb(p0,p1); }
+EXPORT struct S_II f10_S_SF_II(struct S_II p0, float p1,  struct S_II (*cb)(struct S_II, float)) { return cb(p0,p1); }
+EXPORT struct S_IF f10_S_SF_IF(struct S_IF p0, float p1,  struct S_IF (*cb)(struct S_IF, float)) { return cb(p0,p1); }
+EXPORT struct S_ID f10_S_SF_ID(struct S_ID p0, float p1,  struct S_ID (*cb)(struct S_ID, float)) { return cb(p0,p1); }
+EXPORT struct S_IP f10_S_SF_IP(struct S_IP p0, float p1,  struct S_IP (*cb)(struct S_IP, float)) { return cb(p0,p1); }
+EXPORT struct S_FI f10_S_SF_FI(struct S_FI p0, float p1,  struct S_FI (*cb)(struct S_FI, float)) { return cb(p0,p1); }
+EXPORT struct S_FF f10_S_SF_FF(struct S_FF p0, float p1,  struct S_FF (*cb)(struct S_FF, float)) { return cb(p0,p1); }
+EXPORT struct S_FD f10_S_SF_FD(struct S_FD p0, float p1,  struct S_FD (*cb)(struct S_FD, float)) { return cb(p0,p1); }
+EXPORT struct S_FP f10_S_SF_FP(struct S_FP p0, float p1,  struct S_FP (*cb)(struct S_FP, float)) { return cb(p0,p1); }
+EXPORT struct S_DI f10_S_SF_DI(struct S_DI p0, float p1,  struct S_DI (*cb)(struct S_DI, float)) { return cb(p0,p1); }
+EXPORT struct S_DF f10_S_SF_DF(struct S_DF p0, float p1,  struct S_DF (*cb)(struct S_DF, float)) { return cb(p0,p1); }
+EXPORT struct S_DD f10_S_SF_DD(struct S_DD p0, float p1,  struct S_DD (*cb)(struct S_DD, float)) { return cb(p0,p1); }
+EXPORT struct S_DP f10_S_SF_DP(struct S_DP p0, float p1,  struct S_DP (*cb)(struct S_DP, float)) { return cb(p0,p1); }
+EXPORT struct S_PI f10_S_SF_PI(struct S_PI p0, float p1,  struct S_PI (*cb)(struct S_PI, float)) { return cb(p0,p1); }
+EXPORT struct S_PF f10_S_SF_PF(struct S_PF p0, float p1,  struct S_PF (*cb)(struct S_PF, float)) { return cb(p0,p1); }
+EXPORT struct S_PD f10_S_SF_PD(struct S_PD p0, float p1,  struct S_PD (*cb)(struct S_PD, float)) { return cb(p0,p1); }
+EXPORT struct S_PP f10_S_SF_PP(struct S_PP p0, float p1,  struct S_PP (*cb)(struct S_PP, float)) { return cb(p0,p1); }
+EXPORT struct S_III f10_S_SF_III(struct S_III p0, float p1,  struct S_III (*cb)(struct S_III, float)) { return cb(p0,p1); }
+EXPORT struct S_IIF f10_S_SF_IIF(struct S_IIF p0, float p1,  struct S_IIF (*cb)(struct S_IIF, float)) { return cb(p0,p1); }
+EXPORT struct S_IID f10_S_SF_IID(struct S_IID p0, float p1,  struct S_IID (*cb)(struct S_IID, float)) { return cb(p0,p1); }
+EXPORT struct S_IIP f10_S_SF_IIP(struct S_IIP p0, float p1,  struct S_IIP (*cb)(struct S_IIP, float)) { return cb(p0,p1); }
+EXPORT struct S_IFI f10_S_SF_IFI(struct S_IFI p0, float p1,  struct S_IFI (*cb)(struct S_IFI, float)) { return cb(p0,p1); }
+EXPORT struct S_IFF f10_S_SF_IFF(struct S_IFF p0, float p1,  struct S_IFF (*cb)(struct S_IFF, float)) { return cb(p0,p1); }
+EXPORT struct S_IFD f10_S_SF_IFD(struct S_IFD p0, float p1,  struct S_IFD (*cb)(struct S_IFD, float)) { return cb(p0,p1); }
+EXPORT struct S_IFP f11_S_SF_IFP(struct S_IFP p0, float p1,  struct S_IFP (*cb)(struct S_IFP, float)) { return cb(p0,p1); }
+EXPORT struct S_IDI f11_S_SF_IDI(struct S_IDI p0, float p1,  struct S_IDI (*cb)(struct S_IDI, float)) { return cb(p0,p1); }
+EXPORT struct S_IDF f11_S_SF_IDF(struct S_IDF p0, float p1,  struct S_IDF (*cb)(struct S_IDF, float)) { return cb(p0,p1); }
+EXPORT struct S_IDD f11_S_SF_IDD(struct S_IDD p0, float p1,  struct S_IDD (*cb)(struct S_IDD, float)) { return cb(p0,p1); }
+EXPORT struct S_IDP f11_S_SF_IDP(struct S_IDP p0, float p1,  struct S_IDP (*cb)(struct S_IDP, float)) { return cb(p0,p1); }
+EXPORT struct S_IPI f11_S_SF_IPI(struct S_IPI p0, float p1,  struct S_IPI (*cb)(struct S_IPI, float)) { return cb(p0,p1); }
+EXPORT struct S_IPF f11_S_SF_IPF(struct S_IPF p0, float p1,  struct S_IPF (*cb)(struct S_IPF, float)) { return cb(p0,p1); }
+EXPORT struct S_IPD f11_S_SF_IPD(struct S_IPD p0, float p1,  struct S_IPD (*cb)(struct S_IPD, float)) { return cb(p0,p1); }
+EXPORT struct S_IPP f11_S_SF_IPP(struct S_IPP p0, float p1,  struct S_IPP (*cb)(struct S_IPP, float)) { return cb(p0,p1); }
+EXPORT struct S_FII f11_S_SF_FII(struct S_FII p0, float p1,  struct S_FII (*cb)(struct S_FII, float)) { return cb(p0,p1); }
+EXPORT struct S_FIF f11_S_SF_FIF(struct S_FIF p0, float p1,  struct S_FIF (*cb)(struct S_FIF, float)) { return cb(p0,p1); }
+EXPORT struct S_FID f11_S_SF_FID(struct S_FID p0, float p1,  struct S_FID (*cb)(struct S_FID, float)) { return cb(p0,p1); }
+EXPORT struct S_FIP f11_S_SF_FIP(struct S_FIP p0, float p1,  struct S_FIP (*cb)(struct S_FIP, float)) { return cb(p0,p1); }
+EXPORT struct S_FFI f11_S_SF_FFI(struct S_FFI p0, float p1,  struct S_FFI (*cb)(struct S_FFI, float)) { return cb(p0,p1); }
+EXPORT struct S_FFF f11_S_SF_FFF(struct S_FFF p0, float p1,  struct S_FFF (*cb)(struct S_FFF, float)) { return cb(p0,p1); }
+EXPORT struct S_FFD f11_S_SF_FFD(struct S_FFD p0, float p1,  struct S_FFD (*cb)(struct S_FFD, float)) { return cb(p0,p1); }
+EXPORT struct S_FFP f11_S_SF_FFP(struct S_FFP p0, float p1,  struct S_FFP (*cb)(struct S_FFP, float)) { return cb(p0,p1); }
+EXPORT struct S_FDI f11_S_SF_FDI(struct S_FDI p0, float p1,  struct S_FDI (*cb)(struct S_FDI, float)) { return cb(p0,p1); }
+EXPORT struct S_FDF f11_S_SF_FDF(struct S_FDF p0, float p1,  struct S_FDF (*cb)(struct S_FDF, float)) { return cb(p0,p1); }
+EXPORT struct S_FDD f11_S_SF_FDD(struct S_FDD p0, float p1,  struct S_FDD (*cb)(struct S_FDD, float)) { return cb(p0,p1); }
+EXPORT struct S_FDP f11_S_SF_FDP(struct S_FDP p0, float p1,  struct S_FDP (*cb)(struct S_FDP, float)) { return cb(p0,p1); }
+EXPORT struct S_FPI f11_S_SF_FPI(struct S_FPI p0, float p1,  struct S_FPI (*cb)(struct S_FPI, float)) { return cb(p0,p1); }
+EXPORT struct S_FPF f11_S_SF_FPF(struct S_FPF p0, float p1,  struct S_FPF (*cb)(struct S_FPF, float)) { return cb(p0,p1); }
+EXPORT struct S_FPD f11_S_SF_FPD(struct S_FPD p0, float p1,  struct S_FPD (*cb)(struct S_FPD, float)) { return cb(p0,p1); }
+EXPORT struct S_FPP f11_S_SF_FPP(struct S_FPP p0, float p1,  struct S_FPP (*cb)(struct S_FPP, float)) { return cb(p0,p1); }
+EXPORT struct S_DII f11_S_SF_DII(struct S_DII p0, float p1,  struct S_DII (*cb)(struct S_DII, float)) { return cb(p0,p1); }
+EXPORT struct S_DIF f11_S_SF_DIF(struct S_DIF p0, float p1,  struct S_DIF (*cb)(struct S_DIF, float)) { return cb(p0,p1); }
+EXPORT struct S_DID f11_S_SF_DID(struct S_DID p0, float p1,  struct S_DID (*cb)(struct S_DID, float)) { return cb(p0,p1); }
+EXPORT struct S_DIP f11_S_SF_DIP(struct S_DIP p0, float p1,  struct S_DIP (*cb)(struct S_DIP, float)) { return cb(p0,p1); }
+EXPORT struct S_DFI f11_S_SF_DFI(struct S_DFI p0, float p1,  struct S_DFI (*cb)(struct S_DFI, float)) { return cb(p0,p1); }
+EXPORT struct S_DFF f11_S_SF_DFF(struct S_DFF p0, float p1,  struct S_DFF (*cb)(struct S_DFF, float)) { return cb(p0,p1); }
+EXPORT struct S_DFD f11_S_SF_DFD(struct S_DFD p0, float p1,  struct S_DFD (*cb)(struct S_DFD, float)) { return cb(p0,p1); }
+EXPORT struct S_DFP f11_S_SF_DFP(struct S_DFP p0, float p1,  struct S_DFP (*cb)(struct S_DFP, float)) { return cb(p0,p1); }
+EXPORT struct S_DDI f11_S_SF_DDI(struct S_DDI p0, float p1,  struct S_DDI (*cb)(struct S_DDI, float)) { return cb(p0,p1); }
+EXPORT struct S_DDF f11_S_SF_DDF(struct S_DDF p0, float p1,  struct S_DDF (*cb)(struct S_DDF, float)) { return cb(p0,p1); }
+EXPORT struct S_DDD f11_S_SF_DDD(struct S_DDD p0, float p1,  struct S_DDD (*cb)(struct S_DDD, float)) { return cb(p0,p1); }
+EXPORT struct S_DDP f11_S_SF_DDP(struct S_DDP p0, float p1,  struct S_DDP (*cb)(struct S_DDP, float)) { return cb(p0,p1); }
+EXPORT struct S_DPI f11_S_SF_DPI(struct S_DPI p0, float p1,  struct S_DPI (*cb)(struct S_DPI, float)) { return cb(p0,p1); }
+EXPORT struct S_DPF f11_S_SF_DPF(struct S_DPF p0, float p1,  struct S_DPF (*cb)(struct S_DPF, float)) { return cb(p0,p1); }
+EXPORT struct S_DPD f11_S_SF_DPD(struct S_DPD p0, float p1,  struct S_DPD (*cb)(struct S_DPD, float)) { return cb(p0,p1); }
+EXPORT struct S_DPP f11_S_SF_DPP(struct S_DPP p0, float p1,  struct S_DPP (*cb)(struct S_DPP, float)) { return cb(p0,p1); }
+EXPORT struct S_PII f11_S_SF_PII(struct S_PII p0, float p1,  struct S_PII (*cb)(struct S_PII, float)) { return cb(p0,p1); }
+EXPORT struct S_PIF f11_S_SF_PIF(struct S_PIF p0, float p1,  struct S_PIF (*cb)(struct S_PIF, float)) { return cb(p0,p1); }
+EXPORT struct S_PID f11_S_SF_PID(struct S_PID p0, float p1,  struct S_PID (*cb)(struct S_PID, float)) { return cb(p0,p1); }
+EXPORT struct S_PIP f11_S_SF_PIP(struct S_PIP p0, float p1,  struct S_PIP (*cb)(struct S_PIP, float)) { return cb(p0,p1); }
+EXPORT struct S_PFI f11_S_SF_PFI(struct S_PFI p0, float p1,  struct S_PFI (*cb)(struct S_PFI, float)) { return cb(p0,p1); }
+EXPORT struct S_PFF f11_S_SF_PFF(struct S_PFF p0, float p1,  struct S_PFF (*cb)(struct S_PFF, float)) { return cb(p0,p1); }
+EXPORT struct S_PFD f11_S_SF_PFD(struct S_PFD p0, float p1,  struct S_PFD (*cb)(struct S_PFD, float)) { return cb(p0,p1); }
+EXPORT struct S_PFP f11_S_SF_PFP(struct S_PFP p0, float p1,  struct S_PFP (*cb)(struct S_PFP, float)) { return cb(p0,p1); }
+EXPORT struct S_PDI f11_S_SF_PDI(struct S_PDI p0, float p1,  struct S_PDI (*cb)(struct S_PDI, float)) { return cb(p0,p1); }
+EXPORT struct S_PDF f11_S_SF_PDF(struct S_PDF p0, float p1,  struct S_PDF (*cb)(struct S_PDF, float)) { return cb(p0,p1); }
+EXPORT struct S_PDD f11_S_SF_PDD(struct S_PDD p0, float p1,  struct S_PDD (*cb)(struct S_PDD, float)) { return cb(p0,p1); }
+EXPORT struct S_PDP f11_S_SF_PDP(struct S_PDP p0, float p1,  struct S_PDP (*cb)(struct S_PDP, float)) { return cb(p0,p1); }
+EXPORT struct S_PPI f11_S_SF_PPI(struct S_PPI p0, float p1,  struct S_PPI (*cb)(struct S_PPI, float)) { return cb(p0,p1); }
+EXPORT struct S_PPF f11_S_SF_PPF(struct S_PPF p0, float p1,  struct S_PPF (*cb)(struct S_PPF, float)) { return cb(p0,p1); }
+EXPORT struct S_PPD f11_S_SF_PPD(struct S_PPD p0, float p1,  struct S_PPD (*cb)(struct S_PPD, float)) { return cb(p0,p1); }
+EXPORT struct S_PPP f11_S_SF_PPP(struct S_PPP p0, float p1,  struct S_PPP (*cb)(struct S_PPP, float)) { return cb(p0,p1); }
+EXPORT struct S_I f11_S_SD_I(struct S_I p0, double p1,  struct S_I (*cb)(struct S_I, double)) { return cb(p0,p1); }
+EXPORT struct S_F f11_S_SD_F(struct S_F p0, double p1,  struct S_F (*cb)(struct S_F, double)) { return cb(p0,p1); }
+EXPORT struct S_D f11_S_SD_D(struct S_D p0, double p1,  struct S_D (*cb)(struct S_D, double)) { return cb(p0,p1); }
+EXPORT struct S_P f11_S_SD_P(struct S_P p0, double p1,  struct S_P (*cb)(struct S_P, double)) { return cb(p0,p1); }
+EXPORT struct S_II f11_S_SD_II(struct S_II p0, double p1,  struct S_II (*cb)(struct S_II, double)) { return cb(p0,p1); }
+EXPORT struct S_IF f11_S_SD_IF(struct S_IF p0, double p1,  struct S_IF (*cb)(struct S_IF, double)) { return cb(p0,p1); }
+EXPORT struct S_ID f11_S_SD_ID(struct S_ID p0, double p1,  struct S_ID (*cb)(struct S_ID, double)) { return cb(p0,p1); }
+EXPORT struct S_IP f11_S_SD_IP(struct S_IP p0, double p1,  struct S_IP (*cb)(struct S_IP, double)) { return cb(p0,p1); }
+EXPORT struct S_FI f11_S_SD_FI(struct S_FI p0, double p1,  struct S_FI (*cb)(struct S_FI, double)) { return cb(p0,p1); }
+EXPORT struct S_FF f11_S_SD_FF(struct S_FF p0, double p1,  struct S_FF (*cb)(struct S_FF, double)) { return cb(p0,p1); }
+EXPORT struct S_FD f11_S_SD_FD(struct S_FD p0, double p1,  struct S_FD (*cb)(struct S_FD, double)) { return cb(p0,p1); }
+EXPORT struct S_FP f11_S_SD_FP(struct S_FP p0, double p1,  struct S_FP (*cb)(struct S_FP, double)) { return cb(p0,p1); }
+EXPORT struct S_DI f11_S_SD_DI(struct S_DI p0, double p1,  struct S_DI (*cb)(struct S_DI, double)) { return cb(p0,p1); }
+EXPORT struct S_DF f11_S_SD_DF(struct S_DF p0, double p1,  struct S_DF (*cb)(struct S_DF, double)) { return cb(p0,p1); }
+EXPORT struct S_DD f11_S_SD_DD(struct S_DD p0, double p1,  struct S_DD (*cb)(struct S_DD, double)) { return cb(p0,p1); }
+EXPORT struct S_DP f11_S_SD_DP(struct S_DP p0, double p1,  struct S_DP (*cb)(struct S_DP, double)) { return cb(p0,p1); }
+EXPORT struct S_PI f11_S_SD_PI(struct S_PI p0, double p1,  struct S_PI (*cb)(struct S_PI, double)) { return cb(p0,p1); }
+EXPORT struct S_PF f11_S_SD_PF(struct S_PF p0, double p1,  struct S_PF (*cb)(struct S_PF, double)) { return cb(p0,p1); }
+EXPORT struct S_PD f11_S_SD_PD(struct S_PD p0, double p1,  struct S_PD (*cb)(struct S_PD, double)) { return cb(p0,p1); }
+EXPORT struct S_PP f11_S_SD_PP(struct S_PP p0, double p1,  struct S_PP (*cb)(struct S_PP, double)) { return cb(p0,p1); }
+EXPORT struct S_III f11_S_SD_III(struct S_III p0, double p1,  struct S_III (*cb)(struct S_III, double)) { return cb(p0,p1); }
+EXPORT struct S_IIF f11_S_SD_IIF(struct S_IIF p0, double p1,  struct S_IIF (*cb)(struct S_IIF, double)) { return cb(p0,p1); }
+EXPORT struct S_IID f11_S_SD_IID(struct S_IID p0, double p1,  struct S_IID (*cb)(struct S_IID, double)) { return cb(p0,p1); }
+EXPORT struct S_IIP f11_S_SD_IIP(struct S_IIP p0, double p1,  struct S_IIP (*cb)(struct S_IIP, double)) { return cb(p0,p1); }
+EXPORT struct S_IFI f11_S_SD_IFI(struct S_IFI p0, double p1,  struct S_IFI (*cb)(struct S_IFI, double)) { return cb(p0,p1); }
+EXPORT struct S_IFF f11_S_SD_IFF(struct S_IFF p0, double p1,  struct S_IFF (*cb)(struct S_IFF, double)) { return cb(p0,p1); }
+EXPORT struct S_IFD f11_S_SD_IFD(struct S_IFD p0, double p1,  struct S_IFD (*cb)(struct S_IFD, double)) { return cb(p0,p1); }
+EXPORT struct S_IFP f11_S_SD_IFP(struct S_IFP p0, double p1,  struct S_IFP (*cb)(struct S_IFP, double)) { return cb(p0,p1); }
+EXPORT struct S_IDI f11_S_SD_IDI(struct S_IDI p0, double p1,  struct S_IDI (*cb)(struct S_IDI, double)) { return cb(p0,p1); }
+EXPORT struct S_IDF f11_S_SD_IDF(struct S_IDF p0, double p1,  struct S_IDF (*cb)(struct S_IDF, double)) { return cb(p0,p1); }
+EXPORT struct S_IDD f11_S_SD_IDD(struct S_IDD p0, double p1,  struct S_IDD (*cb)(struct S_IDD, double)) { return cb(p0,p1); }
+EXPORT struct S_IDP f11_S_SD_IDP(struct S_IDP p0, double p1,  struct S_IDP (*cb)(struct S_IDP, double)) { return cb(p0,p1); }
+EXPORT struct S_IPI f11_S_SD_IPI(struct S_IPI p0, double p1,  struct S_IPI (*cb)(struct S_IPI, double)) { return cb(p0,p1); }
+EXPORT struct S_IPF f11_S_SD_IPF(struct S_IPF p0, double p1,  struct S_IPF (*cb)(struct S_IPF, double)) { return cb(p0,p1); }
+EXPORT struct S_IPD f11_S_SD_IPD(struct S_IPD p0, double p1,  struct S_IPD (*cb)(struct S_IPD, double)) { return cb(p0,p1); }
+EXPORT struct S_IPP f11_S_SD_IPP(struct S_IPP p0, double p1,  struct S_IPP (*cb)(struct S_IPP, double)) { return cb(p0,p1); }
+EXPORT struct S_FII f11_S_SD_FII(struct S_FII p0, double p1,  struct S_FII (*cb)(struct S_FII, double)) { return cb(p0,p1); }
+EXPORT struct S_FIF f11_S_SD_FIF(struct S_FIF p0, double p1,  struct S_FIF (*cb)(struct S_FIF, double)) { return cb(p0,p1); }
+EXPORT struct S_FID f11_S_SD_FID(struct S_FID p0, double p1,  struct S_FID (*cb)(struct S_FID, double)) { return cb(p0,p1); }
+EXPORT struct S_FIP f11_S_SD_FIP(struct S_FIP p0, double p1,  struct S_FIP (*cb)(struct S_FIP, double)) { return cb(p0,p1); }
+EXPORT struct S_FFI f11_S_SD_FFI(struct S_FFI p0, double p1,  struct S_FFI (*cb)(struct S_FFI, double)) { return cb(p0,p1); }
+EXPORT struct S_FFF f11_S_SD_FFF(struct S_FFF p0, double p1,  struct S_FFF (*cb)(struct S_FFF, double)) { return cb(p0,p1); }
+EXPORT struct S_FFD f11_S_SD_FFD(struct S_FFD p0, double p1,  struct S_FFD (*cb)(struct S_FFD, double)) { return cb(p0,p1); }
+EXPORT struct S_FFP f11_S_SD_FFP(struct S_FFP p0, double p1,  struct S_FFP (*cb)(struct S_FFP, double)) { return cb(p0,p1); }
+EXPORT struct S_FDI f11_S_SD_FDI(struct S_FDI p0, double p1,  struct S_FDI (*cb)(struct S_FDI, double)) { return cb(p0,p1); }
+EXPORT struct S_FDF f11_S_SD_FDF(struct S_FDF p0, double p1,  struct S_FDF (*cb)(struct S_FDF, double)) { return cb(p0,p1); }
+EXPORT struct S_FDD f11_S_SD_FDD(struct S_FDD p0, double p1,  struct S_FDD (*cb)(struct S_FDD, double)) { return cb(p0,p1); }
+EXPORT struct S_FDP f11_S_SD_FDP(struct S_FDP p0, double p1,  struct S_FDP (*cb)(struct S_FDP, double)) { return cb(p0,p1); }
+EXPORT struct S_FPI f11_S_SD_FPI(struct S_FPI p0, double p1,  struct S_FPI (*cb)(struct S_FPI, double)) { return cb(p0,p1); }
+EXPORT struct S_FPF f11_S_SD_FPF(struct S_FPF p0, double p1,  struct S_FPF (*cb)(struct S_FPF, double)) { return cb(p0,p1); }
+EXPORT struct S_FPD f11_S_SD_FPD(struct S_FPD p0, double p1,  struct S_FPD (*cb)(struct S_FPD, double)) { return cb(p0,p1); }
+EXPORT struct S_FPP f11_S_SD_FPP(struct S_FPP p0, double p1,  struct S_FPP (*cb)(struct S_FPP, double)) { return cb(p0,p1); }
+EXPORT struct S_DII f11_S_SD_DII(struct S_DII p0, double p1,  struct S_DII (*cb)(struct S_DII, double)) { return cb(p0,p1); }
+EXPORT struct S_DIF f11_S_SD_DIF(struct S_DIF p0, double p1,  struct S_DIF (*cb)(struct S_DIF, double)) { return cb(p0,p1); }
+EXPORT struct S_DID f11_S_SD_DID(struct S_DID p0, double p1,  struct S_DID (*cb)(struct S_DID, double)) { return cb(p0,p1); }
+EXPORT struct S_DIP f11_S_SD_DIP(struct S_DIP p0, double p1,  struct S_DIP (*cb)(struct S_DIP, double)) { return cb(p0,p1); }
+EXPORT struct S_DFI f11_S_SD_DFI(struct S_DFI p0, double p1,  struct S_DFI (*cb)(struct S_DFI, double)) { return cb(p0,p1); }
+EXPORT struct S_DFF f11_S_SD_DFF(struct S_DFF p0, double p1,  struct S_DFF (*cb)(struct S_DFF, double)) { return cb(p0,p1); }
+EXPORT struct S_DFD f11_S_SD_DFD(struct S_DFD p0, double p1,  struct S_DFD (*cb)(struct S_DFD, double)) { return cb(p0,p1); }
+EXPORT struct S_DFP f11_S_SD_DFP(struct S_DFP p0, double p1,  struct S_DFP (*cb)(struct S_DFP, double)) { return cb(p0,p1); }
+EXPORT struct S_DDI f11_S_SD_DDI(struct S_DDI p0, double p1,  struct S_DDI (*cb)(struct S_DDI, double)) { return cb(p0,p1); }
+EXPORT struct S_DDF f11_S_SD_DDF(struct S_DDF p0, double p1,  struct S_DDF (*cb)(struct S_DDF, double)) { return cb(p0,p1); }
+EXPORT struct S_DDD f11_S_SD_DDD(struct S_DDD p0, double p1,  struct S_DDD (*cb)(struct S_DDD, double)) { return cb(p0,p1); }
+EXPORT struct S_DDP f11_S_SD_DDP(struct S_DDP p0, double p1,  struct S_DDP (*cb)(struct S_DDP, double)) { return cb(p0,p1); }
+EXPORT struct S_DPI f11_S_SD_DPI(struct S_DPI p0, double p1,  struct S_DPI (*cb)(struct S_DPI, double)) { return cb(p0,p1); }
+EXPORT struct S_DPF f11_S_SD_DPF(struct S_DPF p0, double p1,  struct S_DPF (*cb)(struct S_DPF, double)) { return cb(p0,p1); }
+EXPORT struct S_DPD f11_S_SD_DPD(struct S_DPD p0, double p1,  struct S_DPD (*cb)(struct S_DPD, double)) { return cb(p0,p1); }
+EXPORT struct S_DPP f11_S_SD_DPP(struct S_DPP p0, double p1,  struct S_DPP (*cb)(struct S_DPP, double)) { return cb(p0,p1); }
+EXPORT struct S_PII f11_S_SD_PII(struct S_PII p0, double p1,  struct S_PII (*cb)(struct S_PII, double)) { return cb(p0,p1); }
+EXPORT struct S_PIF f11_S_SD_PIF(struct S_PIF p0, double p1,  struct S_PIF (*cb)(struct S_PIF, double)) { return cb(p0,p1); }
+EXPORT struct S_PID f11_S_SD_PID(struct S_PID p0, double p1,  struct S_PID (*cb)(struct S_PID, double)) { return cb(p0,p1); }
+EXPORT struct S_PIP f11_S_SD_PIP(struct S_PIP p0, double p1,  struct S_PIP (*cb)(struct S_PIP, double)) { return cb(p0,p1); }
+EXPORT struct S_PFI f11_S_SD_PFI(struct S_PFI p0, double p1,  struct S_PFI (*cb)(struct S_PFI, double)) { return cb(p0,p1); }
+EXPORT struct S_PFF f11_S_SD_PFF(struct S_PFF p0, double p1,  struct S_PFF (*cb)(struct S_PFF, double)) { return cb(p0,p1); }
+EXPORT struct S_PFD f11_S_SD_PFD(struct S_PFD p0, double p1,  struct S_PFD (*cb)(struct S_PFD, double)) { return cb(p0,p1); }
+EXPORT struct S_PFP f11_S_SD_PFP(struct S_PFP p0, double p1,  struct S_PFP (*cb)(struct S_PFP, double)) { return cb(p0,p1); }
+EXPORT struct S_PDI f11_S_SD_PDI(struct S_PDI p0, double p1,  struct S_PDI (*cb)(struct S_PDI, double)) { return cb(p0,p1); }
+EXPORT struct S_PDF f11_S_SD_PDF(struct S_PDF p0, double p1,  struct S_PDF (*cb)(struct S_PDF, double)) { return cb(p0,p1); }
+EXPORT struct S_PDD f11_S_SD_PDD(struct S_PDD p0, double p1,  struct S_PDD (*cb)(struct S_PDD, double)) { return cb(p0,p1); }
+EXPORT struct S_PDP f11_S_SD_PDP(struct S_PDP p0, double p1,  struct S_PDP (*cb)(struct S_PDP, double)) { return cb(p0,p1); }
+EXPORT struct S_PPI f11_S_SD_PPI(struct S_PPI p0, double p1,  struct S_PPI (*cb)(struct S_PPI, double)) { return cb(p0,p1); }
+EXPORT struct S_PPF f11_S_SD_PPF(struct S_PPF p0, double p1,  struct S_PPF (*cb)(struct S_PPF, double)) { return cb(p0,p1); }
+EXPORT struct S_PPD f11_S_SD_PPD(struct S_PPD p0, double p1,  struct S_PPD (*cb)(struct S_PPD, double)) { return cb(p0,p1); }
+EXPORT struct S_PPP f11_S_SD_PPP(struct S_PPP p0, double p1,  struct S_PPP (*cb)(struct S_PPP, double)) { return cb(p0,p1); }
+EXPORT struct S_I f11_S_SP_I(struct S_I p0, void* p1,  struct S_I (*cb)(struct S_I, void*)) { return cb(p0,p1); }
+EXPORT struct S_F f11_S_SP_F(struct S_F p0, void* p1,  struct S_F (*cb)(struct S_F, void*)) { return cb(p0,p1); }
+EXPORT struct S_D f11_S_SP_D(struct S_D p0, void* p1,  struct S_D (*cb)(struct S_D, void*)) { return cb(p0,p1); }
+EXPORT struct S_P f11_S_SP_P(struct S_P p0, void* p1,  struct S_P (*cb)(struct S_P, void*)) { return cb(p0,p1); }
+EXPORT struct S_II f11_S_SP_II(struct S_II p0, void* p1,  struct S_II (*cb)(struct S_II, void*)) { return cb(p0,p1); }
+EXPORT struct S_IF f11_S_SP_IF(struct S_IF p0, void* p1,  struct S_IF (*cb)(struct S_IF, void*)) { return cb(p0,p1); }
+EXPORT struct S_ID f11_S_SP_ID(struct S_ID p0, void* p1,  struct S_ID (*cb)(struct S_ID, void*)) { return cb(p0,p1); }
+EXPORT struct S_IP f11_S_SP_IP(struct S_IP p0, void* p1,  struct S_IP (*cb)(struct S_IP, void*)) { return cb(p0,p1); }
+EXPORT struct S_FI f11_S_SP_FI(struct S_FI p0, void* p1,  struct S_FI (*cb)(struct S_FI, void*)) { return cb(p0,p1); }
+EXPORT struct S_FF f11_S_SP_FF(struct S_FF p0, void* p1,  struct S_FF (*cb)(struct S_FF, void*)) { return cb(p0,p1); }
+EXPORT struct S_FD f11_S_SP_FD(struct S_FD p0, void* p1,  struct S_FD (*cb)(struct S_FD, void*)) { return cb(p0,p1); }
+EXPORT struct S_FP f11_S_SP_FP(struct S_FP p0, void* p1,  struct S_FP (*cb)(struct S_FP, void*)) { return cb(p0,p1); }
+EXPORT struct S_DI f11_S_SP_DI(struct S_DI p0, void* p1,  struct S_DI (*cb)(struct S_DI, void*)) { return cb(p0,p1); }
+EXPORT struct S_DF f11_S_SP_DF(struct S_DF p0, void* p1,  struct S_DF (*cb)(struct S_DF, void*)) { return cb(p0,p1); }
+EXPORT struct S_DD f11_S_SP_DD(struct S_DD p0, void* p1,  struct S_DD (*cb)(struct S_DD, void*)) { return cb(p0,p1); }
+EXPORT struct S_DP f11_S_SP_DP(struct S_DP p0, void* p1,  struct S_DP (*cb)(struct S_DP, void*)) { return cb(p0,p1); }
+EXPORT struct S_PI f11_S_SP_PI(struct S_PI p0, void* p1,  struct S_PI (*cb)(struct S_PI, void*)) { return cb(p0,p1); }
+EXPORT struct S_PF f11_S_SP_PF(struct S_PF p0, void* p1,  struct S_PF (*cb)(struct S_PF, void*)) { return cb(p0,p1); }
+EXPORT struct S_PD f11_S_SP_PD(struct S_PD p0, void* p1,  struct S_PD (*cb)(struct S_PD, void*)) { return cb(p0,p1); }
+EXPORT struct S_PP f11_S_SP_PP(struct S_PP p0, void* p1,  struct S_PP (*cb)(struct S_PP, void*)) { return cb(p0,p1); }
+EXPORT struct S_III f11_S_SP_III(struct S_III p0, void* p1,  struct S_III (*cb)(struct S_III, void*)) { return cb(p0,p1); }
+EXPORT struct S_IIF f11_S_SP_IIF(struct S_IIF p0, void* p1,  struct S_IIF (*cb)(struct S_IIF, void*)) { return cb(p0,p1); }
+EXPORT struct S_IID f11_S_SP_IID(struct S_IID p0, void* p1,  struct S_IID (*cb)(struct S_IID, void*)) { return cb(p0,p1); }
+EXPORT struct S_IIP f11_S_SP_IIP(struct S_IIP p0, void* p1,  struct S_IIP (*cb)(struct S_IIP, void*)) { return cb(p0,p1); }
+EXPORT struct S_IFI f11_S_SP_IFI(struct S_IFI p0, void* p1,  struct S_IFI (*cb)(struct S_IFI, void*)) { return cb(p0,p1); }
+EXPORT struct S_IFF f11_S_SP_IFF(struct S_IFF p0, void* p1,  struct S_IFF (*cb)(struct S_IFF, void*)) { return cb(p0,p1); }
+EXPORT struct S_IFD f11_S_SP_IFD(struct S_IFD p0, void* p1,  struct S_IFD (*cb)(struct S_IFD, void*)) { return cb(p0,p1); }
+EXPORT struct S_IFP f11_S_SP_IFP(struct S_IFP p0, void* p1,  struct S_IFP (*cb)(struct S_IFP, void*)) { return cb(p0,p1); }
+EXPORT struct S_IDI f11_S_SP_IDI(struct S_IDI p0, void* p1,  struct S_IDI (*cb)(struct S_IDI, void*)) { return cb(p0,p1); }
+EXPORT struct S_IDF f11_S_SP_IDF(struct S_IDF p0, void* p1,  struct S_IDF (*cb)(struct S_IDF, void*)) { return cb(p0,p1); }
+EXPORT struct S_IDD f11_S_SP_IDD(struct S_IDD p0, void* p1,  struct S_IDD (*cb)(struct S_IDD, void*)) { return cb(p0,p1); }
+EXPORT struct S_IDP f11_S_SP_IDP(struct S_IDP p0, void* p1,  struct S_IDP (*cb)(struct S_IDP, void*)) { return cb(p0,p1); }
+EXPORT struct S_IPI f11_S_SP_IPI(struct S_IPI p0, void* p1,  struct S_IPI (*cb)(struct S_IPI, void*)) { return cb(p0,p1); }
+EXPORT struct S_IPF f11_S_SP_IPF(struct S_IPF p0, void* p1,  struct S_IPF (*cb)(struct S_IPF, void*)) { return cb(p0,p1); }
+EXPORT struct S_IPD f11_S_SP_IPD(struct S_IPD p0, void* p1,  struct S_IPD (*cb)(struct S_IPD, void*)) { return cb(p0,p1); }
+EXPORT struct S_IPP f11_S_SP_IPP(struct S_IPP p0, void* p1,  struct S_IPP (*cb)(struct S_IPP, void*)) { return cb(p0,p1); }
+EXPORT struct S_FII f11_S_SP_FII(struct S_FII p0, void* p1,  struct S_FII (*cb)(struct S_FII, void*)) { return cb(p0,p1); }
+EXPORT struct S_FIF f11_S_SP_FIF(struct S_FIF p0, void* p1,  struct S_FIF (*cb)(struct S_FIF, void*)) { return cb(p0,p1); }
+EXPORT struct S_FID f11_S_SP_FID(struct S_FID p0, void* p1,  struct S_FID (*cb)(struct S_FID, void*)) { return cb(p0,p1); }
+EXPORT struct S_FIP f11_S_SP_FIP(struct S_FIP p0, void* p1,  struct S_FIP (*cb)(struct S_FIP, void*)) { return cb(p0,p1); }
+EXPORT struct S_FFI f11_S_SP_FFI(struct S_FFI p0, void* p1,  struct S_FFI (*cb)(struct S_FFI, void*)) { return cb(p0,p1); }
+EXPORT struct S_FFF f11_S_SP_FFF(struct S_FFF p0, void* p1,  struct S_FFF (*cb)(struct S_FFF, void*)) { return cb(p0,p1); }
+EXPORT struct S_FFD f11_S_SP_FFD(struct S_FFD p0, void* p1,  struct S_FFD (*cb)(struct S_FFD, void*)) { return cb(p0,p1); }
+EXPORT struct S_FFP f11_S_SP_FFP(struct S_FFP p0, void* p1,  struct S_FFP (*cb)(struct S_FFP, void*)) { return cb(p0,p1); }
+EXPORT struct S_FDI f11_S_SP_FDI(struct S_FDI p0, void* p1,  struct S_FDI (*cb)(struct S_FDI, void*)) { return cb(p0,p1); }
+EXPORT struct S_FDF f11_S_SP_FDF(struct S_FDF p0, void* p1,  struct S_FDF (*cb)(struct S_FDF, void*)) { return cb(p0,p1); }
+EXPORT struct S_FDD f11_S_SP_FDD(struct S_FDD p0, void* p1,  struct S_FDD (*cb)(struct S_FDD, void*)) { return cb(p0,p1); }
+EXPORT struct S_FDP f11_S_SP_FDP(struct S_FDP p0, void* p1,  struct S_FDP (*cb)(struct S_FDP, void*)) { return cb(p0,p1); }
+EXPORT struct S_FPI f11_S_SP_FPI(struct S_FPI p0, void* p1,  struct S_FPI (*cb)(struct S_FPI, void*)) { return cb(p0,p1); }
+EXPORT struct S_FPF f11_S_SP_FPF(struct S_FPF p0, void* p1,  struct S_FPF (*cb)(struct S_FPF, void*)) { return cb(p0,p1); }
+EXPORT struct S_FPD f11_S_SP_FPD(struct S_FPD p0, void* p1,  struct S_FPD (*cb)(struct S_FPD, void*)) { return cb(p0,p1); }
+EXPORT struct S_FPP f11_S_SP_FPP(struct S_FPP p0, void* p1,  struct S_FPP (*cb)(struct S_FPP, void*)) { return cb(p0,p1); }
+EXPORT struct S_DII f11_S_SP_DII(struct S_DII p0, void* p1,  struct S_DII (*cb)(struct S_DII, void*)) { return cb(p0,p1); }
+EXPORT struct S_DIF f11_S_SP_DIF(struct S_DIF p0, void* p1,  struct S_DIF (*cb)(struct S_DIF, void*)) { return cb(p0,p1); }
+EXPORT struct S_DID f11_S_SP_DID(struct S_DID p0, void* p1,  struct S_DID (*cb)(struct S_DID, void*)) { return cb(p0,p1); }
+EXPORT struct S_DIP f11_S_SP_DIP(struct S_DIP p0, void* p1,  struct S_DIP (*cb)(struct S_DIP, void*)) { return cb(p0,p1); }
+EXPORT struct S_DFI f11_S_SP_DFI(struct S_DFI p0, void* p1,  struct S_DFI (*cb)(struct S_DFI, void*)) { return cb(p0,p1); }
+EXPORT struct S_DFF f11_S_SP_DFF(struct S_DFF p0, void* p1,  struct S_DFF (*cb)(struct S_DFF, void*)) { return cb(p0,p1); }
+EXPORT struct S_DFD f11_S_SP_DFD(struct S_DFD p0, void* p1,  struct S_DFD (*cb)(struct S_DFD, void*)) { return cb(p0,p1); }
+EXPORT struct S_DFP f11_S_SP_DFP(struct S_DFP p0, void* p1,  struct S_DFP (*cb)(struct S_DFP, void*)) { return cb(p0,p1); }
+EXPORT struct S_DDI f11_S_SP_DDI(struct S_DDI p0, void* p1,  struct S_DDI (*cb)(struct S_DDI, void*)) { return cb(p0,p1); }
+EXPORT struct S_DDF f11_S_SP_DDF(struct S_DDF p0, void* p1,  struct S_DDF (*cb)(struct S_DDF, void*)) { return cb(p0,p1); }
+EXPORT struct S_DDD f11_S_SP_DDD(struct S_DDD p0, void* p1,  struct S_DDD (*cb)(struct S_DDD, void*)) { return cb(p0,p1); }
+EXPORT struct S_DDP f11_S_SP_DDP(struct S_DDP p0, void* p1,  struct S_DDP (*cb)(struct S_DDP, void*)) { return cb(p0,p1); }
+EXPORT struct S_DPI f11_S_SP_DPI(struct S_DPI p0, void* p1,  struct S_DPI (*cb)(struct S_DPI, void*)) { return cb(p0,p1); }
+EXPORT struct S_DPF f11_S_SP_DPF(struct S_DPF p0, void* p1,  struct S_DPF (*cb)(struct S_DPF, void*)) { return cb(p0,p1); }
+EXPORT struct S_DPD f11_S_SP_DPD(struct S_DPD p0, void* p1,  struct S_DPD (*cb)(struct S_DPD, void*)) { return cb(p0,p1); }
+EXPORT struct S_DPP f11_S_SP_DPP(struct S_DPP p0, void* p1,  struct S_DPP (*cb)(struct S_DPP, void*)) { return cb(p0,p1); }
+EXPORT struct S_PII f11_S_SP_PII(struct S_PII p0, void* p1,  struct S_PII (*cb)(struct S_PII, void*)) { return cb(p0,p1); }
+EXPORT struct S_PIF f11_S_SP_PIF(struct S_PIF p0, void* p1,  struct S_PIF (*cb)(struct S_PIF, void*)) { return cb(p0,p1); }
+EXPORT struct S_PID f11_S_SP_PID(struct S_PID p0, void* p1,  struct S_PID (*cb)(struct S_PID, void*)) { return cb(p0,p1); }
+EXPORT struct S_PIP f11_S_SP_PIP(struct S_PIP p0, void* p1,  struct S_PIP (*cb)(struct S_PIP, void*)) { return cb(p0,p1); }
+EXPORT struct S_PFI f11_S_SP_PFI(struct S_PFI p0, void* p1,  struct S_PFI (*cb)(struct S_PFI, void*)) { return cb(p0,p1); }
+EXPORT struct S_PFF f11_S_SP_PFF(struct S_PFF p0, void* p1,  struct S_PFF (*cb)(struct S_PFF, void*)) { return cb(p0,p1); }
+EXPORT struct S_PFD f11_S_SP_PFD(struct S_PFD p0, void* p1,  struct S_PFD (*cb)(struct S_PFD, void*)) { return cb(p0,p1); }
+EXPORT struct S_PFP f11_S_SP_PFP(struct S_PFP p0, void* p1,  struct S_PFP (*cb)(struct S_PFP, void*)) { return cb(p0,p1); }
+EXPORT struct S_PDI f11_S_SP_PDI(struct S_PDI p0, void* p1,  struct S_PDI (*cb)(struct S_PDI, void*)) { return cb(p0,p1); }
+EXPORT struct S_PDF f11_S_SP_PDF(struct S_PDF p0, void* p1,  struct S_PDF (*cb)(struct S_PDF, void*)) { return cb(p0,p1); }
+EXPORT struct S_PDD f11_S_SP_PDD(struct S_PDD p0, void* p1,  struct S_PDD (*cb)(struct S_PDD, void*)) { return cb(p0,p1); }
+EXPORT struct S_PDP f11_S_SP_PDP(struct S_PDP p0, void* p1,  struct S_PDP (*cb)(struct S_PDP, void*)) { return cb(p0,p1); }
+EXPORT struct S_PPI f11_S_SP_PPI(struct S_PPI p0, void* p1,  struct S_PPI (*cb)(struct S_PPI, void*)) { return cb(p0,p1); }
+EXPORT struct S_PPF f11_S_SP_PPF(struct S_PPF p0, void* p1,  struct S_PPF (*cb)(struct S_PPF, void*)) { return cb(p0,p1); }
+EXPORT struct S_PPD f11_S_SP_PPD(struct S_PPD p0, void* p1,  struct S_PPD (*cb)(struct S_PPD, void*)) { return cb(p0,p1); }
+EXPORT struct S_PPP f11_S_SP_PPP(struct S_PPP p0, void* p1,  struct S_PPP (*cb)(struct S_PPP, void*)) { return cb(p0,p1); }
+EXPORT struct S_I f11_S_SS_I(struct S_I p0, struct S_I p1,  struct S_I (*cb)(struct S_I, struct S_I)) { return cb(p0,p1); }
+EXPORT struct S_F f11_S_SS_F(struct S_F p0, struct S_F p1,  struct S_F (*cb)(struct S_F, struct S_F)) { return cb(p0,p1); }
+EXPORT struct S_D f11_S_SS_D(struct S_D p0, struct S_D p1,  struct S_D (*cb)(struct S_D, struct S_D)) { return cb(p0,p1); }
+EXPORT struct S_P f11_S_SS_P(struct S_P p0, struct S_P p1,  struct S_P (*cb)(struct S_P, struct S_P)) { return cb(p0,p1); }
+EXPORT struct S_II f11_S_SS_II(struct S_II p0, struct S_II p1,  struct S_II (*cb)(struct S_II, struct S_II)) { return cb(p0,p1); }
+EXPORT struct S_IF f11_S_SS_IF(struct S_IF p0, struct S_IF p1,  struct S_IF (*cb)(struct S_IF, struct S_IF)) { return cb(p0,p1); }
+EXPORT struct S_ID f11_S_SS_ID(struct S_ID p0, struct S_ID p1,  struct S_ID (*cb)(struct S_ID, struct S_ID)) { return cb(p0,p1); }
+EXPORT struct S_IP f11_S_SS_IP(struct S_IP p0, struct S_IP p1,  struct S_IP (*cb)(struct S_IP, struct S_IP)) { return cb(p0,p1); }
+EXPORT struct S_FI f11_S_SS_FI(struct S_FI p0, struct S_FI p1,  struct S_FI (*cb)(struct S_FI, struct S_FI)) { return cb(p0,p1); }
+EXPORT struct S_FF f11_S_SS_FF(struct S_FF p0, struct S_FF p1,  struct S_FF (*cb)(struct S_FF, struct S_FF)) { return cb(p0,p1); }
+EXPORT struct S_FD f11_S_SS_FD(struct S_FD p0, struct S_FD p1,  struct S_FD (*cb)(struct S_FD, struct S_FD)) { return cb(p0,p1); }
+EXPORT struct S_FP f11_S_SS_FP(struct S_FP p0, struct S_FP p1,  struct S_FP (*cb)(struct S_FP, struct S_FP)) { return cb(p0,p1); }
+EXPORT struct S_DI f11_S_SS_DI(struct S_DI p0, struct S_DI p1,  struct S_DI (*cb)(struct S_DI, struct S_DI)) { return cb(p0,p1); }
+EXPORT struct S_DF f11_S_SS_DF(struct S_DF p0, struct S_DF p1,  struct S_DF (*cb)(struct S_DF, struct S_DF)) { return cb(p0,p1); }
+EXPORT struct S_DD f11_S_SS_DD(struct S_DD p0, struct S_DD p1,  struct S_DD (*cb)(struct S_DD, struct S_DD)) { return cb(p0,p1); }
+EXPORT struct S_DP f11_S_SS_DP(struct S_DP p0, struct S_DP p1,  struct S_DP (*cb)(struct S_DP, struct S_DP)) { return cb(p0,p1); }
+EXPORT struct S_PI f11_S_SS_PI(struct S_PI p0, struct S_PI p1,  struct S_PI (*cb)(struct S_PI, struct S_PI)) { return cb(p0,p1); }
+EXPORT struct S_PF f11_S_SS_PF(struct S_PF p0, struct S_PF p1,  struct S_PF (*cb)(struct S_PF, struct S_PF)) { return cb(p0,p1); }
+EXPORT struct S_PD f11_S_SS_PD(struct S_PD p0, struct S_PD p1,  struct S_PD (*cb)(struct S_PD, struct S_PD)) { return cb(p0,p1); }
+EXPORT struct S_PP f11_S_SS_PP(struct S_PP p0, struct S_PP p1,  struct S_PP (*cb)(struct S_PP, struct S_PP)) { return cb(p0,p1); }
+EXPORT struct S_III f11_S_SS_III(struct S_III p0, struct S_III p1,  struct S_III (*cb)(struct S_III, struct S_III)) { return cb(p0,p1); }
+EXPORT struct S_IIF f11_S_SS_IIF(struct S_IIF p0, struct S_IIF p1,  struct S_IIF (*cb)(struct S_IIF, struct S_IIF)) { return cb(p0,p1); }
+EXPORT struct S_IID f11_S_SS_IID(struct S_IID p0, struct S_IID p1,  struct S_IID (*cb)(struct S_IID, struct S_IID)) { return cb(p0,p1); }
+EXPORT struct S_IIP f11_S_SS_IIP(struct S_IIP p0, struct S_IIP p1,  struct S_IIP (*cb)(struct S_IIP, struct S_IIP)) { return cb(p0,p1); }
+EXPORT struct S_IFI f11_S_SS_IFI(struct S_IFI p0, struct S_IFI p1,  struct S_IFI (*cb)(struct S_IFI, struct S_IFI)) { return cb(p0,p1); }
+EXPORT struct S_IFF f11_S_SS_IFF(struct S_IFF p0, struct S_IFF p1,  struct S_IFF (*cb)(struct S_IFF, struct S_IFF)) { return cb(p0,p1); }
+EXPORT struct S_IFD f11_S_SS_IFD(struct S_IFD p0, struct S_IFD p1,  struct S_IFD (*cb)(struct S_IFD, struct S_IFD)) { return cb(p0,p1); }
+EXPORT struct S_IFP f11_S_SS_IFP(struct S_IFP p0, struct S_IFP p1,  struct S_IFP (*cb)(struct S_IFP, struct S_IFP)) { return cb(p0,p1); }
+EXPORT struct S_IDI f11_S_SS_IDI(struct S_IDI p0, struct S_IDI p1,  struct S_IDI (*cb)(struct S_IDI, struct S_IDI)) { return cb(p0,p1); }
+EXPORT struct S_IDF f11_S_SS_IDF(struct S_IDF p0, struct S_IDF p1,  struct S_IDF (*cb)(struct S_IDF, struct S_IDF)) { return cb(p0,p1); }
+EXPORT struct S_IDD f11_S_SS_IDD(struct S_IDD p0, struct S_IDD p1,  struct S_IDD (*cb)(struct S_IDD, struct S_IDD)) { return cb(p0,p1); }
+EXPORT struct S_IDP f11_S_SS_IDP(struct S_IDP p0, struct S_IDP p1,  struct S_IDP (*cb)(struct S_IDP, struct S_IDP)) { return cb(p0,p1); }
+EXPORT struct S_IPI f11_S_SS_IPI(struct S_IPI p0, struct S_IPI p1,  struct S_IPI (*cb)(struct S_IPI, struct S_IPI)) { return cb(p0,p1); }
+EXPORT struct S_IPF f11_S_SS_IPF(struct S_IPF p0, struct S_IPF p1,  struct S_IPF (*cb)(struct S_IPF, struct S_IPF)) { return cb(p0,p1); }
+EXPORT struct S_IPD f11_S_SS_IPD(struct S_IPD p0, struct S_IPD p1,  struct S_IPD (*cb)(struct S_IPD, struct S_IPD)) { return cb(p0,p1); }
+EXPORT struct S_IPP f11_S_SS_IPP(struct S_IPP p0, struct S_IPP p1,  struct S_IPP (*cb)(struct S_IPP, struct S_IPP)) { return cb(p0,p1); }
+EXPORT struct S_FII f11_S_SS_FII(struct S_FII p0, struct S_FII p1,  struct S_FII (*cb)(struct S_FII, struct S_FII)) { return cb(p0,p1); }
+EXPORT struct S_FIF f11_S_SS_FIF(struct S_FIF p0, struct S_FIF p1,  struct S_FIF (*cb)(struct S_FIF, struct S_FIF)) { return cb(p0,p1); }
+EXPORT struct S_FID f11_S_SS_FID(struct S_FID p0, struct S_FID p1,  struct S_FID (*cb)(struct S_FID, struct S_FID)) { return cb(p0,p1); }
+EXPORT struct S_FIP f11_S_SS_FIP(struct S_FIP p0, struct S_FIP p1,  struct S_FIP (*cb)(struct S_FIP, struct S_FIP)) { return cb(p0,p1); }
+EXPORT struct S_FFI f11_S_SS_FFI(struct S_FFI p0, struct S_FFI p1,  struct S_FFI (*cb)(struct S_FFI, struct S_FFI)) { return cb(p0,p1); }
+EXPORT struct S_FFF f11_S_SS_FFF(struct S_FFF p0, struct S_FFF p1,  struct S_FFF (*cb)(struct S_FFF, struct S_FFF)) { return cb(p0,p1); }
+EXPORT struct S_FFD f11_S_SS_FFD(struct S_FFD p0, struct S_FFD p1,  struct S_FFD (*cb)(struct S_FFD, struct S_FFD)) { return cb(p0,p1); }
+EXPORT struct S_FFP f11_S_SS_FFP(struct S_FFP p0, struct S_FFP p1,  struct S_FFP (*cb)(struct S_FFP, struct S_FFP)) { return cb(p0,p1); }
+EXPORT struct S_FDI f11_S_SS_FDI(struct S_FDI p0, struct S_FDI p1,  struct S_FDI (*cb)(struct S_FDI, struct S_FDI)) { return cb(p0,p1); }
+EXPORT struct S_FDF f11_S_SS_FDF(struct S_FDF p0, struct S_FDF p1,  struct S_FDF (*cb)(struct S_FDF, struct S_FDF)) { return cb(p0,p1); }
+EXPORT struct S_FDD f11_S_SS_FDD(struct S_FDD p0, struct S_FDD p1,  struct S_FDD (*cb)(struct S_FDD, struct S_FDD)) { return cb(p0,p1); }
+EXPORT struct S_FDP f11_S_SS_FDP(struct S_FDP p0, struct S_FDP p1,  struct S_FDP (*cb)(struct S_FDP, struct S_FDP)) { return cb(p0,p1); }
+EXPORT struct S_FPI f11_S_SS_FPI(struct S_FPI p0, struct S_FPI p1,  struct S_FPI (*cb)(struct S_FPI, struct S_FPI)) { return cb(p0,p1); }
+EXPORT struct S_FPF f11_S_SS_FPF(struct S_FPF p0, struct S_FPF p1,  struct S_FPF (*cb)(struct S_FPF, struct S_FPF)) { return cb(p0,p1); }
+EXPORT struct S_FPD f11_S_SS_FPD(struct S_FPD p0, struct S_FPD p1,  struct S_FPD (*cb)(struct S_FPD, struct S_FPD)) { return cb(p0,p1); }
+EXPORT struct S_FPP f11_S_SS_FPP(struct S_FPP p0, struct S_FPP p1,  struct S_FPP (*cb)(struct S_FPP, struct S_FPP)) { return cb(p0,p1); }
+EXPORT struct S_DII f11_S_SS_DII(struct S_DII p0, struct S_DII p1,  struct S_DII (*cb)(struct S_DII, struct S_DII)) { return cb(p0,p1); }
+EXPORT struct S_DIF f11_S_SS_DIF(struct S_DIF p0, struct S_DIF p1,  struct S_DIF (*cb)(struct S_DIF, struct S_DIF)) { return cb(p0,p1); }
+EXPORT struct S_DID f11_S_SS_DID(struct S_DID p0, struct S_DID p1,  struct S_DID (*cb)(struct S_DID, struct S_DID)) { return cb(p0,p1); }
+EXPORT struct S_DIP f11_S_SS_DIP(struct S_DIP p0, struct S_DIP p1,  struct S_DIP (*cb)(struct S_DIP, struct S_DIP)) { return cb(p0,p1); }
+EXPORT struct S_DFI f11_S_SS_DFI(struct S_DFI p0, struct S_DFI p1,  struct S_DFI (*cb)(struct S_DFI, struct S_DFI)) { return cb(p0,p1); }
+EXPORT struct S_DFF f11_S_SS_DFF(struct S_DFF p0, struct S_DFF p1,  struct S_DFF (*cb)(struct S_DFF, struct S_DFF)) { return cb(p0,p1); }
+EXPORT struct S_DFD f11_S_SS_DFD(struct S_DFD p0, struct S_DFD p1,  struct S_DFD (*cb)(struct S_DFD, struct S_DFD)) { return cb(p0,p1); }
+EXPORT struct S_DFP f11_S_SS_DFP(struct S_DFP p0, struct S_DFP p1,  struct S_DFP (*cb)(struct S_DFP, struct S_DFP)) { return cb(p0,p1); }
+EXPORT struct S_DDI f11_S_SS_DDI(struct S_DDI p0, struct S_DDI p1,  struct S_DDI (*cb)(struct S_DDI, struct S_DDI)) { return cb(p0,p1); }
+EXPORT struct S_DDF f11_S_SS_DDF(struct S_DDF p0, struct S_DDF p1,  struct S_DDF (*cb)(struct S_DDF, struct S_DDF)) { return cb(p0,p1); }
+EXPORT struct S_DDD f11_S_SS_DDD(struct S_DDD p0, struct S_DDD p1,  struct S_DDD (*cb)(struct S_DDD, struct S_DDD)) { return cb(p0,p1); }
+EXPORT struct S_DDP f11_S_SS_DDP(struct S_DDP p0, struct S_DDP p1,  struct S_DDP (*cb)(struct S_DDP, struct S_DDP)) { return cb(p0,p1); }
+EXPORT struct S_DPI f11_S_SS_DPI(struct S_DPI p0, struct S_DPI p1,  struct S_DPI (*cb)(struct S_DPI, struct S_DPI)) { return cb(p0,p1); }
+EXPORT struct S_DPF f11_S_SS_DPF(struct S_DPF p0, struct S_DPF p1,  struct S_DPF (*cb)(struct S_DPF, struct S_DPF)) { return cb(p0,p1); }
+EXPORT struct S_DPD f11_S_SS_DPD(struct S_DPD p0, struct S_DPD p1,  struct S_DPD (*cb)(struct S_DPD, struct S_DPD)) { return cb(p0,p1); }
+EXPORT struct S_DPP f11_S_SS_DPP(struct S_DPP p0, struct S_DPP p1,  struct S_DPP (*cb)(struct S_DPP, struct S_DPP)) { return cb(p0,p1); }
+EXPORT struct S_PII f11_S_SS_PII(struct S_PII p0, struct S_PII p1,  struct S_PII (*cb)(struct S_PII, struct S_PII)) { return cb(p0,p1); }
+EXPORT struct S_PIF f11_S_SS_PIF(struct S_PIF p0, struct S_PIF p1,  struct S_PIF (*cb)(struct S_PIF, struct S_PIF)) { return cb(p0,p1); }
+EXPORT struct S_PID f11_S_SS_PID(struct S_PID p0, struct S_PID p1,  struct S_PID (*cb)(struct S_PID, struct S_PID)) { return cb(p0,p1); }
+EXPORT struct S_PIP f11_S_SS_PIP(struct S_PIP p0, struct S_PIP p1,  struct S_PIP (*cb)(struct S_PIP, struct S_PIP)) { return cb(p0,p1); }
+EXPORT struct S_PFI f11_S_SS_PFI(struct S_PFI p0, struct S_PFI p1,  struct S_PFI (*cb)(struct S_PFI, struct S_PFI)) { return cb(p0,p1); }
+EXPORT struct S_PFF f11_S_SS_PFF(struct S_PFF p0, struct S_PFF p1,  struct S_PFF (*cb)(struct S_PFF, struct S_PFF)) { return cb(p0,p1); }
+EXPORT struct S_PFD f11_S_SS_PFD(struct S_PFD p0, struct S_PFD p1,  struct S_PFD (*cb)(struct S_PFD, struct S_PFD)) { return cb(p0,p1); }
+EXPORT struct S_PFP f11_S_SS_PFP(struct S_PFP p0, struct S_PFP p1,  struct S_PFP (*cb)(struct S_PFP, struct S_PFP)) { return cb(p0,p1); }
+EXPORT struct S_PDI f11_S_SS_PDI(struct S_PDI p0, struct S_PDI p1,  struct S_PDI (*cb)(struct S_PDI, struct S_PDI)) { return cb(p0,p1); }
+EXPORT struct S_PDF f11_S_SS_PDF(struct S_PDF p0, struct S_PDF p1,  struct S_PDF (*cb)(struct S_PDF, struct S_PDF)) { return cb(p0,p1); }
+EXPORT struct S_PDD f11_S_SS_PDD(struct S_PDD p0, struct S_PDD p1,  struct S_PDD (*cb)(struct S_PDD, struct S_PDD)) { return cb(p0,p1); }
+EXPORT struct S_PDP f11_S_SS_PDP(struct S_PDP p0, struct S_PDP p1,  struct S_PDP (*cb)(struct S_PDP, struct S_PDP)) { return cb(p0,p1); }
+EXPORT struct S_PPI f11_S_SS_PPI(struct S_PPI p0, struct S_PPI p1,  struct S_PPI (*cb)(struct S_PPI, struct S_PPI)) { return cb(p0,p1); }
+EXPORT struct S_PPF f11_S_SS_PPF(struct S_PPF p0, struct S_PPF p1,  struct S_PPF (*cb)(struct S_PPF, struct S_PPF)) { return cb(p0,p1); }
+EXPORT struct S_PPD f11_S_SS_PPD(struct S_PPD p0, struct S_PPD p1,  struct S_PPD (*cb)(struct S_PPD, struct S_PPD)) { return cb(p0,p1); }
+EXPORT struct S_PPP f11_S_SS_PPP(struct S_PPP p0, struct S_PPP p1,  struct S_PPP (*cb)(struct S_PPP, struct S_PPP)) { return cb(p0,p1); }
+EXPORT int f11_I_III_(int p0, int p1, int p2,  int (*cb)(int, int, int)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIF_(int p0, int p1, float p2,  int (*cb)(int, int, float)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IID_(int p0, int p1, double p2,  int (*cb)(int, int, double)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIP_(int p0, int p1, void* p2,  int (*cb)(int, int, void*)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_I(int p0, int p1, struct S_I p2,  int (*cb)(int, int, struct S_I)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_F(int p0, int p1, struct S_F p2,  int (*cb)(int, int, struct S_F)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_D(int p0, int p1, struct S_D p2,  int (*cb)(int, int, struct S_D)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_P(int p0, int p1, struct S_P p2,  int (*cb)(int, int, struct S_P)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_II(int p0, int p1, struct S_II p2,  int (*cb)(int, int, struct S_II)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_IF(int p0, int p1, struct S_IF p2,  int (*cb)(int, int, struct S_IF)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_ID(int p0, int p1, struct S_ID p2,  int (*cb)(int, int, struct S_ID)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_IP(int p0, int p1, struct S_IP p2,  int (*cb)(int, int, struct S_IP)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_FI(int p0, int p1, struct S_FI p2,  int (*cb)(int, int, struct S_FI)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_FF(int p0, int p1, struct S_FF p2,  int (*cb)(int, int, struct S_FF)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_FD(int p0, int p1, struct S_FD p2,  int (*cb)(int, int, struct S_FD)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_FP(int p0, int p1, struct S_FP p2,  int (*cb)(int, int, struct S_FP)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_DI(int p0, int p1, struct S_DI p2,  int (*cb)(int, int, struct S_DI)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_DF(int p0, int p1, struct S_DF p2,  int (*cb)(int, int, struct S_DF)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_DD(int p0, int p1, struct S_DD p2,  int (*cb)(int, int, struct S_DD)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_DP(int p0, int p1, struct S_DP p2,  int (*cb)(int, int, struct S_DP)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_PI(int p0, int p1, struct S_PI p2,  int (*cb)(int, int, struct S_PI)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_PF(int p0, int p1, struct S_PF p2,  int (*cb)(int, int, struct S_PF)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_PD(int p0, int p1, struct S_PD p2,  int (*cb)(int, int, struct S_PD)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_PP(int p0, int p1, struct S_PP p2,  int (*cb)(int, int, struct S_PP)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_III(int p0, int p1, struct S_III p2,  int (*cb)(int, int, struct S_III)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_IIF(int p0, int p1, struct S_IIF p2,  int (*cb)(int, int, struct S_IIF)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_IID(int p0, int p1, struct S_IID p2,  int (*cb)(int, int, struct S_IID)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_IIP(int p0, int p1, struct S_IIP p2,  int (*cb)(int, int, struct S_IIP)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_IFI(int p0, int p1, struct S_IFI p2,  int (*cb)(int, int, struct S_IFI)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_IFF(int p0, int p1, struct S_IFF p2,  int (*cb)(int, int, struct S_IFF)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_IFD(int p0, int p1, struct S_IFD p2,  int (*cb)(int, int, struct S_IFD)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_IFP(int p0, int p1, struct S_IFP p2,  int (*cb)(int, int, struct S_IFP)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_IDI(int p0, int p1, struct S_IDI p2,  int (*cb)(int, int, struct S_IDI)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_IDF(int p0, int p1, struct S_IDF p2,  int (*cb)(int, int, struct S_IDF)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_IDD(int p0, int p1, struct S_IDD p2,  int (*cb)(int, int, struct S_IDD)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_IDP(int p0, int p1, struct S_IDP p2,  int (*cb)(int, int, struct S_IDP)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_IPI(int p0, int p1, struct S_IPI p2,  int (*cb)(int, int, struct S_IPI)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_IPF(int p0, int p1, struct S_IPF p2,  int (*cb)(int, int, struct S_IPF)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_IPD(int p0, int p1, struct S_IPD p2,  int (*cb)(int, int, struct S_IPD)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_IPP(int p0, int p1, struct S_IPP p2,  int (*cb)(int, int, struct S_IPP)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_FII(int p0, int p1, struct S_FII p2,  int (*cb)(int, int, struct S_FII)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_FIF(int p0, int p1, struct S_FIF p2,  int (*cb)(int, int, struct S_FIF)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_FID(int p0, int p1, struct S_FID p2,  int (*cb)(int, int, struct S_FID)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_FIP(int p0, int p1, struct S_FIP p2,  int (*cb)(int, int, struct S_FIP)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_FFI(int p0, int p1, struct S_FFI p2,  int (*cb)(int, int, struct S_FFI)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_FFF(int p0, int p1, struct S_FFF p2,  int (*cb)(int, int, struct S_FFF)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_FFD(int p0, int p1, struct S_FFD p2,  int (*cb)(int, int, struct S_FFD)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_FFP(int p0, int p1, struct S_FFP p2,  int (*cb)(int, int, struct S_FFP)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_FDI(int p0, int p1, struct S_FDI p2,  int (*cb)(int, int, struct S_FDI)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_FDF(int p0, int p1, struct S_FDF p2,  int (*cb)(int, int, struct S_FDF)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_FDD(int p0, int p1, struct S_FDD p2,  int (*cb)(int, int, struct S_FDD)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_FDP(int p0, int p1, struct S_FDP p2,  int (*cb)(int, int, struct S_FDP)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_FPI(int p0, int p1, struct S_FPI p2,  int (*cb)(int, int, struct S_FPI)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_FPF(int p0, int p1, struct S_FPF p2,  int (*cb)(int, int, struct S_FPF)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_FPD(int p0, int p1, struct S_FPD p2,  int (*cb)(int, int, struct S_FPD)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_FPP(int p0, int p1, struct S_FPP p2,  int (*cb)(int, int, struct S_FPP)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_DII(int p0, int p1, struct S_DII p2,  int (*cb)(int, int, struct S_DII)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_DIF(int p0, int p1, struct S_DIF p2,  int (*cb)(int, int, struct S_DIF)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_DID(int p0, int p1, struct S_DID p2,  int (*cb)(int, int, struct S_DID)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_DIP(int p0, int p1, struct S_DIP p2,  int (*cb)(int, int, struct S_DIP)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_DFI(int p0, int p1, struct S_DFI p2,  int (*cb)(int, int, struct S_DFI)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_DFF(int p0, int p1, struct S_DFF p2,  int (*cb)(int, int, struct S_DFF)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_DFD(int p0, int p1, struct S_DFD p2,  int (*cb)(int, int, struct S_DFD)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_DFP(int p0, int p1, struct S_DFP p2,  int (*cb)(int, int, struct S_DFP)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_DDI(int p0, int p1, struct S_DDI p2,  int (*cb)(int, int, struct S_DDI)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_DDF(int p0, int p1, struct S_DDF p2,  int (*cb)(int, int, struct S_DDF)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_DDD(int p0, int p1, struct S_DDD p2,  int (*cb)(int, int, struct S_DDD)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_DDP(int p0, int p1, struct S_DDP p2,  int (*cb)(int, int, struct S_DDP)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_DPI(int p0, int p1, struct S_DPI p2,  int (*cb)(int, int, struct S_DPI)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_DPF(int p0, int p1, struct S_DPF p2,  int (*cb)(int, int, struct S_DPF)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_DPD(int p0, int p1, struct S_DPD p2,  int (*cb)(int, int, struct S_DPD)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_DPP(int p0, int p1, struct S_DPP p2,  int (*cb)(int, int, struct S_DPP)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_PII(int p0, int p1, struct S_PII p2,  int (*cb)(int, int, struct S_PII)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_PIF(int p0, int p1, struct S_PIF p2,  int (*cb)(int, int, struct S_PIF)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_PID(int p0, int p1, struct S_PID p2,  int (*cb)(int, int, struct S_PID)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_PIP(int p0, int p1, struct S_PIP p2,  int (*cb)(int, int, struct S_PIP)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_PFI(int p0, int p1, struct S_PFI p2,  int (*cb)(int, int, struct S_PFI)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_PFF(int p0, int p1, struct S_PFF p2,  int (*cb)(int, int, struct S_PFF)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_PFD(int p0, int p1, struct S_PFD p2,  int (*cb)(int, int, struct S_PFD)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_PFP(int p0, int p1, struct S_PFP p2,  int (*cb)(int, int, struct S_PFP)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_PDI(int p0, int p1, struct S_PDI p2,  int (*cb)(int, int, struct S_PDI)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_PDF(int p0, int p1, struct S_PDF p2,  int (*cb)(int, int, struct S_PDF)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_PDD(int p0, int p1, struct S_PDD p2,  int (*cb)(int, int, struct S_PDD)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_PDP(int p0, int p1, struct S_PDP p2,  int (*cb)(int, int, struct S_PDP)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_PPI(int p0, int p1, struct S_PPI p2,  int (*cb)(int, int, struct S_PPI)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_PPF(int p0, int p1, struct S_PPF p2,  int (*cb)(int, int, struct S_PPF)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_PPD(int p0, int p1, struct S_PPD p2,  int (*cb)(int, int, struct S_PPD)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IIS_PPP(int p0, int p1, struct S_PPP p2,  int (*cb)(int, int, struct S_PPP)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFI_(int p0, float p1, int p2,  int (*cb)(int, float, int)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFF_(int p0, float p1, float p2,  int (*cb)(int, float, float)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFD_(int p0, float p1, double p2,  int (*cb)(int, float, double)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFP_(int p0, float p1, void* p2,  int (*cb)(int, float, void*)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_I(int p0, float p1, struct S_I p2,  int (*cb)(int, float, struct S_I)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_F(int p0, float p1, struct S_F p2,  int (*cb)(int, float, struct S_F)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_D(int p0, float p1, struct S_D p2,  int (*cb)(int, float, struct S_D)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_P(int p0, float p1, struct S_P p2,  int (*cb)(int, float, struct S_P)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_II(int p0, float p1, struct S_II p2,  int (*cb)(int, float, struct S_II)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_IF(int p0, float p1, struct S_IF p2,  int (*cb)(int, float, struct S_IF)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_ID(int p0, float p1, struct S_ID p2,  int (*cb)(int, float, struct S_ID)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_IP(int p0, float p1, struct S_IP p2,  int (*cb)(int, float, struct S_IP)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_FI(int p0, float p1, struct S_FI p2,  int (*cb)(int, float, struct S_FI)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_FF(int p0, float p1, struct S_FF p2,  int (*cb)(int, float, struct S_FF)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_FD(int p0, float p1, struct S_FD p2,  int (*cb)(int, float, struct S_FD)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_FP(int p0, float p1, struct S_FP p2,  int (*cb)(int, float, struct S_FP)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_DI(int p0, float p1, struct S_DI p2,  int (*cb)(int, float, struct S_DI)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_DF(int p0, float p1, struct S_DF p2,  int (*cb)(int, float, struct S_DF)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_DD(int p0, float p1, struct S_DD p2,  int (*cb)(int, float, struct S_DD)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_DP(int p0, float p1, struct S_DP p2,  int (*cb)(int, float, struct S_DP)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_PI(int p0, float p1, struct S_PI p2,  int (*cb)(int, float, struct S_PI)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_PF(int p0, float p1, struct S_PF p2,  int (*cb)(int, float, struct S_PF)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_PD(int p0, float p1, struct S_PD p2,  int (*cb)(int, float, struct S_PD)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_PP(int p0, float p1, struct S_PP p2,  int (*cb)(int, float, struct S_PP)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_III(int p0, float p1, struct S_III p2,  int (*cb)(int, float, struct S_III)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_IIF(int p0, float p1, struct S_IIF p2,  int (*cb)(int, float, struct S_IIF)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_IID(int p0, float p1, struct S_IID p2,  int (*cb)(int, float, struct S_IID)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_IIP(int p0, float p1, struct S_IIP p2,  int (*cb)(int, float, struct S_IIP)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_IFI(int p0, float p1, struct S_IFI p2,  int (*cb)(int, float, struct S_IFI)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_IFF(int p0, float p1, struct S_IFF p2,  int (*cb)(int, float, struct S_IFF)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_IFD(int p0, float p1, struct S_IFD p2,  int (*cb)(int, float, struct S_IFD)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_IFP(int p0, float p1, struct S_IFP p2,  int (*cb)(int, float, struct S_IFP)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_IDI(int p0, float p1, struct S_IDI p2,  int (*cb)(int, float, struct S_IDI)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_IDF(int p0, float p1, struct S_IDF p2,  int (*cb)(int, float, struct S_IDF)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_IDD(int p0, float p1, struct S_IDD p2,  int (*cb)(int, float, struct S_IDD)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_IDP(int p0, float p1, struct S_IDP p2,  int (*cb)(int, float, struct S_IDP)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_IPI(int p0, float p1, struct S_IPI p2,  int (*cb)(int, float, struct S_IPI)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_IPF(int p0, float p1, struct S_IPF p2,  int (*cb)(int, float, struct S_IPF)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_IPD(int p0, float p1, struct S_IPD p2,  int (*cb)(int, float, struct S_IPD)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_IPP(int p0, float p1, struct S_IPP p2,  int (*cb)(int, float, struct S_IPP)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_FII(int p0, float p1, struct S_FII p2,  int (*cb)(int, float, struct S_FII)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_FIF(int p0, float p1, struct S_FIF p2,  int (*cb)(int, float, struct S_FIF)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_FID(int p0, float p1, struct S_FID p2,  int (*cb)(int, float, struct S_FID)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_FIP(int p0, float p1, struct S_FIP p2,  int (*cb)(int, float, struct S_FIP)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_FFI(int p0, float p1, struct S_FFI p2,  int (*cb)(int, float, struct S_FFI)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_FFF(int p0, float p1, struct S_FFF p2,  int (*cb)(int, float, struct S_FFF)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_FFD(int p0, float p1, struct S_FFD p2,  int (*cb)(int, float, struct S_FFD)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_FFP(int p0, float p1, struct S_FFP p2,  int (*cb)(int, float, struct S_FFP)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_FDI(int p0, float p1, struct S_FDI p2,  int (*cb)(int, float, struct S_FDI)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_FDF(int p0, float p1, struct S_FDF p2,  int (*cb)(int, float, struct S_FDF)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_FDD(int p0, float p1, struct S_FDD p2,  int (*cb)(int, float, struct S_FDD)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_FDP(int p0, float p1, struct S_FDP p2,  int (*cb)(int, float, struct S_FDP)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_FPI(int p0, float p1, struct S_FPI p2,  int (*cb)(int, float, struct S_FPI)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_FPF(int p0, float p1, struct S_FPF p2,  int (*cb)(int, float, struct S_FPF)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_FPD(int p0, float p1, struct S_FPD p2,  int (*cb)(int, float, struct S_FPD)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_FPP(int p0, float p1, struct S_FPP p2,  int (*cb)(int, float, struct S_FPP)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_DII(int p0, float p1, struct S_DII p2,  int (*cb)(int, float, struct S_DII)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_DIF(int p0, float p1, struct S_DIF p2,  int (*cb)(int, float, struct S_DIF)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_DID(int p0, float p1, struct S_DID p2,  int (*cb)(int, float, struct S_DID)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_DIP(int p0, float p1, struct S_DIP p2,  int (*cb)(int, float, struct S_DIP)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_DFI(int p0, float p1, struct S_DFI p2,  int (*cb)(int, float, struct S_DFI)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_DFF(int p0, float p1, struct S_DFF p2,  int (*cb)(int, float, struct S_DFF)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_DFD(int p0, float p1, struct S_DFD p2,  int (*cb)(int, float, struct S_DFD)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_DFP(int p0, float p1, struct S_DFP p2,  int (*cb)(int, float, struct S_DFP)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_DDI(int p0, float p1, struct S_DDI p2,  int (*cb)(int, float, struct S_DDI)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_DDF(int p0, float p1, struct S_DDF p2,  int (*cb)(int, float, struct S_DDF)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_DDD(int p0, float p1, struct S_DDD p2,  int (*cb)(int, float, struct S_DDD)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_DDP(int p0, float p1, struct S_DDP p2,  int (*cb)(int, float, struct S_DDP)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_DPI(int p0, float p1, struct S_DPI p2,  int (*cb)(int, float, struct S_DPI)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_DPF(int p0, float p1, struct S_DPF p2,  int (*cb)(int, float, struct S_DPF)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_DPD(int p0, float p1, struct S_DPD p2,  int (*cb)(int, float, struct S_DPD)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_DPP(int p0, float p1, struct S_DPP p2,  int (*cb)(int, float, struct S_DPP)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_PII(int p0, float p1, struct S_PII p2,  int (*cb)(int, float, struct S_PII)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_PIF(int p0, float p1, struct S_PIF p2,  int (*cb)(int, float, struct S_PIF)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_PID(int p0, float p1, struct S_PID p2,  int (*cb)(int, float, struct S_PID)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_PIP(int p0, float p1, struct S_PIP p2,  int (*cb)(int, float, struct S_PIP)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_PFI(int p0, float p1, struct S_PFI p2,  int (*cb)(int, float, struct S_PFI)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_PFF(int p0, float p1, struct S_PFF p2,  int (*cb)(int, float, struct S_PFF)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_PFD(int p0, float p1, struct S_PFD p2,  int (*cb)(int, float, struct S_PFD)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_PFP(int p0, float p1, struct S_PFP p2,  int (*cb)(int, float, struct S_PFP)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_PDI(int p0, float p1, struct S_PDI p2,  int (*cb)(int, float, struct S_PDI)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_PDF(int p0, float p1, struct S_PDF p2,  int (*cb)(int, float, struct S_PDF)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_PDD(int p0, float p1, struct S_PDD p2,  int (*cb)(int, float, struct S_PDD)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_PDP(int p0, float p1, struct S_PDP p2,  int (*cb)(int, float, struct S_PDP)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_PPI(int p0, float p1, struct S_PPI p2,  int (*cb)(int, float, struct S_PPI)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_PPF(int p0, float p1, struct S_PPF p2,  int (*cb)(int, float, struct S_PPF)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_PPD(int p0, float p1, struct S_PPD p2,  int (*cb)(int, float, struct S_PPD)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IFS_PPP(int p0, float p1, struct S_PPP p2,  int (*cb)(int, float, struct S_PPP)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDI_(int p0, double p1, int p2,  int (*cb)(int, double, int)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDF_(int p0, double p1, float p2,  int (*cb)(int, double, float)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDD_(int p0, double p1, double p2,  int (*cb)(int, double, double)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDP_(int p0, double p1, void* p2,  int (*cb)(int, double, void*)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_I(int p0, double p1, struct S_I p2,  int (*cb)(int, double, struct S_I)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_F(int p0, double p1, struct S_F p2,  int (*cb)(int, double, struct S_F)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_D(int p0, double p1, struct S_D p2,  int (*cb)(int, double, struct S_D)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_P(int p0, double p1, struct S_P p2,  int (*cb)(int, double, struct S_P)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_II(int p0, double p1, struct S_II p2,  int (*cb)(int, double, struct S_II)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_IF(int p0, double p1, struct S_IF p2,  int (*cb)(int, double, struct S_IF)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_ID(int p0, double p1, struct S_ID p2,  int (*cb)(int, double, struct S_ID)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_IP(int p0, double p1, struct S_IP p2,  int (*cb)(int, double, struct S_IP)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_FI(int p0, double p1, struct S_FI p2,  int (*cb)(int, double, struct S_FI)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_FF(int p0, double p1, struct S_FF p2,  int (*cb)(int, double, struct S_FF)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_FD(int p0, double p1, struct S_FD p2,  int (*cb)(int, double, struct S_FD)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_FP(int p0, double p1, struct S_FP p2,  int (*cb)(int, double, struct S_FP)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_DI(int p0, double p1, struct S_DI p2,  int (*cb)(int, double, struct S_DI)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_DF(int p0, double p1, struct S_DF p2,  int (*cb)(int, double, struct S_DF)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_DD(int p0, double p1, struct S_DD p2,  int (*cb)(int, double, struct S_DD)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_DP(int p0, double p1, struct S_DP p2,  int (*cb)(int, double, struct S_DP)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_PI(int p0, double p1, struct S_PI p2,  int (*cb)(int, double, struct S_PI)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_PF(int p0, double p1, struct S_PF p2,  int (*cb)(int, double, struct S_PF)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_PD(int p0, double p1, struct S_PD p2,  int (*cb)(int, double, struct S_PD)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_PP(int p0, double p1, struct S_PP p2,  int (*cb)(int, double, struct S_PP)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_III(int p0, double p1, struct S_III p2,  int (*cb)(int, double, struct S_III)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_IIF(int p0, double p1, struct S_IIF p2,  int (*cb)(int, double, struct S_IIF)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_IID(int p0, double p1, struct S_IID p2,  int (*cb)(int, double, struct S_IID)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_IIP(int p0, double p1, struct S_IIP p2,  int (*cb)(int, double, struct S_IIP)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_IFI(int p0, double p1, struct S_IFI p2,  int (*cb)(int, double, struct S_IFI)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_IFF(int p0, double p1, struct S_IFF p2,  int (*cb)(int, double, struct S_IFF)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_IFD(int p0, double p1, struct S_IFD p2,  int (*cb)(int, double, struct S_IFD)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_IFP(int p0, double p1, struct S_IFP p2,  int (*cb)(int, double, struct S_IFP)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_IDI(int p0, double p1, struct S_IDI p2,  int (*cb)(int, double, struct S_IDI)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_IDF(int p0, double p1, struct S_IDF p2,  int (*cb)(int, double, struct S_IDF)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_IDD(int p0, double p1, struct S_IDD p2,  int (*cb)(int, double, struct S_IDD)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_IDP(int p0, double p1, struct S_IDP p2,  int (*cb)(int, double, struct S_IDP)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_IPI(int p0, double p1, struct S_IPI p2,  int (*cb)(int, double, struct S_IPI)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_IPF(int p0, double p1, struct S_IPF p2,  int (*cb)(int, double, struct S_IPF)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_IPD(int p0, double p1, struct S_IPD p2,  int (*cb)(int, double, struct S_IPD)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_IPP(int p0, double p1, struct S_IPP p2,  int (*cb)(int, double, struct S_IPP)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_FII(int p0, double p1, struct S_FII p2,  int (*cb)(int, double, struct S_FII)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_FIF(int p0, double p1, struct S_FIF p2,  int (*cb)(int, double, struct S_FIF)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_FID(int p0, double p1, struct S_FID p2,  int (*cb)(int, double, struct S_FID)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_FIP(int p0, double p1, struct S_FIP p2,  int (*cb)(int, double, struct S_FIP)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_FFI(int p0, double p1, struct S_FFI p2,  int (*cb)(int, double, struct S_FFI)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_FFF(int p0, double p1, struct S_FFF p2,  int (*cb)(int, double, struct S_FFF)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_FFD(int p0, double p1, struct S_FFD p2,  int (*cb)(int, double, struct S_FFD)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_FFP(int p0, double p1, struct S_FFP p2,  int (*cb)(int, double, struct S_FFP)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_FDI(int p0, double p1, struct S_FDI p2,  int (*cb)(int, double, struct S_FDI)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_FDF(int p0, double p1, struct S_FDF p2,  int (*cb)(int, double, struct S_FDF)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_FDD(int p0, double p1, struct S_FDD p2,  int (*cb)(int, double, struct S_FDD)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_FDP(int p0, double p1, struct S_FDP p2,  int (*cb)(int, double, struct S_FDP)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_FPI(int p0, double p1, struct S_FPI p2,  int (*cb)(int, double, struct S_FPI)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_FPF(int p0, double p1, struct S_FPF p2,  int (*cb)(int, double, struct S_FPF)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_FPD(int p0, double p1, struct S_FPD p2,  int (*cb)(int, double, struct S_FPD)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_FPP(int p0, double p1, struct S_FPP p2,  int (*cb)(int, double, struct S_FPP)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_DII(int p0, double p1, struct S_DII p2,  int (*cb)(int, double, struct S_DII)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_DIF(int p0, double p1, struct S_DIF p2,  int (*cb)(int, double, struct S_DIF)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_DID(int p0, double p1, struct S_DID p2,  int (*cb)(int, double, struct S_DID)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_DIP(int p0, double p1, struct S_DIP p2,  int (*cb)(int, double, struct S_DIP)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_DFI(int p0, double p1, struct S_DFI p2,  int (*cb)(int, double, struct S_DFI)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_DFF(int p0, double p1, struct S_DFF p2,  int (*cb)(int, double, struct S_DFF)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_DFD(int p0, double p1, struct S_DFD p2,  int (*cb)(int, double, struct S_DFD)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_DFP(int p0, double p1, struct S_DFP p2,  int (*cb)(int, double, struct S_DFP)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_DDI(int p0, double p1, struct S_DDI p2,  int (*cb)(int, double, struct S_DDI)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_DDF(int p0, double p1, struct S_DDF p2,  int (*cb)(int, double, struct S_DDF)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_DDD(int p0, double p1, struct S_DDD p2,  int (*cb)(int, double, struct S_DDD)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_DDP(int p0, double p1, struct S_DDP p2,  int (*cb)(int, double, struct S_DDP)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_DPI(int p0, double p1, struct S_DPI p2,  int (*cb)(int, double, struct S_DPI)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_DPF(int p0, double p1, struct S_DPF p2,  int (*cb)(int, double, struct S_DPF)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_DPD(int p0, double p1, struct S_DPD p2,  int (*cb)(int, double, struct S_DPD)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_DPP(int p0, double p1, struct S_DPP p2,  int (*cb)(int, double, struct S_DPP)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_PII(int p0, double p1, struct S_PII p2,  int (*cb)(int, double, struct S_PII)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_PIF(int p0, double p1, struct S_PIF p2,  int (*cb)(int, double, struct S_PIF)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_PID(int p0, double p1, struct S_PID p2,  int (*cb)(int, double, struct S_PID)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_PIP(int p0, double p1, struct S_PIP p2,  int (*cb)(int, double, struct S_PIP)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_PFI(int p0, double p1, struct S_PFI p2,  int (*cb)(int, double, struct S_PFI)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_PFF(int p0, double p1, struct S_PFF p2,  int (*cb)(int, double, struct S_PFF)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_PFD(int p0, double p1, struct S_PFD p2,  int (*cb)(int, double, struct S_PFD)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_PFP(int p0, double p1, struct S_PFP p2,  int (*cb)(int, double, struct S_PFP)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_PDI(int p0, double p1, struct S_PDI p2,  int (*cb)(int, double, struct S_PDI)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_PDF(int p0, double p1, struct S_PDF p2,  int (*cb)(int, double, struct S_PDF)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_PDD(int p0, double p1, struct S_PDD p2,  int (*cb)(int, double, struct S_PDD)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_PDP(int p0, double p1, struct S_PDP p2,  int (*cb)(int, double, struct S_PDP)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_PPI(int p0, double p1, struct S_PPI p2,  int (*cb)(int, double, struct S_PPI)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_PPF(int p0, double p1, struct S_PPF p2,  int (*cb)(int, double, struct S_PPF)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_PPD(int p0, double p1, struct S_PPD p2,  int (*cb)(int, double, struct S_PPD)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IDS_PPP(int p0, double p1, struct S_PPP p2,  int (*cb)(int, double, struct S_PPP)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IPI_(int p0, void* p1, int p2,  int (*cb)(int, void*, int)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IPF_(int p0, void* p1, float p2,  int (*cb)(int, void*, float)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IPD_(int p0, void* p1, double p2,  int (*cb)(int, void*, double)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IPP_(int p0, void* p1, void* p2,  int (*cb)(int, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IPS_I(int p0, void* p1, struct S_I p2,  int (*cb)(int, void*, struct S_I)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IPS_F(int p0, void* p1, struct S_F p2,  int (*cb)(int, void*, struct S_F)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IPS_D(int p0, void* p1, struct S_D p2,  int (*cb)(int, void*, struct S_D)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IPS_P(int p0, void* p1, struct S_P p2,  int (*cb)(int, void*, struct S_P)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IPS_II(int p0, void* p1, struct S_II p2,  int (*cb)(int, void*, struct S_II)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IPS_IF(int p0, void* p1, struct S_IF p2,  int (*cb)(int, void*, struct S_IF)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IPS_ID(int p0, void* p1, struct S_ID p2,  int (*cb)(int, void*, struct S_ID)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IPS_IP(int p0, void* p1, struct S_IP p2,  int (*cb)(int, void*, struct S_IP)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IPS_FI(int p0, void* p1, struct S_FI p2,  int (*cb)(int, void*, struct S_FI)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IPS_FF(int p0, void* p1, struct S_FF p2,  int (*cb)(int, void*, struct S_FF)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IPS_FD(int p0, void* p1, struct S_FD p2,  int (*cb)(int, void*, struct S_FD)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IPS_FP(int p0, void* p1, struct S_FP p2,  int (*cb)(int, void*, struct S_FP)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IPS_DI(int p0, void* p1, struct S_DI p2,  int (*cb)(int, void*, struct S_DI)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IPS_DF(int p0, void* p1, struct S_DF p2,  int (*cb)(int, void*, struct S_DF)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IPS_DD(int p0, void* p1, struct S_DD p2,  int (*cb)(int, void*, struct S_DD)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IPS_DP(int p0, void* p1, struct S_DP p2,  int (*cb)(int, void*, struct S_DP)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IPS_PI(int p0, void* p1, struct S_PI p2,  int (*cb)(int, void*, struct S_PI)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IPS_PF(int p0, void* p1, struct S_PF p2,  int (*cb)(int, void*, struct S_PF)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IPS_PD(int p0, void* p1, struct S_PD p2,  int (*cb)(int, void*, struct S_PD)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IPS_PP(int p0, void* p1, struct S_PP p2,  int (*cb)(int, void*, struct S_PP)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IPS_III(int p0, void* p1, struct S_III p2,  int (*cb)(int, void*, struct S_III)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IPS_IIF(int p0, void* p1, struct S_IIF p2,  int (*cb)(int, void*, struct S_IIF)) { return cb(p0,p1,p2); }
+EXPORT int f11_I_IPS_IID(int p0, void* p1, struct S_IID p2,  int (*cb)(int, void*, struct S_IID)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_IPS_IIP(int p0, void* p1, struct S_IIP p2,  int (*cb)(int, void*, struct S_IIP)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_IPS_IFI(int p0, void* p1, struct S_IFI p2,  int (*cb)(int, void*, struct S_IFI)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_IPS_IFF(int p0, void* p1, struct S_IFF p2,  int (*cb)(int, void*, struct S_IFF)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_IPS_IFD(int p0, void* p1, struct S_IFD p2,  int (*cb)(int, void*, struct S_IFD)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_IPS_IFP(int p0, void* p1, struct S_IFP p2,  int (*cb)(int, void*, struct S_IFP)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_IPS_IDI(int p0, void* p1, struct S_IDI p2,  int (*cb)(int, void*, struct S_IDI)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_IPS_IDF(int p0, void* p1, struct S_IDF p2,  int (*cb)(int, void*, struct S_IDF)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_IPS_IDD(int p0, void* p1, struct S_IDD p2,  int (*cb)(int, void*, struct S_IDD)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_IPS_IDP(int p0, void* p1, struct S_IDP p2,  int (*cb)(int, void*, struct S_IDP)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_IPS_IPI(int p0, void* p1, struct S_IPI p2,  int (*cb)(int, void*, struct S_IPI)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_IPS_IPF(int p0, void* p1, struct S_IPF p2,  int (*cb)(int, void*, struct S_IPF)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_IPS_IPD(int p0, void* p1, struct S_IPD p2,  int (*cb)(int, void*, struct S_IPD)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_IPS_IPP(int p0, void* p1, struct S_IPP p2,  int (*cb)(int, void*, struct S_IPP)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_IPS_FII(int p0, void* p1, struct S_FII p2,  int (*cb)(int, void*, struct S_FII)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_IPS_FIF(int p0, void* p1, struct S_FIF p2,  int (*cb)(int, void*, struct S_FIF)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_IPS_FID(int p0, void* p1, struct S_FID p2,  int (*cb)(int, void*, struct S_FID)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_IPS_FIP(int p0, void* p1, struct S_FIP p2,  int (*cb)(int, void*, struct S_FIP)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_IPS_FFI(int p0, void* p1, struct S_FFI p2,  int (*cb)(int, void*, struct S_FFI)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_IPS_FFF(int p0, void* p1, struct S_FFF p2,  int (*cb)(int, void*, struct S_FFF)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_IPS_FFD(int p0, void* p1, struct S_FFD p2,  int (*cb)(int, void*, struct S_FFD)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_IPS_FFP(int p0, void* p1, struct S_FFP p2,  int (*cb)(int, void*, struct S_FFP)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_IPS_FDI(int p0, void* p1, struct S_FDI p2,  int (*cb)(int, void*, struct S_FDI)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_IPS_FDF(int p0, void* p1, struct S_FDF p2,  int (*cb)(int, void*, struct S_FDF)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_IPS_FDD(int p0, void* p1, struct S_FDD p2,  int (*cb)(int, void*, struct S_FDD)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_IPS_FDP(int p0, void* p1, struct S_FDP p2,  int (*cb)(int, void*, struct S_FDP)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_IPS_FPI(int p0, void* p1, struct S_FPI p2,  int (*cb)(int, void*, struct S_FPI)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_IPS_FPF(int p0, void* p1, struct S_FPF p2,  int (*cb)(int, void*, struct S_FPF)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_IPS_FPD(int p0, void* p1, struct S_FPD p2,  int (*cb)(int, void*, struct S_FPD)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_IPS_FPP(int p0, void* p1, struct S_FPP p2,  int (*cb)(int, void*, struct S_FPP)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_IPS_DII(int p0, void* p1, struct S_DII p2,  int (*cb)(int, void*, struct S_DII)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_IPS_DIF(int p0, void* p1, struct S_DIF p2,  int (*cb)(int, void*, struct S_DIF)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_IPS_DID(int p0, void* p1, struct S_DID p2,  int (*cb)(int, void*, struct S_DID)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_IPS_DIP(int p0, void* p1, struct S_DIP p2,  int (*cb)(int, void*, struct S_DIP)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_IPS_DFI(int p0, void* p1, struct S_DFI p2,  int (*cb)(int, void*, struct S_DFI)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_IPS_DFF(int p0, void* p1, struct S_DFF p2,  int (*cb)(int, void*, struct S_DFF)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_IPS_DFD(int p0, void* p1, struct S_DFD p2,  int (*cb)(int, void*, struct S_DFD)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_IPS_DFP(int p0, void* p1, struct S_DFP p2,  int (*cb)(int, void*, struct S_DFP)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_IPS_DDI(int p0, void* p1, struct S_DDI p2,  int (*cb)(int, void*, struct S_DDI)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_IPS_DDF(int p0, void* p1, struct S_DDF p2,  int (*cb)(int, void*, struct S_DDF)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_IPS_DDD(int p0, void* p1, struct S_DDD p2,  int (*cb)(int, void*, struct S_DDD)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_IPS_DDP(int p0, void* p1, struct S_DDP p2,  int (*cb)(int, void*, struct S_DDP)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_IPS_DPI(int p0, void* p1, struct S_DPI p2,  int (*cb)(int, void*, struct S_DPI)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_IPS_DPF(int p0, void* p1, struct S_DPF p2,  int (*cb)(int, void*, struct S_DPF)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_IPS_DPD(int p0, void* p1, struct S_DPD p2,  int (*cb)(int, void*, struct S_DPD)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_IPS_DPP(int p0, void* p1, struct S_DPP p2,  int (*cb)(int, void*, struct S_DPP)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_IPS_PII(int p0, void* p1, struct S_PII p2,  int (*cb)(int, void*, struct S_PII)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_IPS_PIF(int p0, void* p1, struct S_PIF p2,  int (*cb)(int, void*, struct S_PIF)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_IPS_PID(int p0, void* p1, struct S_PID p2,  int (*cb)(int, void*, struct S_PID)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_IPS_PIP(int p0, void* p1, struct S_PIP p2,  int (*cb)(int, void*, struct S_PIP)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_IPS_PFI(int p0, void* p1, struct S_PFI p2,  int (*cb)(int, void*, struct S_PFI)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_IPS_PFF(int p0, void* p1, struct S_PFF p2,  int (*cb)(int, void*, struct S_PFF)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_IPS_PFD(int p0, void* p1, struct S_PFD p2,  int (*cb)(int, void*, struct S_PFD)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_IPS_PFP(int p0, void* p1, struct S_PFP p2,  int (*cb)(int, void*, struct S_PFP)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_IPS_PDI(int p0, void* p1, struct S_PDI p2,  int (*cb)(int, void*, struct S_PDI)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_IPS_PDF(int p0, void* p1, struct S_PDF p2,  int (*cb)(int, void*, struct S_PDF)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_IPS_PDD(int p0, void* p1, struct S_PDD p2,  int (*cb)(int, void*, struct S_PDD)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_IPS_PDP(int p0, void* p1, struct S_PDP p2,  int (*cb)(int, void*, struct S_PDP)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_IPS_PPI(int p0, void* p1, struct S_PPI p2,  int (*cb)(int, void*, struct S_PPI)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_IPS_PPF(int p0, void* p1, struct S_PPF p2,  int (*cb)(int, void*, struct S_PPF)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_IPS_PPD(int p0, void* p1, struct S_PPD p2,  int (*cb)(int, void*, struct S_PPD)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_IPS_PPP(int p0, void* p1, struct S_PPP p2,  int (*cb)(int, void*, struct S_PPP)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_I(int p0, struct S_I p1, int p2,  int (*cb)(int, struct S_I, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_F(int p0, struct S_F p1, int p2,  int (*cb)(int, struct S_F, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_D(int p0, struct S_D p1, int p2,  int (*cb)(int, struct S_D, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_P(int p0, struct S_P p1, int p2,  int (*cb)(int, struct S_P, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_II(int p0, struct S_II p1, int p2,  int (*cb)(int, struct S_II, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_IF(int p0, struct S_IF p1, int p2,  int (*cb)(int, struct S_IF, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_ID(int p0, struct S_ID p1, int p2,  int (*cb)(int, struct S_ID, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_IP(int p0, struct S_IP p1, int p2,  int (*cb)(int, struct S_IP, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_FI(int p0, struct S_FI p1, int p2,  int (*cb)(int, struct S_FI, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_FF(int p0, struct S_FF p1, int p2,  int (*cb)(int, struct S_FF, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_FD(int p0, struct S_FD p1, int p2,  int (*cb)(int, struct S_FD, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_FP(int p0, struct S_FP p1, int p2,  int (*cb)(int, struct S_FP, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_DI(int p0, struct S_DI p1, int p2,  int (*cb)(int, struct S_DI, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_DF(int p0, struct S_DF p1, int p2,  int (*cb)(int, struct S_DF, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_DD(int p0, struct S_DD p1, int p2,  int (*cb)(int, struct S_DD, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_DP(int p0, struct S_DP p1, int p2,  int (*cb)(int, struct S_DP, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_PI(int p0, struct S_PI p1, int p2,  int (*cb)(int, struct S_PI, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_PF(int p0, struct S_PF p1, int p2,  int (*cb)(int, struct S_PF, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_PD(int p0, struct S_PD p1, int p2,  int (*cb)(int, struct S_PD, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_PP(int p0, struct S_PP p1, int p2,  int (*cb)(int, struct S_PP, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_III(int p0, struct S_III p1, int p2,  int (*cb)(int, struct S_III, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_IIF(int p0, struct S_IIF p1, int p2,  int (*cb)(int, struct S_IIF, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_IID(int p0, struct S_IID p1, int p2,  int (*cb)(int, struct S_IID, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_IIP(int p0, struct S_IIP p1, int p2,  int (*cb)(int, struct S_IIP, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_IFI(int p0, struct S_IFI p1, int p2,  int (*cb)(int, struct S_IFI, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_IFF(int p0, struct S_IFF p1, int p2,  int (*cb)(int, struct S_IFF, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_IFD(int p0, struct S_IFD p1, int p2,  int (*cb)(int, struct S_IFD, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_IFP(int p0, struct S_IFP p1, int p2,  int (*cb)(int, struct S_IFP, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_IDI(int p0, struct S_IDI p1, int p2,  int (*cb)(int, struct S_IDI, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_IDF(int p0, struct S_IDF p1, int p2,  int (*cb)(int, struct S_IDF, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_IDD(int p0, struct S_IDD p1, int p2,  int (*cb)(int, struct S_IDD, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_IDP(int p0, struct S_IDP p1, int p2,  int (*cb)(int, struct S_IDP, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_IPI(int p0, struct S_IPI p1, int p2,  int (*cb)(int, struct S_IPI, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_IPF(int p0, struct S_IPF p1, int p2,  int (*cb)(int, struct S_IPF, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_IPD(int p0, struct S_IPD p1, int p2,  int (*cb)(int, struct S_IPD, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_IPP(int p0, struct S_IPP p1, int p2,  int (*cb)(int, struct S_IPP, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_FII(int p0, struct S_FII p1, int p2,  int (*cb)(int, struct S_FII, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_FIF(int p0, struct S_FIF p1, int p2,  int (*cb)(int, struct S_FIF, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_FID(int p0, struct S_FID p1, int p2,  int (*cb)(int, struct S_FID, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_FIP(int p0, struct S_FIP p1, int p2,  int (*cb)(int, struct S_FIP, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_FFI(int p0, struct S_FFI p1, int p2,  int (*cb)(int, struct S_FFI, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_FFF(int p0, struct S_FFF p1, int p2,  int (*cb)(int, struct S_FFF, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_FFD(int p0, struct S_FFD p1, int p2,  int (*cb)(int, struct S_FFD, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_FFP(int p0, struct S_FFP p1, int p2,  int (*cb)(int, struct S_FFP, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_FDI(int p0, struct S_FDI p1, int p2,  int (*cb)(int, struct S_FDI, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_FDF(int p0, struct S_FDF p1, int p2,  int (*cb)(int, struct S_FDF, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_FDD(int p0, struct S_FDD p1, int p2,  int (*cb)(int, struct S_FDD, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_FDP(int p0, struct S_FDP p1, int p2,  int (*cb)(int, struct S_FDP, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_FPI(int p0, struct S_FPI p1, int p2,  int (*cb)(int, struct S_FPI, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_FPF(int p0, struct S_FPF p1, int p2,  int (*cb)(int, struct S_FPF, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_FPD(int p0, struct S_FPD p1, int p2,  int (*cb)(int, struct S_FPD, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_FPP(int p0, struct S_FPP p1, int p2,  int (*cb)(int, struct S_FPP, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_DII(int p0, struct S_DII p1, int p2,  int (*cb)(int, struct S_DII, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_DIF(int p0, struct S_DIF p1, int p2,  int (*cb)(int, struct S_DIF, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_DID(int p0, struct S_DID p1, int p2,  int (*cb)(int, struct S_DID, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_DIP(int p0, struct S_DIP p1, int p2,  int (*cb)(int, struct S_DIP, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_DFI(int p0, struct S_DFI p1, int p2,  int (*cb)(int, struct S_DFI, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_DFF(int p0, struct S_DFF p1, int p2,  int (*cb)(int, struct S_DFF, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_DFD(int p0, struct S_DFD p1, int p2,  int (*cb)(int, struct S_DFD, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_DFP(int p0, struct S_DFP p1, int p2,  int (*cb)(int, struct S_DFP, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_DDI(int p0, struct S_DDI p1, int p2,  int (*cb)(int, struct S_DDI, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_DDF(int p0, struct S_DDF p1, int p2,  int (*cb)(int, struct S_DDF, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_DDD(int p0, struct S_DDD p1, int p2,  int (*cb)(int, struct S_DDD, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_DDP(int p0, struct S_DDP p1, int p2,  int (*cb)(int, struct S_DDP, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_DPI(int p0, struct S_DPI p1, int p2,  int (*cb)(int, struct S_DPI, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_DPF(int p0, struct S_DPF p1, int p2,  int (*cb)(int, struct S_DPF, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_DPD(int p0, struct S_DPD p1, int p2,  int (*cb)(int, struct S_DPD, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_DPP(int p0, struct S_DPP p1, int p2,  int (*cb)(int, struct S_DPP, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_PII(int p0, struct S_PII p1, int p2,  int (*cb)(int, struct S_PII, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_PIF(int p0, struct S_PIF p1, int p2,  int (*cb)(int, struct S_PIF, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_PID(int p0, struct S_PID p1, int p2,  int (*cb)(int, struct S_PID, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_PIP(int p0, struct S_PIP p1, int p2,  int (*cb)(int, struct S_PIP, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_PFI(int p0, struct S_PFI p1, int p2,  int (*cb)(int, struct S_PFI, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_PFF(int p0, struct S_PFF p1, int p2,  int (*cb)(int, struct S_PFF, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_PFD(int p0, struct S_PFD p1, int p2,  int (*cb)(int, struct S_PFD, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_PFP(int p0, struct S_PFP p1, int p2,  int (*cb)(int, struct S_PFP, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_PDI(int p0, struct S_PDI p1, int p2,  int (*cb)(int, struct S_PDI, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_PDF(int p0, struct S_PDF p1, int p2,  int (*cb)(int, struct S_PDF, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_PDD(int p0, struct S_PDD p1, int p2,  int (*cb)(int, struct S_PDD, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_PDP(int p0, struct S_PDP p1, int p2,  int (*cb)(int, struct S_PDP, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_PPI(int p0, struct S_PPI p1, int p2,  int (*cb)(int, struct S_PPI, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_PPF(int p0, struct S_PPF p1, int p2,  int (*cb)(int, struct S_PPF, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_PPD(int p0, struct S_PPD p1, int p2,  int (*cb)(int, struct S_PPD, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISI_PPP(int p0, struct S_PPP p1, int p2,  int (*cb)(int, struct S_PPP, int)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_I(int p0, struct S_I p1, float p2,  int (*cb)(int, struct S_I, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_F(int p0, struct S_F p1, float p2,  int (*cb)(int, struct S_F, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_D(int p0, struct S_D p1, float p2,  int (*cb)(int, struct S_D, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_P(int p0, struct S_P p1, float p2,  int (*cb)(int, struct S_P, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_II(int p0, struct S_II p1, float p2,  int (*cb)(int, struct S_II, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_IF(int p0, struct S_IF p1, float p2,  int (*cb)(int, struct S_IF, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_ID(int p0, struct S_ID p1, float p2,  int (*cb)(int, struct S_ID, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_IP(int p0, struct S_IP p1, float p2,  int (*cb)(int, struct S_IP, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_FI(int p0, struct S_FI p1, float p2,  int (*cb)(int, struct S_FI, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_FF(int p0, struct S_FF p1, float p2,  int (*cb)(int, struct S_FF, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_FD(int p0, struct S_FD p1, float p2,  int (*cb)(int, struct S_FD, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_FP(int p0, struct S_FP p1, float p2,  int (*cb)(int, struct S_FP, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_DI(int p0, struct S_DI p1, float p2,  int (*cb)(int, struct S_DI, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_DF(int p0, struct S_DF p1, float p2,  int (*cb)(int, struct S_DF, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_DD(int p0, struct S_DD p1, float p2,  int (*cb)(int, struct S_DD, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_DP(int p0, struct S_DP p1, float p2,  int (*cb)(int, struct S_DP, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_PI(int p0, struct S_PI p1, float p2,  int (*cb)(int, struct S_PI, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_PF(int p0, struct S_PF p1, float p2,  int (*cb)(int, struct S_PF, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_PD(int p0, struct S_PD p1, float p2,  int (*cb)(int, struct S_PD, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_PP(int p0, struct S_PP p1, float p2,  int (*cb)(int, struct S_PP, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_III(int p0, struct S_III p1, float p2,  int (*cb)(int, struct S_III, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_IIF(int p0, struct S_IIF p1, float p2,  int (*cb)(int, struct S_IIF, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_IID(int p0, struct S_IID p1, float p2,  int (*cb)(int, struct S_IID, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_IIP(int p0, struct S_IIP p1, float p2,  int (*cb)(int, struct S_IIP, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_IFI(int p0, struct S_IFI p1, float p2,  int (*cb)(int, struct S_IFI, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_IFF(int p0, struct S_IFF p1, float p2,  int (*cb)(int, struct S_IFF, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_IFD(int p0, struct S_IFD p1, float p2,  int (*cb)(int, struct S_IFD, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_IFP(int p0, struct S_IFP p1, float p2,  int (*cb)(int, struct S_IFP, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_IDI(int p0, struct S_IDI p1, float p2,  int (*cb)(int, struct S_IDI, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_IDF(int p0, struct S_IDF p1, float p2,  int (*cb)(int, struct S_IDF, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_IDD(int p0, struct S_IDD p1, float p2,  int (*cb)(int, struct S_IDD, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_IDP(int p0, struct S_IDP p1, float p2,  int (*cb)(int, struct S_IDP, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_IPI(int p0, struct S_IPI p1, float p2,  int (*cb)(int, struct S_IPI, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_IPF(int p0, struct S_IPF p1, float p2,  int (*cb)(int, struct S_IPF, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_IPD(int p0, struct S_IPD p1, float p2,  int (*cb)(int, struct S_IPD, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_IPP(int p0, struct S_IPP p1, float p2,  int (*cb)(int, struct S_IPP, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_FII(int p0, struct S_FII p1, float p2,  int (*cb)(int, struct S_FII, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_FIF(int p0, struct S_FIF p1, float p2,  int (*cb)(int, struct S_FIF, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_FID(int p0, struct S_FID p1, float p2,  int (*cb)(int, struct S_FID, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_FIP(int p0, struct S_FIP p1, float p2,  int (*cb)(int, struct S_FIP, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_FFI(int p0, struct S_FFI p1, float p2,  int (*cb)(int, struct S_FFI, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_FFF(int p0, struct S_FFF p1, float p2,  int (*cb)(int, struct S_FFF, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_FFD(int p0, struct S_FFD p1, float p2,  int (*cb)(int, struct S_FFD, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_FFP(int p0, struct S_FFP p1, float p2,  int (*cb)(int, struct S_FFP, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_FDI(int p0, struct S_FDI p1, float p2,  int (*cb)(int, struct S_FDI, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_FDF(int p0, struct S_FDF p1, float p2,  int (*cb)(int, struct S_FDF, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_FDD(int p0, struct S_FDD p1, float p2,  int (*cb)(int, struct S_FDD, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_FDP(int p0, struct S_FDP p1, float p2,  int (*cb)(int, struct S_FDP, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_FPI(int p0, struct S_FPI p1, float p2,  int (*cb)(int, struct S_FPI, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_FPF(int p0, struct S_FPF p1, float p2,  int (*cb)(int, struct S_FPF, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_FPD(int p0, struct S_FPD p1, float p2,  int (*cb)(int, struct S_FPD, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_FPP(int p0, struct S_FPP p1, float p2,  int (*cb)(int, struct S_FPP, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_DII(int p0, struct S_DII p1, float p2,  int (*cb)(int, struct S_DII, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_DIF(int p0, struct S_DIF p1, float p2,  int (*cb)(int, struct S_DIF, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_DID(int p0, struct S_DID p1, float p2,  int (*cb)(int, struct S_DID, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_DIP(int p0, struct S_DIP p1, float p2,  int (*cb)(int, struct S_DIP, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_DFI(int p0, struct S_DFI p1, float p2,  int (*cb)(int, struct S_DFI, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_DFF(int p0, struct S_DFF p1, float p2,  int (*cb)(int, struct S_DFF, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_DFD(int p0, struct S_DFD p1, float p2,  int (*cb)(int, struct S_DFD, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_DFP(int p0, struct S_DFP p1, float p2,  int (*cb)(int, struct S_DFP, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_DDI(int p0, struct S_DDI p1, float p2,  int (*cb)(int, struct S_DDI, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_DDF(int p0, struct S_DDF p1, float p2,  int (*cb)(int, struct S_DDF, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_DDD(int p0, struct S_DDD p1, float p2,  int (*cb)(int, struct S_DDD, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_DDP(int p0, struct S_DDP p1, float p2,  int (*cb)(int, struct S_DDP, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_DPI(int p0, struct S_DPI p1, float p2,  int (*cb)(int, struct S_DPI, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_DPF(int p0, struct S_DPF p1, float p2,  int (*cb)(int, struct S_DPF, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_DPD(int p0, struct S_DPD p1, float p2,  int (*cb)(int, struct S_DPD, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_DPP(int p0, struct S_DPP p1, float p2,  int (*cb)(int, struct S_DPP, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_PII(int p0, struct S_PII p1, float p2,  int (*cb)(int, struct S_PII, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_PIF(int p0, struct S_PIF p1, float p2,  int (*cb)(int, struct S_PIF, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_PID(int p0, struct S_PID p1, float p2,  int (*cb)(int, struct S_PID, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_PIP(int p0, struct S_PIP p1, float p2,  int (*cb)(int, struct S_PIP, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_PFI(int p0, struct S_PFI p1, float p2,  int (*cb)(int, struct S_PFI, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_PFF(int p0, struct S_PFF p1, float p2,  int (*cb)(int, struct S_PFF, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_PFD(int p0, struct S_PFD p1, float p2,  int (*cb)(int, struct S_PFD, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_PFP(int p0, struct S_PFP p1, float p2,  int (*cb)(int, struct S_PFP, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_PDI(int p0, struct S_PDI p1, float p2,  int (*cb)(int, struct S_PDI, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_PDF(int p0, struct S_PDF p1, float p2,  int (*cb)(int, struct S_PDF, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_PDD(int p0, struct S_PDD p1, float p2,  int (*cb)(int, struct S_PDD, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_PDP(int p0, struct S_PDP p1, float p2,  int (*cb)(int, struct S_PDP, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_PPI(int p0, struct S_PPI p1, float p2,  int (*cb)(int, struct S_PPI, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_PPF(int p0, struct S_PPF p1, float p2,  int (*cb)(int, struct S_PPF, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_PPD(int p0, struct S_PPD p1, float p2,  int (*cb)(int, struct S_PPD, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISF_PPP(int p0, struct S_PPP p1, float p2,  int (*cb)(int, struct S_PPP, float)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_I(int p0, struct S_I p1, double p2,  int (*cb)(int, struct S_I, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_F(int p0, struct S_F p1, double p2,  int (*cb)(int, struct S_F, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_D(int p0, struct S_D p1, double p2,  int (*cb)(int, struct S_D, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_P(int p0, struct S_P p1, double p2,  int (*cb)(int, struct S_P, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_II(int p0, struct S_II p1, double p2,  int (*cb)(int, struct S_II, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_IF(int p0, struct S_IF p1, double p2,  int (*cb)(int, struct S_IF, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_ID(int p0, struct S_ID p1, double p2,  int (*cb)(int, struct S_ID, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_IP(int p0, struct S_IP p1, double p2,  int (*cb)(int, struct S_IP, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_FI(int p0, struct S_FI p1, double p2,  int (*cb)(int, struct S_FI, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_FF(int p0, struct S_FF p1, double p2,  int (*cb)(int, struct S_FF, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_FD(int p0, struct S_FD p1, double p2,  int (*cb)(int, struct S_FD, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_FP(int p0, struct S_FP p1, double p2,  int (*cb)(int, struct S_FP, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_DI(int p0, struct S_DI p1, double p2,  int (*cb)(int, struct S_DI, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_DF(int p0, struct S_DF p1, double p2,  int (*cb)(int, struct S_DF, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_DD(int p0, struct S_DD p1, double p2,  int (*cb)(int, struct S_DD, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_DP(int p0, struct S_DP p1, double p2,  int (*cb)(int, struct S_DP, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_PI(int p0, struct S_PI p1, double p2,  int (*cb)(int, struct S_PI, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_PF(int p0, struct S_PF p1, double p2,  int (*cb)(int, struct S_PF, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_PD(int p0, struct S_PD p1, double p2,  int (*cb)(int, struct S_PD, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_PP(int p0, struct S_PP p1, double p2,  int (*cb)(int, struct S_PP, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_III(int p0, struct S_III p1, double p2,  int (*cb)(int, struct S_III, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_IIF(int p0, struct S_IIF p1, double p2,  int (*cb)(int, struct S_IIF, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_IID(int p0, struct S_IID p1, double p2,  int (*cb)(int, struct S_IID, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_IIP(int p0, struct S_IIP p1, double p2,  int (*cb)(int, struct S_IIP, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_IFI(int p0, struct S_IFI p1, double p2,  int (*cb)(int, struct S_IFI, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_IFF(int p0, struct S_IFF p1, double p2,  int (*cb)(int, struct S_IFF, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_IFD(int p0, struct S_IFD p1, double p2,  int (*cb)(int, struct S_IFD, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_IFP(int p0, struct S_IFP p1, double p2,  int (*cb)(int, struct S_IFP, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_IDI(int p0, struct S_IDI p1, double p2,  int (*cb)(int, struct S_IDI, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_IDF(int p0, struct S_IDF p1, double p2,  int (*cb)(int, struct S_IDF, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_IDD(int p0, struct S_IDD p1, double p2,  int (*cb)(int, struct S_IDD, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_IDP(int p0, struct S_IDP p1, double p2,  int (*cb)(int, struct S_IDP, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_IPI(int p0, struct S_IPI p1, double p2,  int (*cb)(int, struct S_IPI, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_IPF(int p0, struct S_IPF p1, double p2,  int (*cb)(int, struct S_IPF, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_IPD(int p0, struct S_IPD p1, double p2,  int (*cb)(int, struct S_IPD, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_IPP(int p0, struct S_IPP p1, double p2,  int (*cb)(int, struct S_IPP, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_FII(int p0, struct S_FII p1, double p2,  int (*cb)(int, struct S_FII, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_FIF(int p0, struct S_FIF p1, double p2,  int (*cb)(int, struct S_FIF, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_FID(int p0, struct S_FID p1, double p2,  int (*cb)(int, struct S_FID, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_FIP(int p0, struct S_FIP p1, double p2,  int (*cb)(int, struct S_FIP, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_FFI(int p0, struct S_FFI p1, double p2,  int (*cb)(int, struct S_FFI, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_FFF(int p0, struct S_FFF p1, double p2,  int (*cb)(int, struct S_FFF, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_FFD(int p0, struct S_FFD p1, double p2,  int (*cb)(int, struct S_FFD, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_FFP(int p0, struct S_FFP p1, double p2,  int (*cb)(int, struct S_FFP, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_FDI(int p0, struct S_FDI p1, double p2,  int (*cb)(int, struct S_FDI, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_FDF(int p0, struct S_FDF p1, double p2,  int (*cb)(int, struct S_FDF, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_FDD(int p0, struct S_FDD p1, double p2,  int (*cb)(int, struct S_FDD, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_FDP(int p0, struct S_FDP p1, double p2,  int (*cb)(int, struct S_FDP, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_FPI(int p0, struct S_FPI p1, double p2,  int (*cb)(int, struct S_FPI, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_FPF(int p0, struct S_FPF p1, double p2,  int (*cb)(int, struct S_FPF, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_FPD(int p0, struct S_FPD p1, double p2,  int (*cb)(int, struct S_FPD, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_FPP(int p0, struct S_FPP p1, double p2,  int (*cb)(int, struct S_FPP, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_DII(int p0, struct S_DII p1, double p2,  int (*cb)(int, struct S_DII, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_DIF(int p0, struct S_DIF p1, double p2,  int (*cb)(int, struct S_DIF, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_DID(int p0, struct S_DID p1, double p2,  int (*cb)(int, struct S_DID, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_DIP(int p0, struct S_DIP p1, double p2,  int (*cb)(int, struct S_DIP, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_DFI(int p0, struct S_DFI p1, double p2,  int (*cb)(int, struct S_DFI, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_DFF(int p0, struct S_DFF p1, double p2,  int (*cb)(int, struct S_DFF, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_DFD(int p0, struct S_DFD p1, double p2,  int (*cb)(int, struct S_DFD, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_DFP(int p0, struct S_DFP p1, double p2,  int (*cb)(int, struct S_DFP, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_DDI(int p0, struct S_DDI p1, double p2,  int (*cb)(int, struct S_DDI, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_DDF(int p0, struct S_DDF p1, double p2,  int (*cb)(int, struct S_DDF, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_DDD(int p0, struct S_DDD p1, double p2,  int (*cb)(int, struct S_DDD, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_DDP(int p0, struct S_DDP p1, double p2,  int (*cb)(int, struct S_DDP, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_DPI(int p0, struct S_DPI p1, double p2,  int (*cb)(int, struct S_DPI, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_DPF(int p0, struct S_DPF p1, double p2,  int (*cb)(int, struct S_DPF, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_DPD(int p0, struct S_DPD p1, double p2,  int (*cb)(int, struct S_DPD, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_DPP(int p0, struct S_DPP p1, double p2,  int (*cb)(int, struct S_DPP, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_PII(int p0, struct S_PII p1, double p2,  int (*cb)(int, struct S_PII, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_PIF(int p0, struct S_PIF p1, double p2,  int (*cb)(int, struct S_PIF, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_PID(int p0, struct S_PID p1, double p2,  int (*cb)(int, struct S_PID, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_PIP(int p0, struct S_PIP p1, double p2,  int (*cb)(int, struct S_PIP, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_PFI(int p0, struct S_PFI p1, double p2,  int (*cb)(int, struct S_PFI, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_PFF(int p0, struct S_PFF p1, double p2,  int (*cb)(int, struct S_PFF, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_PFD(int p0, struct S_PFD p1, double p2,  int (*cb)(int, struct S_PFD, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_PFP(int p0, struct S_PFP p1, double p2,  int (*cb)(int, struct S_PFP, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_PDI(int p0, struct S_PDI p1, double p2,  int (*cb)(int, struct S_PDI, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_PDF(int p0, struct S_PDF p1, double p2,  int (*cb)(int, struct S_PDF, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_PDD(int p0, struct S_PDD p1, double p2,  int (*cb)(int, struct S_PDD, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_PDP(int p0, struct S_PDP p1, double p2,  int (*cb)(int, struct S_PDP, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_PPI(int p0, struct S_PPI p1, double p2,  int (*cb)(int, struct S_PPI, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_PPF(int p0, struct S_PPF p1, double p2,  int (*cb)(int, struct S_PPF, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_PPD(int p0, struct S_PPD p1, double p2,  int (*cb)(int, struct S_PPD, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISD_PPP(int p0, struct S_PPP p1, double p2,  int (*cb)(int, struct S_PPP, double)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_I(int p0, struct S_I p1, void* p2,  int (*cb)(int, struct S_I, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_F(int p0, struct S_F p1, void* p2,  int (*cb)(int, struct S_F, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_D(int p0, struct S_D p1, void* p2,  int (*cb)(int, struct S_D, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_P(int p0, struct S_P p1, void* p2,  int (*cb)(int, struct S_P, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_II(int p0, struct S_II p1, void* p2,  int (*cb)(int, struct S_II, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_IF(int p0, struct S_IF p1, void* p2,  int (*cb)(int, struct S_IF, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_ID(int p0, struct S_ID p1, void* p2,  int (*cb)(int, struct S_ID, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_IP(int p0, struct S_IP p1, void* p2,  int (*cb)(int, struct S_IP, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_FI(int p0, struct S_FI p1, void* p2,  int (*cb)(int, struct S_FI, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_FF(int p0, struct S_FF p1, void* p2,  int (*cb)(int, struct S_FF, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_FD(int p0, struct S_FD p1, void* p2,  int (*cb)(int, struct S_FD, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_FP(int p0, struct S_FP p1, void* p2,  int (*cb)(int, struct S_FP, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_DI(int p0, struct S_DI p1, void* p2,  int (*cb)(int, struct S_DI, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_DF(int p0, struct S_DF p1, void* p2,  int (*cb)(int, struct S_DF, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_DD(int p0, struct S_DD p1, void* p2,  int (*cb)(int, struct S_DD, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_DP(int p0, struct S_DP p1, void* p2,  int (*cb)(int, struct S_DP, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_PI(int p0, struct S_PI p1, void* p2,  int (*cb)(int, struct S_PI, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_PF(int p0, struct S_PF p1, void* p2,  int (*cb)(int, struct S_PF, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_PD(int p0, struct S_PD p1, void* p2,  int (*cb)(int, struct S_PD, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_PP(int p0, struct S_PP p1, void* p2,  int (*cb)(int, struct S_PP, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_III(int p0, struct S_III p1, void* p2,  int (*cb)(int, struct S_III, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_IIF(int p0, struct S_IIF p1, void* p2,  int (*cb)(int, struct S_IIF, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_IID(int p0, struct S_IID p1, void* p2,  int (*cb)(int, struct S_IID, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_IIP(int p0, struct S_IIP p1, void* p2,  int (*cb)(int, struct S_IIP, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_IFI(int p0, struct S_IFI p1, void* p2,  int (*cb)(int, struct S_IFI, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_IFF(int p0, struct S_IFF p1, void* p2,  int (*cb)(int, struct S_IFF, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_IFD(int p0, struct S_IFD p1, void* p2,  int (*cb)(int, struct S_IFD, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_IFP(int p0, struct S_IFP p1, void* p2,  int (*cb)(int, struct S_IFP, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_IDI(int p0, struct S_IDI p1, void* p2,  int (*cb)(int, struct S_IDI, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_IDF(int p0, struct S_IDF p1, void* p2,  int (*cb)(int, struct S_IDF, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_IDD(int p0, struct S_IDD p1, void* p2,  int (*cb)(int, struct S_IDD, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_IDP(int p0, struct S_IDP p1, void* p2,  int (*cb)(int, struct S_IDP, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_IPI(int p0, struct S_IPI p1, void* p2,  int (*cb)(int, struct S_IPI, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_IPF(int p0, struct S_IPF p1, void* p2,  int (*cb)(int, struct S_IPF, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_IPD(int p0, struct S_IPD p1, void* p2,  int (*cb)(int, struct S_IPD, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_IPP(int p0, struct S_IPP p1, void* p2,  int (*cb)(int, struct S_IPP, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_FII(int p0, struct S_FII p1, void* p2,  int (*cb)(int, struct S_FII, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_FIF(int p0, struct S_FIF p1, void* p2,  int (*cb)(int, struct S_FIF, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_FID(int p0, struct S_FID p1, void* p2,  int (*cb)(int, struct S_FID, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_FIP(int p0, struct S_FIP p1, void* p2,  int (*cb)(int, struct S_FIP, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_FFI(int p0, struct S_FFI p1, void* p2,  int (*cb)(int, struct S_FFI, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_FFF(int p0, struct S_FFF p1, void* p2,  int (*cb)(int, struct S_FFF, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_FFD(int p0, struct S_FFD p1, void* p2,  int (*cb)(int, struct S_FFD, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_FFP(int p0, struct S_FFP p1, void* p2,  int (*cb)(int, struct S_FFP, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_FDI(int p0, struct S_FDI p1, void* p2,  int (*cb)(int, struct S_FDI, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_FDF(int p0, struct S_FDF p1, void* p2,  int (*cb)(int, struct S_FDF, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_FDD(int p0, struct S_FDD p1, void* p2,  int (*cb)(int, struct S_FDD, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_FDP(int p0, struct S_FDP p1, void* p2,  int (*cb)(int, struct S_FDP, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_FPI(int p0, struct S_FPI p1, void* p2,  int (*cb)(int, struct S_FPI, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_FPF(int p0, struct S_FPF p1, void* p2,  int (*cb)(int, struct S_FPF, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_FPD(int p0, struct S_FPD p1, void* p2,  int (*cb)(int, struct S_FPD, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_FPP(int p0, struct S_FPP p1, void* p2,  int (*cb)(int, struct S_FPP, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_DII(int p0, struct S_DII p1, void* p2,  int (*cb)(int, struct S_DII, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_DIF(int p0, struct S_DIF p1, void* p2,  int (*cb)(int, struct S_DIF, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_DID(int p0, struct S_DID p1, void* p2,  int (*cb)(int, struct S_DID, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_DIP(int p0, struct S_DIP p1, void* p2,  int (*cb)(int, struct S_DIP, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_DFI(int p0, struct S_DFI p1, void* p2,  int (*cb)(int, struct S_DFI, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_DFF(int p0, struct S_DFF p1, void* p2,  int (*cb)(int, struct S_DFF, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_DFD(int p0, struct S_DFD p1, void* p2,  int (*cb)(int, struct S_DFD, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_DFP(int p0, struct S_DFP p1, void* p2,  int (*cb)(int, struct S_DFP, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_DDI(int p0, struct S_DDI p1, void* p2,  int (*cb)(int, struct S_DDI, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_DDF(int p0, struct S_DDF p1, void* p2,  int (*cb)(int, struct S_DDF, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_DDD(int p0, struct S_DDD p1, void* p2,  int (*cb)(int, struct S_DDD, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_DDP(int p0, struct S_DDP p1, void* p2,  int (*cb)(int, struct S_DDP, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_DPI(int p0, struct S_DPI p1, void* p2,  int (*cb)(int, struct S_DPI, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_DPF(int p0, struct S_DPF p1, void* p2,  int (*cb)(int, struct S_DPF, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_DPD(int p0, struct S_DPD p1, void* p2,  int (*cb)(int, struct S_DPD, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_DPP(int p0, struct S_DPP p1, void* p2,  int (*cb)(int, struct S_DPP, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_PII(int p0, struct S_PII p1, void* p2,  int (*cb)(int, struct S_PII, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_PIF(int p0, struct S_PIF p1, void* p2,  int (*cb)(int, struct S_PIF, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_PID(int p0, struct S_PID p1, void* p2,  int (*cb)(int, struct S_PID, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_PIP(int p0, struct S_PIP p1, void* p2,  int (*cb)(int, struct S_PIP, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_PFI(int p0, struct S_PFI p1, void* p2,  int (*cb)(int, struct S_PFI, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_PFF(int p0, struct S_PFF p1, void* p2,  int (*cb)(int, struct S_PFF, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_PFD(int p0, struct S_PFD p1, void* p2,  int (*cb)(int, struct S_PFD, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_PFP(int p0, struct S_PFP p1, void* p2,  int (*cb)(int, struct S_PFP, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_PDI(int p0, struct S_PDI p1, void* p2,  int (*cb)(int, struct S_PDI, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_PDF(int p0, struct S_PDF p1, void* p2,  int (*cb)(int, struct S_PDF, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_PDD(int p0, struct S_PDD p1, void* p2,  int (*cb)(int, struct S_PDD, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_PDP(int p0, struct S_PDP p1, void* p2,  int (*cb)(int, struct S_PDP, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_PPI(int p0, struct S_PPI p1, void* p2,  int (*cb)(int, struct S_PPI, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_PPF(int p0, struct S_PPF p1, void* p2,  int (*cb)(int, struct S_PPF, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_PPD(int p0, struct S_PPD p1, void* p2,  int (*cb)(int, struct S_PPD, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISP_PPP(int p0, struct S_PPP p1, void* p2,  int (*cb)(int, struct S_PPP, void*)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_I(int p0, struct S_I p1, struct S_I p2,  int (*cb)(int, struct S_I, struct S_I)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_F(int p0, struct S_F p1, struct S_F p2,  int (*cb)(int, struct S_F, struct S_F)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_D(int p0, struct S_D p1, struct S_D p2,  int (*cb)(int, struct S_D, struct S_D)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_P(int p0, struct S_P p1, struct S_P p2,  int (*cb)(int, struct S_P, struct S_P)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_II(int p0, struct S_II p1, struct S_II p2,  int (*cb)(int, struct S_II, struct S_II)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_IF(int p0, struct S_IF p1, struct S_IF p2,  int (*cb)(int, struct S_IF, struct S_IF)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_ID(int p0, struct S_ID p1, struct S_ID p2,  int (*cb)(int, struct S_ID, struct S_ID)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_IP(int p0, struct S_IP p1, struct S_IP p2,  int (*cb)(int, struct S_IP, struct S_IP)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_FI(int p0, struct S_FI p1, struct S_FI p2,  int (*cb)(int, struct S_FI, struct S_FI)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_FF(int p0, struct S_FF p1, struct S_FF p2,  int (*cb)(int, struct S_FF, struct S_FF)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_FD(int p0, struct S_FD p1, struct S_FD p2,  int (*cb)(int, struct S_FD, struct S_FD)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_FP(int p0, struct S_FP p1, struct S_FP p2,  int (*cb)(int, struct S_FP, struct S_FP)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_DI(int p0, struct S_DI p1, struct S_DI p2,  int (*cb)(int, struct S_DI, struct S_DI)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_DF(int p0, struct S_DF p1, struct S_DF p2,  int (*cb)(int, struct S_DF, struct S_DF)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_DD(int p0, struct S_DD p1, struct S_DD p2,  int (*cb)(int, struct S_DD, struct S_DD)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_DP(int p0, struct S_DP p1, struct S_DP p2,  int (*cb)(int, struct S_DP, struct S_DP)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_PI(int p0, struct S_PI p1, struct S_PI p2,  int (*cb)(int, struct S_PI, struct S_PI)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_PF(int p0, struct S_PF p1, struct S_PF p2,  int (*cb)(int, struct S_PF, struct S_PF)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_PD(int p0, struct S_PD p1, struct S_PD p2,  int (*cb)(int, struct S_PD, struct S_PD)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_PP(int p0, struct S_PP p1, struct S_PP p2,  int (*cb)(int, struct S_PP, struct S_PP)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_III(int p0, struct S_III p1, struct S_III p2,  int (*cb)(int, struct S_III, struct S_III)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_IIF(int p0, struct S_IIF p1, struct S_IIF p2,  int (*cb)(int, struct S_IIF, struct S_IIF)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_IID(int p0, struct S_IID p1, struct S_IID p2,  int (*cb)(int, struct S_IID, struct S_IID)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_IIP(int p0, struct S_IIP p1, struct S_IIP p2,  int (*cb)(int, struct S_IIP, struct S_IIP)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_IFI(int p0, struct S_IFI p1, struct S_IFI p2,  int (*cb)(int, struct S_IFI, struct S_IFI)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_IFF(int p0, struct S_IFF p1, struct S_IFF p2,  int (*cb)(int, struct S_IFF, struct S_IFF)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_IFD(int p0, struct S_IFD p1, struct S_IFD p2,  int (*cb)(int, struct S_IFD, struct S_IFD)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_IFP(int p0, struct S_IFP p1, struct S_IFP p2,  int (*cb)(int, struct S_IFP, struct S_IFP)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_IDI(int p0, struct S_IDI p1, struct S_IDI p2,  int (*cb)(int, struct S_IDI, struct S_IDI)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_IDF(int p0, struct S_IDF p1, struct S_IDF p2,  int (*cb)(int, struct S_IDF, struct S_IDF)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_IDD(int p0, struct S_IDD p1, struct S_IDD p2,  int (*cb)(int, struct S_IDD, struct S_IDD)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_IDP(int p0, struct S_IDP p1, struct S_IDP p2,  int (*cb)(int, struct S_IDP, struct S_IDP)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_IPI(int p0, struct S_IPI p1, struct S_IPI p2,  int (*cb)(int, struct S_IPI, struct S_IPI)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_IPF(int p0, struct S_IPF p1, struct S_IPF p2,  int (*cb)(int, struct S_IPF, struct S_IPF)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_IPD(int p0, struct S_IPD p1, struct S_IPD p2,  int (*cb)(int, struct S_IPD, struct S_IPD)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_IPP(int p0, struct S_IPP p1, struct S_IPP p2,  int (*cb)(int, struct S_IPP, struct S_IPP)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_FII(int p0, struct S_FII p1, struct S_FII p2,  int (*cb)(int, struct S_FII, struct S_FII)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_FIF(int p0, struct S_FIF p1, struct S_FIF p2,  int (*cb)(int, struct S_FIF, struct S_FIF)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_FID(int p0, struct S_FID p1, struct S_FID p2,  int (*cb)(int, struct S_FID, struct S_FID)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_FIP(int p0, struct S_FIP p1, struct S_FIP p2,  int (*cb)(int, struct S_FIP, struct S_FIP)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_FFI(int p0, struct S_FFI p1, struct S_FFI p2,  int (*cb)(int, struct S_FFI, struct S_FFI)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_FFF(int p0, struct S_FFF p1, struct S_FFF p2,  int (*cb)(int, struct S_FFF, struct S_FFF)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_FFD(int p0, struct S_FFD p1, struct S_FFD p2,  int (*cb)(int, struct S_FFD, struct S_FFD)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_FFP(int p0, struct S_FFP p1, struct S_FFP p2,  int (*cb)(int, struct S_FFP, struct S_FFP)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_FDI(int p0, struct S_FDI p1, struct S_FDI p2,  int (*cb)(int, struct S_FDI, struct S_FDI)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_FDF(int p0, struct S_FDF p1, struct S_FDF p2,  int (*cb)(int, struct S_FDF, struct S_FDF)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_FDD(int p0, struct S_FDD p1, struct S_FDD p2,  int (*cb)(int, struct S_FDD, struct S_FDD)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_FDP(int p0, struct S_FDP p1, struct S_FDP p2,  int (*cb)(int, struct S_FDP, struct S_FDP)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_FPI(int p0, struct S_FPI p1, struct S_FPI p2,  int (*cb)(int, struct S_FPI, struct S_FPI)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_FPF(int p0, struct S_FPF p1, struct S_FPF p2,  int (*cb)(int, struct S_FPF, struct S_FPF)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_FPD(int p0, struct S_FPD p1, struct S_FPD p2,  int (*cb)(int, struct S_FPD, struct S_FPD)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_FPP(int p0, struct S_FPP p1, struct S_FPP p2,  int (*cb)(int, struct S_FPP, struct S_FPP)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_DII(int p0, struct S_DII p1, struct S_DII p2,  int (*cb)(int, struct S_DII, struct S_DII)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_DIF(int p0, struct S_DIF p1, struct S_DIF p2,  int (*cb)(int, struct S_DIF, struct S_DIF)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_DID(int p0, struct S_DID p1, struct S_DID p2,  int (*cb)(int, struct S_DID, struct S_DID)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_DIP(int p0, struct S_DIP p1, struct S_DIP p2,  int (*cb)(int, struct S_DIP, struct S_DIP)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_DFI(int p0, struct S_DFI p1, struct S_DFI p2,  int (*cb)(int, struct S_DFI, struct S_DFI)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_DFF(int p0, struct S_DFF p1, struct S_DFF p2,  int (*cb)(int, struct S_DFF, struct S_DFF)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_DFD(int p0, struct S_DFD p1, struct S_DFD p2,  int (*cb)(int, struct S_DFD, struct S_DFD)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_DFP(int p0, struct S_DFP p1, struct S_DFP p2,  int (*cb)(int, struct S_DFP, struct S_DFP)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_DDI(int p0, struct S_DDI p1, struct S_DDI p2,  int (*cb)(int, struct S_DDI, struct S_DDI)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_DDF(int p0, struct S_DDF p1, struct S_DDF p2,  int (*cb)(int, struct S_DDF, struct S_DDF)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_DDD(int p0, struct S_DDD p1, struct S_DDD p2,  int (*cb)(int, struct S_DDD, struct S_DDD)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_DDP(int p0, struct S_DDP p1, struct S_DDP p2,  int (*cb)(int, struct S_DDP, struct S_DDP)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_DPI(int p0, struct S_DPI p1, struct S_DPI p2,  int (*cb)(int, struct S_DPI, struct S_DPI)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_DPF(int p0, struct S_DPF p1, struct S_DPF p2,  int (*cb)(int, struct S_DPF, struct S_DPF)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_DPD(int p0, struct S_DPD p1, struct S_DPD p2,  int (*cb)(int, struct S_DPD, struct S_DPD)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_DPP(int p0, struct S_DPP p1, struct S_DPP p2,  int (*cb)(int, struct S_DPP, struct S_DPP)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_PII(int p0, struct S_PII p1, struct S_PII p2,  int (*cb)(int, struct S_PII, struct S_PII)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_PIF(int p0, struct S_PIF p1, struct S_PIF p2,  int (*cb)(int, struct S_PIF, struct S_PIF)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_PID(int p0, struct S_PID p1, struct S_PID p2,  int (*cb)(int, struct S_PID, struct S_PID)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_PIP(int p0, struct S_PIP p1, struct S_PIP p2,  int (*cb)(int, struct S_PIP, struct S_PIP)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_PFI(int p0, struct S_PFI p1, struct S_PFI p2,  int (*cb)(int, struct S_PFI, struct S_PFI)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_PFF(int p0, struct S_PFF p1, struct S_PFF p2,  int (*cb)(int, struct S_PFF, struct S_PFF)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_PFD(int p0, struct S_PFD p1, struct S_PFD p2,  int (*cb)(int, struct S_PFD, struct S_PFD)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_PFP(int p0, struct S_PFP p1, struct S_PFP p2,  int (*cb)(int, struct S_PFP, struct S_PFP)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_PDI(int p0, struct S_PDI p1, struct S_PDI p2,  int (*cb)(int, struct S_PDI, struct S_PDI)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_PDF(int p0, struct S_PDF p1, struct S_PDF p2,  int (*cb)(int, struct S_PDF, struct S_PDF)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_PDD(int p0, struct S_PDD p1, struct S_PDD p2,  int (*cb)(int, struct S_PDD, struct S_PDD)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_PDP(int p0, struct S_PDP p1, struct S_PDP p2,  int (*cb)(int, struct S_PDP, struct S_PDP)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_PPI(int p0, struct S_PPI p1, struct S_PPI p2,  int (*cb)(int, struct S_PPI, struct S_PPI)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_PPF(int p0, struct S_PPF p1, struct S_PPF p2,  int (*cb)(int, struct S_PPF, struct S_PPF)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_PPD(int p0, struct S_PPD p1, struct S_PPD p2,  int (*cb)(int, struct S_PPD, struct S_PPD)) { return cb(p0,p1,p2); }
+EXPORT int f12_I_ISS_PPP(int p0, struct S_PPP p1, struct S_PPP p2,  int (*cb)(int, struct S_PPP, struct S_PPP)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FII_(float p0, int p1, int p2,  float (*cb)(float, int, int)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIF_(float p0, int p1, float p2,  float (*cb)(float, int, float)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FID_(float p0, int p1, double p2,  float (*cb)(float, int, double)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIP_(float p0, int p1, void* p2,  float (*cb)(float, int, void*)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_I(float p0, int p1, struct S_I p2,  float (*cb)(float, int, struct S_I)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_F(float p0, int p1, struct S_F p2,  float (*cb)(float, int, struct S_F)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_D(float p0, int p1, struct S_D p2,  float (*cb)(float, int, struct S_D)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_P(float p0, int p1, struct S_P p2,  float (*cb)(float, int, struct S_P)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_II(float p0, int p1, struct S_II p2,  float (*cb)(float, int, struct S_II)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_IF(float p0, int p1, struct S_IF p2,  float (*cb)(float, int, struct S_IF)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_ID(float p0, int p1, struct S_ID p2,  float (*cb)(float, int, struct S_ID)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_IP(float p0, int p1, struct S_IP p2,  float (*cb)(float, int, struct S_IP)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_FI(float p0, int p1, struct S_FI p2,  float (*cb)(float, int, struct S_FI)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_FF(float p0, int p1, struct S_FF p2,  float (*cb)(float, int, struct S_FF)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_FD(float p0, int p1, struct S_FD p2,  float (*cb)(float, int, struct S_FD)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_FP(float p0, int p1, struct S_FP p2,  float (*cb)(float, int, struct S_FP)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_DI(float p0, int p1, struct S_DI p2,  float (*cb)(float, int, struct S_DI)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_DF(float p0, int p1, struct S_DF p2,  float (*cb)(float, int, struct S_DF)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_DD(float p0, int p1, struct S_DD p2,  float (*cb)(float, int, struct S_DD)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_DP(float p0, int p1, struct S_DP p2,  float (*cb)(float, int, struct S_DP)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_PI(float p0, int p1, struct S_PI p2,  float (*cb)(float, int, struct S_PI)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_PF(float p0, int p1, struct S_PF p2,  float (*cb)(float, int, struct S_PF)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_PD(float p0, int p1, struct S_PD p2,  float (*cb)(float, int, struct S_PD)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_PP(float p0, int p1, struct S_PP p2,  float (*cb)(float, int, struct S_PP)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_III(float p0, int p1, struct S_III p2,  float (*cb)(float, int, struct S_III)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_IIF(float p0, int p1, struct S_IIF p2,  float (*cb)(float, int, struct S_IIF)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_IID(float p0, int p1, struct S_IID p2,  float (*cb)(float, int, struct S_IID)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_IIP(float p0, int p1, struct S_IIP p2,  float (*cb)(float, int, struct S_IIP)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_IFI(float p0, int p1, struct S_IFI p2,  float (*cb)(float, int, struct S_IFI)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_IFF(float p0, int p1, struct S_IFF p2,  float (*cb)(float, int, struct S_IFF)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_IFD(float p0, int p1, struct S_IFD p2,  float (*cb)(float, int, struct S_IFD)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_IFP(float p0, int p1, struct S_IFP p2,  float (*cb)(float, int, struct S_IFP)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_IDI(float p0, int p1, struct S_IDI p2,  float (*cb)(float, int, struct S_IDI)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_IDF(float p0, int p1, struct S_IDF p2,  float (*cb)(float, int, struct S_IDF)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_IDD(float p0, int p1, struct S_IDD p2,  float (*cb)(float, int, struct S_IDD)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_IDP(float p0, int p1, struct S_IDP p2,  float (*cb)(float, int, struct S_IDP)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_IPI(float p0, int p1, struct S_IPI p2,  float (*cb)(float, int, struct S_IPI)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_IPF(float p0, int p1, struct S_IPF p2,  float (*cb)(float, int, struct S_IPF)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_IPD(float p0, int p1, struct S_IPD p2,  float (*cb)(float, int, struct S_IPD)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_IPP(float p0, int p1, struct S_IPP p2,  float (*cb)(float, int, struct S_IPP)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_FII(float p0, int p1, struct S_FII p2,  float (*cb)(float, int, struct S_FII)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_FIF(float p0, int p1, struct S_FIF p2,  float (*cb)(float, int, struct S_FIF)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_FID(float p0, int p1, struct S_FID p2,  float (*cb)(float, int, struct S_FID)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_FIP(float p0, int p1, struct S_FIP p2,  float (*cb)(float, int, struct S_FIP)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_FFI(float p0, int p1, struct S_FFI p2,  float (*cb)(float, int, struct S_FFI)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_FFF(float p0, int p1, struct S_FFF p2,  float (*cb)(float, int, struct S_FFF)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_FFD(float p0, int p1, struct S_FFD p2,  float (*cb)(float, int, struct S_FFD)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_FFP(float p0, int p1, struct S_FFP p2,  float (*cb)(float, int, struct S_FFP)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_FDI(float p0, int p1, struct S_FDI p2,  float (*cb)(float, int, struct S_FDI)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_FDF(float p0, int p1, struct S_FDF p2,  float (*cb)(float, int, struct S_FDF)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_FDD(float p0, int p1, struct S_FDD p2,  float (*cb)(float, int, struct S_FDD)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_FDP(float p0, int p1, struct S_FDP p2,  float (*cb)(float, int, struct S_FDP)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_FPI(float p0, int p1, struct S_FPI p2,  float (*cb)(float, int, struct S_FPI)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_FPF(float p0, int p1, struct S_FPF p2,  float (*cb)(float, int, struct S_FPF)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_FPD(float p0, int p1, struct S_FPD p2,  float (*cb)(float, int, struct S_FPD)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_FPP(float p0, int p1, struct S_FPP p2,  float (*cb)(float, int, struct S_FPP)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_DII(float p0, int p1, struct S_DII p2,  float (*cb)(float, int, struct S_DII)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_DIF(float p0, int p1, struct S_DIF p2,  float (*cb)(float, int, struct S_DIF)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_DID(float p0, int p1, struct S_DID p2,  float (*cb)(float, int, struct S_DID)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_DIP(float p0, int p1, struct S_DIP p2,  float (*cb)(float, int, struct S_DIP)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_DFI(float p0, int p1, struct S_DFI p2,  float (*cb)(float, int, struct S_DFI)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_DFF(float p0, int p1, struct S_DFF p2,  float (*cb)(float, int, struct S_DFF)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_DFD(float p0, int p1, struct S_DFD p2,  float (*cb)(float, int, struct S_DFD)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_DFP(float p0, int p1, struct S_DFP p2,  float (*cb)(float, int, struct S_DFP)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_DDI(float p0, int p1, struct S_DDI p2,  float (*cb)(float, int, struct S_DDI)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_DDF(float p0, int p1, struct S_DDF p2,  float (*cb)(float, int, struct S_DDF)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_DDD(float p0, int p1, struct S_DDD p2,  float (*cb)(float, int, struct S_DDD)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_DDP(float p0, int p1, struct S_DDP p2,  float (*cb)(float, int, struct S_DDP)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_DPI(float p0, int p1, struct S_DPI p2,  float (*cb)(float, int, struct S_DPI)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_DPF(float p0, int p1, struct S_DPF p2,  float (*cb)(float, int, struct S_DPF)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_DPD(float p0, int p1, struct S_DPD p2,  float (*cb)(float, int, struct S_DPD)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_DPP(float p0, int p1, struct S_DPP p2,  float (*cb)(float, int, struct S_DPP)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_PII(float p0, int p1, struct S_PII p2,  float (*cb)(float, int, struct S_PII)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_PIF(float p0, int p1, struct S_PIF p2,  float (*cb)(float, int, struct S_PIF)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_PID(float p0, int p1, struct S_PID p2,  float (*cb)(float, int, struct S_PID)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_PIP(float p0, int p1, struct S_PIP p2,  float (*cb)(float, int, struct S_PIP)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_PFI(float p0, int p1, struct S_PFI p2,  float (*cb)(float, int, struct S_PFI)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_PFF(float p0, int p1, struct S_PFF p2,  float (*cb)(float, int, struct S_PFF)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_PFD(float p0, int p1, struct S_PFD p2,  float (*cb)(float, int, struct S_PFD)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_PFP(float p0, int p1, struct S_PFP p2,  float (*cb)(float, int, struct S_PFP)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_PDI(float p0, int p1, struct S_PDI p2,  float (*cb)(float, int, struct S_PDI)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_PDF(float p0, int p1, struct S_PDF p2,  float (*cb)(float, int, struct S_PDF)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_PDD(float p0, int p1, struct S_PDD p2,  float (*cb)(float, int, struct S_PDD)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_PDP(float p0, int p1, struct S_PDP p2,  float (*cb)(float, int, struct S_PDP)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_PPI(float p0, int p1, struct S_PPI p2,  float (*cb)(float, int, struct S_PPI)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_PPF(float p0, int p1, struct S_PPF p2,  float (*cb)(float, int, struct S_PPF)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_PPD(float p0, int p1, struct S_PPD p2,  float (*cb)(float, int, struct S_PPD)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FIS_PPP(float p0, int p1, struct S_PPP p2,  float (*cb)(float, int, struct S_PPP)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FFI_(float p0, float p1, int p2,  float (*cb)(float, float, int)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FFF_(float p0, float p1, float p2,  float (*cb)(float, float, float)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FFD_(float p0, float p1, double p2,  float (*cb)(float, float, double)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FFP_(float p0, float p1, void* p2,  float (*cb)(float, float, void*)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FFS_I(float p0, float p1, struct S_I p2,  float (*cb)(float, float, struct S_I)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FFS_F(float p0, float p1, struct S_F p2,  float (*cb)(float, float, struct S_F)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FFS_D(float p0, float p1, struct S_D p2,  float (*cb)(float, float, struct S_D)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FFS_P(float p0, float p1, struct S_P p2,  float (*cb)(float, float, struct S_P)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FFS_II(float p0, float p1, struct S_II p2,  float (*cb)(float, float, struct S_II)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FFS_IF(float p0, float p1, struct S_IF p2,  float (*cb)(float, float, struct S_IF)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FFS_ID(float p0, float p1, struct S_ID p2,  float (*cb)(float, float, struct S_ID)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FFS_IP(float p0, float p1, struct S_IP p2,  float (*cb)(float, float, struct S_IP)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FFS_FI(float p0, float p1, struct S_FI p2,  float (*cb)(float, float, struct S_FI)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FFS_FF(float p0, float p1, struct S_FF p2,  float (*cb)(float, float, struct S_FF)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FFS_FD(float p0, float p1, struct S_FD p2,  float (*cb)(float, float, struct S_FD)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FFS_FP(float p0, float p1, struct S_FP p2,  float (*cb)(float, float, struct S_FP)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FFS_DI(float p0, float p1, struct S_DI p2,  float (*cb)(float, float, struct S_DI)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FFS_DF(float p0, float p1, struct S_DF p2,  float (*cb)(float, float, struct S_DF)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FFS_DD(float p0, float p1, struct S_DD p2,  float (*cb)(float, float, struct S_DD)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FFS_DP(float p0, float p1, struct S_DP p2,  float (*cb)(float, float, struct S_DP)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FFS_PI(float p0, float p1, struct S_PI p2,  float (*cb)(float, float, struct S_PI)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FFS_PF(float p0, float p1, struct S_PF p2,  float (*cb)(float, float, struct S_PF)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FFS_PD(float p0, float p1, struct S_PD p2,  float (*cb)(float, float, struct S_PD)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FFS_PP(float p0, float p1, struct S_PP p2,  float (*cb)(float, float, struct S_PP)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FFS_III(float p0, float p1, struct S_III p2,  float (*cb)(float, float, struct S_III)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FFS_IIF(float p0, float p1, struct S_IIF p2,  float (*cb)(float, float, struct S_IIF)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FFS_IID(float p0, float p1, struct S_IID p2,  float (*cb)(float, float, struct S_IID)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FFS_IIP(float p0, float p1, struct S_IIP p2,  float (*cb)(float, float, struct S_IIP)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FFS_IFI(float p0, float p1, struct S_IFI p2,  float (*cb)(float, float, struct S_IFI)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FFS_IFF(float p0, float p1, struct S_IFF p2,  float (*cb)(float, float, struct S_IFF)) { return cb(p0,p1,p2); }
+EXPORT float f12_F_FFS_IFD(float p0, float p1, struct S_IFD p2,  float (*cb)(float, float, struct S_IFD)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FFS_IFP(float p0, float p1, struct S_IFP p2,  float (*cb)(float, float, struct S_IFP)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FFS_IDI(float p0, float p1, struct S_IDI p2,  float (*cb)(float, float, struct S_IDI)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FFS_IDF(float p0, float p1, struct S_IDF p2,  float (*cb)(float, float, struct S_IDF)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FFS_IDD(float p0, float p1, struct S_IDD p2,  float (*cb)(float, float, struct S_IDD)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FFS_IDP(float p0, float p1, struct S_IDP p2,  float (*cb)(float, float, struct S_IDP)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FFS_IPI(float p0, float p1, struct S_IPI p2,  float (*cb)(float, float, struct S_IPI)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FFS_IPF(float p0, float p1, struct S_IPF p2,  float (*cb)(float, float, struct S_IPF)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FFS_IPD(float p0, float p1, struct S_IPD p2,  float (*cb)(float, float, struct S_IPD)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FFS_IPP(float p0, float p1, struct S_IPP p2,  float (*cb)(float, float, struct S_IPP)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FFS_FII(float p0, float p1, struct S_FII p2,  float (*cb)(float, float, struct S_FII)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FFS_FIF(float p0, float p1, struct S_FIF p2,  float (*cb)(float, float, struct S_FIF)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FFS_FID(float p0, float p1, struct S_FID p2,  float (*cb)(float, float, struct S_FID)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FFS_FIP(float p0, float p1, struct S_FIP p2,  float (*cb)(float, float, struct S_FIP)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FFS_FFI(float p0, float p1, struct S_FFI p2,  float (*cb)(float, float, struct S_FFI)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FFS_FFF(float p0, float p1, struct S_FFF p2,  float (*cb)(float, float, struct S_FFF)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FFS_FFD(float p0, float p1, struct S_FFD p2,  float (*cb)(float, float, struct S_FFD)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FFS_FFP(float p0, float p1, struct S_FFP p2,  float (*cb)(float, float, struct S_FFP)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FFS_FDI(float p0, float p1, struct S_FDI p2,  float (*cb)(float, float, struct S_FDI)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FFS_FDF(float p0, float p1, struct S_FDF p2,  float (*cb)(float, float, struct S_FDF)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FFS_FDD(float p0, float p1, struct S_FDD p2,  float (*cb)(float, float, struct S_FDD)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FFS_FDP(float p0, float p1, struct S_FDP p2,  float (*cb)(float, float, struct S_FDP)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FFS_FPI(float p0, float p1, struct S_FPI p2,  float (*cb)(float, float, struct S_FPI)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FFS_FPF(float p0, float p1, struct S_FPF p2,  float (*cb)(float, float, struct S_FPF)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FFS_FPD(float p0, float p1, struct S_FPD p2,  float (*cb)(float, float, struct S_FPD)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FFS_FPP(float p0, float p1, struct S_FPP p2,  float (*cb)(float, float, struct S_FPP)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FFS_DII(float p0, float p1, struct S_DII p2,  float (*cb)(float, float, struct S_DII)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FFS_DIF(float p0, float p1, struct S_DIF p2,  float (*cb)(float, float, struct S_DIF)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FFS_DID(float p0, float p1, struct S_DID p2,  float (*cb)(float, float, struct S_DID)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FFS_DIP(float p0, float p1, struct S_DIP p2,  float (*cb)(float, float, struct S_DIP)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FFS_DFI(float p0, float p1, struct S_DFI p2,  float (*cb)(float, float, struct S_DFI)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FFS_DFF(float p0, float p1, struct S_DFF p2,  float (*cb)(float, float, struct S_DFF)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FFS_DFD(float p0, float p1, struct S_DFD p2,  float (*cb)(float, float, struct S_DFD)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FFS_DFP(float p0, float p1, struct S_DFP p2,  float (*cb)(float, float, struct S_DFP)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FFS_DDI(float p0, float p1, struct S_DDI p2,  float (*cb)(float, float, struct S_DDI)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FFS_DDF(float p0, float p1, struct S_DDF p2,  float (*cb)(float, float, struct S_DDF)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FFS_DDD(float p0, float p1, struct S_DDD p2,  float (*cb)(float, float, struct S_DDD)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FFS_DDP(float p0, float p1, struct S_DDP p2,  float (*cb)(float, float, struct S_DDP)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FFS_DPI(float p0, float p1, struct S_DPI p2,  float (*cb)(float, float, struct S_DPI)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FFS_DPF(float p0, float p1, struct S_DPF p2,  float (*cb)(float, float, struct S_DPF)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FFS_DPD(float p0, float p1, struct S_DPD p2,  float (*cb)(float, float, struct S_DPD)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FFS_DPP(float p0, float p1, struct S_DPP p2,  float (*cb)(float, float, struct S_DPP)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FFS_PII(float p0, float p1, struct S_PII p2,  float (*cb)(float, float, struct S_PII)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FFS_PIF(float p0, float p1, struct S_PIF p2,  float (*cb)(float, float, struct S_PIF)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FFS_PID(float p0, float p1, struct S_PID p2,  float (*cb)(float, float, struct S_PID)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FFS_PIP(float p0, float p1, struct S_PIP p2,  float (*cb)(float, float, struct S_PIP)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FFS_PFI(float p0, float p1, struct S_PFI p2,  float (*cb)(float, float, struct S_PFI)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FFS_PFF(float p0, float p1, struct S_PFF p2,  float (*cb)(float, float, struct S_PFF)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FFS_PFD(float p0, float p1, struct S_PFD p2,  float (*cb)(float, float, struct S_PFD)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FFS_PFP(float p0, float p1, struct S_PFP p2,  float (*cb)(float, float, struct S_PFP)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FFS_PDI(float p0, float p1, struct S_PDI p2,  float (*cb)(float, float, struct S_PDI)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FFS_PDF(float p0, float p1, struct S_PDF p2,  float (*cb)(float, float, struct S_PDF)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FFS_PDD(float p0, float p1, struct S_PDD p2,  float (*cb)(float, float, struct S_PDD)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FFS_PDP(float p0, float p1, struct S_PDP p2,  float (*cb)(float, float, struct S_PDP)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FFS_PPI(float p0, float p1, struct S_PPI p2,  float (*cb)(float, float, struct S_PPI)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FFS_PPF(float p0, float p1, struct S_PPF p2,  float (*cb)(float, float, struct S_PPF)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FFS_PPD(float p0, float p1, struct S_PPD p2,  float (*cb)(float, float, struct S_PPD)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FFS_PPP(float p0, float p1, struct S_PPP p2,  float (*cb)(float, float, struct S_PPP)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDI_(float p0, double p1, int p2,  float (*cb)(float, double, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDF_(float p0, double p1, float p2,  float (*cb)(float, double, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDD_(float p0, double p1, double p2,  float (*cb)(float, double, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDP_(float p0, double p1, void* p2,  float (*cb)(float, double, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_I(float p0, double p1, struct S_I p2,  float (*cb)(float, double, struct S_I)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_F(float p0, double p1, struct S_F p2,  float (*cb)(float, double, struct S_F)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_D(float p0, double p1, struct S_D p2,  float (*cb)(float, double, struct S_D)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_P(float p0, double p1, struct S_P p2,  float (*cb)(float, double, struct S_P)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_II(float p0, double p1, struct S_II p2,  float (*cb)(float, double, struct S_II)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_IF(float p0, double p1, struct S_IF p2,  float (*cb)(float, double, struct S_IF)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_ID(float p0, double p1, struct S_ID p2,  float (*cb)(float, double, struct S_ID)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_IP(float p0, double p1, struct S_IP p2,  float (*cb)(float, double, struct S_IP)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_FI(float p0, double p1, struct S_FI p2,  float (*cb)(float, double, struct S_FI)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_FF(float p0, double p1, struct S_FF p2,  float (*cb)(float, double, struct S_FF)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_FD(float p0, double p1, struct S_FD p2,  float (*cb)(float, double, struct S_FD)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_FP(float p0, double p1, struct S_FP p2,  float (*cb)(float, double, struct S_FP)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_DI(float p0, double p1, struct S_DI p2,  float (*cb)(float, double, struct S_DI)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_DF(float p0, double p1, struct S_DF p2,  float (*cb)(float, double, struct S_DF)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_DD(float p0, double p1, struct S_DD p2,  float (*cb)(float, double, struct S_DD)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_DP(float p0, double p1, struct S_DP p2,  float (*cb)(float, double, struct S_DP)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_PI(float p0, double p1, struct S_PI p2,  float (*cb)(float, double, struct S_PI)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_PF(float p0, double p1, struct S_PF p2,  float (*cb)(float, double, struct S_PF)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_PD(float p0, double p1, struct S_PD p2,  float (*cb)(float, double, struct S_PD)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_PP(float p0, double p1, struct S_PP p2,  float (*cb)(float, double, struct S_PP)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_III(float p0, double p1, struct S_III p2,  float (*cb)(float, double, struct S_III)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_IIF(float p0, double p1, struct S_IIF p2,  float (*cb)(float, double, struct S_IIF)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_IID(float p0, double p1, struct S_IID p2,  float (*cb)(float, double, struct S_IID)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_IIP(float p0, double p1, struct S_IIP p2,  float (*cb)(float, double, struct S_IIP)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_IFI(float p0, double p1, struct S_IFI p2,  float (*cb)(float, double, struct S_IFI)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_IFF(float p0, double p1, struct S_IFF p2,  float (*cb)(float, double, struct S_IFF)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_IFD(float p0, double p1, struct S_IFD p2,  float (*cb)(float, double, struct S_IFD)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_IFP(float p0, double p1, struct S_IFP p2,  float (*cb)(float, double, struct S_IFP)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_IDI(float p0, double p1, struct S_IDI p2,  float (*cb)(float, double, struct S_IDI)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_IDF(float p0, double p1, struct S_IDF p2,  float (*cb)(float, double, struct S_IDF)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_IDD(float p0, double p1, struct S_IDD p2,  float (*cb)(float, double, struct S_IDD)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_IDP(float p0, double p1, struct S_IDP p2,  float (*cb)(float, double, struct S_IDP)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_IPI(float p0, double p1, struct S_IPI p2,  float (*cb)(float, double, struct S_IPI)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_IPF(float p0, double p1, struct S_IPF p2,  float (*cb)(float, double, struct S_IPF)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_IPD(float p0, double p1, struct S_IPD p2,  float (*cb)(float, double, struct S_IPD)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_IPP(float p0, double p1, struct S_IPP p2,  float (*cb)(float, double, struct S_IPP)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_FII(float p0, double p1, struct S_FII p2,  float (*cb)(float, double, struct S_FII)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_FIF(float p0, double p1, struct S_FIF p2,  float (*cb)(float, double, struct S_FIF)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_FID(float p0, double p1, struct S_FID p2,  float (*cb)(float, double, struct S_FID)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_FIP(float p0, double p1, struct S_FIP p2,  float (*cb)(float, double, struct S_FIP)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_FFI(float p0, double p1, struct S_FFI p2,  float (*cb)(float, double, struct S_FFI)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_FFF(float p0, double p1, struct S_FFF p2,  float (*cb)(float, double, struct S_FFF)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_FFD(float p0, double p1, struct S_FFD p2,  float (*cb)(float, double, struct S_FFD)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_FFP(float p0, double p1, struct S_FFP p2,  float (*cb)(float, double, struct S_FFP)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_FDI(float p0, double p1, struct S_FDI p2,  float (*cb)(float, double, struct S_FDI)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_FDF(float p0, double p1, struct S_FDF p2,  float (*cb)(float, double, struct S_FDF)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_FDD(float p0, double p1, struct S_FDD p2,  float (*cb)(float, double, struct S_FDD)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_FDP(float p0, double p1, struct S_FDP p2,  float (*cb)(float, double, struct S_FDP)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_FPI(float p0, double p1, struct S_FPI p2,  float (*cb)(float, double, struct S_FPI)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_FPF(float p0, double p1, struct S_FPF p2,  float (*cb)(float, double, struct S_FPF)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_FPD(float p0, double p1, struct S_FPD p2,  float (*cb)(float, double, struct S_FPD)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_FPP(float p0, double p1, struct S_FPP p2,  float (*cb)(float, double, struct S_FPP)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_DII(float p0, double p1, struct S_DII p2,  float (*cb)(float, double, struct S_DII)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_DIF(float p0, double p1, struct S_DIF p2,  float (*cb)(float, double, struct S_DIF)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_DID(float p0, double p1, struct S_DID p2,  float (*cb)(float, double, struct S_DID)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_DIP(float p0, double p1, struct S_DIP p2,  float (*cb)(float, double, struct S_DIP)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_DFI(float p0, double p1, struct S_DFI p2,  float (*cb)(float, double, struct S_DFI)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_DFF(float p0, double p1, struct S_DFF p2,  float (*cb)(float, double, struct S_DFF)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_DFD(float p0, double p1, struct S_DFD p2,  float (*cb)(float, double, struct S_DFD)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_DFP(float p0, double p1, struct S_DFP p2,  float (*cb)(float, double, struct S_DFP)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_DDI(float p0, double p1, struct S_DDI p2,  float (*cb)(float, double, struct S_DDI)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_DDF(float p0, double p1, struct S_DDF p2,  float (*cb)(float, double, struct S_DDF)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_DDD(float p0, double p1, struct S_DDD p2,  float (*cb)(float, double, struct S_DDD)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_DDP(float p0, double p1, struct S_DDP p2,  float (*cb)(float, double, struct S_DDP)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_DPI(float p0, double p1, struct S_DPI p2,  float (*cb)(float, double, struct S_DPI)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_DPF(float p0, double p1, struct S_DPF p2,  float (*cb)(float, double, struct S_DPF)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_DPD(float p0, double p1, struct S_DPD p2,  float (*cb)(float, double, struct S_DPD)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_DPP(float p0, double p1, struct S_DPP p2,  float (*cb)(float, double, struct S_DPP)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_PII(float p0, double p1, struct S_PII p2,  float (*cb)(float, double, struct S_PII)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_PIF(float p0, double p1, struct S_PIF p2,  float (*cb)(float, double, struct S_PIF)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_PID(float p0, double p1, struct S_PID p2,  float (*cb)(float, double, struct S_PID)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_PIP(float p0, double p1, struct S_PIP p2,  float (*cb)(float, double, struct S_PIP)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_PFI(float p0, double p1, struct S_PFI p2,  float (*cb)(float, double, struct S_PFI)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_PFF(float p0, double p1, struct S_PFF p2,  float (*cb)(float, double, struct S_PFF)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_PFD(float p0, double p1, struct S_PFD p2,  float (*cb)(float, double, struct S_PFD)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_PFP(float p0, double p1, struct S_PFP p2,  float (*cb)(float, double, struct S_PFP)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_PDI(float p0, double p1, struct S_PDI p2,  float (*cb)(float, double, struct S_PDI)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_PDF(float p0, double p1, struct S_PDF p2,  float (*cb)(float, double, struct S_PDF)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_PDD(float p0, double p1, struct S_PDD p2,  float (*cb)(float, double, struct S_PDD)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_PDP(float p0, double p1, struct S_PDP p2,  float (*cb)(float, double, struct S_PDP)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_PPI(float p0, double p1, struct S_PPI p2,  float (*cb)(float, double, struct S_PPI)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_PPF(float p0, double p1, struct S_PPF p2,  float (*cb)(float, double, struct S_PPF)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_PPD(float p0, double p1, struct S_PPD p2,  float (*cb)(float, double, struct S_PPD)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FDS_PPP(float p0, double p1, struct S_PPP p2,  float (*cb)(float, double, struct S_PPP)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPI_(float p0, void* p1, int p2,  float (*cb)(float, void*, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPF_(float p0, void* p1, float p2,  float (*cb)(float, void*, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPD_(float p0, void* p1, double p2,  float (*cb)(float, void*, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPP_(float p0, void* p1, void* p2,  float (*cb)(float, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_I(float p0, void* p1, struct S_I p2,  float (*cb)(float, void*, struct S_I)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_F(float p0, void* p1, struct S_F p2,  float (*cb)(float, void*, struct S_F)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_D(float p0, void* p1, struct S_D p2,  float (*cb)(float, void*, struct S_D)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_P(float p0, void* p1, struct S_P p2,  float (*cb)(float, void*, struct S_P)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_II(float p0, void* p1, struct S_II p2,  float (*cb)(float, void*, struct S_II)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_IF(float p0, void* p1, struct S_IF p2,  float (*cb)(float, void*, struct S_IF)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_ID(float p0, void* p1, struct S_ID p2,  float (*cb)(float, void*, struct S_ID)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_IP(float p0, void* p1, struct S_IP p2,  float (*cb)(float, void*, struct S_IP)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_FI(float p0, void* p1, struct S_FI p2,  float (*cb)(float, void*, struct S_FI)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_FF(float p0, void* p1, struct S_FF p2,  float (*cb)(float, void*, struct S_FF)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_FD(float p0, void* p1, struct S_FD p2,  float (*cb)(float, void*, struct S_FD)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_FP(float p0, void* p1, struct S_FP p2,  float (*cb)(float, void*, struct S_FP)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_DI(float p0, void* p1, struct S_DI p2,  float (*cb)(float, void*, struct S_DI)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_DF(float p0, void* p1, struct S_DF p2,  float (*cb)(float, void*, struct S_DF)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_DD(float p0, void* p1, struct S_DD p2,  float (*cb)(float, void*, struct S_DD)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_DP(float p0, void* p1, struct S_DP p2,  float (*cb)(float, void*, struct S_DP)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_PI(float p0, void* p1, struct S_PI p2,  float (*cb)(float, void*, struct S_PI)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_PF(float p0, void* p1, struct S_PF p2,  float (*cb)(float, void*, struct S_PF)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_PD(float p0, void* p1, struct S_PD p2,  float (*cb)(float, void*, struct S_PD)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_PP(float p0, void* p1, struct S_PP p2,  float (*cb)(float, void*, struct S_PP)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_III(float p0, void* p1, struct S_III p2,  float (*cb)(float, void*, struct S_III)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_IIF(float p0, void* p1, struct S_IIF p2,  float (*cb)(float, void*, struct S_IIF)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_IID(float p0, void* p1, struct S_IID p2,  float (*cb)(float, void*, struct S_IID)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_IIP(float p0, void* p1, struct S_IIP p2,  float (*cb)(float, void*, struct S_IIP)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_IFI(float p0, void* p1, struct S_IFI p2,  float (*cb)(float, void*, struct S_IFI)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_IFF(float p0, void* p1, struct S_IFF p2,  float (*cb)(float, void*, struct S_IFF)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_IFD(float p0, void* p1, struct S_IFD p2,  float (*cb)(float, void*, struct S_IFD)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_IFP(float p0, void* p1, struct S_IFP p2,  float (*cb)(float, void*, struct S_IFP)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_IDI(float p0, void* p1, struct S_IDI p2,  float (*cb)(float, void*, struct S_IDI)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_IDF(float p0, void* p1, struct S_IDF p2,  float (*cb)(float, void*, struct S_IDF)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_IDD(float p0, void* p1, struct S_IDD p2,  float (*cb)(float, void*, struct S_IDD)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_IDP(float p0, void* p1, struct S_IDP p2,  float (*cb)(float, void*, struct S_IDP)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_IPI(float p0, void* p1, struct S_IPI p2,  float (*cb)(float, void*, struct S_IPI)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_IPF(float p0, void* p1, struct S_IPF p2,  float (*cb)(float, void*, struct S_IPF)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_IPD(float p0, void* p1, struct S_IPD p2,  float (*cb)(float, void*, struct S_IPD)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_IPP(float p0, void* p1, struct S_IPP p2,  float (*cb)(float, void*, struct S_IPP)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_FII(float p0, void* p1, struct S_FII p2,  float (*cb)(float, void*, struct S_FII)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_FIF(float p0, void* p1, struct S_FIF p2,  float (*cb)(float, void*, struct S_FIF)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_FID(float p0, void* p1, struct S_FID p2,  float (*cb)(float, void*, struct S_FID)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_FIP(float p0, void* p1, struct S_FIP p2,  float (*cb)(float, void*, struct S_FIP)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_FFI(float p0, void* p1, struct S_FFI p2,  float (*cb)(float, void*, struct S_FFI)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_FFF(float p0, void* p1, struct S_FFF p2,  float (*cb)(float, void*, struct S_FFF)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_FFD(float p0, void* p1, struct S_FFD p2,  float (*cb)(float, void*, struct S_FFD)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_FFP(float p0, void* p1, struct S_FFP p2,  float (*cb)(float, void*, struct S_FFP)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_FDI(float p0, void* p1, struct S_FDI p2,  float (*cb)(float, void*, struct S_FDI)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_FDF(float p0, void* p1, struct S_FDF p2,  float (*cb)(float, void*, struct S_FDF)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_FDD(float p0, void* p1, struct S_FDD p2,  float (*cb)(float, void*, struct S_FDD)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_FDP(float p0, void* p1, struct S_FDP p2,  float (*cb)(float, void*, struct S_FDP)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_FPI(float p0, void* p1, struct S_FPI p2,  float (*cb)(float, void*, struct S_FPI)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_FPF(float p0, void* p1, struct S_FPF p2,  float (*cb)(float, void*, struct S_FPF)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_FPD(float p0, void* p1, struct S_FPD p2,  float (*cb)(float, void*, struct S_FPD)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_FPP(float p0, void* p1, struct S_FPP p2,  float (*cb)(float, void*, struct S_FPP)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_DII(float p0, void* p1, struct S_DII p2,  float (*cb)(float, void*, struct S_DII)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_DIF(float p0, void* p1, struct S_DIF p2,  float (*cb)(float, void*, struct S_DIF)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_DID(float p0, void* p1, struct S_DID p2,  float (*cb)(float, void*, struct S_DID)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_DIP(float p0, void* p1, struct S_DIP p2,  float (*cb)(float, void*, struct S_DIP)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_DFI(float p0, void* p1, struct S_DFI p2,  float (*cb)(float, void*, struct S_DFI)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_DFF(float p0, void* p1, struct S_DFF p2,  float (*cb)(float, void*, struct S_DFF)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_DFD(float p0, void* p1, struct S_DFD p2,  float (*cb)(float, void*, struct S_DFD)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_DFP(float p0, void* p1, struct S_DFP p2,  float (*cb)(float, void*, struct S_DFP)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_DDI(float p0, void* p1, struct S_DDI p2,  float (*cb)(float, void*, struct S_DDI)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_DDF(float p0, void* p1, struct S_DDF p2,  float (*cb)(float, void*, struct S_DDF)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_DDD(float p0, void* p1, struct S_DDD p2,  float (*cb)(float, void*, struct S_DDD)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_DDP(float p0, void* p1, struct S_DDP p2,  float (*cb)(float, void*, struct S_DDP)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_DPI(float p0, void* p1, struct S_DPI p2,  float (*cb)(float, void*, struct S_DPI)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_DPF(float p0, void* p1, struct S_DPF p2,  float (*cb)(float, void*, struct S_DPF)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_DPD(float p0, void* p1, struct S_DPD p2,  float (*cb)(float, void*, struct S_DPD)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_DPP(float p0, void* p1, struct S_DPP p2,  float (*cb)(float, void*, struct S_DPP)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_PII(float p0, void* p1, struct S_PII p2,  float (*cb)(float, void*, struct S_PII)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_PIF(float p0, void* p1, struct S_PIF p2,  float (*cb)(float, void*, struct S_PIF)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_PID(float p0, void* p1, struct S_PID p2,  float (*cb)(float, void*, struct S_PID)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_PIP(float p0, void* p1, struct S_PIP p2,  float (*cb)(float, void*, struct S_PIP)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_PFI(float p0, void* p1, struct S_PFI p2,  float (*cb)(float, void*, struct S_PFI)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_PFF(float p0, void* p1, struct S_PFF p2,  float (*cb)(float, void*, struct S_PFF)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_PFD(float p0, void* p1, struct S_PFD p2,  float (*cb)(float, void*, struct S_PFD)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_PFP(float p0, void* p1, struct S_PFP p2,  float (*cb)(float, void*, struct S_PFP)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_PDI(float p0, void* p1, struct S_PDI p2,  float (*cb)(float, void*, struct S_PDI)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_PDF(float p0, void* p1, struct S_PDF p2,  float (*cb)(float, void*, struct S_PDF)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_PDD(float p0, void* p1, struct S_PDD p2,  float (*cb)(float, void*, struct S_PDD)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_PDP(float p0, void* p1, struct S_PDP p2,  float (*cb)(float, void*, struct S_PDP)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_PPI(float p0, void* p1, struct S_PPI p2,  float (*cb)(float, void*, struct S_PPI)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_PPF(float p0, void* p1, struct S_PPF p2,  float (*cb)(float, void*, struct S_PPF)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_PPD(float p0, void* p1, struct S_PPD p2,  float (*cb)(float, void*, struct S_PPD)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FPS_PPP(float p0, void* p1, struct S_PPP p2,  float (*cb)(float, void*, struct S_PPP)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_I(float p0, struct S_I p1, int p2,  float (*cb)(float, struct S_I, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_F(float p0, struct S_F p1, int p2,  float (*cb)(float, struct S_F, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_D(float p0, struct S_D p1, int p2,  float (*cb)(float, struct S_D, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_P(float p0, struct S_P p1, int p2,  float (*cb)(float, struct S_P, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_II(float p0, struct S_II p1, int p2,  float (*cb)(float, struct S_II, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_IF(float p0, struct S_IF p1, int p2,  float (*cb)(float, struct S_IF, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_ID(float p0, struct S_ID p1, int p2,  float (*cb)(float, struct S_ID, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_IP(float p0, struct S_IP p1, int p2,  float (*cb)(float, struct S_IP, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_FI(float p0, struct S_FI p1, int p2,  float (*cb)(float, struct S_FI, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_FF(float p0, struct S_FF p1, int p2,  float (*cb)(float, struct S_FF, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_FD(float p0, struct S_FD p1, int p2,  float (*cb)(float, struct S_FD, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_FP(float p0, struct S_FP p1, int p2,  float (*cb)(float, struct S_FP, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_DI(float p0, struct S_DI p1, int p2,  float (*cb)(float, struct S_DI, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_DF(float p0, struct S_DF p1, int p2,  float (*cb)(float, struct S_DF, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_DD(float p0, struct S_DD p1, int p2,  float (*cb)(float, struct S_DD, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_DP(float p0, struct S_DP p1, int p2,  float (*cb)(float, struct S_DP, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_PI(float p0, struct S_PI p1, int p2,  float (*cb)(float, struct S_PI, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_PF(float p0, struct S_PF p1, int p2,  float (*cb)(float, struct S_PF, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_PD(float p0, struct S_PD p1, int p2,  float (*cb)(float, struct S_PD, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_PP(float p0, struct S_PP p1, int p2,  float (*cb)(float, struct S_PP, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_III(float p0, struct S_III p1, int p2,  float (*cb)(float, struct S_III, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_IIF(float p0, struct S_IIF p1, int p2,  float (*cb)(float, struct S_IIF, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_IID(float p0, struct S_IID p1, int p2,  float (*cb)(float, struct S_IID, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_IIP(float p0, struct S_IIP p1, int p2,  float (*cb)(float, struct S_IIP, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_IFI(float p0, struct S_IFI p1, int p2,  float (*cb)(float, struct S_IFI, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_IFF(float p0, struct S_IFF p1, int p2,  float (*cb)(float, struct S_IFF, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_IFD(float p0, struct S_IFD p1, int p2,  float (*cb)(float, struct S_IFD, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_IFP(float p0, struct S_IFP p1, int p2,  float (*cb)(float, struct S_IFP, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_IDI(float p0, struct S_IDI p1, int p2,  float (*cb)(float, struct S_IDI, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_IDF(float p0, struct S_IDF p1, int p2,  float (*cb)(float, struct S_IDF, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_IDD(float p0, struct S_IDD p1, int p2,  float (*cb)(float, struct S_IDD, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_IDP(float p0, struct S_IDP p1, int p2,  float (*cb)(float, struct S_IDP, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_IPI(float p0, struct S_IPI p1, int p2,  float (*cb)(float, struct S_IPI, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_IPF(float p0, struct S_IPF p1, int p2,  float (*cb)(float, struct S_IPF, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_IPD(float p0, struct S_IPD p1, int p2,  float (*cb)(float, struct S_IPD, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_IPP(float p0, struct S_IPP p1, int p2,  float (*cb)(float, struct S_IPP, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_FII(float p0, struct S_FII p1, int p2,  float (*cb)(float, struct S_FII, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_FIF(float p0, struct S_FIF p1, int p2,  float (*cb)(float, struct S_FIF, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_FID(float p0, struct S_FID p1, int p2,  float (*cb)(float, struct S_FID, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_FIP(float p0, struct S_FIP p1, int p2,  float (*cb)(float, struct S_FIP, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_FFI(float p0, struct S_FFI p1, int p2,  float (*cb)(float, struct S_FFI, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_FFF(float p0, struct S_FFF p1, int p2,  float (*cb)(float, struct S_FFF, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_FFD(float p0, struct S_FFD p1, int p2,  float (*cb)(float, struct S_FFD, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_FFP(float p0, struct S_FFP p1, int p2,  float (*cb)(float, struct S_FFP, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_FDI(float p0, struct S_FDI p1, int p2,  float (*cb)(float, struct S_FDI, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_FDF(float p0, struct S_FDF p1, int p2,  float (*cb)(float, struct S_FDF, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_FDD(float p0, struct S_FDD p1, int p2,  float (*cb)(float, struct S_FDD, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_FDP(float p0, struct S_FDP p1, int p2,  float (*cb)(float, struct S_FDP, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_FPI(float p0, struct S_FPI p1, int p2,  float (*cb)(float, struct S_FPI, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_FPF(float p0, struct S_FPF p1, int p2,  float (*cb)(float, struct S_FPF, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_FPD(float p0, struct S_FPD p1, int p2,  float (*cb)(float, struct S_FPD, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_FPP(float p0, struct S_FPP p1, int p2,  float (*cb)(float, struct S_FPP, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_DII(float p0, struct S_DII p1, int p2,  float (*cb)(float, struct S_DII, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_DIF(float p0, struct S_DIF p1, int p2,  float (*cb)(float, struct S_DIF, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_DID(float p0, struct S_DID p1, int p2,  float (*cb)(float, struct S_DID, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_DIP(float p0, struct S_DIP p1, int p2,  float (*cb)(float, struct S_DIP, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_DFI(float p0, struct S_DFI p1, int p2,  float (*cb)(float, struct S_DFI, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_DFF(float p0, struct S_DFF p1, int p2,  float (*cb)(float, struct S_DFF, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_DFD(float p0, struct S_DFD p1, int p2,  float (*cb)(float, struct S_DFD, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_DFP(float p0, struct S_DFP p1, int p2,  float (*cb)(float, struct S_DFP, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_DDI(float p0, struct S_DDI p1, int p2,  float (*cb)(float, struct S_DDI, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_DDF(float p0, struct S_DDF p1, int p2,  float (*cb)(float, struct S_DDF, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_DDD(float p0, struct S_DDD p1, int p2,  float (*cb)(float, struct S_DDD, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_DDP(float p0, struct S_DDP p1, int p2,  float (*cb)(float, struct S_DDP, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_DPI(float p0, struct S_DPI p1, int p2,  float (*cb)(float, struct S_DPI, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_DPF(float p0, struct S_DPF p1, int p2,  float (*cb)(float, struct S_DPF, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_DPD(float p0, struct S_DPD p1, int p2,  float (*cb)(float, struct S_DPD, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_DPP(float p0, struct S_DPP p1, int p2,  float (*cb)(float, struct S_DPP, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_PII(float p0, struct S_PII p1, int p2,  float (*cb)(float, struct S_PII, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_PIF(float p0, struct S_PIF p1, int p2,  float (*cb)(float, struct S_PIF, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_PID(float p0, struct S_PID p1, int p2,  float (*cb)(float, struct S_PID, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_PIP(float p0, struct S_PIP p1, int p2,  float (*cb)(float, struct S_PIP, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_PFI(float p0, struct S_PFI p1, int p2,  float (*cb)(float, struct S_PFI, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_PFF(float p0, struct S_PFF p1, int p2,  float (*cb)(float, struct S_PFF, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_PFD(float p0, struct S_PFD p1, int p2,  float (*cb)(float, struct S_PFD, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_PFP(float p0, struct S_PFP p1, int p2,  float (*cb)(float, struct S_PFP, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_PDI(float p0, struct S_PDI p1, int p2,  float (*cb)(float, struct S_PDI, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_PDF(float p0, struct S_PDF p1, int p2,  float (*cb)(float, struct S_PDF, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_PDD(float p0, struct S_PDD p1, int p2,  float (*cb)(float, struct S_PDD, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_PDP(float p0, struct S_PDP p1, int p2,  float (*cb)(float, struct S_PDP, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_PPI(float p0, struct S_PPI p1, int p2,  float (*cb)(float, struct S_PPI, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_PPF(float p0, struct S_PPF p1, int p2,  float (*cb)(float, struct S_PPF, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_PPD(float p0, struct S_PPD p1, int p2,  float (*cb)(float, struct S_PPD, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSI_PPP(float p0, struct S_PPP p1, int p2,  float (*cb)(float, struct S_PPP, int)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_I(float p0, struct S_I p1, float p2,  float (*cb)(float, struct S_I, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_F(float p0, struct S_F p1, float p2,  float (*cb)(float, struct S_F, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_D(float p0, struct S_D p1, float p2,  float (*cb)(float, struct S_D, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_P(float p0, struct S_P p1, float p2,  float (*cb)(float, struct S_P, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_II(float p0, struct S_II p1, float p2,  float (*cb)(float, struct S_II, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_IF(float p0, struct S_IF p1, float p2,  float (*cb)(float, struct S_IF, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_ID(float p0, struct S_ID p1, float p2,  float (*cb)(float, struct S_ID, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_IP(float p0, struct S_IP p1, float p2,  float (*cb)(float, struct S_IP, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_FI(float p0, struct S_FI p1, float p2,  float (*cb)(float, struct S_FI, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_FF(float p0, struct S_FF p1, float p2,  float (*cb)(float, struct S_FF, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_FD(float p0, struct S_FD p1, float p2,  float (*cb)(float, struct S_FD, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_FP(float p0, struct S_FP p1, float p2,  float (*cb)(float, struct S_FP, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_DI(float p0, struct S_DI p1, float p2,  float (*cb)(float, struct S_DI, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_DF(float p0, struct S_DF p1, float p2,  float (*cb)(float, struct S_DF, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_DD(float p0, struct S_DD p1, float p2,  float (*cb)(float, struct S_DD, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_DP(float p0, struct S_DP p1, float p2,  float (*cb)(float, struct S_DP, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_PI(float p0, struct S_PI p1, float p2,  float (*cb)(float, struct S_PI, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_PF(float p0, struct S_PF p1, float p2,  float (*cb)(float, struct S_PF, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_PD(float p0, struct S_PD p1, float p2,  float (*cb)(float, struct S_PD, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_PP(float p0, struct S_PP p1, float p2,  float (*cb)(float, struct S_PP, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_III(float p0, struct S_III p1, float p2,  float (*cb)(float, struct S_III, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_IIF(float p0, struct S_IIF p1, float p2,  float (*cb)(float, struct S_IIF, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_IID(float p0, struct S_IID p1, float p2,  float (*cb)(float, struct S_IID, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_IIP(float p0, struct S_IIP p1, float p2,  float (*cb)(float, struct S_IIP, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_IFI(float p0, struct S_IFI p1, float p2,  float (*cb)(float, struct S_IFI, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_IFF(float p0, struct S_IFF p1, float p2,  float (*cb)(float, struct S_IFF, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_IFD(float p0, struct S_IFD p1, float p2,  float (*cb)(float, struct S_IFD, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_IFP(float p0, struct S_IFP p1, float p2,  float (*cb)(float, struct S_IFP, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_IDI(float p0, struct S_IDI p1, float p2,  float (*cb)(float, struct S_IDI, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_IDF(float p0, struct S_IDF p1, float p2,  float (*cb)(float, struct S_IDF, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_IDD(float p0, struct S_IDD p1, float p2,  float (*cb)(float, struct S_IDD, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_IDP(float p0, struct S_IDP p1, float p2,  float (*cb)(float, struct S_IDP, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_IPI(float p0, struct S_IPI p1, float p2,  float (*cb)(float, struct S_IPI, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_IPF(float p0, struct S_IPF p1, float p2,  float (*cb)(float, struct S_IPF, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_IPD(float p0, struct S_IPD p1, float p2,  float (*cb)(float, struct S_IPD, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_IPP(float p0, struct S_IPP p1, float p2,  float (*cb)(float, struct S_IPP, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_FII(float p0, struct S_FII p1, float p2,  float (*cb)(float, struct S_FII, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_FIF(float p0, struct S_FIF p1, float p2,  float (*cb)(float, struct S_FIF, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_FID(float p0, struct S_FID p1, float p2,  float (*cb)(float, struct S_FID, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_FIP(float p0, struct S_FIP p1, float p2,  float (*cb)(float, struct S_FIP, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_FFI(float p0, struct S_FFI p1, float p2,  float (*cb)(float, struct S_FFI, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_FFF(float p0, struct S_FFF p1, float p2,  float (*cb)(float, struct S_FFF, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_FFD(float p0, struct S_FFD p1, float p2,  float (*cb)(float, struct S_FFD, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_FFP(float p0, struct S_FFP p1, float p2,  float (*cb)(float, struct S_FFP, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_FDI(float p0, struct S_FDI p1, float p2,  float (*cb)(float, struct S_FDI, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_FDF(float p0, struct S_FDF p1, float p2,  float (*cb)(float, struct S_FDF, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_FDD(float p0, struct S_FDD p1, float p2,  float (*cb)(float, struct S_FDD, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_FDP(float p0, struct S_FDP p1, float p2,  float (*cb)(float, struct S_FDP, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_FPI(float p0, struct S_FPI p1, float p2,  float (*cb)(float, struct S_FPI, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_FPF(float p0, struct S_FPF p1, float p2,  float (*cb)(float, struct S_FPF, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_FPD(float p0, struct S_FPD p1, float p2,  float (*cb)(float, struct S_FPD, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_FPP(float p0, struct S_FPP p1, float p2,  float (*cb)(float, struct S_FPP, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_DII(float p0, struct S_DII p1, float p2,  float (*cb)(float, struct S_DII, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_DIF(float p0, struct S_DIF p1, float p2,  float (*cb)(float, struct S_DIF, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_DID(float p0, struct S_DID p1, float p2,  float (*cb)(float, struct S_DID, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_DIP(float p0, struct S_DIP p1, float p2,  float (*cb)(float, struct S_DIP, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_DFI(float p0, struct S_DFI p1, float p2,  float (*cb)(float, struct S_DFI, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_DFF(float p0, struct S_DFF p1, float p2,  float (*cb)(float, struct S_DFF, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_DFD(float p0, struct S_DFD p1, float p2,  float (*cb)(float, struct S_DFD, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_DFP(float p0, struct S_DFP p1, float p2,  float (*cb)(float, struct S_DFP, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_DDI(float p0, struct S_DDI p1, float p2,  float (*cb)(float, struct S_DDI, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_DDF(float p0, struct S_DDF p1, float p2,  float (*cb)(float, struct S_DDF, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_DDD(float p0, struct S_DDD p1, float p2,  float (*cb)(float, struct S_DDD, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_DDP(float p0, struct S_DDP p1, float p2,  float (*cb)(float, struct S_DDP, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_DPI(float p0, struct S_DPI p1, float p2,  float (*cb)(float, struct S_DPI, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_DPF(float p0, struct S_DPF p1, float p2,  float (*cb)(float, struct S_DPF, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_DPD(float p0, struct S_DPD p1, float p2,  float (*cb)(float, struct S_DPD, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_DPP(float p0, struct S_DPP p1, float p2,  float (*cb)(float, struct S_DPP, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_PII(float p0, struct S_PII p1, float p2,  float (*cb)(float, struct S_PII, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_PIF(float p0, struct S_PIF p1, float p2,  float (*cb)(float, struct S_PIF, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_PID(float p0, struct S_PID p1, float p2,  float (*cb)(float, struct S_PID, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_PIP(float p0, struct S_PIP p1, float p2,  float (*cb)(float, struct S_PIP, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_PFI(float p0, struct S_PFI p1, float p2,  float (*cb)(float, struct S_PFI, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_PFF(float p0, struct S_PFF p1, float p2,  float (*cb)(float, struct S_PFF, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_PFD(float p0, struct S_PFD p1, float p2,  float (*cb)(float, struct S_PFD, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_PFP(float p0, struct S_PFP p1, float p2,  float (*cb)(float, struct S_PFP, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_PDI(float p0, struct S_PDI p1, float p2,  float (*cb)(float, struct S_PDI, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_PDF(float p0, struct S_PDF p1, float p2,  float (*cb)(float, struct S_PDF, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_PDD(float p0, struct S_PDD p1, float p2,  float (*cb)(float, struct S_PDD, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_PDP(float p0, struct S_PDP p1, float p2,  float (*cb)(float, struct S_PDP, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_PPI(float p0, struct S_PPI p1, float p2,  float (*cb)(float, struct S_PPI, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_PPF(float p0, struct S_PPF p1, float p2,  float (*cb)(float, struct S_PPF, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_PPD(float p0, struct S_PPD p1, float p2,  float (*cb)(float, struct S_PPD, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSF_PPP(float p0, struct S_PPP p1, float p2,  float (*cb)(float, struct S_PPP, float)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_I(float p0, struct S_I p1, double p2,  float (*cb)(float, struct S_I, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_F(float p0, struct S_F p1, double p2,  float (*cb)(float, struct S_F, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_D(float p0, struct S_D p1, double p2,  float (*cb)(float, struct S_D, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_P(float p0, struct S_P p1, double p2,  float (*cb)(float, struct S_P, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_II(float p0, struct S_II p1, double p2,  float (*cb)(float, struct S_II, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_IF(float p0, struct S_IF p1, double p2,  float (*cb)(float, struct S_IF, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_ID(float p0, struct S_ID p1, double p2,  float (*cb)(float, struct S_ID, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_IP(float p0, struct S_IP p1, double p2,  float (*cb)(float, struct S_IP, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_FI(float p0, struct S_FI p1, double p2,  float (*cb)(float, struct S_FI, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_FF(float p0, struct S_FF p1, double p2,  float (*cb)(float, struct S_FF, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_FD(float p0, struct S_FD p1, double p2,  float (*cb)(float, struct S_FD, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_FP(float p0, struct S_FP p1, double p2,  float (*cb)(float, struct S_FP, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_DI(float p0, struct S_DI p1, double p2,  float (*cb)(float, struct S_DI, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_DF(float p0, struct S_DF p1, double p2,  float (*cb)(float, struct S_DF, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_DD(float p0, struct S_DD p1, double p2,  float (*cb)(float, struct S_DD, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_DP(float p0, struct S_DP p1, double p2,  float (*cb)(float, struct S_DP, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_PI(float p0, struct S_PI p1, double p2,  float (*cb)(float, struct S_PI, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_PF(float p0, struct S_PF p1, double p2,  float (*cb)(float, struct S_PF, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_PD(float p0, struct S_PD p1, double p2,  float (*cb)(float, struct S_PD, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_PP(float p0, struct S_PP p1, double p2,  float (*cb)(float, struct S_PP, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_III(float p0, struct S_III p1, double p2,  float (*cb)(float, struct S_III, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_IIF(float p0, struct S_IIF p1, double p2,  float (*cb)(float, struct S_IIF, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_IID(float p0, struct S_IID p1, double p2,  float (*cb)(float, struct S_IID, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_IIP(float p0, struct S_IIP p1, double p2,  float (*cb)(float, struct S_IIP, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_IFI(float p0, struct S_IFI p1, double p2,  float (*cb)(float, struct S_IFI, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_IFF(float p0, struct S_IFF p1, double p2,  float (*cb)(float, struct S_IFF, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_IFD(float p0, struct S_IFD p1, double p2,  float (*cb)(float, struct S_IFD, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_IFP(float p0, struct S_IFP p1, double p2,  float (*cb)(float, struct S_IFP, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_IDI(float p0, struct S_IDI p1, double p2,  float (*cb)(float, struct S_IDI, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_IDF(float p0, struct S_IDF p1, double p2,  float (*cb)(float, struct S_IDF, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_IDD(float p0, struct S_IDD p1, double p2,  float (*cb)(float, struct S_IDD, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_IDP(float p0, struct S_IDP p1, double p2,  float (*cb)(float, struct S_IDP, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_IPI(float p0, struct S_IPI p1, double p2,  float (*cb)(float, struct S_IPI, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_IPF(float p0, struct S_IPF p1, double p2,  float (*cb)(float, struct S_IPF, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_IPD(float p0, struct S_IPD p1, double p2,  float (*cb)(float, struct S_IPD, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_IPP(float p0, struct S_IPP p1, double p2,  float (*cb)(float, struct S_IPP, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_FII(float p0, struct S_FII p1, double p2,  float (*cb)(float, struct S_FII, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_FIF(float p0, struct S_FIF p1, double p2,  float (*cb)(float, struct S_FIF, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_FID(float p0, struct S_FID p1, double p2,  float (*cb)(float, struct S_FID, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_FIP(float p0, struct S_FIP p1, double p2,  float (*cb)(float, struct S_FIP, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_FFI(float p0, struct S_FFI p1, double p2,  float (*cb)(float, struct S_FFI, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_FFF(float p0, struct S_FFF p1, double p2,  float (*cb)(float, struct S_FFF, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_FFD(float p0, struct S_FFD p1, double p2,  float (*cb)(float, struct S_FFD, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_FFP(float p0, struct S_FFP p1, double p2,  float (*cb)(float, struct S_FFP, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_FDI(float p0, struct S_FDI p1, double p2,  float (*cb)(float, struct S_FDI, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_FDF(float p0, struct S_FDF p1, double p2,  float (*cb)(float, struct S_FDF, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_FDD(float p0, struct S_FDD p1, double p2,  float (*cb)(float, struct S_FDD, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_FDP(float p0, struct S_FDP p1, double p2,  float (*cb)(float, struct S_FDP, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_FPI(float p0, struct S_FPI p1, double p2,  float (*cb)(float, struct S_FPI, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_FPF(float p0, struct S_FPF p1, double p2,  float (*cb)(float, struct S_FPF, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_FPD(float p0, struct S_FPD p1, double p2,  float (*cb)(float, struct S_FPD, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_FPP(float p0, struct S_FPP p1, double p2,  float (*cb)(float, struct S_FPP, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_DII(float p0, struct S_DII p1, double p2,  float (*cb)(float, struct S_DII, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_DIF(float p0, struct S_DIF p1, double p2,  float (*cb)(float, struct S_DIF, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_DID(float p0, struct S_DID p1, double p2,  float (*cb)(float, struct S_DID, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_DIP(float p0, struct S_DIP p1, double p2,  float (*cb)(float, struct S_DIP, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_DFI(float p0, struct S_DFI p1, double p2,  float (*cb)(float, struct S_DFI, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_DFF(float p0, struct S_DFF p1, double p2,  float (*cb)(float, struct S_DFF, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_DFD(float p0, struct S_DFD p1, double p2,  float (*cb)(float, struct S_DFD, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_DFP(float p0, struct S_DFP p1, double p2,  float (*cb)(float, struct S_DFP, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_DDI(float p0, struct S_DDI p1, double p2,  float (*cb)(float, struct S_DDI, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_DDF(float p0, struct S_DDF p1, double p2,  float (*cb)(float, struct S_DDF, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_DDD(float p0, struct S_DDD p1, double p2,  float (*cb)(float, struct S_DDD, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_DDP(float p0, struct S_DDP p1, double p2,  float (*cb)(float, struct S_DDP, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_DPI(float p0, struct S_DPI p1, double p2,  float (*cb)(float, struct S_DPI, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_DPF(float p0, struct S_DPF p1, double p2,  float (*cb)(float, struct S_DPF, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_DPD(float p0, struct S_DPD p1, double p2,  float (*cb)(float, struct S_DPD, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_DPP(float p0, struct S_DPP p1, double p2,  float (*cb)(float, struct S_DPP, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_PII(float p0, struct S_PII p1, double p2,  float (*cb)(float, struct S_PII, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_PIF(float p0, struct S_PIF p1, double p2,  float (*cb)(float, struct S_PIF, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_PID(float p0, struct S_PID p1, double p2,  float (*cb)(float, struct S_PID, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_PIP(float p0, struct S_PIP p1, double p2,  float (*cb)(float, struct S_PIP, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_PFI(float p0, struct S_PFI p1, double p2,  float (*cb)(float, struct S_PFI, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_PFF(float p0, struct S_PFF p1, double p2,  float (*cb)(float, struct S_PFF, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_PFD(float p0, struct S_PFD p1, double p2,  float (*cb)(float, struct S_PFD, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_PFP(float p0, struct S_PFP p1, double p2,  float (*cb)(float, struct S_PFP, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_PDI(float p0, struct S_PDI p1, double p2,  float (*cb)(float, struct S_PDI, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_PDF(float p0, struct S_PDF p1, double p2,  float (*cb)(float, struct S_PDF, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_PDD(float p0, struct S_PDD p1, double p2,  float (*cb)(float, struct S_PDD, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_PDP(float p0, struct S_PDP p1, double p2,  float (*cb)(float, struct S_PDP, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_PPI(float p0, struct S_PPI p1, double p2,  float (*cb)(float, struct S_PPI, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_PPF(float p0, struct S_PPF p1, double p2,  float (*cb)(float, struct S_PPF, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_PPD(float p0, struct S_PPD p1, double p2,  float (*cb)(float, struct S_PPD, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSD_PPP(float p0, struct S_PPP p1, double p2,  float (*cb)(float, struct S_PPP, double)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_I(float p0, struct S_I p1, void* p2,  float (*cb)(float, struct S_I, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_F(float p0, struct S_F p1, void* p2,  float (*cb)(float, struct S_F, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_D(float p0, struct S_D p1, void* p2,  float (*cb)(float, struct S_D, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_P(float p0, struct S_P p1, void* p2,  float (*cb)(float, struct S_P, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_II(float p0, struct S_II p1, void* p2,  float (*cb)(float, struct S_II, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_IF(float p0, struct S_IF p1, void* p2,  float (*cb)(float, struct S_IF, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_ID(float p0, struct S_ID p1, void* p2,  float (*cb)(float, struct S_ID, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_IP(float p0, struct S_IP p1, void* p2,  float (*cb)(float, struct S_IP, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_FI(float p0, struct S_FI p1, void* p2,  float (*cb)(float, struct S_FI, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_FF(float p0, struct S_FF p1, void* p2,  float (*cb)(float, struct S_FF, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_FD(float p0, struct S_FD p1, void* p2,  float (*cb)(float, struct S_FD, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_FP(float p0, struct S_FP p1, void* p2,  float (*cb)(float, struct S_FP, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_DI(float p0, struct S_DI p1, void* p2,  float (*cb)(float, struct S_DI, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_DF(float p0, struct S_DF p1, void* p2,  float (*cb)(float, struct S_DF, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_DD(float p0, struct S_DD p1, void* p2,  float (*cb)(float, struct S_DD, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_DP(float p0, struct S_DP p1, void* p2,  float (*cb)(float, struct S_DP, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_PI(float p0, struct S_PI p1, void* p2,  float (*cb)(float, struct S_PI, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_PF(float p0, struct S_PF p1, void* p2,  float (*cb)(float, struct S_PF, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_PD(float p0, struct S_PD p1, void* p2,  float (*cb)(float, struct S_PD, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_PP(float p0, struct S_PP p1, void* p2,  float (*cb)(float, struct S_PP, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_III(float p0, struct S_III p1, void* p2,  float (*cb)(float, struct S_III, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_IIF(float p0, struct S_IIF p1, void* p2,  float (*cb)(float, struct S_IIF, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_IID(float p0, struct S_IID p1, void* p2,  float (*cb)(float, struct S_IID, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_IIP(float p0, struct S_IIP p1, void* p2,  float (*cb)(float, struct S_IIP, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_IFI(float p0, struct S_IFI p1, void* p2,  float (*cb)(float, struct S_IFI, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_IFF(float p0, struct S_IFF p1, void* p2,  float (*cb)(float, struct S_IFF, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_IFD(float p0, struct S_IFD p1, void* p2,  float (*cb)(float, struct S_IFD, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_IFP(float p0, struct S_IFP p1, void* p2,  float (*cb)(float, struct S_IFP, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_IDI(float p0, struct S_IDI p1, void* p2,  float (*cb)(float, struct S_IDI, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_IDF(float p0, struct S_IDF p1, void* p2,  float (*cb)(float, struct S_IDF, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_IDD(float p0, struct S_IDD p1, void* p2,  float (*cb)(float, struct S_IDD, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_IDP(float p0, struct S_IDP p1, void* p2,  float (*cb)(float, struct S_IDP, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_IPI(float p0, struct S_IPI p1, void* p2,  float (*cb)(float, struct S_IPI, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_IPF(float p0, struct S_IPF p1, void* p2,  float (*cb)(float, struct S_IPF, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_IPD(float p0, struct S_IPD p1, void* p2,  float (*cb)(float, struct S_IPD, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_IPP(float p0, struct S_IPP p1, void* p2,  float (*cb)(float, struct S_IPP, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_FII(float p0, struct S_FII p1, void* p2,  float (*cb)(float, struct S_FII, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_FIF(float p0, struct S_FIF p1, void* p2,  float (*cb)(float, struct S_FIF, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_FID(float p0, struct S_FID p1, void* p2,  float (*cb)(float, struct S_FID, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_FIP(float p0, struct S_FIP p1, void* p2,  float (*cb)(float, struct S_FIP, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_FFI(float p0, struct S_FFI p1, void* p2,  float (*cb)(float, struct S_FFI, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_FFF(float p0, struct S_FFF p1, void* p2,  float (*cb)(float, struct S_FFF, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_FFD(float p0, struct S_FFD p1, void* p2,  float (*cb)(float, struct S_FFD, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_FFP(float p0, struct S_FFP p1, void* p2,  float (*cb)(float, struct S_FFP, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_FDI(float p0, struct S_FDI p1, void* p2,  float (*cb)(float, struct S_FDI, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_FDF(float p0, struct S_FDF p1, void* p2,  float (*cb)(float, struct S_FDF, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_FDD(float p0, struct S_FDD p1, void* p2,  float (*cb)(float, struct S_FDD, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_FDP(float p0, struct S_FDP p1, void* p2,  float (*cb)(float, struct S_FDP, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_FPI(float p0, struct S_FPI p1, void* p2,  float (*cb)(float, struct S_FPI, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_FPF(float p0, struct S_FPF p1, void* p2,  float (*cb)(float, struct S_FPF, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_FPD(float p0, struct S_FPD p1, void* p2,  float (*cb)(float, struct S_FPD, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_FPP(float p0, struct S_FPP p1, void* p2,  float (*cb)(float, struct S_FPP, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_DII(float p0, struct S_DII p1, void* p2,  float (*cb)(float, struct S_DII, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_DIF(float p0, struct S_DIF p1, void* p2,  float (*cb)(float, struct S_DIF, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_DID(float p0, struct S_DID p1, void* p2,  float (*cb)(float, struct S_DID, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_DIP(float p0, struct S_DIP p1, void* p2,  float (*cb)(float, struct S_DIP, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_DFI(float p0, struct S_DFI p1, void* p2,  float (*cb)(float, struct S_DFI, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_DFF(float p0, struct S_DFF p1, void* p2,  float (*cb)(float, struct S_DFF, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_DFD(float p0, struct S_DFD p1, void* p2,  float (*cb)(float, struct S_DFD, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_DFP(float p0, struct S_DFP p1, void* p2,  float (*cb)(float, struct S_DFP, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_DDI(float p0, struct S_DDI p1, void* p2,  float (*cb)(float, struct S_DDI, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_DDF(float p0, struct S_DDF p1, void* p2,  float (*cb)(float, struct S_DDF, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_DDD(float p0, struct S_DDD p1, void* p2,  float (*cb)(float, struct S_DDD, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_DDP(float p0, struct S_DDP p1, void* p2,  float (*cb)(float, struct S_DDP, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_DPI(float p0, struct S_DPI p1, void* p2,  float (*cb)(float, struct S_DPI, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_DPF(float p0, struct S_DPF p1, void* p2,  float (*cb)(float, struct S_DPF, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_DPD(float p0, struct S_DPD p1, void* p2,  float (*cb)(float, struct S_DPD, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_DPP(float p0, struct S_DPP p1, void* p2,  float (*cb)(float, struct S_DPP, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_PII(float p0, struct S_PII p1, void* p2,  float (*cb)(float, struct S_PII, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_PIF(float p0, struct S_PIF p1, void* p2,  float (*cb)(float, struct S_PIF, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_PID(float p0, struct S_PID p1, void* p2,  float (*cb)(float, struct S_PID, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_PIP(float p0, struct S_PIP p1, void* p2,  float (*cb)(float, struct S_PIP, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_PFI(float p0, struct S_PFI p1, void* p2,  float (*cb)(float, struct S_PFI, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_PFF(float p0, struct S_PFF p1, void* p2,  float (*cb)(float, struct S_PFF, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_PFD(float p0, struct S_PFD p1, void* p2,  float (*cb)(float, struct S_PFD, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_PFP(float p0, struct S_PFP p1, void* p2,  float (*cb)(float, struct S_PFP, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_PDI(float p0, struct S_PDI p1, void* p2,  float (*cb)(float, struct S_PDI, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_PDF(float p0, struct S_PDF p1, void* p2,  float (*cb)(float, struct S_PDF, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_PDD(float p0, struct S_PDD p1, void* p2,  float (*cb)(float, struct S_PDD, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_PDP(float p0, struct S_PDP p1, void* p2,  float (*cb)(float, struct S_PDP, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_PPI(float p0, struct S_PPI p1, void* p2,  float (*cb)(float, struct S_PPI, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_PPF(float p0, struct S_PPF p1, void* p2,  float (*cb)(float, struct S_PPF, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_PPD(float p0, struct S_PPD p1, void* p2,  float (*cb)(float, struct S_PPD, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSP_PPP(float p0, struct S_PPP p1, void* p2,  float (*cb)(float, struct S_PPP, void*)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSS_I(float p0, struct S_I p1, struct S_I p2,  float (*cb)(float, struct S_I, struct S_I)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSS_F(float p0, struct S_F p1, struct S_F p2,  float (*cb)(float, struct S_F, struct S_F)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSS_D(float p0, struct S_D p1, struct S_D p2,  float (*cb)(float, struct S_D, struct S_D)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSS_P(float p0, struct S_P p1, struct S_P p2,  float (*cb)(float, struct S_P, struct S_P)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSS_II(float p0, struct S_II p1, struct S_II p2,  float (*cb)(float, struct S_II, struct S_II)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSS_IF(float p0, struct S_IF p1, struct S_IF p2,  float (*cb)(float, struct S_IF, struct S_IF)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSS_ID(float p0, struct S_ID p1, struct S_ID p2,  float (*cb)(float, struct S_ID, struct S_ID)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSS_IP(float p0, struct S_IP p1, struct S_IP p2,  float (*cb)(float, struct S_IP, struct S_IP)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSS_FI(float p0, struct S_FI p1, struct S_FI p2,  float (*cb)(float, struct S_FI, struct S_FI)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSS_FF(float p0, struct S_FF p1, struct S_FF p2,  float (*cb)(float, struct S_FF, struct S_FF)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSS_FD(float p0, struct S_FD p1, struct S_FD p2,  float (*cb)(float, struct S_FD, struct S_FD)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSS_FP(float p0, struct S_FP p1, struct S_FP p2,  float (*cb)(float, struct S_FP, struct S_FP)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSS_DI(float p0, struct S_DI p1, struct S_DI p2,  float (*cb)(float, struct S_DI, struct S_DI)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSS_DF(float p0, struct S_DF p1, struct S_DF p2,  float (*cb)(float, struct S_DF, struct S_DF)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSS_DD(float p0, struct S_DD p1, struct S_DD p2,  float (*cb)(float, struct S_DD, struct S_DD)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSS_DP(float p0, struct S_DP p1, struct S_DP p2,  float (*cb)(float, struct S_DP, struct S_DP)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSS_PI(float p0, struct S_PI p1, struct S_PI p2,  float (*cb)(float, struct S_PI, struct S_PI)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSS_PF(float p0, struct S_PF p1, struct S_PF p2,  float (*cb)(float, struct S_PF, struct S_PF)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSS_PD(float p0, struct S_PD p1, struct S_PD p2,  float (*cb)(float, struct S_PD, struct S_PD)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSS_PP(float p0, struct S_PP p1, struct S_PP p2,  float (*cb)(float, struct S_PP, struct S_PP)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSS_III(float p0, struct S_III p1, struct S_III p2,  float (*cb)(float, struct S_III, struct S_III)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSS_IIF(float p0, struct S_IIF p1, struct S_IIF p2,  float (*cb)(float, struct S_IIF, struct S_IIF)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSS_IID(float p0, struct S_IID p1, struct S_IID p2,  float (*cb)(float, struct S_IID, struct S_IID)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSS_IIP(float p0, struct S_IIP p1, struct S_IIP p2,  float (*cb)(float, struct S_IIP, struct S_IIP)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSS_IFI(float p0, struct S_IFI p1, struct S_IFI p2,  float (*cb)(float, struct S_IFI, struct S_IFI)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSS_IFF(float p0, struct S_IFF p1, struct S_IFF p2,  float (*cb)(float, struct S_IFF, struct S_IFF)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSS_IFD(float p0, struct S_IFD p1, struct S_IFD p2,  float (*cb)(float, struct S_IFD, struct S_IFD)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSS_IFP(float p0, struct S_IFP p1, struct S_IFP p2,  float (*cb)(float, struct S_IFP, struct S_IFP)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSS_IDI(float p0, struct S_IDI p1, struct S_IDI p2,  float (*cb)(float, struct S_IDI, struct S_IDI)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSS_IDF(float p0, struct S_IDF p1, struct S_IDF p2,  float (*cb)(float, struct S_IDF, struct S_IDF)) { return cb(p0,p1,p2); }
+EXPORT float f13_F_FSS_IDD(float p0, struct S_IDD p1, struct S_IDD p2,  float (*cb)(float, struct S_IDD, struct S_IDD)) { return cb(p0,p1,p2); }
+EXPORT float f14_F_FSS_IDP(float p0, struct S_IDP p1, struct S_IDP p2,  float (*cb)(float, struct S_IDP, struct S_IDP)) { return cb(p0,p1,p2); }
+EXPORT float f14_F_FSS_IPI(float p0, struct S_IPI p1, struct S_IPI p2,  float (*cb)(float, struct S_IPI, struct S_IPI)) { return cb(p0,p1,p2); }
+EXPORT float f14_F_FSS_IPF(float p0, struct S_IPF p1, struct S_IPF p2,  float (*cb)(float, struct S_IPF, struct S_IPF)) { return cb(p0,p1,p2); }
+EXPORT float f14_F_FSS_IPD(float p0, struct S_IPD p1, struct S_IPD p2,  float (*cb)(float, struct S_IPD, struct S_IPD)) { return cb(p0,p1,p2); }
+EXPORT float f14_F_FSS_IPP(float p0, struct S_IPP p1, struct S_IPP p2,  float (*cb)(float, struct S_IPP, struct S_IPP)) { return cb(p0,p1,p2); }
+EXPORT float f14_F_FSS_FII(float p0, struct S_FII p1, struct S_FII p2,  float (*cb)(float, struct S_FII, struct S_FII)) { return cb(p0,p1,p2); }
+EXPORT float f14_F_FSS_FIF(float p0, struct S_FIF p1, struct S_FIF p2,  float (*cb)(float, struct S_FIF, struct S_FIF)) { return cb(p0,p1,p2); }
+EXPORT float f14_F_FSS_FID(float p0, struct S_FID p1, struct S_FID p2,  float (*cb)(float, struct S_FID, struct S_FID)) { return cb(p0,p1,p2); }
+EXPORT float f14_F_FSS_FIP(float p0, struct S_FIP p1, struct S_FIP p2,  float (*cb)(float, struct S_FIP, struct S_FIP)) { return cb(p0,p1,p2); }
+EXPORT float f14_F_FSS_FFI(float p0, struct S_FFI p1, struct S_FFI p2,  float (*cb)(float, struct S_FFI, struct S_FFI)) { return cb(p0,p1,p2); }
+EXPORT float f14_F_FSS_FFF(float p0, struct S_FFF p1, struct S_FFF p2,  float (*cb)(float, struct S_FFF, struct S_FFF)) { return cb(p0,p1,p2); }
+EXPORT float f14_F_FSS_FFD(float p0, struct S_FFD p1, struct S_FFD p2,  float (*cb)(float, struct S_FFD, struct S_FFD)) { return cb(p0,p1,p2); }
+EXPORT float f14_F_FSS_FFP(float p0, struct S_FFP p1, struct S_FFP p2,  float (*cb)(float, struct S_FFP, struct S_FFP)) { return cb(p0,p1,p2); }
+EXPORT float f14_F_FSS_FDI(float p0, struct S_FDI p1, struct S_FDI p2,  float (*cb)(float, struct S_FDI, struct S_FDI)) { return cb(p0,p1,p2); }
+EXPORT float f14_F_FSS_FDF(float p0, struct S_FDF p1, struct S_FDF p2,  float (*cb)(float, struct S_FDF, struct S_FDF)) { return cb(p0,p1,p2); }
+EXPORT float f14_F_FSS_FDD(float p0, struct S_FDD p1, struct S_FDD p2,  float (*cb)(float, struct S_FDD, struct S_FDD)) { return cb(p0,p1,p2); }
+EXPORT float f14_F_FSS_FDP(float p0, struct S_FDP p1, struct S_FDP p2,  float (*cb)(float, struct S_FDP, struct S_FDP)) { return cb(p0,p1,p2); }
+EXPORT float f14_F_FSS_FPI(float p0, struct S_FPI p1, struct S_FPI p2,  float (*cb)(float, struct S_FPI, struct S_FPI)) { return cb(p0,p1,p2); }
+EXPORT float f14_F_FSS_FPF(float p0, struct S_FPF p1, struct S_FPF p2,  float (*cb)(float, struct S_FPF, struct S_FPF)) { return cb(p0,p1,p2); }
+EXPORT float f14_F_FSS_FPD(float p0, struct S_FPD p1, struct S_FPD p2,  float (*cb)(float, struct S_FPD, struct S_FPD)) { return cb(p0,p1,p2); }
+EXPORT float f14_F_FSS_FPP(float p0, struct S_FPP p1, struct S_FPP p2,  float (*cb)(float, struct S_FPP, struct S_FPP)) { return cb(p0,p1,p2); }
+EXPORT float f14_F_FSS_DII(float p0, struct S_DII p1, struct S_DII p2,  float (*cb)(float, struct S_DII, struct S_DII)) { return cb(p0,p1,p2); }
+EXPORT float f14_F_FSS_DIF(float p0, struct S_DIF p1, struct S_DIF p2,  float (*cb)(float, struct S_DIF, struct S_DIF)) { return cb(p0,p1,p2); }
+EXPORT float f14_F_FSS_DID(float p0, struct S_DID p1, struct S_DID p2,  float (*cb)(float, struct S_DID, struct S_DID)) { return cb(p0,p1,p2); }
+EXPORT float f14_F_FSS_DIP(float p0, struct S_DIP p1, struct S_DIP p2,  float (*cb)(float, struct S_DIP, struct S_DIP)) { return cb(p0,p1,p2); }
+EXPORT float f14_F_FSS_DFI(float p0, struct S_DFI p1, struct S_DFI p2,  float (*cb)(float, struct S_DFI, struct S_DFI)) { return cb(p0,p1,p2); }
+EXPORT float f14_F_FSS_DFF(float p0, struct S_DFF p1, struct S_DFF p2,  float (*cb)(float, struct S_DFF, struct S_DFF)) { return cb(p0,p1,p2); }
+EXPORT float f14_F_FSS_DFD(float p0, struct S_DFD p1, struct S_DFD p2,  float (*cb)(float, struct S_DFD, struct S_DFD)) { return cb(p0,p1,p2); }
+EXPORT float f14_F_FSS_DFP(float p0, struct S_DFP p1, struct S_DFP p2,  float (*cb)(float, struct S_DFP, struct S_DFP)) { return cb(p0,p1,p2); }
+EXPORT float f14_F_FSS_DDI(float p0, struct S_DDI p1, struct S_DDI p2,  float (*cb)(float, struct S_DDI, struct S_DDI)) { return cb(p0,p1,p2); }
+EXPORT float f14_F_FSS_DDF(float p0, struct S_DDF p1, struct S_DDF p2,  float (*cb)(float, struct S_DDF, struct S_DDF)) { return cb(p0,p1,p2); }
+EXPORT float f14_F_FSS_DDD(float p0, struct S_DDD p1, struct S_DDD p2,  float (*cb)(float, struct S_DDD, struct S_DDD)) { return cb(p0,p1,p2); }
+EXPORT float f14_F_FSS_DDP(float p0, struct S_DDP p1, struct S_DDP p2,  float (*cb)(float, struct S_DDP, struct S_DDP)) { return cb(p0,p1,p2); }
+EXPORT float f14_F_FSS_DPI(float p0, struct S_DPI p1, struct S_DPI p2,  float (*cb)(float, struct S_DPI, struct S_DPI)) { return cb(p0,p1,p2); }
+EXPORT float f14_F_FSS_DPF(float p0, struct S_DPF p1, struct S_DPF p2,  float (*cb)(float, struct S_DPF, struct S_DPF)) { return cb(p0,p1,p2); }
+EXPORT float f14_F_FSS_DPD(float p0, struct S_DPD p1, struct S_DPD p2,  float (*cb)(float, struct S_DPD, struct S_DPD)) { return cb(p0,p1,p2); }
+EXPORT float f14_F_FSS_DPP(float p0, struct S_DPP p1, struct S_DPP p2,  float (*cb)(float, struct S_DPP, struct S_DPP)) { return cb(p0,p1,p2); }
+EXPORT float f14_F_FSS_PII(float p0, struct S_PII p1, struct S_PII p2,  float (*cb)(float, struct S_PII, struct S_PII)) { return cb(p0,p1,p2); }
+EXPORT float f14_F_FSS_PIF(float p0, struct S_PIF p1, struct S_PIF p2,  float (*cb)(float, struct S_PIF, struct S_PIF)) { return cb(p0,p1,p2); }
+EXPORT float f14_F_FSS_PID(float p0, struct S_PID p1, struct S_PID p2,  float (*cb)(float, struct S_PID, struct S_PID)) { return cb(p0,p1,p2); }
+EXPORT float f14_F_FSS_PIP(float p0, struct S_PIP p1, struct S_PIP p2,  float (*cb)(float, struct S_PIP, struct S_PIP)) { return cb(p0,p1,p2); }
+EXPORT float f14_F_FSS_PFI(float p0, struct S_PFI p1, struct S_PFI p2,  float (*cb)(float, struct S_PFI, struct S_PFI)) { return cb(p0,p1,p2); }
+EXPORT float f14_F_FSS_PFF(float p0, struct S_PFF p1, struct S_PFF p2,  float (*cb)(float, struct S_PFF, struct S_PFF)) { return cb(p0,p1,p2); }
+EXPORT float f14_F_FSS_PFD(float p0, struct S_PFD p1, struct S_PFD p2,  float (*cb)(float, struct S_PFD, struct S_PFD)) { return cb(p0,p1,p2); }
+EXPORT float f14_F_FSS_PFP(float p0, struct S_PFP p1, struct S_PFP p2,  float (*cb)(float, struct S_PFP, struct S_PFP)) { return cb(p0,p1,p2); }
+EXPORT float f14_F_FSS_PDI(float p0, struct S_PDI p1, struct S_PDI p2,  float (*cb)(float, struct S_PDI, struct S_PDI)) { return cb(p0,p1,p2); }
+EXPORT float f14_F_FSS_PDF(float p0, struct S_PDF p1, struct S_PDF p2,  float (*cb)(float, struct S_PDF, struct S_PDF)) { return cb(p0,p1,p2); }
+EXPORT float f14_F_FSS_PDD(float p0, struct S_PDD p1, struct S_PDD p2,  float (*cb)(float, struct S_PDD, struct S_PDD)) { return cb(p0,p1,p2); }
+EXPORT float f14_F_FSS_PDP(float p0, struct S_PDP p1, struct S_PDP p2,  float (*cb)(float, struct S_PDP, struct S_PDP)) { return cb(p0,p1,p2); }
+EXPORT float f14_F_FSS_PPI(float p0, struct S_PPI p1, struct S_PPI p2,  float (*cb)(float, struct S_PPI, struct S_PPI)) { return cb(p0,p1,p2); }
+EXPORT float f14_F_FSS_PPF(float p0, struct S_PPF p1, struct S_PPF p2,  float (*cb)(float, struct S_PPF, struct S_PPF)) { return cb(p0,p1,p2); }
+EXPORT float f14_F_FSS_PPD(float p0, struct S_PPD p1, struct S_PPD p2,  float (*cb)(float, struct S_PPD, struct S_PPD)) { return cb(p0,p1,p2); }
+EXPORT float f14_F_FSS_PPP(float p0, struct S_PPP p1, struct S_PPP p2,  float (*cb)(float, struct S_PPP, struct S_PPP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DII_(double p0, int p1, int p2,  double (*cb)(double, int, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIF_(double p0, int p1, float p2,  double (*cb)(double, int, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DID_(double p0, int p1, double p2,  double (*cb)(double, int, double)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIP_(double p0, int p1, void* p2,  double (*cb)(double, int, void*)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_I(double p0, int p1, struct S_I p2,  double (*cb)(double, int, struct S_I)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_F(double p0, int p1, struct S_F p2,  double (*cb)(double, int, struct S_F)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_D(double p0, int p1, struct S_D p2,  double (*cb)(double, int, struct S_D)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_P(double p0, int p1, struct S_P p2,  double (*cb)(double, int, struct S_P)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_II(double p0, int p1, struct S_II p2,  double (*cb)(double, int, struct S_II)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_IF(double p0, int p1, struct S_IF p2,  double (*cb)(double, int, struct S_IF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_ID(double p0, int p1, struct S_ID p2,  double (*cb)(double, int, struct S_ID)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_IP(double p0, int p1, struct S_IP p2,  double (*cb)(double, int, struct S_IP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_FI(double p0, int p1, struct S_FI p2,  double (*cb)(double, int, struct S_FI)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_FF(double p0, int p1, struct S_FF p2,  double (*cb)(double, int, struct S_FF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_FD(double p0, int p1, struct S_FD p2,  double (*cb)(double, int, struct S_FD)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_FP(double p0, int p1, struct S_FP p2,  double (*cb)(double, int, struct S_FP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_DI(double p0, int p1, struct S_DI p2,  double (*cb)(double, int, struct S_DI)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_DF(double p0, int p1, struct S_DF p2,  double (*cb)(double, int, struct S_DF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_DD(double p0, int p1, struct S_DD p2,  double (*cb)(double, int, struct S_DD)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_DP(double p0, int p1, struct S_DP p2,  double (*cb)(double, int, struct S_DP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_PI(double p0, int p1, struct S_PI p2,  double (*cb)(double, int, struct S_PI)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_PF(double p0, int p1, struct S_PF p2,  double (*cb)(double, int, struct S_PF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_PD(double p0, int p1, struct S_PD p2,  double (*cb)(double, int, struct S_PD)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_PP(double p0, int p1, struct S_PP p2,  double (*cb)(double, int, struct S_PP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_III(double p0, int p1, struct S_III p2,  double (*cb)(double, int, struct S_III)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_IIF(double p0, int p1, struct S_IIF p2,  double (*cb)(double, int, struct S_IIF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_IID(double p0, int p1, struct S_IID p2,  double (*cb)(double, int, struct S_IID)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_IIP(double p0, int p1, struct S_IIP p2,  double (*cb)(double, int, struct S_IIP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_IFI(double p0, int p1, struct S_IFI p2,  double (*cb)(double, int, struct S_IFI)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_IFF(double p0, int p1, struct S_IFF p2,  double (*cb)(double, int, struct S_IFF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_IFD(double p0, int p1, struct S_IFD p2,  double (*cb)(double, int, struct S_IFD)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_IFP(double p0, int p1, struct S_IFP p2,  double (*cb)(double, int, struct S_IFP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_IDI(double p0, int p1, struct S_IDI p2,  double (*cb)(double, int, struct S_IDI)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_IDF(double p0, int p1, struct S_IDF p2,  double (*cb)(double, int, struct S_IDF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_IDD(double p0, int p1, struct S_IDD p2,  double (*cb)(double, int, struct S_IDD)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_IDP(double p0, int p1, struct S_IDP p2,  double (*cb)(double, int, struct S_IDP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_IPI(double p0, int p1, struct S_IPI p2,  double (*cb)(double, int, struct S_IPI)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_IPF(double p0, int p1, struct S_IPF p2,  double (*cb)(double, int, struct S_IPF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_IPD(double p0, int p1, struct S_IPD p2,  double (*cb)(double, int, struct S_IPD)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_IPP(double p0, int p1, struct S_IPP p2,  double (*cb)(double, int, struct S_IPP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_FII(double p0, int p1, struct S_FII p2,  double (*cb)(double, int, struct S_FII)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_FIF(double p0, int p1, struct S_FIF p2,  double (*cb)(double, int, struct S_FIF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_FID(double p0, int p1, struct S_FID p2,  double (*cb)(double, int, struct S_FID)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_FIP(double p0, int p1, struct S_FIP p2,  double (*cb)(double, int, struct S_FIP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_FFI(double p0, int p1, struct S_FFI p2,  double (*cb)(double, int, struct S_FFI)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_FFF(double p0, int p1, struct S_FFF p2,  double (*cb)(double, int, struct S_FFF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_FFD(double p0, int p1, struct S_FFD p2,  double (*cb)(double, int, struct S_FFD)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_FFP(double p0, int p1, struct S_FFP p2,  double (*cb)(double, int, struct S_FFP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_FDI(double p0, int p1, struct S_FDI p2,  double (*cb)(double, int, struct S_FDI)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_FDF(double p0, int p1, struct S_FDF p2,  double (*cb)(double, int, struct S_FDF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_FDD(double p0, int p1, struct S_FDD p2,  double (*cb)(double, int, struct S_FDD)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_FDP(double p0, int p1, struct S_FDP p2,  double (*cb)(double, int, struct S_FDP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_FPI(double p0, int p1, struct S_FPI p2,  double (*cb)(double, int, struct S_FPI)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_FPF(double p0, int p1, struct S_FPF p2,  double (*cb)(double, int, struct S_FPF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_FPD(double p0, int p1, struct S_FPD p2,  double (*cb)(double, int, struct S_FPD)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_FPP(double p0, int p1, struct S_FPP p2,  double (*cb)(double, int, struct S_FPP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_DII(double p0, int p1, struct S_DII p2,  double (*cb)(double, int, struct S_DII)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_DIF(double p0, int p1, struct S_DIF p2,  double (*cb)(double, int, struct S_DIF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_DID(double p0, int p1, struct S_DID p2,  double (*cb)(double, int, struct S_DID)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_DIP(double p0, int p1, struct S_DIP p2,  double (*cb)(double, int, struct S_DIP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_DFI(double p0, int p1, struct S_DFI p2,  double (*cb)(double, int, struct S_DFI)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_DFF(double p0, int p1, struct S_DFF p2,  double (*cb)(double, int, struct S_DFF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_DFD(double p0, int p1, struct S_DFD p2,  double (*cb)(double, int, struct S_DFD)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_DFP(double p0, int p1, struct S_DFP p2,  double (*cb)(double, int, struct S_DFP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_DDI(double p0, int p1, struct S_DDI p2,  double (*cb)(double, int, struct S_DDI)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_DDF(double p0, int p1, struct S_DDF p2,  double (*cb)(double, int, struct S_DDF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_DDD(double p0, int p1, struct S_DDD p2,  double (*cb)(double, int, struct S_DDD)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_DDP(double p0, int p1, struct S_DDP p2,  double (*cb)(double, int, struct S_DDP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_DPI(double p0, int p1, struct S_DPI p2,  double (*cb)(double, int, struct S_DPI)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_DPF(double p0, int p1, struct S_DPF p2,  double (*cb)(double, int, struct S_DPF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_DPD(double p0, int p1, struct S_DPD p2,  double (*cb)(double, int, struct S_DPD)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_DPP(double p0, int p1, struct S_DPP p2,  double (*cb)(double, int, struct S_DPP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_PII(double p0, int p1, struct S_PII p2,  double (*cb)(double, int, struct S_PII)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_PIF(double p0, int p1, struct S_PIF p2,  double (*cb)(double, int, struct S_PIF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_PID(double p0, int p1, struct S_PID p2,  double (*cb)(double, int, struct S_PID)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_PIP(double p0, int p1, struct S_PIP p2,  double (*cb)(double, int, struct S_PIP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_PFI(double p0, int p1, struct S_PFI p2,  double (*cb)(double, int, struct S_PFI)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_PFF(double p0, int p1, struct S_PFF p2,  double (*cb)(double, int, struct S_PFF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_PFD(double p0, int p1, struct S_PFD p2,  double (*cb)(double, int, struct S_PFD)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_PFP(double p0, int p1, struct S_PFP p2,  double (*cb)(double, int, struct S_PFP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_PDI(double p0, int p1, struct S_PDI p2,  double (*cb)(double, int, struct S_PDI)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_PDF(double p0, int p1, struct S_PDF p2,  double (*cb)(double, int, struct S_PDF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_PDD(double p0, int p1, struct S_PDD p2,  double (*cb)(double, int, struct S_PDD)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_PDP(double p0, int p1, struct S_PDP p2,  double (*cb)(double, int, struct S_PDP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_PPI(double p0, int p1, struct S_PPI p2,  double (*cb)(double, int, struct S_PPI)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_PPF(double p0, int p1, struct S_PPF p2,  double (*cb)(double, int, struct S_PPF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_PPD(double p0, int p1, struct S_PPD p2,  double (*cb)(double, int, struct S_PPD)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DIS_PPP(double p0, int p1, struct S_PPP p2,  double (*cb)(double, int, struct S_PPP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFI_(double p0, float p1, int p2,  double (*cb)(double, float, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFF_(double p0, float p1, float p2,  double (*cb)(double, float, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFD_(double p0, float p1, double p2,  double (*cb)(double, float, double)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFP_(double p0, float p1, void* p2,  double (*cb)(double, float, void*)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_I(double p0, float p1, struct S_I p2,  double (*cb)(double, float, struct S_I)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_F(double p0, float p1, struct S_F p2,  double (*cb)(double, float, struct S_F)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_D(double p0, float p1, struct S_D p2,  double (*cb)(double, float, struct S_D)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_P(double p0, float p1, struct S_P p2,  double (*cb)(double, float, struct S_P)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_II(double p0, float p1, struct S_II p2,  double (*cb)(double, float, struct S_II)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_IF(double p0, float p1, struct S_IF p2,  double (*cb)(double, float, struct S_IF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_ID(double p0, float p1, struct S_ID p2,  double (*cb)(double, float, struct S_ID)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_IP(double p0, float p1, struct S_IP p2,  double (*cb)(double, float, struct S_IP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_FI(double p0, float p1, struct S_FI p2,  double (*cb)(double, float, struct S_FI)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_FF(double p0, float p1, struct S_FF p2,  double (*cb)(double, float, struct S_FF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_FD(double p0, float p1, struct S_FD p2,  double (*cb)(double, float, struct S_FD)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_FP(double p0, float p1, struct S_FP p2,  double (*cb)(double, float, struct S_FP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_DI(double p0, float p1, struct S_DI p2,  double (*cb)(double, float, struct S_DI)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_DF(double p0, float p1, struct S_DF p2,  double (*cb)(double, float, struct S_DF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_DD(double p0, float p1, struct S_DD p2,  double (*cb)(double, float, struct S_DD)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_DP(double p0, float p1, struct S_DP p2,  double (*cb)(double, float, struct S_DP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_PI(double p0, float p1, struct S_PI p2,  double (*cb)(double, float, struct S_PI)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_PF(double p0, float p1, struct S_PF p2,  double (*cb)(double, float, struct S_PF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_PD(double p0, float p1, struct S_PD p2,  double (*cb)(double, float, struct S_PD)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_PP(double p0, float p1, struct S_PP p2,  double (*cb)(double, float, struct S_PP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_III(double p0, float p1, struct S_III p2,  double (*cb)(double, float, struct S_III)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_IIF(double p0, float p1, struct S_IIF p2,  double (*cb)(double, float, struct S_IIF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_IID(double p0, float p1, struct S_IID p2,  double (*cb)(double, float, struct S_IID)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_IIP(double p0, float p1, struct S_IIP p2,  double (*cb)(double, float, struct S_IIP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_IFI(double p0, float p1, struct S_IFI p2,  double (*cb)(double, float, struct S_IFI)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_IFF(double p0, float p1, struct S_IFF p2,  double (*cb)(double, float, struct S_IFF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_IFD(double p0, float p1, struct S_IFD p2,  double (*cb)(double, float, struct S_IFD)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_IFP(double p0, float p1, struct S_IFP p2,  double (*cb)(double, float, struct S_IFP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_IDI(double p0, float p1, struct S_IDI p2,  double (*cb)(double, float, struct S_IDI)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_IDF(double p0, float p1, struct S_IDF p2,  double (*cb)(double, float, struct S_IDF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_IDD(double p0, float p1, struct S_IDD p2,  double (*cb)(double, float, struct S_IDD)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_IDP(double p0, float p1, struct S_IDP p2,  double (*cb)(double, float, struct S_IDP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_IPI(double p0, float p1, struct S_IPI p2,  double (*cb)(double, float, struct S_IPI)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_IPF(double p0, float p1, struct S_IPF p2,  double (*cb)(double, float, struct S_IPF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_IPD(double p0, float p1, struct S_IPD p2,  double (*cb)(double, float, struct S_IPD)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_IPP(double p0, float p1, struct S_IPP p2,  double (*cb)(double, float, struct S_IPP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_FII(double p0, float p1, struct S_FII p2,  double (*cb)(double, float, struct S_FII)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_FIF(double p0, float p1, struct S_FIF p2,  double (*cb)(double, float, struct S_FIF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_FID(double p0, float p1, struct S_FID p2,  double (*cb)(double, float, struct S_FID)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_FIP(double p0, float p1, struct S_FIP p2,  double (*cb)(double, float, struct S_FIP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_FFI(double p0, float p1, struct S_FFI p2,  double (*cb)(double, float, struct S_FFI)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_FFF(double p0, float p1, struct S_FFF p2,  double (*cb)(double, float, struct S_FFF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_FFD(double p0, float p1, struct S_FFD p2,  double (*cb)(double, float, struct S_FFD)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_FFP(double p0, float p1, struct S_FFP p2,  double (*cb)(double, float, struct S_FFP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_FDI(double p0, float p1, struct S_FDI p2,  double (*cb)(double, float, struct S_FDI)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_FDF(double p0, float p1, struct S_FDF p2,  double (*cb)(double, float, struct S_FDF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_FDD(double p0, float p1, struct S_FDD p2,  double (*cb)(double, float, struct S_FDD)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_FDP(double p0, float p1, struct S_FDP p2,  double (*cb)(double, float, struct S_FDP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_FPI(double p0, float p1, struct S_FPI p2,  double (*cb)(double, float, struct S_FPI)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_FPF(double p0, float p1, struct S_FPF p2,  double (*cb)(double, float, struct S_FPF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_FPD(double p0, float p1, struct S_FPD p2,  double (*cb)(double, float, struct S_FPD)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_FPP(double p0, float p1, struct S_FPP p2,  double (*cb)(double, float, struct S_FPP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_DII(double p0, float p1, struct S_DII p2,  double (*cb)(double, float, struct S_DII)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_DIF(double p0, float p1, struct S_DIF p2,  double (*cb)(double, float, struct S_DIF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_DID(double p0, float p1, struct S_DID p2,  double (*cb)(double, float, struct S_DID)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_DIP(double p0, float p1, struct S_DIP p2,  double (*cb)(double, float, struct S_DIP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_DFI(double p0, float p1, struct S_DFI p2,  double (*cb)(double, float, struct S_DFI)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_DFF(double p0, float p1, struct S_DFF p2,  double (*cb)(double, float, struct S_DFF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_DFD(double p0, float p1, struct S_DFD p2,  double (*cb)(double, float, struct S_DFD)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_DFP(double p0, float p1, struct S_DFP p2,  double (*cb)(double, float, struct S_DFP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_DDI(double p0, float p1, struct S_DDI p2,  double (*cb)(double, float, struct S_DDI)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_DDF(double p0, float p1, struct S_DDF p2,  double (*cb)(double, float, struct S_DDF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_DDD(double p0, float p1, struct S_DDD p2,  double (*cb)(double, float, struct S_DDD)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_DDP(double p0, float p1, struct S_DDP p2,  double (*cb)(double, float, struct S_DDP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_DPI(double p0, float p1, struct S_DPI p2,  double (*cb)(double, float, struct S_DPI)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_DPF(double p0, float p1, struct S_DPF p2,  double (*cb)(double, float, struct S_DPF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_DPD(double p0, float p1, struct S_DPD p2,  double (*cb)(double, float, struct S_DPD)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_DPP(double p0, float p1, struct S_DPP p2,  double (*cb)(double, float, struct S_DPP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_PII(double p0, float p1, struct S_PII p2,  double (*cb)(double, float, struct S_PII)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_PIF(double p0, float p1, struct S_PIF p2,  double (*cb)(double, float, struct S_PIF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_PID(double p0, float p1, struct S_PID p2,  double (*cb)(double, float, struct S_PID)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_PIP(double p0, float p1, struct S_PIP p2,  double (*cb)(double, float, struct S_PIP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_PFI(double p0, float p1, struct S_PFI p2,  double (*cb)(double, float, struct S_PFI)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_PFF(double p0, float p1, struct S_PFF p2,  double (*cb)(double, float, struct S_PFF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_PFD(double p0, float p1, struct S_PFD p2,  double (*cb)(double, float, struct S_PFD)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_PFP(double p0, float p1, struct S_PFP p2,  double (*cb)(double, float, struct S_PFP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_PDI(double p0, float p1, struct S_PDI p2,  double (*cb)(double, float, struct S_PDI)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_PDF(double p0, float p1, struct S_PDF p2,  double (*cb)(double, float, struct S_PDF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_PDD(double p0, float p1, struct S_PDD p2,  double (*cb)(double, float, struct S_PDD)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_PDP(double p0, float p1, struct S_PDP p2,  double (*cb)(double, float, struct S_PDP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_PPI(double p0, float p1, struct S_PPI p2,  double (*cb)(double, float, struct S_PPI)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_PPF(double p0, float p1, struct S_PPF p2,  double (*cb)(double, float, struct S_PPF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_PPD(double p0, float p1, struct S_PPD p2,  double (*cb)(double, float, struct S_PPD)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DFS_PPP(double p0, float p1, struct S_PPP p2,  double (*cb)(double, float, struct S_PPP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDI_(double p0, double p1, int p2,  double (*cb)(double, double, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDF_(double p0, double p1, float p2,  double (*cb)(double, double, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDD_(double p0, double p1, double p2,  double (*cb)(double, double, double)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDP_(double p0, double p1, void* p2,  double (*cb)(double, double, void*)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_I(double p0, double p1, struct S_I p2,  double (*cb)(double, double, struct S_I)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_F(double p0, double p1, struct S_F p2,  double (*cb)(double, double, struct S_F)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_D(double p0, double p1, struct S_D p2,  double (*cb)(double, double, struct S_D)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_P(double p0, double p1, struct S_P p2,  double (*cb)(double, double, struct S_P)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_II(double p0, double p1, struct S_II p2,  double (*cb)(double, double, struct S_II)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_IF(double p0, double p1, struct S_IF p2,  double (*cb)(double, double, struct S_IF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_ID(double p0, double p1, struct S_ID p2,  double (*cb)(double, double, struct S_ID)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_IP(double p0, double p1, struct S_IP p2,  double (*cb)(double, double, struct S_IP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_FI(double p0, double p1, struct S_FI p2,  double (*cb)(double, double, struct S_FI)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_FF(double p0, double p1, struct S_FF p2,  double (*cb)(double, double, struct S_FF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_FD(double p0, double p1, struct S_FD p2,  double (*cb)(double, double, struct S_FD)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_FP(double p0, double p1, struct S_FP p2,  double (*cb)(double, double, struct S_FP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_DI(double p0, double p1, struct S_DI p2,  double (*cb)(double, double, struct S_DI)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_DF(double p0, double p1, struct S_DF p2,  double (*cb)(double, double, struct S_DF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_DD(double p0, double p1, struct S_DD p2,  double (*cb)(double, double, struct S_DD)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_DP(double p0, double p1, struct S_DP p2,  double (*cb)(double, double, struct S_DP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_PI(double p0, double p1, struct S_PI p2,  double (*cb)(double, double, struct S_PI)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_PF(double p0, double p1, struct S_PF p2,  double (*cb)(double, double, struct S_PF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_PD(double p0, double p1, struct S_PD p2,  double (*cb)(double, double, struct S_PD)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_PP(double p0, double p1, struct S_PP p2,  double (*cb)(double, double, struct S_PP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_III(double p0, double p1, struct S_III p2,  double (*cb)(double, double, struct S_III)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_IIF(double p0, double p1, struct S_IIF p2,  double (*cb)(double, double, struct S_IIF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_IID(double p0, double p1, struct S_IID p2,  double (*cb)(double, double, struct S_IID)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_IIP(double p0, double p1, struct S_IIP p2,  double (*cb)(double, double, struct S_IIP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_IFI(double p0, double p1, struct S_IFI p2,  double (*cb)(double, double, struct S_IFI)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_IFF(double p0, double p1, struct S_IFF p2,  double (*cb)(double, double, struct S_IFF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_IFD(double p0, double p1, struct S_IFD p2,  double (*cb)(double, double, struct S_IFD)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_IFP(double p0, double p1, struct S_IFP p2,  double (*cb)(double, double, struct S_IFP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_IDI(double p0, double p1, struct S_IDI p2,  double (*cb)(double, double, struct S_IDI)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_IDF(double p0, double p1, struct S_IDF p2,  double (*cb)(double, double, struct S_IDF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_IDD(double p0, double p1, struct S_IDD p2,  double (*cb)(double, double, struct S_IDD)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_IDP(double p0, double p1, struct S_IDP p2,  double (*cb)(double, double, struct S_IDP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_IPI(double p0, double p1, struct S_IPI p2,  double (*cb)(double, double, struct S_IPI)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_IPF(double p0, double p1, struct S_IPF p2,  double (*cb)(double, double, struct S_IPF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_IPD(double p0, double p1, struct S_IPD p2,  double (*cb)(double, double, struct S_IPD)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_IPP(double p0, double p1, struct S_IPP p2,  double (*cb)(double, double, struct S_IPP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_FII(double p0, double p1, struct S_FII p2,  double (*cb)(double, double, struct S_FII)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_FIF(double p0, double p1, struct S_FIF p2,  double (*cb)(double, double, struct S_FIF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_FID(double p0, double p1, struct S_FID p2,  double (*cb)(double, double, struct S_FID)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_FIP(double p0, double p1, struct S_FIP p2,  double (*cb)(double, double, struct S_FIP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_FFI(double p0, double p1, struct S_FFI p2,  double (*cb)(double, double, struct S_FFI)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_FFF(double p0, double p1, struct S_FFF p2,  double (*cb)(double, double, struct S_FFF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_FFD(double p0, double p1, struct S_FFD p2,  double (*cb)(double, double, struct S_FFD)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_FFP(double p0, double p1, struct S_FFP p2,  double (*cb)(double, double, struct S_FFP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_FDI(double p0, double p1, struct S_FDI p2,  double (*cb)(double, double, struct S_FDI)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_FDF(double p0, double p1, struct S_FDF p2,  double (*cb)(double, double, struct S_FDF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_FDD(double p0, double p1, struct S_FDD p2,  double (*cb)(double, double, struct S_FDD)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_FDP(double p0, double p1, struct S_FDP p2,  double (*cb)(double, double, struct S_FDP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_FPI(double p0, double p1, struct S_FPI p2,  double (*cb)(double, double, struct S_FPI)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_FPF(double p0, double p1, struct S_FPF p2,  double (*cb)(double, double, struct S_FPF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_FPD(double p0, double p1, struct S_FPD p2,  double (*cb)(double, double, struct S_FPD)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_FPP(double p0, double p1, struct S_FPP p2,  double (*cb)(double, double, struct S_FPP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_DII(double p0, double p1, struct S_DII p2,  double (*cb)(double, double, struct S_DII)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_DIF(double p0, double p1, struct S_DIF p2,  double (*cb)(double, double, struct S_DIF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_DID(double p0, double p1, struct S_DID p2,  double (*cb)(double, double, struct S_DID)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_DIP(double p0, double p1, struct S_DIP p2,  double (*cb)(double, double, struct S_DIP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_DFI(double p0, double p1, struct S_DFI p2,  double (*cb)(double, double, struct S_DFI)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_DFF(double p0, double p1, struct S_DFF p2,  double (*cb)(double, double, struct S_DFF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_DFD(double p0, double p1, struct S_DFD p2,  double (*cb)(double, double, struct S_DFD)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_DFP(double p0, double p1, struct S_DFP p2,  double (*cb)(double, double, struct S_DFP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_DDI(double p0, double p1, struct S_DDI p2,  double (*cb)(double, double, struct S_DDI)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_DDF(double p0, double p1, struct S_DDF p2,  double (*cb)(double, double, struct S_DDF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_DDD(double p0, double p1, struct S_DDD p2,  double (*cb)(double, double, struct S_DDD)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_DDP(double p0, double p1, struct S_DDP p2,  double (*cb)(double, double, struct S_DDP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_DPI(double p0, double p1, struct S_DPI p2,  double (*cb)(double, double, struct S_DPI)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_DPF(double p0, double p1, struct S_DPF p2,  double (*cb)(double, double, struct S_DPF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_DPD(double p0, double p1, struct S_DPD p2,  double (*cb)(double, double, struct S_DPD)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_DPP(double p0, double p1, struct S_DPP p2,  double (*cb)(double, double, struct S_DPP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_PII(double p0, double p1, struct S_PII p2,  double (*cb)(double, double, struct S_PII)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_PIF(double p0, double p1, struct S_PIF p2,  double (*cb)(double, double, struct S_PIF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_PID(double p0, double p1, struct S_PID p2,  double (*cb)(double, double, struct S_PID)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_PIP(double p0, double p1, struct S_PIP p2,  double (*cb)(double, double, struct S_PIP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_PFI(double p0, double p1, struct S_PFI p2,  double (*cb)(double, double, struct S_PFI)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_PFF(double p0, double p1, struct S_PFF p2,  double (*cb)(double, double, struct S_PFF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_PFD(double p0, double p1, struct S_PFD p2,  double (*cb)(double, double, struct S_PFD)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_PFP(double p0, double p1, struct S_PFP p2,  double (*cb)(double, double, struct S_PFP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_PDI(double p0, double p1, struct S_PDI p2,  double (*cb)(double, double, struct S_PDI)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_PDF(double p0, double p1, struct S_PDF p2,  double (*cb)(double, double, struct S_PDF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_PDD(double p0, double p1, struct S_PDD p2,  double (*cb)(double, double, struct S_PDD)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_PDP(double p0, double p1, struct S_PDP p2,  double (*cb)(double, double, struct S_PDP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_PPI(double p0, double p1, struct S_PPI p2,  double (*cb)(double, double, struct S_PPI)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_PPF(double p0, double p1, struct S_PPF p2,  double (*cb)(double, double, struct S_PPF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_PPD(double p0, double p1, struct S_PPD p2,  double (*cb)(double, double, struct S_PPD)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DDS_PPP(double p0, double p1, struct S_PPP p2,  double (*cb)(double, double, struct S_PPP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPI_(double p0, void* p1, int p2,  double (*cb)(double, void*, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPF_(double p0, void* p1, float p2,  double (*cb)(double, void*, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPD_(double p0, void* p1, double p2,  double (*cb)(double, void*, double)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPP_(double p0, void* p1, void* p2,  double (*cb)(double, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_I(double p0, void* p1, struct S_I p2,  double (*cb)(double, void*, struct S_I)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_F(double p0, void* p1, struct S_F p2,  double (*cb)(double, void*, struct S_F)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_D(double p0, void* p1, struct S_D p2,  double (*cb)(double, void*, struct S_D)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_P(double p0, void* p1, struct S_P p2,  double (*cb)(double, void*, struct S_P)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_II(double p0, void* p1, struct S_II p2,  double (*cb)(double, void*, struct S_II)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_IF(double p0, void* p1, struct S_IF p2,  double (*cb)(double, void*, struct S_IF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_ID(double p0, void* p1, struct S_ID p2,  double (*cb)(double, void*, struct S_ID)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_IP(double p0, void* p1, struct S_IP p2,  double (*cb)(double, void*, struct S_IP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_FI(double p0, void* p1, struct S_FI p2,  double (*cb)(double, void*, struct S_FI)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_FF(double p0, void* p1, struct S_FF p2,  double (*cb)(double, void*, struct S_FF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_FD(double p0, void* p1, struct S_FD p2,  double (*cb)(double, void*, struct S_FD)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_FP(double p0, void* p1, struct S_FP p2,  double (*cb)(double, void*, struct S_FP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_DI(double p0, void* p1, struct S_DI p2,  double (*cb)(double, void*, struct S_DI)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_DF(double p0, void* p1, struct S_DF p2,  double (*cb)(double, void*, struct S_DF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_DD(double p0, void* p1, struct S_DD p2,  double (*cb)(double, void*, struct S_DD)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_DP(double p0, void* p1, struct S_DP p2,  double (*cb)(double, void*, struct S_DP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_PI(double p0, void* p1, struct S_PI p2,  double (*cb)(double, void*, struct S_PI)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_PF(double p0, void* p1, struct S_PF p2,  double (*cb)(double, void*, struct S_PF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_PD(double p0, void* p1, struct S_PD p2,  double (*cb)(double, void*, struct S_PD)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_PP(double p0, void* p1, struct S_PP p2,  double (*cb)(double, void*, struct S_PP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_III(double p0, void* p1, struct S_III p2,  double (*cb)(double, void*, struct S_III)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_IIF(double p0, void* p1, struct S_IIF p2,  double (*cb)(double, void*, struct S_IIF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_IID(double p0, void* p1, struct S_IID p2,  double (*cb)(double, void*, struct S_IID)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_IIP(double p0, void* p1, struct S_IIP p2,  double (*cb)(double, void*, struct S_IIP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_IFI(double p0, void* p1, struct S_IFI p2,  double (*cb)(double, void*, struct S_IFI)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_IFF(double p0, void* p1, struct S_IFF p2,  double (*cb)(double, void*, struct S_IFF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_IFD(double p0, void* p1, struct S_IFD p2,  double (*cb)(double, void*, struct S_IFD)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_IFP(double p0, void* p1, struct S_IFP p2,  double (*cb)(double, void*, struct S_IFP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_IDI(double p0, void* p1, struct S_IDI p2,  double (*cb)(double, void*, struct S_IDI)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_IDF(double p0, void* p1, struct S_IDF p2,  double (*cb)(double, void*, struct S_IDF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_IDD(double p0, void* p1, struct S_IDD p2,  double (*cb)(double, void*, struct S_IDD)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_IDP(double p0, void* p1, struct S_IDP p2,  double (*cb)(double, void*, struct S_IDP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_IPI(double p0, void* p1, struct S_IPI p2,  double (*cb)(double, void*, struct S_IPI)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_IPF(double p0, void* p1, struct S_IPF p2,  double (*cb)(double, void*, struct S_IPF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_IPD(double p0, void* p1, struct S_IPD p2,  double (*cb)(double, void*, struct S_IPD)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_IPP(double p0, void* p1, struct S_IPP p2,  double (*cb)(double, void*, struct S_IPP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_FII(double p0, void* p1, struct S_FII p2,  double (*cb)(double, void*, struct S_FII)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_FIF(double p0, void* p1, struct S_FIF p2,  double (*cb)(double, void*, struct S_FIF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_FID(double p0, void* p1, struct S_FID p2,  double (*cb)(double, void*, struct S_FID)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_FIP(double p0, void* p1, struct S_FIP p2,  double (*cb)(double, void*, struct S_FIP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_FFI(double p0, void* p1, struct S_FFI p2,  double (*cb)(double, void*, struct S_FFI)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_FFF(double p0, void* p1, struct S_FFF p2,  double (*cb)(double, void*, struct S_FFF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_FFD(double p0, void* p1, struct S_FFD p2,  double (*cb)(double, void*, struct S_FFD)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_FFP(double p0, void* p1, struct S_FFP p2,  double (*cb)(double, void*, struct S_FFP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_FDI(double p0, void* p1, struct S_FDI p2,  double (*cb)(double, void*, struct S_FDI)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_FDF(double p0, void* p1, struct S_FDF p2,  double (*cb)(double, void*, struct S_FDF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_FDD(double p0, void* p1, struct S_FDD p2,  double (*cb)(double, void*, struct S_FDD)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_FDP(double p0, void* p1, struct S_FDP p2,  double (*cb)(double, void*, struct S_FDP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_FPI(double p0, void* p1, struct S_FPI p2,  double (*cb)(double, void*, struct S_FPI)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_FPF(double p0, void* p1, struct S_FPF p2,  double (*cb)(double, void*, struct S_FPF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_FPD(double p0, void* p1, struct S_FPD p2,  double (*cb)(double, void*, struct S_FPD)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_FPP(double p0, void* p1, struct S_FPP p2,  double (*cb)(double, void*, struct S_FPP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_DII(double p0, void* p1, struct S_DII p2,  double (*cb)(double, void*, struct S_DII)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_DIF(double p0, void* p1, struct S_DIF p2,  double (*cb)(double, void*, struct S_DIF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_DID(double p0, void* p1, struct S_DID p2,  double (*cb)(double, void*, struct S_DID)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_DIP(double p0, void* p1, struct S_DIP p2,  double (*cb)(double, void*, struct S_DIP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_DFI(double p0, void* p1, struct S_DFI p2,  double (*cb)(double, void*, struct S_DFI)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_DFF(double p0, void* p1, struct S_DFF p2,  double (*cb)(double, void*, struct S_DFF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_DFD(double p0, void* p1, struct S_DFD p2,  double (*cb)(double, void*, struct S_DFD)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_DFP(double p0, void* p1, struct S_DFP p2,  double (*cb)(double, void*, struct S_DFP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_DDI(double p0, void* p1, struct S_DDI p2,  double (*cb)(double, void*, struct S_DDI)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_DDF(double p0, void* p1, struct S_DDF p2,  double (*cb)(double, void*, struct S_DDF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_DDD(double p0, void* p1, struct S_DDD p2,  double (*cb)(double, void*, struct S_DDD)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_DDP(double p0, void* p1, struct S_DDP p2,  double (*cb)(double, void*, struct S_DDP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_DPI(double p0, void* p1, struct S_DPI p2,  double (*cb)(double, void*, struct S_DPI)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_DPF(double p0, void* p1, struct S_DPF p2,  double (*cb)(double, void*, struct S_DPF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_DPD(double p0, void* p1, struct S_DPD p2,  double (*cb)(double, void*, struct S_DPD)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_DPP(double p0, void* p1, struct S_DPP p2,  double (*cb)(double, void*, struct S_DPP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_PII(double p0, void* p1, struct S_PII p2,  double (*cb)(double, void*, struct S_PII)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_PIF(double p0, void* p1, struct S_PIF p2,  double (*cb)(double, void*, struct S_PIF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_PID(double p0, void* p1, struct S_PID p2,  double (*cb)(double, void*, struct S_PID)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_PIP(double p0, void* p1, struct S_PIP p2,  double (*cb)(double, void*, struct S_PIP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_PFI(double p0, void* p1, struct S_PFI p2,  double (*cb)(double, void*, struct S_PFI)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_PFF(double p0, void* p1, struct S_PFF p2,  double (*cb)(double, void*, struct S_PFF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_PFD(double p0, void* p1, struct S_PFD p2,  double (*cb)(double, void*, struct S_PFD)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_PFP(double p0, void* p1, struct S_PFP p2,  double (*cb)(double, void*, struct S_PFP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_PDI(double p0, void* p1, struct S_PDI p2,  double (*cb)(double, void*, struct S_PDI)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_PDF(double p0, void* p1, struct S_PDF p2,  double (*cb)(double, void*, struct S_PDF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_PDD(double p0, void* p1, struct S_PDD p2,  double (*cb)(double, void*, struct S_PDD)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_PDP(double p0, void* p1, struct S_PDP p2,  double (*cb)(double, void*, struct S_PDP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_PPI(double p0, void* p1, struct S_PPI p2,  double (*cb)(double, void*, struct S_PPI)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_PPF(double p0, void* p1, struct S_PPF p2,  double (*cb)(double, void*, struct S_PPF)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_PPD(double p0, void* p1, struct S_PPD p2,  double (*cb)(double, void*, struct S_PPD)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DPS_PPP(double p0, void* p1, struct S_PPP p2,  double (*cb)(double, void*, struct S_PPP)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_I(double p0, struct S_I p1, int p2,  double (*cb)(double, struct S_I, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_F(double p0, struct S_F p1, int p2,  double (*cb)(double, struct S_F, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_D(double p0, struct S_D p1, int p2,  double (*cb)(double, struct S_D, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_P(double p0, struct S_P p1, int p2,  double (*cb)(double, struct S_P, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_II(double p0, struct S_II p1, int p2,  double (*cb)(double, struct S_II, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_IF(double p0, struct S_IF p1, int p2,  double (*cb)(double, struct S_IF, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_ID(double p0, struct S_ID p1, int p2,  double (*cb)(double, struct S_ID, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_IP(double p0, struct S_IP p1, int p2,  double (*cb)(double, struct S_IP, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_FI(double p0, struct S_FI p1, int p2,  double (*cb)(double, struct S_FI, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_FF(double p0, struct S_FF p1, int p2,  double (*cb)(double, struct S_FF, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_FD(double p0, struct S_FD p1, int p2,  double (*cb)(double, struct S_FD, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_FP(double p0, struct S_FP p1, int p2,  double (*cb)(double, struct S_FP, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_DI(double p0, struct S_DI p1, int p2,  double (*cb)(double, struct S_DI, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_DF(double p0, struct S_DF p1, int p2,  double (*cb)(double, struct S_DF, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_DD(double p0, struct S_DD p1, int p2,  double (*cb)(double, struct S_DD, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_DP(double p0, struct S_DP p1, int p2,  double (*cb)(double, struct S_DP, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_PI(double p0, struct S_PI p1, int p2,  double (*cb)(double, struct S_PI, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_PF(double p0, struct S_PF p1, int p2,  double (*cb)(double, struct S_PF, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_PD(double p0, struct S_PD p1, int p2,  double (*cb)(double, struct S_PD, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_PP(double p0, struct S_PP p1, int p2,  double (*cb)(double, struct S_PP, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_III(double p0, struct S_III p1, int p2,  double (*cb)(double, struct S_III, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_IIF(double p0, struct S_IIF p1, int p2,  double (*cb)(double, struct S_IIF, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_IID(double p0, struct S_IID p1, int p2,  double (*cb)(double, struct S_IID, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_IIP(double p0, struct S_IIP p1, int p2,  double (*cb)(double, struct S_IIP, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_IFI(double p0, struct S_IFI p1, int p2,  double (*cb)(double, struct S_IFI, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_IFF(double p0, struct S_IFF p1, int p2,  double (*cb)(double, struct S_IFF, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_IFD(double p0, struct S_IFD p1, int p2,  double (*cb)(double, struct S_IFD, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_IFP(double p0, struct S_IFP p1, int p2,  double (*cb)(double, struct S_IFP, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_IDI(double p0, struct S_IDI p1, int p2,  double (*cb)(double, struct S_IDI, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_IDF(double p0, struct S_IDF p1, int p2,  double (*cb)(double, struct S_IDF, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_IDD(double p0, struct S_IDD p1, int p2,  double (*cb)(double, struct S_IDD, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_IDP(double p0, struct S_IDP p1, int p2,  double (*cb)(double, struct S_IDP, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_IPI(double p0, struct S_IPI p1, int p2,  double (*cb)(double, struct S_IPI, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_IPF(double p0, struct S_IPF p1, int p2,  double (*cb)(double, struct S_IPF, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_IPD(double p0, struct S_IPD p1, int p2,  double (*cb)(double, struct S_IPD, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_IPP(double p0, struct S_IPP p1, int p2,  double (*cb)(double, struct S_IPP, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_FII(double p0, struct S_FII p1, int p2,  double (*cb)(double, struct S_FII, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_FIF(double p0, struct S_FIF p1, int p2,  double (*cb)(double, struct S_FIF, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_FID(double p0, struct S_FID p1, int p2,  double (*cb)(double, struct S_FID, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_FIP(double p0, struct S_FIP p1, int p2,  double (*cb)(double, struct S_FIP, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_FFI(double p0, struct S_FFI p1, int p2,  double (*cb)(double, struct S_FFI, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_FFF(double p0, struct S_FFF p1, int p2,  double (*cb)(double, struct S_FFF, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_FFD(double p0, struct S_FFD p1, int p2,  double (*cb)(double, struct S_FFD, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_FFP(double p0, struct S_FFP p1, int p2,  double (*cb)(double, struct S_FFP, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_FDI(double p0, struct S_FDI p1, int p2,  double (*cb)(double, struct S_FDI, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_FDF(double p0, struct S_FDF p1, int p2,  double (*cb)(double, struct S_FDF, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_FDD(double p0, struct S_FDD p1, int p2,  double (*cb)(double, struct S_FDD, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_FDP(double p0, struct S_FDP p1, int p2,  double (*cb)(double, struct S_FDP, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_FPI(double p0, struct S_FPI p1, int p2,  double (*cb)(double, struct S_FPI, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_FPF(double p0, struct S_FPF p1, int p2,  double (*cb)(double, struct S_FPF, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_FPD(double p0, struct S_FPD p1, int p2,  double (*cb)(double, struct S_FPD, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_FPP(double p0, struct S_FPP p1, int p2,  double (*cb)(double, struct S_FPP, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_DII(double p0, struct S_DII p1, int p2,  double (*cb)(double, struct S_DII, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_DIF(double p0, struct S_DIF p1, int p2,  double (*cb)(double, struct S_DIF, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_DID(double p0, struct S_DID p1, int p2,  double (*cb)(double, struct S_DID, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_DIP(double p0, struct S_DIP p1, int p2,  double (*cb)(double, struct S_DIP, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_DFI(double p0, struct S_DFI p1, int p2,  double (*cb)(double, struct S_DFI, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_DFF(double p0, struct S_DFF p1, int p2,  double (*cb)(double, struct S_DFF, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_DFD(double p0, struct S_DFD p1, int p2,  double (*cb)(double, struct S_DFD, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_DFP(double p0, struct S_DFP p1, int p2,  double (*cb)(double, struct S_DFP, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_DDI(double p0, struct S_DDI p1, int p2,  double (*cb)(double, struct S_DDI, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_DDF(double p0, struct S_DDF p1, int p2,  double (*cb)(double, struct S_DDF, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_DDD(double p0, struct S_DDD p1, int p2,  double (*cb)(double, struct S_DDD, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_DDP(double p0, struct S_DDP p1, int p2,  double (*cb)(double, struct S_DDP, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_DPI(double p0, struct S_DPI p1, int p2,  double (*cb)(double, struct S_DPI, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_DPF(double p0, struct S_DPF p1, int p2,  double (*cb)(double, struct S_DPF, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_DPD(double p0, struct S_DPD p1, int p2,  double (*cb)(double, struct S_DPD, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_DPP(double p0, struct S_DPP p1, int p2,  double (*cb)(double, struct S_DPP, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_PII(double p0, struct S_PII p1, int p2,  double (*cb)(double, struct S_PII, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_PIF(double p0, struct S_PIF p1, int p2,  double (*cb)(double, struct S_PIF, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_PID(double p0, struct S_PID p1, int p2,  double (*cb)(double, struct S_PID, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_PIP(double p0, struct S_PIP p1, int p2,  double (*cb)(double, struct S_PIP, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_PFI(double p0, struct S_PFI p1, int p2,  double (*cb)(double, struct S_PFI, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_PFF(double p0, struct S_PFF p1, int p2,  double (*cb)(double, struct S_PFF, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_PFD(double p0, struct S_PFD p1, int p2,  double (*cb)(double, struct S_PFD, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_PFP(double p0, struct S_PFP p1, int p2,  double (*cb)(double, struct S_PFP, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_PDI(double p0, struct S_PDI p1, int p2,  double (*cb)(double, struct S_PDI, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_PDF(double p0, struct S_PDF p1, int p2,  double (*cb)(double, struct S_PDF, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_PDD(double p0, struct S_PDD p1, int p2,  double (*cb)(double, struct S_PDD, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_PDP(double p0, struct S_PDP p1, int p2,  double (*cb)(double, struct S_PDP, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_PPI(double p0, struct S_PPI p1, int p2,  double (*cb)(double, struct S_PPI, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_PPF(double p0, struct S_PPF p1, int p2,  double (*cb)(double, struct S_PPF, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_PPD(double p0, struct S_PPD p1, int p2,  double (*cb)(double, struct S_PPD, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSI_PPP(double p0, struct S_PPP p1, int p2,  double (*cb)(double, struct S_PPP, int)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_I(double p0, struct S_I p1, float p2,  double (*cb)(double, struct S_I, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_F(double p0, struct S_F p1, float p2,  double (*cb)(double, struct S_F, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_D(double p0, struct S_D p1, float p2,  double (*cb)(double, struct S_D, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_P(double p0, struct S_P p1, float p2,  double (*cb)(double, struct S_P, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_II(double p0, struct S_II p1, float p2,  double (*cb)(double, struct S_II, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_IF(double p0, struct S_IF p1, float p2,  double (*cb)(double, struct S_IF, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_ID(double p0, struct S_ID p1, float p2,  double (*cb)(double, struct S_ID, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_IP(double p0, struct S_IP p1, float p2,  double (*cb)(double, struct S_IP, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_FI(double p0, struct S_FI p1, float p2,  double (*cb)(double, struct S_FI, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_FF(double p0, struct S_FF p1, float p2,  double (*cb)(double, struct S_FF, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_FD(double p0, struct S_FD p1, float p2,  double (*cb)(double, struct S_FD, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_FP(double p0, struct S_FP p1, float p2,  double (*cb)(double, struct S_FP, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_DI(double p0, struct S_DI p1, float p2,  double (*cb)(double, struct S_DI, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_DF(double p0, struct S_DF p1, float p2,  double (*cb)(double, struct S_DF, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_DD(double p0, struct S_DD p1, float p2,  double (*cb)(double, struct S_DD, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_DP(double p0, struct S_DP p1, float p2,  double (*cb)(double, struct S_DP, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_PI(double p0, struct S_PI p1, float p2,  double (*cb)(double, struct S_PI, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_PF(double p0, struct S_PF p1, float p2,  double (*cb)(double, struct S_PF, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_PD(double p0, struct S_PD p1, float p2,  double (*cb)(double, struct S_PD, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_PP(double p0, struct S_PP p1, float p2,  double (*cb)(double, struct S_PP, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_III(double p0, struct S_III p1, float p2,  double (*cb)(double, struct S_III, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_IIF(double p0, struct S_IIF p1, float p2,  double (*cb)(double, struct S_IIF, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_IID(double p0, struct S_IID p1, float p2,  double (*cb)(double, struct S_IID, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_IIP(double p0, struct S_IIP p1, float p2,  double (*cb)(double, struct S_IIP, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_IFI(double p0, struct S_IFI p1, float p2,  double (*cb)(double, struct S_IFI, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_IFF(double p0, struct S_IFF p1, float p2,  double (*cb)(double, struct S_IFF, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_IFD(double p0, struct S_IFD p1, float p2,  double (*cb)(double, struct S_IFD, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_IFP(double p0, struct S_IFP p1, float p2,  double (*cb)(double, struct S_IFP, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_IDI(double p0, struct S_IDI p1, float p2,  double (*cb)(double, struct S_IDI, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_IDF(double p0, struct S_IDF p1, float p2,  double (*cb)(double, struct S_IDF, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_IDD(double p0, struct S_IDD p1, float p2,  double (*cb)(double, struct S_IDD, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_IDP(double p0, struct S_IDP p1, float p2,  double (*cb)(double, struct S_IDP, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_IPI(double p0, struct S_IPI p1, float p2,  double (*cb)(double, struct S_IPI, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_IPF(double p0, struct S_IPF p1, float p2,  double (*cb)(double, struct S_IPF, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_IPD(double p0, struct S_IPD p1, float p2,  double (*cb)(double, struct S_IPD, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_IPP(double p0, struct S_IPP p1, float p2,  double (*cb)(double, struct S_IPP, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_FII(double p0, struct S_FII p1, float p2,  double (*cb)(double, struct S_FII, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_FIF(double p0, struct S_FIF p1, float p2,  double (*cb)(double, struct S_FIF, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_FID(double p0, struct S_FID p1, float p2,  double (*cb)(double, struct S_FID, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_FIP(double p0, struct S_FIP p1, float p2,  double (*cb)(double, struct S_FIP, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_FFI(double p0, struct S_FFI p1, float p2,  double (*cb)(double, struct S_FFI, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_FFF(double p0, struct S_FFF p1, float p2,  double (*cb)(double, struct S_FFF, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_FFD(double p0, struct S_FFD p1, float p2,  double (*cb)(double, struct S_FFD, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_FFP(double p0, struct S_FFP p1, float p2,  double (*cb)(double, struct S_FFP, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_FDI(double p0, struct S_FDI p1, float p2,  double (*cb)(double, struct S_FDI, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_FDF(double p0, struct S_FDF p1, float p2,  double (*cb)(double, struct S_FDF, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_FDD(double p0, struct S_FDD p1, float p2,  double (*cb)(double, struct S_FDD, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_FDP(double p0, struct S_FDP p1, float p2,  double (*cb)(double, struct S_FDP, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_FPI(double p0, struct S_FPI p1, float p2,  double (*cb)(double, struct S_FPI, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_FPF(double p0, struct S_FPF p1, float p2,  double (*cb)(double, struct S_FPF, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_FPD(double p0, struct S_FPD p1, float p2,  double (*cb)(double, struct S_FPD, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_FPP(double p0, struct S_FPP p1, float p2,  double (*cb)(double, struct S_FPP, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_DII(double p0, struct S_DII p1, float p2,  double (*cb)(double, struct S_DII, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_DIF(double p0, struct S_DIF p1, float p2,  double (*cb)(double, struct S_DIF, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_DID(double p0, struct S_DID p1, float p2,  double (*cb)(double, struct S_DID, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_DIP(double p0, struct S_DIP p1, float p2,  double (*cb)(double, struct S_DIP, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_DFI(double p0, struct S_DFI p1, float p2,  double (*cb)(double, struct S_DFI, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_DFF(double p0, struct S_DFF p1, float p2,  double (*cb)(double, struct S_DFF, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_DFD(double p0, struct S_DFD p1, float p2,  double (*cb)(double, struct S_DFD, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_DFP(double p0, struct S_DFP p1, float p2,  double (*cb)(double, struct S_DFP, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_DDI(double p0, struct S_DDI p1, float p2,  double (*cb)(double, struct S_DDI, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_DDF(double p0, struct S_DDF p1, float p2,  double (*cb)(double, struct S_DDF, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_DDD(double p0, struct S_DDD p1, float p2,  double (*cb)(double, struct S_DDD, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_DDP(double p0, struct S_DDP p1, float p2,  double (*cb)(double, struct S_DDP, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_DPI(double p0, struct S_DPI p1, float p2,  double (*cb)(double, struct S_DPI, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_DPF(double p0, struct S_DPF p1, float p2,  double (*cb)(double, struct S_DPF, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_DPD(double p0, struct S_DPD p1, float p2,  double (*cb)(double, struct S_DPD, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_DPP(double p0, struct S_DPP p1, float p2,  double (*cb)(double, struct S_DPP, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_PII(double p0, struct S_PII p1, float p2,  double (*cb)(double, struct S_PII, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_PIF(double p0, struct S_PIF p1, float p2,  double (*cb)(double, struct S_PIF, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_PID(double p0, struct S_PID p1, float p2,  double (*cb)(double, struct S_PID, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_PIP(double p0, struct S_PIP p1, float p2,  double (*cb)(double, struct S_PIP, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_PFI(double p0, struct S_PFI p1, float p2,  double (*cb)(double, struct S_PFI, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_PFF(double p0, struct S_PFF p1, float p2,  double (*cb)(double, struct S_PFF, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_PFD(double p0, struct S_PFD p1, float p2,  double (*cb)(double, struct S_PFD, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_PFP(double p0, struct S_PFP p1, float p2,  double (*cb)(double, struct S_PFP, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_PDI(double p0, struct S_PDI p1, float p2,  double (*cb)(double, struct S_PDI, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_PDF(double p0, struct S_PDF p1, float p2,  double (*cb)(double, struct S_PDF, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_PDD(double p0, struct S_PDD p1, float p2,  double (*cb)(double, struct S_PDD, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_PDP(double p0, struct S_PDP p1, float p2,  double (*cb)(double, struct S_PDP, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_PPI(double p0, struct S_PPI p1, float p2,  double (*cb)(double, struct S_PPI, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_PPF(double p0, struct S_PPF p1, float p2,  double (*cb)(double, struct S_PPF, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_PPD(double p0, struct S_PPD p1, float p2,  double (*cb)(double, struct S_PPD, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSF_PPP(double p0, struct S_PPP p1, float p2,  double (*cb)(double, struct S_PPP, float)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSD_I(double p0, struct S_I p1, double p2,  double (*cb)(double, struct S_I, double)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSD_F(double p0, struct S_F p1, double p2,  double (*cb)(double, struct S_F, double)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSD_D(double p0, struct S_D p1, double p2,  double (*cb)(double, struct S_D, double)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSD_P(double p0, struct S_P p1, double p2,  double (*cb)(double, struct S_P, double)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSD_II(double p0, struct S_II p1, double p2,  double (*cb)(double, struct S_II, double)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSD_IF(double p0, struct S_IF p1, double p2,  double (*cb)(double, struct S_IF, double)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSD_ID(double p0, struct S_ID p1, double p2,  double (*cb)(double, struct S_ID, double)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSD_IP(double p0, struct S_IP p1, double p2,  double (*cb)(double, struct S_IP, double)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSD_FI(double p0, struct S_FI p1, double p2,  double (*cb)(double, struct S_FI, double)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSD_FF(double p0, struct S_FF p1, double p2,  double (*cb)(double, struct S_FF, double)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSD_FD(double p0, struct S_FD p1, double p2,  double (*cb)(double, struct S_FD, double)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSD_FP(double p0, struct S_FP p1, double p2,  double (*cb)(double, struct S_FP, double)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSD_DI(double p0, struct S_DI p1, double p2,  double (*cb)(double, struct S_DI, double)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSD_DF(double p0, struct S_DF p1, double p2,  double (*cb)(double, struct S_DF, double)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSD_DD(double p0, struct S_DD p1, double p2,  double (*cb)(double, struct S_DD, double)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSD_DP(double p0, struct S_DP p1, double p2,  double (*cb)(double, struct S_DP, double)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSD_PI(double p0, struct S_PI p1, double p2,  double (*cb)(double, struct S_PI, double)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSD_PF(double p0, struct S_PF p1, double p2,  double (*cb)(double, struct S_PF, double)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSD_PD(double p0, struct S_PD p1, double p2,  double (*cb)(double, struct S_PD, double)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSD_PP(double p0, struct S_PP p1, double p2,  double (*cb)(double, struct S_PP, double)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSD_III(double p0, struct S_III p1, double p2,  double (*cb)(double, struct S_III, double)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSD_IIF(double p0, struct S_IIF p1, double p2,  double (*cb)(double, struct S_IIF, double)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSD_IID(double p0, struct S_IID p1, double p2,  double (*cb)(double, struct S_IID, double)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSD_IIP(double p0, struct S_IIP p1, double p2,  double (*cb)(double, struct S_IIP, double)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSD_IFI(double p0, struct S_IFI p1, double p2,  double (*cb)(double, struct S_IFI, double)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSD_IFF(double p0, struct S_IFF p1, double p2,  double (*cb)(double, struct S_IFF, double)) { return cb(p0,p1,p2); }
+EXPORT double f14_D_DSD_IFD(double p0, struct S_IFD p1, double p2,  double (*cb)(double, struct S_IFD, double)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSD_IFP(double p0, struct S_IFP p1, double p2,  double (*cb)(double, struct S_IFP, double)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSD_IDI(double p0, struct S_IDI p1, double p2,  double (*cb)(double, struct S_IDI, double)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSD_IDF(double p0, struct S_IDF p1, double p2,  double (*cb)(double, struct S_IDF, double)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSD_IDD(double p0, struct S_IDD p1, double p2,  double (*cb)(double, struct S_IDD, double)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSD_IDP(double p0, struct S_IDP p1, double p2,  double (*cb)(double, struct S_IDP, double)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSD_IPI(double p0, struct S_IPI p1, double p2,  double (*cb)(double, struct S_IPI, double)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSD_IPF(double p0, struct S_IPF p1, double p2,  double (*cb)(double, struct S_IPF, double)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSD_IPD(double p0, struct S_IPD p1, double p2,  double (*cb)(double, struct S_IPD, double)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSD_IPP(double p0, struct S_IPP p1, double p2,  double (*cb)(double, struct S_IPP, double)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSD_FII(double p0, struct S_FII p1, double p2,  double (*cb)(double, struct S_FII, double)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSD_FIF(double p0, struct S_FIF p1, double p2,  double (*cb)(double, struct S_FIF, double)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSD_FID(double p0, struct S_FID p1, double p2,  double (*cb)(double, struct S_FID, double)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSD_FIP(double p0, struct S_FIP p1, double p2,  double (*cb)(double, struct S_FIP, double)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSD_FFI(double p0, struct S_FFI p1, double p2,  double (*cb)(double, struct S_FFI, double)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSD_FFF(double p0, struct S_FFF p1, double p2,  double (*cb)(double, struct S_FFF, double)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSD_FFD(double p0, struct S_FFD p1, double p2,  double (*cb)(double, struct S_FFD, double)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSD_FFP(double p0, struct S_FFP p1, double p2,  double (*cb)(double, struct S_FFP, double)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSD_FDI(double p0, struct S_FDI p1, double p2,  double (*cb)(double, struct S_FDI, double)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSD_FDF(double p0, struct S_FDF p1, double p2,  double (*cb)(double, struct S_FDF, double)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSD_FDD(double p0, struct S_FDD p1, double p2,  double (*cb)(double, struct S_FDD, double)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSD_FDP(double p0, struct S_FDP p1, double p2,  double (*cb)(double, struct S_FDP, double)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSD_FPI(double p0, struct S_FPI p1, double p2,  double (*cb)(double, struct S_FPI, double)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSD_FPF(double p0, struct S_FPF p1, double p2,  double (*cb)(double, struct S_FPF, double)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSD_FPD(double p0, struct S_FPD p1, double p2,  double (*cb)(double, struct S_FPD, double)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSD_FPP(double p0, struct S_FPP p1, double p2,  double (*cb)(double, struct S_FPP, double)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSD_DII(double p0, struct S_DII p1, double p2,  double (*cb)(double, struct S_DII, double)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSD_DIF(double p0, struct S_DIF p1, double p2,  double (*cb)(double, struct S_DIF, double)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSD_DID(double p0, struct S_DID p1, double p2,  double (*cb)(double, struct S_DID, double)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSD_DIP(double p0, struct S_DIP p1, double p2,  double (*cb)(double, struct S_DIP, double)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSD_DFI(double p0, struct S_DFI p1, double p2,  double (*cb)(double, struct S_DFI, double)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSD_DFF(double p0, struct S_DFF p1, double p2,  double (*cb)(double, struct S_DFF, double)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSD_DFD(double p0, struct S_DFD p1, double p2,  double (*cb)(double, struct S_DFD, double)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSD_DFP(double p0, struct S_DFP p1, double p2,  double (*cb)(double, struct S_DFP, double)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSD_DDI(double p0, struct S_DDI p1, double p2,  double (*cb)(double, struct S_DDI, double)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSD_DDF(double p0, struct S_DDF p1, double p2,  double (*cb)(double, struct S_DDF, double)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSD_DDD(double p0, struct S_DDD p1, double p2,  double (*cb)(double, struct S_DDD, double)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSD_DDP(double p0, struct S_DDP p1, double p2,  double (*cb)(double, struct S_DDP, double)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSD_DPI(double p0, struct S_DPI p1, double p2,  double (*cb)(double, struct S_DPI, double)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSD_DPF(double p0, struct S_DPF p1, double p2,  double (*cb)(double, struct S_DPF, double)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSD_DPD(double p0, struct S_DPD p1, double p2,  double (*cb)(double, struct S_DPD, double)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSD_DPP(double p0, struct S_DPP p1, double p2,  double (*cb)(double, struct S_DPP, double)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSD_PII(double p0, struct S_PII p1, double p2,  double (*cb)(double, struct S_PII, double)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSD_PIF(double p0, struct S_PIF p1, double p2,  double (*cb)(double, struct S_PIF, double)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSD_PID(double p0, struct S_PID p1, double p2,  double (*cb)(double, struct S_PID, double)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSD_PIP(double p0, struct S_PIP p1, double p2,  double (*cb)(double, struct S_PIP, double)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSD_PFI(double p0, struct S_PFI p1, double p2,  double (*cb)(double, struct S_PFI, double)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSD_PFF(double p0, struct S_PFF p1, double p2,  double (*cb)(double, struct S_PFF, double)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSD_PFD(double p0, struct S_PFD p1, double p2,  double (*cb)(double, struct S_PFD, double)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSD_PFP(double p0, struct S_PFP p1, double p2,  double (*cb)(double, struct S_PFP, double)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSD_PDI(double p0, struct S_PDI p1, double p2,  double (*cb)(double, struct S_PDI, double)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSD_PDF(double p0, struct S_PDF p1, double p2,  double (*cb)(double, struct S_PDF, double)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSD_PDD(double p0, struct S_PDD p1, double p2,  double (*cb)(double, struct S_PDD, double)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSD_PDP(double p0, struct S_PDP p1, double p2,  double (*cb)(double, struct S_PDP, double)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSD_PPI(double p0, struct S_PPI p1, double p2,  double (*cb)(double, struct S_PPI, double)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSD_PPF(double p0, struct S_PPF p1, double p2,  double (*cb)(double, struct S_PPF, double)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSD_PPD(double p0, struct S_PPD p1, double p2,  double (*cb)(double, struct S_PPD, double)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSD_PPP(double p0, struct S_PPP p1, double p2,  double (*cb)(double, struct S_PPP, double)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_I(double p0, struct S_I p1, void* p2,  double (*cb)(double, struct S_I, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_F(double p0, struct S_F p1, void* p2,  double (*cb)(double, struct S_F, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_D(double p0, struct S_D p1, void* p2,  double (*cb)(double, struct S_D, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_P(double p0, struct S_P p1, void* p2,  double (*cb)(double, struct S_P, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_II(double p0, struct S_II p1, void* p2,  double (*cb)(double, struct S_II, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_IF(double p0, struct S_IF p1, void* p2,  double (*cb)(double, struct S_IF, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_ID(double p0, struct S_ID p1, void* p2,  double (*cb)(double, struct S_ID, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_IP(double p0, struct S_IP p1, void* p2,  double (*cb)(double, struct S_IP, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_FI(double p0, struct S_FI p1, void* p2,  double (*cb)(double, struct S_FI, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_FF(double p0, struct S_FF p1, void* p2,  double (*cb)(double, struct S_FF, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_FD(double p0, struct S_FD p1, void* p2,  double (*cb)(double, struct S_FD, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_FP(double p0, struct S_FP p1, void* p2,  double (*cb)(double, struct S_FP, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_DI(double p0, struct S_DI p1, void* p2,  double (*cb)(double, struct S_DI, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_DF(double p0, struct S_DF p1, void* p2,  double (*cb)(double, struct S_DF, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_DD(double p0, struct S_DD p1, void* p2,  double (*cb)(double, struct S_DD, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_DP(double p0, struct S_DP p1, void* p2,  double (*cb)(double, struct S_DP, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_PI(double p0, struct S_PI p1, void* p2,  double (*cb)(double, struct S_PI, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_PF(double p0, struct S_PF p1, void* p2,  double (*cb)(double, struct S_PF, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_PD(double p0, struct S_PD p1, void* p2,  double (*cb)(double, struct S_PD, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_PP(double p0, struct S_PP p1, void* p2,  double (*cb)(double, struct S_PP, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_III(double p0, struct S_III p1, void* p2,  double (*cb)(double, struct S_III, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_IIF(double p0, struct S_IIF p1, void* p2,  double (*cb)(double, struct S_IIF, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_IID(double p0, struct S_IID p1, void* p2,  double (*cb)(double, struct S_IID, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_IIP(double p0, struct S_IIP p1, void* p2,  double (*cb)(double, struct S_IIP, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_IFI(double p0, struct S_IFI p1, void* p2,  double (*cb)(double, struct S_IFI, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_IFF(double p0, struct S_IFF p1, void* p2,  double (*cb)(double, struct S_IFF, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_IFD(double p0, struct S_IFD p1, void* p2,  double (*cb)(double, struct S_IFD, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_IFP(double p0, struct S_IFP p1, void* p2,  double (*cb)(double, struct S_IFP, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_IDI(double p0, struct S_IDI p1, void* p2,  double (*cb)(double, struct S_IDI, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_IDF(double p0, struct S_IDF p1, void* p2,  double (*cb)(double, struct S_IDF, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_IDD(double p0, struct S_IDD p1, void* p2,  double (*cb)(double, struct S_IDD, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_IDP(double p0, struct S_IDP p1, void* p2,  double (*cb)(double, struct S_IDP, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_IPI(double p0, struct S_IPI p1, void* p2,  double (*cb)(double, struct S_IPI, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_IPF(double p0, struct S_IPF p1, void* p2,  double (*cb)(double, struct S_IPF, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_IPD(double p0, struct S_IPD p1, void* p2,  double (*cb)(double, struct S_IPD, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_IPP(double p0, struct S_IPP p1, void* p2,  double (*cb)(double, struct S_IPP, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_FII(double p0, struct S_FII p1, void* p2,  double (*cb)(double, struct S_FII, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_FIF(double p0, struct S_FIF p1, void* p2,  double (*cb)(double, struct S_FIF, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_FID(double p0, struct S_FID p1, void* p2,  double (*cb)(double, struct S_FID, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_FIP(double p0, struct S_FIP p1, void* p2,  double (*cb)(double, struct S_FIP, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_FFI(double p0, struct S_FFI p1, void* p2,  double (*cb)(double, struct S_FFI, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_FFF(double p0, struct S_FFF p1, void* p2,  double (*cb)(double, struct S_FFF, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_FFD(double p0, struct S_FFD p1, void* p2,  double (*cb)(double, struct S_FFD, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_FFP(double p0, struct S_FFP p1, void* p2,  double (*cb)(double, struct S_FFP, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_FDI(double p0, struct S_FDI p1, void* p2,  double (*cb)(double, struct S_FDI, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_FDF(double p0, struct S_FDF p1, void* p2,  double (*cb)(double, struct S_FDF, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_FDD(double p0, struct S_FDD p1, void* p2,  double (*cb)(double, struct S_FDD, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_FDP(double p0, struct S_FDP p1, void* p2,  double (*cb)(double, struct S_FDP, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_FPI(double p0, struct S_FPI p1, void* p2,  double (*cb)(double, struct S_FPI, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_FPF(double p0, struct S_FPF p1, void* p2,  double (*cb)(double, struct S_FPF, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_FPD(double p0, struct S_FPD p1, void* p2,  double (*cb)(double, struct S_FPD, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_FPP(double p0, struct S_FPP p1, void* p2,  double (*cb)(double, struct S_FPP, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_DII(double p0, struct S_DII p1, void* p2,  double (*cb)(double, struct S_DII, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_DIF(double p0, struct S_DIF p1, void* p2,  double (*cb)(double, struct S_DIF, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_DID(double p0, struct S_DID p1, void* p2,  double (*cb)(double, struct S_DID, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_DIP(double p0, struct S_DIP p1, void* p2,  double (*cb)(double, struct S_DIP, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_DFI(double p0, struct S_DFI p1, void* p2,  double (*cb)(double, struct S_DFI, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_DFF(double p0, struct S_DFF p1, void* p2,  double (*cb)(double, struct S_DFF, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_DFD(double p0, struct S_DFD p1, void* p2,  double (*cb)(double, struct S_DFD, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_DFP(double p0, struct S_DFP p1, void* p2,  double (*cb)(double, struct S_DFP, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_DDI(double p0, struct S_DDI p1, void* p2,  double (*cb)(double, struct S_DDI, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_DDF(double p0, struct S_DDF p1, void* p2,  double (*cb)(double, struct S_DDF, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_DDD(double p0, struct S_DDD p1, void* p2,  double (*cb)(double, struct S_DDD, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_DDP(double p0, struct S_DDP p1, void* p2,  double (*cb)(double, struct S_DDP, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_DPI(double p0, struct S_DPI p1, void* p2,  double (*cb)(double, struct S_DPI, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_DPF(double p0, struct S_DPF p1, void* p2,  double (*cb)(double, struct S_DPF, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_DPD(double p0, struct S_DPD p1, void* p2,  double (*cb)(double, struct S_DPD, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_DPP(double p0, struct S_DPP p1, void* p2,  double (*cb)(double, struct S_DPP, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_PII(double p0, struct S_PII p1, void* p2,  double (*cb)(double, struct S_PII, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_PIF(double p0, struct S_PIF p1, void* p2,  double (*cb)(double, struct S_PIF, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_PID(double p0, struct S_PID p1, void* p2,  double (*cb)(double, struct S_PID, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_PIP(double p0, struct S_PIP p1, void* p2,  double (*cb)(double, struct S_PIP, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_PFI(double p0, struct S_PFI p1, void* p2,  double (*cb)(double, struct S_PFI, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_PFF(double p0, struct S_PFF p1, void* p2,  double (*cb)(double, struct S_PFF, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_PFD(double p0, struct S_PFD p1, void* p2,  double (*cb)(double, struct S_PFD, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_PFP(double p0, struct S_PFP p1, void* p2,  double (*cb)(double, struct S_PFP, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_PDI(double p0, struct S_PDI p1, void* p2,  double (*cb)(double, struct S_PDI, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_PDF(double p0, struct S_PDF p1, void* p2,  double (*cb)(double, struct S_PDF, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_PDD(double p0, struct S_PDD p1, void* p2,  double (*cb)(double, struct S_PDD, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_PDP(double p0, struct S_PDP p1, void* p2,  double (*cb)(double, struct S_PDP, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_PPI(double p0, struct S_PPI p1, void* p2,  double (*cb)(double, struct S_PPI, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_PPF(double p0, struct S_PPF p1, void* p2,  double (*cb)(double, struct S_PPF, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_PPD(double p0, struct S_PPD p1, void* p2,  double (*cb)(double, struct S_PPD, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSP_PPP(double p0, struct S_PPP p1, void* p2,  double (*cb)(double, struct S_PPP, void*)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_I(double p0, struct S_I p1, struct S_I p2,  double (*cb)(double, struct S_I, struct S_I)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_F(double p0, struct S_F p1, struct S_F p2,  double (*cb)(double, struct S_F, struct S_F)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_D(double p0, struct S_D p1, struct S_D p2,  double (*cb)(double, struct S_D, struct S_D)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_P(double p0, struct S_P p1, struct S_P p2,  double (*cb)(double, struct S_P, struct S_P)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_II(double p0, struct S_II p1, struct S_II p2,  double (*cb)(double, struct S_II, struct S_II)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_IF(double p0, struct S_IF p1, struct S_IF p2,  double (*cb)(double, struct S_IF, struct S_IF)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_ID(double p0, struct S_ID p1, struct S_ID p2,  double (*cb)(double, struct S_ID, struct S_ID)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_IP(double p0, struct S_IP p1, struct S_IP p2,  double (*cb)(double, struct S_IP, struct S_IP)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_FI(double p0, struct S_FI p1, struct S_FI p2,  double (*cb)(double, struct S_FI, struct S_FI)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_FF(double p0, struct S_FF p1, struct S_FF p2,  double (*cb)(double, struct S_FF, struct S_FF)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_FD(double p0, struct S_FD p1, struct S_FD p2,  double (*cb)(double, struct S_FD, struct S_FD)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_FP(double p0, struct S_FP p1, struct S_FP p2,  double (*cb)(double, struct S_FP, struct S_FP)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_DI(double p0, struct S_DI p1, struct S_DI p2,  double (*cb)(double, struct S_DI, struct S_DI)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_DF(double p0, struct S_DF p1, struct S_DF p2,  double (*cb)(double, struct S_DF, struct S_DF)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_DD(double p0, struct S_DD p1, struct S_DD p2,  double (*cb)(double, struct S_DD, struct S_DD)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_DP(double p0, struct S_DP p1, struct S_DP p2,  double (*cb)(double, struct S_DP, struct S_DP)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_PI(double p0, struct S_PI p1, struct S_PI p2,  double (*cb)(double, struct S_PI, struct S_PI)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_PF(double p0, struct S_PF p1, struct S_PF p2,  double (*cb)(double, struct S_PF, struct S_PF)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_PD(double p0, struct S_PD p1, struct S_PD p2,  double (*cb)(double, struct S_PD, struct S_PD)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_PP(double p0, struct S_PP p1, struct S_PP p2,  double (*cb)(double, struct S_PP, struct S_PP)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_III(double p0, struct S_III p1, struct S_III p2,  double (*cb)(double, struct S_III, struct S_III)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_IIF(double p0, struct S_IIF p1, struct S_IIF p2,  double (*cb)(double, struct S_IIF, struct S_IIF)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_IID(double p0, struct S_IID p1, struct S_IID p2,  double (*cb)(double, struct S_IID, struct S_IID)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_IIP(double p0, struct S_IIP p1, struct S_IIP p2,  double (*cb)(double, struct S_IIP, struct S_IIP)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_IFI(double p0, struct S_IFI p1, struct S_IFI p2,  double (*cb)(double, struct S_IFI, struct S_IFI)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_IFF(double p0, struct S_IFF p1, struct S_IFF p2,  double (*cb)(double, struct S_IFF, struct S_IFF)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_IFD(double p0, struct S_IFD p1, struct S_IFD p2,  double (*cb)(double, struct S_IFD, struct S_IFD)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_IFP(double p0, struct S_IFP p1, struct S_IFP p2,  double (*cb)(double, struct S_IFP, struct S_IFP)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_IDI(double p0, struct S_IDI p1, struct S_IDI p2,  double (*cb)(double, struct S_IDI, struct S_IDI)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_IDF(double p0, struct S_IDF p1, struct S_IDF p2,  double (*cb)(double, struct S_IDF, struct S_IDF)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_IDD(double p0, struct S_IDD p1, struct S_IDD p2,  double (*cb)(double, struct S_IDD, struct S_IDD)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_IDP(double p0, struct S_IDP p1, struct S_IDP p2,  double (*cb)(double, struct S_IDP, struct S_IDP)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_IPI(double p0, struct S_IPI p1, struct S_IPI p2,  double (*cb)(double, struct S_IPI, struct S_IPI)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_IPF(double p0, struct S_IPF p1, struct S_IPF p2,  double (*cb)(double, struct S_IPF, struct S_IPF)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_IPD(double p0, struct S_IPD p1, struct S_IPD p2,  double (*cb)(double, struct S_IPD, struct S_IPD)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_IPP(double p0, struct S_IPP p1, struct S_IPP p2,  double (*cb)(double, struct S_IPP, struct S_IPP)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_FII(double p0, struct S_FII p1, struct S_FII p2,  double (*cb)(double, struct S_FII, struct S_FII)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_FIF(double p0, struct S_FIF p1, struct S_FIF p2,  double (*cb)(double, struct S_FIF, struct S_FIF)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_FID(double p0, struct S_FID p1, struct S_FID p2,  double (*cb)(double, struct S_FID, struct S_FID)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_FIP(double p0, struct S_FIP p1, struct S_FIP p2,  double (*cb)(double, struct S_FIP, struct S_FIP)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_FFI(double p0, struct S_FFI p1, struct S_FFI p2,  double (*cb)(double, struct S_FFI, struct S_FFI)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_FFF(double p0, struct S_FFF p1, struct S_FFF p2,  double (*cb)(double, struct S_FFF, struct S_FFF)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_FFD(double p0, struct S_FFD p1, struct S_FFD p2,  double (*cb)(double, struct S_FFD, struct S_FFD)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_FFP(double p0, struct S_FFP p1, struct S_FFP p2,  double (*cb)(double, struct S_FFP, struct S_FFP)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_FDI(double p0, struct S_FDI p1, struct S_FDI p2,  double (*cb)(double, struct S_FDI, struct S_FDI)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_FDF(double p0, struct S_FDF p1, struct S_FDF p2,  double (*cb)(double, struct S_FDF, struct S_FDF)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_FDD(double p0, struct S_FDD p1, struct S_FDD p2,  double (*cb)(double, struct S_FDD, struct S_FDD)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_FDP(double p0, struct S_FDP p1, struct S_FDP p2,  double (*cb)(double, struct S_FDP, struct S_FDP)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_FPI(double p0, struct S_FPI p1, struct S_FPI p2,  double (*cb)(double, struct S_FPI, struct S_FPI)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_FPF(double p0, struct S_FPF p1, struct S_FPF p2,  double (*cb)(double, struct S_FPF, struct S_FPF)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_FPD(double p0, struct S_FPD p1, struct S_FPD p2,  double (*cb)(double, struct S_FPD, struct S_FPD)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_FPP(double p0, struct S_FPP p1, struct S_FPP p2,  double (*cb)(double, struct S_FPP, struct S_FPP)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_DII(double p0, struct S_DII p1, struct S_DII p2,  double (*cb)(double, struct S_DII, struct S_DII)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_DIF(double p0, struct S_DIF p1, struct S_DIF p2,  double (*cb)(double, struct S_DIF, struct S_DIF)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_DID(double p0, struct S_DID p1, struct S_DID p2,  double (*cb)(double, struct S_DID, struct S_DID)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_DIP(double p0, struct S_DIP p1, struct S_DIP p2,  double (*cb)(double, struct S_DIP, struct S_DIP)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_DFI(double p0, struct S_DFI p1, struct S_DFI p2,  double (*cb)(double, struct S_DFI, struct S_DFI)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_DFF(double p0, struct S_DFF p1, struct S_DFF p2,  double (*cb)(double, struct S_DFF, struct S_DFF)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_DFD(double p0, struct S_DFD p1, struct S_DFD p2,  double (*cb)(double, struct S_DFD, struct S_DFD)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_DFP(double p0, struct S_DFP p1, struct S_DFP p2,  double (*cb)(double, struct S_DFP, struct S_DFP)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_DDI(double p0, struct S_DDI p1, struct S_DDI p2,  double (*cb)(double, struct S_DDI, struct S_DDI)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_DDF(double p0, struct S_DDF p1, struct S_DDF p2,  double (*cb)(double, struct S_DDF, struct S_DDF)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_DDD(double p0, struct S_DDD p1, struct S_DDD p2,  double (*cb)(double, struct S_DDD, struct S_DDD)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_DDP(double p0, struct S_DDP p1, struct S_DDP p2,  double (*cb)(double, struct S_DDP, struct S_DDP)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_DPI(double p0, struct S_DPI p1, struct S_DPI p2,  double (*cb)(double, struct S_DPI, struct S_DPI)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_DPF(double p0, struct S_DPF p1, struct S_DPF p2,  double (*cb)(double, struct S_DPF, struct S_DPF)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_DPD(double p0, struct S_DPD p1, struct S_DPD p2,  double (*cb)(double, struct S_DPD, struct S_DPD)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_DPP(double p0, struct S_DPP p1, struct S_DPP p2,  double (*cb)(double, struct S_DPP, struct S_DPP)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_PII(double p0, struct S_PII p1, struct S_PII p2,  double (*cb)(double, struct S_PII, struct S_PII)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_PIF(double p0, struct S_PIF p1, struct S_PIF p2,  double (*cb)(double, struct S_PIF, struct S_PIF)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_PID(double p0, struct S_PID p1, struct S_PID p2,  double (*cb)(double, struct S_PID, struct S_PID)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_PIP(double p0, struct S_PIP p1, struct S_PIP p2,  double (*cb)(double, struct S_PIP, struct S_PIP)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_PFI(double p0, struct S_PFI p1, struct S_PFI p2,  double (*cb)(double, struct S_PFI, struct S_PFI)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_PFF(double p0, struct S_PFF p1, struct S_PFF p2,  double (*cb)(double, struct S_PFF, struct S_PFF)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_PFD(double p0, struct S_PFD p1, struct S_PFD p2,  double (*cb)(double, struct S_PFD, struct S_PFD)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_PFP(double p0, struct S_PFP p1, struct S_PFP p2,  double (*cb)(double, struct S_PFP, struct S_PFP)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_PDI(double p0, struct S_PDI p1, struct S_PDI p2,  double (*cb)(double, struct S_PDI, struct S_PDI)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_PDF(double p0, struct S_PDF p1, struct S_PDF p2,  double (*cb)(double, struct S_PDF, struct S_PDF)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_PDD(double p0, struct S_PDD p1, struct S_PDD p2,  double (*cb)(double, struct S_PDD, struct S_PDD)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_PDP(double p0, struct S_PDP p1, struct S_PDP p2,  double (*cb)(double, struct S_PDP, struct S_PDP)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_PPI(double p0, struct S_PPI p1, struct S_PPI p2,  double (*cb)(double, struct S_PPI, struct S_PPI)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_PPF(double p0, struct S_PPF p1, struct S_PPF p2,  double (*cb)(double, struct S_PPF, struct S_PPF)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_PPD(double p0, struct S_PPD p1, struct S_PPD p2,  double (*cb)(double, struct S_PPD, struct S_PPD)) { return cb(p0,p1,p2); }
+EXPORT double f15_D_DSS_PPP(double p0, struct S_PPP p1, struct S_PPP p2,  double (*cb)(double, struct S_PPP, struct S_PPP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PII_(void* p0, int p1, int p2,  void* (*cb)(void*, int, int)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIF_(void* p0, int p1, float p2,  void* (*cb)(void*, int, float)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PID_(void* p0, int p1, double p2,  void* (*cb)(void*, int, double)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIP_(void* p0, int p1, void* p2,  void* (*cb)(void*, int, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_I(void* p0, int p1, struct S_I p2,  void* (*cb)(void*, int, struct S_I)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_F(void* p0, int p1, struct S_F p2,  void* (*cb)(void*, int, struct S_F)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_D(void* p0, int p1, struct S_D p2,  void* (*cb)(void*, int, struct S_D)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_P(void* p0, int p1, struct S_P p2,  void* (*cb)(void*, int, struct S_P)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_II(void* p0, int p1, struct S_II p2,  void* (*cb)(void*, int, struct S_II)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_IF(void* p0, int p1, struct S_IF p2,  void* (*cb)(void*, int, struct S_IF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_ID(void* p0, int p1, struct S_ID p2,  void* (*cb)(void*, int, struct S_ID)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_IP(void* p0, int p1, struct S_IP p2,  void* (*cb)(void*, int, struct S_IP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_FI(void* p0, int p1, struct S_FI p2,  void* (*cb)(void*, int, struct S_FI)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_FF(void* p0, int p1, struct S_FF p2,  void* (*cb)(void*, int, struct S_FF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_FD(void* p0, int p1, struct S_FD p2,  void* (*cb)(void*, int, struct S_FD)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_FP(void* p0, int p1, struct S_FP p2,  void* (*cb)(void*, int, struct S_FP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_DI(void* p0, int p1, struct S_DI p2,  void* (*cb)(void*, int, struct S_DI)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_DF(void* p0, int p1, struct S_DF p2,  void* (*cb)(void*, int, struct S_DF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_DD(void* p0, int p1, struct S_DD p2,  void* (*cb)(void*, int, struct S_DD)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_DP(void* p0, int p1, struct S_DP p2,  void* (*cb)(void*, int, struct S_DP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_PI(void* p0, int p1, struct S_PI p2,  void* (*cb)(void*, int, struct S_PI)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_PF(void* p0, int p1, struct S_PF p2,  void* (*cb)(void*, int, struct S_PF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_PD(void* p0, int p1, struct S_PD p2,  void* (*cb)(void*, int, struct S_PD)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_PP(void* p0, int p1, struct S_PP p2,  void* (*cb)(void*, int, struct S_PP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_III(void* p0, int p1, struct S_III p2,  void* (*cb)(void*, int, struct S_III)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_IIF(void* p0, int p1, struct S_IIF p2,  void* (*cb)(void*, int, struct S_IIF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_IID(void* p0, int p1, struct S_IID p2,  void* (*cb)(void*, int, struct S_IID)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_IIP(void* p0, int p1, struct S_IIP p2,  void* (*cb)(void*, int, struct S_IIP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_IFI(void* p0, int p1, struct S_IFI p2,  void* (*cb)(void*, int, struct S_IFI)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_IFF(void* p0, int p1, struct S_IFF p2,  void* (*cb)(void*, int, struct S_IFF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_IFD(void* p0, int p1, struct S_IFD p2,  void* (*cb)(void*, int, struct S_IFD)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_IFP(void* p0, int p1, struct S_IFP p2,  void* (*cb)(void*, int, struct S_IFP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_IDI(void* p0, int p1, struct S_IDI p2,  void* (*cb)(void*, int, struct S_IDI)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_IDF(void* p0, int p1, struct S_IDF p2,  void* (*cb)(void*, int, struct S_IDF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_IDD(void* p0, int p1, struct S_IDD p2,  void* (*cb)(void*, int, struct S_IDD)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_IDP(void* p0, int p1, struct S_IDP p2,  void* (*cb)(void*, int, struct S_IDP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_IPI(void* p0, int p1, struct S_IPI p2,  void* (*cb)(void*, int, struct S_IPI)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_IPF(void* p0, int p1, struct S_IPF p2,  void* (*cb)(void*, int, struct S_IPF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_IPD(void* p0, int p1, struct S_IPD p2,  void* (*cb)(void*, int, struct S_IPD)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_IPP(void* p0, int p1, struct S_IPP p2,  void* (*cb)(void*, int, struct S_IPP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_FII(void* p0, int p1, struct S_FII p2,  void* (*cb)(void*, int, struct S_FII)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_FIF(void* p0, int p1, struct S_FIF p2,  void* (*cb)(void*, int, struct S_FIF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_FID(void* p0, int p1, struct S_FID p2,  void* (*cb)(void*, int, struct S_FID)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_FIP(void* p0, int p1, struct S_FIP p2,  void* (*cb)(void*, int, struct S_FIP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_FFI(void* p0, int p1, struct S_FFI p2,  void* (*cb)(void*, int, struct S_FFI)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_FFF(void* p0, int p1, struct S_FFF p2,  void* (*cb)(void*, int, struct S_FFF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_FFD(void* p0, int p1, struct S_FFD p2,  void* (*cb)(void*, int, struct S_FFD)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_FFP(void* p0, int p1, struct S_FFP p2,  void* (*cb)(void*, int, struct S_FFP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_FDI(void* p0, int p1, struct S_FDI p2,  void* (*cb)(void*, int, struct S_FDI)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_FDF(void* p0, int p1, struct S_FDF p2,  void* (*cb)(void*, int, struct S_FDF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_FDD(void* p0, int p1, struct S_FDD p2,  void* (*cb)(void*, int, struct S_FDD)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_FDP(void* p0, int p1, struct S_FDP p2,  void* (*cb)(void*, int, struct S_FDP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_FPI(void* p0, int p1, struct S_FPI p2,  void* (*cb)(void*, int, struct S_FPI)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_FPF(void* p0, int p1, struct S_FPF p2,  void* (*cb)(void*, int, struct S_FPF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_FPD(void* p0, int p1, struct S_FPD p2,  void* (*cb)(void*, int, struct S_FPD)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_FPP(void* p0, int p1, struct S_FPP p2,  void* (*cb)(void*, int, struct S_FPP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_DII(void* p0, int p1, struct S_DII p2,  void* (*cb)(void*, int, struct S_DII)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_DIF(void* p0, int p1, struct S_DIF p2,  void* (*cb)(void*, int, struct S_DIF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_DID(void* p0, int p1, struct S_DID p2,  void* (*cb)(void*, int, struct S_DID)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_DIP(void* p0, int p1, struct S_DIP p2,  void* (*cb)(void*, int, struct S_DIP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_DFI(void* p0, int p1, struct S_DFI p2,  void* (*cb)(void*, int, struct S_DFI)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_DFF(void* p0, int p1, struct S_DFF p2,  void* (*cb)(void*, int, struct S_DFF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_DFD(void* p0, int p1, struct S_DFD p2,  void* (*cb)(void*, int, struct S_DFD)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_DFP(void* p0, int p1, struct S_DFP p2,  void* (*cb)(void*, int, struct S_DFP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_DDI(void* p0, int p1, struct S_DDI p2,  void* (*cb)(void*, int, struct S_DDI)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_DDF(void* p0, int p1, struct S_DDF p2,  void* (*cb)(void*, int, struct S_DDF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_DDD(void* p0, int p1, struct S_DDD p2,  void* (*cb)(void*, int, struct S_DDD)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_DDP(void* p0, int p1, struct S_DDP p2,  void* (*cb)(void*, int, struct S_DDP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_DPI(void* p0, int p1, struct S_DPI p2,  void* (*cb)(void*, int, struct S_DPI)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_DPF(void* p0, int p1, struct S_DPF p2,  void* (*cb)(void*, int, struct S_DPF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_DPD(void* p0, int p1, struct S_DPD p2,  void* (*cb)(void*, int, struct S_DPD)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_DPP(void* p0, int p1, struct S_DPP p2,  void* (*cb)(void*, int, struct S_DPP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_PII(void* p0, int p1, struct S_PII p2,  void* (*cb)(void*, int, struct S_PII)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_PIF(void* p0, int p1, struct S_PIF p2,  void* (*cb)(void*, int, struct S_PIF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_PID(void* p0, int p1, struct S_PID p2,  void* (*cb)(void*, int, struct S_PID)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_PIP(void* p0, int p1, struct S_PIP p2,  void* (*cb)(void*, int, struct S_PIP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_PFI(void* p0, int p1, struct S_PFI p2,  void* (*cb)(void*, int, struct S_PFI)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_PFF(void* p0, int p1, struct S_PFF p2,  void* (*cb)(void*, int, struct S_PFF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_PFD(void* p0, int p1, struct S_PFD p2,  void* (*cb)(void*, int, struct S_PFD)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_PFP(void* p0, int p1, struct S_PFP p2,  void* (*cb)(void*, int, struct S_PFP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_PDI(void* p0, int p1, struct S_PDI p2,  void* (*cb)(void*, int, struct S_PDI)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_PDF(void* p0, int p1, struct S_PDF p2,  void* (*cb)(void*, int, struct S_PDF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_PDD(void* p0, int p1, struct S_PDD p2,  void* (*cb)(void*, int, struct S_PDD)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_PDP(void* p0, int p1, struct S_PDP p2,  void* (*cb)(void*, int, struct S_PDP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_PPI(void* p0, int p1, struct S_PPI p2,  void* (*cb)(void*, int, struct S_PPI)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_PPF(void* p0, int p1, struct S_PPF p2,  void* (*cb)(void*, int, struct S_PPF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_PPD(void* p0, int p1, struct S_PPD p2,  void* (*cb)(void*, int, struct S_PPD)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PIS_PPP(void* p0, int p1, struct S_PPP p2,  void* (*cb)(void*, int, struct S_PPP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFI_(void* p0, float p1, int p2,  void* (*cb)(void*, float, int)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFF_(void* p0, float p1, float p2,  void* (*cb)(void*, float, float)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFD_(void* p0, float p1, double p2,  void* (*cb)(void*, float, double)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFP_(void* p0, float p1, void* p2,  void* (*cb)(void*, float, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_I(void* p0, float p1, struct S_I p2,  void* (*cb)(void*, float, struct S_I)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_F(void* p0, float p1, struct S_F p2,  void* (*cb)(void*, float, struct S_F)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_D(void* p0, float p1, struct S_D p2,  void* (*cb)(void*, float, struct S_D)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_P(void* p0, float p1, struct S_P p2,  void* (*cb)(void*, float, struct S_P)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_II(void* p0, float p1, struct S_II p2,  void* (*cb)(void*, float, struct S_II)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_IF(void* p0, float p1, struct S_IF p2,  void* (*cb)(void*, float, struct S_IF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_ID(void* p0, float p1, struct S_ID p2,  void* (*cb)(void*, float, struct S_ID)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_IP(void* p0, float p1, struct S_IP p2,  void* (*cb)(void*, float, struct S_IP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_FI(void* p0, float p1, struct S_FI p2,  void* (*cb)(void*, float, struct S_FI)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_FF(void* p0, float p1, struct S_FF p2,  void* (*cb)(void*, float, struct S_FF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_FD(void* p0, float p1, struct S_FD p2,  void* (*cb)(void*, float, struct S_FD)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_FP(void* p0, float p1, struct S_FP p2,  void* (*cb)(void*, float, struct S_FP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_DI(void* p0, float p1, struct S_DI p2,  void* (*cb)(void*, float, struct S_DI)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_DF(void* p0, float p1, struct S_DF p2,  void* (*cb)(void*, float, struct S_DF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_DD(void* p0, float p1, struct S_DD p2,  void* (*cb)(void*, float, struct S_DD)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_DP(void* p0, float p1, struct S_DP p2,  void* (*cb)(void*, float, struct S_DP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_PI(void* p0, float p1, struct S_PI p2,  void* (*cb)(void*, float, struct S_PI)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_PF(void* p0, float p1, struct S_PF p2,  void* (*cb)(void*, float, struct S_PF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_PD(void* p0, float p1, struct S_PD p2,  void* (*cb)(void*, float, struct S_PD)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_PP(void* p0, float p1, struct S_PP p2,  void* (*cb)(void*, float, struct S_PP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_III(void* p0, float p1, struct S_III p2,  void* (*cb)(void*, float, struct S_III)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_IIF(void* p0, float p1, struct S_IIF p2,  void* (*cb)(void*, float, struct S_IIF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_IID(void* p0, float p1, struct S_IID p2,  void* (*cb)(void*, float, struct S_IID)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_IIP(void* p0, float p1, struct S_IIP p2,  void* (*cb)(void*, float, struct S_IIP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_IFI(void* p0, float p1, struct S_IFI p2,  void* (*cb)(void*, float, struct S_IFI)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_IFF(void* p0, float p1, struct S_IFF p2,  void* (*cb)(void*, float, struct S_IFF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_IFD(void* p0, float p1, struct S_IFD p2,  void* (*cb)(void*, float, struct S_IFD)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_IFP(void* p0, float p1, struct S_IFP p2,  void* (*cb)(void*, float, struct S_IFP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_IDI(void* p0, float p1, struct S_IDI p2,  void* (*cb)(void*, float, struct S_IDI)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_IDF(void* p0, float p1, struct S_IDF p2,  void* (*cb)(void*, float, struct S_IDF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_IDD(void* p0, float p1, struct S_IDD p2,  void* (*cb)(void*, float, struct S_IDD)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_IDP(void* p0, float p1, struct S_IDP p2,  void* (*cb)(void*, float, struct S_IDP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_IPI(void* p0, float p1, struct S_IPI p2,  void* (*cb)(void*, float, struct S_IPI)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_IPF(void* p0, float p1, struct S_IPF p2,  void* (*cb)(void*, float, struct S_IPF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_IPD(void* p0, float p1, struct S_IPD p2,  void* (*cb)(void*, float, struct S_IPD)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_IPP(void* p0, float p1, struct S_IPP p2,  void* (*cb)(void*, float, struct S_IPP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_FII(void* p0, float p1, struct S_FII p2,  void* (*cb)(void*, float, struct S_FII)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_FIF(void* p0, float p1, struct S_FIF p2,  void* (*cb)(void*, float, struct S_FIF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_FID(void* p0, float p1, struct S_FID p2,  void* (*cb)(void*, float, struct S_FID)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_FIP(void* p0, float p1, struct S_FIP p2,  void* (*cb)(void*, float, struct S_FIP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_FFI(void* p0, float p1, struct S_FFI p2,  void* (*cb)(void*, float, struct S_FFI)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_FFF(void* p0, float p1, struct S_FFF p2,  void* (*cb)(void*, float, struct S_FFF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_FFD(void* p0, float p1, struct S_FFD p2,  void* (*cb)(void*, float, struct S_FFD)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_FFP(void* p0, float p1, struct S_FFP p2,  void* (*cb)(void*, float, struct S_FFP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_FDI(void* p0, float p1, struct S_FDI p2,  void* (*cb)(void*, float, struct S_FDI)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_FDF(void* p0, float p1, struct S_FDF p2,  void* (*cb)(void*, float, struct S_FDF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_FDD(void* p0, float p1, struct S_FDD p2,  void* (*cb)(void*, float, struct S_FDD)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_FDP(void* p0, float p1, struct S_FDP p2,  void* (*cb)(void*, float, struct S_FDP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_FPI(void* p0, float p1, struct S_FPI p2,  void* (*cb)(void*, float, struct S_FPI)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_FPF(void* p0, float p1, struct S_FPF p2,  void* (*cb)(void*, float, struct S_FPF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_FPD(void* p0, float p1, struct S_FPD p2,  void* (*cb)(void*, float, struct S_FPD)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_FPP(void* p0, float p1, struct S_FPP p2,  void* (*cb)(void*, float, struct S_FPP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_DII(void* p0, float p1, struct S_DII p2,  void* (*cb)(void*, float, struct S_DII)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_DIF(void* p0, float p1, struct S_DIF p2,  void* (*cb)(void*, float, struct S_DIF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_DID(void* p0, float p1, struct S_DID p2,  void* (*cb)(void*, float, struct S_DID)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_DIP(void* p0, float p1, struct S_DIP p2,  void* (*cb)(void*, float, struct S_DIP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_DFI(void* p0, float p1, struct S_DFI p2,  void* (*cb)(void*, float, struct S_DFI)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_DFF(void* p0, float p1, struct S_DFF p2,  void* (*cb)(void*, float, struct S_DFF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_DFD(void* p0, float p1, struct S_DFD p2,  void* (*cb)(void*, float, struct S_DFD)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_DFP(void* p0, float p1, struct S_DFP p2,  void* (*cb)(void*, float, struct S_DFP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_DDI(void* p0, float p1, struct S_DDI p2,  void* (*cb)(void*, float, struct S_DDI)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_DDF(void* p0, float p1, struct S_DDF p2,  void* (*cb)(void*, float, struct S_DDF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_DDD(void* p0, float p1, struct S_DDD p2,  void* (*cb)(void*, float, struct S_DDD)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_DDP(void* p0, float p1, struct S_DDP p2,  void* (*cb)(void*, float, struct S_DDP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_DPI(void* p0, float p1, struct S_DPI p2,  void* (*cb)(void*, float, struct S_DPI)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_DPF(void* p0, float p1, struct S_DPF p2,  void* (*cb)(void*, float, struct S_DPF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_DPD(void* p0, float p1, struct S_DPD p2,  void* (*cb)(void*, float, struct S_DPD)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_DPP(void* p0, float p1, struct S_DPP p2,  void* (*cb)(void*, float, struct S_DPP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_PII(void* p0, float p1, struct S_PII p2,  void* (*cb)(void*, float, struct S_PII)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_PIF(void* p0, float p1, struct S_PIF p2,  void* (*cb)(void*, float, struct S_PIF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_PID(void* p0, float p1, struct S_PID p2,  void* (*cb)(void*, float, struct S_PID)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_PIP(void* p0, float p1, struct S_PIP p2,  void* (*cb)(void*, float, struct S_PIP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_PFI(void* p0, float p1, struct S_PFI p2,  void* (*cb)(void*, float, struct S_PFI)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_PFF(void* p0, float p1, struct S_PFF p2,  void* (*cb)(void*, float, struct S_PFF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_PFD(void* p0, float p1, struct S_PFD p2,  void* (*cb)(void*, float, struct S_PFD)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_PFP(void* p0, float p1, struct S_PFP p2,  void* (*cb)(void*, float, struct S_PFP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_PDI(void* p0, float p1, struct S_PDI p2,  void* (*cb)(void*, float, struct S_PDI)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_PDF(void* p0, float p1, struct S_PDF p2,  void* (*cb)(void*, float, struct S_PDF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_PDD(void* p0, float p1, struct S_PDD p2,  void* (*cb)(void*, float, struct S_PDD)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_PDP(void* p0, float p1, struct S_PDP p2,  void* (*cb)(void*, float, struct S_PDP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_PPI(void* p0, float p1, struct S_PPI p2,  void* (*cb)(void*, float, struct S_PPI)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_PPF(void* p0, float p1, struct S_PPF p2,  void* (*cb)(void*, float, struct S_PPF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_PPD(void* p0, float p1, struct S_PPD p2,  void* (*cb)(void*, float, struct S_PPD)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PFS_PPP(void* p0, float p1, struct S_PPP p2,  void* (*cb)(void*, float, struct S_PPP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDI_(void* p0, double p1, int p2,  void* (*cb)(void*, double, int)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDF_(void* p0, double p1, float p2,  void* (*cb)(void*, double, float)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDD_(void* p0, double p1, double p2,  void* (*cb)(void*, double, double)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDP_(void* p0, double p1, void* p2,  void* (*cb)(void*, double, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_I(void* p0, double p1, struct S_I p2,  void* (*cb)(void*, double, struct S_I)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_F(void* p0, double p1, struct S_F p2,  void* (*cb)(void*, double, struct S_F)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_D(void* p0, double p1, struct S_D p2,  void* (*cb)(void*, double, struct S_D)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_P(void* p0, double p1, struct S_P p2,  void* (*cb)(void*, double, struct S_P)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_II(void* p0, double p1, struct S_II p2,  void* (*cb)(void*, double, struct S_II)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_IF(void* p0, double p1, struct S_IF p2,  void* (*cb)(void*, double, struct S_IF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_ID(void* p0, double p1, struct S_ID p2,  void* (*cb)(void*, double, struct S_ID)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_IP(void* p0, double p1, struct S_IP p2,  void* (*cb)(void*, double, struct S_IP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_FI(void* p0, double p1, struct S_FI p2,  void* (*cb)(void*, double, struct S_FI)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_FF(void* p0, double p1, struct S_FF p2,  void* (*cb)(void*, double, struct S_FF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_FD(void* p0, double p1, struct S_FD p2,  void* (*cb)(void*, double, struct S_FD)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_FP(void* p0, double p1, struct S_FP p2,  void* (*cb)(void*, double, struct S_FP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_DI(void* p0, double p1, struct S_DI p2,  void* (*cb)(void*, double, struct S_DI)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_DF(void* p0, double p1, struct S_DF p2,  void* (*cb)(void*, double, struct S_DF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_DD(void* p0, double p1, struct S_DD p2,  void* (*cb)(void*, double, struct S_DD)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_DP(void* p0, double p1, struct S_DP p2,  void* (*cb)(void*, double, struct S_DP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_PI(void* p0, double p1, struct S_PI p2,  void* (*cb)(void*, double, struct S_PI)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_PF(void* p0, double p1, struct S_PF p2,  void* (*cb)(void*, double, struct S_PF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_PD(void* p0, double p1, struct S_PD p2,  void* (*cb)(void*, double, struct S_PD)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_PP(void* p0, double p1, struct S_PP p2,  void* (*cb)(void*, double, struct S_PP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_III(void* p0, double p1, struct S_III p2,  void* (*cb)(void*, double, struct S_III)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_IIF(void* p0, double p1, struct S_IIF p2,  void* (*cb)(void*, double, struct S_IIF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_IID(void* p0, double p1, struct S_IID p2,  void* (*cb)(void*, double, struct S_IID)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_IIP(void* p0, double p1, struct S_IIP p2,  void* (*cb)(void*, double, struct S_IIP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_IFI(void* p0, double p1, struct S_IFI p2,  void* (*cb)(void*, double, struct S_IFI)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_IFF(void* p0, double p1, struct S_IFF p2,  void* (*cb)(void*, double, struct S_IFF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_IFD(void* p0, double p1, struct S_IFD p2,  void* (*cb)(void*, double, struct S_IFD)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_IFP(void* p0, double p1, struct S_IFP p2,  void* (*cb)(void*, double, struct S_IFP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_IDI(void* p0, double p1, struct S_IDI p2,  void* (*cb)(void*, double, struct S_IDI)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_IDF(void* p0, double p1, struct S_IDF p2,  void* (*cb)(void*, double, struct S_IDF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_IDD(void* p0, double p1, struct S_IDD p2,  void* (*cb)(void*, double, struct S_IDD)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_IDP(void* p0, double p1, struct S_IDP p2,  void* (*cb)(void*, double, struct S_IDP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_IPI(void* p0, double p1, struct S_IPI p2,  void* (*cb)(void*, double, struct S_IPI)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_IPF(void* p0, double p1, struct S_IPF p2,  void* (*cb)(void*, double, struct S_IPF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_IPD(void* p0, double p1, struct S_IPD p2,  void* (*cb)(void*, double, struct S_IPD)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_IPP(void* p0, double p1, struct S_IPP p2,  void* (*cb)(void*, double, struct S_IPP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_FII(void* p0, double p1, struct S_FII p2,  void* (*cb)(void*, double, struct S_FII)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_FIF(void* p0, double p1, struct S_FIF p2,  void* (*cb)(void*, double, struct S_FIF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_FID(void* p0, double p1, struct S_FID p2,  void* (*cb)(void*, double, struct S_FID)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_FIP(void* p0, double p1, struct S_FIP p2,  void* (*cb)(void*, double, struct S_FIP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_FFI(void* p0, double p1, struct S_FFI p2,  void* (*cb)(void*, double, struct S_FFI)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_FFF(void* p0, double p1, struct S_FFF p2,  void* (*cb)(void*, double, struct S_FFF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_FFD(void* p0, double p1, struct S_FFD p2,  void* (*cb)(void*, double, struct S_FFD)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_FFP(void* p0, double p1, struct S_FFP p2,  void* (*cb)(void*, double, struct S_FFP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_FDI(void* p0, double p1, struct S_FDI p2,  void* (*cb)(void*, double, struct S_FDI)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_FDF(void* p0, double p1, struct S_FDF p2,  void* (*cb)(void*, double, struct S_FDF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_FDD(void* p0, double p1, struct S_FDD p2,  void* (*cb)(void*, double, struct S_FDD)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_FDP(void* p0, double p1, struct S_FDP p2,  void* (*cb)(void*, double, struct S_FDP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_FPI(void* p0, double p1, struct S_FPI p2,  void* (*cb)(void*, double, struct S_FPI)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_FPF(void* p0, double p1, struct S_FPF p2,  void* (*cb)(void*, double, struct S_FPF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_FPD(void* p0, double p1, struct S_FPD p2,  void* (*cb)(void*, double, struct S_FPD)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_FPP(void* p0, double p1, struct S_FPP p2,  void* (*cb)(void*, double, struct S_FPP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_DII(void* p0, double p1, struct S_DII p2,  void* (*cb)(void*, double, struct S_DII)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_DIF(void* p0, double p1, struct S_DIF p2,  void* (*cb)(void*, double, struct S_DIF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_DID(void* p0, double p1, struct S_DID p2,  void* (*cb)(void*, double, struct S_DID)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_DIP(void* p0, double p1, struct S_DIP p2,  void* (*cb)(void*, double, struct S_DIP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_DFI(void* p0, double p1, struct S_DFI p2,  void* (*cb)(void*, double, struct S_DFI)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_DFF(void* p0, double p1, struct S_DFF p2,  void* (*cb)(void*, double, struct S_DFF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_DFD(void* p0, double p1, struct S_DFD p2,  void* (*cb)(void*, double, struct S_DFD)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_DFP(void* p0, double p1, struct S_DFP p2,  void* (*cb)(void*, double, struct S_DFP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_DDI(void* p0, double p1, struct S_DDI p2,  void* (*cb)(void*, double, struct S_DDI)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_DDF(void* p0, double p1, struct S_DDF p2,  void* (*cb)(void*, double, struct S_DDF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_DDD(void* p0, double p1, struct S_DDD p2,  void* (*cb)(void*, double, struct S_DDD)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_DDP(void* p0, double p1, struct S_DDP p2,  void* (*cb)(void*, double, struct S_DDP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_DPI(void* p0, double p1, struct S_DPI p2,  void* (*cb)(void*, double, struct S_DPI)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_DPF(void* p0, double p1, struct S_DPF p2,  void* (*cb)(void*, double, struct S_DPF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_DPD(void* p0, double p1, struct S_DPD p2,  void* (*cb)(void*, double, struct S_DPD)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_DPP(void* p0, double p1, struct S_DPP p2,  void* (*cb)(void*, double, struct S_DPP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_PII(void* p0, double p1, struct S_PII p2,  void* (*cb)(void*, double, struct S_PII)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_PIF(void* p0, double p1, struct S_PIF p2,  void* (*cb)(void*, double, struct S_PIF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_PID(void* p0, double p1, struct S_PID p2,  void* (*cb)(void*, double, struct S_PID)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_PIP(void* p0, double p1, struct S_PIP p2,  void* (*cb)(void*, double, struct S_PIP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_PFI(void* p0, double p1, struct S_PFI p2,  void* (*cb)(void*, double, struct S_PFI)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_PFF(void* p0, double p1, struct S_PFF p2,  void* (*cb)(void*, double, struct S_PFF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_PFD(void* p0, double p1, struct S_PFD p2,  void* (*cb)(void*, double, struct S_PFD)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_PFP(void* p0, double p1, struct S_PFP p2,  void* (*cb)(void*, double, struct S_PFP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_PDI(void* p0, double p1, struct S_PDI p2,  void* (*cb)(void*, double, struct S_PDI)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_PDF(void* p0, double p1, struct S_PDF p2,  void* (*cb)(void*, double, struct S_PDF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_PDD(void* p0, double p1, struct S_PDD p2,  void* (*cb)(void*, double, struct S_PDD)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_PDP(void* p0, double p1, struct S_PDP p2,  void* (*cb)(void*, double, struct S_PDP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_PPI(void* p0, double p1, struct S_PPI p2,  void* (*cb)(void*, double, struct S_PPI)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_PPF(void* p0, double p1, struct S_PPF p2,  void* (*cb)(void*, double, struct S_PPF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_PPD(void* p0, double p1, struct S_PPD p2,  void* (*cb)(void*, double, struct S_PPD)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PDS_PPP(void* p0, double p1, struct S_PPP p2,  void* (*cb)(void*, double, struct S_PPP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPI_(void* p0, void* p1, int p2,  void* (*cb)(void*, void*, int)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPF_(void* p0, void* p1, float p2,  void* (*cb)(void*, void*, float)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPD_(void* p0, void* p1, double p2,  void* (*cb)(void*, void*, double)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPP_(void* p0, void* p1, void* p2,  void* (*cb)(void*, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_I(void* p0, void* p1, struct S_I p2,  void* (*cb)(void*, void*, struct S_I)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_F(void* p0, void* p1, struct S_F p2,  void* (*cb)(void*, void*, struct S_F)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_D(void* p0, void* p1, struct S_D p2,  void* (*cb)(void*, void*, struct S_D)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_P(void* p0, void* p1, struct S_P p2,  void* (*cb)(void*, void*, struct S_P)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_II(void* p0, void* p1, struct S_II p2,  void* (*cb)(void*, void*, struct S_II)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_IF(void* p0, void* p1, struct S_IF p2,  void* (*cb)(void*, void*, struct S_IF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_ID(void* p0, void* p1, struct S_ID p2,  void* (*cb)(void*, void*, struct S_ID)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_IP(void* p0, void* p1, struct S_IP p2,  void* (*cb)(void*, void*, struct S_IP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_FI(void* p0, void* p1, struct S_FI p2,  void* (*cb)(void*, void*, struct S_FI)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_FF(void* p0, void* p1, struct S_FF p2,  void* (*cb)(void*, void*, struct S_FF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_FD(void* p0, void* p1, struct S_FD p2,  void* (*cb)(void*, void*, struct S_FD)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_FP(void* p0, void* p1, struct S_FP p2,  void* (*cb)(void*, void*, struct S_FP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_DI(void* p0, void* p1, struct S_DI p2,  void* (*cb)(void*, void*, struct S_DI)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_DF(void* p0, void* p1, struct S_DF p2,  void* (*cb)(void*, void*, struct S_DF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_DD(void* p0, void* p1, struct S_DD p2,  void* (*cb)(void*, void*, struct S_DD)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_DP(void* p0, void* p1, struct S_DP p2,  void* (*cb)(void*, void*, struct S_DP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_PI(void* p0, void* p1, struct S_PI p2,  void* (*cb)(void*, void*, struct S_PI)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_PF(void* p0, void* p1, struct S_PF p2,  void* (*cb)(void*, void*, struct S_PF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_PD(void* p0, void* p1, struct S_PD p2,  void* (*cb)(void*, void*, struct S_PD)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_PP(void* p0, void* p1, struct S_PP p2,  void* (*cb)(void*, void*, struct S_PP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_III(void* p0, void* p1, struct S_III p2,  void* (*cb)(void*, void*, struct S_III)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_IIF(void* p0, void* p1, struct S_IIF p2,  void* (*cb)(void*, void*, struct S_IIF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_IID(void* p0, void* p1, struct S_IID p2,  void* (*cb)(void*, void*, struct S_IID)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_IIP(void* p0, void* p1, struct S_IIP p2,  void* (*cb)(void*, void*, struct S_IIP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_IFI(void* p0, void* p1, struct S_IFI p2,  void* (*cb)(void*, void*, struct S_IFI)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_IFF(void* p0, void* p1, struct S_IFF p2,  void* (*cb)(void*, void*, struct S_IFF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_IFD(void* p0, void* p1, struct S_IFD p2,  void* (*cb)(void*, void*, struct S_IFD)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_IFP(void* p0, void* p1, struct S_IFP p2,  void* (*cb)(void*, void*, struct S_IFP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_IDI(void* p0, void* p1, struct S_IDI p2,  void* (*cb)(void*, void*, struct S_IDI)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_IDF(void* p0, void* p1, struct S_IDF p2,  void* (*cb)(void*, void*, struct S_IDF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_IDD(void* p0, void* p1, struct S_IDD p2,  void* (*cb)(void*, void*, struct S_IDD)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_IDP(void* p0, void* p1, struct S_IDP p2,  void* (*cb)(void*, void*, struct S_IDP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_IPI(void* p0, void* p1, struct S_IPI p2,  void* (*cb)(void*, void*, struct S_IPI)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_IPF(void* p0, void* p1, struct S_IPF p2,  void* (*cb)(void*, void*, struct S_IPF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_IPD(void* p0, void* p1, struct S_IPD p2,  void* (*cb)(void*, void*, struct S_IPD)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_IPP(void* p0, void* p1, struct S_IPP p2,  void* (*cb)(void*, void*, struct S_IPP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_FII(void* p0, void* p1, struct S_FII p2,  void* (*cb)(void*, void*, struct S_FII)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_FIF(void* p0, void* p1, struct S_FIF p2,  void* (*cb)(void*, void*, struct S_FIF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_FID(void* p0, void* p1, struct S_FID p2,  void* (*cb)(void*, void*, struct S_FID)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_FIP(void* p0, void* p1, struct S_FIP p2,  void* (*cb)(void*, void*, struct S_FIP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_FFI(void* p0, void* p1, struct S_FFI p2,  void* (*cb)(void*, void*, struct S_FFI)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_FFF(void* p0, void* p1, struct S_FFF p2,  void* (*cb)(void*, void*, struct S_FFF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_FFD(void* p0, void* p1, struct S_FFD p2,  void* (*cb)(void*, void*, struct S_FFD)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_FFP(void* p0, void* p1, struct S_FFP p2,  void* (*cb)(void*, void*, struct S_FFP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_FDI(void* p0, void* p1, struct S_FDI p2,  void* (*cb)(void*, void*, struct S_FDI)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_FDF(void* p0, void* p1, struct S_FDF p2,  void* (*cb)(void*, void*, struct S_FDF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_FDD(void* p0, void* p1, struct S_FDD p2,  void* (*cb)(void*, void*, struct S_FDD)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_FDP(void* p0, void* p1, struct S_FDP p2,  void* (*cb)(void*, void*, struct S_FDP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_FPI(void* p0, void* p1, struct S_FPI p2,  void* (*cb)(void*, void*, struct S_FPI)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_FPF(void* p0, void* p1, struct S_FPF p2,  void* (*cb)(void*, void*, struct S_FPF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_FPD(void* p0, void* p1, struct S_FPD p2,  void* (*cb)(void*, void*, struct S_FPD)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_FPP(void* p0, void* p1, struct S_FPP p2,  void* (*cb)(void*, void*, struct S_FPP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_DII(void* p0, void* p1, struct S_DII p2,  void* (*cb)(void*, void*, struct S_DII)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_DIF(void* p0, void* p1, struct S_DIF p2,  void* (*cb)(void*, void*, struct S_DIF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_DID(void* p0, void* p1, struct S_DID p2,  void* (*cb)(void*, void*, struct S_DID)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_DIP(void* p0, void* p1, struct S_DIP p2,  void* (*cb)(void*, void*, struct S_DIP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_DFI(void* p0, void* p1, struct S_DFI p2,  void* (*cb)(void*, void*, struct S_DFI)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_DFF(void* p0, void* p1, struct S_DFF p2,  void* (*cb)(void*, void*, struct S_DFF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_DFD(void* p0, void* p1, struct S_DFD p2,  void* (*cb)(void*, void*, struct S_DFD)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_DFP(void* p0, void* p1, struct S_DFP p2,  void* (*cb)(void*, void*, struct S_DFP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_DDI(void* p0, void* p1, struct S_DDI p2,  void* (*cb)(void*, void*, struct S_DDI)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_DDF(void* p0, void* p1, struct S_DDF p2,  void* (*cb)(void*, void*, struct S_DDF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_DDD(void* p0, void* p1, struct S_DDD p2,  void* (*cb)(void*, void*, struct S_DDD)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_DDP(void* p0, void* p1, struct S_DDP p2,  void* (*cb)(void*, void*, struct S_DDP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_DPI(void* p0, void* p1, struct S_DPI p2,  void* (*cb)(void*, void*, struct S_DPI)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_DPF(void* p0, void* p1, struct S_DPF p2,  void* (*cb)(void*, void*, struct S_DPF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_DPD(void* p0, void* p1, struct S_DPD p2,  void* (*cb)(void*, void*, struct S_DPD)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_DPP(void* p0, void* p1, struct S_DPP p2,  void* (*cb)(void*, void*, struct S_DPP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_PII(void* p0, void* p1, struct S_PII p2,  void* (*cb)(void*, void*, struct S_PII)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_PIF(void* p0, void* p1, struct S_PIF p2,  void* (*cb)(void*, void*, struct S_PIF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_PID(void* p0, void* p1, struct S_PID p2,  void* (*cb)(void*, void*, struct S_PID)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_PIP(void* p0, void* p1, struct S_PIP p2,  void* (*cb)(void*, void*, struct S_PIP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_PFI(void* p0, void* p1, struct S_PFI p2,  void* (*cb)(void*, void*, struct S_PFI)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_PFF(void* p0, void* p1, struct S_PFF p2,  void* (*cb)(void*, void*, struct S_PFF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_PFD(void* p0, void* p1, struct S_PFD p2,  void* (*cb)(void*, void*, struct S_PFD)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_PFP(void* p0, void* p1, struct S_PFP p2,  void* (*cb)(void*, void*, struct S_PFP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_PDI(void* p0, void* p1, struct S_PDI p2,  void* (*cb)(void*, void*, struct S_PDI)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_PDF(void* p0, void* p1, struct S_PDF p2,  void* (*cb)(void*, void*, struct S_PDF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_PDD(void* p0, void* p1, struct S_PDD p2,  void* (*cb)(void*, void*, struct S_PDD)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_PDP(void* p0, void* p1, struct S_PDP p2,  void* (*cb)(void*, void*, struct S_PDP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_PPI(void* p0, void* p1, struct S_PPI p2,  void* (*cb)(void*, void*, struct S_PPI)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_PPF(void* p0, void* p1, struct S_PPF p2,  void* (*cb)(void*, void*, struct S_PPF)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_PPD(void* p0, void* p1, struct S_PPD p2,  void* (*cb)(void*, void*, struct S_PPD)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PPS_PPP(void* p0, void* p1, struct S_PPP p2,  void* (*cb)(void*, void*, struct S_PPP)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PSI_I(void* p0, struct S_I p1, int p2,  void* (*cb)(void*, struct S_I, int)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PSI_F(void* p0, struct S_F p1, int p2,  void* (*cb)(void*, struct S_F, int)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PSI_D(void* p0, struct S_D p1, int p2,  void* (*cb)(void*, struct S_D, int)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PSI_P(void* p0, struct S_P p1, int p2,  void* (*cb)(void*, struct S_P, int)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PSI_II(void* p0, struct S_II p1, int p2,  void* (*cb)(void*, struct S_II, int)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PSI_IF(void* p0, struct S_IF p1, int p2,  void* (*cb)(void*, struct S_IF, int)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PSI_ID(void* p0, struct S_ID p1, int p2,  void* (*cb)(void*, struct S_ID, int)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PSI_IP(void* p0, struct S_IP p1, int p2,  void* (*cb)(void*, struct S_IP, int)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PSI_FI(void* p0, struct S_FI p1, int p2,  void* (*cb)(void*, struct S_FI, int)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PSI_FF(void* p0, struct S_FF p1, int p2,  void* (*cb)(void*, struct S_FF, int)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PSI_FD(void* p0, struct S_FD p1, int p2,  void* (*cb)(void*, struct S_FD, int)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PSI_FP(void* p0, struct S_FP p1, int p2,  void* (*cb)(void*, struct S_FP, int)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PSI_DI(void* p0, struct S_DI p1, int p2,  void* (*cb)(void*, struct S_DI, int)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PSI_DF(void* p0, struct S_DF p1, int p2,  void* (*cb)(void*, struct S_DF, int)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PSI_DD(void* p0, struct S_DD p1, int p2,  void* (*cb)(void*, struct S_DD, int)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PSI_DP(void* p0, struct S_DP p1, int p2,  void* (*cb)(void*, struct S_DP, int)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PSI_PI(void* p0, struct S_PI p1, int p2,  void* (*cb)(void*, struct S_PI, int)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PSI_PF(void* p0, struct S_PF p1, int p2,  void* (*cb)(void*, struct S_PF, int)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PSI_PD(void* p0, struct S_PD p1, int p2,  void* (*cb)(void*, struct S_PD, int)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PSI_PP(void* p0, struct S_PP p1, int p2,  void* (*cb)(void*, struct S_PP, int)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PSI_III(void* p0, struct S_III p1, int p2,  void* (*cb)(void*, struct S_III, int)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PSI_IIF(void* p0, struct S_IIF p1, int p2,  void* (*cb)(void*, struct S_IIF, int)) { return cb(p0,p1,p2); }
+EXPORT void* f15_P_PSI_IID(void* p0, struct S_IID p1, int p2,  void* (*cb)(void*, struct S_IID, int)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSI_IIP(void* p0, struct S_IIP p1, int p2,  void* (*cb)(void*, struct S_IIP, int)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSI_IFI(void* p0, struct S_IFI p1, int p2,  void* (*cb)(void*, struct S_IFI, int)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSI_IFF(void* p0, struct S_IFF p1, int p2,  void* (*cb)(void*, struct S_IFF, int)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSI_IFD(void* p0, struct S_IFD p1, int p2,  void* (*cb)(void*, struct S_IFD, int)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSI_IFP(void* p0, struct S_IFP p1, int p2,  void* (*cb)(void*, struct S_IFP, int)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSI_IDI(void* p0, struct S_IDI p1, int p2,  void* (*cb)(void*, struct S_IDI, int)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSI_IDF(void* p0, struct S_IDF p1, int p2,  void* (*cb)(void*, struct S_IDF, int)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSI_IDD(void* p0, struct S_IDD p1, int p2,  void* (*cb)(void*, struct S_IDD, int)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSI_IDP(void* p0, struct S_IDP p1, int p2,  void* (*cb)(void*, struct S_IDP, int)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSI_IPI(void* p0, struct S_IPI p1, int p2,  void* (*cb)(void*, struct S_IPI, int)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSI_IPF(void* p0, struct S_IPF p1, int p2,  void* (*cb)(void*, struct S_IPF, int)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSI_IPD(void* p0, struct S_IPD p1, int p2,  void* (*cb)(void*, struct S_IPD, int)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSI_IPP(void* p0, struct S_IPP p1, int p2,  void* (*cb)(void*, struct S_IPP, int)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSI_FII(void* p0, struct S_FII p1, int p2,  void* (*cb)(void*, struct S_FII, int)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSI_FIF(void* p0, struct S_FIF p1, int p2,  void* (*cb)(void*, struct S_FIF, int)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSI_FID(void* p0, struct S_FID p1, int p2,  void* (*cb)(void*, struct S_FID, int)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSI_FIP(void* p0, struct S_FIP p1, int p2,  void* (*cb)(void*, struct S_FIP, int)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSI_FFI(void* p0, struct S_FFI p1, int p2,  void* (*cb)(void*, struct S_FFI, int)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSI_FFF(void* p0, struct S_FFF p1, int p2,  void* (*cb)(void*, struct S_FFF, int)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSI_FFD(void* p0, struct S_FFD p1, int p2,  void* (*cb)(void*, struct S_FFD, int)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSI_FFP(void* p0, struct S_FFP p1, int p2,  void* (*cb)(void*, struct S_FFP, int)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSI_FDI(void* p0, struct S_FDI p1, int p2,  void* (*cb)(void*, struct S_FDI, int)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSI_FDF(void* p0, struct S_FDF p1, int p2,  void* (*cb)(void*, struct S_FDF, int)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSI_FDD(void* p0, struct S_FDD p1, int p2,  void* (*cb)(void*, struct S_FDD, int)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSI_FDP(void* p0, struct S_FDP p1, int p2,  void* (*cb)(void*, struct S_FDP, int)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSI_FPI(void* p0, struct S_FPI p1, int p2,  void* (*cb)(void*, struct S_FPI, int)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSI_FPF(void* p0, struct S_FPF p1, int p2,  void* (*cb)(void*, struct S_FPF, int)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSI_FPD(void* p0, struct S_FPD p1, int p2,  void* (*cb)(void*, struct S_FPD, int)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSI_FPP(void* p0, struct S_FPP p1, int p2,  void* (*cb)(void*, struct S_FPP, int)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSI_DII(void* p0, struct S_DII p1, int p2,  void* (*cb)(void*, struct S_DII, int)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSI_DIF(void* p0, struct S_DIF p1, int p2,  void* (*cb)(void*, struct S_DIF, int)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSI_DID(void* p0, struct S_DID p1, int p2,  void* (*cb)(void*, struct S_DID, int)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSI_DIP(void* p0, struct S_DIP p1, int p2,  void* (*cb)(void*, struct S_DIP, int)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSI_DFI(void* p0, struct S_DFI p1, int p2,  void* (*cb)(void*, struct S_DFI, int)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSI_DFF(void* p0, struct S_DFF p1, int p2,  void* (*cb)(void*, struct S_DFF, int)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSI_DFD(void* p0, struct S_DFD p1, int p2,  void* (*cb)(void*, struct S_DFD, int)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSI_DFP(void* p0, struct S_DFP p1, int p2,  void* (*cb)(void*, struct S_DFP, int)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSI_DDI(void* p0, struct S_DDI p1, int p2,  void* (*cb)(void*, struct S_DDI, int)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSI_DDF(void* p0, struct S_DDF p1, int p2,  void* (*cb)(void*, struct S_DDF, int)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSI_DDD(void* p0, struct S_DDD p1, int p2,  void* (*cb)(void*, struct S_DDD, int)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSI_DDP(void* p0, struct S_DDP p1, int p2,  void* (*cb)(void*, struct S_DDP, int)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSI_DPI(void* p0, struct S_DPI p1, int p2,  void* (*cb)(void*, struct S_DPI, int)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSI_DPF(void* p0, struct S_DPF p1, int p2,  void* (*cb)(void*, struct S_DPF, int)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSI_DPD(void* p0, struct S_DPD p1, int p2,  void* (*cb)(void*, struct S_DPD, int)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSI_DPP(void* p0, struct S_DPP p1, int p2,  void* (*cb)(void*, struct S_DPP, int)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSI_PII(void* p0, struct S_PII p1, int p2,  void* (*cb)(void*, struct S_PII, int)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSI_PIF(void* p0, struct S_PIF p1, int p2,  void* (*cb)(void*, struct S_PIF, int)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSI_PID(void* p0, struct S_PID p1, int p2,  void* (*cb)(void*, struct S_PID, int)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSI_PIP(void* p0, struct S_PIP p1, int p2,  void* (*cb)(void*, struct S_PIP, int)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSI_PFI(void* p0, struct S_PFI p1, int p2,  void* (*cb)(void*, struct S_PFI, int)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSI_PFF(void* p0, struct S_PFF p1, int p2,  void* (*cb)(void*, struct S_PFF, int)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSI_PFD(void* p0, struct S_PFD p1, int p2,  void* (*cb)(void*, struct S_PFD, int)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSI_PFP(void* p0, struct S_PFP p1, int p2,  void* (*cb)(void*, struct S_PFP, int)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSI_PDI(void* p0, struct S_PDI p1, int p2,  void* (*cb)(void*, struct S_PDI, int)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSI_PDF(void* p0, struct S_PDF p1, int p2,  void* (*cb)(void*, struct S_PDF, int)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSI_PDD(void* p0, struct S_PDD p1, int p2,  void* (*cb)(void*, struct S_PDD, int)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSI_PDP(void* p0, struct S_PDP p1, int p2,  void* (*cb)(void*, struct S_PDP, int)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSI_PPI(void* p0, struct S_PPI p1, int p2,  void* (*cb)(void*, struct S_PPI, int)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSI_PPF(void* p0, struct S_PPF p1, int p2,  void* (*cb)(void*, struct S_PPF, int)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSI_PPD(void* p0, struct S_PPD p1, int p2,  void* (*cb)(void*, struct S_PPD, int)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSI_PPP(void* p0, struct S_PPP p1, int p2,  void* (*cb)(void*, struct S_PPP, int)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_I(void* p0, struct S_I p1, float p2,  void* (*cb)(void*, struct S_I, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_F(void* p0, struct S_F p1, float p2,  void* (*cb)(void*, struct S_F, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_D(void* p0, struct S_D p1, float p2,  void* (*cb)(void*, struct S_D, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_P(void* p0, struct S_P p1, float p2,  void* (*cb)(void*, struct S_P, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_II(void* p0, struct S_II p1, float p2,  void* (*cb)(void*, struct S_II, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_IF(void* p0, struct S_IF p1, float p2,  void* (*cb)(void*, struct S_IF, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_ID(void* p0, struct S_ID p1, float p2,  void* (*cb)(void*, struct S_ID, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_IP(void* p0, struct S_IP p1, float p2,  void* (*cb)(void*, struct S_IP, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_FI(void* p0, struct S_FI p1, float p2,  void* (*cb)(void*, struct S_FI, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_FF(void* p0, struct S_FF p1, float p2,  void* (*cb)(void*, struct S_FF, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_FD(void* p0, struct S_FD p1, float p2,  void* (*cb)(void*, struct S_FD, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_FP(void* p0, struct S_FP p1, float p2,  void* (*cb)(void*, struct S_FP, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_DI(void* p0, struct S_DI p1, float p2,  void* (*cb)(void*, struct S_DI, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_DF(void* p0, struct S_DF p1, float p2,  void* (*cb)(void*, struct S_DF, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_DD(void* p0, struct S_DD p1, float p2,  void* (*cb)(void*, struct S_DD, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_DP(void* p0, struct S_DP p1, float p2,  void* (*cb)(void*, struct S_DP, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_PI(void* p0, struct S_PI p1, float p2,  void* (*cb)(void*, struct S_PI, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_PF(void* p0, struct S_PF p1, float p2,  void* (*cb)(void*, struct S_PF, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_PD(void* p0, struct S_PD p1, float p2,  void* (*cb)(void*, struct S_PD, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_PP(void* p0, struct S_PP p1, float p2,  void* (*cb)(void*, struct S_PP, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_III(void* p0, struct S_III p1, float p2,  void* (*cb)(void*, struct S_III, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_IIF(void* p0, struct S_IIF p1, float p2,  void* (*cb)(void*, struct S_IIF, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_IID(void* p0, struct S_IID p1, float p2,  void* (*cb)(void*, struct S_IID, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_IIP(void* p0, struct S_IIP p1, float p2,  void* (*cb)(void*, struct S_IIP, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_IFI(void* p0, struct S_IFI p1, float p2,  void* (*cb)(void*, struct S_IFI, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_IFF(void* p0, struct S_IFF p1, float p2,  void* (*cb)(void*, struct S_IFF, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_IFD(void* p0, struct S_IFD p1, float p2,  void* (*cb)(void*, struct S_IFD, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_IFP(void* p0, struct S_IFP p1, float p2,  void* (*cb)(void*, struct S_IFP, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_IDI(void* p0, struct S_IDI p1, float p2,  void* (*cb)(void*, struct S_IDI, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_IDF(void* p0, struct S_IDF p1, float p2,  void* (*cb)(void*, struct S_IDF, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_IDD(void* p0, struct S_IDD p1, float p2,  void* (*cb)(void*, struct S_IDD, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_IDP(void* p0, struct S_IDP p1, float p2,  void* (*cb)(void*, struct S_IDP, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_IPI(void* p0, struct S_IPI p1, float p2,  void* (*cb)(void*, struct S_IPI, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_IPF(void* p0, struct S_IPF p1, float p2,  void* (*cb)(void*, struct S_IPF, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_IPD(void* p0, struct S_IPD p1, float p2,  void* (*cb)(void*, struct S_IPD, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_IPP(void* p0, struct S_IPP p1, float p2,  void* (*cb)(void*, struct S_IPP, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_FII(void* p0, struct S_FII p1, float p2,  void* (*cb)(void*, struct S_FII, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_FIF(void* p0, struct S_FIF p1, float p2,  void* (*cb)(void*, struct S_FIF, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_FID(void* p0, struct S_FID p1, float p2,  void* (*cb)(void*, struct S_FID, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_FIP(void* p0, struct S_FIP p1, float p2,  void* (*cb)(void*, struct S_FIP, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_FFI(void* p0, struct S_FFI p1, float p2,  void* (*cb)(void*, struct S_FFI, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_FFF(void* p0, struct S_FFF p1, float p2,  void* (*cb)(void*, struct S_FFF, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_FFD(void* p0, struct S_FFD p1, float p2,  void* (*cb)(void*, struct S_FFD, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_FFP(void* p0, struct S_FFP p1, float p2,  void* (*cb)(void*, struct S_FFP, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_FDI(void* p0, struct S_FDI p1, float p2,  void* (*cb)(void*, struct S_FDI, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_FDF(void* p0, struct S_FDF p1, float p2,  void* (*cb)(void*, struct S_FDF, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_FDD(void* p0, struct S_FDD p1, float p2,  void* (*cb)(void*, struct S_FDD, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_FDP(void* p0, struct S_FDP p1, float p2,  void* (*cb)(void*, struct S_FDP, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_FPI(void* p0, struct S_FPI p1, float p2,  void* (*cb)(void*, struct S_FPI, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_FPF(void* p0, struct S_FPF p1, float p2,  void* (*cb)(void*, struct S_FPF, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_FPD(void* p0, struct S_FPD p1, float p2,  void* (*cb)(void*, struct S_FPD, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_FPP(void* p0, struct S_FPP p1, float p2,  void* (*cb)(void*, struct S_FPP, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_DII(void* p0, struct S_DII p1, float p2,  void* (*cb)(void*, struct S_DII, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_DIF(void* p0, struct S_DIF p1, float p2,  void* (*cb)(void*, struct S_DIF, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_DID(void* p0, struct S_DID p1, float p2,  void* (*cb)(void*, struct S_DID, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_DIP(void* p0, struct S_DIP p1, float p2,  void* (*cb)(void*, struct S_DIP, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_DFI(void* p0, struct S_DFI p1, float p2,  void* (*cb)(void*, struct S_DFI, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_DFF(void* p0, struct S_DFF p1, float p2,  void* (*cb)(void*, struct S_DFF, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_DFD(void* p0, struct S_DFD p1, float p2,  void* (*cb)(void*, struct S_DFD, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_DFP(void* p0, struct S_DFP p1, float p2,  void* (*cb)(void*, struct S_DFP, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_DDI(void* p0, struct S_DDI p1, float p2,  void* (*cb)(void*, struct S_DDI, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_DDF(void* p0, struct S_DDF p1, float p2,  void* (*cb)(void*, struct S_DDF, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_DDD(void* p0, struct S_DDD p1, float p2,  void* (*cb)(void*, struct S_DDD, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_DDP(void* p0, struct S_DDP p1, float p2,  void* (*cb)(void*, struct S_DDP, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_DPI(void* p0, struct S_DPI p1, float p2,  void* (*cb)(void*, struct S_DPI, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_DPF(void* p0, struct S_DPF p1, float p2,  void* (*cb)(void*, struct S_DPF, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_DPD(void* p0, struct S_DPD p1, float p2,  void* (*cb)(void*, struct S_DPD, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_DPP(void* p0, struct S_DPP p1, float p2,  void* (*cb)(void*, struct S_DPP, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_PII(void* p0, struct S_PII p1, float p2,  void* (*cb)(void*, struct S_PII, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_PIF(void* p0, struct S_PIF p1, float p2,  void* (*cb)(void*, struct S_PIF, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_PID(void* p0, struct S_PID p1, float p2,  void* (*cb)(void*, struct S_PID, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_PIP(void* p0, struct S_PIP p1, float p2,  void* (*cb)(void*, struct S_PIP, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_PFI(void* p0, struct S_PFI p1, float p2,  void* (*cb)(void*, struct S_PFI, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_PFF(void* p0, struct S_PFF p1, float p2,  void* (*cb)(void*, struct S_PFF, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_PFD(void* p0, struct S_PFD p1, float p2,  void* (*cb)(void*, struct S_PFD, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_PFP(void* p0, struct S_PFP p1, float p2,  void* (*cb)(void*, struct S_PFP, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_PDI(void* p0, struct S_PDI p1, float p2,  void* (*cb)(void*, struct S_PDI, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_PDF(void* p0, struct S_PDF p1, float p2,  void* (*cb)(void*, struct S_PDF, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_PDD(void* p0, struct S_PDD p1, float p2,  void* (*cb)(void*, struct S_PDD, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_PDP(void* p0, struct S_PDP p1, float p2,  void* (*cb)(void*, struct S_PDP, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_PPI(void* p0, struct S_PPI p1, float p2,  void* (*cb)(void*, struct S_PPI, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_PPF(void* p0, struct S_PPF p1, float p2,  void* (*cb)(void*, struct S_PPF, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_PPD(void* p0, struct S_PPD p1, float p2,  void* (*cb)(void*, struct S_PPD, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSF_PPP(void* p0, struct S_PPP p1, float p2,  void* (*cb)(void*, struct S_PPP, float)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_I(void* p0, struct S_I p1, double p2,  void* (*cb)(void*, struct S_I, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_F(void* p0, struct S_F p1, double p2,  void* (*cb)(void*, struct S_F, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_D(void* p0, struct S_D p1, double p2,  void* (*cb)(void*, struct S_D, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_P(void* p0, struct S_P p1, double p2,  void* (*cb)(void*, struct S_P, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_II(void* p0, struct S_II p1, double p2,  void* (*cb)(void*, struct S_II, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_IF(void* p0, struct S_IF p1, double p2,  void* (*cb)(void*, struct S_IF, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_ID(void* p0, struct S_ID p1, double p2,  void* (*cb)(void*, struct S_ID, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_IP(void* p0, struct S_IP p1, double p2,  void* (*cb)(void*, struct S_IP, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_FI(void* p0, struct S_FI p1, double p2,  void* (*cb)(void*, struct S_FI, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_FF(void* p0, struct S_FF p1, double p2,  void* (*cb)(void*, struct S_FF, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_FD(void* p0, struct S_FD p1, double p2,  void* (*cb)(void*, struct S_FD, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_FP(void* p0, struct S_FP p1, double p2,  void* (*cb)(void*, struct S_FP, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_DI(void* p0, struct S_DI p1, double p2,  void* (*cb)(void*, struct S_DI, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_DF(void* p0, struct S_DF p1, double p2,  void* (*cb)(void*, struct S_DF, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_DD(void* p0, struct S_DD p1, double p2,  void* (*cb)(void*, struct S_DD, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_DP(void* p0, struct S_DP p1, double p2,  void* (*cb)(void*, struct S_DP, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_PI(void* p0, struct S_PI p1, double p2,  void* (*cb)(void*, struct S_PI, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_PF(void* p0, struct S_PF p1, double p2,  void* (*cb)(void*, struct S_PF, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_PD(void* p0, struct S_PD p1, double p2,  void* (*cb)(void*, struct S_PD, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_PP(void* p0, struct S_PP p1, double p2,  void* (*cb)(void*, struct S_PP, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_III(void* p0, struct S_III p1, double p2,  void* (*cb)(void*, struct S_III, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_IIF(void* p0, struct S_IIF p1, double p2,  void* (*cb)(void*, struct S_IIF, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_IID(void* p0, struct S_IID p1, double p2,  void* (*cb)(void*, struct S_IID, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_IIP(void* p0, struct S_IIP p1, double p2,  void* (*cb)(void*, struct S_IIP, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_IFI(void* p0, struct S_IFI p1, double p2,  void* (*cb)(void*, struct S_IFI, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_IFF(void* p0, struct S_IFF p1, double p2,  void* (*cb)(void*, struct S_IFF, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_IFD(void* p0, struct S_IFD p1, double p2,  void* (*cb)(void*, struct S_IFD, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_IFP(void* p0, struct S_IFP p1, double p2,  void* (*cb)(void*, struct S_IFP, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_IDI(void* p0, struct S_IDI p1, double p2,  void* (*cb)(void*, struct S_IDI, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_IDF(void* p0, struct S_IDF p1, double p2,  void* (*cb)(void*, struct S_IDF, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_IDD(void* p0, struct S_IDD p1, double p2,  void* (*cb)(void*, struct S_IDD, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_IDP(void* p0, struct S_IDP p1, double p2,  void* (*cb)(void*, struct S_IDP, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_IPI(void* p0, struct S_IPI p1, double p2,  void* (*cb)(void*, struct S_IPI, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_IPF(void* p0, struct S_IPF p1, double p2,  void* (*cb)(void*, struct S_IPF, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_IPD(void* p0, struct S_IPD p1, double p2,  void* (*cb)(void*, struct S_IPD, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_IPP(void* p0, struct S_IPP p1, double p2,  void* (*cb)(void*, struct S_IPP, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_FII(void* p0, struct S_FII p1, double p2,  void* (*cb)(void*, struct S_FII, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_FIF(void* p0, struct S_FIF p1, double p2,  void* (*cb)(void*, struct S_FIF, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_FID(void* p0, struct S_FID p1, double p2,  void* (*cb)(void*, struct S_FID, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_FIP(void* p0, struct S_FIP p1, double p2,  void* (*cb)(void*, struct S_FIP, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_FFI(void* p0, struct S_FFI p1, double p2,  void* (*cb)(void*, struct S_FFI, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_FFF(void* p0, struct S_FFF p1, double p2,  void* (*cb)(void*, struct S_FFF, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_FFD(void* p0, struct S_FFD p1, double p2,  void* (*cb)(void*, struct S_FFD, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_FFP(void* p0, struct S_FFP p1, double p2,  void* (*cb)(void*, struct S_FFP, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_FDI(void* p0, struct S_FDI p1, double p2,  void* (*cb)(void*, struct S_FDI, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_FDF(void* p0, struct S_FDF p1, double p2,  void* (*cb)(void*, struct S_FDF, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_FDD(void* p0, struct S_FDD p1, double p2,  void* (*cb)(void*, struct S_FDD, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_FDP(void* p0, struct S_FDP p1, double p2,  void* (*cb)(void*, struct S_FDP, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_FPI(void* p0, struct S_FPI p1, double p2,  void* (*cb)(void*, struct S_FPI, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_FPF(void* p0, struct S_FPF p1, double p2,  void* (*cb)(void*, struct S_FPF, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_FPD(void* p0, struct S_FPD p1, double p2,  void* (*cb)(void*, struct S_FPD, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_FPP(void* p0, struct S_FPP p1, double p2,  void* (*cb)(void*, struct S_FPP, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_DII(void* p0, struct S_DII p1, double p2,  void* (*cb)(void*, struct S_DII, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_DIF(void* p0, struct S_DIF p1, double p2,  void* (*cb)(void*, struct S_DIF, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_DID(void* p0, struct S_DID p1, double p2,  void* (*cb)(void*, struct S_DID, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_DIP(void* p0, struct S_DIP p1, double p2,  void* (*cb)(void*, struct S_DIP, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_DFI(void* p0, struct S_DFI p1, double p2,  void* (*cb)(void*, struct S_DFI, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_DFF(void* p0, struct S_DFF p1, double p2,  void* (*cb)(void*, struct S_DFF, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_DFD(void* p0, struct S_DFD p1, double p2,  void* (*cb)(void*, struct S_DFD, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_DFP(void* p0, struct S_DFP p1, double p2,  void* (*cb)(void*, struct S_DFP, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_DDI(void* p0, struct S_DDI p1, double p2,  void* (*cb)(void*, struct S_DDI, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_DDF(void* p0, struct S_DDF p1, double p2,  void* (*cb)(void*, struct S_DDF, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_DDD(void* p0, struct S_DDD p1, double p2,  void* (*cb)(void*, struct S_DDD, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_DDP(void* p0, struct S_DDP p1, double p2,  void* (*cb)(void*, struct S_DDP, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_DPI(void* p0, struct S_DPI p1, double p2,  void* (*cb)(void*, struct S_DPI, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_DPF(void* p0, struct S_DPF p1, double p2,  void* (*cb)(void*, struct S_DPF, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_DPD(void* p0, struct S_DPD p1, double p2,  void* (*cb)(void*, struct S_DPD, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_DPP(void* p0, struct S_DPP p1, double p2,  void* (*cb)(void*, struct S_DPP, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_PII(void* p0, struct S_PII p1, double p2,  void* (*cb)(void*, struct S_PII, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_PIF(void* p0, struct S_PIF p1, double p2,  void* (*cb)(void*, struct S_PIF, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_PID(void* p0, struct S_PID p1, double p2,  void* (*cb)(void*, struct S_PID, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_PIP(void* p0, struct S_PIP p1, double p2,  void* (*cb)(void*, struct S_PIP, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_PFI(void* p0, struct S_PFI p1, double p2,  void* (*cb)(void*, struct S_PFI, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_PFF(void* p0, struct S_PFF p1, double p2,  void* (*cb)(void*, struct S_PFF, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_PFD(void* p0, struct S_PFD p1, double p2,  void* (*cb)(void*, struct S_PFD, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_PFP(void* p0, struct S_PFP p1, double p2,  void* (*cb)(void*, struct S_PFP, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_PDI(void* p0, struct S_PDI p1, double p2,  void* (*cb)(void*, struct S_PDI, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_PDF(void* p0, struct S_PDF p1, double p2,  void* (*cb)(void*, struct S_PDF, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_PDD(void* p0, struct S_PDD p1, double p2,  void* (*cb)(void*, struct S_PDD, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_PDP(void* p0, struct S_PDP p1, double p2,  void* (*cb)(void*, struct S_PDP, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_PPI(void* p0, struct S_PPI p1, double p2,  void* (*cb)(void*, struct S_PPI, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_PPF(void* p0, struct S_PPF p1, double p2,  void* (*cb)(void*, struct S_PPF, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_PPD(void* p0, struct S_PPD p1, double p2,  void* (*cb)(void*, struct S_PPD, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSD_PPP(void* p0, struct S_PPP p1, double p2,  void* (*cb)(void*, struct S_PPP, double)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_I(void* p0, struct S_I p1, void* p2,  void* (*cb)(void*, struct S_I, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_F(void* p0, struct S_F p1, void* p2,  void* (*cb)(void*, struct S_F, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_D(void* p0, struct S_D p1, void* p2,  void* (*cb)(void*, struct S_D, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_P(void* p0, struct S_P p1, void* p2,  void* (*cb)(void*, struct S_P, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_II(void* p0, struct S_II p1, void* p2,  void* (*cb)(void*, struct S_II, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_IF(void* p0, struct S_IF p1, void* p2,  void* (*cb)(void*, struct S_IF, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_ID(void* p0, struct S_ID p1, void* p2,  void* (*cb)(void*, struct S_ID, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_IP(void* p0, struct S_IP p1, void* p2,  void* (*cb)(void*, struct S_IP, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_FI(void* p0, struct S_FI p1, void* p2,  void* (*cb)(void*, struct S_FI, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_FF(void* p0, struct S_FF p1, void* p2,  void* (*cb)(void*, struct S_FF, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_FD(void* p0, struct S_FD p1, void* p2,  void* (*cb)(void*, struct S_FD, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_FP(void* p0, struct S_FP p1, void* p2,  void* (*cb)(void*, struct S_FP, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_DI(void* p0, struct S_DI p1, void* p2,  void* (*cb)(void*, struct S_DI, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_DF(void* p0, struct S_DF p1, void* p2,  void* (*cb)(void*, struct S_DF, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_DD(void* p0, struct S_DD p1, void* p2,  void* (*cb)(void*, struct S_DD, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_DP(void* p0, struct S_DP p1, void* p2,  void* (*cb)(void*, struct S_DP, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_PI(void* p0, struct S_PI p1, void* p2,  void* (*cb)(void*, struct S_PI, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_PF(void* p0, struct S_PF p1, void* p2,  void* (*cb)(void*, struct S_PF, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_PD(void* p0, struct S_PD p1, void* p2,  void* (*cb)(void*, struct S_PD, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_PP(void* p0, struct S_PP p1, void* p2,  void* (*cb)(void*, struct S_PP, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_III(void* p0, struct S_III p1, void* p2,  void* (*cb)(void*, struct S_III, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_IIF(void* p0, struct S_IIF p1, void* p2,  void* (*cb)(void*, struct S_IIF, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_IID(void* p0, struct S_IID p1, void* p2,  void* (*cb)(void*, struct S_IID, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_IIP(void* p0, struct S_IIP p1, void* p2,  void* (*cb)(void*, struct S_IIP, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_IFI(void* p0, struct S_IFI p1, void* p2,  void* (*cb)(void*, struct S_IFI, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_IFF(void* p0, struct S_IFF p1, void* p2,  void* (*cb)(void*, struct S_IFF, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_IFD(void* p0, struct S_IFD p1, void* p2,  void* (*cb)(void*, struct S_IFD, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_IFP(void* p0, struct S_IFP p1, void* p2,  void* (*cb)(void*, struct S_IFP, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_IDI(void* p0, struct S_IDI p1, void* p2,  void* (*cb)(void*, struct S_IDI, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_IDF(void* p0, struct S_IDF p1, void* p2,  void* (*cb)(void*, struct S_IDF, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_IDD(void* p0, struct S_IDD p1, void* p2,  void* (*cb)(void*, struct S_IDD, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_IDP(void* p0, struct S_IDP p1, void* p2,  void* (*cb)(void*, struct S_IDP, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_IPI(void* p0, struct S_IPI p1, void* p2,  void* (*cb)(void*, struct S_IPI, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_IPF(void* p0, struct S_IPF p1, void* p2,  void* (*cb)(void*, struct S_IPF, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_IPD(void* p0, struct S_IPD p1, void* p2,  void* (*cb)(void*, struct S_IPD, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_IPP(void* p0, struct S_IPP p1, void* p2,  void* (*cb)(void*, struct S_IPP, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_FII(void* p0, struct S_FII p1, void* p2,  void* (*cb)(void*, struct S_FII, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_FIF(void* p0, struct S_FIF p1, void* p2,  void* (*cb)(void*, struct S_FIF, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_FID(void* p0, struct S_FID p1, void* p2,  void* (*cb)(void*, struct S_FID, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_FIP(void* p0, struct S_FIP p1, void* p2,  void* (*cb)(void*, struct S_FIP, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_FFI(void* p0, struct S_FFI p1, void* p2,  void* (*cb)(void*, struct S_FFI, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_FFF(void* p0, struct S_FFF p1, void* p2,  void* (*cb)(void*, struct S_FFF, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_FFD(void* p0, struct S_FFD p1, void* p2,  void* (*cb)(void*, struct S_FFD, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_FFP(void* p0, struct S_FFP p1, void* p2,  void* (*cb)(void*, struct S_FFP, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_FDI(void* p0, struct S_FDI p1, void* p2,  void* (*cb)(void*, struct S_FDI, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_FDF(void* p0, struct S_FDF p1, void* p2,  void* (*cb)(void*, struct S_FDF, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_FDD(void* p0, struct S_FDD p1, void* p2,  void* (*cb)(void*, struct S_FDD, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_FDP(void* p0, struct S_FDP p1, void* p2,  void* (*cb)(void*, struct S_FDP, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_FPI(void* p0, struct S_FPI p1, void* p2,  void* (*cb)(void*, struct S_FPI, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_FPF(void* p0, struct S_FPF p1, void* p2,  void* (*cb)(void*, struct S_FPF, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_FPD(void* p0, struct S_FPD p1, void* p2,  void* (*cb)(void*, struct S_FPD, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_FPP(void* p0, struct S_FPP p1, void* p2,  void* (*cb)(void*, struct S_FPP, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_DII(void* p0, struct S_DII p1, void* p2,  void* (*cb)(void*, struct S_DII, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_DIF(void* p0, struct S_DIF p1, void* p2,  void* (*cb)(void*, struct S_DIF, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_DID(void* p0, struct S_DID p1, void* p2,  void* (*cb)(void*, struct S_DID, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_DIP(void* p0, struct S_DIP p1, void* p2,  void* (*cb)(void*, struct S_DIP, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_DFI(void* p0, struct S_DFI p1, void* p2,  void* (*cb)(void*, struct S_DFI, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_DFF(void* p0, struct S_DFF p1, void* p2,  void* (*cb)(void*, struct S_DFF, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_DFD(void* p0, struct S_DFD p1, void* p2,  void* (*cb)(void*, struct S_DFD, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_DFP(void* p0, struct S_DFP p1, void* p2,  void* (*cb)(void*, struct S_DFP, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_DDI(void* p0, struct S_DDI p1, void* p2,  void* (*cb)(void*, struct S_DDI, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_DDF(void* p0, struct S_DDF p1, void* p2,  void* (*cb)(void*, struct S_DDF, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_DDD(void* p0, struct S_DDD p1, void* p2,  void* (*cb)(void*, struct S_DDD, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_DDP(void* p0, struct S_DDP p1, void* p2,  void* (*cb)(void*, struct S_DDP, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_DPI(void* p0, struct S_DPI p1, void* p2,  void* (*cb)(void*, struct S_DPI, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_DPF(void* p0, struct S_DPF p1, void* p2,  void* (*cb)(void*, struct S_DPF, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_DPD(void* p0, struct S_DPD p1, void* p2,  void* (*cb)(void*, struct S_DPD, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_DPP(void* p0, struct S_DPP p1, void* p2,  void* (*cb)(void*, struct S_DPP, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_PII(void* p0, struct S_PII p1, void* p2,  void* (*cb)(void*, struct S_PII, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_PIF(void* p0, struct S_PIF p1, void* p2,  void* (*cb)(void*, struct S_PIF, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_PID(void* p0, struct S_PID p1, void* p2,  void* (*cb)(void*, struct S_PID, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_PIP(void* p0, struct S_PIP p1, void* p2,  void* (*cb)(void*, struct S_PIP, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_PFI(void* p0, struct S_PFI p1, void* p2,  void* (*cb)(void*, struct S_PFI, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_PFF(void* p0, struct S_PFF p1, void* p2,  void* (*cb)(void*, struct S_PFF, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_PFD(void* p0, struct S_PFD p1, void* p2,  void* (*cb)(void*, struct S_PFD, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_PFP(void* p0, struct S_PFP p1, void* p2,  void* (*cb)(void*, struct S_PFP, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_PDI(void* p0, struct S_PDI p1, void* p2,  void* (*cb)(void*, struct S_PDI, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_PDF(void* p0, struct S_PDF p1, void* p2,  void* (*cb)(void*, struct S_PDF, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_PDD(void* p0, struct S_PDD p1, void* p2,  void* (*cb)(void*, struct S_PDD, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_PDP(void* p0, struct S_PDP p1, void* p2,  void* (*cb)(void*, struct S_PDP, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_PPI(void* p0, struct S_PPI p1, void* p2,  void* (*cb)(void*, struct S_PPI, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_PPF(void* p0, struct S_PPF p1, void* p2,  void* (*cb)(void*, struct S_PPF, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_PPD(void* p0, struct S_PPD p1, void* p2,  void* (*cb)(void*, struct S_PPD, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSP_PPP(void* p0, struct S_PPP p1, void* p2,  void* (*cb)(void*, struct S_PPP, void*)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_I(void* p0, struct S_I p1, struct S_I p2,  void* (*cb)(void*, struct S_I, struct S_I)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_F(void* p0, struct S_F p1, struct S_F p2,  void* (*cb)(void*, struct S_F, struct S_F)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_D(void* p0, struct S_D p1, struct S_D p2,  void* (*cb)(void*, struct S_D, struct S_D)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_P(void* p0, struct S_P p1, struct S_P p2,  void* (*cb)(void*, struct S_P, struct S_P)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_II(void* p0, struct S_II p1, struct S_II p2,  void* (*cb)(void*, struct S_II, struct S_II)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_IF(void* p0, struct S_IF p1, struct S_IF p2,  void* (*cb)(void*, struct S_IF, struct S_IF)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_ID(void* p0, struct S_ID p1, struct S_ID p2,  void* (*cb)(void*, struct S_ID, struct S_ID)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_IP(void* p0, struct S_IP p1, struct S_IP p2,  void* (*cb)(void*, struct S_IP, struct S_IP)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_FI(void* p0, struct S_FI p1, struct S_FI p2,  void* (*cb)(void*, struct S_FI, struct S_FI)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_FF(void* p0, struct S_FF p1, struct S_FF p2,  void* (*cb)(void*, struct S_FF, struct S_FF)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_FD(void* p0, struct S_FD p1, struct S_FD p2,  void* (*cb)(void*, struct S_FD, struct S_FD)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_FP(void* p0, struct S_FP p1, struct S_FP p2,  void* (*cb)(void*, struct S_FP, struct S_FP)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_DI(void* p0, struct S_DI p1, struct S_DI p2,  void* (*cb)(void*, struct S_DI, struct S_DI)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_DF(void* p0, struct S_DF p1, struct S_DF p2,  void* (*cb)(void*, struct S_DF, struct S_DF)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_DD(void* p0, struct S_DD p1, struct S_DD p2,  void* (*cb)(void*, struct S_DD, struct S_DD)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_DP(void* p0, struct S_DP p1, struct S_DP p2,  void* (*cb)(void*, struct S_DP, struct S_DP)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_PI(void* p0, struct S_PI p1, struct S_PI p2,  void* (*cb)(void*, struct S_PI, struct S_PI)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_PF(void* p0, struct S_PF p1, struct S_PF p2,  void* (*cb)(void*, struct S_PF, struct S_PF)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_PD(void* p0, struct S_PD p1, struct S_PD p2,  void* (*cb)(void*, struct S_PD, struct S_PD)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_PP(void* p0, struct S_PP p1, struct S_PP p2,  void* (*cb)(void*, struct S_PP, struct S_PP)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_III(void* p0, struct S_III p1, struct S_III p2,  void* (*cb)(void*, struct S_III, struct S_III)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_IIF(void* p0, struct S_IIF p1, struct S_IIF p2,  void* (*cb)(void*, struct S_IIF, struct S_IIF)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_IID(void* p0, struct S_IID p1, struct S_IID p2,  void* (*cb)(void*, struct S_IID, struct S_IID)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_IIP(void* p0, struct S_IIP p1, struct S_IIP p2,  void* (*cb)(void*, struct S_IIP, struct S_IIP)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_IFI(void* p0, struct S_IFI p1, struct S_IFI p2,  void* (*cb)(void*, struct S_IFI, struct S_IFI)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_IFF(void* p0, struct S_IFF p1, struct S_IFF p2,  void* (*cb)(void*, struct S_IFF, struct S_IFF)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_IFD(void* p0, struct S_IFD p1, struct S_IFD p2,  void* (*cb)(void*, struct S_IFD, struct S_IFD)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_IFP(void* p0, struct S_IFP p1, struct S_IFP p2,  void* (*cb)(void*, struct S_IFP, struct S_IFP)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_IDI(void* p0, struct S_IDI p1, struct S_IDI p2,  void* (*cb)(void*, struct S_IDI, struct S_IDI)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_IDF(void* p0, struct S_IDF p1, struct S_IDF p2,  void* (*cb)(void*, struct S_IDF, struct S_IDF)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_IDD(void* p0, struct S_IDD p1, struct S_IDD p2,  void* (*cb)(void*, struct S_IDD, struct S_IDD)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_IDP(void* p0, struct S_IDP p1, struct S_IDP p2,  void* (*cb)(void*, struct S_IDP, struct S_IDP)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_IPI(void* p0, struct S_IPI p1, struct S_IPI p2,  void* (*cb)(void*, struct S_IPI, struct S_IPI)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_IPF(void* p0, struct S_IPF p1, struct S_IPF p2,  void* (*cb)(void*, struct S_IPF, struct S_IPF)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_IPD(void* p0, struct S_IPD p1, struct S_IPD p2,  void* (*cb)(void*, struct S_IPD, struct S_IPD)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_IPP(void* p0, struct S_IPP p1, struct S_IPP p2,  void* (*cb)(void*, struct S_IPP, struct S_IPP)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_FII(void* p0, struct S_FII p1, struct S_FII p2,  void* (*cb)(void*, struct S_FII, struct S_FII)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_FIF(void* p0, struct S_FIF p1, struct S_FIF p2,  void* (*cb)(void*, struct S_FIF, struct S_FIF)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_FID(void* p0, struct S_FID p1, struct S_FID p2,  void* (*cb)(void*, struct S_FID, struct S_FID)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_FIP(void* p0, struct S_FIP p1, struct S_FIP p2,  void* (*cb)(void*, struct S_FIP, struct S_FIP)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_FFI(void* p0, struct S_FFI p1, struct S_FFI p2,  void* (*cb)(void*, struct S_FFI, struct S_FFI)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_FFF(void* p0, struct S_FFF p1, struct S_FFF p2,  void* (*cb)(void*, struct S_FFF, struct S_FFF)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_FFD(void* p0, struct S_FFD p1, struct S_FFD p2,  void* (*cb)(void*, struct S_FFD, struct S_FFD)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_FFP(void* p0, struct S_FFP p1, struct S_FFP p2,  void* (*cb)(void*, struct S_FFP, struct S_FFP)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_FDI(void* p0, struct S_FDI p1, struct S_FDI p2,  void* (*cb)(void*, struct S_FDI, struct S_FDI)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_FDF(void* p0, struct S_FDF p1, struct S_FDF p2,  void* (*cb)(void*, struct S_FDF, struct S_FDF)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_FDD(void* p0, struct S_FDD p1, struct S_FDD p2,  void* (*cb)(void*, struct S_FDD, struct S_FDD)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_FDP(void* p0, struct S_FDP p1, struct S_FDP p2,  void* (*cb)(void*, struct S_FDP, struct S_FDP)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_FPI(void* p0, struct S_FPI p1, struct S_FPI p2,  void* (*cb)(void*, struct S_FPI, struct S_FPI)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_FPF(void* p0, struct S_FPF p1, struct S_FPF p2,  void* (*cb)(void*, struct S_FPF, struct S_FPF)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_FPD(void* p0, struct S_FPD p1, struct S_FPD p2,  void* (*cb)(void*, struct S_FPD, struct S_FPD)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_FPP(void* p0, struct S_FPP p1, struct S_FPP p2,  void* (*cb)(void*, struct S_FPP, struct S_FPP)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_DII(void* p0, struct S_DII p1, struct S_DII p2,  void* (*cb)(void*, struct S_DII, struct S_DII)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_DIF(void* p0, struct S_DIF p1, struct S_DIF p2,  void* (*cb)(void*, struct S_DIF, struct S_DIF)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_DID(void* p0, struct S_DID p1, struct S_DID p2,  void* (*cb)(void*, struct S_DID, struct S_DID)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_DIP(void* p0, struct S_DIP p1, struct S_DIP p2,  void* (*cb)(void*, struct S_DIP, struct S_DIP)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_DFI(void* p0, struct S_DFI p1, struct S_DFI p2,  void* (*cb)(void*, struct S_DFI, struct S_DFI)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_DFF(void* p0, struct S_DFF p1, struct S_DFF p2,  void* (*cb)(void*, struct S_DFF, struct S_DFF)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_DFD(void* p0, struct S_DFD p1, struct S_DFD p2,  void* (*cb)(void*, struct S_DFD, struct S_DFD)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_DFP(void* p0, struct S_DFP p1, struct S_DFP p2,  void* (*cb)(void*, struct S_DFP, struct S_DFP)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_DDI(void* p0, struct S_DDI p1, struct S_DDI p2,  void* (*cb)(void*, struct S_DDI, struct S_DDI)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_DDF(void* p0, struct S_DDF p1, struct S_DDF p2,  void* (*cb)(void*, struct S_DDF, struct S_DDF)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_DDD(void* p0, struct S_DDD p1, struct S_DDD p2,  void* (*cb)(void*, struct S_DDD, struct S_DDD)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_DDP(void* p0, struct S_DDP p1, struct S_DDP p2,  void* (*cb)(void*, struct S_DDP, struct S_DDP)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_DPI(void* p0, struct S_DPI p1, struct S_DPI p2,  void* (*cb)(void*, struct S_DPI, struct S_DPI)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_DPF(void* p0, struct S_DPF p1, struct S_DPF p2,  void* (*cb)(void*, struct S_DPF, struct S_DPF)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_DPD(void* p0, struct S_DPD p1, struct S_DPD p2,  void* (*cb)(void*, struct S_DPD, struct S_DPD)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_DPP(void* p0, struct S_DPP p1, struct S_DPP p2,  void* (*cb)(void*, struct S_DPP, struct S_DPP)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_PII(void* p0, struct S_PII p1, struct S_PII p2,  void* (*cb)(void*, struct S_PII, struct S_PII)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_PIF(void* p0, struct S_PIF p1, struct S_PIF p2,  void* (*cb)(void*, struct S_PIF, struct S_PIF)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_PID(void* p0, struct S_PID p1, struct S_PID p2,  void* (*cb)(void*, struct S_PID, struct S_PID)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_PIP(void* p0, struct S_PIP p1, struct S_PIP p2,  void* (*cb)(void*, struct S_PIP, struct S_PIP)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_PFI(void* p0, struct S_PFI p1, struct S_PFI p2,  void* (*cb)(void*, struct S_PFI, struct S_PFI)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_PFF(void* p0, struct S_PFF p1, struct S_PFF p2,  void* (*cb)(void*, struct S_PFF, struct S_PFF)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_PFD(void* p0, struct S_PFD p1, struct S_PFD p2,  void* (*cb)(void*, struct S_PFD, struct S_PFD)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_PFP(void* p0, struct S_PFP p1, struct S_PFP p2,  void* (*cb)(void*, struct S_PFP, struct S_PFP)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_PDI(void* p0, struct S_PDI p1, struct S_PDI p2,  void* (*cb)(void*, struct S_PDI, struct S_PDI)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_PDF(void* p0, struct S_PDF p1, struct S_PDF p2,  void* (*cb)(void*, struct S_PDF, struct S_PDF)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_PDD(void* p0, struct S_PDD p1, struct S_PDD p2,  void* (*cb)(void*, struct S_PDD, struct S_PDD)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_PDP(void* p0, struct S_PDP p1, struct S_PDP p2,  void* (*cb)(void*, struct S_PDP, struct S_PDP)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_PPI(void* p0, struct S_PPI p1, struct S_PPI p2,  void* (*cb)(void*, struct S_PPI, struct S_PPI)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_PPF(void* p0, struct S_PPF p1, struct S_PPF p2,  void* (*cb)(void*, struct S_PPF, struct S_PPF)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_PPD(void* p0, struct S_PPD p1, struct S_PPD p2,  void* (*cb)(void*, struct S_PPD, struct S_PPD)) { return cb(p0,p1,p2); }
+EXPORT void* f16_P_PSS_PPP(void* p0, struct S_PPP p1, struct S_PPP p2,  void* (*cb)(void*, struct S_PPP, struct S_PPP)) { return cb(p0,p1,p2); }
+EXPORT struct S_I f16_S_SII_I(struct S_I p0, int p1, int p2,  struct S_I (*cb)(struct S_I, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_F f16_S_SII_F(struct S_F p0, int p1, int p2,  struct S_F (*cb)(struct S_F, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_D f16_S_SII_D(struct S_D p0, int p1, int p2,  struct S_D (*cb)(struct S_D, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_P f16_S_SII_P(struct S_P p0, int p1, int p2,  struct S_P (*cb)(struct S_P, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_II f16_S_SII_II(struct S_II p0, int p1, int p2,  struct S_II (*cb)(struct S_II, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IF f16_S_SII_IF(struct S_IF p0, int p1, int p2,  struct S_IF (*cb)(struct S_IF, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_ID f16_S_SII_ID(struct S_ID p0, int p1, int p2,  struct S_ID (*cb)(struct S_ID, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IP f16_S_SII_IP(struct S_IP p0, int p1, int p2,  struct S_IP (*cb)(struct S_IP, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FI f16_S_SII_FI(struct S_FI p0, int p1, int p2,  struct S_FI (*cb)(struct S_FI, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FF f16_S_SII_FF(struct S_FF p0, int p1, int p2,  struct S_FF (*cb)(struct S_FF, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FD f16_S_SII_FD(struct S_FD p0, int p1, int p2,  struct S_FD (*cb)(struct S_FD, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FP f16_S_SII_FP(struct S_FP p0, int p1, int p2,  struct S_FP (*cb)(struct S_FP, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DI f16_S_SII_DI(struct S_DI p0, int p1, int p2,  struct S_DI (*cb)(struct S_DI, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DF f16_S_SII_DF(struct S_DF p0, int p1, int p2,  struct S_DF (*cb)(struct S_DF, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DD f16_S_SII_DD(struct S_DD p0, int p1, int p2,  struct S_DD (*cb)(struct S_DD, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DP f16_S_SII_DP(struct S_DP p0, int p1, int p2,  struct S_DP (*cb)(struct S_DP, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PI f16_S_SII_PI(struct S_PI p0, int p1, int p2,  struct S_PI (*cb)(struct S_PI, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PF f16_S_SII_PF(struct S_PF p0, int p1, int p2,  struct S_PF (*cb)(struct S_PF, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PD f16_S_SII_PD(struct S_PD p0, int p1, int p2,  struct S_PD (*cb)(struct S_PD, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PP f16_S_SII_PP(struct S_PP p0, int p1, int p2,  struct S_PP (*cb)(struct S_PP, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_III f16_S_SII_III(struct S_III p0, int p1, int p2,  struct S_III (*cb)(struct S_III, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IIF f16_S_SII_IIF(struct S_IIF p0, int p1, int p2,  struct S_IIF (*cb)(struct S_IIF, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IID f16_S_SII_IID(struct S_IID p0, int p1, int p2,  struct S_IID (*cb)(struct S_IID, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IIP f16_S_SII_IIP(struct S_IIP p0, int p1, int p2,  struct S_IIP (*cb)(struct S_IIP, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFI f16_S_SII_IFI(struct S_IFI p0, int p1, int p2,  struct S_IFI (*cb)(struct S_IFI, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFF f16_S_SII_IFF(struct S_IFF p0, int p1, int p2,  struct S_IFF (*cb)(struct S_IFF, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFD f16_S_SII_IFD(struct S_IFD p0, int p1, int p2,  struct S_IFD (*cb)(struct S_IFD, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFP f16_S_SII_IFP(struct S_IFP p0, int p1, int p2,  struct S_IFP (*cb)(struct S_IFP, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDI f16_S_SII_IDI(struct S_IDI p0, int p1, int p2,  struct S_IDI (*cb)(struct S_IDI, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDF f16_S_SII_IDF(struct S_IDF p0, int p1, int p2,  struct S_IDF (*cb)(struct S_IDF, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDD f16_S_SII_IDD(struct S_IDD p0, int p1, int p2,  struct S_IDD (*cb)(struct S_IDD, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDP f16_S_SII_IDP(struct S_IDP p0, int p1, int p2,  struct S_IDP (*cb)(struct S_IDP, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPI f16_S_SII_IPI(struct S_IPI p0, int p1, int p2,  struct S_IPI (*cb)(struct S_IPI, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPF f16_S_SII_IPF(struct S_IPF p0, int p1, int p2,  struct S_IPF (*cb)(struct S_IPF, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPD f16_S_SII_IPD(struct S_IPD p0, int p1, int p2,  struct S_IPD (*cb)(struct S_IPD, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPP f16_S_SII_IPP(struct S_IPP p0, int p1, int p2,  struct S_IPP (*cb)(struct S_IPP, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FII f16_S_SII_FII(struct S_FII p0, int p1, int p2,  struct S_FII (*cb)(struct S_FII, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FIF f16_S_SII_FIF(struct S_FIF p0, int p1, int p2,  struct S_FIF (*cb)(struct S_FIF, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FID f16_S_SII_FID(struct S_FID p0, int p1, int p2,  struct S_FID (*cb)(struct S_FID, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FIP f16_S_SII_FIP(struct S_FIP p0, int p1, int p2,  struct S_FIP (*cb)(struct S_FIP, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFI f16_S_SII_FFI(struct S_FFI p0, int p1, int p2,  struct S_FFI (*cb)(struct S_FFI, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFF f16_S_SII_FFF(struct S_FFF p0, int p1, int p2,  struct S_FFF (*cb)(struct S_FFF, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFD f16_S_SII_FFD(struct S_FFD p0, int p1, int p2,  struct S_FFD (*cb)(struct S_FFD, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFP f16_S_SII_FFP(struct S_FFP p0, int p1, int p2,  struct S_FFP (*cb)(struct S_FFP, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDI f16_S_SII_FDI(struct S_FDI p0, int p1, int p2,  struct S_FDI (*cb)(struct S_FDI, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDF f16_S_SII_FDF(struct S_FDF p0, int p1, int p2,  struct S_FDF (*cb)(struct S_FDF, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDD f16_S_SII_FDD(struct S_FDD p0, int p1, int p2,  struct S_FDD (*cb)(struct S_FDD, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDP f16_S_SII_FDP(struct S_FDP p0, int p1, int p2,  struct S_FDP (*cb)(struct S_FDP, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPI f16_S_SII_FPI(struct S_FPI p0, int p1, int p2,  struct S_FPI (*cb)(struct S_FPI, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPF f16_S_SII_FPF(struct S_FPF p0, int p1, int p2,  struct S_FPF (*cb)(struct S_FPF, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPD f16_S_SII_FPD(struct S_FPD p0, int p1, int p2,  struct S_FPD (*cb)(struct S_FPD, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPP f16_S_SII_FPP(struct S_FPP p0, int p1, int p2,  struct S_FPP (*cb)(struct S_FPP, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DII f16_S_SII_DII(struct S_DII p0, int p1, int p2,  struct S_DII (*cb)(struct S_DII, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DIF f16_S_SII_DIF(struct S_DIF p0, int p1, int p2,  struct S_DIF (*cb)(struct S_DIF, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DID f16_S_SII_DID(struct S_DID p0, int p1, int p2,  struct S_DID (*cb)(struct S_DID, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DIP f16_S_SII_DIP(struct S_DIP p0, int p1, int p2,  struct S_DIP (*cb)(struct S_DIP, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFI f16_S_SII_DFI(struct S_DFI p0, int p1, int p2,  struct S_DFI (*cb)(struct S_DFI, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFF f16_S_SII_DFF(struct S_DFF p0, int p1, int p2,  struct S_DFF (*cb)(struct S_DFF, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFD f16_S_SII_DFD(struct S_DFD p0, int p1, int p2,  struct S_DFD (*cb)(struct S_DFD, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFP f16_S_SII_DFP(struct S_DFP p0, int p1, int p2,  struct S_DFP (*cb)(struct S_DFP, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDI f16_S_SII_DDI(struct S_DDI p0, int p1, int p2,  struct S_DDI (*cb)(struct S_DDI, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDF f16_S_SII_DDF(struct S_DDF p0, int p1, int p2,  struct S_DDF (*cb)(struct S_DDF, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDD f16_S_SII_DDD(struct S_DDD p0, int p1, int p2,  struct S_DDD (*cb)(struct S_DDD, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDP f16_S_SII_DDP(struct S_DDP p0, int p1, int p2,  struct S_DDP (*cb)(struct S_DDP, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPI f16_S_SII_DPI(struct S_DPI p0, int p1, int p2,  struct S_DPI (*cb)(struct S_DPI, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPF f16_S_SII_DPF(struct S_DPF p0, int p1, int p2,  struct S_DPF (*cb)(struct S_DPF, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPD f16_S_SII_DPD(struct S_DPD p0, int p1, int p2,  struct S_DPD (*cb)(struct S_DPD, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPP f16_S_SII_DPP(struct S_DPP p0, int p1, int p2,  struct S_DPP (*cb)(struct S_DPP, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PII f16_S_SII_PII(struct S_PII p0, int p1, int p2,  struct S_PII (*cb)(struct S_PII, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PIF f16_S_SII_PIF(struct S_PIF p0, int p1, int p2,  struct S_PIF (*cb)(struct S_PIF, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PID f16_S_SII_PID(struct S_PID p0, int p1, int p2,  struct S_PID (*cb)(struct S_PID, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PIP f16_S_SII_PIP(struct S_PIP p0, int p1, int p2,  struct S_PIP (*cb)(struct S_PIP, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFI f16_S_SII_PFI(struct S_PFI p0, int p1, int p2,  struct S_PFI (*cb)(struct S_PFI, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFF f16_S_SII_PFF(struct S_PFF p0, int p1, int p2,  struct S_PFF (*cb)(struct S_PFF, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFD f16_S_SII_PFD(struct S_PFD p0, int p1, int p2,  struct S_PFD (*cb)(struct S_PFD, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFP f16_S_SII_PFP(struct S_PFP p0, int p1, int p2,  struct S_PFP (*cb)(struct S_PFP, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDI f16_S_SII_PDI(struct S_PDI p0, int p1, int p2,  struct S_PDI (*cb)(struct S_PDI, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDF f16_S_SII_PDF(struct S_PDF p0, int p1, int p2,  struct S_PDF (*cb)(struct S_PDF, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDD f16_S_SII_PDD(struct S_PDD p0, int p1, int p2,  struct S_PDD (*cb)(struct S_PDD, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDP f16_S_SII_PDP(struct S_PDP p0, int p1, int p2,  struct S_PDP (*cb)(struct S_PDP, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPI f16_S_SII_PPI(struct S_PPI p0, int p1, int p2,  struct S_PPI (*cb)(struct S_PPI, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPF f16_S_SII_PPF(struct S_PPF p0, int p1, int p2,  struct S_PPF (*cb)(struct S_PPF, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPD f16_S_SII_PPD(struct S_PPD p0, int p1, int p2,  struct S_PPD (*cb)(struct S_PPD, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPP f16_S_SII_PPP(struct S_PPP p0, int p1, int p2,  struct S_PPP (*cb)(struct S_PPP, int, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_I f16_S_SIF_I(struct S_I p0, int p1, float p2,  struct S_I (*cb)(struct S_I, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_F f16_S_SIF_F(struct S_F p0, int p1, float p2,  struct S_F (*cb)(struct S_F, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_D f16_S_SIF_D(struct S_D p0, int p1, float p2,  struct S_D (*cb)(struct S_D, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_P f16_S_SIF_P(struct S_P p0, int p1, float p2,  struct S_P (*cb)(struct S_P, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_II f16_S_SIF_II(struct S_II p0, int p1, float p2,  struct S_II (*cb)(struct S_II, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IF f16_S_SIF_IF(struct S_IF p0, int p1, float p2,  struct S_IF (*cb)(struct S_IF, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_ID f16_S_SIF_ID(struct S_ID p0, int p1, float p2,  struct S_ID (*cb)(struct S_ID, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IP f16_S_SIF_IP(struct S_IP p0, int p1, float p2,  struct S_IP (*cb)(struct S_IP, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FI f16_S_SIF_FI(struct S_FI p0, int p1, float p2,  struct S_FI (*cb)(struct S_FI, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FF f16_S_SIF_FF(struct S_FF p0, int p1, float p2,  struct S_FF (*cb)(struct S_FF, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FD f16_S_SIF_FD(struct S_FD p0, int p1, float p2,  struct S_FD (*cb)(struct S_FD, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FP f16_S_SIF_FP(struct S_FP p0, int p1, float p2,  struct S_FP (*cb)(struct S_FP, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DI f16_S_SIF_DI(struct S_DI p0, int p1, float p2,  struct S_DI (*cb)(struct S_DI, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DF f16_S_SIF_DF(struct S_DF p0, int p1, float p2,  struct S_DF (*cb)(struct S_DF, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DD f16_S_SIF_DD(struct S_DD p0, int p1, float p2,  struct S_DD (*cb)(struct S_DD, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DP f16_S_SIF_DP(struct S_DP p0, int p1, float p2,  struct S_DP (*cb)(struct S_DP, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PI f16_S_SIF_PI(struct S_PI p0, int p1, float p2,  struct S_PI (*cb)(struct S_PI, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PF f16_S_SIF_PF(struct S_PF p0, int p1, float p2,  struct S_PF (*cb)(struct S_PF, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PD f16_S_SIF_PD(struct S_PD p0, int p1, float p2,  struct S_PD (*cb)(struct S_PD, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PP f16_S_SIF_PP(struct S_PP p0, int p1, float p2,  struct S_PP (*cb)(struct S_PP, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_III f16_S_SIF_III(struct S_III p0, int p1, float p2,  struct S_III (*cb)(struct S_III, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IIF f16_S_SIF_IIF(struct S_IIF p0, int p1, float p2,  struct S_IIF (*cb)(struct S_IIF, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IID f16_S_SIF_IID(struct S_IID p0, int p1, float p2,  struct S_IID (*cb)(struct S_IID, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IIP f16_S_SIF_IIP(struct S_IIP p0, int p1, float p2,  struct S_IIP (*cb)(struct S_IIP, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFI f16_S_SIF_IFI(struct S_IFI p0, int p1, float p2,  struct S_IFI (*cb)(struct S_IFI, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFF f16_S_SIF_IFF(struct S_IFF p0, int p1, float p2,  struct S_IFF (*cb)(struct S_IFF, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFD f16_S_SIF_IFD(struct S_IFD p0, int p1, float p2,  struct S_IFD (*cb)(struct S_IFD, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFP f16_S_SIF_IFP(struct S_IFP p0, int p1, float p2,  struct S_IFP (*cb)(struct S_IFP, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDI f16_S_SIF_IDI(struct S_IDI p0, int p1, float p2,  struct S_IDI (*cb)(struct S_IDI, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDF f16_S_SIF_IDF(struct S_IDF p0, int p1, float p2,  struct S_IDF (*cb)(struct S_IDF, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDD f16_S_SIF_IDD(struct S_IDD p0, int p1, float p2,  struct S_IDD (*cb)(struct S_IDD, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDP f16_S_SIF_IDP(struct S_IDP p0, int p1, float p2,  struct S_IDP (*cb)(struct S_IDP, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPI f16_S_SIF_IPI(struct S_IPI p0, int p1, float p2,  struct S_IPI (*cb)(struct S_IPI, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPF f16_S_SIF_IPF(struct S_IPF p0, int p1, float p2,  struct S_IPF (*cb)(struct S_IPF, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPD f16_S_SIF_IPD(struct S_IPD p0, int p1, float p2,  struct S_IPD (*cb)(struct S_IPD, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPP f16_S_SIF_IPP(struct S_IPP p0, int p1, float p2,  struct S_IPP (*cb)(struct S_IPP, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FII f16_S_SIF_FII(struct S_FII p0, int p1, float p2,  struct S_FII (*cb)(struct S_FII, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FIF f16_S_SIF_FIF(struct S_FIF p0, int p1, float p2,  struct S_FIF (*cb)(struct S_FIF, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FID f16_S_SIF_FID(struct S_FID p0, int p1, float p2,  struct S_FID (*cb)(struct S_FID, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FIP f16_S_SIF_FIP(struct S_FIP p0, int p1, float p2,  struct S_FIP (*cb)(struct S_FIP, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFI f16_S_SIF_FFI(struct S_FFI p0, int p1, float p2,  struct S_FFI (*cb)(struct S_FFI, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFF f16_S_SIF_FFF(struct S_FFF p0, int p1, float p2,  struct S_FFF (*cb)(struct S_FFF, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFD f16_S_SIF_FFD(struct S_FFD p0, int p1, float p2,  struct S_FFD (*cb)(struct S_FFD, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFP f16_S_SIF_FFP(struct S_FFP p0, int p1, float p2,  struct S_FFP (*cb)(struct S_FFP, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDI f16_S_SIF_FDI(struct S_FDI p0, int p1, float p2,  struct S_FDI (*cb)(struct S_FDI, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDF f16_S_SIF_FDF(struct S_FDF p0, int p1, float p2,  struct S_FDF (*cb)(struct S_FDF, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDD f16_S_SIF_FDD(struct S_FDD p0, int p1, float p2,  struct S_FDD (*cb)(struct S_FDD, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDP f16_S_SIF_FDP(struct S_FDP p0, int p1, float p2,  struct S_FDP (*cb)(struct S_FDP, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPI f16_S_SIF_FPI(struct S_FPI p0, int p1, float p2,  struct S_FPI (*cb)(struct S_FPI, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPF f16_S_SIF_FPF(struct S_FPF p0, int p1, float p2,  struct S_FPF (*cb)(struct S_FPF, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPD f16_S_SIF_FPD(struct S_FPD p0, int p1, float p2,  struct S_FPD (*cb)(struct S_FPD, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPP f16_S_SIF_FPP(struct S_FPP p0, int p1, float p2,  struct S_FPP (*cb)(struct S_FPP, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DII f16_S_SIF_DII(struct S_DII p0, int p1, float p2,  struct S_DII (*cb)(struct S_DII, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DIF f16_S_SIF_DIF(struct S_DIF p0, int p1, float p2,  struct S_DIF (*cb)(struct S_DIF, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DID f16_S_SIF_DID(struct S_DID p0, int p1, float p2,  struct S_DID (*cb)(struct S_DID, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DIP f16_S_SIF_DIP(struct S_DIP p0, int p1, float p2,  struct S_DIP (*cb)(struct S_DIP, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFI f16_S_SIF_DFI(struct S_DFI p0, int p1, float p2,  struct S_DFI (*cb)(struct S_DFI, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFF f16_S_SIF_DFF(struct S_DFF p0, int p1, float p2,  struct S_DFF (*cb)(struct S_DFF, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFD f16_S_SIF_DFD(struct S_DFD p0, int p1, float p2,  struct S_DFD (*cb)(struct S_DFD, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFP f16_S_SIF_DFP(struct S_DFP p0, int p1, float p2,  struct S_DFP (*cb)(struct S_DFP, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDI f16_S_SIF_DDI(struct S_DDI p0, int p1, float p2,  struct S_DDI (*cb)(struct S_DDI, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDF f16_S_SIF_DDF(struct S_DDF p0, int p1, float p2,  struct S_DDF (*cb)(struct S_DDF, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDD f16_S_SIF_DDD(struct S_DDD p0, int p1, float p2,  struct S_DDD (*cb)(struct S_DDD, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDP f16_S_SIF_DDP(struct S_DDP p0, int p1, float p2,  struct S_DDP (*cb)(struct S_DDP, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPI f16_S_SIF_DPI(struct S_DPI p0, int p1, float p2,  struct S_DPI (*cb)(struct S_DPI, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPF f16_S_SIF_DPF(struct S_DPF p0, int p1, float p2,  struct S_DPF (*cb)(struct S_DPF, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPD f16_S_SIF_DPD(struct S_DPD p0, int p1, float p2,  struct S_DPD (*cb)(struct S_DPD, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPP f16_S_SIF_DPP(struct S_DPP p0, int p1, float p2,  struct S_DPP (*cb)(struct S_DPP, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PII f16_S_SIF_PII(struct S_PII p0, int p1, float p2,  struct S_PII (*cb)(struct S_PII, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PIF f16_S_SIF_PIF(struct S_PIF p0, int p1, float p2,  struct S_PIF (*cb)(struct S_PIF, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PID f16_S_SIF_PID(struct S_PID p0, int p1, float p2,  struct S_PID (*cb)(struct S_PID, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PIP f16_S_SIF_PIP(struct S_PIP p0, int p1, float p2,  struct S_PIP (*cb)(struct S_PIP, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFI f16_S_SIF_PFI(struct S_PFI p0, int p1, float p2,  struct S_PFI (*cb)(struct S_PFI, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFF f16_S_SIF_PFF(struct S_PFF p0, int p1, float p2,  struct S_PFF (*cb)(struct S_PFF, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFD f16_S_SIF_PFD(struct S_PFD p0, int p1, float p2,  struct S_PFD (*cb)(struct S_PFD, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFP f16_S_SIF_PFP(struct S_PFP p0, int p1, float p2,  struct S_PFP (*cb)(struct S_PFP, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDI f16_S_SIF_PDI(struct S_PDI p0, int p1, float p2,  struct S_PDI (*cb)(struct S_PDI, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDF f16_S_SIF_PDF(struct S_PDF p0, int p1, float p2,  struct S_PDF (*cb)(struct S_PDF, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDD f16_S_SIF_PDD(struct S_PDD p0, int p1, float p2,  struct S_PDD (*cb)(struct S_PDD, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDP f16_S_SIF_PDP(struct S_PDP p0, int p1, float p2,  struct S_PDP (*cb)(struct S_PDP, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPI f16_S_SIF_PPI(struct S_PPI p0, int p1, float p2,  struct S_PPI (*cb)(struct S_PPI, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPF f16_S_SIF_PPF(struct S_PPF p0, int p1, float p2,  struct S_PPF (*cb)(struct S_PPF, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPD f16_S_SIF_PPD(struct S_PPD p0, int p1, float p2,  struct S_PPD (*cb)(struct S_PPD, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPP f16_S_SIF_PPP(struct S_PPP p0, int p1, float p2,  struct S_PPP (*cb)(struct S_PPP, int, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_I f16_S_SID_I(struct S_I p0, int p1, double p2,  struct S_I (*cb)(struct S_I, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_F f16_S_SID_F(struct S_F p0, int p1, double p2,  struct S_F (*cb)(struct S_F, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_D f16_S_SID_D(struct S_D p0, int p1, double p2,  struct S_D (*cb)(struct S_D, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_P f16_S_SID_P(struct S_P p0, int p1, double p2,  struct S_P (*cb)(struct S_P, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_II f16_S_SID_II(struct S_II p0, int p1, double p2,  struct S_II (*cb)(struct S_II, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IF f16_S_SID_IF(struct S_IF p0, int p1, double p2,  struct S_IF (*cb)(struct S_IF, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_ID f16_S_SID_ID(struct S_ID p0, int p1, double p2,  struct S_ID (*cb)(struct S_ID, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IP f16_S_SID_IP(struct S_IP p0, int p1, double p2,  struct S_IP (*cb)(struct S_IP, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FI f16_S_SID_FI(struct S_FI p0, int p1, double p2,  struct S_FI (*cb)(struct S_FI, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FF f16_S_SID_FF(struct S_FF p0, int p1, double p2,  struct S_FF (*cb)(struct S_FF, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FD f16_S_SID_FD(struct S_FD p0, int p1, double p2,  struct S_FD (*cb)(struct S_FD, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FP f16_S_SID_FP(struct S_FP p0, int p1, double p2,  struct S_FP (*cb)(struct S_FP, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DI f16_S_SID_DI(struct S_DI p0, int p1, double p2,  struct S_DI (*cb)(struct S_DI, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DF f16_S_SID_DF(struct S_DF p0, int p1, double p2,  struct S_DF (*cb)(struct S_DF, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DD f16_S_SID_DD(struct S_DD p0, int p1, double p2,  struct S_DD (*cb)(struct S_DD, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DP f16_S_SID_DP(struct S_DP p0, int p1, double p2,  struct S_DP (*cb)(struct S_DP, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PI f16_S_SID_PI(struct S_PI p0, int p1, double p2,  struct S_PI (*cb)(struct S_PI, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PF f16_S_SID_PF(struct S_PF p0, int p1, double p2,  struct S_PF (*cb)(struct S_PF, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PD f16_S_SID_PD(struct S_PD p0, int p1, double p2,  struct S_PD (*cb)(struct S_PD, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PP f16_S_SID_PP(struct S_PP p0, int p1, double p2,  struct S_PP (*cb)(struct S_PP, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_III f16_S_SID_III(struct S_III p0, int p1, double p2,  struct S_III (*cb)(struct S_III, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IIF f16_S_SID_IIF(struct S_IIF p0, int p1, double p2,  struct S_IIF (*cb)(struct S_IIF, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IID f16_S_SID_IID(struct S_IID p0, int p1, double p2,  struct S_IID (*cb)(struct S_IID, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IIP f16_S_SID_IIP(struct S_IIP p0, int p1, double p2,  struct S_IIP (*cb)(struct S_IIP, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFI f16_S_SID_IFI(struct S_IFI p0, int p1, double p2,  struct S_IFI (*cb)(struct S_IFI, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFF f16_S_SID_IFF(struct S_IFF p0, int p1, double p2,  struct S_IFF (*cb)(struct S_IFF, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFD f16_S_SID_IFD(struct S_IFD p0, int p1, double p2,  struct S_IFD (*cb)(struct S_IFD, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFP f16_S_SID_IFP(struct S_IFP p0, int p1, double p2,  struct S_IFP (*cb)(struct S_IFP, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDI f16_S_SID_IDI(struct S_IDI p0, int p1, double p2,  struct S_IDI (*cb)(struct S_IDI, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDF f16_S_SID_IDF(struct S_IDF p0, int p1, double p2,  struct S_IDF (*cb)(struct S_IDF, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDD f16_S_SID_IDD(struct S_IDD p0, int p1, double p2,  struct S_IDD (*cb)(struct S_IDD, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDP f16_S_SID_IDP(struct S_IDP p0, int p1, double p2,  struct S_IDP (*cb)(struct S_IDP, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPI f16_S_SID_IPI(struct S_IPI p0, int p1, double p2,  struct S_IPI (*cb)(struct S_IPI, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPF f16_S_SID_IPF(struct S_IPF p0, int p1, double p2,  struct S_IPF (*cb)(struct S_IPF, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPD f16_S_SID_IPD(struct S_IPD p0, int p1, double p2,  struct S_IPD (*cb)(struct S_IPD, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPP f17_S_SID_IPP(struct S_IPP p0, int p1, double p2,  struct S_IPP (*cb)(struct S_IPP, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FII f17_S_SID_FII(struct S_FII p0, int p1, double p2,  struct S_FII (*cb)(struct S_FII, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FIF f17_S_SID_FIF(struct S_FIF p0, int p1, double p2,  struct S_FIF (*cb)(struct S_FIF, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FID f17_S_SID_FID(struct S_FID p0, int p1, double p2,  struct S_FID (*cb)(struct S_FID, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FIP f17_S_SID_FIP(struct S_FIP p0, int p1, double p2,  struct S_FIP (*cb)(struct S_FIP, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFI f17_S_SID_FFI(struct S_FFI p0, int p1, double p2,  struct S_FFI (*cb)(struct S_FFI, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFF f17_S_SID_FFF(struct S_FFF p0, int p1, double p2,  struct S_FFF (*cb)(struct S_FFF, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFD f17_S_SID_FFD(struct S_FFD p0, int p1, double p2,  struct S_FFD (*cb)(struct S_FFD, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFP f17_S_SID_FFP(struct S_FFP p0, int p1, double p2,  struct S_FFP (*cb)(struct S_FFP, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDI f17_S_SID_FDI(struct S_FDI p0, int p1, double p2,  struct S_FDI (*cb)(struct S_FDI, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDF f17_S_SID_FDF(struct S_FDF p0, int p1, double p2,  struct S_FDF (*cb)(struct S_FDF, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDD f17_S_SID_FDD(struct S_FDD p0, int p1, double p2,  struct S_FDD (*cb)(struct S_FDD, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDP f17_S_SID_FDP(struct S_FDP p0, int p1, double p2,  struct S_FDP (*cb)(struct S_FDP, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPI f17_S_SID_FPI(struct S_FPI p0, int p1, double p2,  struct S_FPI (*cb)(struct S_FPI, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPF f17_S_SID_FPF(struct S_FPF p0, int p1, double p2,  struct S_FPF (*cb)(struct S_FPF, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPD f17_S_SID_FPD(struct S_FPD p0, int p1, double p2,  struct S_FPD (*cb)(struct S_FPD, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPP f17_S_SID_FPP(struct S_FPP p0, int p1, double p2,  struct S_FPP (*cb)(struct S_FPP, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DII f17_S_SID_DII(struct S_DII p0, int p1, double p2,  struct S_DII (*cb)(struct S_DII, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DIF f17_S_SID_DIF(struct S_DIF p0, int p1, double p2,  struct S_DIF (*cb)(struct S_DIF, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DID f17_S_SID_DID(struct S_DID p0, int p1, double p2,  struct S_DID (*cb)(struct S_DID, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DIP f17_S_SID_DIP(struct S_DIP p0, int p1, double p2,  struct S_DIP (*cb)(struct S_DIP, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFI f17_S_SID_DFI(struct S_DFI p0, int p1, double p2,  struct S_DFI (*cb)(struct S_DFI, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFF f17_S_SID_DFF(struct S_DFF p0, int p1, double p2,  struct S_DFF (*cb)(struct S_DFF, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFD f17_S_SID_DFD(struct S_DFD p0, int p1, double p2,  struct S_DFD (*cb)(struct S_DFD, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFP f17_S_SID_DFP(struct S_DFP p0, int p1, double p2,  struct S_DFP (*cb)(struct S_DFP, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDI f17_S_SID_DDI(struct S_DDI p0, int p1, double p2,  struct S_DDI (*cb)(struct S_DDI, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDF f17_S_SID_DDF(struct S_DDF p0, int p1, double p2,  struct S_DDF (*cb)(struct S_DDF, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDD f17_S_SID_DDD(struct S_DDD p0, int p1, double p2,  struct S_DDD (*cb)(struct S_DDD, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDP f17_S_SID_DDP(struct S_DDP p0, int p1, double p2,  struct S_DDP (*cb)(struct S_DDP, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPI f17_S_SID_DPI(struct S_DPI p0, int p1, double p2,  struct S_DPI (*cb)(struct S_DPI, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPF f17_S_SID_DPF(struct S_DPF p0, int p1, double p2,  struct S_DPF (*cb)(struct S_DPF, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPD f17_S_SID_DPD(struct S_DPD p0, int p1, double p2,  struct S_DPD (*cb)(struct S_DPD, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPP f17_S_SID_DPP(struct S_DPP p0, int p1, double p2,  struct S_DPP (*cb)(struct S_DPP, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PII f17_S_SID_PII(struct S_PII p0, int p1, double p2,  struct S_PII (*cb)(struct S_PII, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PIF f17_S_SID_PIF(struct S_PIF p0, int p1, double p2,  struct S_PIF (*cb)(struct S_PIF, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PID f17_S_SID_PID(struct S_PID p0, int p1, double p2,  struct S_PID (*cb)(struct S_PID, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PIP f17_S_SID_PIP(struct S_PIP p0, int p1, double p2,  struct S_PIP (*cb)(struct S_PIP, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFI f17_S_SID_PFI(struct S_PFI p0, int p1, double p2,  struct S_PFI (*cb)(struct S_PFI, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFF f17_S_SID_PFF(struct S_PFF p0, int p1, double p2,  struct S_PFF (*cb)(struct S_PFF, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFD f17_S_SID_PFD(struct S_PFD p0, int p1, double p2,  struct S_PFD (*cb)(struct S_PFD, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFP f17_S_SID_PFP(struct S_PFP p0, int p1, double p2,  struct S_PFP (*cb)(struct S_PFP, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDI f17_S_SID_PDI(struct S_PDI p0, int p1, double p2,  struct S_PDI (*cb)(struct S_PDI, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDF f17_S_SID_PDF(struct S_PDF p0, int p1, double p2,  struct S_PDF (*cb)(struct S_PDF, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDD f17_S_SID_PDD(struct S_PDD p0, int p1, double p2,  struct S_PDD (*cb)(struct S_PDD, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDP f17_S_SID_PDP(struct S_PDP p0, int p1, double p2,  struct S_PDP (*cb)(struct S_PDP, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPI f17_S_SID_PPI(struct S_PPI p0, int p1, double p2,  struct S_PPI (*cb)(struct S_PPI, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPF f17_S_SID_PPF(struct S_PPF p0, int p1, double p2,  struct S_PPF (*cb)(struct S_PPF, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPD f17_S_SID_PPD(struct S_PPD p0, int p1, double p2,  struct S_PPD (*cb)(struct S_PPD, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPP f17_S_SID_PPP(struct S_PPP p0, int p1, double p2,  struct S_PPP (*cb)(struct S_PPP, int, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_I f17_S_SIP_I(struct S_I p0, int p1, void* p2,  struct S_I (*cb)(struct S_I, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_F f17_S_SIP_F(struct S_F p0, int p1, void* p2,  struct S_F (*cb)(struct S_F, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_D f17_S_SIP_D(struct S_D p0, int p1, void* p2,  struct S_D (*cb)(struct S_D, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_P f17_S_SIP_P(struct S_P p0, int p1, void* p2,  struct S_P (*cb)(struct S_P, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_II f17_S_SIP_II(struct S_II p0, int p1, void* p2,  struct S_II (*cb)(struct S_II, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IF f17_S_SIP_IF(struct S_IF p0, int p1, void* p2,  struct S_IF (*cb)(struct S_IF, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_ID f17_S_SIP_ID(struct S_ID p0, int p1, void* p2,  struct S_ID (*cb)(struct S_ID, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IP f17_S_SIP_IP(struct S_IP p0, int p1, void* p2,  struct S_IP (*cb)(struct S_IP, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FI f17_S_SIP_FI(struct S_FI p0, int p1, void* p2,  struct S_FI (*cb)(struct S_FI, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FF f17_S_SIP_FF(struct S_FF p0, int p1, void* p2,  struct S_FF (*cb)(struct S_FF, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FD f17_S_SIP_FD(struct S_FD p0, int p1, void* p2,  struct S_FD (*cb)(struct S_FD, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FP f17_S_SIP_FP(struct S_FP p0, int p1, void* p2,  struct S_FP (*cb)(struct S_FP, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DI f17_S_SIP_DI(struct S_DI p0, int p1, void* p2,  struct S_DI (*cb)(struct S_DI, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DF f17_S_SIP_DF(struct S_DF p0, int p1, void* p2,  struct S_DF (*cb)(struct S_DF, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DD f17_S_SIP_DD(struct S_DD p0, int p1, void* p2,  struct S_DD (*cb)(struct S_DD, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DP f17_S_SIP_DP(struct S_DP p0, int p1, void* p2,  struct S_DP (*cb)(struct S_DP, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PI f17_S_SIP_PI(struct S_PI p0, int p1, void* p2,  struct S_PI (*cb)(struct S_PI, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PF f17_S_SIP_PF(struct S_PF p0, int p1, void* p2,  struct S_PF (*cb)(struct S_PF, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PD f17_S_SIP_PD(struct S_PD p0, int p1, void* p2,  struct S_PD (*cb)(struct S_PD, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PP f17_S_SIP_PP(struct S_PP p0, int p1, void* p2,  struct S_PP (*cb)(struct S_PP, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_III f17_S_SIP_III(struct S_III p0, int p1, void* p2,  struct S_III (*cb)(struct S_III, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IIF f17_S_SIP_IIF(struct S_IIF p0, int p1, void* p2,  struct S_IIF (*cb)(struct S_IIF, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IID f17_S_SIP_IID(struct S_IID p0, int p1, void* p2,  struct S_IID (*cb)(struct S_IID, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IIP f17_S_SIP_IIP(struct S_IIP p0, int p1, void* p2,  struct S_IIP (*cb)(struct S_IIP, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFI f17_S_SIP_IFI(struct S_IFI p0, int p1, void* p2,  struct S_IFI (*cb)(struct S_IFI, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFF f17_S_SIP_IFF(struct S_IFF p0, int p1, void* p2,  struct S_IFF (*cb)(struct S_IFF, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFD f17_S_SIP_IFD(struct S_IFD p0, int p1, void* p2,  struct S_IFD (*cb)(struct S_IFD, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFP f17_S_SIP_IFP(struct S_IFP p0, int p1, void* p2,  struct S_IFP (*cb)(struct S_IFP, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDI f17_S_SIP_IDI(struct S_IDI p0, int p1, void* p2,  struct S_IDI (*cb)(struct S_IDI, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDF f17_S_SIP_IDF(struct S_IDF p0, int p1, void* p2,  struct S_IDF (*cb)(struct S_IDF, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDD f17_S_SIP_IDD(struct S_IDD p0, int p1, void* p2,  struct S_IDD (*cb)(struct S_IDD, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDP f17_S_SIP_IDP(struct S_IDP p0, int p1, void* p2,  struct S_IDP (*cb)(struct S_IDP, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPI f17_S_SIP_IPI(struct S_IPI p0, int p1, void* p2,  struct S_IPI (*cb)(struct S_IPI, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPF f17_S_SIP_IPF(struct S_IPF p0, int p1, void* p2,  struct S_IPF (*cb)(struct S_IPF, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPD f17_S_SIP_IPD(struct S_IPD p0, int p1, void* p2,  struct S_IPD (*cb)(struct S_IPD, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPP f17_S_SIP_IPP(struct S_IPP p0, int p1, void* p2,  struct S_IPP (*cb)(struct S_IPP, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FII f17_S_SIP_FII(struct S_FII p0, int p1, void* p2,  struct S_FII (*cb)(struct S_FII, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FIF f17_S_SIP_FIF(struct S_FIF p0, int p1, void* p2,  struct S_FIF (*cb)(struct S_FIF, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FID f17_S_SIP_FID(struct S_FID p0, int p1, void* p2,  struct S_FID (*cb)(struct S_FID, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FIP f17_S_SIP_FIP(struct S_FIP p0, int p1, void* p2,  struct S_FIP (*cb)(struct S_FIP, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFI f17_S_SIP_FFI(struct S_FFI p0, int p1, void* p2,  struct S_FFI (*cb)(struct S_FFI, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFF f17_S_SIP_FFF(struct S_FFF p0, int p1, void* p2,  struct S_FFF (*cb)(struct S_FFF, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFD f17_S_SIP_FFD(struct S_FFD p0, int p1, void* p2,  struct S_FFD (*cb)(struct S_FFD, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFP f17_S_SIP_FFP(struct S_FFP p0, int p1, void* p2,  struct S_FFP (*cb)(struct S_FFP, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDI f17_S_SIP_FDI(struct S_FDI p0, int p1, void* p2,  struct S_FDI (*cb)(struct S_FDI, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDF f17_S_SIP_FDF(struct S_FDF p0, int p1, void* p2,  struct S_FDF (*cb)(struct S_FDF, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDD f17_S_SIP_FDD(struct S_FDD p0, int p1, void* p2,  struct S_FDD (*cb)(struct S_FDD, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDP f17_S_SIP_FDP(struct S_FDP p0, int p1, void* p2,  struct S_FDP (*cb)(struct S_FDP, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPI f17_S_SIP_FPI(struct S_FPI p0, int p1, void* p2,  struct S_FPI (*cb)(struct S_FPI, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPF f17_S_SIP_FPF(struct S_FPF p0, int p1, void* p2,  struct S_FPF (*cb)(struct S_FPF, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPD f17_S_SIP_FPD(struct S_FPD p0, int p1, void* p2,  struct S_FPD (*cb)(struct S_FPD, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPP f17_S_SIP_FPP(struct S_FPP p0, int p1, void* p2,  struct S_FPP (*cb)(struct S_FPP, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DII f17_S_SIP_DII(struct S_DII p0, int p1, void* p2,  struct S_DII (*cb)(struct S_DII, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DIF f17_S_SIP_DIF(struct S_DIF p0, int p1, void* p2,  struct S_DIF (*cb)(struct S_DIF, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DID f17_S_SIP_DID(struct S_DID p0, int p1, void* p2,  struct S_DID (*cb)(struct S_DID, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DIP f17_S_SIP_DIP(struct S_DIP p0, int p1, void* p2,  struct S_DIP (*cb)(struct S_DIP, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFI f17_S_SIP_DFI(struct S_DFI p0, int p1, void* p2,  struct S_DFI (*cb)(struct S_DFI, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFF f17_S_SIP_DFF(struct S_DFF p0, int p1, void* p2,  struct S_DFF (*cb)(struct S_DFF, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFD f17_S_SIP_DFD(struct S_DFD p0, int p1, void* p2,  struct S_DFD (*cb)(struct S_DFD, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFP f17_S_SIP_DFP(struct S_DFP p0, int p1, void* p2,  struct S_DFP (*cb)(struct S_DFP, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDI f17_S_SIP_DDI(struct S_DDI p0, int p1, void* p2,  struct S_DDI (*cb)(struct S_DDI, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDF f17_S_SIP_DDF(struct S_DDF p0, int p1, void* p2,  struct S_DDF (*cb)(struct S_DDF, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDD f17_S_SIP_DDD(struct S_DDD p0, int p1, void* p2,  struct S_DDD (*cb)(struct S_DDD, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDP f17_S_SIP_DDP(struct S_DDP p0, int p1, void* p2,  struct S_DDP (*cb)(struct S_DDP, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPI f17_S_SIP_DPI(struct S_DPI p0, int p1, void* p2,  struct S_DPI (*cb)(struct S_DPI, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPF f17_S_SIP_DPF(struct S_DPF p0, int p1, void* p2,  struct S_DPF (*cb)(struct S_DPF, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPD f17_S_SIP_DPD(struct S_DPD p0, int p1, void* p2,  struct S_DPD (*cb)(struct S_DPD, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPP f17_S_SIP_DPP(struct S_DPP p0, int p1, void* p2,  struct S_DPP (*cb)(struct S_DPP, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PII f17_S_SIP_PII(struct S_PII p0, int p1, void* p2,  struct S_PII (*cb)(struct S_PII, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PIF f17_S_SIP_PIF(struct S_PIF p0, int p1, void* p2,  struct S_PIF (*cb)(struct S_PIF, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PID f17_S_SIP_PID(struct S_PID p0, int p1, void* p2,  struct S_PID (*cb)(struct S_PID, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PIP f17_S_SIP_PIP(struct S_PIP p0, int p1, void* p2,  struct S_PIP (*cb)(struct S_PIP, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFI f17_S_SIP_PFI(struct S_PFI p0, int p1, void* p2,  struct S_PFI (*cb)(struct S_PFI, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFF f17_S_SIP_PFF(struct S_PFF p0, int p1, void* p2,  struct S_PFF (*cb)(struct S_PFF, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFD f17_S_SIP_PFD(struct S_PFD p0, int p1, void* p2,  struct S_PFD (*cb)(struct S_PFD, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFP f17_S_SIP_PFP(struct S_PFP p0, int p1, void* p2,  struct S_PFP (*cb)(struct S_PFP, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDI f17_S_SIP_PDI(struct S_PDI p0, int p1, void* p2,  struct S_PDI (*cb)(struct S_PDI, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDF f17_S_SIP_PDF(struct S_PDF p0, int p1, void* p2,  struct S_PDF (*cb)(struct S_PDF, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDD f17_S_SIP_PDD(struct S_PDD p0, int p1, void* p2,  struct S_PDD (*cb)(struct S_PDD, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDP f17_S_SIP_PDP(struct S_PDP p0, int p1, void* p2,  struct S_PDP (*cb)(struct S_PDP, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPI f17_S_SIP_PPI(struct S_PPI p0, int p1, void* p2,  struct S_PPI (*cb)(struct S_PPI, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPF f17_S_SIP_PPF(struct S_PPF p0, int p1, void* p2,  struct S_PPF (*cb)(struct S_PPF, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPD f17_S_SIP_PPD(struct S_PPD p0, int p1, void* p2,  struct S_PPD (*cb)(struct S_PPD, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPP f17_S_SIP_PPP(struct S_PPP p0, int p1, void* p2,  struct S_PPP (*cb)(struct S_PPP, int, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_I f17_S_SIS_I(struct S_I p0, int p1, struct S_I p2,  struct S_I (*cb)(struct S_I, int, struct S_I)) { return cb(p0,p1,p2); }
+EXPORT struct S_F f17_S_SIS_F(struct S_F p0, int p1, struct S_F p2,  struct S_F (*cb)(struct S_F, int, struct S_F)) { return cb(p0,p1,p2); }
+EXPORT struct S_D f17_S_SIS_D(struct S_D p0, int p1, struct S_D p2,  struct S_D (*cb)(struct S_D, int, struct S_D)) { return cb(p0,p1,p2); }
+EXPORT struct S_P f17_S_SIS_P(struct S_P p0, int p1, struct S_P p2,  struct S_P (*cb)(struct S_P, int, struct S_P)) { return cb(p0,p1,p2); }
+EXPORT struct S_II f17_S_SIS_II(struct S_II p0, int p1, struct S_II p2,  struct S_II (*cb)(struct S_II, int, struct S_II)) { return cb(p0,p1,p2); }
+EXPORT struct S_IF f17_S_SIS_IF(struct S_IF p0, int p1, struct S_IF p2,  struct S_IF (*cb)(struct S_IF, int, struct S_IF)) { return cb(p0,p1,p2); }
+EXPORT struct S_ID f17_S_SIS_ID(struct S_ID p0, int p1, struct S_ID p2,  struct S_ID (*cb)(struct S_ID, int, struct S_ID)) { return cb(p0,p1,p2); }
+EXPORT struct S_IP f17_S_SIS_IP(struct S_IP p0, int p1, struct S_IP p2,  struct S_IP (*cb)(struct S_IP, int, struct S_IP)) { return cb(p0,p1,p2); }
+EXPORT struct S_FI f17_S_SIS_FI(struct S_FI p0, int p1, struct S_FI p2,  struct S_FI (*cb)(struct S_FI, int, struct S_FI)) { return cb(p0,p1,p2); }
+EXPORT struct S_FF f17_S_SIS_FF(struct S_FF p0, int p1, struct S_FF p2,  struct S_FF (*cb)(struct S_FF, int, struct S_FF)) { return cb(p0,p1,p2); }
+EXPORT struct S_FD f17_S_SIS_FD(struct S_FD p0, int p1, struct S_FD p2,  struct S_FD (*cb)(struct S_FD, int, struct S_FD)) { return cb(p0,p1,p2); }
+EXPORT struct S_FP f17_S_SIS_FP(struct S_FP p0, int p1, struct S_FP p2,  struct S_FP (*cb)(struct S_FP, int, struct S_FP)) { return cb(p0,p1,p2); }
+EXPORT struct S_DI f17_S_SIS_DI(struct S_DI p0, int p1, struct S_DI p2,  struct S_DI (*cb)(struct S_DI, int, struct S_DI)) { return cb(p0,p1,p2); }
+EXPORT struct S_DF f17_S_SIS_DF(struct S_DF p0, int p1, struct S_DF p2,  struct S_DF (*cb)(struct S_DF, int, struct S_DF)) { return cb(p0,p1,p2); }
+EXPORT struct S_DD f17_S_SIS_DD(struct S_DD p0, int p1, struct S_DD p2,  struct S_DD (*cb)(struct S_DD, int, struct S_DD)) { return cb(p0,p1,p2); }
+EXPORT struct S_DP f17_S_SIS_DP(struct S_DP p0, int p1, struct S_DP p2,  struct S_DP (*cb)(struct S_DP, int, struct S_DP)) { return cb(p0,p1,p2); }
+EXPORT struct S_PI f17_S_SIS_PI(struct S_PI p0, int p1, struct S_PI p2,  struct S_PI (*cb)(struct S_PI, int, struct S_PI)) { return cb(p0,p1,p2); }
+EXPORT struct S_PF f17_S_SIS_PF(struct S_PF p0, int p1, struct S_PF p2,  struct S_PF (*cb)(struct S_PF, int, struct S_PF)) { return cb(p0,p1,p2); }
+EXPORT struct S_PD f17_S_SIS_PD(struct S_PD p0, int p1, struct S_PD p2,  struct S_PD (*cb)(struct S_PD, int, struct S_PD)) { return cb(p0,p1,p2); }
+EXPORT struct S_PP f17_S_SIS_PP(struct S_PP p0, int p1, struct S_PP p2,  struct S_PP (*cb)(struct S_PP, int, struct S_PP)) { return cb(p0,p1,p2); }
+EXPORT struct S_III f17_S_SIS_III(struct S_III p0, int p1, struct S_III p2,  struct S_III (*cb)(struct S_III, int, struct S_III)) { return cb(p0,p1,p2); }
+EXPORT struct S_IIF f17_S_SIS_IIF(struct S_IIF p0, int p1, struct S_IIF p2,  struct S_IIF (*cb)(struct S_IIF, int, struct S_IIF)) { return cb(p0,p1,p2); }
+EXPORT struct S_IID f17_S_SIS_IID(struct S_IID p0, int p1, struct S_IID p2,  struct S_IID (*cb)(struct S_IID, int, struct S_IID)) { return cb(p0,p1,p2); }
+EXPORT struct S_IIP f17_S_SIS_IIP(struct S_IIP p0, int p1, struct S_IIP p2,  struct S_IIP (*cb)(struct S_IIP, int, struct S_IIP)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFI f17_S_SIS_IFI(struct S_IFI p0, int p1, struct S_IFI p2,  struct S_IFI (*cb)(struct S_IFI, int, struct S_IFI)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFF f17_S_SIS_IFF(struct S_IFF p0, int p1, struct S_IFF p2,  struct S_IFF (*cb)(struct S_IFF, int, struct S_IFF)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFD f17_S_SIS_IFD(struct S_IFD p0, int p1, struct S_IFD p2,  struct S_IFD (*cb)(struct S_IFD, int, struct S_IFD)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFP f17_S_SIS_IFP(struct S_IFP p0, int p1, struct S_IFP p2,  struct S_IFP (*cb)(struct S_IFP, int, struct S_IFP)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDI f17_S_SIS_IDI(struct S_IDI p0, int p1, struct S_IDI p2,  struct S_IDI (*cb)(struct S_IDI, int, struct S_IDI)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDF f17_S_SIS_IDF(struct S_IDF p0, int p1, struct S_IDF p2,  struct S_IDF (*cb)(struct S_IDF, int, struct S_IDF)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDD f17_S_SIS_IDD(struct S_IDD p0, int p1, struct S_IDD p2,  struct S_IDD (*cb)(struct S_IDD, int, struct S_IDD)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDP f17_S_SIS_IDP(struct S_IDP p0, int p1, struct S_IDP p2,  struct S_IDP (*cb)(struct S_IDP, int, struct S_IDP)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPI f17_S_SIS_IPI(struct S_IPI p0, int p1, struct S_IPI p2,  struct S_IPI (*cb)(struct S_IPI, int, struct S_IPI)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPF f17_S_SIS_IPF(struct S_IPF p0, int p1, struct S_IPF p2,  struct S_IPF (*cb)(struct S_IPF, int, struct S_IPF)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPD f17_S_SIS_IPD(struct S_IPD p0, int p1, struct S_IPD p2,  struct S_IPD (*cb)(struct S_IPD, int, struct S_IPD)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPP f17_S_SIS_IPP(struct S_IPP p0, int p1, struct S_IPP p2,  struct S_IPP (*cb)(struct S_IPP, int, struct S_IPP)) { return cb(p0,p1,p2); }
+EXPORT struct S_FII f17_S_SIS_FII(struct S_FII p0, int p1, struct S_FII p2,  struct S_FII (*cb)(struct S_FII, int, struct S_FII)) { return cb(p0,p1,p2); }
+EXPORT struct S_FIF f17_S_SIS_FIF(struct S_FIF p0, int p1, struct S_FIF p2,  struct S_FIF (*cb)(struct S_FIF, int, struct S_FIF)) { return cb(p0,p1,p2); }
+EXPORT struct S_FID f17_S_SIS_FID(struct S_FID p0, int p1, struct S_FID p2,  struct S_FID (*cb)(struct S_FID, int, struct S_FID)) { return cb(p0,p1,p2); }
+EXPORT struct S_FIP f17_S_SIS_FIP(struct S_FIP p0, int p1, struct S_FIP p2,  struct S_FIP (*cb)(struct S_FIP, int, struct S_FIP)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFI f17_S_SIS_FFI(struct S_FFI p0, int p1, struct S_FFI p2,  struct S_FFI (*cb)(struct S_FFI, int, struct S_FFI)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFF f17_S_SIS_FFF(struct S_FFF p0, int p1, struct S_FFF p2,  struct S_FFF (*cb)(struct S_FFF, int, struct S_FFF)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFD f17_S_SIS_FFD(struct S_FFD p0, int p1, struct S_FFD p2,  struct S_FFD (*cb)(struct S_FFD, int, struct S_FFD)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFP f17_S_SIS_FFP(struct S_FFP p0, int p1, struct S_FFP p2,  struct S_FFP (*cb)(struct S_FFP, int, struct S_FFP)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDI f17_S_SIS_FDI(struct S_FDI p0, int p1, struct S_FDI p2,  struct S_FDI (*cb)(struct S_FDI, int, struct S_FDI)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDF f17_S_SIS_FDF(struct S_FDF p0, int p1, struct S_FDF p2,  struct S_FDF (*cb)(struct S_FDF, int, struct S_FDF)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDD f17_S_SIS_FDD(struct S_FDD p0, int p1, struct S_FDD p2,  struct S_FDD (*cb)(struct S_FDD, int, struct S_FDD)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDP f17_S_SIS_FDP(struct S_FDP p0, int p1, struct S_FDP p2,  struct S_FDP (*cb)(struct S_FDP, int, struct S_FDP)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPI f17_S_SIS_FPI(struct S_FPI p0, int p1, struct S_FPI p2,  struct S_FPI (*cb)(struct S_FPI, int, struct S_FPI)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPF f17_S_SIS_FPF(struct S_FPF p0, int p1, struct S_FPF p2,  struct S_FPF (*cb)(struct S_FPF, int, struct S_FPF)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPD f17_S_SIS_FPD(struct S_FPD p0, int p1, struct S_FPD p2,  struct S_FPD (*cb)(struct S_FPD, int, struct S_FPD)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPP f17_S_SIS_FPP(struct S_FPP p0, int p1, struct S_FPP p2,  struct S_FPP (*cb)(struct S_FPP, int, struct S_FPP)) { return cb(p0,p1,p2); }
+EXPORT struct S_DII f17_S_SIS_DII(struct S_DII p0, int p1, struct S_DII p2,  struct S_DII (*cb)(struct S_DII, int, struct S_DII)) { return cb(p0,p1,p2); }
+EXPORT struct S_DIF f17_S_SIS_DIF(struct S_DIF p0, int p1, struct S_DIF p2,  struct S_DIF (*cb)(struct S_DIF, int, struct S_DIF)) { return cb(p0,p1,p2); }
+EXPORT struct S_DID f17_S_SIS_DID(struct S_DID p0, int p1, struct S_DID p2,  struct S_DID (*cb)(struct S_DID, int, struct S_DID)) { return cb(p0,p1,p2); }
+EXPORT struct S_DIP f17_S_SIS_DIP(struct S_DIP p0, int p1, struct S_DIP p2,  struct S_DIP (*cb)(struct S_DIP, int, struct S_DIP)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFI f17_S_SIS_DFI(struct S_DFI p0, int p1, struct S_DFI p2,  struct S_DFI (*cb)(struct S_DFI, int, struct S_DFI)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFF f17_S_SIS_DFF(struct S_DFF p0, int p1, struct S_DFF p2,  struct S_DFF (*cb)(struct S_DFF, int, struct S_DFF)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFD f17_S_SIS_DFD(struct S_DFD p0, int p1, struct S_DFD p2,  struct S_DFD (*cb)(struct S_DFD, int, struct S_DFD)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFP f17_S_SIS_DFP(struct S_DFP p0, int p1, struct S_DFP p2,  struct S_DFP (*cb)(struct S_DFP, int, struct S_DFP)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDI f17_S_SIS_DDI(struct S_DDI p0, int p1, struct S_DDI p2,  struct S_DDI (*cb)(struct S_DDI, int, struct S_DDI)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDF f17_S_SIS_DDF(struct S_DDF p0, int p1, struct S_DDF p2,  struct S_DDF (*cb)(struct S_DDF, int, struct S_DDF)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDD f17_S_SIS_DDD(struct S_DDD p0, int p1, struct S_DDD p2,  struct S_DDD (*cb)(struct S_DDD, int, struct S_DDD)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDP f17_S_SIS_DDP(struct S_DDP p0, int p1, struct S_DDP p2,  struct S_DDP (*cb)(struct S_DDP, int, struct S_DDP)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPI f17_S_SIS_DPI(struct S_DPI p0, int p1, struct S_DPI p2,  struct S_DPI (*cb)(struct S_DPI, int, struct S_DPI)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPF f17_S_SIS_DPF(struct S_DPF p0, int p1, struct S_DPF p2,  struct S_DPF (*cb)(struct S_DPF, int, struct S_DPF)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPD f17_S_SIS_DPD(struct S_DPD p0, int p1, struct S_DPD p2,  struct S_DPD (*cb)(struct S_DPD, int, struct S_DPD)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPP f17_S_SIS_DPP(struct S_DPP p0, int p1, struct S_DPP p2,  struct S_DPP (*cb)(struct S_DPP, int, struct S_DPP)) { return cb(p0,p1,p2); }
+EXPORT struct S_PII f17_S_SIS_PII(struct S_PII p0, int p1, struct S_PII p2,  struct S_PII (*cb)(struct S_PII, int, struct S_PII)) { return cb(p0,p1,p2); }
+EXPORT struct S_PIF f17_S_SIS_PIF(struct S_PIF p0, int p1, struct S_PIF p2,  struct S_PIF (*cb)(struct S_PIF, int, struct S_PIF)) { return cb(p0,p1,p2); }
+EXPORT struct S_PID f17_S_SIS_PID(struct S_PID p0, int p1, struct S_PID p2,  struct S_PID (*cb)(struct S_PID, int, struct S_PID)) { return cb(p0,p1,p2); }
+EXPORT struct S_PIP f17_S_SIS_PIP(struct S_PIP p0, int p1, struct S_PIP p2,  struct S_PIP (*cb)(struct S_PIP, int, struct S_PIP)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFI f17_S_SIS_PFI(struct S_PFI p0, int p1, struct S_PFI p2,  struct S_PFI (*cb)(struct S_PFI, int, struct S_PFI)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFF f17_S_SIS_PFF(struct S_PFF p0, int p1, struct S_PFF p2,  struct S_PFF (*cb)(struct S_PFF, int, struct S_PFF)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFD f17_S_SIS_PFD(struct S_PFD p0, int p1, struct S_PFD p2,  struct S_PFD (*cb)(struct S_PFD, int, struct S_PFD)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFP f17_S_SIS_PFP(struct S_PFP p0, int p1, struct S_PFP p2,  struct S_PFP (*cb)(struct S_PFP, int, struct S_PFP)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDI f17_S_SIS_PDI(struct S_PDI p0, int p1, struct S_PDI p2,  struct S_PDI (*cb)(struct S_PDI, int, struct S_PDI)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDF f17_S_SIS_PDF(struct S_PDF p0, int p1, struct S_PDF p2,  struct S_PDF (*cb)(struct S_PDF, int, struct S_PDF)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDD f17_S_SIS_PDD(struct S_PDD p0, int p1, struct S_PDD p2,  struct S_PDD (*cb)(struct S_PDD, int, struct S_PDD)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDP f17_S_SIS_PDP(struct S_PDP p0, int p1, struct S_PDP p2,  struct S_PDP (*cb)(struct S_PDP, int, struct S_PDP)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPI f17_S_SIS_PPI(struct S_PPI p0, int p1, struct S_PPI p2,  struct S_PPI (*cb)(struct S_PPI, int, struct S_PPI)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPF f17_S_SIS_PPF(struct S_PPF p0, int p1, struct S_PPF p2,  struct S_PPF (*cb)(struct S_PPF, int, struct S_PPF)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPD f17_S_SIS_PPD(struct S_PPD p0, int p1, struct S_PPD p2,  struct S_PPD (*cb)(struct S_PPD, int, struct S_PPD)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPP f17_S_SIS_PPP(struct S_PPP p0, int p1, struct S_PPP p2,  struct S_PPP (*cb)(struct S_PPP, int, struct S_PPP)) { return cb(p0,p1,p2); }
+EXPORT struct S_I f17_S_SFI_I(struct S_I p0, float p1, int p2,  struct S_I (*cb)(struct S_I, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_F f17_S_SFI_F(struct S_F p0, float p1, int p2,  struct S_F (*cb)(struct S_F, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_D f17_S_SFI_D(struct S_D p0, float p1, int p2,  struct S_D (*cb)(struct S_D, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_P f17_S_SFI_P(struct S_P p0, float p1, int p2,  struct S_P (*cb)(struct S_P, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_II f17_S_SFI_II(struct S_II p0, float p1, int p2,  struct S_II (*cb)(struct S_II, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IF f17_S_SFI_IF(struct S_IF p0, float p1, int p2,  struct S_IF (*cb)(struct S_IF, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_ID f17_S_SFI_ID(struct S_ID p0, float p1, int p2,  struct S_ID (*cb)(struct S_ID, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IP f17_S_SFI_IP(struct S_IP p0, float p1, int p2,  struct S_IP (*cb)(struct S_IP, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FI f17_S_SFI_FI(struct S_FI p0, float p1, int p2,  struct S_FI (*cb)(struct S_FI, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FF f17_S_SFI_FF(struct S_FF p0, float p1, int p2,  struct S_FF (*cb)(struct S_FF, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FD f17_S_SFI_FD(struct S_FD p0, float p1, int p2,  struct S_FD (*cb)(struct S_FD, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FP f17_S_SFI_FP(struct S_FP p0, float p1, int p2,  struct S_FP (*cb)(struct S_FP, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DI f17_S_SFI_DI(struct S_DI p0, float p1, int p2,  struct S_DI (*cb)(struct S_DI, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DF f17_S_SFI_DF(struct S_DF p0, float p1, int p2,  struct S_DF (*cb)(struct S_DF, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DD f17_S_SFI_DD(struct S_DD p0, float p1, int p2,  struct S_DD (*cb)(struct S_DD, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DP f17_S_SFI_DP(struct S_DP p0, float p1, int p2,  struct S_DP (*cb)(struct S_DP, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PI f17_S_SFI_PI(struct S_PI p0, float p1, int p2,  struct S_PI (*cb)(struct S_PI, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PF f17_S_SFI_PF(struct S_PF p0, float p1, int p2,  struct S_PF (*cb)(struct S_PF, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PD f17_S_SFI_PD(struct S_PD p0, float p1, int p2,  struct S_PD (*cb)(struct S_PD, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PP f17_S_SFI_PP(struct S_PP p0, float p1, int p2,  struct S_PP (*cb)(struct S_PP, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_III f17_S_SFI_III(struct S_III p0, float p1, int p2,  struct S_III (*cb)(struct S_III, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IIF f17_S_SFI_IIF(struct S_IIF p0, float p1, int p2,  struct S_IIF (*cb)(struct S_IIF, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IID f17_S_SFI_IID(struct S_IID p0, float p1, int p2,  struct S_IID (*cb)(struct S_IID, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IIP f17_S_SFI_IIP(struct S_IIP p0, float p1, int p2,  struct S_IIP (*cb)(struct S_IIP, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFI f17_S_SFI_IFI(struct S_IFI p0, float p1, int p2,  struct S_IFI (*cb)(struct S_IFI, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFF f17_S_SFI_IFF(struct S_IFF p0, float p1, int p2,  struct S_IFF (*cb)(struct S_IFF, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFD f17_S_SFI_IFD(struct S_IFD p0, float p1, int p2,  struct S_IFD (*cb)(struct S_IFD, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFP f17_S_SFI_IFP(struct S_IFP p0, float p1, int p2,  struct S_IFP (*cb)(struct S_IFP, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDI f17_S_SFI_IDI(struct S_IDI p0, float p1, int p2,  struct S_IDI (*cb)(struct S_IDI, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDF f17_S_SFI_IDF(struct S_IDF p0, float p1, int p2,  struct S_IDF (*cb)(struct S_IDF, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDD f17_S_SFI_IDD(struct S_IDD p0, float p1, int p2,  struct S_IDD (*cb)(struct S_IDD, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDP f17_S_SFI_IDP(struct S_IDP p0, float p1, int p2,  struct S_IDP (*cb)(struct S_IDP, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPI f17_S_SFI_IPI(struct S_IPI p0, float p1, int p2,  struct S_IPI (*cb)(struct S_IPI, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPF f17_S_SFI_IPF(struct S_IPF p0, float p1, int p2,  struct S_IPF (*cb)(struct S_IPF, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPD f17_S_SFI_IPD(struct S_IPD p0, float p1, int p2,  struct S_IPD (*cb)(struct S_IPD, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPP f17_S_SFI_IPP(struct S_IPP p0, float p1, int p2,  struct S_IPP (*cb)(struct S_IPP, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FII f17_S_SFI_FII(struct S_FII p0, float p1, int p2,  struct S_FII (*cb)(struct S_FII, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FIF f17_S_SFI_FIF(struct S_FIF p0, float p1, int p2,  struct S_FIF (*cb)(struct S_FIF, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FID f17_S_SFI_FID(struct S_FID p0, float p1, int p2,  struct S_FID (*cb)(struct S_FID, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FIP f17_S_SFI_FIP(struct S_FIP p0, float p1, int p2,  struct S_FIP (*cb)(struct S_FIP, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFI f17_S_SFI_FFI(struct S_FFI p0, float p1, int p2,  struct S_FFI (*cb)(struct S_FFI, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFF f17_S_SFI_FFF(struct S_FFF p0, float p1, int p2,  struct S_FFF (*cb)(struct S_FFF, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFD f17_S_SFI_FFD(struct S_FFD p0, float p1, int p2,  struct S_FFD (*cb)(struct S_FFD, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFP f17_S_SFI_FFP(struct S_FFP p0, float p1, int p2,  struct S_FFP (*cb)(struct S_FFP, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDI f17_S_SFI_FDI(struct S_FDI p0, float p1, int p2,  struct S_FDI (*cb)(struct S_FDI, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDF f17_S_SFI_FDF(struct S_FDF p0, float p1, int p2,  struct S_FDF (*cb)(struct S_FDF, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDD f17_S_SFI_FDD(struct S_FDD p0, float p1, int p2,  struct S_FDD (*cb)(struct S_FDD, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDP f17_S_SFI_FDP(struct S_FDP p0, float p1, int p2,  struct S_FDP (*cb)(struct S_FDP, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPI f17_S_SFI_FPI(struct S_FPI p0, float p1, int p2,  struct S_FPI (*cb)(struct S_FPI, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPF f17_S_SFI_FPF(struct S_FPF p0, float p1, int p2,  struct S_FPF (*cb)(struct S_FPF, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPD f17_S_SFI_FPD(struct S_FPD p0, float p1, int p2,  struct S_FPD (*cb)(struct S_FPD, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPP f17_S_SFI_FPP(struct S_FPP p0, float p1, int p2,  struct S_FPP (*cb)(struct S_FPP, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DII f17_S_SFI_DII(struct S_DII p0, float p1, int p2,  struct S_DII (*cb)(struct S_DII, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DIF f17_S_SFI_DIF(struct S_DIF p0, float p1, int p2,  struct S_DIF (*cb)(struct S_DIF, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DID f17_S_SFI_DID(struct S_DID p0, float p1, int p2,  struct S_DID (*cb)(struct S_DID, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DIP f17_S_SFI_DIP(struct S_DIP p0, float p1, int p2,  struct S_DIP (*cb)(struct S_DIP, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFI f17_S_SFI_DFI(struct S_DFI p0, float p1, int p2,  struct S_DFI (*cb)(struct S_DFI, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFF f17_S_SFI_DFF(struct S_DFF p0, float p1, int p2,  struct S_DFF (*cb)(struct S_DFF, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFD f17_S_SFI_DFD(struct S_DFD p0, float p1, int p2,  struct S_DFD (*cb)(struct S_DFD, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFP f17_S_SFI_DFP(struct S_DFP p0, float p1, int p2,  struct S_DFP (*cb)(struct S_DFP, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDI f17_S_SFI_DDI(struct S_DDI p0, float p1, int p2,  struct S_DDI (*cb)(struct S_DDI, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDF f17_S_SFI_DDF(struct S_DDF p0, float p1, int p2,  struct S_DDF (*cb)(struct S_DDF, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDD f17_S_SFI_DDD(struct S_DDD p0, float p1, int p2,  struct S_DDD (*cb)(struct S_DDD, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDP f17_S_SFI_DDP(struct S_DDP p0, float p1, int p2,  struct S_DDP (*cb)(struct S_DDP, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPI f17_S_SFI_DPI(struct S_DPI p0, float p1, int p2,  struct S_DPI (*cb)(struct S_DPI, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPF f17_S_SFI_DPF(struct S_DPF p0, float p1, int p2,  struct S_DPF (*cb)(struct S_DPF, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPD f17_S_SFI_DPD(struct S_DPD p0, float p1, int p2,  struct S_DPD (*cb)(struct S_DPD, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPP f17_S_SFI_DPP(struct S_DPP p0, float p1, int p2,  struct S_DPP (*cb)(struct S_DPP, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PII f17_S_SFI_PII(struct S_PII p0, float p1, int p2,  struct S_PII (*cb)(struct S_PII, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PIF f17_S_SFI_PIF(struct S_PIF p0, float p1, int p2,  struct S_PIF (*cb)(struct S_PIF, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PID f17_S_SFI_PID(struct S_PID p0, float p1, int p2,  struct S_PID (*cb)(struct S_PID, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PIP f17_S_SFI_PIP(struct S_PIP p0, float p1, int p2,  struct S_PIP (*cb)(struct S_PIP, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFI f17_S_SFI_PFI(struct S_PFI p0, float p1, int p2,  struct S_PFI (*cb)(struct S_PFI, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFF f17_S_SFI_PFF(struct S_PFF p0, float p1, int p2,  struct S_PFF (*cb)(struct S_PFF, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFD f17_S_SFI_PFD(struct S_PFD p0, float p1, int p2,  struct S_PFD (*cb)(struct S_PFD, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFP f17_S_SFI_PFP(struct S_PFP p0, float p1, int p2,  struct S_PFP (*cb)(struct S_PFP, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDI f17_S_SFI_PDI(struct S_PDI p0, float p1, int p2,  struct S_PDI (*cb)(struct S_PDI, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDF f17_S_SFI_PDF(struct S_PDF p0, float p1, int p2,  struct S_PDF (*cb)(struct S_PDF, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDD f17_S_SFI_PDD(struct S_PDD p0, float p1, int p2,  struct S_PDD (*cb)(struct S_PDD, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDP f17_S_SFI_PDP(struct S_PDP p0, float p1, int p2,  struct S_PDP (*cb)(struct S_PDP, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPI f17_S_SFI_PPI(struct S_PPI p0, float p1, int p2,  struct S_PPI (*cb)(struct S_PPI, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPF f17_S_SFI_PPF(struct S_PPF p0, float p1, int p2,  struct S_PPF (*cb)(struct S_PPF, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPD f17_S_SFI_PPD(struct S_PPD p0, float p1, int p2,  struct S_PPD (*cb)(struct S_PPD, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPP f17_S_SFI_PPP(struct S_PPP p0, float p1, int p2,  struct S_PPP (*cb)(struct S_PPP, float, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_I f17_S_SFF_I(struct S_I p0, float p1, float p2,  struct S_I (*cb)(struct S_I, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_F f17_S_SFF_F(struct S_F p0, float p1, float p2,  struct S_F (*cb)(struct S_F, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_D f17_S_SFF_D(struct S_D p0, float p1, float p2,  struct S_D (*cb)(struct S_D, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_P f17_S_SFF_P(struct S_P p0, float p1, float p2,  struct S_P (*cb)(struct S_P, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_II f17_S_SFF_II(struct S_II p0, float p1, float p2,  struct S_II (*cb)(struct S_II, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IF f17_S_SFF_IF(struct S_IF p0, float p1, float p2,  struct S_IF (*cb)(struct S_IF, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_ID f17_S_SFF_ID(struct S_ID p0, float p1, float p2,  struct S_ID (*cb)(struct S_ID, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IP f17_S_SFF_IP(struct S_IP p0, float p1, float p2,  struct S_IP (*cb)(struct S_IP, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FI f17_S_SFF_FI(struct S_FI p0, float p1, float p2,  struct S_FI (*cb)(struct S_FI, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FF f17_S_SFF_FF(struct S_FF p0, float p1, float p2,  struct S_FF (*cb)(struct S_FF, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FD f17_S_SFF_FD(struct S_FD p0, float p1, float p2,  struct S_FD (*cb)(struct S_FD, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FP f17_S_SFF_FP(struct S_FP p0, float p1, float p2,  struct S_FP (*cb)(struct S_FP, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DI f17_S_SFF_DI(struct S_DI p0, float p1, float p2,  struct S_DI (*cb)(struct S_DI, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DF f17_S_SFF_DF(struct S_DF p0, float p1, float p2,  struct S_DF (*cb)(struct S_DF, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DD f17_S_SFF_DD(struct S_DD p0, float p1, float p2,  struct S_DD (*cb)(struct S_DD, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DP f17_S_SFF_DP(struct S_DP p0, float p1, float p2,  struct S_DP (*cb)(struct S_DP, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PI f17_S_SFF_PI(struct S_PI p0, float p1, float p2,  struct S_PI (*cb)(struct S_PI, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PF f17_S_SFF_PF(struct S_PF p0, float p1, float p2,  struct S_PF (*cb)(struct S_PF, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PD f17_S_SFF_PD(struct S_PD p0, float p1, float p2,  struct S_PD (*cb)(struct S_PD, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PP f17_S_SFF_PP(struct S_PP p0, float p1, float p2,  struct S_PP (*cb)(struct S_PP, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_III f17_S_SFF_III(struct S_III p0, float p1, float p2,  struct S_III (*cb)(struct S_III, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IIF f17_S_SFF_IIF(struct S_IIF p0, float p1, float p2,  struct S_IIF (*cb)(struct S_IIF, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IID f17_S_SFF_IID(struct S_IID p0, float p1, float p2,  struct S_IID (*cb)(struct S_IID, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IIP f17_S_SFF_IIP(struct S_IIP p0, float p1, float p2,  struct S_IIP (*cb)(struct S_IIP, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFI f17_S_SFF_IFI(struct S_IFI p0, float p1, float p2,  struct S_IFI (*cb)(struct S_IFI, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFF f17_S_SFF_IFF(struct S_IFF p0, float p1, float p2,  struct S_IFF (*cb)(struct S_IFF, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFD f17_S_SFF_IFD(struct S_IFD p0, float p1, float p2,  struct S_IFD (*cb)(struct S_IFD, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFP f17_S_SFF_IFP(struct S_IFP p0, float p1, float p2,  struct S_IFP (*cb)(struct S_IFP, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDI f17_S_SFF_IDI(struct S_IDI p0, float p1, float p2,  struct S_IDI (*cb)(struct S_IDI, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDF f17_S_SFF_IDF(struct S_IDF p0, float p1, float p2,  struct S_IDF (*cb)(struct S_IDF, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDD f17_S_SFF_IDD(struct S_IDD p0, float p1, float p2,  struct S_IDD (*cb)(struct S_IDD, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDP f17_S_SFF_IDP(struct S_IDP p0, float p1, float p2,  struct S_IDP (*cb)(struct S_IDP, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPI f17_S_SFF_IPI(struct S_IPI p0, float p1, float p2,  struct S_IPI (*cb)(struct S_IPI, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPF f17_S_SFF_IPF(struct S_IPF p0, float p1, float p2,  struct S_IPF (*cb)(struct S_IPF, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPD f17_S_SFF_IPD(struct S_IPD p0, float p1, float p2,  struct S_IPD (*cb)(struct S_IPD, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPP f17_S_SFF_IPP(struct S_IPP p0, float p1, float p2,  struct S_IPP (*cb)(struct S_IPP, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FII f17_S_SFF_FII(struct S_FII p0, float p1, float p2,  struct S_FII (*cb)(struct S_FII, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FIF f17_S_SFF_FIF(struct S_FIF p0, float p1, float p2,  struct S_FIF (*cb)(struct S_FIF, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FID f17_S_SFF_FID(struct S_FID p0, float p1, float p2,  struct S_FID (*cb)(struct S_FID, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FIP f17_S_SFF_FIP(struct S_FIP p0, float p1, float p2,  struct S_FIP (*cb)(struct S_FIP, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFI f17_S_SFF_FFI(struct S_FFI p0, float p1, float p2,  struct S_FFI (*cb)(struct S_FFI, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFF f17_S_SFF_FFF(struct S_FFF p0, float p1, float p2,  struct S_FFF (*cb)(struct S_FFF, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFD f17_S_SFF_FFD(struct S_FFD p0, float p1, float p2,  struct S_FFD (*cb)(struct S_FFD, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFP f17_S_SFF_FFP(struct S_FFP p0, float p1, float p2,  struct S_FFP (*cb)(struct S_FFP, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDI f17_S_SFF_FDI(struct S_FDI p0, float p1, float p2,  struct S_FDI (*cb)(struct S_FDI, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDF f17_S_SFF_FDF(struct S_FDF p0, float p1, float p2,  struct S_FDF (*cb)(struct S_FDF, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDD f17_S_SFF_FDD(struct S_FDD p0, float p1, float p2,  struct S_FDD (*cb)(struct S_FDD, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDP f17_S_SFF_FDP(struct S_FDP p0, float p1, float p2,  struct S_FDP (*cb)(struct S_FDP, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPI f17_S_SFF_FPI(struct S_FPI p0, float p1, float p2,  struct S_FPI (*cb)(struct S_FPI, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPF f17_S_SFF_FPF(struct S_FPF p0, float p1, float p2,  struct S_FPF (*cb)(struct S_FPF, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPD f17_S_SFF_FPD(struct S_FPD p0, float p1, float p2,  struct S_FPD (*cb)(struct S_FPD, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPP f17_S_SFF_FPP(struct S_FPP p0, float p1, float p2,  struct S_FPP (*cb)(struct S_FPP, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DII f17_S_SFF_DII(struct S_DII p0, float p1, float p2,  struct S_DII (*cb)(struct S_DII, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DIF f17_S_SFF_DIF(struct S_DIF p0, float p1, float p2,  struct S_DIF (*cb)(struct S_DIF, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DID f17_S_SFF_DID(struct S_DID p0, float p1, float p2,  struct S_DID (*cb)(struct S_DID, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DIP f17_S_SFF_DIP(struct S_DIP p0, float p1, float p2,  struct S_DIP (*cb)(struct S_DIP, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFI f17_S_SFF_DFI(struct S_DFI p0, float p1, float p2,  struct S_DFI (*cb)(struct S_DFI, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFF f17_S_SFF_DFF(struct S_DFF p0, float p1, float p2,  struct S_DFF (*cb)(struct S_DFF, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFD f17_S_SFF_DFD(struct S_DFD p0, float p1, float p2,  struct S_DFD (*cb)(struct S_DFD, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFP f17_S_SFF_DFP(struct S_DFP p0, float p1, float p2,  struct S_DFP (*cb)(struct S_DFP, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDI f17_S_SFF_DDI(struct S_DDI p0, float p1, float p2,  struct S_DDI (*cb)(struct S_DDI, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDF f17_S_SFF_DDF(struct S_DDF p0, float p1, float p2,  struct S_DDF (*cb)(struct S_DDF, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDD f17_S_SFF_DDD(struct S_DDD p0, float p1, float p2,  struct S_DDD (*cb)(struct S_DDD, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDP f17_S_SFF_DDP(struct S_DDP p0, float p1, float p2,  struct S_DDP (*cb)(struct S_DDP, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPI f17_S_SFF_DPI(struct S_DPI p0, float p1, float p2,  struct S_DPI (*cb)(struct S_DPI, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPF f17_S_SFF_DPF(struct S_DPF p0, float p1, float p2,  struct S_DPF (*cb)(struct S_DPF, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPD f17_S_SFF_DPD(struct S_DPD p0, float p1, float p2,  struct S_DPD (*cb)(struct S_DPD, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPP f17_S_SFF_DPP(struct S_DPP p0, float p1, float p2,  struct S_DPP (*cb)(struct S_DPP, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PII f17_S_SFF_PII(struct S_PII p0, float p1, float p2,  struct S_PII (*cb)(struct S_PII, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PIF f17_S_SFF_PIF(struct S_PIF p0, float p1, float p2,  struct S_PIF (*cb)(struct S_PIF, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PID f17_S_SFF_PID(struct S_PID p0, float p1, float p2,  struct S_PID (*cb)(struct S_PID, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PIP f17_S_SFF_PIP(struct S_PIP p0, float p1, float p2,  struct S_PIP (*cb)(struct S_PIP, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFI f17_S_SFF_PFI(struct S_PFI p0, float p1, float p2,  struct S_PFI (*cb)(struct S_PFI, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFF f17_S_SFF_PFF(struct S_PFF p0, float p1, float p2,  struct S_PFF (*cb)(struct S_PFF, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFD f17_S_SFF_PFD(struct S_PFD p0, float p1, float p2,  struct S_PFD (*cb)(struct S_PFD, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFP f17_S_SFF_PFP(struct S_PFP p0, float p1, float p2,  struct S_PFP (*cb)(struct S_PFP, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDI f17_S_SFF_PDI(struct S_PDI p0, float p1, float p2,  struct S_PDI (*cb)(struct S_PDI, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDF f17_S_SFF_PDF(struct S_PDF p0, float p1, float p2,  struct S_PDF (*cb)(struct S_PDF, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDD f17_S_SFF_PDD(struct S_PDD p0, float p1, float p2,  struct S_PDD (*cb)(struct S_PDD, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDP f17_S_SFF_PDP(struct S_PDP p0, float p1, float p2,  struct S_PDP (*cb)(struct S_PDP, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPI f17_S_SFF_PPI(struct S_PPI p0, float p1, float p2,  struct S_PPI (*cb)(struct S_PPI, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPF f17_S_SFF_PPF(struct S_PPF p0, float p1, float p2,  struct S_PPF (*cb)(struct S_PPF, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPD f17_S_SFF_PPD(struct S_PPD p0, float p1, float p2,  struct S_PPD (*cb)(struct S_PPD, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPP f17_S_SFF_PPP(struct S_PPP p0, float p1, float p2,  struct S_PPP (*cb)(struct S_PPP, float, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_I f17_S_SFD_I(struct S_I p0, float p1, double p2,  struct S_I (*cb)(struct S_I, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_F f17_S_SFD_F(struct S_F p0, float p1, double p2,  struct S_F (*cb)(struct S_F, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_D f17_S_SFD_D(struct S_D p0, float p1, double p2,  struct S_D (*cb)(struct S_D, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_P f17_S_SFD_P(struct S_P p0, float p1, double p2,  struct S_P (*cb)(struct S_P, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_II f17_S_SFD_II(struct S_II p0, float p1, double p2,  struct S_II (*cb)(struct S_II, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IF f17_S_SFD_IF(struct S_IF p0, float p1, double p2,  struct S_IF (*cb)(struct S_IF, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_ID f17_S_SFD_ID(struct S_ID p0, float p1, double p2,  struct S_ID (*cb)(struct S_ID, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IP f17_S_SFD_IP(struct S_IP p0, float p1, double p2,  struct S_IP (*cb)(struct S_IP, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FI f17_S_SFD_FI(struct S_FI p0, float p1, double p2,  struct S_FI (*cb)(struct S_FI, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FF f17_S_SFD_FF(struct S_FF p0, float p1, double p2,  struct S_FF (*cb)(struct S_FF, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FD f17_S_SFD_FD(struct S_FD p0, float p1, double p2,  struct S_FD (*cb)(struct S_FD, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FP f17_S_SFD_FP(struct S_FP p0, float p1, double p2,  struct S_FP (*cb)(struct S_FP, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DI f17_S_SFD_DI(struct S_DI p0, float p1, double p2,  struct S_DI (*cb)(struct S_DI, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DF f17_S_SFD_DF(struct S_DF p0, float p1, double p2,  struct S_DF (*cb)(struct S_DF, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DD f17_S_SFD_DD(struct S_DD p0, float p1, double p2,  struct S_DD (*cb)(struct S_DD, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DP f17_S_SFD_DP(struct S_DP p0, float p1, double p2,  struct S_DP (*cb)(struct S_DP, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PI f17_S_SFD_PI(struct S_PI p0, float p1, double p2,  struct S_PI (*cb)(struct S_PI, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PF f17_S_SFD_PF(struct S_PF p0, float p1, double p2,  struct S_PF (*cb)(struct S_PF, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PD f17_S_SFD_PD(struct S_PD p0, float p1, double p2,  struct S_PD (*cb)(struct S_PD, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PP f17_S_SFD_PP(struct S_PP p0, float p1, double p2,  struct S_PP (*cb)(struct S_PP, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_III f17_S_SFD_III(struct S_III p0, float p1, double p2,  struct S_III (*cb)(struct S_III, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IIF f17_S_SFD_IIF(struct S_IIF p0, float p1, double p2,  struct S_IIF (*cb)(struct S_IIF, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IID f17_S_SFD_IID(struct S_IID p0, float p1, double p2,  struct S_IID (*cb)(struct S_IID, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IIP f17_S_SFD_IIP(struct S_IIP p0, float p1, double p2,  struct S_IIP (*cb)(struct S_IIP, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFI f17_S_SFD_IFI(struct S_IFI p0, float p1, double p2,  struct S_IFI (*cb)(struct S_IFI, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFF f17_S_SFD_IFF(struct S_IFF p0, float p1, double p2,  struct S_IFF (*cb)(struct S_IFF, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFD f17_S_SFD_IFD(struct S_IFD p0, float p1, double p2,  struct S_IFD (*cb)(struct S_IFD, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFP f17_S_SFD_IFP(struct S_IFP p0, float p1, double p2,  struct S_IFP (*cb)(struct S_IFP, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDI f17_S_SFD_IDI(struct S_IDI p0, float p1, double p2,  struct S_IDI (*cb)(struct S_IDI, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDF f17_S_SFD_IDF(struct S_IDF p0, float p1, double p2,  struct S_IDF (*cb)(struct S_IDF, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDD f17_S_SFD_IDD(struct S_IDD p0, float p1, double p2,  struct S_IDD (*cb)(struct S_IDD, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDP f17_S_SFD_IDP(struct S_IDP p0, float p1, double p2,  struct S_IDP (*cb)(struct S_IDP, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPI f17_S_SFD_IPI(struct S_IPI p0, float p1, double p2,  struct S_IPI (*cb)(struct S_IPI, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPF f17_S_SFD_IPF(struct S_IPF p0, float p1, double p2,  struct S_IPF (*cb)(struct S_IPF, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPD f17_S_SFD_IPD(struct S_IPD p0, float p1, double p2,  struct S_IPD (*cb)(struct S_IPD, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPP f17_S_SFD_IPP(struct S_IPP p0, float p1, double p2,  struct S_IPP (*cb)(struct S_IPP, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FII f17_S_SFD_FII(struct S_FII p0, float p1, double p2,  struct S_FII (*cb)(struct S_FII, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FIF f17_S_SFD_FIF(struct S_FIF p0, float p1, double p2,  struct S_FIF (*cb)(struct S_FIF, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FID f17_S_SFD_FID(struct S_FID p0, float p1, double p2,  struct S_FID (*cb)(struct S_FID, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FIP f17_S_SFD_FIP(struct S_FIP p0, float p1, double p2,  struct S_FIP (*cb)(struct S_FIP, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFI f17_S_SFD_FFI(struct S_FFI p0, float p1, double p2,  struct S_FFI (*cb)(struct S_FFI, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFF f17_S_SFD_FFF(struct S_FFF p0, float p1, double p2,  struct S_FFF (*cb)(struct S_FFF, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFD f17_S_SFD_FFD(struct S_FFD p0, float p1, double p2,  struct S_FFD (*cb)(struct S_FFD, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFP f17_S_SFD_FFP(struct S_FFP p0, float p1, double p2,  struct S_FFP (*cb)(struct S_FFP, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDI f17_S_SFD_FDI(struct S_FDI p0, float p1, double p2,  struct S_FDI (*cb)(struct S_FDI, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDF f17_S_SFD_FDF(struct S_FDF p0, float p1, double p2,  struct S_FDF (*cb)(struct S_FDF, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDD f17_S_SFD_FDD(struct S_FDD p0, float p1, double p2,  struct S_FDD (*cb)(struct S_FDD, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDP f17_S_SFD_FDP(struct S_FDP p0, float p1, double p2,  struct S_FDP (*cb)(struct S_FDP, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPI f17_S_SFD_FPI(struct S_FPI p0, float p1, double p2,  struct S_FPI (*cb)(struct S_FPI, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPF f17_S_SFD_FPF(struct S_FPF p0, float p1, double p2,  struct S_FPF (*cb)(struct S_FPF, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPD f17_S_SFD_FPD(struct S_FPD p0, float p1, double p2,  struct S_FPD (*cb)(struct S_FPD, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPP f17_S_SFD_FPP(struct S_FPP p0, float p1, double p2,  struct S_FPP (*cb)(struct S_FPP, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DII f17_S_SFD_DII(struct S_DII p0, float p1, double p2,  struct S_DII (*cb)(struct S_DII, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DIF f17_S_SFD_DIF(struct S_DIF p0, float p1, double p2,  struct S_DIF (*cb)(struct S_DIF, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DID f17_S_SFD_DID(struct S_DID p0, float p1, double p2,  struct S_DID (*cb)(struct S_DID, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DIP f17_S_SFD_DIP(struct S_DIP p0, float p1, double p2,  struct S_DIP (*cb)(struct S_DIP, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFI f17_S_SFD_DFI(struct S_DFI p0, float p1, double p2,  struct S_DFI (*cb)(struct S_DFI, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFF f17_S_SFD_DFF(struct S_DFF p0, float p1, double p2,  struct S_DFF (*cb)(struct S_DFF, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFD f17_S_SFD_DFD(struct S_DFD p0, float p1, double p2,  struct S_DFD (*cb)(struct S_DFD, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFP f17_S_SFD_DFP(struct S_DFP p0, float p1, double p2,  struct S_DFP (*cb)(struct S_DFP, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDI f17_S_SFD_DDI(struct S_DDI p0, float p1, double p2,  struct S_DDI (*cb)(struct S_DDI, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDF f17_S_SFD_DDF(struct S_DDF p0, float p1, double p2,  struct S_DDF (*cb)(struct S_DDF, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDD f17_S_SFD_DDD(struct S_DDD p0, float p1, double p2,  struct S_DDD (*cb)(struct S_DDD, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDP f17_S_SFD_DDP(struct S_DDP p0, float p1, double p2,  struct S_DDP (*cb)(struct S_DDP, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPI f17_S_SFD_DPI(struct S_DPI p0, float p1, double p2,  struct S_DPI (*cb)(struct S_DPI, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPF f17_S_SFD_DPF(struct S_DPF p0, float p1, double p2,  struct S_DPF (*cb)(struct S_DPF, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPD f17_S_SFD_DPD(struct S_DPD p0, float p1, double p2,  struct S_DPD (*cb)(struct S_DPD, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPP f17_S_SFD_DPP(struct S_DPP p0, float p1, double p2,  struct S_DPP (*cb)(struct S_DPP, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PII f17_S_SFD_PII(struct S_PII p0, float p1, double p2,  struct S_PII (*cb)(struct S_PII, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PIF f17_S_SFD_PIF(struct S_PIF p0, float p1, double p2,  struct S_PIF (*cb)(struct S_PIF, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PID f17_S_SFD_PID(struct S_PID p0, float p1, double p2,  struct S_PID (*cb)(struct S_PID, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PIP f17_S_SFD_PIP(struct S_PIP p0, float p1, double p2,  struct S_PIP (*cb)(struct S_PIP, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFI f17_S_SFD_PFI(struct S_PFI p0, float p1, double p2,  struct S_PFI (*cb)(struct S_PFI, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFF f17_S_SFD_PFF(struct S_PFF p0, float p1, double p2,  struct S_PFF (*cb)(struct S_PFF, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFD f17_S_SFD_PFD(struct S_PFD p0, float p1, double p2,  struct S_PFD (*cb)(struct S_PFD, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFP f17_S_SFD_PFP(struct S_PFP p0, float p1, double p2,  struct S_PFP (*cb)(struct S_PFP, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDI f17_S_SFD_PDI(struct S_PDI p0, float p1, double p2,  struct S_PDI (*cb)(struct S_PDI, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDF f17_S_SFD_PDF(struct S_PDF p0, float p1, double p2,  struct S_PDF (*cb)(struct S_PDF, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDD f17_S_SFD_PDD(struct S_PDD p0, float p1, double p2,  struct S_PDD (*cb)(struct S_PDD, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDP f17_S_SFD_PDP(struct S_PDP p0, float p1, double p2,  struct S_PDP (*cb)(struct S_PDP, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPI f17_S_SFD_PPI(struct S_PPI p0, float p1, double p2,  struct S_PPI (*cb)(struct S_PPI, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPF f17_S_SFD_PPF(struct S_PPF p0, float p1, double p2,  struct S_PPF (*cb)(struct S_PPF, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPD f17_S_SFD_PPD(struct S_PPD p0, float p1, double p2,  struct S_PPD (*cb)(struct S_PPD, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPP f17_S_SFD_PPP(struct S_PPP p0, float p1, double p2,  struct S_PPP (*cb)(struct S_PPP, float, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_I f17_S_SFP_I(struct S_I p0, float p1, void* p2,  struct S_I (*cb)(struct S_I, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_F f17_S_SFP_F(struct S_F p0, float p1, void* p2,  struct S_F (*cb)(struct S_F, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_D f17_S_SFP_D(struct S_D p0, float p1, void* p2,  struct S_D (*cb)(struct S_D, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_P f17_S_SFP_P(struct S_P p0, float p1, void* p2,  struct S_P (*cb)(struct S_P, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_II f17_S_SFP_II(struct S_II p0, float p1, void* p2,  struct S_II (*cb)(struct S_II, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IF f17_S_SFP_IF(struct S_IF p0, float p1, void* p2,  struct S_IF (*cb)(struct S_IF, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_ID f17_S_SFP_ID(struct S_ID p0, float p1, void* p2,  struct S_ID (*cb)(struct S_ID, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IP f17_S_SFP_IP(struct S_IP p0, float p1, void* p2,  struct S_IP (*cb)(struct S_IP, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FI f17_S_SFP_FI(struct S_FI p0, float p1, void* p2,  struct S_FI (*cb)(struct S_FI, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FF f17_S_SFP_FF(struct S_FF p0, float p1, void* p2,  struct S_FF (*cb)(struct S_FF, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FD f17_S_SFP_FD(struct S_FD p0, float p1, void* p2,  struct S_FD (*cb)(struct S_FD, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FP f17_S_SFP_FP(struct S_FP p0, float p1, void* p2,  struct S_FP (*cb)(struct S_FP, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DI f17_S_SFP_DI(struct S_DI p0, float p1, void* p2,  struct S_DI (*cb)(struct S_DI, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DF f17_S_SFP_DF(struct S_DF p0, float p1, void* p2,  struct S_DF (*cb)(struct S_DF, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DD f17_S_SFP_DD(struct S_DD p0, float p1, void* p2,  struct S_DD (*cb)(struct S_DD, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DP f17_S_SFP_DP(struct S_DP p0, float p1, void* p2,  struct S_DP (*cb)(struct S_DP, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PI f17_S_SFP_PI(struct S_PI p0, float p1, void* p2,  struct S_PI (*cb)(struct S_PI, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PF f17_S_SFP_PF(struct S_PF p0, float p1, void* p2,  struct S_PF (*cb)(struct S_PF, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PD f17_S_SFP_PD(struct S_PD p0, float p1, void* p2,  struct S_PD (*cb)(struct S_PD, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PP f17_S_SFP_PP(struct S_PP p0, float p1, void* p2,  struct S_PP (*cb)(struct S_PP, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_III f17_S_SFP_III(struct S_III p0, float p1, void* p2,  struct S_III (*cb)(struct S_III, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IIF f17_S_SFP_IIF(struct S_IIF p0, float p1, void* p2,  struct S_IIF (*cb)(struct S_IIF, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IID f17_S_SFP_IID(struct S_IID p0, float p1, void* p2,  struct S_IID (*cb)(struct S_IID, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IIP f17_S_SFP_IIP(struct S_IIP p0, float p1, void* p2,  struct S_IIP (*cb)(struct S_IIP, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFI f17_S_SFP_IFI(struct S_IFI p0, float p1, void* p2,  struct S_IFI (*cb)(struct S_IFI, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFF f17_S_SFP_IFF(struct S_IFF p0, float p1, void* p2,  struct S_IFF (*cb)(struct S_IFF, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFD f17_S_SFP_IFD(struct S_IFD p0, float p1, void* p2,  struct S_IFD (*cb)(struct S_IFD, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFP f17_S_SFP_IFP(struct S_IFP p0, float p1, void* p2,  struct S_IFP (*cb)(struct S_IFP, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDI f17_S_SFP_IDI(struct S_IDI p0, float p1, void* p2,  struct S_IDI (*cb)(struct S_IDI, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDF f17_S_SFP_IDF(struct S_IDF p0, float p1, void* p2,  struct S_IDF (*cb)(struct S_IDF, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDD f17_S_SFP_IDD(struct S_IDD p0, float p1, void* p2,  struct S_IDD (*cb)(struct S_IDD, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDP f17_S_SFP_IDP(struct S_IDP p0, float p1, void* p2,  struct S_IDP (*cb)(struct S_IDP, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPI f17_S_SFP_IPI(struct S_IPI p0, float p1, void* p2,  struct S_IPI (*cb)(struct S_IPI, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPF f17_S_SFP_IPF(struct S_IPF p0, float p1, void* p2,  struct S_IPF (*cb)(struct S_IPF, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPD f17_S_SFP_IPD(struct S_IPD p0, float p1, void* p2,  struct S_IPD (*cb)(struct S_IPD, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPP f17_S_SFP_IPP(struct S_IPP p0, float p1, void* p2,  struct S_IPP (*cb)(struct S_IPP, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FII f17_S_SFP_FII(struct S_FII p0, float p1, void* p2,  struct S_FII (*cb)(struct S_FII, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FIF f17_S_SFP_FIF(struct S_FIF p0, float p1, void* p2,  struct S_FIF (*cb)(struct S_FIF, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FID f17_S_SFP_FID(struct S_FID p0, float p1, void* p2,  struct S_FID (*cb)(struct S_FID, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FIP f17_S_SFP_FIP(struct S_FIP p0, float p1, void* p2,  struct S_FIP (*cb)(struct S_FIP, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFI f17_S_SFP_FFI(struct S_FFI p0, float p1, void* p2,  struct S_FFI (*cb)(struct S_FFI, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFF f17_S_SFP_FFF(struct S_FFF p0, float p1, void* p2,  struct S_FFF (*cb)(struct S_FFF, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFD f17_S_SFP_FFD(struct S_FFD p0, float p1, void* p2,  struct S_FFD (*cb)(struct S_FFD, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFP f17_S_SFP_FFP(struct S_FFP p0, float p1, void* p2,  struct S_FFP (*cb)(struct S_FFP, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDI f17_S_SFP_FDI(struct S_FDI p0, float p1, void* p2,  struct S_FDI (*cb)(struct S_FDI, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDF f17_S_SFP_FDF(struct S_FDF p0, float p1, void* p2,  struct S_FDF (*cb)(struct S_FDF, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDD f17_S_SFP_FDD(struct S_FDD p0, float p1, void* p2,  struct S_FDD (*cb)(struct S_FDD, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDP f17_S_SFP_FDP(struct S_FDP p0, float p1, void* p2,  struct S_FDP (*cb)(struct S_FDP, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPI f17_S_SFP_FPI(struct S_FPI p0, float p1, void* p2,  struct S_FPI (*cb)(struct S_FPI, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPF f17_S_SFP_FPF(struct S_FPF p0, float p1, void* p2,  struct S_FPF (*cb)(struct S_FPF, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPD f17_S_SFP_FPD(struct S_FPD p0, float p1, void* p2,  struct S_FPD (*cb)(struct S_FPD, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPP f17_S_SFP_FPP(struct S_FPP p0, float p1, void* p2,  struct S_FPP (*cb)(struct S_FPP, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DII f17_S_SFP_DII(struct S_DII p0, float p1, void* p2,  struct S_DII (*cb)(struct S_DII, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DIF f17_S_SFP_DIF(struct S_DIF p0, float p1, void* p2,  struct S_DIF (*cb)(struct S_DIF, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DID f17_S_SFP_DID(struct S_DID p0, float p1, void* p2,  struct S_DID (*cb)(struct S_DID, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DIP f17_S_SFP_DIP(struct S_DIP p0, float p1, void* p2,  struct S_DIP (*cb)(struct S_DIP, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFI f17_S_SFP_DFI(struct S_DFI p0, float p1, void* p2,  struct S_DFI (*cb)(struct S_DFI, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFF f17_S_SFP_DFF(struct S_DFF p0, float p1, void* p2,  struct S_DFF (*cb)(struct S_DFF, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFD f17_S_SFP_DFD(struct S_DFD p0, float p1, void* p2,  struct S_DFD (*cb)(struct S_DFD, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFP f17_S_SFP_DFP(struct S_DFP p0, float p1, void* p2,  struct S_DFP (*cb)(struct S_DFP, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDI f17_S_SFP_DDI(struct S_DDI p0, float p1, void* p2,  struct S_DDI (*cb)(struct S_DDI, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDF f17_S_SFP_DDF(struct S_DDF p0, float p1, void* p2,  struct S_DDF (*cb)(struct S_DDF, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDD f17_S_SFP_DDD(struct S_DDD p0, float p1, void* p2,  struct S_DDD (*cb)(struct S_DDD, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDP f17_S_SFP_DDP(struct S_DDP p0, float p1, void* p2,  struct S_DDP (*cb)(struct S_DDP, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPI f17_S_SFP_DPI(struct S_DPI p0, float p1, void* p2,  struct S_DPI (*cb)(struct S_DPI, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPF f17_S_SFP_DPF(struct S_DPF p0, float p1, void* p2,  struct S_DPF (*cb)(struct S_DPF, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPD f17_S_SFP_DPD(struct S_DPD p0, float p1, void* p2,  struct S_DPD (*cb)(struct S_DPD, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPP f17_S_SFP_DPP(struct S_DPP p0, float p1, void* p2,  struct S_DPP (*cb)(struct S_DPP, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PII f17_S_SFP_PII(struct S_PII p0, float p1, void* p2,  struct S_PII (*cb)(struct S_PII, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PIF f17_S_SFP_PIF(struct S_PIF p0, float p1, void* p2,  struct S_PIF (*cb)(struct S_PIF, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PID f17_S_SFP_PID(struct S_PID p0, float p1, void* p2,  struct S_PID (*cb)(struct S_PID, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PIP f17_S_SFP_PIP(struct S_PIP p0, float p1, void* p2,  struct S_PIP (*cb)(struct S_PIP, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFI f17_S_SFP_PFI(struct S_PFI p0, float p1, void* p2,  struct S_PFI (*cb)(struct S_PFI, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFF f17_S_SFP_PFF(struct S_PFF p0, float p1, void* p2,  struct S_PFF (*cb)(struct S_PFF, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFD f17_S_SFP_PFD(struct S_PFD p0, float p1, void* p2,  struct S_PFD (*cb)(struct S_PFD, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFP f17_S_SFP_PFP(struct S_PFP p0, float p1, void* p2,  struct S_PFP (*cb)(struct S_PFP, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDI f17_S_SFP_PDI(struct S_PDI p0, float p1, void* p2,  struct S_PDI (*cb)(struct S_PDI, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDF f17_S_SFP_PDF(struct S_PDF p0, float p1, void* p2,  struct S_PDF (*cb)(struct S_PDF, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDD f17_S_SFP_PDD(struct S_PDD p0, float p1, void* p2,  struct S_PDD (*cb)(struct S_PDD, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDP f17_S_SFP_PDP(struct S_PDP p0, float p1, void* p2,  struct S_PDP (*cb)(struct S_PDP, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPI f17_S_SFP_PPI(struct S_PPI p0, float p1, void* p2,  struct S_PPI (*cb)(struct S_PPI, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPF f17_S_SFP_PPF(struct S_PPF p0, float p1, void* p2,  struct S_PPF (*cb)(struct S_PPF, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPD f17_S_SFP_PPD(struct S_PPD p0, float p1, void* p2,  struct S_PPD (*cb)(struct S_PPD, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPP f17_S_SFP_PPP(struct S_PPP p0, float p1, void* p2,  struct S_PPP (*cb)(struct S_PPP, float, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_I f17_S_SFS_I(struct S_I p0, float p1, struct S_I p2,  struct S_I (*cb)(struct S_I, float, struct S_I)) { return cb(p0,p1,p2); }
+EXPORT struct S_F f17_S_SFS_F(struct S_F p0, float p1, struct S_F p2,  struct S_F (*cb)(struct S_F, float, struct S_F)) { return cb(p0,p1,p2); }
+EXPORT struct S_D f17_S_SFS_D(struct S_D p0, float p1, struct S_D p2,  struct S_D (*cb)(struct S_D, float, struct S_D)) { return cb(p0,p1,p2); }
+EXPORT struct S_P f17_S_SFS_P(struct S_P p0, float p1, struct S_P p2,  struct S_P (*cb)(struct S_P, float, struct S_P)) { return cb(p0,p1,p2); }
+EXPORT struct S_II f17_S_SFS_II(struct S_II p0, float p1, struct S_II p2,  struct S_II (*cb)(struct S_II, float, struct S_II)) { return cb(p0,p1,p2); }
+EXPORT struct S_IF f17_S_SFS_IF(struct S_IF p0, float p1, struct S_IF p2,  struct S_IF (*cb)(struct S_IF, float, struct S_IF)) { return cb(p0,p1,p2); }
+EXPORT struct S_ID f17_S_SFS_ID(struct S_ID p0, float p1, struct S_ID p2,  struct S_ID (*cb)(struct S_ID, float, struct S_ID)) { return cb(p0,p1,p2); }
+EXPORT struct S_IP f17_S_SFS_IP(struct S_IP p0, float p1, struct S_IP p2,  struct S_IP (*cb)(struct S_IP, float, struct S_IP)) { return cb(p0,p1,p2); }
+EXPORT struct S_FI f17_S_SFS_FI(struct S_FI p0, float p1, struct S_FI p2,  struct S_FI (*cb)(struct S_FI, float, struct S_FI)) { return cb(p0,p1,p2); }
+EXPORT struct S_FF f17_S_SFS_FF(struct S_FF p0, float p1, struct S_FF p2,  struct S_FF (*cb)(struct S_FF, float, struct S_FF)) { return cb(p0,p1,p2); }
+EXPORT struct S_FD f17_S_SFS_FD(struct S_FD p0, float p1, struct S_FD p2,  struct S_FD (*cb)(struct S_FD, float, struct S_FD)) { return cb(p0,p1,p2); }
+EXPORT struct S_FP f17_S_SFS_FP(struct S_FP p0, float p1, struct S_FP p2,  struct S_FP (*cb)(struct S_FP, float, struct S_FP)) { return cb(p0,p1,p2); }
+EXPORT struct S_DI f17_S_SFS_DI(struct S_DI p0, float p1, struct S_DI p2,  struct S_DI (*cb)(struct S_DI, float, struct S_DI)) { return cb(p0,p1,p2); }
+EXPORT struct S_DF f17_S_SFS_DF(struct S_DF p0, float p1, struct S_DF p2,  struct S_DF (*cb)(struct S_DF, float, struct S_DF)) { return cb(p0,p1,p2); }
+EXPORT struct S_DD f17_S_SFS_DD(struct S_DD p0, float p1, struct S_DD p2,  struct S_DD (*cb)(struct S_DD, float, struct S_DD)) { return cb(p0,p1,p2); }
+EXPORT struct S_DP f17_S_SFS_DP(struct S_DP p0, float p1, struct S_DP p2,  struct S_DP (*cb)(struct S_DP, float, struct S_DP)) { return cb(p0,p1,p2); }
+EXPORT struct S_PI f17_S_SFS_PI(struct S_PI p0, float p1, struct S_PI p2,  struct S_PI (*cb)(struct S_PI, float, struct S_PI)) { return cb(p0,p1,p2); }
+EXPORT struct S_PF f17_S_SFS_PF(struct S_PF p0, float p1, struct S_PF p2,  struct S_PF (*cb)(struct S_PF, float, struct S_PF)) { return cb(p0,p1,p2); }
+EXPORT struct S_PD f17_S_SFS_PD(struct S_PD p0, float p1, struct S_PD p2,  struct S_PD (*cb)(struct S_PD, float, struct S_PD)) { return cb(p0,p1,p2); }
+EXPORT struct S_PP f17_S_SFS_PP(struct S_PP p0, float p1, struct S_PP p2,  struct S_PP (*cb)(struct S_PP, float, struct S_PP)) { return cb(p0,p1,p2); }
+EXPORT struct S_III f17_S_SFS_III(struct S_III p0, float p1, struct S_III p2,  struct S_III (*cb)(struct S_III, float, struct S_III)) { return cb(p0,p1,p2); }
+EXPORT struct S_IIF f17_S_SFS_IIF(struct S_IIF p0, float p1, struct S_IIF p2,  struct S_IIF (*cb)(struct S_IIF, float, struct S_IIF)) { return cb(p0,p1,p2); }
+EXPORT struct S_IID f17_S_SFS_IID(struct S_IID p0, float p1, struct S_IID p2,  struct S_IID (*cb)(struct S_IID, float, struct S_IID)) { return cb(p0,p1,p2); }
+EXPORT struct S_IIP f17_S_SFS_IIP(struct S_IIP p0, float p1, struct S_IIP p2,  struct S_IIP (*cb)(struct S_IIP, float, struct S_IIP)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFI f17_S_SFS_IFI(struct S_IFI p0, float p1, struct S_IFI p2,  struct S_IFI (*cb)(struct S_IFI, float, struct S_IFI)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFF f17_S_SFS_IFF(struct S_IFF p0, float p1, struct S_IFF p2,  struct S_IFF (*cb)(struct S_IFF, float, struct S_IFF)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFD f17_S_SFS_IFD(struct S_IFD p0, float p1, struct S_IFD p2,  struct S_IFD (*cb)(struct S_IFD, float, struct S_IFD)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFP f17_S_SFS_IFP(struct S_IFP p0, float p1, struct S_IFP p2,  struct S_IFP (*cb)(struct S_IFP, float, struct S_IFP)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDI f17_S_SFS_IDI(struct S_IDI p0, float p1, struct S_IDI p2,  struct S_IDI (*cb)(struct S_IDI, float, struct S_IDI)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDF f17_S_SFS_IDF(struct S_IDF p0, float p1, struct S_IDF p2,  struct S_IDF (*cb)(struct S_IDF, float, struct S_IDF)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDD f17_S_SFS_IDD(struct S_IDD p0, float p1, struct S_IDD p2,  struct S_IDD (*cb)(struct S_IDD, float, struct S_IDD)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDP f17_S_SFS_IDP(struct S_IDP p0, float p1, struct S_IDP p2,  struct S_IDP (*cb)(struct S_IDP, float, struct S_IDP)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPI f17_S_SFS_IPI(struct S_IPI p0, float p1, struct S_IPI p2,  struct S_IPI (*cb)(struct S_IPI, float, struct S_IPI)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPF f17_S_SFS_IPF(struct S_IPF p0, float p1, struct S_IPF p2,  struct S_IPF (*cb)(struct S_IPF, float, struct S_IPF)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPD f17_S_SFS_IPD(struct S_IPD p0, float p1, struct S_IPD p2,  struct S_IPD (*cb)(struct S_IPD, float, struct S_IPD)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPP f17_S_SFS_IPP(struct S_IPP p0, float p1, struct S_IPP p2,  struct S_IPP (*cb)(struct S_IPP, float, struct S_IPP)) { return cb(p0,p1,p2); }
+EXPORT struct S_FII f17_S_SFS_FII(struct S_FII p0, float p1, struct S_FII p2,  struct S_FII (*cb)(struct S_FII, float, struct S_FII)) { return cb(p0,p1,p2); }
+EXPORT struct S_FIF f17_S_SFS_FIF(struct S_FIF p0, float p1, struct S_FIF p2,  struct S_FIF (*cb)(struct S_FIF, float, struct S_FIF)) { return cb(p0,p1,p2); }
+EXPORT struct S_FID f17_S_SFS_FID(struct S_FID p0, float p1, struct S_FID p2,  struct S_FID (*cb)(struct S_FID, float, struct S_FID)) { return cb(p0,p1,p2); }
+EXPORT struct S_FIP f17_S_SFS_FIP(struct S_FIP p0, float p1, struct S_FIP p2,  struct S_FIP (*cb)(struct S_FIP, float, struct S_FIP)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFI f17_S_SFS_FFI(struct S_FFI p0, float p1, struct S_FFI p2,  struct S_FFI (*cb)(struct S_FFI, float, struct S_FFI)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFF f17_S_SFS_FFF(struct S_FFF p0, float p1, struct S_FFF p2,  struct S_FFF (*cb)(struct S_FFF, float, struct S_FFF)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFD f17_S_SFS_FFD(struct S_FFD p0, float p1, struct S_FFD p2,  struct S_FFD (*cb)(struct S_FFD, float, struct S_FFD)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFP f17_S_SFS_FFP(struct S_FFP p0, float p1, struct S_FFP p2,  struct S_FFP (*cb)(struct S_FFP, float, struct S_FFP)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDI f17_S_SFS_FDI(struct S_FDI p0, float p1, struct S_FDI p2,  struct S_FDI (*cb)(struct S_FDI, float, struct S_FDI)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDF f17_S_SFS_FDF(struct S_FDF p0, float p1, struct S_FDF p2,  struct S_FDF (*cb)(struct S_FDF, float, struct S_FDF)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDD f17_S_SFS_FDD(struct S_FDD p0, float p1, struct S_FDD p2,  struct S_FDD (*cb)(struct S_FDD, float, struct S_FDD)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDP f18_S_SFS_FDP(struct S_FDP p0, float p1, struct S_FDP p2,  struct S_FDP (*cb)(struct S_FDP, float, struct S_FDP)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPI f18_S_SFS_FPI(struct S_FPI p0, float p1, struct S_FPI p2,  struct S_FPI (*cb)(struct S_FPI, float, struct S_FPI)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPF f18_S_SFS_FPF(struct S_FPF p0, float p1, struct S_FPF p2,  struct S_FPF (*cb)(struct S_FPF, float, struct S_FPF)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPD f18_S_SFS_FPD(struct S_FPD p0, float p1, struct S_FPD p2,  struct S_FPD (*cb)(struct S_FPD, float, struct S_FPD)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPP f18_S_SFS_FPP(struct S_FPP p0, float p1, struct S_FPP p2,  struct S_FPP (*cb)(struct S_FPP, float, struct S_FPP)) { return cb(p0,p1,p2); }
+EXPORT struct S_DII f18_S_SFS_DII(struct S_DII p0, float p1, struct S_DII p2,  struct S_DII (*cb)(struct S_DII, float, struct S_DII)) { return cb(p0,p1,p2); }
+EXPORT struct S_DIF f18_S_SFS_DIF(struct S_DIF p0, float p1, struct S_DIF p2,  struct S_DIF (*cb)(struct S_DIF, float, struct S_DIF)) { return cb(p0,p1,p2); }
+EXPORT struct S_DID f18_S_SFS_DID(struct S_DID p0, float p1, struct S_DID p2,  struct S_DID (*cb)(struct S_DID, float, struct S_DID)) { return cb(p0,p1,p2); }
+EXPORT struct S_DIP f18_S_SFS_DIP(struct S_DIP p0, float p1, struct S_DIP p2,  struct S_DIP (*cb)(struct S_DIP, float, struct S_DIP)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFI f18_S_SFS_DFI(struct S_DFI p0, float p1, struct S_DFI p2,  struct S_DFI (*cb)(struct S_DFI, float, struct S_DFI)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFF f18_S_SFS_DFF(struct S_DFF p0, float p1, struct S_DFF p2,  struct S_DFF (*cb)(struct S_DFF, float, struct S_DFF)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFD f18_S_SFS_DFD(struct S_DFD p0, float p1, struct S_DFD p2,  struct S_DFD (*cb)(struct S_DFD, float, struct S_DFD)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFP f18_S_SFS_DFP(struct S_DFP p0, float p1, struct S_DFP p2,  struct S_DFP (*cb)(struct S_DFP, float, struct S_DFP)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDI f18_S_SFS_DDI(struct S_DDI p0, float p1, struct S_DDI p2,  struct S_DDI (*cb)(struct S_DDI, float, struct S_DDI)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDF f18_S_SFS_DDF(struct S_DDF p0, float p1, struct S_DDF p2,  struct S_DDF (*cb)(struct S_DDF, float, struct S_DDF)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDD f18_S_SFS_DDD(struct S_DDD p0, float p1, struct S_DDD p2,  struct S_DDD (*cb)(struct S_DDD, float, struct S_DDD)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDP f18_S_SFS_DDP(struct S_DDP p0, float p1, struct S_DDP p2,  struct S_DDP (*cb)(struct S_DDP, float, struct S_DDP)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPI f18_S_SFS_DPI(struct S_DPI p0, float p1, struct S_DPI p2,  struct S_DPI (*cb)(struct S_DPI, float, struct S_DPI)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPF f18_S_SFS_DPF(struct S_DPF p0, float p1, struct S_DPF p2,  struct S_DPF (*cb)(struct S_DPF, float, struct S_DPF)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPD f18_S_SFS_DPD(struct S_DPD p0, float p1, struct S_DPD p2,  struct S_DPD (*cb)(struct S_DPD, float, struct S_DPD)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPP f18_S_SFS_DPP(struct S_DPP p0, float p1, struct S_DPP p2,  struct S_DPP (*cb)(struct S_DPP, float, struct S_DPP)) { return cb(p0,p1,p2); }
+EXPORT struct S_PII f18_S_SFS_PII(struct S_PII p0, float p1, struct S_PII p2,  struct S_PII (*cb)(struct S_PII, float, struct S_PII)) { return cb(p0,p1,p2); }
+EXPORT struct S_PIF f18_S_SFS_PIF(struct S_PIF p0, float p1, struct S_PIF p2,  struct S_PIF (*cb)(struct S_PIF, float, struct S_PIF)) { return cb(p0,p1,p2); }
+EXPORT struct S_PID f18_S_SFS_PID(struct S_PID p0, float p1, struct S_PID p2,  struct S_PID (*cb)(struct S_PID, float, struct S_PID)) { return cb(p0,p1,p2); }
+EXPORT struct S_PIP f18_S_SFS_PIP(struct S_PIP p0, float p1, struct S_PIP p2,  struct S_PIP (*cb)(struct S_PIP, float, struct S_PIP)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFI f18_S_SFS_PFI(struct S_PFI p0, float p1, struct S_PFI p2,  struct S_PFI (*cb)(struct S_PFI, float, struct S_PFI)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFF f18_S_SFS_PFF(struct S_PFF p0, float p1, struct S_PFF p2,  struct S_PFF (*cb)(struct S_PFF, float, struct S_PFF)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFD f18_S_SFS_PFD(struct S_PFD p0, float p1, struct S_PFD p2,  struct S_PFD (*cb)(struct S_PFD, float, struct S_PFD)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFP f18_S_SFS_PFP(struct S_PFP p0, float p1, struct S_PFP p2,  struct S_PFP (*cb)(struct S_PFP, float, struct S_PFP)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDI f18_S_SFS_PDI(struct S_PDI p0, float p1, struct S_PDI p2,  struct S_PDI (*cb)(struct S_PDI, float, struct S_PDI)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDF f18_S_SFS_PDF(struct S_PDF p0, float p1, struct S_PDF p2,  struct S_PDF (*cb)(struct S_PDF, float, struct S_PDF)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDD f18_S_SFS_PDD(struct S_PDD p0, float p1, struct S_PDD p2,  struct S_PDD (*cb)(struct S_PDD, float, struct S_PDD)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDP f18_S_SFS_PDP(struct S_PDP p0, float p1, struct S_PDP p2,  struct S_PDP (*cb)(struct S_PDP, float, struct S_PDP)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPI f18_S_SFS_PPI(struct S_PPI p0, float p1, struct S_PPI p2,  struct S_PPI (*cb)(struct S_PPI, float, struct S_PPI)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPF f18_S_SFS_PPF(struct S_PPF p0, float p1, struct S_PPF p2,  struct S_PPF (*cb)(struct S_PPF, float, struct S_PPF)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPD f18_S_SFS_PPD(struct S_PPD p0, float p1, struct S_PPD p2,  struct S_PPD (*cb)(struct S_PPD, float, struct S_PPD)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPP f18_S_SFS_PPP(struct S_PPP p0, float p1, struct S_PPP p2,  struct S_PPP (*cb)(struct S_PPP, float, struct S_PPP)) { return cb(p0,p1,p2); }
+EXPORT struct S_I f18_S_SDI_I(struct S_I p0, double p1, int p2,  struct S_I (*cb)(struct S_I, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_F f18_S_SDI_F(struct S_F p0, double p1, int p2,  struct S_F (*cb)(struct S_F, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_D f18_S_SDI_D(struct S_D p0, double p1, int p2,  struct S_D (*cb)(struct S_D, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_P f18_S_SDI_P(struct S_P p0, double p1, int p2,  struct S_P (*cb)(struct S_P, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_II f18_S_SDI_II(struct S_II p0, double p1, int p2,  struct S_II (*cb)(struct S_II, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IF f18_S_SDI_IF(struct S_IF p0, double p1, int p2,  struct S_IF (*cb)(struct S_IF, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_ID f18_S_SDI_ID(struct S_ID p0, double p1, int p2,  struct S_ID (*cb)(struct S_ID, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IP f18_S_SDI_IP(struct S_IP p0, double p1, int p2,  struct S_IP (*cb)(struct S_IP, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FI f18_S_SDI_FI(struct S_FI p0, double p1, int p2,  struct S_FI (*cb)(struct S_FI, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FF f18_S_SDI_FF(struct S_FF p0, double p1, int p2,  struct S_FF (*cb)(struct S_FF, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FD f18_S_SDI_FD(struct S_FD p0, double p1, int p2,  struct S_FD (*cb)(struct S_FD, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FP f18_S_SDI_FP(struct S_FP p0, double p1, int p2,  struct S_FP (*cb)(struct S_FP, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DI f18_S_SDI_DI(struct S_DI p0, double p1, int p2,  struct S_DI (*cb)(struct S_DI, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DF f18_S_SDI_DF(struct S_DF p0, double p1, int p2,  struct S_DF (*cb)(struct S_DF, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DD f18_S_SDI_DD(struct S_DD p0, double p1, int p2,  struct S_DD (*cb)(struct S_DD, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DP f18_S_SDI_DP(struct S_DP p0, double p1, int p2,  struct S_DP (*cb)(struct S_DP, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PI f18_S_SDI_PI(struct S_PI p0, double p1, int p2,  struct S_PI (*cb)(struct S_PI, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PF f18_S_SDI_PF(struct S_PF p0, double p1, int p2,  struct S_PF (*cb)(struct S_PF, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PD f18_S_SDI_PD(struct S_PD p0, double p1, int p2,  struct S_PD (*cb)(struct S_PD, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PP f18_S_SDI_PP(struct S_PP p0, double p1, int p2,  struct S_PP (*cb)(struct S_PP, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_III f18_S_SDI_III(struct S_III p0, double p1, int p2,  struct S_III (*cb)(struct S_III, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IIF f18_S_SDI_IIF(struct S_IIF p0, double p1, int p2,  struct S_IIF (*cb)(struct S_IIF, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IID f18_S_SDI_IID(struct S_IID p0, double p1, int p2,  struct S_IID (*cb)(struct S_IID, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IIP f18_S_SDI_IIP(struct S_IIP p0, double p1, int p2,  struct S_IIP (*cb)(struct S_IIP, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFI f18_S_SDI_IFI(struct S_IFI p0, double p1, int p2,  struct S_IFI (*cb)(struct S_IFI, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFF f18_S_SDI_IFF(struct S_IFF p0, double p1, int p2,  struct S_IFF (*cb)(struct S_IFF, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFD f18_S_SDI_IFD(struct S_IFD p0, double p1, int p2,  struct S_IFD (*cb)(struct S_IFD, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFP f18_S_SDI_IFP(struct S_IFP p0, double p1, int p2,  struct S_IFP (*cb)(struct S_IFP, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDI f18_S_SDI_IDI(struct S_IDI p0, double p1, int p2,  struct S_IDI (*cb)(struct S_IDI, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDF f18_S_SDI_IDF(struct S_IDF p0, double p1, int p2,  struct S_IDF (*cb)(struct S_IDF, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDD f18_S_SDI_IDD(struct S_IDD p0, double p1, int p2,  struct S_IDD (*cb)(struct S_IDD, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDP f18_S_SDI_IDP(struct S_IDP p0, double p1, int p2,  struct S_IDP (*cb)(struct S_IDP, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPI f18_S_SDI_IPI(struct S_IPI p0, double p1, int p2,  struct S_IPI (*cb)(struct S_IPI, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPF f18_S_SDI_IPF(struct S_IPF p0, double p1, int p2,  struct S_IPF (*cb)(struct S_IPF, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPD f18_S_SDI_IPD(struct S_IPD p0, double p1, int p2,  struct S_IPD (*cb)(struct S_IPD, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPP f18_S_SDI_IPP(struct S_IPP p0, double p1, int p2,  struct S_IPP (*cb)(struct S_IPP, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FII f18_S_SDI_FII(struct S_FII p0, double p1, int p2,  struct S_FII (*cb)(struct S_FII, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FIF f18_S_SDI_FIF(struct S_FIF p0, double p1, int p2,  struct S_FIF (*cb)(struct S_FIF, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FID f18_S_SDI_FID(struct S_FID p0, double p1, int p2,  struct S_FID (*cb)(struct S_FID, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FIP f18_S_SDI_FIP(struct S_FIP p0, double p1, int p2,  struct S_FIP (*cb)(struct S_FIP, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFI f18_S_SDI_FFI(struct S_FFI p0, double p1, int p2,  struct S_FFI (*cb)(struct S_FFI, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFF f18_S_SDI_FFF(struct S_FFF p0, double p1, int p2,  struct S_FFF (*cb)(struct S_FFF, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFD f18_S_SDI_FFD(struct S_FFD p0, double p1, int p2,  struct S_FFD (*cb)(struct S_FFD, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFP f18_S_SDI_FFP(struct S_FFP p0, double p1, int p2,  struct S_FFP (*cb)(struct S_FFP, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDI f18_S_SDI_FDI(struct S_FDI p0, double p1, int p2,  struct S_FDI (*cb)(struct S_FDI, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDF f18_S_SDI_FDF(struct S_FDF p0, double p1, int p2,  struct S_FDF (*cb)(struct S_FDF, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDD f18_S_SDI_FDD(struct S_FDD p0, double p1, int p2,  struct S_FDD (*cb)(struct S_FDD, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDP f18_S_SDI_FDP(struct S_FDP p0, double p1, int p2,  struct S_FDP (*cb)(struct S_FDP, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPI f18_S_SDI_FPI(struct S_FPI p0, double p1, int p2,  struct S_FPI (*cb)(struct S_FPI, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPF f18_S_SDI_FPF(struct S_FPF p0, double p1, int p2,  struct S_FPF (*cb)(struct S_FPF, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPD f18_S_SDI_FPD(struct S_FPD p0, double p1, int p2,  struct S_FPD (*cb)(struct S_FPD, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPP f18_S_SDI_FPP(struct S_FPP p0, double p1, int p2,  struct S_FPP (*cb)(struct S_FPP, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DII f18_S_SDI_DII(struct S_DII p0, double p1, int p2,  struct S_DII (*cb)(struct S_DII, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DIF f18_S_SDI_DIF(struct S_DIF p0, double p1, int p2,  struct S_DIF (*cb)(struct S_DIF, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DID f18_S_SDI_DID(struct S_DID p0, double p1, int p2,  struct S_DID (*cb)(struct S_DID, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DIP f18_S_SDI_DIP(struct S_DIP p0, double p1, int p2,  struct S_DIP (*cb)(struct S_DIP, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFI f18_S_SDI_DFI(struct S_DFI p0, double p1, int p2,  struct S_DFI (*cb)(struct S_DFI, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFF f18_S_SDI_DFF(struct S_DFF p0, double p1, int p2,  struct S_DFF (*cb)(struct S_DFF, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFD f18_S_SDI_DFD(struct S_DFD p0, double p1, int p2,  struct S_DFD (*cb)(struct S_DFD, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFP f18_S_SDI_DFP(struct S_DFP p0, double p1, int p2,  struct S_DFP (*cb)(struct S_DFP, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDI f18_S_SDI_DDI(struct S_DDI p0, double p1, int p2,  struct S_DDI (*cb)(struct S_DDI, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDF f18_S_SDI_DDF(struct S_DDF p0, double p1, int p2,  struct S_DDF (*cb)(struct S_DDF, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDD f18_S_SDI_DDD(struct S_DDD p0, double p1, int p2,  struct S_DDD (*cb)(struct S_DDD, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDP f18_S_SDI_DDP(struct S_DDP p0, double p1, int p2,  struct S_DDP (*cb)(struct S_DDP, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPI f18_S_SDI_DPI(struct S_DPI p0, double p1, int p2,  struct S_DPI (*cb)(struct S_DPI, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPF f18_S_SDI_DPF(struct S_DPF p0, double p1, int p2,  struct S_DPF (*cb)(struct S_DPF, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPD f18_S_SDI_DPD(struct S_DPD p0, double p1, int p2,  struct S_DPD (*cb)(struct S_DPD, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPP f18_S_SDI_DPP(struct S_DPP p0, double p1, int p2,  struct S_DPP (*cb)(struct S_DPP, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PII f18_S_SDI_PII(struct S_PII p0, double p1, int p2,  struct S_PII (*cb)(struct S_PII, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PIF f18_S_SDI_PIF(struct S_PIF p0, double p1, int p2,  struct S_PIF (*cb)(struct S_PIF, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PID f18_S_SDI_PID(struct S_PID p0, double p1, int p2,  struct S_PID (*cb)(struct S_PID, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PIP f18_S_SDI_PIP(struct S_PIP p0, double p1, int p2,  struct S_PIP (*cb)(struct S_PIP, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFI f18_S_SDI_PFI(struct S_PFI p0, double p1, int p2,  struct S_PFI (*cb)(struct S_PFI, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFF f18_S_SDI_PFF(struct S_PFF p0, double p1, int p2,  struct S_PFF (*cb)(struct S_PFF, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFD f18_S_SDI_PFD(struct S_PFD p0, double p1, int p2,  struct S_PFD (*cb)(struct S_PFD, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFP f18_S_SDI_PFP(struct S_PFP p0, double p1, int p2,  struct S_PFP (*cb)(struct S_PFP, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDI f18_S_SDI_PDI(struct S_PDI p0, double p1, int p2,  struct S_PDI (*cb)(struct S_PDI, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDF f18_S_SDI_PDF(struct S_PDF p0, double p1, int p2,  struct S_PDF (*cb)(struct S_PDF, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDD f18_S_SDI_PDD(struct S_PDD p0, double p1, int p2,  struct S_PDD (*cb)(struct S_PDD, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDP f18_S_SDI_PDP(struct S_PDP p0, double p1, int p2,  struct S_PDP (*cb)(struct S_PDP, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPI f18_S_SDI_PPI(struct S_PPI p0, double p1, int p2,  struct S_PPI (*cb)(struct S_PPI, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPF f18_S_SDI_PPF(struct S_PPF p0, double p1, int p2,  struct S_PPF (*cb)(struct S_PPF, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPD f18_S_SDI_PPD(struct S_PPD p0, double p1, int p2,  struct S_PPD (*cb)(struct S_PPD, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPP f18_S_SDI_PPP(struct S_PPP p0, double p1, int p2,  struct S_PPP (*cb)(struct S_PPP, double, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_I f18_S_SDF_I(struct S_I p0, double p1, float p2,  struct S_I (*cb)(struct S_I, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_F f18_S_SDF_F(struct S_F p0, double p1, float p2,  struct S_F (*cb)(struct S_F, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_D f18_S_SDF_D(struct S_D p0, double p1, float p2,  struct S_D (*cb)(struct S_D, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_P f18_S_SDF_P(struct S_P p0, double p1, float p2,  struct S_P (*cb)(struct S_P, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_II f18_S_SDF_II(struct S_II p0, double p1, float p2,  struct S_II (*cb)(struct S_II, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IF f18_S_SDF_IF(struct S_IF p0, double p1, float p2,  struct S_IF (*cb)(struct S_IF, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_ID f18_S_SDF_ID(struct S_ID p0, double p1, float p2,  struct S_ID (*cb)(struct S_ID, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IP f18_S_SDF_IP(struct S_IP p0, double p1, float p2,  struct S_IP (*cb)(struct S_IP, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FI f18_S_SDF_FI(struct S_FI p0, double p1, float p2,  struct S_FI (*cb)(struct S_FI, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FF f18_S_SDF_FF(struct S_FF p0, double p1, float p2,  struct S_FF (*cb)(struct S_FF, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FD f18_S_SDF_FD(struct S_FD p0, double p1, float p2,  struct S_FD (*cb)(struct S_FD, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FP f18_S_SDF_FP(struct S_FP p0, double p1, float p2,  struct S_FP (*cb)(struct S_FP, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DI f18_S_SDF_DI(struct S_DI p0, double p1, float p2,  struct S_DI (*cb)(struct S_DI, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DF f18_S_SDF_DF(struct S_DF p0, double p1, float p2,  struct S_DF (*cb)(struct S_DF, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DD f18_S_SDF_DD(struct S_DD p0, double p1, float p2,  struct S_DD (*cb)(struct S_DD, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DP f18_S_SDF_DP(struct S_DP p0, double p1, float p2,  struct S_DP (*cb)(struct S_DP, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PI f18_S_SDF_PI(struct S_PI p0, double p1, float p2,  struct S_PI (*cb)(struct S_PI, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PF f18_S_SDF_PF(struct S_PF p0, double p1, float p2,  struct S_PF (*cb)(struct S_PF, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PD f18_S_SDF_PD(struct S_PD p0, double p1, float p2,  struct S_PD (*cb)(struct S_PD, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PP f18_S_SDF_PP(struct S_PP p0, double p1, float p2,  struct S_PP (*cb)(struct S_PP, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_III f18_S_SDF_III(struct S_III p0, double p1, float p2,  struct S_III (*cb)(struct S_III, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IIF f18_S_SDF_IIF(struct S_IIF p0, double p1, float p2,  struct S_IIF (*cb)(struct S_IIF, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IID f18_S_SDF_IID(struct S_IID p0, double p1, float p2,  struct S_IID (*cb)(struct S_IID, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IIP f18_S_SDF_IIP(struct S_IIP p0, double p1, float p2,  struct S_IIP (*cb)(struct S_IIP, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFI f18_S_SDF_IFI(struct S_IFI p0, double p1, float p2,  struct S_IFI (*cb)(struct S_IFI, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFF f18_S_SDF_IFF(struct S_IFF p0, double p1, float p2,  struct S_IFF (*cb)(struct S_IFF, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFD f18_S_SDF_IFD(struct S_IFD p0, double p1, float p2,  struct S_IFD (*cb)(struct S_IFD, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFP f18_S_SDF_IFP(struct S_IFP p0, double p1, float p2,  struct S_IFP (*cb)(struct S_IFP, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDI f18_S_SDF_IDI(struct S_IDI p0, double p1, float p2,  struct S_IDI (*cb)(struct S_IDI, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDF f18_S_SDF_IDF(struct S_IDF p0, double p1, float p2,  struct S_IDF (*cb)(struct S_IDF, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDD f18_S_SDF_IDD(struct S_IDD p0, double p1, float p2,  struct S_IDD (*cb)(struct S_IDD, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDP f18_S_SDF_IDP(struct S_IDP p0, double p1, float p2,  struct S_IDP (*cb)(struct S_IDP, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPI f18_S_SDF_IPI(struct S_IPI p0, double p1, float p2,  struct S_IPI (*cb)(struct S_IPI, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPF f18_S_SDF_IPF(struct S_IPF p0, double p1, float p2,  struct S_IPF (*cb)(struct S_IPF, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPD f18_S_SDF_IPD(struct S_IPD p0, double p1, float p2,  struct S_IPD (*cb)(struct S_IPD, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPP f18_S_SDF_IPP(struct S_IPP p0, double p1, float p2,  struct S_IPP (*cb)(struct S_IPP, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FII f18_S_SDF_FII(struct S_FII p0, double p1, float p2,  struct S_FII (*cb)(struct S_FII, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FIF f18_S_SDF_FIF(struct S_FIF p0, double p1, float p2,  struct S_FIF (*cb)(struct S_FIF, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FID f18_S_SDF_FID(struct S_FID p0, double p1, float p2,  struct S_FID (*cb)(struct S_FID, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FIP f18_S_SDF_FIP(struct S_FIP p0, double p1, float p2,  struct S_FIP (*cb)(struct S_FIP, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFI f18_S_SDF_FFI(struct S_FFI p0, double p1, float p2,  struct S_FFI (*cb)(struct S_FFI, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFF f18_S_SDF_FFF(struct S_FFF p0, double p1, float p2,  struct S_FFF (*cb)(struct S_FFF, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFD f18_S_SDF_FFD(struct S_FFD p0, double p1, float p2,  struct S_FFD (*cb)(struct S_FFD, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFP f18_S_SDF_FFP(struct S_FFP p0, double p1, float p2,  struct S_FFP (*cb)(struct S_FFP, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDI f18_S_SDF_FDI(struct S_FDI p0, double p1, float p2,  struct S_FDI (*cb)(struct S_FDI, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDF f18_S_SDF_FDF(struct S_FDF p0, double p1, float p2,  struct S_FDF (*cb)(struct S_FDF, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDD f18_S_SDF_FDD(struct S_FDD p0, double p1, float p2,  struct S_FDD (*cb)(struct S_FDD, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDP f18_S_SDF_FDP(struct S_FDP p0, double p1, float p2,  struct S_FDP (*cb)(struct S_FDP, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPI f18_S_SDF_FPI(struct S_FPI p0, double p1, float p2,  struct S_FPI (*cb)(struct S_FPI, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPF f18_S_SDF_FPF(struct S_FPF p0, double p1, float p2,  struct S_FPF (*cb)(struct S_FPF, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPD f18_S_SDF_FPD(struct S_FPD p0, double p1, float p2,  struct S_FPD (*cb)(struct S_FPD, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPP f18_S_SDF_FPP(struct S_FPP p0, double p1, float p2,  struct S_FPP (*cb)(struct S_FPP, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DII f18_S_SDF_DII(struct S_DII p0, double p1, float p2,  struct S_DII (*cb)(struct S_DII, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DIF f18_S_SDF_DIF(struct S_DIF p0, double p1, float p2,  struct S_DIF (*cb)(struct S_DIF, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DID f18_S_SDF_DID(struct S_DID p0, double p1, float p2,  struct S_DID (*cb)(struct S_DID, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DIP f18_S_SDF_DIP(struct S_DIP p0, double p1, float p2,  struct S_DIP (*cb)(struct S_DIP, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFI f18_S_SDF_DFI(struct S_DFI p0, double p1, float p2,  struct S_DFI (*cb)(struct S_DFI, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFF f18_S_SDF_DFF(struct S_DFF p0, double p1, float p2,  struct S_DFF (*cb)(struct S_DFF, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFD f18_S_SDF_DFD(struct S_DFD p0, double p1, float p2,  struct S_DFD (*cb)(struct S_DFD, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFP f18_S_SDF_DFP(struct S_DFP p0, double p1, float p2,  struct S_DFP (*cb)(struct S_DFP, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDI f18_S_SDF_DDI(struct S_DDI p0, double p1, float p2,  struct S_DDI (*cb)(struct S_DDI, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDF f18_S_SDF_DDF(struct S_DDF p0, double p1, float p2,  struct S_DDF (*cb)(struct S_DDF, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDD f18_S_SDF_DDD(struct S_DDD p0, double p1, float p2,  struct S_DDD (*cb)(struct S_DDD, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDP f18_S_SDF_DDP(struct S_DDP p0, double p1, float p2,  struct S_DDP (*cb)(struct S_DDP, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPI f18_S_SDF_DPI(struct S_DPI p0, double p1, float p2,  struct S_DPI (*cb)(struct S_DPI, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPF f18_S_SDF_DPF(struct S_DPF p0, double p1, float p2,  struct S_DPF (*cb)(struct S_DPF, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPD f18_S_SDF_DPD(struct S_DPD p0, double p1, float p2,  struct S_DPD (*cb)(struct S_DPD, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPP f18_S_SDF_DPP(struct S_DPP p0, double p1, float p2,  struct S_DPP (*cb)(struct S_DPP, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PII f18_S_SDF_PII(struct S_PII p0, double p1, float p2,  struct S_PII (*cb)(struct S_PII, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PIF f18_S_SDF_PIF(struct S_PIF p0, double p1, float p2,  struct S_PIF (*cb)(struct S_PIF, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PID f18_S_SDF_PID(struct S_PID p0, double p1, float p2,  struct S_PID (*cb)(struct S_PID, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PIP f18_S_SDF_PIP(struct S_PIP p0, double p1, float p2,  struct S_PIP (*cb)(struct S_PIP, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFI f18_S_SDF_PFI(struct S_PFI p0, double p1, float p2,  struct S_PFI (*cb)(struct S_PFI, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFF f18_S_SDF_PFF(struct S_PFF p0, double p1, float p2,  struct S_PFF (*cb)(struct S_PFF, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFD f18_S_SDF_PFD(struct S_PFD p0, double p1, float p2,  struct S_PFD (*cb)(struct S_PFD, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFP f18_S_SDF_PFP(struct S_PFP p0, double p1, float p2,  struct S_PFP (*cb)(struct S_PFP, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDI f18_S_SDF_PDI(struct S_PDI p0, double p1, float p2,  struct S_PDI (*cb)(struct S_PDI, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDF f18_S_SDF_PDF(struct S_PDF p0, double p1, float p2,  struct S_PDF (*cb)(struct S_PDF, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDD f18_S_SDF_PDD(struct S_PDD p0, double p1, float p2,  struct S_PDD (*cb)(struct S_PDD, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDP f18_S_SDF_PDP(struct S_PDP p0, double p1, float p2,  struct S_PDP (*cb)(struct S_PDP, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPI f18_S_SDF_PPI(struct S_PPI p0, double p1, float p2,  struct S_PPI (*cb)(struct S_PPI, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPF f18_S_SDF_PPF(struct S_PPF p0, double p1, float p2,  struct S_PPF (*cb)(struct S_PPF, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPD f18_S_SDF_PPD(struct S_PPD p0, double p1, float p2,  struct S_PPD (*cb)(struct S_PPD, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPP f18_S_SDF_PPP(struct S_PPP p0, double p1, float p2,  struct S_PPP (*cb)(struct S_PPP, double, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_I f18_S_SDD_I(struct S_I p0, double p1, double p2,  struct S_I (*cb)(struct S_I, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_F f18_S_SDD_F(struct S_F p0, double p1, double p2,  struct S_F (*cb)(struct S_F, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_D f18_S_SDD_D(struct S_D p0, double p1, double p2,  struct S_D (*cb)(struct S_D, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_P f18_S_SDD_P(struct S_P p0, double p1, double p2,  struct S_P (*cb)(struct S_P, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_II f18_S_SDD_II(struct S_II p0, double p1, double p2,  struct S_II (*cb)(struct S_II, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IF f18_S_SDD_IF(struct S_IF p0, double p1, double p2,  struct S_IF (*cb)(struct S_IF, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_ID f18_S_SDD_ID(struct S_ID p0, double p1, double p2,  struct S_ID (*cb)(struct S_ID, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IP f18_S_SDD_IP(struct S_IP p0, double p1, double p2,  struct S_IP (*cb)(struct S_IP, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FI f18_S_SDD_FI(struct S_FI p0, double p1, double p2,  struct S_FI (*cb)(struct S_FI, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FF f18_S_SDD_FF(struct S_FF p0, double p1, double p2,  struct S_FF (*cb)(struct S_FF, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FD f18_S_SDD_FD(struct S_FD p0, double p1, double p2,  struct S_FD (*cb)(struct S_FD, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FP f18_S_SDD_FP(struct S_FP p0, double p1, double p2,  struct S_FP (*cb)(struct S_FP, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DI f18_S_SDD_DI(struct S_DI p0, double p1, double p2,  struct S_DI (*cb)(struct S_DI, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DF f18_S_SDD_DF(struct S_DF p0, double p1, double p2,  struct S_DF (*cb)(struct S_DF, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DD f18_S_SDD_DD(struct S_DD p0, double p1, double p2,  struct S_DD (*cb)(struct S_DD, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DP f18_S_SDD_DP(struct S_DP p0, double p1, double p2,  struct S_DP (*cb)(struct S_DP, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PI f18_S_SDD_PI(struct S_PI p0, double p1, double p2,  struct S_PI (*cb)(struct S_PI, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PF f18_S_SDD_PF(struct S_PF p0, double p1, double p2,  struct S_PF (*cb)(struct S_PF, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PD f18_S_SDD_PD(struct S_PD p0, double p1, double p2,  struct S_PD (*cb)(struct S_PD, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PP f18_S_SDD_PP(struct S_PP p0, double p1, double p2,  struct S_PP (*cb)(struct S_PP, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_III f18_S_SDD_III(struct S_III p0, double p1, double p2,  struct S_III (*cb)(struct S_III, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IIF f18_S_SDD_IIF(struct S_IIF p0, double p1, double p2,  struct S_IIF (*cb)(struct S_IIF, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IID f18_S_SDD_IID(struct S_IID p0, double p1, double p2,  struct S_IID (*cb)(struct S_IID, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IIP f18_S_SDD_IIP(struct S_IIP p0, double p1, double p2,  struct S_IIP (*cb)(struct S_IIP, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFI f18_S_SDD_IFI(struct S_IFI p0, double p1, double p2,  struct S_IFI (*cb)(struct S_IFI, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFF f18_S_SDD_IFF(struct S_IFF p0, double p1, double p2,  struct S_IFF (*cb)(struct S_IFF, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFD f18_S_SDD_IFD(struct S_IFD p0, double p1, double p2,  struct S_IFD (*cb)(struct S_IFD, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFP f18_S_SDD_IFP(struct S_IFP p0, double p1, double p2,  struct S_IFP (*cb)(struct S_IFP, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDI f18_S_SDD_IDI(struct S_IDI p0, double p1, double p2,  struct S_IDI (*cb)(struct S_IDI, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDF f18_S_SDD_IDF(struct S_IDF p0, double p1, double p2,  struct S_IDF (*cb)(struct S_IDF, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDD f18_S_SDD_IDD(struct S_IDD p0, double p1, double p2,  struct S_IDD (*cb)(struct S_IDD, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDP f18_S_SDD_IDP(struct S_IDP p0, double p1, double p2,  struct S_IDP (*cb)(struct S_IDP, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPI f18_S_SDD_IPI(struct S_IPI p0, double p1, double p2,  struct S_IPI (*cb)(struct S_IPI, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPF f18_S_SDD_IPF(struct S_IPF p0, double p1, double p2,  struct S_IPF (*cb)(struct S_IPF, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPD f18_S_SDD_IPD(struct S_IPD p0, double p1, double p2,  struct S_IPD (*cb)(struct S_IPD, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPP f18_S_SDD_IPP(struct S_IPP p0, double p1, double p2,  struct S_IPP (*cb)(struct S_IPP, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FII f18_S_SDD_FII(struct S_FII p0, double p1, double p2,  struct S_FII (*cb)(struct S_FII, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FIF f18_S_SDD_FIF(struct S_FIF p0, double p1, double p2,  struct S_FIF (*cb)(struct S_FIF, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FID f18_S_SDD_FID(struct S_FID p0, double p1, double p2,  struct S_FID (*cb)(struct S_FID, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FIP f18_S_SDD_FIP(struct S_FIP p0, double p1, double p2,  struct S_FIP (*cb)(struct S_FIP, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFI f18_S_SDD_FFI(struct S_FFI p0, double p1, double p2,  struct S_FFI (*cb)(struct S_FFI, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFF f18_S_SDD_FFF(struct S_FFF p0, double p1, double p2,  struct S_FFF (*cb)(struct S_FFF, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFD f18_S_SDD_FFD(struct S_FFD p0, double p1, double p2,  struct S_FFD (*cb)(struct S_FFD, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFP f18_S_SDD_FFP(struct S_FFP p0, double p1, double p2,  struct S_FFP (*cb)(struct S_FFP, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDI f18_S_SDD_FDI(struct S_FDI p0, double p1, double p2,  struct S_FDI (*cb)(struct S_FDI, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDF f18_S_SDD_FDF(struct S_FDF p0, double p1, double p2,  struct S_FDF (*cb)(struct S_FDF, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDD f18_S_SDD_FDD(struct S_FDD p0, double p1, double p2,  struct S_FDD (*cb)(struct S_FDD, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDP f18_S_SDD_FDP(struct S_FDP p0, double p1, double p2,  struct S_FDP (*cb)(struct S_FDP, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPI f18_S_SDD_FPI(struct S_FPI p0, double p1, double p2,  struct S_FPI (*cb)(struct S_FPI, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPF f18_S_SDD_FPF(struct S_FPF p0, double p1, double p2,  struct S_FPF (*cb)(struct S_FPF, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPD f18_S_SDD_FPD(struct S_FPD p0, double p1, double p2,  struct S_FPD (*cb)(struct S_FPD, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPP f18_S_SDD_FPP(struct S_FPP p0, double p1, double p2,  struct S_FPP (*cb)(struct S_FPP, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DII f18_S_SDD_DII(struct S_DII p0, double p1, double p2,  struct S_DII (*cb)(struct S_DII, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DIF f18_S_SDD_DIF(struct S_DIF p0, double p1, double p2,  struct S_DIF (*cb)(struct S_DIF, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DID f18_S_SDD_DID(struct S_DID p0, double p1, double p2,  struct S_DID (*cb)(struct S_DID, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DIP f18_S_SDD_DIP(struct S_DIP p0, double p1, double p2,  struct S_DIP (*cb)(struct S_DIP, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFI f18_S_SDD_DFI(struct S_DFI p0, double p1, double p2,  struct S_DFI (*cb)(struct S_DFI, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFF f18_S_SDD_DFF(struct S_DFF p0, double p1, double p2,  struct S_DFF (*cb)(struct S_DFF, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFD f18_S_SDD_DFD(struct S_DFD p0, double p1, double p2,  struct S_DFD (*cb)(struct S_DFD, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFP f18_S_SDD_DFP(struct S_DFP p0, double p1, double p2,  struct S_DFP (*cb)(struct S_DFP, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDI f18_S_SDD_DDI(struct S_DDI p0, double p1, double p2,  struct S_DDI (*cb)(struct S_DDI, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDF f18_S_SDD_DDF(struct S_DDF p0, double p1, double p2,  struct S_DDF (*cb)(struct S_DDF, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDD f18_S_SDD_DDD(struct S_DDD p0, double p1, double p2,  struct S_DDD (*cb)(struct S_DDD, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDP f18_S_SDD_DDP(struct S_DDP p0, double p1, double p2,  struct S_DDP (*cb)(struct S_DDP, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPI f18_S_SDD_DPI(struct S_DPI p0, double p1, double p2,  struct S_DPI (*cb)(struct S_DPI, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPF f18_S_SDD_DPF(struct S_DPF p0, double p1, double p2,  struct S_DPF (*cb)(struct S_DPF, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPD f18_S_SDD_DPD(struct S_DPD p0, double p1, double p2,  struct S_DPD (*cb)(struct S_DPD, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPP f18_S_SDD_DPP(struct S_DPP p0, double p1, double p2,  struct S_DPP (*cb)(struct S_DPP, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PII f18_S_SDD_PII(struct S_PII p0, double p1, double p2,  struct S_PII (*cb)(struct S_PII, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PIF f18_S_SDD_PIF(struct S_PIF p0, double p1, double p2,  struct S_PIF (*cb)(struct S_PIF, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PID f18_S_SDD_PID(struct S_PID p0, double p1, double p2,  struct S_PID (*cb)(struct S_PID, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PIP f18_S_SDD_PIP(struct S_PIP p0, double p1, double p2,  struct S_PIP (*cb)(struct S_PIP, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFI f18_S_SDD_PFI(struct S_PFI p0, double p1, double p2,  struct S_PFI (*cb)(struct S_PFI, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFF f18_S_SDD_PFF(struct S_PFF p0, double p1, double p2,  struct S_PFF (*cb)(struct S_PFF, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFD f18_S_SDD_PFD(struct S_PFD p0, double p1, double p2,  struct S_PFD (*cb)(struct S_PFD, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFP f18_S_SDD_PFP(struct S_PFP p0, double p1, double p2,  struct S_PFP (*cb)(struct S_PFP, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDI f18_S_SDD_PDI(struct S_PDI p0, double p1, double p2,  struct S_PDI (*cb)(struct S_PDI, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDF f18_S_SDD_PDF(struct S_PDF p0, double p1, double p2,  struct S_PDF (*cb)(struct S_PDF, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDD f18_S_SDD_PDD(struct S_PDD p0, double p1, double p2,  struct S_PDD (*cb)(struct S_PDD, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDP f18_S_SDD_PDP(struct S_PDP p0, double p1, double p2,  struct S_PDP (*cb)(struct S_PDP, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPI f18_S_SDD_PPI(struct S_PPI p0, double p1, double p2,  struct S_PPI (*cb)(struct S_PPI, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPF f18_S_SDD_PPF(struct S_PPF p0, double p1, double p2,  struct S_PPF (*cb)(struct S_PPF, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPD f18_S_SDD_PPD(struct S_PPD p0, double p1, double p2,  struct S_PPD (*cb)(struct S_PPD, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPP f18_S_SDD_PPP(struct S_PPP p0, double p1, double p2,  struct S_PPP (*cb)(struct S_PPP, double, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_I f18_S_SDP_I(struct S_I p0, double p1, void* p2,  struct S_I (*cb)(struct S_I, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_F f18_S_SDP_F(struct S_F p0, double p1, void* p2,  struct S_F (*cb)(struct S_F, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_D f18_S_SDP_D(struct S_D p0, double p1, void* p2,  struct S_D (*cb)(struct S_D, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_P f18_S_SDP_P(struct S_P p0, double p1, void* p2,  struct S_P (*cb)(struct S_P, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_II f18_S_SDP_II(struct S_II p0, double p1, void* p2,  struct S_II (*cb)(struct S_II, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IF f18_S_SDP_IF(struct S_IF p0, double p1, void* p2,  struct S_IF (*cb)(struct S_IF, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_ID f18_S_SDP_ID(struct S_ID p0, double p1, void* p2,  struct S_ID (*cb)(struct S_ID, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IP f18_S_SDP_IP(struct S_IP p0, double p1, void* p2,  struct S_IP (*cb)(struct S_IP, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FI f18_S_SDP_FI(struct S_FI p0, double p1, void* p2,  struct S_FI (*cb)(struct S_FI, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FF f18_S_SDP_FF(struct S_FF p0, double p1, void* p2,  struct S_FF (*cb)(struct S_FF, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FD f18_S_SDP_FD(struct S_FD p0, double p1, void* p2,  struct S_FD (*cb)(struct S_FD, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FP f18_S_SDP_FP(struct S_FP p0, double p1, void* p2,  struct S_FP (*cb)(struct S_FP, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DI f18_S_SDP_DI(struct S_DI p0, double p1, void* p2,  struct S_DI (*cb)(struct S_DI, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DF f18_S_SDP_DF(struct S_DF p0, double p1, void* p2,  struct S_DF (*cb)(struct S_DF, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DD f18_S_SDP_DD(struct S_DD p0, double p1, void* p2,  struct S_DD (*cb)(struct S_DD, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DP f18_S_SDP_DP(struct S_DP p0, double p1, void* p2,  struct S_DP (*cb)(struct S_DP, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PI f18_S_SDP_PI(struct S_PI p0, double p1, void* p2,  struct S_PI (*cb)(struct S_PI, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PF f18_S_SDP_PF(struct S_PF p0, double p1, void* p2,  struct S_PF (*cb)(struct S_PF, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PD f18_S_SDP_PD(struct S_PD p0, double p1, void* p2,  struct S_PD (*cb)(struct S_PD, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PP f18_S_SDP_PP(struct S_PP p0, double p1, void* p2,  struct S_PP (*cb)(struct S_PP, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_III f18_S_SDP_III(struct S_III p0, double p1, void* p2,  struct S_III (*cb)(struct S_III, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IIF f18_S_SDP_IIF(struct S_IIF p0, double p1, void* p2,  struct S_IIF (*cb)(struct S_IIF, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IID f18_S_SDP_IID(struct S_IID p0, double p1, void* p2,  struct S_IID (*cb)(struct S_IID, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IIP f18_S_SDP_IIP(struct S_IIP p0, double p1, void* p2,  struct S_IIP (*cb)(struct S_IIP, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFI f18_S_SDP_IFI(struct S_IFI p0, double p1, void* p2,  struct S_IFI (*cb)(struct S_IFI, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFF f18_S_SDP_IFF(struct S_IFF p0, double p1, void* p2,  struct S_IFF (*cb)(struct S_IFF, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFD f18_S_SDP_IFD(struct S_IFD p0, double p1, void* p2,  struct S_IFD (*cb)(struct S_IFD, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFP f18_S_SDP_IFP(struct S_IFP p0, double p1, void* p2,  struct S_IFP (*cb)(struct S_IFP, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDI f18_S_SDP_IDI(struct S_IDI p0, double p1, void* p2,  struct S_IDI (*cb)(struct S_IDI, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDF f18_S_SDP_IDF(struct S_IDF p0, double p1, void* p2,  struct S_IDF (*cb)(struct S_IDF, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDD f18_S_SDP_IDD(struct S_IDD p0, double p1, void* p2,  struct S_IDD (*cb)(struct S_IDD, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDP f18_S_SDP_IDP(struct S_IDP p0, double p1, void* p2,  struct S_IDP (*cb)(struct S_IDP, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPI f18_S_SDP_IPI(struct S_IPI p0, double p1, void* p2,  struct S_IPI (*cb)(struct S_IPI, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPF f18_S_SDP_IPF(struct S_IPF p0, double p1, void* p2,  struct S_IPF (*cb)(struct S_IPF, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPD f18_S_SDP_IPD(struct S_IPD p0, double p1, void* p2,  struct S_IPD (*cb)(struct S_IPD, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPP f18_S_SDP_IPP(struct S_IPP p0, double p1, void* p2,  struct S_IPP (*cb)(struct S_IPP, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FII f18_S_SDP_FII(struct S_FII p0, double p1, void* p2,  struct S_FII (*cb)(struct S_FII, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FIF f18_S_SDP_FIF(struct S_FIF p0, double p1, void* p2,  struct S_FIF (*cb)(struct S_FIF, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FID f18_S_SDP_FID(struct S_FID p0, double p1, void* p2,  struct S_FID (*cb)(struct S_FID, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FIP f18_S_SDP_FIP(struct S_FIP p0, double p1, void* p2,  struct S_FIP (*cb)(struct S_FIP, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFI f18_S_SDP_FFI(struct S_FFI p0, double p1, void* p2,  struct S_FFI (*cb)(struct S_FFI, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFF f18_S_SDP_FFF(struct S_FFF p0, double p1, void* p2,  struct S_FFF (*cb)(struct S_FFF, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFD f18_S_SDP_FFD(struct S_FFD p0, double p1, void* p2,  struct S_FFD (*cb)(struct S_FFD, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFP f18_S_SDP_FFP(struct S_FFP p0, double p1, void* p2,  struct S_FFP (*cb)(struct S_FFP, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDI f18_S_SDP_FDI(struct S_FDI p0, double p1, void* p2,  struct S_FDI (*cb)(struct S_FDI, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDF f18_S_SDP_FDF(struct S_FDF p0, double p1, void* p2,  struct S_FDF (*cb)(struct S_FDF, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDD f18_S_SDP_FDD(struct S_FDD p0, double p1, void* p2,  struct S_FDD (*cb)(struct S_FDD, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDP f18_S_SDP_FDP(struct S_FDP p0, double p1, void* p2,  struct S_FDP (*cb)(struct S_FDP, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPI f18_S_SDP_FPI(struct S_FPI p0, double p1, void* p2,  struct S_FPI (*cb)(struct S_FPI, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPF f18_S_SDP_FPF(struct S_FPF p0, double p1, void* p2,  struct S_FPF (*cb)(struct S_FPF, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPD f18_S_SDP_FPD(struct S_FPD p0, double p1, void* p2,  struct S_FPD (*cb)(struct S_FPD, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPP f18_S_SDP_FPP(struct S_FPP p0, double p1, void* p2,  struct S_FPP (*cb)(struct S_FPP, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DII f18_S_SDP_DII(struct S_DII p0, double p1, void* p2,  struct S_DII (*cb)(struct S_DII, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DIF f18_S_SDP_DIF(struct S_DIF p0, double p1, void* p2,  struct S_DIF (*cb)(struct S_DIF, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DID f18_S_SDP_DID(struct S_DID p0, double p1, void* p2,  struct S_DID (*cb)(struct S_DID, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DIP f18_S_SDP_DIP(struct S_DIP p0, double p1, void* p2,  struct S_DIP (*cb)(struct S_DIP, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFI f18_S_SDP_DFI(struct S_DFI p0, double p1, void* p2,  struct S_DFI (*cb)(struct S_DFI, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFF f18_S_SDP_DFF(struct S_DFF p0, double p1, void* p2,  struct S_DFF (*cb)(struct S_DFF, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFD f18_S_SDP_DFD(struct S_DFD p0, double p1, void* p2,  struct S_DFD (*cb)(struct S_DFD, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFP f18_S_SDP_DFP(struct S_DFP p0, double p1, void* p2,  struct S_DFP (*cb)(struct S_DFP, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDI f18_S_SDP_DDI(struct S_DDI p0, double p1, void* p2,  struct S_DDI (*cb)(struct S_DDI, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDF f18_S_SDP_DDF(struct S_DDF p0, double p1, void* p2,  struct S_DDF (*cb)(struct S_DDF, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDD f18_S_SDP_DDD(struct S_DDD p0, double p1, void* p2,  struct S_DDD (*cb)(struct S_DDD, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDP f18_S_SDP_DDP(struct S_DDP p0, double p1, void* p2,  struct S_DDP (*cb)(struct S_DDP, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPI f18_S_SDP_DPI(struct S_DPI p0, double p1, void* p2,  struct S_DPI (*cb)(struct S_DPI, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPF f18_S_SDP_DPF(struct S_DPF p0, double p1, void* p2,  struct S_DPF (*cb)(struct S_DPF, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPD f18_S_SDP_DPD(struct S_DPD p0, double p1, void* p2,  struct S_DPD (*cb)(struct S_DPD, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPP f18_S_SDP_DPP(struct S_DPP p0, double p1, void* p2,  struct S_DPP (*cb)(struct S_DPP, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PII f18_S_SDP_PII(struct S_PII p0, double p1, void* p2,  struct S_PII (*cb)(struct S_PII, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PIF f18_S_SDP_PIF(struct S_PIF p0, double p1, void* p2,  struct S_PIF (*cb)(struct S_PIF, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PID f18_S_SDP_PID(struct S_PID p0, double p1, void* p2,  struct S_PID (*cb)(struct S_PID, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PIP f18_S_SDP_PIP(struct S_PIP p0, double p1, void* p2,  struct S_PIP (*cb)(struct S_PIP, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFI f18_S_SDP_PFI(struct S_PFI p0, double p1, void* p2,  struct S_PFI (*cb)(struct S_PFI, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFF f18_S_SDP_PFF(struct S_PFF p0, double p1, void* p2,  struct S_PFF (*cb)(struct S_PFF, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFD f18_S_SDP_PFD(struct S_PFD p0, double p1, void* p2,  struct S_PFD (*cb)(struct S_PFD, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFP f18_S_SDP_PFP(struct S_PFP p0, double p1, void* p2,  struct S_PFP (*cb)(struct S_PFP, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDI f18_S_SDP_PDI(struct S_PDI p0, double p1, void* p2,  struct S_PDI (*cb)(struct S_PDI, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDF f18_S_SDP_PDF(struct S_PDF p0, double p1, void* p2,  struct S_PDF (*cb)(struct S_PDF, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDD f18_S_SDP_PDD(struct S_PDD p0, double p1, void* p2,  struct S_PDD (*cb)(struct S_PDD, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDP f18_S_SDP_PDP(struct S_PDP p0, double p1, void* p2,  struct S_PDP (*cb)(struct S_PDP, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPI f18_S_SDP_PPI(struct S_PPI p0, double p1, void* p2,  struct S_PPI (*cb)(struct S_PPI, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPF f18_S_SDP_PPF(struct S_PPF p0, double p1, void* p2,  struct S_PPF (*cb)(struct S_PPF, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPD f18_S_SDP_PPD(struct S_PPD p0, double p1, void* p2,  struct S_PPD (*cb)(struct S_PPD, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPP f18_S_SDP_PPP(struct S_PPP p0, double p1, void* p2,  struct S_PPP (*cb)(struct S_PPP, double, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_I f18_S_SDS_I(struct S_I p0, double p1, struct S_I p2,  struct S_I (*cb)(struct S_I, double, struct S_I)) { return cb(p0,p1,p2); }
+EXPORT struct S_F f18_S_SDS_F(struct S_F p0, double p1, struct S_F p2,  struct S_F (*cb)(struct S_F, double, struct S_F)) { return cb(p0,p1,p2); }
+EXPORT struct S_D f18_S_SDS_D(struct S_D p0, double p1, struct S_D p2,  struct S_D (*cb)(struct S_D, double, struct S_D)) { return cb(p0,p1,p2); }
+EXPORT struct S_P f18_S_SDS_P(struct S_P p0, double p1, struct S_P p2,  struct S_P (*cb)(struct S_P, double, struct S_P)) { return cb(p0,p1,p2); }
+EXPORT struct S_II f18_S_SDS_II(struct S_II p0, double p1, struct S_II p2,  struct S_II (*cb)(struct S_II, double, struct S_II)) { return cb(p0,p1,p2); }
+EXPORT struct S_IF f18_S_SDS_IF(struct S_IF p0, double p1, struct S_IF p2,  struct S_IF (*cb)(struct S_IF, double, struct S_IF)) { return cb(p0,p1,p2); }
+EXPORT struct S_ID f18_S_SDS_ID(struct S_ID p0, double p1, struct S_ID p2,  struct S_ID (*cb)(struct S_ID, double, struct S_ID)) { return cb(p0,p1,p2); }
+EXPORT struct S_IP f18_S_SDS_IP(struct S_IP p0, double p1, struct S_IP p2,  struct S_IP (*cb)(struct S_IP, double, struct S_IP)) { return cb(p0,p1,p2); }
+EXPORT struct S_FI f18_S_SDS_FI(struct S_FI p0, double p1, struct S_FI p2,  struct S_FI (*cb)(struct S_FI, double, struct S_FI)) { return cb(p0,p1,p2); }
+EXPORT struct S_FF f18_S_SDS_FF(struct S_FF p0, double p1, struct S_FF p2,  struct S_FF (*cb)(struct S_FF, double, struct S_FF)) { return cb(p0,p1,p2); }
+EXPORT struct S_FD f18_S_SDS_FD(struct S_FD p0, double p1, struct S_FD p2,  struct S_FD (*cb)(struct S_FD, double, struct S_FD)) { return cb(p0,p1,p2); }
+EXPORT struct S_FP f18_S_SDS_FP(struct S_FP p0, double p1, struct S_FP p2,  struct S_FP (*cb)(struct S_FP, double, struct S_FP)) { return cb(p0,p1,p2); }
+EXPORT struct S_DI f18_S_SDS_DI(struct S_DI p0, double p1, struct S_DI p2,  struct S_DI (*cb)(struct S_DI, double, struct S_DI)) { return cb(p0,p1,p2); }
+EXPORT struct S_DF f18_S_SDS_DF(struct S_DF p0, double p1, struct S_DF p2,  struct S_DF (*cb)(struct S_DF, double, struct S_DF)) { return cb(p0,p1,p2); }
+EXPORT struct S_DD f18_S_SDS_DD(struct S_DD p0, double p1, struct S_DD p2,  struct S_DD (*cb)(struct S_DD, double, struct S_DD)) { return cb(p0,p1,p2); }
+EXPORT struct S_DP f18_S_SDS_DP(struct S_DP p0, double p1, struct S_DP p2,  struct S_DP (*cb)(struct S_DP, double, struct S_DP)) { return cb(p0,p1,p2); }
+EXPORT struct S_PI f18_S_SDS_PI(struct S_PI p0, double p1, struct S_PI p2,  struct S_PI (*cb)(struct S_PI, double, struct S_PI)) { return cb(p0,p1,p2); }
+EXPORT struct S_PF f18_S_SDS_PF(struct S_PF p0, double p1, struct S_PF p2,  struct S_PF (*cb)(struct S_PF, double, struct S_PF)) { return cb(p0,p1,p2); }
+EXPORT struct S_PD f18_S_SDS_PD(struct S_PD p0, double p1, struct S_PD p2,  struct S_PD (*cb)(struct S_PD, double, struct S_PD)) { return cb(p0,p1,p2); }
+EXPORT struct S_PP f18_S_SDS_PP(struct S_PP p0, double p1, struct S_PP p2,  struct S_PP (*cb)(struct S_PP, double, struct S_PP)) { return cb(p0,p1,p2); }
+EXPORT struct S_III f18_S_SDS_III(struct S_III p0, double p1, struct S_III p2,  struct S_III (*cb)(struct S_III, double, struct S_III)) { return cb(p0,p1,p2); }
+EXPORT struct S_IIF f18_S_SDS_IIF(struct S_IIF p0, double p1, struct S_IIF p2,  struct S_IIF (*cb)(struct S_IIF, double, struct S_IIF)) { return cb(p0,p1,p2); }
+EXPORT struct S_IID f18_S_SDS_IID(struct S_IID p0, double p1, struct S_IID p2,  struct S_IID (*cb)(struct S_IID, double, struct S_IID)) { return cb(p0,p1,p2); }
+EXPORT struct S_IIP f18_S_SDS_IIP(struct S_IIP p0, double p1, struct S_IIP p2,  struct S_IIP (*cb)(struct S_IIP, double, struct S_IIP)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFI f18_S_SDS_IFI(struct S_IFI p0, double p1, struct S_IFI p2,  struct S_IFI (*cb)(struct S_IFI, double, struct S_IFI)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFF f18_S_SDS_IFF(struct S_IFF p0, double p1, struct S_IFF p2,  struct S_IFF (*cb)(struct S_IFF, double, struct S_IFF)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFD f18_S_SDS_IFD(struct S_IFD p0, double p1, struct S_IFD p2,  struct S_IFD (*cb)(struct S_IFD, double, struct S_IFD)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFP f18_S_SDS_IFP(struct S_IFP p0, double p1, struct S_IFP p2,  struct S_IFP (*cb)(struct S_IFP, double, struct S_IFP)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDI f18_S_SDS_IDI(struct S_IDI p0, double p1, struct S_IDI p2,  struct S_IDI (*cb)(struct S_IDI, double, struct S_IDI)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDF f18_S_SDS_IDF(struct S_IDF p0, double p1, struct S_IDF p2,  struct S_IDF (*cb)(struct S_IDF, double, struct S_IDF)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDD f18_S_SDS_IDD(struct S_IDD p0, double p1, struct S_IDD p2,  struct S_IDD (*cb)(struct S_IDD, double, struct S_IDD)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDP f18_S_SDS_IDP(struct S_IDP p0, double p1, struct S_IDP p2,  struct S_IDP (*cb)(struct S_IDP, double, struct S_IDP)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPI f18_S_SDS_IPI(struct S_IPI p0, double p1, struct S_IPI p2,  struct S_IPI (*cb)(struct S_IPI, double, struct S_IPI)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPF f18_S_SDS_IPF(struct S_IPF p0, double p1, struct S_IPF p2,  struct S_IPF (*cb)(struct S_IPF, double, struct S_IPF)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPD f18_S_SDS_IPD(struct S_IPD p0, double p1, struct S_IPD p2,  struct S_IPD (*cb)(struct S_IPD, double, struct S_IPD)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPP f18_S_SDS_IPP(struct S_IPP p0, double p1, struct S_IPP p2,  struct S_IPP (*cb)(struct S_IPP, double, struct S_IPP)) { return cb(p0,p1,p2); }
+EXPORT struct S_FII f18_S_SDS_FII(struct S_FII p0, double p1, struct S_FII p2,  struct S_FII (*cb)(struct S_FII, double, struct S_FII)) { return cb(p0,p1,p2); }
+EXPORT struct S_FIF f18_S_SDS_FIF(struct S_FIF p0, double p1, struct S_FIF p2,  struct S_FIF (*cb)(struct S_FIF, double, struct S_FIF)) { return cb(p0,p1,p2); }
+EXPORT struct S_FID f18_S_SDS_FID(struct S_FID p0, double p1, struct S_FID p2,  struct S_FID (*cb)(struct S_FID, double, struct S_FID)) { return cb(p0,p1,p2); }
+EXPORT struct S_FIP f18_S_SDS_FIP(struct S_FIP p0, double p1, struct S_FIP p2,  struct S_FIP (*cb)(struct S_FIP, double, struct S_FIP)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFI f18_S_SDS_FFI(struct S_FFI p0, double p1, struct S_FFI p2,  struct S_FFI (*cb)(struct S_FFI, double, struct S_FFI)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFF f18_S_SDS_FFF(struct S_FFF p0, double p1, struct S_FFF p2,  struct S_FFF (*cb)(struct S_FFF, double, struct S_FFF)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFD f18_S_SDS_FFD(struct S_FFD p0, double p1, struct S_FFD p2,  struct S_FFD (*cb)(struct S_FFD, double, struct S_FFD)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFP f18_S_SDS_FFP(struct S_FFP p0, double p1, struct S_FFP p2,  struct S_FFP (*cb)(struct S_FFP, double, struct S_FFP)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDI f18_S_SDS_FDI(struct S_FDI p0, double p1, struct S_FDI p2,  struct S_FDI (*cb)(struct S_FDI, double, struct S_FDI)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDF f18_S_SDS_FDF(struct S_FDF p0, double p1, struct S_FDF p2,  struct S_FDF (*cb)(struct S_FDF, double, struct S_FDF)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDD f18_S_SDS_FDD(struct S_FDD p0, double p1, struct S_FDD p2,  struct S_FDD (*cb)(struct S_FDD, double, struct S_FDD)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDP f18_S_SDS_FDP(struct S_FDP p0, double p1, struct S_FDP p2,  struct S_FDP (*cb)(struct S_FDP, double, struct S_FDP)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPI f18_S_SDS_FPI(struct S_FPI p0, double p1, struct S_FPI p2,  struct S_FPI (*cb)(struct S_FPI, double, struct S_FPI)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPF f18_S_SDS_FPF(struct S_FPF p0, double p1, struct S_FPF p2,  struct S_FPF (*cb)(struct S_FPF, double, struct S_FPF)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPD f18_S_SDS_FPD(struct S_FPD p0, double p1, struct S_FPD p2,  struct S_FPD (*cb)(struct S_FPD, double, struct S_FPD)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPP f18_S_SDS_FPP(struct S_FPP p0, double p1, struct S_FPP p2,  struct S_FPP (*cb)(struct S_FPP, double, struct S_FPP)) { return cb(p0,p1,p2); }
+EXPORT struct S_DII f18_S_SDS_DII(struct S_DII p0, double p1, struct S_DII p2,  struct S_DII (*cb)(struct S_DII, double, struct S_DII)) { return cb(p0,p1,p2); }
+EXPORT struct S_DIF f18_S_SDS_DIF(struct S_DIF p0, double p1, struct S_DIF p2,  struct S_DIF (*cb)(struct S_DIF, double, struct S_DIF)) { return cb(p0,p1,p2); }
+EXPORT struct S_DID f18_S_SDS_DID(struct S_DID p0, double p1, struct S_DID p2,  struct S_DID (*cb)(struct S_DID, double, struct S_DID)) { return cb(p0,p1,p2); }
+EXPORT struct S_DIP f18_S_SDS_DIP(struct S_DIP p0, double p1, struct S_DIP p2,  struct S_DIP (*cb)(struct S_DIP, double, struct S_DIP)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFI f18_S_SDS_DFI(struct S_DFI p0, double p1, struct S_DFI p2,  struct S_DFI (*cb)(struct S_DFI, double, struct S_DFI)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFF f18_S_SDS_DFF(struct S_DFF p0, double p1, struct S_DFF p2,  struct S_DFF (*cb)(struct S_DFF, double, struct S_DFF)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFD f18_S_SDS_DFD(struct S_DFD p0, double p1, struct S_DFD p2,  struct S_DFD (*cb)(struct S_DFD, double, struct S_DFD)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFP f18_S_SDS_DFP(struct S_DFP p0, double p1, struct S_DFP p2,  struct S_DFP (*cb)(struct S_DFP, double, struct S_DFP)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDI f18_S_SDS_DDI(struct S_DDI p0, double p1, struct S_DDI p2,  struct S_DDI (*cb)(struct S_DDI, double, struct S_DDI)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDF f18_S_SDS_DDF(struct S_DDF p0, double p1, struct S_DDF p2,  struct S_DDF (*cb)(struct S_DDF, double, struct S_DDF)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDD f18_S_SDS_DDD(struct S_DDD p0, double p1, struct S_DDD p2,  struct S_DDD (*cb)(struct S_DDD, double, struct S_DDD)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDP f18_S_SDS_DDP(struct S_DDP p0, double p1, struct S_DDP p2,  struct S_DDP (*cb)(struct S_DDP, double, struct S_DDP)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPI f18_S_SDS_DPI(struct S_DPI p0, double p1, struct S_DPI p2,  struct S_DPI (*cb)(struct S_DPI, double, struct S_DPI)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPF f18_S_SDS_DPF(struct S_DPF p0, double p1, struct S_DPF p2,  struct S_DPF (*cb)(struct S_DPF, double, struct S_DPF)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPD f18_S_SDS_DPD(struct S_DPD p0, double p1, struct S_DPD p2,  struct S_DPD (*cb)(struct S_DPD, double, struct S_DPD)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPP f18_S_SDS_DPP(struct S_DPP p0, double p1, struct S_DPP p2,  struct S_DPP (*cb)(struct S_DPP, double, struct S_DPP)) { return cb(p0,p1,p2); }
+EXPORT struct S_PII f18_S_SDS_PII(struct S_PII p0, double p1, struct S_PII p2,  struct S_PII (*cb)(struct S_PII, double, struct S_PII)) { return cb(p0,p1,p2); }
+EXPORT struct S_PIF f18_S_SDS_PIF(struct S_PIF p0, double p1, struct S_PIF p2,  struct S_PIF (*cb)(struct S_PIF, double, struct S_PIF)) { return cb(p0,p1,p2); }
+EXPORT struct S_PID f18_S_SDS_PID(struct S_PID p0, double p1, struct S_PID p2,  struct S_PID (*cb)(struct S_PID, double, struct S_PID)) { return cb(p0,p1,p2); }
+EXPORT struct S_PIP f18_S_SDS_PIP(struct S_PIP p0, double p1, struct S_PIP p2,  struct S_PIP (*cb)(struct S_PIP, double, struct S_PIP)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFI f18_S_SDS_PFI(struct S_PFI p0, double p1, struct S_PFI p2,  struct S_PFI (*cb)(struct S_PFI, double, struct S_PFI)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFF f18_S_SDS_PFF(struct S_PFF p0, double p1, struct S_PFF p2,  struct S_PFF (*cb)(struct S_PFF, double, struct S_PFF)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFD f18_S_SDS_PFD(struct S_PFD p0, double p1, struct S_PFD p2,  struct S_PFD (*cb)(struct S_PFD, double, struct S_PFD)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFP f18_S_SDS_PFP(struct S_PFP p0, double p1, struct S_PFP p2,  struct S_PFP (*cb)(struct S_PFP, double, struct S_PFP)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDI f18_S_SDS_PDI(struct S_PDI p0, double p1, struct S_PDI p2,  struct S_PDI (*cb)(struct S_PDI, double, struct S_PDI)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDF f18_S_SDS_PDF(struct S_PDF p0, double p1, struct S_PDF p2,  struct S_PDF (*cb)(struct S_PDF, double, struct S_PDF)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDD f18_S_SDS_PDD(struct S_PDD p0, double p1, struct S_PDD p2,  struct S_PDD (*cb)(struct S_PDD, double, struct S_PDD)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDP f18_S_SDS_PDP(struct S_PDP p0, double p1, struct S_PDP p2,  struct S_PDP (*cb)(struct S_PDP, double, struct S_PDP)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPI f18_S_SDS_PPI(struct S_PPI p0, double p1, struct S_PPI p2,  struct S_PPI (*cb)(struct S_PPI, double, struct S_PPI)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPF f18_S_SDS_PPF(struct S_PPF p0, double p1, struct S_PPF p2,  struct S_PPF (*cb)(struct S_PPF, double, struct S_PPF)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPD f18_S_SDS_PPD(struct S_PPD p0, double p1, struct S_PPD p2,  struct S_PPD (*cb)(struct S_PPD, double, struct S_PPD)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPP f18_S_SDS_PPP(struct S_PPP p0, double p1, struct S_PPP p2,  struct S_PPP (*cb)(struct S_PPP, double, struct S_PPP)) { return cb(p0,p1,p2); }
+EXPORT struct S_I f18_S_SPI_I(struct S_I p0, void* p1, int p2,  struct S_I (*cb)(struct S_I, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_F f18_S_SPI_F(struct S_F p0, void* p1, int p2,  struct S_F (*cb)(struct S_F, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_D f18_S_SPI_D(struct S_D p0, void* p1, int p2,  struct S_D (*cb)(struct S_D, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_P f18_S_SPI_P(struct S_P p0, void* p1, int p2,  struct S_P (*cb)(struct S_P, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_II f18_S_SPI_II(struct S_II p0, void* p1, int p2,  struct S_II (*cb)(struct S_II, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IF f18_S_SPI_IF(struct S_IF p0, void* p1, int p2,  struct S_IF (*cb)(struct S_IF, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_ID f18_S_SPI_ID(struct S_ID p0, void* p1, int p2,  struct S_ID (*cb)(struct S_ID, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IP f18_S_SPI_IP(struct S_IP p0, void* p1, int p2,  struct S_IP (*cb)(struct S_IP, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FI f18_S_SPI_FI(struct S_FI p0, void* p1, int p2,  struct S_FI (*cb)(struct S_FI, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FF f18_S_SPI_FF(struct S_FF p0, void* p1, int p2,  struct S_FF (*cb)(struct S_FF, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FD f18_S_SPI_FD(struct S_FD p0, void* p1, int p2,  struct S_FD (*cb)(struct S_FD, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FP f18_S_SPI_FP(struct S_FP p0, void* p1, int p2,  struct S_FP (*cb)(struct S_FP, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DI f18_S_SPI_DI(struct S_DI p0, void* p1, int p2,  struct S_DI (*cb)(struct S_DI, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DF f18_S_SPI_DF(struct S_DF p0, void* p1, int p2,  struct S_DF (*cb)(struct S_DF, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DD f18_S_SPI_DD(struct S_DD p0, void* p1, int p2,  struct S_DD (*cb)(struct S_DD, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DP f18_S_SPI_DP(struct S_DP p0, void* p1, int p2,  struct S_DP (*cb)(struct S_DP, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PI f18_S_SPI_PI(struct S_PI p0, void* p1, int p2,  struct S_PI (*cb)(struct S_PI, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PF f18_S_SPI_PF(struct S_PF p0, void* p1, int p2,  struct S_PF (*cb)(struct S_PF, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PD f18_S_SPI_PD(struct S_PD p0, void* p1, int p2,  struct S_PD (*cb)(struct S_PD, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PP f18_S_SPI_PP(struct S_PP p0, void* p1, int p2,  struct S_PP (*cb)(struct S_PP, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_III f18_S_SPI_III(struct S_III p0, void* p1, int p2,  struct S_III (*cb)(struct S_III, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IIF f18_S_SPI_IIF(struct S_IIF p0, void* p1, int p2,  struct S_IIF (*cb)(struct S_IIF, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IID f18_S_SPI_IID(struct S_IID p0, void* p1, int p2,  struct S_IID (*cb)(struct S_IID, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IIP f18_S_SPI_IIP(struct S_IIP p0, void* p1, int p2,  struct S_IIP (*cb)(struct S_IIP, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFI f18_S_SPI_IFI(struct S_IFI p0, void* p1, int p2,  struct S_IFI (*cb)(struct S_IFI, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFF f18_S_SPI_IFF(struct S_IFF p0, void* p1, int p2,  struct S_IFF (*cb)(struct S_IFF, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFD f18_S_SPI_IFD(struct S_IFD p0, void* p1, int p2,  struct S_IFD (*cb)(struct S_IFD, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFP f18_S_SPI_IFP(struct S_IFP p0, void* p1, int p2,  struct S_IFP (*cb)(struct S_IFP, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDI f18_S_SPI_IDI(struct S_IDI p0, void* p1, int p2,  struct S_IDI (*cb)(struct S_IDI, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDF f18_S_SPI_IDF(struct S_IDF p0, void* p1, int p2,  struct S_IDF (*cb)(struct S_IDF, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDD f18_S_SPI_IDD(struct S_IDD p0, void* p1, int p2,  struct S_IDD (*cb)(struct S_IDD, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDP f18_S_SPI_IDP(struct S_IDP p0, void* p1, int p2,  struct S_IDP (*cb)(struct S_IDP, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPI f18_S_SPI_IPI(struct S_IPI p0, void* p1, int p2,  struct S_IPI (*cb)(struct S_IPI, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPF f18_S_SPI_IPF(struct S_IPF p0, void* p1, int p2,  struct S_IPF (*cb)(struct S_IPF, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPD f18_S_SPI_IPD(struct S_IPD p0, void* p1, int p2,  struct S_IPD (*cb)(struct S_IPD, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPP f18_S_SPI_IPP(struct S_IPP p0, void* p1, int p2,  struct S_IPP (*cb)(struct S_IPP, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FII f18_S_SPI_FII(struct S_FII p0, void* p1, int p2,  struct S_FII (*cb)(struct S_FII, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FIF f18_S_SPI_FIF(struct S_FIF p0, void* p1, int p2,  struct S_FIF (*cb)(struct S_FIF, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FID f18_S_SPI_FID(struct S_FID p0, void* p1, int p2,  struct S_FID (*cb)(struct S_FID, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FIP f18_S_SPI_FIP(struct S_FIP p0, void* p1, int p2,  struct S_FIP (*cb)(struct S_FIP, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFI f18_S_SPI_FFI(struct S_FFI p0, void* p1, int p2,  struct S_FFI (*cb)(struct S_FFI, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFF f18_S_SPI_FFF(struct S_FFF p0, void* p1, int p2,  struct S_FFF (*cb)(struct S_FFF, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFD f18_S_SPI_FFD(struct S_FFD p0, void* p1, int p2,  struct S_FFD (*cb)(struct S_FFD, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFP f18_S_SPI_FFP(struct S_FFP p0, void* p1, int p2,  struct S_FFP (*cb)(struct S_FFP, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDI f18_S_SPI_FDI(struct S_FDI p0, void* p1, int p2,  struct S_FDI (*cb)(struct S_FDI, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDF f18_S_SPI_FDF(struct S_FDF p0, void* p1, int p2,  struct S_FDF (*cb)(struct S_FDF, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDD f18_S_SPI_FDD(struct S_FDD p0, void* p1, int p2,  struct S_FDD (*cb)(struct S_FDD, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDP f18_S_SPI_FDP(struct S_FDP p0, void* p1, int p2,  struct S_FDP (*cb)(struct S_FDP, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPI f18_S_SPI_FPI(struct S_FPI p0, void* p1, int p2,  struct S_FPI (*cb)(struct S_FPI, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPF f18_S_SPI_FPF(struct S_FPF p0, void* p1, int p2,  struct S_FPF (*cb)(struct S_FPF, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPD f18_S_SPI_FPD(struct S_FPD p0, void* p1, int p2,  struct S_FPD (*cb)(struct S_FPD, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPP f18_S_SPI_FPP(struct S_FPP p0, void* p1, int p2,  struct S_FPP (*cb)(struct S_FPP, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DII f18_S_SPI_DII(struct S_DII p0, void* p1, int p2,  struct S_DII (*cb)(struct S_DII, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DIF f18_S_SPI_DIF(struct S_DIF p0, void* p1, int p2,  struct S_DIF (*cb)(struct S_DIF, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DID f18_S_SPI_DID(struct S_DID p0, void* p1, int p2,  struct S_DID (*cb)(struct S_DID, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DIP f18_S_SPI_DIP(struct S_DIP p0, void* p1, int p2,  struct S_DIP (*cb)(struct S_DIP, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFI f18_S_SPI_DFI(struct S_DFI p0, void* p1, int p2,  struct S_DFI (*cb)(struct S_DFI, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFF f18_S_SPI_DFF(struct S_DFF p0, void* p1, int p2,  struct S_DFF (*cb)(struct S_DFF, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFD f18_S_SPI_DFD(struct S_DFD p0, void* p1, int p2,  struct S_DFD (*cb)(struct S_DFD, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFP f18_S_SPI_DFP(struct S_DFP p0, void* p1, int p2,  struct S_DFP (*cb)(struct S_DFP, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDI f18_S_SPI_DDI(struct S_DDI p0, void* p1, int p2,  struct S_DDI (*cb)(struct S_DDI, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDF f18_S_SPI_DDF(struct S_DDF p0, void* p1, int p2,  struct S_DDF (*cb)(struct S_DDF, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDD f18_S_SPI_DDD(struct S_DDD p0, void* p1, int p2,  struct S_DDD (*cb)(struct S_DDD, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDP f18_S_SPI_DDP(struct S_DDP p0, void* p1, int p2,  struct S_DDP (*cb)(struct S_DDP, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPI f18_S_SPI_DPI(struct S_DPI p0, void* p1, int p2,  struct S_DPI (*cb)(struct S_DPI, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPF f18_S_SPI_DPF(struct S_DPF p0, void* p1, int p2,  struct S_DPF (*cb)(struct S_DPF, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPD f18_S_SPI_DPD(struct S_DPD p0, void* p1, int p2,  struct S_DPD (*cb)(struct S_DPD, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPP f18_S_SPI_DPP(struct S_DPP p0, void* p1, int p2,  struct S_DPP (*cb)(struct S_DPP, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PII f18_S_SPI_PII(struct S_PII p0, void* p1, int p2,  struct S_PII (*cb)(struct S_PII, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PIF f18_S_SPI_PIF(struct S_PIF p0, void* p1, int p2,  struct S_PIF (*cb)(struct S_PIF, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PID f18_S_SPI_PID(struct S_PID p0, void* p1, int p2,  struct S_PID (*cb)(struct S_PID, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PIP f18_S_SPI_PIP(struct S_PIP p0, void* p1, int p2,  struct S_PIP (*cb)(struct S_PIP, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFI f18_S_SPI_PFI(struct S_PFI p0, void* p1, int p2,  struct S_PFI (*cb)(struct S_PFI, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFF f18_S_SPI_PFF(struct S_PFF p0, void* p1, int p2,  struct S_PFF (*cb)(struct S_PFF, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFD f18_S_SPI_PFD(struct S_PFD p0, void* p1, int p2,  struct S_PFD (*cb)(struct S_PFD, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFP f18_S_SPI_PFP(struct S_PFP p0, void* p1, int p2,  struct S_PFP (*cb)(struct S_PFP, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDI f18_S_SPI_PDI(struct S_PDI p0, void* p1, int p2,  struct S_PDI (*cb)(struct S_PDI, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDF f18_S_SPI_PDF(struct S_PDF p0, void* p1, int p2,  struct S_PDF (*cb)(struct S_PDF, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDD f18_S_SPI_PDD(struct S_PDD p0, void* p1, int p2,  struct S_PDD (*cb)(struct S_PDD, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDP f18_S_SPI_PDP(struct S_PDP p0, void* p1, int p2,  struct S_PDP (*cb)(struct S_PDP, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPI f18_S_SPI_PPI(struct S_PPI p0, void* p1, int p2,  struct S_PPI (*cb)(struct S_PPI, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPF f18_S_SPI_PPF(struct S_PPF p0, void* p1, int p2,  struct S_PPF (*cb)(struct S_PPF, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPD f18_S_SPI_PPD(struct S_PPD p0, void* p1, int p2,  struct S_PPD (*cb)(struct S_PPD, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPP f18_S_SPI_PPP(struct S_PPP p0, void* p1, int p2,  struct S_PPP (*cb)(struct S_PPP, void*, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_I f18_S_SPF_I(struct S_I p0, void* p1, float p2,  struct S_I (*cb)(struct S_I, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_F f18_S_SPF_F(struct S_F p0, void* p1, float p2,  struct S_F (*cb)(struct S_F, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_D f18_S_SPF_D(struct S_D p0, void* p1, float p2,  struct S_D (*cb)(struct S_D, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_P f18_S_SPF_P(struct S_P p0, void* p1, float p2,  struct S_P (*cb)(struct S_P, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_II f18_S_SPF_II(struct S_II p0, void* p1, float p2,  struct S_II (*cb)(struct S_II, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IF f18_S_SPF_IF(struct S_IF p0, void* p1, float p2,  struct S_IF (*cb)(struct S_IF, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_ID f18_S_SPF_ID(struct S_ID p0, void* p1, float p2,  struct S_ID (*cb)(struct S_ID, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IP f18_S_SPF_IP(struct S_IP p0, void* p1, float p2,  struct S_IP (*cb)(struct S_IP, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FI f18_S_SPF_FI(struct S_FI p0, void* p1, float p2,  struct S_FI (*cb)(struct S_FI, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FF f18_S_SPF_FF(struct S_FF p0, void* p1, float p2,  struct S_FF (*cb)(struct S_FF, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FD f18_S_SPF_FD(struct S_FD p0, void* p1, float p2,  struct S_FD (*cb)(struct S_FD, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FP f18_S_SPF_FP(struct S_FP p0, void* p1, float p2,  struct S_FP (*cb)(struct S_FP, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DI f18_S_SPF_DI(struct S_DI p0, void* p1, float p2,  struct S_DI (*cb)(struct S_DI, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DF f18_S_SPF_DF(struct S_DF p0, void* p1, float p2,  struct S_DF (*cb)(struct S_DF, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DD f18_S_SPF_DD(struct S_DD p0, void* p1, float p2,  struct S_DD (*cb)(struct S_DD, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DP f18_S_SPF_DP(struct S_DP p0, void* p1, float p2,  struct S_DP (*cb)(struct S_DP, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PI f18_S_SPF_PI(struct S_PI p0, void* p1, float p2,  struct S_PI (*cb)(struct S_PI, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PF f18_S_SPF_PF(struct S_PF p0, void* p1, float p2,  struct S_PF (*cb)(struct S_PF, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PD f18_S_SPF_PD(struct S_PD p0, void* p1, float p2,  struct S_PD (*cb)(struct S_PD, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PP f18_S_SPF_PP(struct S_PP p0, void* p1, float p2,  struct S_PP (*cb)(struct S_PP, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_III f18_S_SPF_III(struct S_III p0, void* p1, float p2,  struct S_III (*cb)(struct S_III, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IIF f18_S_SPF_IIF(struct S_IIF p0, void* p1, float p2,  struct S_IIF (*cb)(struct S_IIF, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IID f18_S_SPF_IID(struct S_IID p0, void* p1, float p2,  struct S_IID (*cb)(struct S_IID, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IIP f18_S_SPF_IIP(struct S_IIP p0, void* p1, float p2,  struct S_IIP (*cb)(struct S_IIP, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFI f18_S_SPF_IFI(struct S_IFI p0, void* p1, float p2,  struct S_IFI (*cb)(struct S_IFI, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFF f18_S_SPF_IFF(struct S_IFF p0, void* p1, float p2,  struct S_IFF (*cb)(struct S_IFF, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFD f18_S_SPF_IFD(struct S_IFD p0, void* p1, float p2,  struct S_IFD (*cb)(struct S_IFD, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFP f18_S_SPF_IFP(struct S_IFP p0, void* p1, float p2,  struct S_IFP (*cb)(struct S_IFP, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDI f18_S_SPF_IDI(struct S_IDI p0, void* p1, float p2,  struct S_IDI (*cb)(struct S_IDI, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDF f18_S_SPF_IDF(struct S_IDF p0, void* p1, float p2,  struct S_IDF (*cb)(struct S_IDF, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDD f18_S_SPF_IDD(struct S_IDD p0, void* p1, float p2,  struct S_IDD (*cb)(struct S_IDD, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDP f18_S_SPF_IDP(struct S_IDP p0, void* p1, float p2,  struct S_IDP (*cb)(struct S_IDP, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPI f18_S_SPF_IPI(struct S_IPI p0, void* p1, float p2,  struct S_IPI (*cb)(struct S_IPI, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPF f18_S_SPF_IPF(struct S_IPF p0, void* p1, float p2,  struct S_IPF (*cb)(struct S_IPF, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPD f18_S_SPF_IPD(struct S_IPD p0, void* p1, float p2,  struct S_IPD (*cb)(struct S_IPD, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPP f18_S_SPF_IPP(struct S_IPP p0, void* p1, float p2,  struct S_IPP (*cb)(struct S_IPP, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FII f18_S_SPF_FII(struct S_FII p0, void* p1, float p2,  struct S_FII (*cb)(struct S_FII, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FIF f18_S_SPF_FIF(struct S_FIF p0, void* p1, float p2,  struct S_FIF (*cb)(struct S_FIF, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FID f18_S_SPF_FID(struct S_FID p0, void* p1, float p2,  struct S_FID (*cb)(struct S_FID, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FIP f18_S_SPF_FIP(struct S_FIP p0, void* p1, float p2,  struct S_FIP (*cb)(struct S_FIP, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFI f18_S_SPF_FFI(struct S_FFI p0, void* p1, float p2,  struct S_FFI (*cb)(struct S_FFI, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFF f18_S_SPF_FFF(struct S_FFF p0, void* p1, float p2,  struct S_FFF (*cb)(struct S_FFF, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFD f18_S_SPF_FFD(struct S_FFD p0, void* p1, float p2,  struct S_FFD (*cb)(struct S_FFD, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFP f18_S_SPF_FFP(struct S_FFP p0, void* p1, float p2,  struct S_FFP (*cb)(struct S_FFP, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDI f18_S_SPF_FDI(struct S_FDI p0, void* p1, float p2,  struct S_FDI (*cb)(struct S_FDI, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDF f18_S_SPF_FDF(struct S_FDF p0, void* p1, float p2,  struct S_FDF (*cb)(struct S_FDF, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDD f18_S_SPF_FDD(struct S_FDD p0, void* p1, float p2,  struct S_FDD (*cb)(struct S_FDD, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDP f18_S_SPF_FDP(struct S_FDP p0, void* p1, float p2,  struct S_FDP (*cb)(struct S_FDP, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPI f18_S_SPF_FPI(struct S_FPI p0, void* p1, float p2,  struct S_FPI (*cb)(struct S_FPI, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPF f18_S_SPF_FPF(struct S_FPF p0, void* p1, float p2,  struct S_FPF (*cb)(struct S_FPF, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPD f18_S_SPF_FPD(struct S_FPD p0, void* p1, float p2,  struct S_FPD (*cb)(struct S_FPD, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPP f18_S_SPF_FPP(struct S_FPP p0, void* p1, float p2,  struct S_FPP (*cb)(struct S_FPP, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DII f18_S_SPF_DII(struct S_DII p0, void* p1, float p2,  struct S_DII (*cb)(struct S_DII, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DIF f18_S_SPF_DIF(struct S_DIF p0, void* p1, float p2,  struct S_DIF (*cb)(struct S_DIF, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DID f18_S_SPF_DID(struct S_DID p0, void* p1, float p2,  struct S_DID (*cb)(struct S_DID, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DIP f18_S_SPF_DIP(struct S_DIP p0, void* p1, float p2,  struct S_DIP (*cb)(struct S_DIP, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFI f18_S_SPF_DFI(struct S_DFI p0, void* p1, float p2,  struct S_DFI (*cb)(struct S_DFI, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFF f18_S_SPF_DFF(struct S_DFF p0, void* p1, float p2,  struct S_DFF (*cb)(struct S_DFF, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFD f18_S_SPF_DFD(struct S_DFD p0, void* p1, float p2,  struct S_DFD (*cb)(struct S_DFD, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFP f19_S_SPF_DFP(struct S_DFP p0, void* p1, float p2,  struct S_DFP (*cb)(struct S_DFP, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDI f19_S_SPF_DDI(struct S_DDI p0, void* p1, float p2,  struct S_DDI (*cb)(struct S_DDI, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDF f19_S_SPF_DDF(struct S_DDF p0, void* p1, float p2,  struct S_DDF (*cb)(struct S_DDF, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDD f19_S_SPF_DDD(struct S_DDD p0, void* p1, float p2,  struct S_DDD (*cb)(struct S_DDD, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDP f19_S_SPF_DDP(struct S_DDP p0, void* p1, float p2,  struct S_DDP (*cb)(struct S_DDP, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPI f19_S_SPF_DPI(struct S_DPI p0, void* p1, float p2,  struct S_DPI (*cb)(struct S_DPI, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPF f19_S_SPF_DPF(struct S_DPF p0, void* p1, float p2,  struct S_DPF (*cb)(struct S_DPF, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPD f19_S_SPF_DPD(struct S_DPD p0, void* p1, float p2,  struct S_DPD (*cb)(struct S_DPD, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPP f19_S_SPF_DPP(struct S_DPP p0, void* p1, float p2,  struct S_DPP (*cb)(struct S_DPP, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PII f19_S_SPF_PII(struct S_PII p0, void* p1, float p2,  struct S_PII (*cb)(struct S_PII, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PIF f19_S_SPF_PIF(struct S_PIF p0, void* p1, float p2,  struct S_PIF (*cb)(struct S_PIF, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PID f19_S_SPF_PID(struct S_PID p0, void* p1, float p2,  struct S_PID (*cb)(struct S_PID, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PIP f19_S_SPF_PIP(struct S_PIP p0, void* p1, float p2,  struct S_PIP (*cb)(struct S_PIP, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFI f19_S_SPF_PFI(struct S_PFI p0, void* p1, float p2,  struct S_PFI (*cb)(struct S_PFI, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFF f19_S_SPF_PFF(struct S_PFF p0, void* p1, float p2,  struct S_PFF (*cb)(struct S_PFF, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFD f19_S_SPF_PFD(struct S_PFD p0, void* p1, float p2,  struct S_PFD (*cb)(struct S_PFD, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFP f19_S_SPF_PFP(struct S_PFP p0, void* p1, float p2,  struct S_PFP (*cb)(struct S_PFP, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDI f19_S_SPF_PDI(struct S_PDI p0, void* p1, float p2,  struct S_PDI (*cb)(struct S_PDI, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDF f19_S_SPF_PDF(struct S_PDF p0, void* p1, float p2,  struct S_PDF (*cb)(struct S_PDF, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDD f19_S_SPF_PDD(struct S_PDD p0, void* p1, float p2,  struct S_PDD (*cb)(struct S_PDD, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDP f19_S_SPF_PDP(struct S_PDP p0, void* p1, float p2,  struct S_PDP (*cb)(struct S_PDP, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPI f19_S_SPF_PPI(struct S_PPI p0, void* p1, float p2,  struct S_PPI (*cb)(struct S_PPI, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPF f19_S_SPF_PPF(struct S_PPF p0, void* p1, float p2,  struct S_PPF (*cb)(struct S_PPF, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPD f19_S_SPF_PPD(struct S_PPD p0, void* p1, float p2,  struct S_PPD (*cb)(struct S_PPD, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPP f19_S_SPF_PPP(struct S_PPP p0, void* p1, float p2,  struct S_PPP (*cb)(struct S_PPP, void*, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_I f19_S_SPD_I(struct S_I p0, void* p1, double p2,  struct S_I (*cb)(struct S_I, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_F f19_S_SPD_F(struct S_F p0, void* p1, double p2,  struct S_F (*cb)(struct S_F, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_D f19_S_SPD_D(struct S_D p0, void* p1, double p2,  struct S_D (*cb)(struct S_D, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_P f19_S_SPD_P(struct S_P p0, void* p1, double p2,  struct S_P (*cb)(struct S_P, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_II f19_S_SPD_II(struct S_II p0, void* p1, double p2,  struct S_II (*cb)(struct S_II, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IF f19_S_SPD_IF(struct S_IF p0, void* p1, double p2,  struct S_IF (*cb)(struct S_IF, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_ID f19_S_SPD_ID(struct S_ID p0, void* p1, double p2,  struct S_ID (*cb)(struct S_ID, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IP f19_S_SPD_IP(struct S_IP p0, void* p1, double p2,  struct S_IP (*cb)(struct S_IP, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FI f19_S_SPD_FI(struct S_FI p0, void* p1, double p2,  struct S_FI (*cb)(struct S_FI, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FF f19_S_SPD_FF(struct S_FF p0, void* p1, double p2,  struct S_FF (*cb)(struct S_FF, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FD f19_S_SPD_FD(struct S_FD p0, void* p1, double p2,  struct S_FD (*cb)(struct S_FD, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FP f19_S_SPD_FP(struct S_FP p0, void* p1, double p2,  struct S_FP (*cb)(struct S_FP, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DI f19_S_SPD_DI(struct S_DI p0, void* p1, double p2,  struct S_DI (*cb)(struct S_DI, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DF f19_S_SPD_DF(struct S_DF p0, void* p1, double p2,  struct S_DF (*cb)(struct S_DF, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DD f19_S_SPD_DD(struct S_DD p0, void* p1, double p2,  struct S_DD (*cb)(struct S_DD, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DP f19_S_SPD_DP(struct S_DP p0, void* p1, double p2,  struct S_DP (*cb)(struct S_DP, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PI f19_S_SPD_PI(struct S_PI p0, void* p1, double p2,  struct S_PI (*cb)(struct S_PI, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PF f19_S_SPD_PF(struct S_PF p0, void* p1, double p2,  struct S_PF (*cb)(struct S_PF, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PD f19_S_SPD_PD(struct S_PD p0, void* p1, double p2,  struct S_PD (*cb)(struct S_PD, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PP f19_S_SPD_PP(struct S_PP p0, void* p1, double p2,  struct S_PP (*cb)(struct S_PP, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_III f19_S_SPD_III(struct S_III p0, void* p1, double p2,  struct S_III (*cb)(struct S_III, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IIF f19_S_SPD_IIF(struct S_IIF p0, void* p1, double p2,  struct S_IIF (*cb)(struct S_IIF, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IID f19_S_SPD_IID(struct S_IID p0, void* p1, double p2,  struct S_IID (*cb)(struct S_IID, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IIP f19_S_SPD_IIP(struct S_IIP p0, void* p1, double p2,  struct S_IIP (*cb)(struct S_IIP, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFI f19_S_SPD_IFI(struct S_IFI p0, void* p1, double p2,  struct S_IFI (*cb)(struct S_IFI, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFF f19_S_SPD_IFF(struct S_IFF p0, void* p1, double p2,  struct S_IFF (*cb)(struct S_IFF, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFD f19_S_SPD_IFD(struct S_IFD p0, void* p1, double p2,  struct S_IFD (*cb)(struct S_IFD, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFP f19_S_SPD_IFP(struct S_IFP p0, void* p1, double p2,  struct S_IFP (*cb)(struct S_IFP, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDI f19_S_SPD_IDI(struct S_IDI p0, void* p1, double p2,  struct S_IDI (*cb)(struct S_IDI, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDF f19_S_SPD_IDF(struct S_IDF p0, void* p1, double p2,  struct S_IDF (*cb)(struct S_IDF, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDD f19_S_SPD_IDD(struct S_IDD p0, void* p1, double p2,  struct S_IDD (*cb)(struct S_IDD, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDP f19_S_SPD_IDP(struct S_IDP p0, void* p1, double p2,  struct S_IDP (*cb)(struct S_IDP, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPI f19_S_SPD_IPI(struct S_IPI p0, void* p1, double p2,  struct S_IPI (*cb)(struct S_IPI, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPF f19_S_SPD_IPF(struct S_IPF p0, void* p1, double p2,  struct S_IPF (*cb)(struct S_IPF, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPD f19_S_SPD_IPD(struct S_IPD p0, void* p1, double p2,  struct S_IPD (*cb)(struct S_IPD, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPP f19_S_SPD_IPP(struct S_IPP p0, void* p1, double p2,  struct S_IPP (*cb)(struct S_IPP, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FII f19_S_SPD_FII(struct S_FII p0, void* p1, double p2,  struct S_FII (*cb)(struct S_FII, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FIF f19_S_SPD_FIF(struct S_FIF p0, void* p1, double p2,  struct S_FIF (*cb)(struct S_FIF, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FID f19_S_SPD_FID(struct S_FID p0, void* p1, double p2,  struct S_FID (*cb)(struct S_FID, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FIP f19_S_SPD_FIP(struct S_FIP p0, void* p1, double p2,  struct S_FIP (*cb)(struct S_FIP, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFI f19_S_SPD_FFI(struct S_FFI p0, void* p1, double p2,  struct S_FFI (*cb)(struct S_FFI, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFF f19_S_SPD_FFF(struct S_FFF p0, void* p1, double p2,  struct S_FFF (*cb)(struct S_FFF, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFD f19_S_SPD_FFD(struct S_FFD p0, void* p1, double p2,  struct S_FFD (*cb)(struct S_FFD, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFP f19_S_SPD_FFP(struct S_FFP p0, void* p1, double p2,  struct S_FFP (*cb)(struct S_FFP, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDI f19_S_SPD_FDI(struct S_FDI p0, void* p1, double p2,  struct S_FDI (*cb)(struct S_FDI, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDF f19_S_SPD_FDF(struct S_FDF p0, void* p1, double p2,  struct S_FDF (*cb)(struct S_FDF, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDD f19_S_SPD_FDD(struct S_FDD p0, void* p1, double p2,  struct S_FDD (*cb)(struct S_FDD, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDP f19_S_SPD_FDP(struct S_FDP p0, void* p1, double p2,  struct S_FDP (*cb)(struct S_FDP, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPI f19_S_SPD_FPI(struct S_FPI p0, void* p1, double p2,  struct S_FPI (*cb)(struct S_FPI, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPF f19_S_SPD_FPF(struct S_FPF p0, void* p1, double p2,  struct S_FPF (*cb)(struct S_FPF, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPD f19_S_SPD_FPD(struct S_FPD p0, void* p1, double p2,  struct S_FPD (*cb)(struct S_FPD, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPP f19_S_SPD_FPP(struct S_FPP p0, void* p1, double p2,  struct S_FPP (*cb)(struct S_FPP, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DII f19_S_SPD_DII(struct S_DII p0, void* p1, double p2,  struct S_DII (*cb)(struct S_DII, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DIF f19_S_SPD_DIF(struct S_DIF p0, void* p1, double p2,  struct S_DIF (*cb)(struct S_DIF, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DID f19_S_SPD_DID(struct S_DID p0, void* p1, double p2,  struct S_DID (*cb)(struct S_DID, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DIP f19_S_SPD_DIP(struct S_DIP p0, void* p1, double p2,  struct S_DIP (*cb)(struct S_DIP, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFI f19_S_SPD_DFI(struct S_DFI p0, void* p1, double p2,  struct S_DFI (*cb)(struct S_DFI, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFF f19_S_SPD_DFF(struct S_DFF p0, void* p1, double p2,  struct S_DFF (*cb)(struct S_DFF, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFD f19_S_SPD_DFD(struct S_DFD p0, void* p1, double p2,  struct S_DFD (*cb)(struct S_DFD, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFP f19_S_SPD_DFP(struct S_DFP p0, void* p1, double p2,  struct S_DFP (*cb)(struct S_DFP, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDI f19_S_SPD_DDI(struct S_DDI p0, void* p1, double p2,  struct S_DDI (*cb)(struct S_DDI, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDF f19_S_SPD_DDF(struct S_DDF p0, void* p1, double p2,  struct S_DDF (*cb)(struct S_DDF, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDD f19_S_SPD_DDD(struct S_DDD p0, void* p1, double p2,  struct S_DDD (*cb)(struct S_DDD, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDP f19_S_SPD_DDP(struct S_DDP p0, void* p1, double p2,  struct S_DDP (*cb)(struct S_DDP, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPI f19_S_SPD_DPI(struct S_DPI p0, void* p1, double p2,  struct S_DPI (*cb)(struct S_DPI, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPF f19_S_SPD_DPF(struct S_DPF p0, void* p1, double p2,  struct S_DPF (*cb)(struct S_DPF, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPD f19_S_SPD_DPD(struct S_DPD p0, void* p1, double p2,  struct S_DPD (*cb)(struct S_DPD, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPP f19_S_SPD_DPP(struct S_DPP p0, void* p1, double p2,  struct S_DPP (*cb)(struct S_DPP, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PII f19_S_SPD_PII(struct S_PII p0, void* p1, double p2,  struct S_PII (*cb)(struct S_PII, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PIF f19_S_SPD_PIF(struct S_PIF p0, void* p1, double p2,  struct S_PIF (*cb)(struct S_PIF, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PID f19_S_SPD_PID(struct S_PID p0, void* p1, double p2,  struct S_PID (*cb)(struct S_PID, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PIP f19_S_SPD_PIP(struct S_PIP p0, void* p1, double p2,  struct S_PIP (*cb)(struct S_PIP, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFI f19_S_SPD_PFI(struct S_PFI p0, void* p1, double p2,  struct S_PFI (*cb)(struct S_PFI, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFF f19_S_SPD_PFF(struct S_PFF p0, void* p1, double p2,  struct S_PFF (*cb)(struct S_PFF, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFD f19_S_SPD_PFD(struct S_PFD p0, void* p1, double p2,  struct S_PFD (*cb)(struct S_PFD, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFP f19_S_SPD_PFP(struct S_PFP p0, void* p1, double p2,  struct S_PFP (*cb)(struct S_PFP, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDI f19_S_SPD_PDI(struct S_PDI p0, void* p1, double p2,  struct S_PDI (*cb)(struct S_PDI, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDF f19_S_SPD_PDF(struct S_PDF p0, void* p1, double p2,  struct S_PDF (*cb)(struct S_PDF, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDD f19_S_SPD_PDD(struct S_PDD p0, void* p1, double p2,  struct S_PDD (*cb)(struct S_PDD, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDP f19_S_SPD_PDP(struct S_PDP p0, void* p1, double p2,  struct S_PDP (*cb)(struct S_PDP, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPI f19_S_SPD_PPI(struct S_PPI p0, void* p1, double p2,  struct S_PPI (*cb)(struct S_PPI, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPF f19_S_SPD_PPF(struct S_PPF p0, void* p1, double p2,  struct S_PPF (*cb)(struct S_PPF, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPD f19_S_SPD_PPD(struct S_PPD p0, void* p1, double p2,  struct S_PPD (*cb)(struct S_PPD, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPP f19_S_SPD_PPP(struct S_PPP p0, void* p1, double p2,  struct S_PPP (*cb)(struct S_PPP, void*, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_I f19_S_SPP_I(struct S_I p0, void* p1, void* p2,  struct S_I (*cb)(struct S_I, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_F f19_S_SPP_F(struct S_F p0, void* p1, void* p2,  struct S_F (*cb)(struct S_F, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_D f19_S_SPP_D(struct S_D p0, void* p1, void* p2,  struct S_D (*cb)(struct S_D, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_P f19_S_SPP_P(struct S_P p0, void* p1, void* p2,  struct S_P (*cb)(struct S_P, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_II f19_S_SPP_II(struct S_II p0, void* p1, void* p2,  struct S_II (*cb)(struct S_II, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IF f19_S_SPP_IF(struct S_IF p0, void* p1, void* p2,  struct S_IF (*cb)(struct S_IF, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_ID f19_S_SPP_ID(struct S_ID p0, void* p1, void* p2,  struct S_ID (*cb)(struct S_ID, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IP f19_S_SPP_IP(struct S_IP p0, void* p1, void* p2,  struct S_IP (*cb)(struct S_IP, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FI f19_S_SPP_FI(struct S_FI p0, void* p1, void* p2,  struct S_FI (*cb)(struct S_FI, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FF f19_S_SPP_FF(struct S_FF p0, void* p1, void* p2,  struct S_FF (*cb)(struct S_FF, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FD f19_S_SPP_FD(struct S_FD p0, void* p1, void* p2,  struct S_FD (*cb)(struct S_FD, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FP f19_S_SPP_FP(struct S_FP p0, void* p1, void* p2,  struct S_FP (*cb)(struct S_FP, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DI f19_S_SPP_DI(struct S_DI p0, void* p1, void* p2,  struct S_DI (*cb)(struct S_DI, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DF f19_S_SPP_DF(struct S_DF p0, void* p1, void* p2,  struct S_DF (*cb)(struct S_DF, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DD f19_S_SPP_DD(struct S_DD p0, void* p1, void* p2,  struct S_DD (*cb)(struct S_DD, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DP f19_S_SPP_DP(struct S_DP p0, void* p1, void* p2,  struct S_DP (*cb)(struct S_DP, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PI f19_S_SPP_PI(struct S_PI p0, void* p1, void* p2,  struct S_PI (*cb)(struct S_PI, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PF f19_S_SPP_PF(struct S_PF p0, void* p1, void* p2,  struct S_PF (*cb)(struct S_PF, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PD f19_S_SPP_PD(struct S_PD p0, void* p1, void* p2,  struct S_PD (*cb)(struct S_PD, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PP f19_S_SPP_PP(struct S_PP p0, void* p1, void* p2,  struct S_PP (*cb)(struct S_PP, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_III f19_S_SPP_III(struct S_III p0, void* p1, void* p2,  struct S_III (*cb)(struct S_III, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IIF f19_S_SPP_IIF(struct S_IIF p0, void* p1, void* p2,  struct S_IIF (*cb)(struct S_IIF, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IID f19_S_SPP_IID(struct S_IID p0, void* p1, void* p2,  struct S_IID (*cb)(struct S_IID, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IIP f19_S_SPP_IIP(struct S_IIP p0, void* p1, void* p2,  struct S_IIP (*cb)(struct S_IIP, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFI f19_S_SPP_IFI(struct S_IFI p0, void* p1, void* p2,  struct S_IFI (*cb)(struct S_IFI, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFF f19_S_SPP_IFF(struct S_IFF p0, void* p1, void* p2,  struct S_IFF (*cb)(struct S_IFF, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFD f19_S_SPP_IFD(struct S_IFD p0, void* p1, void* p2,  struct S_IFD (*cb)(struct S_IFD, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFP f19_S_SPP_IFP(struct S_IFP p0, void* p1, void* p2,  struct S_IFP (*cb)(struct S_IFP, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDI f19_S_SPP_IDI(struct S_IDI p0, void* p1, void* p2,  struct S_IDI (*cb)(struct S_IDI, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDF f19_S_SPP_IDF(struct S_IDF p0, void* p1, void* p2,  struct S_IDF (*cb)(struct S_IDF, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDD f19_S_SPP_IDD(struct S_IDD p0, void* p1, void* p2,  struct S_IDD (*cb)(struct S_IDD, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDP f19_S_SPP_IDP(struct S_IDP p0, void* p1, void* p2,  struct S_IDP (*cb)(struct S_IDP, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPI f19_S_SPP_IPI(struct S_IPI p0, void* p1, void* p2,  struct S_IPI (*cb)(struct S_IPI, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPF f19_S_SPP_IPF(struct S_IPF p0, void* p1, void* p2,  struct S_IPF (*cb)(struct S_IPF, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPD f19_S_SPP_IPD(struct S_IPD p0, void* p1, void* p2,  struct S_IPD (*cb)(struct S_IPD, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPP f19_S_SPP_IPP(struct S_IPP p0, void* p1, void* p2,  struct S_IPP (*cb)(struct S_IPP, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FII f19_S_SPP_FII(struct S_FII p0, void* p1, void* p2,  struct S_FII (*cb)(struct S_FII, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FIF f19_S_SPP_FIF(struct S_FIF p0, void* p1, void* p2,  struct S_FIF (*cb)(struct S_FIF, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FID f19_S_SPP_FID(struct S_FID p0, void* p1, void* p2,  struct S_FID (*cb)(struct S_FID, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FIP f19_S_SPP_FIP(struct S_FIP p0, void* p1, void* p2,  struct S_FIP (*cb)(struct S_FIP, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFI f19_S_SPP_FFI(struct S_FFI p0, void* p1, void* p2,  struct S_FFI (*cb)(struct S_FFI, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFF f19_S_SPP_FFF(struct S_FFF p0, void* p1, void* p2,  struct S_FFF (*cb)(struct S_FFF, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFD f19_S_SPP_FFD(struct S_FFD p0, void* p1, void* p2,  struct S_FFD (*cb)(struct S_FFD, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFP f19_S_SPP_FFP(struct S_FFP p0, void* p1, void* p2,  struct S_FFP (*cb)(struct S_FFP, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDI f19_S_SPP_FDI(struct S_FDI p0, void* p1, void* p2,  struct S_FDI (*cb)(struct S_FDI, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDF f19_S_SPP_FDF(struct S_FDF p0, void* p1, void* p2,  struct S_FDF (*cb)(struct S_FDF, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDD f19_S_SPP_FDD(struct S_FDD p0, void* p1, void* p2,  struct S_FDD (*cb)(struct S_FDD, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDP f19_S_SPP_FDP(struct S_FDP p0, void* p1, void* p2,  struct S_FDP (*cb)(struct S_FDP, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPI f19_S_SPP_FPI(struct S_FPI p0, void* p1, void* p2,  struct S_FPI (*cb)(struct S_FPI, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPF f19_S_SPP_FPF(struct S_FPF p0, void* p1, void* p2,  struct S_FPF (*cb)(struct S_FPF, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPD f19_S_SPP_FPD(struct S_FPD p0, void* p1, void* p2,  struct S_FPD (*cb)(struct S_FPD, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPP f19_S_SPP_FPP(struct S_FPP p0, void* p1, void* p2,  struct S_FPP (*cb)(struct S_FPP, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DII f19_S_SPP_DII(struct S_DII p0, void* p1, void* p2,  struct S_DII (*cb)(struct S_DII, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DIF f19_S_SPP_DIF(struct S_DIF p0, void* p1, void* p2,  struct S_DIF (*cb)(struct S_DIF, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DID f19_S_SPP_DID(struct S_DID p0, void* p1, void* p2,  struct S_DID (*cb)(struct S_DID, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DIP f19_S_SPP_DIP(struct S_DIP p0, void* p1, void* p2,  struct S_DIP (*cb)(struct S_DIP, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFI f19_S_SPP_DFI(struct S_DFI p0, void* p1, void* p2,  struct S_DFI (*cb)(struct S_DFI, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFF f19_S_SPP_DFF(struct S_DFF p0, void* p1, void* p2,  struct S_DFF (*cb)(struct S_DFF, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFD f19_S_SPP_DFD(struct S_DFD p0, void* p1, void* p2,  struct S_DFD (*cb)(struct S_DFD, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFP f19_S_SPP_DFP(struct S_DFP p0, void* p1, void* p2,  struct S_DFP (*cb)(struct S_DFP, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDI f19_S_SPP_DDI(struct S_DDI p0, void* p1, void* p2,  struct S_DDI (*cb)(struct S_DDI, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDF f19_S_SPP_DDF(struct S_DDF p0, void* p1, void* p2,  struct S_DDF (*cb)(struct S_DDF, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDD f19_S_SPP_DDD(struct S_DDD p0, void* p1, void* p2,  struct S_DDD (*cb)(struct S_DDD, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDP f19_S_SPP_DDP(struct S_DDP p0, void* p1, void* p2,  struct S_DDP (*cb)(struct S_DDP, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPI f19_S_SPP_DPI(struct S_DPI p0, void* p1, void* p2,  struct S_DPI (*cb)(struct S_DPI, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPF f19_S_SPP_DPF(struct S_DPF p0, void* p1, void* p2,  struct S_DPF (*cb)(struct S_DPF, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPD f19_S_SPP_DPD(struct S_DPD p0, void* p1, void* p2,  struct S_DPD (*cb)(struct S_DPD, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPP f19_S_SPP_DPP(struct S_DPP p0, void* p1, void* p2,  struct S_DPP (*cb)(struct S_DPP, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PII f19_S_SPP_PII(struct S_PII p0, void* p1, void* p2,  struct S_PII (*cb)(struct S_PII, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PIF f19_S_SPP_PIF(struct S_PIF p0, void* p1, void* p2,  struct S_PIF (*cb)(struct S_PIF, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PID f19_S_SPP_PID(struct S_PID p0, void* p1, void* p2,  struct S_PID (*cb)(struct S_PID, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PIP f19_S_SPP_PIP(struct S_PIP p0, void* p1, void* p2,  struct S_PIP (*cb)(struct S_PIP, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFI f19_S_SPP_PFI(struct S_PFI p0, void* p1, void* p2,  struct S_PFI (*cb)(struct S_PFI, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFF f19_S_SPP_PFF(struct S_PFF p0, void* p1, void* p2,  struct S_PFF (*cb)(struct S_PFF, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFD f19_S_SPP_PFD(struct S_PFD p0, void* p1, void* p2,  struct S_PFD (*cb)(struct S_PFD, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFP f19_S_SPP_PFP(struct S_PFP p0, void* p1, void* p2,  struct S_PFP (*cb)(struct S_PFP, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDI f19_S_SPP_PDI(struct S_PDI p0, void* p1, void* p2,  struct S_PDI (*cb)(struct S_PDI, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDF f19_S_SPP_PDF(struct S_PDF p0, void* p1, void* p2,  struct S_PDF (*cb)(struct S_PDF, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDD f19_S_SPP_PDD(struct S_PDD p0, void* p1, void* p2,  struct S_PDD (*cb)(struct S_PDD, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDP f19_S_SPP_PDP(struct S_PDP p0, void* p1, void* p2,  struct S_PDP (*cb)(struct S_PDP, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPI f19_S_SPP_PPI(struct S_PPI p0, void* p1, void* p2,  struct S_PPI (*cb)(struct S_PPI, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPF f19_S_SPP_PPF(struct S_PPF p0, void* p1, void* p2,  struct S_PPF (*cb)(struct S_PPF, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPD f19_S_SPP_PPD(struct S_PPD p0, void* p1, void* p2,  struct S_PPD (*cb)(struct S_PPD, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPP f19_S_SPP_PPP(struct S_PPP p0, void* p1, void* p2,  struct S_PPP (*cb)(struct S_PPP, void*, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_I f19_S_SPS_I(struct S_I p0, void* p1, struct S_I p2,  struct S_I (*cb)(struct S_I, void*, struct S_I)) { return cb(p0,p1,p2); }
+EXPORT struct S_F f19_S_SPS_F(struct S_F p0, void* p1, struct S_F p2,  struct S_F (*cb)(struct S_F, void*, struct S_F)) { return cb(p0,p1,p2); }
+EXPORT struct S_D f19_S_SPS_D(struct S_D p0, void* p1, struct S_D p2,  struct S_D (*cb)(struct S_D, void*, struct S_D)) { return cb(p0,p1,p2); }
+EXPORT struct S_P f19_S_SPS_P(struct S_P p0, void* p1, struct S_P p2,  struct S_P (*cb)(struct S_P, void*, struct S_P)) { return cb(p0,p1,p2); }
+EXPORT struct S_II f19_S_SPS_II(struct S_II p0, void* p1, struct S_II p2,  struct S_II (*cb)(struct S_II, void*, struct S_II)) { return cb(p0,p1,p2); }
+EXPORT struct S_IF f19_S_SPS_IF(struct S_IF p0, void* p1, struct S_IF p2,  struct S_IF (*cb)(struct S_IF, void*, struct S_IF)) { return cb(p0,p1,p2); }
+EXPORT struct S_ID f19_S_SPS_ID(struct S_ID p0, void* p1, struct S_ID p2,  struct S_ID (*cb)(struct S_ID, void*, struct S_ID)) { return cb(p0,p1,p2); }
+EXPORT struct S_IP f19_S_SPS_IP(struct S_IP p0, void* p1, struct S_IP p2,  struct S_IP (*cb)(struct S_IP, void*, struct S_IP)) { return cb(p0,p1,p2); }
+EXPORT struct S_FI f19_S_SPS_FI(struct S_FI p0, void* p1, struct S_FI p2,  struct S_FI (*cb)(struct S_FI, void*, struct S_FI)) { return cb(p0,p1,p2); }
+EXPORT struct S_FF f19_S_SPS_FF(struct S_FF p0, void* p1, struct S_FF p2,  struct S_FF (*cb)(struct S_FF, void*, struct S_FF)) { return cb(p0,p1,p2); }
+EXPORT struct S_FD f19_S_SPS_FD(struct S_FD p0, void* p1, struct S_FD p2,  struct S_FD (*cb)(struct S_FD, void*, struct S_FD)) { return cb(p0,p1,p2); }
+EXPORT struct S_FP f19_S_SPS_FP(struct S_FP p0, void* p1, struct S_FP p2,  struct S_FP (*cb)(struct S_FP, void*, struct S_FP)) { return cb(p0,p1,p2); }
+EXPORT struct S_DI f19_S_SPS_DI(struct S_DI p0, void* p1, struct S_DI p2,  struct S_DI (*cb)(struct S_DI, void*, struct S_DI)) { return cb(p0,p1,p2); }
+EXPORT struct S_DF f19_S_SPS_DF(struct S_DF p0, void* p1, struct S_DF p2,  struct S_DF (*cb)(struct S_DF, void*, struct S_DF)) { return cb(p0,p1,p2); }
+EXPORT struct S_DD f19_S_SPS_DD(struct S_DD p0, void* p1, struct S_DD p2,  struct S_DD (*cb)(struct S_DD, void*, struct S_DD)) { return cb(p0,p1,p2); }
+EXPORT struct S_DP f19_S_SPS_DP(struct S_DP p0, void* p1, struct S_DP p2,  struct S_DP (*cb)(struct S_DP, void*, struct S_DP)) { return cb(p0,p1,p2); }
+EXPORT struct S_PI f19_S_SPS_PI(struct S_PI p0, void* p1, struct S_PI p2,  struct S_PI (*cb)(struct S_PI, void*, struct S_PI)) { return cb(p0,p1,p2); }
+EXPORT struct S_PF f19_S_SPS_PF(struct S_PF p0, void* p1, struct S_PF p2,  struct S_PF (*cb)(struct S_PF, void*, struct S_PF)) { return cb(p0,p1,p2); }
+EXPORT struct S_PD f19_S_SPS_PD(struct S_PD p0, void* p1, struct S_PD p2,  struct S_PD (*cb)(struct S_PD, void*, struct S_PD)) { return cb(p0,p1,p2); }
+EXPORT struct S_PP f19_S_SPS_PP(struct S_PP p0, void* p1, struct S_PP p2,  struct S_PP (*cb)(struct S_PP, void*, struct S_PP)) { return cb(p0,p1,p2); }
+EXPORT struct S_III f19_S_SPS_III(struct S_III p0, void* p1, struct S_III p2,  struct S_III (*cb)(struct S_III, void*, struct S_III)) { return cb(p0,p1,p2); }
+EXPORT struct S_IIF f19_S_SPS_IIF(struct S_IIF p0, void* p1, struct S_IIF p2,  struct S_IIF (*cb)(struct S_IIF, void*, struct S_IIF)) { return cb(p0,p1,p2); }
+EXPORT struct S_IID f19_S_SPS_IID(struct S_IID p0, void* p1, struct S_IID p2,  struct S_IID (*cb)(struct S_IID, void*, struct S_IID)) { return cb(p0,p1,p2); }
+EXPORT struct S_IIP f19_S_SPS_IIP(struct S_IIP p0, void* p1, struct S_IIP p2,  struct S_IIP (*cb)(struct S_IIP, void*, struct S_IIP)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFI f19_S_SPS_IFI(struct S_IFI p0, void* p1, struct S_IFI p2,  struct S_IFI (*cb)(struct S_IFI, void*, struct S_IFI)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFF f19_S_SPS_IFF(struct S_IFF p0, void* p1, struct S_IFF p2,  struct S_IFF (*cb)(struct S_IFF, void*, struct S_IFF)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFD f19_S_SPS_IFD(struct S_IFD p0, void* p1, struct S_IFD p2,  struct S_IFD (*cb)(struct S_IFD, void*, struct S_IFD)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFP f19_S_SPS_IFP(struct S_IFP p0, void* p1, struct S_IFP p2,  struct S_IFP (*cb)(struct S_IFP, void*, struct S_IFP)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDI f19_S_SPS_IDI(struct S_IDI p0, void* p1, struct S_IDI p2,  struct S_IDI (*cb)(struct S_IDI, void*, struct S_IDI)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDF f19_S_SPS_IDF(struct S_IDF p0, void* p1, struct S_IDF p2,  struct S_IDF (*cb)(struct S_IDF, void*, struct S_IDF)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDD f19_S_SPS_IDD(struct S_IDD p0, void* p1, struct S_IDD p2,  struct S_IDD (*cb)(struct S_IDD, void*, struct S_IDD)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDP f19_S_SPS_IDP(struct S_IDP p0, void* p1, struct S_IDP p2,  struct S_IDP (*cb)(struct S_IDP, void*, struct S_IDP)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPI f19_S_SPS_IPI(struct S_IPI p0, void* p1, struct S_IPI p2,  struct S_IPI (*cb)(struct S_IPI, void*, struct S_IPI)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPF f19_S_SPS_IPF(struct S_IPF p0, void* p1, struct S_IPF p2,  struct S_IPF (*cb)(struct S_IPF, void*, struct S_IPF)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPD f19_S_SPS_IPD(struct S_IPD p0, void* p1, struct S_IPD p2,  struct S_IPD (*cb)(struct S_IPD, void*, struct S_IPD)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPP f19_S_SPS_IPP(struct S_IPP p0, void* p1, struct S_IPP p2,  struct S_IPP (*cb)(struct S_IPP, void*, struct S_IPP)) { return cb(p0,p1,p2); }
+EXPORT struct S_FII f19_S_SPS_FII(struct S_FII p0, void* p1, struct S_FII p2,  struct S_FII (*cb)(struct S_FII, void*, struct S_FII)) { return cb(p0,p1,p2); }
+EXPORT struct S_FIF f19_S_SPS_FIF(struct S_FIF p0, void* p1, struct S_FIF p2,  struct S_FIF (*cb)(struct S_FIF, void*, struct S_FIF)) { return cb(p0,p1,p2); }
+EXPORT struct S_FID f19_S_SPS_FID(struct S_FID p0, void* p1, struct S_FID p2,  struct S_FID (*cb)(struct S_FID, void*, struct S_FID)) { return cb(p0,p1,p2); }
+EXPORT struct S_FIP f19_S_SPS_FIP(struct S_FIP p0, void* p1, struct S_FIP p2,  struct S_FIP (*cb)(struct S_FIP, void*, struct S_FIP)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFI f19_S_SPS_FFI(struct S_FFI p0, void* p1, struct S_FFI p2,  struct S_FFI (*cb)(struct S_FFI, void*, struct S_FFI)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFF f19_S_SPS_FFF(struct S_FFF p0, void* p1, struct S_FFF p2,  struct S_FFF (*cb)(struct S_FFF, void*, struct S_FFF)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFD f19_S_SPS_FFD(struct S_FFD p0, void* p1, struct S_FFD p2,  struct S_FFD (*cb)(struct S_FFD, void*, struct S_FFD)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFP f19_S_SPS_FFP(struct S_FFP p0, void* p1, struct S_FFP p2,  struct S_FFP (*cb)(struct S_FFP, void*, struct S_FFP)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDI f19_S_SPS_FDI(struct S_FDI p0, void* p1, struct S_FDI p2,  struct S_FDI (*cb)(struct S_FDI, void*, struct S_FDI)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDF f19_S_SPS_FDF(struct S_FDF p0, void* p1, struct S_FDF p2,  struct S_FDF (*cb)(struct S_FDF, void*, struct S_FDF)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDD f19_S_SPS_FDD(struct S_FDD p0, void* p1, struct S_FDD p2,  struct S_FDD (*cb)(struct S_FDD, void*, struct S_FDD)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDP f19_S_SPS_FDP(struct S_FDP p0, void* p1, struct S_FDP p2,  struct S_FDP (*cb)(struct S_FDP, void*, struct S_FDP)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPI f19_S_SPS_FPI(struct S_FPI p0, void* p1, struct S_FPI p2,  struct S_FPI (*cb)(struct S_FPI, void*, struct S_FPI)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPF f19_S_SPS_FPF(struct S_FPF p0, void* p1, struct S_FPF p2,  struct S_FPF (*cb)(struct S_FPF, void*, struct S_FPF)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPD f19_S_SPS_FPD(struct S_FPD p0, void* p1, struct S_FPD p2,  struct S_FPD (*cb)(struct S_FPD, void*, struct S_FPD)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPP f19_S_SPS_FPP(struct S_FPP p0, void* p1, struct S_FPP p2,  struct S_FPP (*cb)(struct S_FPP, void*, struct S_FPP)) { return cb(p0,p1,p2); }
+EXPORT struct S_DII f19_S_SPS_DII(struct S_DII p0, void* p1, struct S_DII p2,  struct S_DII (*cb)(struct S_DII, void*, struct S_DII)) { return cb(p0,p1,p2); }
+EXPORT struct S_DIF f19_S_SPS_DIF(struct S_DIF p0, void* p1, struct S_DIF p2,  struct S_DIF (*cb)(struct S_DIF, void*, struct S_DIF)) { return cb(p0,p1,p2); }
+EXPORT struct S_DID f19_S_SPS_DID(struct S_DID p0, void* p1, struct S_DID p2,  struct S_DID (*cb)(struct S_DID, void*, struct S_DID)) { return cb(p0,p1,p2); }
+EXPORT struct S_DIP f19_S_SPS_DIP(struct S_DIP p0, void* p1, struct S_DIP p2,  struct S_DIP (*cb)(struct S_DIP, void*, struct S_DIP)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFI f19_S_SPS_DFI(struct S_DFI p0, void* p1, struct S_DFI p2,  struct S_DFI (*cb)(struct S_DFI, void*, struct S_DFI)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFF f19_S_SPS_DFF(struct S_DFF p0, void* p1, struct S_DFF p2,  struct S_DFF (*cb)(struct S_DFF, void*, struct S_DFF)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFD f19_S_SPS_DFD(struct S_DFD p0, void* p1, struct S_DFD p2,  struct S_DFD (*cb)(struct S_DFD, void*, struct S_DFD)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFP f19_S_SPS_DFP(struct S_DFP p0, void* p1, struct S_DFP p2,  struct S_DFP (*cb)(struct S_DFP, void*, struct S_DFP)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDI f19_S_SPS_DDI(struct S_DDI p0, void* p1, struct S_DDI p2,  struct S_DDI (*cb)(struct S_DDI, void*, struct S_DDI)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDF f19_S_SPS_DDF(struct S_DDF p0, void* p1, struct S_DDF p2,  struct S_DDF (*cb)(struct S_DDF, void*, struct S_DDF)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDD f19_S_SPS_DDD(struct S_DDD p0, void* p1, struct S_DDD p2,  struct S_DDD (*cb)(struct S_DDD, void*, struct S_DDD)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDP f19_S_SPS_DDP(struct S_DDP p0, void* p1, struct S_DDP p2,  struct S_DDP (*cb)(struct S_DDP, void*, struct S_DDP)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPI f19_S_SPS_DPI(struct S_DPI p0, void* p1, struct S_DPI p2,  struct S_DPI (*cb)(struct S_DPI, void*, struct S_DPI)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPF f19_S_SPS_DPF(struct S_DPF p0, void* p1, struct S_DPF p2,  struct S_DPF (*cb)(struct S_DPF, void*, struct S_DPF)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPD f19_S_SPS_DPD(struct S_DPD p0, void* p1, struct S_DPD p2,  struct S_DPD (*cb)(struct S_DPD, void*, struct S_DPD)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPP f19_S_SPS_DPP(struct S_DPP p0, void* p1, struct S_DPP p2,  struct S_DPP (*cb)(struct S_DPP, void*, struct S_DPP)) { return cb(p0,p1,p2); }
+EXPORT struct S_PII f19_S_SPS_PII(struct S_PII p0, void* p1, struct S_PII p2,  struct S_PII (*cb)(struct S_PII, void*, struct S_PII)) { return cb(p0,p1,p2); }
+EXPORT struct S_PIF f19_S_SPS_PIF(struct S_PIF p0, void* p1, struct S_PIF p2,  struct S_PIF (*cb)(struct S_PIF, void*, struct S_PIF)) { return cb(p0,p1,p2); }
+EXPORT struct S_PID f19_S_SPS_PID(struct S_PID p0, void* p1, struct S_PID p2,  struct S_PID (*cb)(struct S_PID, void*, struct S_PID)) { return cb(p0,p1,p2); }
+EXPORT struct S_PIP f19_S_SPS_PIP(struct S_PIP p0, void* p1, struct S_PIP p2,  struct S_PIP (*cb)(struct S_PIP, void*, struct S_PIP)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFI f19_S_SPS_PFI(struct S_PFI p0, void* p1, struct S_PFI p2,  struct S_PFI (*cb)(struct S_PFI, void*, struct S_PFI)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFF f19_S_SPS_PFF(struct S_PFF p0, void* p1, struct S_PFF p2,  struct S_PFF (*cb)(struct S_PFF, void*, struct S_PFF)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFD f19_S_SPS_PFD(struct S_PFD p0, void* p1, struct S_PFD p2,  struct S_PFD (*cb)(struct S_PFD, void*, struct S_PFD)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFP f19_S_SPS_PFP(struct S_PFP p0, void* p1, struct S_PFP p2,  struct S_PFP (*cb)(struct S_PFP, void*, struct S_PFP)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDI f19_S_SPS_PDI(struct S_PDI p0, void* p1, struct S_PDI p2,  struct S_PDI (*cb)(struct S_PDI, void*, struct S_PDI)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDF f19_S_SPS_PDF(struct S_PDF p0, void* p1, struct S_PDF p2,  struct S_PDF (*cb)(struct S_PDF, void*, struct S_PDF)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDD f19_S_SPS_PDD(struct S_PDD p0, void* p1, struct S_PDD p2,  struct S_PDD (*cb)(struct S_PDD, void*, struct S_PDD)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDP f19_S_SPS_PDP(struct S_PDP p0, void* p1, struct S_PDP p2,  struct S_PDP (*cb)(struct S_PDP, void*, struct S_PDP)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPI f19_S_SPS_PPI(struct S_PPI p0, void* p1, struct S_PPI p2,  struct S_PPI (*cb)(struct S_PPI, void*, struct S_PPI)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPF f19_S_SPS_PPF(struct S_PPF p0, void* p1, struct S_PPF p2,  struct S_PPF (*cb)(struct S_PPF, void*, struct S_PPF)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPD f19_S_SPS_PPD(struct S_PPD p0, void* p1, struct S_PPD p2,  struct S_PPD (*cb)(struct S_PPD, void*, struct S_PPD)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPP f19_S_SPS_PPP(struct S_PPP p0, void* p1, struct S_PPP p2,  struct S_PPP (*cb)(struct S_PPP, void*, struct S_PPP)) { return cb(p0,p1,p2); }
+EXPORT struct S_I f19_S_SSI_I(struct S_I p0, struct S_I p1, int p2,  struct S_I (*cb)(struct S_I, struct S_I, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_F f19_S_SSI_F(struct S_F p0, struct S_F p1, int p2,  struct S_F (*cb)(struct S_F, struct S_F, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_D f19_S_SSI_D(struct S_D p0, struct S_D p1, int p2,  struct S_D (*cb)(struct S_D, struct S_D, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_P f19_S_SSI_P(struct S_P p0, struct S_P p1, int p2,  struct S_P (*cb)(struct S_P, struct S_P, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_II f19_S_SSI_II(struct S_II p0, struct S_II p1, int p2,  struct S_II (*cb)(struct S_II, struct S_II, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IF f19_S_SSI_IF(struct S_IF p0, struct S_IF p1, int p2,  struct S_IF (*cb)(struct S_IF, struct S_IF, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_ID f19_S_SSI_ID(struct S_ID p0, struct S_ID p1, int p2,  struct S_ID (*cb)(struct S_ID, struct S_ID, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IP f19_S_SSI_IP(struct S_IP p0, struct S_IP p1, int p2,  struct S_IP (*cb)(struct S_IP, struct S_IP, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FI f19_S_SSI_FI(struct S_FI p0, struct S_FI p1, int p2,  struct S_FI (*cb)(struct S_FI, struct S_FI, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FF f19_S_SSI_FF(struct S_FF p0, struct S_FF p1, int p2,  struct S_FF (*cb)(struct S_FF, struct S_FF, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FD f19_S_SSI_FD(struct S_FD p0, struct S_FD p1, int p2,  struct S_FD (*cb)(struct S_FD, struct S_FD, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FP f19_S_SSI_FP(struct S_FP p0, struct S_FP p1, int p2,  struct S_FP (*cb)(struct S_FP, struct S_FP, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DI f19_S_SSI_DI(struct S_DI p0, struct S_DI p1, int p2,  struct S_DI (*cb)(struct S_DI, struct S_DI, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DF f19_S_SSI_DF(struct S_DF p0, struct S_DF p1, int p2,  struct S_DF (*cb)(struct S_DF, struct S_DF, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DD f19_S_SSI_DD(struct S_DD p0, struct S_DD p1, int p2,  struct S_DD (*cb)(struct S_DD, struct S_DD, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DP f19_S_SSI_DP(struct S_DP p0, struct S_DP p1, int p2,  struct S_DP (*cb)(struct S_DP, struct S_DP, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PI f19_S_SSI_PI(struct S_PI p0, struct S_PI p1, int p2,  struct S_PI (*cb)(struct S_PI, struct S_PI, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PF f19_S_SSI_PF(struct S_PF p0, struct S_PF p1, int p2,  struct S_PF (*cb)(struct S_PF, struct S_PF, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PD f19_S_SSI_PD(struct S_PD p0, struct S_PD p1, int p2,  struct S_PD (*cb)(struct S_PD, struct S_PD, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PP f19_S_SSI_PP(struct S_PP p0, struct S_PP p1, int p2,  struct S_PP (*cb)(struct S_PP, struct S_PP, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_III f19_S_SSI_III(struct S_III p0, struct S_III p1, int p2,  struct S_III (*cb)(struct S_III, struct S_III, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IIF f19_S_SSI_IIF(struct S_IIF p0, struct S_IIF p1, int p2,  struct S_IIF (*cb)(struct S_IIF, struct S_IIF, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IID f19_S_SSI_IID(struct S_IID p0, struct S_IID p1, int p2,  struct S_IID (*cb)(struct S_IID, struct S_IID, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IIP f19_S_SSI_IIP(struct S_IIP p0, struct S_IIP p1, int p2,  struct S_IIP (*cb)(struct S_IIP, struct S_IIP, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFI f19_S_SSI_IFI(struct S_IFI p0, struct S_IFI p1, int p2,  struct S_IFI (*cb)(struct S_IFI, struct S_IFI, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFF f19_S_SSI_IFF(struct S_IFF p0, struct S_IFF p1, int p2,  struct S_IFF (*cb)(struct S_IFF, struct S_IFF, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFD f19_S_SSI_IFD(struct S_IFD p0, struct S_IFD p1, int p2,  struct S_IFD (*cb)(struct S_IFD, struct S_IFD, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFP f19_S_SSI_IFP(struct S_IFP p0, struct S_IFP p1, int p2,  struct S_IFP (*cb)(struct S_IFP, struct S_IFP, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDI f19_S_SSI_IDI(struct S_IDI p0, struct S_IDI p1, int p2,  struct S_IDI (*cb)(struct S_IDI, struct S_IDI, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDF f19_S_SSI_IDF(struct S_IDF p0, struct S_IDF p1, int p2,  struct S_IDF (*cb)(struct S_IDF, struct S_IDF, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDD f19_S_SSI_IDD(struct S_IDD p0, struct S_IDD p1, int p2,  struct S_IDD (*cb)(struct S_IDD, struct S_IDD, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDP f19_S_SSI_IDP(struct S_IDP p0, struct S_IDP p1, int p2,  struct S_IDP (*cb)(struct S_IDP, struct S_IDP, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPI f19_S_SSI_IPI(struct S_IPI p0, struct S_IPI p1, int p2,  struct S_IPI (*cb)(struct S_IPI, struct S_IPI, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPF f19_S_SSI_IPF(struct S_IPF p0, struct S_IPF p1, int p2,  struct S_IPF (*cb)(struct S_IPF, struct S_IPF, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPD f19_S_SSI_IPD(struct S_IPD p0, struct S_IPD p1, int p2,  struct S_IPD (*cb)(struct S_IPD, struct S_IPD, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPP f19_S_SSI_IPP(struct S_IPP p0, struct S_IPP p1, int p2,  struct S_IPP (*cb)(struct S_IPP, struct S_IPP, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FII f19_S_SSI_FII(struct S_FII p0, struct S_FII p1, int p2,  struct S_FII (*cb)(struct S_FII, struct S_FII, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FIF f19_S_SSI_FIF(struct S_FIF p0, struct S_FIF p1, int p2,  struct S_FIF (*cb)(struct S_FIF, struct S_FIF, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FID f19_S_SSI_FID(struct S_FID p0, struct S_FID p1, int p2,  struct S_FID (*cb)(struct S_FID, struct S_FID, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FIP f19_S_SSI_FIP(struct S_FIP p0, struct S_FIP p1, int p2,  struct S_FIP (*cb)(struct S_FIP, struct S_FIP, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFI f19_S_SSI_FFI(struct S_FFI p0, struct S_FFI p1, int p2,  struct S_FFI (*cb)(struct S_FFI, struct S_FFI, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFF f19_S_SSI_FFF(struct S_FFF p0, struct S_FFF p1, int p2,  struct S_FFF (*cb)(struct S_FFF, struct S_FFF, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFD f19_S_SSI_FFD(struct S_FFD p0, struct S_FFD p1, int p2,  struct S_FFD (*cb)(struct S_FFD, struct S_FFD, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFP f19_S_SSI_FFP(struct S_FFP p0, struct S_FFP p1, int p2,  struct S_FFP (*cb)(struct S_FFP, struct S_FFP, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDI f19_S_SSI_FDI(struct S_FDI p0, struct S_FDI p1, int p2,  struct S_FDI (*cb)(struct S_FDI, struct S_FDI, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDF f19_S_SSI_FDF(struct S_FDF p0, struct S_FDF p1, int p2,  struct S_FDF (*cb)(struct S_FDF, struct S_FDF, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDD f19_S_SSI_FDD(struct S_FDD p0, struct S_FDD p1, int p2,  struct S_FDD (*cb)(struct S_FDD, struct S_FDD, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDP f19_S_SSI_FDP(struct S_FDP p0, struct S_FDP p1, int p2,  struct S_FDP (*cb)(struct S_FDP, struct S_FDP, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPI f19_S_SSI_FPI(struct S_FPI p0, struct S_FPI p1, int p2,  struct S_FPI (*cb)(struct S_FPI, struct S_FPI, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPF f19_S_SSI_FPF(struct S_FPF p0, struct S_FPF p1, int p2,  struct S_FPF (*cb)(struct S_FPF, struct S_FPF, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPD f19_S_SSI_FPD(struct S_FPD p0, struct S_FPD p1, int p2,  struct S_FPD (*cb)(struct S_FPD, struct S_FPD, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPP f19_S_SSI_FPP(struct S_FPP p0, struct S_FPP p1, int p2,  struct S_FPP (*cb)(struct S_FPP, struct S_FPP, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DII f19_S_SSI_DII(struct S_DII p0, struct S_DII p1, int p2,  struct S_DII (*cb)(struct S_DII, struct S_DII, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DIF f19_S_SSI_DIF(struct S_DIF p0, struct S_DIF p1, int p2,  struct S_DIF (*cb)(struct S_DIF, struct S_DIF, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DID f19_S_SSI_DID(struct S_DID p0, struct S_DID p1, int p2,  struct S_DID (*cb)(struct S_DID, struct S_DID, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DIP f19_S_SSI_DIP(struct S_DIP p0, struct S_DIP p1, int p2,  struct S_DIP (*cb)(struct S_DIP, struct S_DIP, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFI f19_S_SSI_DFI(struct S_DFI p0, struct S_DFI p1, int p2,  struct S_DFI (*cb)(struct S_DFI, struct S_DFI, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFF f19_S_SSI_DFF(struct S_DFF p0, struct S_DFF p1, int p2,  struct S_DFF (*cb)(struct S_DFF, struct S_DFF, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFD f19_S_SSI_DFD(struct S_DFD p0, struct S_DFD p1, int p2,  struct S_DFD (*cb)(struct S_DFD, struct S_DFD, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFP f19_S_SSI_DFP(struct S_DFP p0, struct S_DFP p1, int p2,  struct S_DFP (*cb)(struct S_DFP, struct S_DFP, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDI f19_S_SSI_DDI(struct S_DDI p0, struct S_DDI p1, int p2,  struct S_DDI (*cb)(struct S_DDI, struct S_DDI, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDF f19_S_SSI_DDF(struct S_DDF p0, struct S_DDF p1, int p2,  struct S_DDF (*cb)(struct S_DDF, struct S_DDF, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDD f19_S_SSI_DDD(struct S_DDD p0, struct S_DDD p1, int p2,  struct S_DDD (*cb)(struct S_DDD, struct S_DDD, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDP f19_S_SSI_DDP(struct S_DDP p0, struct S_DDP p1, int p2,  struct S_DDP (*cb)(struct S_DDP, struct S_DDP, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPI f19_S_SSI_DPI(struct S_DPI p0, struct S_DPI p1, int p2,  struct S_DPI (*cb)(struct S_DPI, struct S_DPI, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPF f19_S_SSI_DPF(struct S_DPF p0, struct S_DPF p1, int p2,  struct S_DPF (*cb)(struct S_DPF, struct S_DPF, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPD f19_S_SSI_DPD(struct S_DPD p0, struct S_DPD p1, int p2,  struct S_DPD (*cb)(struct S_DPD, struct S_DPD, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPP f19_S_SSI_DPP(struct S_DPP p0, struct S_DPP p1, int p2,  struct S_DPP (*cb)(struct S_DPP, struct S_DPP, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PII f19_S_SSI_PII(struct S_PII p0, struct S_PII p1, int p2,  struct S_PII (*cb)(struct S_PII, struct S_PII, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PIF f19_S_SSI_PIF(struct S_PIF p0, struct S_PIF p1, int p2,  struct S_PIF (*cb)(struct S_PIF, struct S_PIF, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PID f19_S_SSI_PID(struct S_PID p0, struct S_PID p1, int p2,  struct S_PID (*cb)(struct S_PID, struct S_PID, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PIP f19_S_SSI_PIP(struct S_PIP p0, struct S_PIP p1, int p2,  struct S_PIP (*cb)(struct S_PIP, struct S_PIP, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFI f19_S_SSI_PFI(struct S_PFI p0, struct S_PFI p1, int p2,  struct S_PFI (*cb)(struct S_PFI, struct S_PFI, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFF f19_S_SSI_PFF(struct S_PFF p0, struct S_PFF p1, int p2,  struct S_PFF (*cb)(struct S_PFF, struct S_PFF, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFD f19_S_SSI_PFD(struct S_PFD p0, struct S_PFD p1, int p2,  struct S_PFD (*cb)(struct S_PFD, struct S_PFD, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFP f19_S_SSI_PFP(struct S_PFP p0, struct S_PFP p1, int p2,  struct S_PFP (*cb)(struct S_PFP, struct S_PFP, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDI f19_S_SSI_PDI(struct S_PDI p0, struct S_PDI p1, int p2,  struct S_PDI (*cb)(struct S_PDI, struct S_PDI, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDF f19_S_SSI_PDF(struct S_PDF p0, struct S_PDF p1, int p2,  struct S_PDF (*cb)(struct S_PDF, struct S_PDF, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDD f19_S_SSI_PDD(struct S_PDD p0, struct S_PDD p1, int p2,  struct S_PDD (*cb)(struct S_PDD, struct S_PDD, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDP f19_S_SSI_PDP(struct S_PDP p0, struct S_PDP p1, int p2,  struct S_PDP (*cb)(struct S_PDP, struct S_PDP, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPI f19_S_SSI_PPI(struct S_PPI p0, struct S_PPI p1, int p2,  struct S_PPI (*cb)(struct S_PPI, struct S_PPI, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPF f19_S_SSI_PPF(struct S_PPF p0, struct S_PPF p1, int p2,  struct S_PPF (*cb)(struct S_PPF, struct S_PPF, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPD f19_S_SSI_PPD(struct S_PPD p0, struct S_PPD p1, int p2,  struct S_PPD (*cb)(struct S_PPD, struct S_PPD, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPP f19_S_SSI_PPP(struct S_PPP p0, struct S_PPP p1, int p2,  struct S_PPP (*cb)(struct S_PPP, struct S_PPP, int)) { return cb(p0,p1,p2); }
+EXPORT struct S_I f19_S_SSF_I(struct S_I p0, struct S_I p1, float p2,  struct S_I (*cb)(struct S_I, struct S_I, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_F f19_S_SSF_F(struct S_F p0, struct S_F p1, float p2,  struct S_F (*cb)(struct S_F, struct S_F, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_D f19_S_SSF_D(struct S_D p0, struct S_D p1, float p2,  struct S_D (*cb)(struct S_D, struct S_D, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_P f19_S_SSF_P(struct S_P p0, struct S_P p1, float p2,  struct S_P (*cb)(struct S_P, struct S_P, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_II f19_S_SSF_II(struct S_II p0, struct S_II p1, float p2,  struct S_II (*cb)(struct S_II, struct S_II, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IF f19_S_SSF_IF(struct S_IF p0, struct S_IF p1, float p2,  struct S_IF (*cb)(struct S_IF, struct S_IF, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_ID f19_S_SSF_ID(struct S_ID p0, struct S_ID p1, float p2,  struct S_ID (*cb)(struct S_ID, struct S_ID, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IP f19_S_SSF_IP(struct S_IP p0, struct S_IP p1, float p2,  struct S_IP (*cb)(struct S_IP, struct S_IP, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FI f19_S_SSF_FI(struct S_FI p0, struct S_FI p1, float p2,  struct S_FI (*cb)(struct S_FI, struct S_FI, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FF f19_S_SSF_FF(struct S_FF p0, struct S_FF p1, float p2,  struct S_FF (*cb)(struct S_FF, struct S_FF, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FD f19_S_SSF_FD(struct S_FD p0, struct S_FD p1, float p2,  struct S_FD (*cb)(struct S_FD, struct S_FD, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FP f19_S_SSF_FP(struct S_FP p0, struct S_FP p1, float p2,  struct S_FP (*cb)(struct S_FP, struct S_FP, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DI f19_S_SSF_DI(struct S_DI p0, struct S_DI p1, float p2,  struct S_DI (*cb)(struct S_DI, struct S_DI, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DF f19_S_SSF_DF(struct S_DF p0, struct S_DF p1, float p2,  struct S_DF (*cb)(struct S_DF, struct S_DF, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DD f19_S_SSF_DD(struct S_DD p0, struct S_DD p1, float p2,  struct S_DD (*cb)(struct S_DD, struct S_DD, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DP f19_S_SSF_DP(struct S_DP p0, struct S_DP p1, float p2,  struct S_DP (*cb)(struct S_DP, struct S_DP, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PI f19_S_SSF_PI(struct S_PI p0, struct S_PI p1, float p2,  struct S_PI (*cb)(struct S_PI, struct S_PI, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PF f19_S_SSF_PF(struct S_PF p0, struct S_PF p1, float p2,  struct S_PF (*cb)(struct S_PF, struct S_PF, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PD f19_S_SSF_PD(struct S_PD p0, struct S_PD p1, float p2,  struct S_PD (*cb)(struct S_PD, struct S_PD, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PP f19_S_SSF_PP(struct S_PP p0, struct S_PP p1, float p2,  struct S_PP (*cb)(struct S_PP, struct S_PP, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_III f19_S_SSF_III(struct S_III p0, struct S_III p1, float p2,  struct S_III (*cb)(struct S_III, struct S_III, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IIF f19_S_SSF_IIF(struct S_IIF p0, struct S_IIF p1, float p2,  struct S_IIF (*cb)(struct S_IIF, struct S_IIF, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IID f19_S_SSF_IID(struct S_IID p0, struct S_IID p1, float p2,  struct S_IID (*cb)(struct S_IID, struct S_IID, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IIP f19_S_SSF_IIP(struct S_IIP p0, struct S_IIP p1, float p2,  struct S_IIP (*cb)(struct S_IIP, struct S_IIP, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFI f19_S_SSF_IFI(struct S_IFI p0, struct S_IFI p1, float p2,  struct S_IFI (*cb)(struct S_IFI, struct S_IFI, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFF f19_S_SSF_IFF(struct S_IFF p0, struct S_IFF p1, float p2,  struct S_IFF (*cb)(struct S_IFF, struct S_IFF, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFD f19_S_SSF_IFD(struct S_IFD p0, struct S_IFD p1, float p2,  struct S_IFD (*cb)(struct S_IFD, struct S_IFD, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFP f19_S_SSF_IFP(struct S_IFP p0, struct S_IFP p1, float p2,  struct S_IFP (*cb)(struct S_IFP, struct S_IFP, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDI f19_S_SSF_IDI(struct S_IDI p0, struct S_IDI p1, float p2,  struct S_IDI (*cb)(struct S_IDI, struct S_IDI, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDF f19_S_SSF_IDF(struct S_IDF p0, struct S_IDF p1, float p2,  struct S_IDF (*cb)(struct S_IDF, struct S_IDF, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDD f19_S_SSF_IDD(struct S_IDD p0, struct S_IDD p1, float p2,  struct S_IDD (*cb)(struct S_IDD, struct S_IDD, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDP f19_S_SSF_IDP(struct S_IDP p0, struct S_IDP p1, float p2,  struct S_IDP (*cb)(struct S_IDP, struct S_IDP, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPI f19_S_SSF_IPI(struct S_IPI p0, struct S_IPI p1, float p2,  struct S_IPI (*cb)(struct S_IPI, struct S_IPI, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPF f19_S_SSF_IPF(struct S_IPF p0, struct S_IPF p1, float p2,  struct S_IPF (*cb)(struct S_IPF, struct S_IPF, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPD f19_S_SSF_IPD(struct S_IPD p0, struct S_IPD p1, float p2,  struct S_IPD (*cb)(struct S_IPD, struct S_IPD, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPP f19_S_SSF_IPP(struct S_IPP p0, struct S_IPP p1, float p2,  struct S_IPP (*cb)(struct S_IPP, struct S_IPP, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FII f19_S_SSF_FII(struct S_FII p0, struct S_FII p1, float p2,  struct S_FII (*cb)(struct S_FII, struct S_FII, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FIF f19_S_SSF_FIF(struct S_FIF p0, struct S_FIF p1, float p2,  struct S_FIF (*cb)(struct S_FIF, struct S_FIF, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FID f19_S_SSF_FID(struct S_FID p0, struct S_FID p1, float p2,  struct S_FID (*cb)(struct S_FID, struct S_FID, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FIP f19_S_SSF_FIP(struct S_FIP p0, struct S_FIP p1, float p2,  struct S_FIP (*cb)(struct S_FIP, struct S_FIP, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFI f19_S_SSF_FFI(struct S_FFI p0, struct S_FFI p1, float p2,  struct S_FFI (*cb)(struct S_FFI, struct S_FFI, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFF f19_S_SSF_FFF(struct S_FFF p0, struct S_FFF p1, float p2,  struct S_FFF (*cb)(struct S_FFF, struct S_FFF, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFD f19_S_SSF_FFD(struct S_FFD p0, struct S_FFD p1, float p2,  struct S_FFD (*cb)(struct S_FFD, struct S_FFD, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFP f19_S_SSF_FFP(struct S_FFP p0, struct S_FFP p1, float p2,  struct S_FFP (*cb)(struct S_FFP, struct S_FFP, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDI f19_S_SSF_FDI(struct S_FDI p0, struct S_FDI p1, float p2,  struct S_FDI (*cb)(struct S_FDI, struct S_FDI, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDF f19_S_SSF_FDF(struct S_FDF p0, struct S_FDF p1, float p2,  struct S_FDF (*cb)(struct S_FDF, struct S_FDF, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDD f19_S_SSF_FDD(struct S_FDD p0, struct S_FDD p1, float p2,  struct S_FDD (*cb)(struct S_FDD, struct S_FDD, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDP f19_S_SSF_FDP(struct S_FDP p0, struct S_FDP p1, float p2,  struct S_FDP (*cb)(struct S_FDP, struct S_FDP, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPI f19_S_SSF_FPI(struct S_FPI p0, struct S_FPI p1, float p2,  struct S_FPI (*cb)(struct S_FPI, struct S_FPI, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPF f19_S_SSF_FPF(struct S_FPF p0, struct S_FPF p1, float p2,  struct S_FPF (*cb)(struct S_FPF, struct S_FPF, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPD f19_S_SSF_FPD(struct S_FPD p0, struct S_FPD p1, float p2,  struct S_FPD (*cb)(struct S_FPD, struct S_FPD, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPP f19_S_SSF_FPP(struct S_FPP p0, struct S_FPP p1, float p2,  struct S_FPP (*cb)(struct S_FPP, struct S_FPP, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DII f19_S_SSF_DII(struct S_DII p0, struct S_DII p1, float p2,  struct S_DII (*cb)(struct S_DII, struct S_DII, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DIF f19_S_SSF_DIF(struct S_DIF p0, struct S_DIF p1, float p2,  struct S_DIF (*cb)(struct S_DIF, struct S_DIF, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DID f19_S_SSF_DID(struct S_DID p0, struct S_DID p1, float p2,  struct S_DID (*cb)(struct S_DID, struct S_DID, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DIP f19_S_SSF_DIP(struct S_DIP p0, struct S_DIP p1, float p2,  struct S_DIP (*cb)(struct S_DIP, struct S_DIP, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFI f19_S_SSF_DFI(struct S_DFI p0, struct S_DFI p1, float p2,  struct S_DFI (*cb)(struct S_DFI, struct S_DFI, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFF f19_S_SSF_DFF(struct S_DFF p0, struct S_DFF p1, float p2,  struct S_DFF (*cb)(struct S_DFF, struct S_DFF, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFD f19_S_SSF_DFD(struct S_DFD p0, struct S_DFD p1, float p2,  struct S_DFD (*cb)(struct S_DFD, struct S_DFD, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFP f19_S_SSF_DFP(struct S_DFP p0, struct S_DFP p1, float p2,  struct S_DFP (*cb)(struct S_DFP, struct S_DFP, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDI f19_S_SSF_DDI(struct S_DDI p0, struct S_DDI p1, float p2,  struct S_DDI (*cb)(struct S_DDI, struct S_DDI, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDF f19_S_SSF_DDF(struct S_DDF p0, struct S_DDF p1, float p2,  struct S_DDF (*cb)(struct S_DDF, struct S_DDF, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDD f19_S_SSF_DDD(struct S_DDD p0, struct S_DDD p1, float p2,  struct S_DDD (*cb)(struct S_DDD, struct S_DDD, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDP f19_S_SSF_DDP(struct S_DDP p0, struct S_DDP p1, float p2,  struct S_DDP (*cb)(struct S_DDP, struct S_DDP, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPI f19_S_SSF_DPI(struct S_DPI p0, struct S_DPI p1, float p2,  struct S_DPI (*cb)(struct S_DPI, struct S_DPI, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPF f19_S_SSF_DPF(struct S_DPF p0, struct S_DPF p1, float p2,  struct S_DPF (*cb)(struct S_DPF, struct S_DPF, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPD f19_S_SSF_DPD(struct S_DPD p0, struct S_DPD p1, float p2,  struct S_DPD (*cb)(struct S_DPD, struct S_DPD, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPP f19_S_SSF_DPP(struct S_DPP p0, struct S_DPP p1, float p2,  struct S_DPP (*cb)(struct S_DPP, struct S_DPP, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PII f19_S_SSF_PII(struct S_PII p0, struct S_PII p1, float p2,  struct S_PII (*cb)(struct S_PII, struct S_PII, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PIF f19_S_SSF_PIF(struct S_PIF p0, struct S_PIF p1, float p2,  struct S_PIF (*cb)(struct S_PIF, struct S_PIF, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PID f19_S_SSF_PID(struct S_PID p0, struct S_PID p1, float p2,  struct S_PID (*cb)(struct S_PID, struct S_PID, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PIP f19_S_SSF_PIP(struct S_PIP p0, struct S_PIP p1, float p2,  struct S_PIP (*cb)(struct S_PIP, struct S_PIP, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFI f19_S_SSF_PFI(struct S_PFI p0, struct S_PFI p1, float p2,  struct S_PFI (*cb)(struct S_PFI, struct S_PFI, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFF f19_S_SSF_PFF(struct S_PFF p0, struct S_PFF p1, float p2,  struct S_PFF (*cb)(struct S_PFF, struct S_PFF, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFD f19_S_SSF_PFD(struct S_PFD p0, struct S_PFD p1, float p2,  struct S_PFD (*cb)(struct S_PFD, struct S_PFD, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFP f19_S_SSF_PFP(struct S_PFP p0, struct S_PFP p1, float p2,  struct S_PFP (*cb)(struct S_PFP, struct S_PFP, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDI f19_S_SSF_PDI(struct S_PDI p0, struct S_PDI p1, float p2,  struct S_PDI (*cb)(struct S_PDI, struct S_PDI, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDF f19_S_SSF_PDF(struct S_PDF p0, struct S_PDF p1, float p2,  struct S_PDF (*cb)(struct S_PDF, struct S_PDF, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDD f19_S_SSF_PDD(struct S_PDD p0, struct S_PDD p1, float p2,  struct S_PDD (*cb)(struct S_PDD, struct S_PDD, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDP f19_S_SSF_PDP(struct S_PDP p0, struct S_PDP p1, float p2,  struct S_PDP (*cb)(struct S_PDP, struct S_PDP, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPI f19_S_SSF_PPI(struct S_PPI p0, struct S_PPI p1, float p2,  struct S_PPI (*cb)(struct S_PPI, struct S_PPI, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPF f19_S_SSF_PPF(struct S_PPF p0, struct S_PPF p1, float p2,  struct S_PPF (*cb)(struct S_PPF, struct S_PPF, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPD f19_S_SSF_PPD(struct S_PPD p0, struct S_PPD p1, float p2,  struct S_PPD (*cb)(struct S_PPD, struct S_PPD, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPP f19_S_SSF_PPP(struct S_PPP p0, struct S_PPP p1, float p2,  struct S_PPP (*cb)(struct S_PPP, struct S_PPP, float)) { return cb(p0,p1,p2); }
+EXPORT struct S_I f19_S_SSD_I(struct S_I p0, struct S_I p1, double p2,  struct S_I (*cb)(struct S_I, struct S_I, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_F f19_S_SSD_F(struct S_F p0, struct S_F p1, double p2,  struct S_F (*cb)(struct S_F, struct S_F, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_D f19_S_SSD_D(struct S_D p0, struct S_D p1, double p2,  struct S_D (*cb)(struct S_D, struct S_D, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_P f19_S_SSD_P(struct S_P p0, struct S_P p1, double p2,  struct S_P (*cb)(struct S_P, struct S_P, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_II f19_S_SSD_II(struct S_II p0, struct S_II p1, double p2,  struct S_II (*cb)(struct S_II, struct S_II, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IF f19_S_SSD_IF(struct S_IF p0, struct S_IF p1, double p2,  struct S_IF (*cb)(struct S_IF, struct S_IF, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_ID f19_S_SSD_ID(struct S_ID p0, struct S_ID p1, double p2,  struct S_ID (*cb)(struct S_ID, struct S_ID, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IP f19_S_SSD_IP(struct S_IP p0, struct S_IP p1, double p2,  struct S_IP (*cb)(struct S_IP, struct S_IP, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FI f19_S_SSD_FI(struct S_FI p0, struct S_FI p1, double p2,  struct S_FI (*cb)(struct S_FI, struct S_FI, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FF f19_S_SSD_FF(struct S_FF p0, struct S_FF p1, double p2,  struct S_FF (*cb)(struct S_FF, struct S_FF, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FD f19_S_SSD_FD(struct S_FD p0, struct S_FD p1, double p2,  struct S_FD (*cb)(struct S_FD, struct S_FD, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FP f19_S_SSD_FP(struct S_FP p0, struct S_FP p1, double p2,  struct S_FP (*cb)(struct S_FP, struct S_FP, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DI f19_S_SSD_DI(struct S_DI p0, struct S_DI p1, double p2,  struct S_DI (*cb)(struct S_DI, struct S_DI, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DF f19_S_SSD_DF(struct S_DF p0, struct S_DF p1, double p2,  struct S_DF (*cb)(struct S_DF, struct S_DF, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DD f19_S_SSD_DD(struct S_DD p0, struct S_DD p1, double p2,  struct S_DD (*cb)(struct S_DD, struct S_DD, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DP f19_S_SSD_DP(struct S_DP p0, struct S_DP p1, double p2,  struct S_DP (*cb)(struct S_DP, struct S_DP, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PI f19_S_SSD_PI(struct S_PI p0, struct S_PI p1, double p2,  struct S_PI (*cb)(struct S_PI, struct S_PI, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PF f19_S_SSD_PF(struct S_PF p0, struct S_PF p1, double p2,  struct S_PF (*cb)(struct S_PF, struct S_PF, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PD f19_S_SSD_PD(struct S_PD p0, struct S_PD p1, double p2,  struct S_PD (*cb)(struct S_PD, struct S_PD, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PP f19_S_SSD_PP(struct S_PP p0, struct S_PP p1, double p2,  struct S_PP (*cb)(struct S_PP, struct S_PP, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_III f19_S_SSD_III(struct S_III p0, struct S_III p1, double p2,  struct S_III (*cb)(struct S_III, struct S_III, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IIF f19_S_SSD_IIF(struct S_IIF p0, struct S_IIF p1, double p2,  struct S_IIF (*cb)(struct S_IIF, struct S_IIF, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IID f19_S_SSD_IID(struct S_IID p0, struct S_IID p1, double p2,  struct S_IID (*cb)(struct S_IID, struct S_IID, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IIP f19_S_SSD_IIP(struct S_IIP p0, struct S_IIP p1, double p2,  struct S_IIP (*cb)(struct S_IIP, struct S_IIP, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFI f19_S_SSD_IFI(struct S_IFI p0, struct S_IFI p1, double p2,  struct S_IFI (*cb)(struct S_IFI, struct S_IFI, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFF f19_S_SSD_IFF(struct S_IFF p0, struct S_IFF p1, double p2,  struct S_IFF (*cb)(struct S_IFF, struct S_IFF, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFD f19_S_SSD_IFD(struct S_IFD p0, struct S_IFD p1, double p2,  struct S_IFD (*cb)(struct S_IFD, struct S_IFD, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFP f19_S_SSD_IFP(struct S_IFP p0, struct S_IFP p1, double p2,  struct S_IFP (*cb)(struct S_IFP, struct S_IFP, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDI f19_S_SSD_IDI(struct S_IDI p0, struct S_IDI p1, double p2,  struct S_IDI (*cb)(struct S_IDI, struct S_IDI, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDF f19_S_SSD_IDF(struct S_IDF p0, struct S_IDF p1, double p2,  struct S_IDF (*cb)(struct S_IDF, struct S_IDF, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDD f19_S_SSD_IDD(struct S_IDD p0, struct S_IDD p1, double p2,  struct S_IDD (*cb)(struct S_IDD, struct S_IDD, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDP f19_S_SSD_IDP(struct S_IDP p0, struct S_IDP p1, double p2,  struct S_IDP (*cb)(struct S_IDP, struct S_IDP, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPI f19_S_SSD_IPI(struct S_IPI p0, struct S_IPI p1, double p2,  struct S_IPI (*cb)(struct S_IPI, struct S_IPI, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPF f19_S_SSD_IPF(struct S_IPF p0, struct S_IPF p1, double p2,  struct S_IPF (*cb)(struct S_IPF, struct S_IPF, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPD f19_S_SSD_IPD(struct S_IPD p0, struct S_IPD p1, double p2,  struct S_IPD (*cb)(struct S_IPD, struct S_IPD, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPP f19_S_SSD_IPP(struct S_IPP p0, struct S_IPP p1, double p2,  struct S_IPP (*cb)(struct S_IPP, struct S_IPP, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FII f19_S_SSD_FII(struct S_FII p0, struct S_FII p1, double p2,  struct S_FII (*cb)(struct S_FII, struct S_FII, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FIF f19_S_SSD_FIF(struct S_FIF p0, struct S_FIF p1, double p2,  struct S_FIF (*cb)(struct S_FIF, struct S_FIF, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FID f19_S_SSD_FID(struct S_FID p0, struct S_FID p1, double p2,  struct S_FID (*cb)(struct S_FID, struct S_FID, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FIP f19_S_SSD_FIP(struct S_FIP p0, struct S_FIP p1, double p2,  struct S_FIP (*cb)(struct S_FIP, struct S_FIP, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFI f19_S_SSD_FFI(struct S_FFI p0, struct S_FFI p1, double p2,  struct S_FFI (*cb)(struct S_FFI, struct S_FFI, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFF f19_S_SSD_FFF(struct S_FFF p0, struct S_FFF p1, double p2,  struct S_FFF (*cb)(struct S_FFF, struct S_FFF, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFD f19_S_SSD_FFD(struct S_FFD p0, struct S_FFD p1, double p2,  struct S_FFD (*cb)(struct S_FFD, struct S_FFD, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFP f19_S_SSD_FFP(struct S_FFP p0, struct S_FFP p1, double p2,  struct S_FFP (*cb)(struct S_FFP, struct S_FFP, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDI f19_S_SSD_FDI(struct S_FDI p0, struct S_FDI p1, double p2,  struct S_FDI (*cb)(struct S_FDI, struct S_FDI, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDF f19_S_SSD_FDF(struct S_FDF p0, struct S_FDF p1, double p2,  struct S_FDF (*cb)(struct S_FDF, struct S_FDF, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDD f19_S_SSD_FDD(struct S_FDD p0, struct S_FDD p1, double p2,  struct S_FDD (*cb)(struct S_FDD, struct S_FDD, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDP f19_S_SSD_FDP(struct S_FDP p0, struct S_FDP p1, double p2,  struct S_FDP (*cb)(struct S_FDP, struct S_FDP, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPI f19_S_SSD_FPI(struct S_FPI p0, struct S_FPI p1, double p2,  struct S_FPI (*cb)(struct S_FPI, struct S_FPI, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPF f19_S_SSD_FPF(struct S_FPF p0, struct S_FPF p1, double p2,  struct S_FPF (*cb)(struct S_FPF, struct S_FPF, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPD f19_S_SSD_FPD(struct S_FPD p0, struct S_FPD p1, double p2,  struct S_FPD (*cb)(struct S_FPD, struct S_FPD, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPP f19_S_SSD_FPP(struct S_FPP p0, struct S_FPP p1, double p2,  struct S_FPP (*cb)(struct S_FPP, struct S_FPP, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DII f19_S_SSD_DII(struct S_DII p0, struct S_DII p1, double p2,  struct S_DII (*cb)(struct S_DII, struct S_DII, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DIF f19_S_SSD_DIF(struct S_DIF p0, struct S_DIF p1, double p2,  struct S_DIF (*cb)(struct S_DIF, struct S_DIF, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DID f19_S_SSD_DID(struct S_DID p0, struct S_DID p1, double p2,  struct S_DID (*cb)(struct S_DID, struct S_DID, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DIP f19_S_SSD_DIP(struct S_DIP p0, struct S_DIP p1, double p2,  struct S_DIP (*cb)(struct S_DIP, struct S_DIP, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFI f19_S_SSD_DFI(struct S_DFI p0, struct S_DFI p1, double p2,  struct S_DFI (*cb)(struct S_DFI, struct S_DFI, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFF f19_S_SSD_DFF(struct S_DFF p0, struct S_DFF p1, double p2,  struct S_DFF (*cb)(struct S_DFF, struct S_DFF, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFD f19_S_SSD_DFD(struct S_DFD p0, struct S_DFD p1, double p2,  struct S_DFD (*cb)(struct S_DFD, struct S_DFD, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFP f19_S_SSD_DFP(struct S_DFP p0, struct S_DFP p1, double p2,  struct S_DFP (*cb)(struct S_DFP, struct S_DFP, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDI f19_S_SSD_DDI(struct S_DDI p0, struct S_DDI p1, double p2,  struct S_DDI (*cb)(struct S_DDI, struct S_DDI, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDF f19_S_SSD_DDF(struct S_DDF p0, struct S_DDF p1, double p2,  struct S_DDF (*cb)(struct S_DDF, struct S_DDF, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDD f19_S_SSD_DDD(struct S_DDD p0, struct S_DDD p1, double p2,  struct S_DDD (*cb)(struct S_DDD, struct S_DDD, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDP f19_S_SSD_DDP(struct S_DDP p0, struct S_DDP p1, double p2,  struct S_DDP (*cb)(struct S_DDP, struct S_DDP, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPI f19_S_SSD_DPI(struct S_DPI p0, struct S_DPI p1, double p2,  struct S_DPI (*cb)(struct S_DPI, struct S_DPI, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPF f19_S_SSD_DPF(struct S_DPF p0, struct S_DPF p1, double p2,  struct S_DPF (*cb)(struct S_DPF, struct S_DPF, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPD f19_S_SSD_DPD(struct S_DPD p0, struct S_DPD p1, double p2,  struct S_DPD (*cb)(struct S_DPD, struct S_DPD, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPP f19_S_SSD_DPP(struct S_DPP p0, struct S_DPP p1, double p2,  struct S_DPP (*cb)(struct S_DPP, struct S_DPP, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PII f19_S_SSD_PII(struct S_PII p0, struct S_PII p1, double p2,  struct S_PII (*cb)(struct S_PII, struct S_PII, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PIF f19_S_SSD_PIF(struct S_PIF p0, struct S_PIF p1, double p2,  struct S_PIF (*cb)(struct S_PIF, struct S_PIF, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PID f19_S_SSD_PID(struct S_PID p0, struct S_PID p1, double p2,  struct S_PID (*cb)(struct S_PID, struct S_PID, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PIP f19_S_SSD_PIP(struct S_PIP p0, struct S_PIP p1, double p2,  struct S_PIP (*cb)(struct S_PIP, struct S_PIP, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFI f19_S_SSD_PFI(struct S_PFI p0, struct S_PFI p1, double p2,  struct S_PFI (*cb)(struct S_PFI, struct S_PFI, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFF f19_S_SSD_PFF(struct S_PFF p0, struct S_PFF p1, double p2,  struct S_PFF (*cb)(struct S_PFF, struct S_PFF, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFD f19_S_SSD_PFD(struct S_PFD p0, struct S_PFD p1, double p2,  struct S_PFD (*cb)(struct S_PFD, struct S_PFD, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFP f19_S_SSD_PFP(struct S_PFP p0, struct S_PFP p1, double p2,  struct S_PFP (*cb)(struct S_PFP, struct S_PFP, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDI f19_S_SSD_PDI(struct S_PDI p0, struct S_PDI p1, double p2,  struct S_PDI (*cb)(struct S_PDI, struct S_PDI, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDF f19_S_SSD_PDF(struct S_PDF p0, struct S_PDF p1, double p2,  struct S_PDF (*cb)(struct S_PDF, struct S_PDF, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDD f19_S_SSD_PDD(struct S_PDD p0, struct S_PDD p1, double p2,  struct S_PDD (*cb)(struct S_PDD, struct S_PDD, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDP f19_S_SSD_PDP(struct S_PDP p0, struct S_PDP p1, double p2,  struct S_PDP (*cb)(struct S_PDP, struct S_PDP, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPI f19_S_SSD_PPI(struct S_PPI p0, struct S_PPI p1, double p2,  struct S_PPI (*cb)(struct S_PPI, struct S_PPI, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPF f19_S_SSD_PPF(struct S_PPF p0, struct S_PPF p1, double p2,  struct S_PPF (*cb)(struct S_PPF, struct S_PPF, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPD f19_S_SSD_PPD(struct S_PPD p0, struct S_PPD p1, double p2,  struct S_PPD (*cb)(struct S_PPD, struct S_PPD, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPP f19_S_SSD_PPP(struct S_PPP p0, struct S_PPP p1, double p2,  struct S_PPP (*cb)(struct S_PPP, struct S_PPP, double)) { return cb(p0,p1,p2); }
+EXPORT struct S_I f19_S_SSP_I(struct S_I p0, struct S_I p1, void* p2,  struct S_I (*cb)(struct S_I, struct S_I, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_F f19_S_SSP_F(struct S_F p0, struct S_F p1, void* p2,  struct S_F (*cb)(struct S_F, struct S_F, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_D f19_S_SSP_D(struct S_D p0, struct S_D p1, void* p2,  struct S_D (*cb)(struct S_D, struct S_D, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_P f19_S_SSP_P(struct S_P p0, struct S_P p1, void* p2,  struct S_P (*cb)(struct S_P, struct S_P, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_II f19_S_SSP_II(struct S_II p0, struct S_II p1, void* p2,  struct S_II (*cb)(struct S_II, struct S_II, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IF f19_S_SSP_IF(struct S_IF p0, struct S_IF p1, void* p2,  struct S_IF (*cb)(struct S_IF, struct S_IF, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_ID f19_S_SSP_ID(struct S_ID p0, struct S_ID p1, void* p2,  struct S_ID (*cb)(struct S_ID, struct S_ID, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IP f19_S_SSP_IP(struct S_IP p0, struct S_IP p1, void* p2,  struct S_IP (*cb)(struct S_IP, struct S_IP, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FI f19_S_SSP_FI(struct S_FI p0, struct S_FI p1, void* p2,  struct S_FI (*cb)(struct S_FI, struct S_FI, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FF f19_S_SSP_FF(struct S_FF p0, struct S_FF p1, void* p2,  struct S_FF (*cb)(struct S_FF, struct S_FF, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FD f19_S_SSP_FD(struct S_FD p0, struct S_FD p1, void* p2,  struct S_FD (*cb)(struct S_FD, struct S_FD, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FP f19_S_SSP_FP(struct S_FP p0, struct S_FP p1, void* p2,  struct S_FP (*cb)(struct S_FP, struct S_FP, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DI f19_S_SSP_DI(struct S_DI p0, struct S_DI p1, void* p2,  struct S_DI (*cb)(struct S_DI, struct S_DI, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DF f19_S_SSP_DF(struct S_DF p0, struct S_DF p1, void* p2,  struct S_DF (*cb)(struct S_DF, struct S_DF, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DD f19_S_SSP_DD(struct S_DD p0, struct S_DD p1, void* p2,  struct S_DD (*cb)(struct S_DD, struct S_DD, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DP f19_S_SSP_DP(struct S_DP p0, struct S_DP p1, void* p2,  struct S_DP (*cb)(struct S_DP, struct S_DP, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PI f19_S_SSP_PI(struct S_PI p0, struct S_PI p1, void* p2,  struct S_PI (*cb)(struct S_PI, struct S_PI, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PF f19_S_SSP_PF(struct S_PF p0, struct S_PF p1, void* p2,  struct S_PF (*cb)(struct S_PF, struct S_PF, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PD f19_S_SSP_PD(struct S_PD p0, struct S_PD p1, void* p2,  struct S_PD (*cb)(struct S_PD, struct S_PD, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PP f19_S_SSP_PP(struct S_PP p0, struct S_PP p1, void* p2,  struct S_PP (*cb)(struct S_PP, struct S_PP, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_III f19_S_SSP_III(struct S_III p0, struct S_III p1, void* p2,  struct S_III (*cb)(struct S_III, struct S_III, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IIF f19_S_SSP_IIF(struct S_IIF p0, struct S_IIF p1, void* p2,  struct S_IIF (*cb)(struct S_IIF, struct S_IIF, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IID f19_S_SSP_IID(struct S_IID p0, struct S_IID p1, void* p2,  struct S_IID (*cb)(struct S_IID, struct S_IID, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IIP f19_S_SSP_IIP(struct S_IIP p0, struct S_IIP p1, void* p2,  struct S_IIP (*cb)(struct S_IIP, struct S_IIP, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFI f19_S_SSP_IFI(struct S_IFI p0, struct S_IFI p1, void* p2,  struct S_IFI (*cb)(struct S_IFI, struct S_IFI, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFF f19_S_SSP_IFF(struct S_IFF p0, struct S_IFF p1, void* p2,  struct S_IFF (*cb)(struct S_IFF, struct S_IFF, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFD f19_S_SSP_IFD(struct S_IFD p0, struct S_IFD p1, void* p2,  struct S_IFD (*cb)(struct S_IFD, struct S_IFD, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFP f19_S_SSP_IFP(struct S_IFP p0, struct S_IFP p1, void* p2,  struct S_IFP (*cb)(struct S_IFP, struct S_IFP, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDI f19_S_SSP_IDI(struct S_IDI p0, struct S_IDI p1, void* p2,  struct S_IDI (*cb)(struct S_IDI, struct S_IDI, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDF f19_S_SSP_IDF(struct S_IDF p0, struct S_IDF p1, void* p2,  struct S_IDF (*cb)(struct S_IDF, struct S_IDF, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDD f19_S_SSP_IDD(struct S_IDD p0, struct S_IDD p1, void* p2,  struct S_IDD (*cb)(struct S_IDD, struct S_IDD, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDP f19_S_SSP_IDP(struct S_IDP p0, struct S_IDP p1, void* p2,  struct S_IDP (*cb)(struct S_IDP, struct S_IDP, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPI f19_S_SSP_IPI(struct S_IPI p0, struct S_IPI p1, void* p2,  struct S_IPI (*cb)(struct S_IPI, struct S_IPI, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPF f19_S_SSP_IPF(struct S_IPF p0, struct S_IPF p1, void* p2,  struct S_IPF (*cb)(struct S_IPF, struct S_IPF, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPD f19_S_SSP_IPD(struct S_IPD p0, struct S_IPD p1, void* p2,  struct S_IPD (*cb)(struct S_IPD, struct S_IPD, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPP f19_S_SSP_IPP(struct S_IPP p0, struct S_IPP p1, void* p2,  struct S_IPP (*cb)(struct S_IPP, struct S_IPP, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FII f19_S_SSP_FII(struct S_FII p0, struct S_FII p1, void* p2,  struct S_FII (*cb)(struct S_FII, struct S_FII, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FIF f19_S_SSP_FIF(struct S_FIF p0, struct S_FIF p1, void* p2,  struct S_FIF (*cb)(struct S_FIF, struct S_FIF, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FID f19_S_SSP_FID(struct S_FID p0, struct S_FID p1, void* p2,  struct S_FID (*cb)(struct S_FID, struct S_FID, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FIP f19_S_SSP_FIP(struct S_FIP p0, struct S_FIP p1, void* p2,  struct S_FIP (*cb)(struct S_FIP, struct S_FIP, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFI f19_S_SSP_FFI(struct S_FFI p0, struct S_FFI p1, void* p2,  struct S_FFI (*cb)(struct S_FFI, struct S_FFI, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFF f19_S_SSP_FFF(struct S_FFF p0, struct S_FFF p1, void* p2,  struct S_FFF (*cb)(struct S_FFF, struct S_FFF, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFD f19_S_SSP_FFD(struct S_FFD p0, struct S_FFD p1, void* p2,  struct S_FFD (*cb)(struct S_FFD, struct S_FFD, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFP f19_S_SSP_FFP(struct S_FFP p0, struct S_FFP p1, void* p2,  struct S_FFP (*cb)(struct S_FFP, struct S_FFP, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDI f19_S_SSP_FDI(struct S_FDI p0, struct S_FDI p1, void* p2,  struct S_FDI (*cb)(struct S_FDI, struct S_FDI, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDF f19_S_SSP_FDF(struct S_FDF p0, struct S_FDF p1, void* p2,  struct S_FDF (*cb)(struct S_FDF, struct S_FDF, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDD f19_S_SSP_FDD(struct S_FDD p0, struct S_FDD p1, void* p2,  struct S_FDD (*cb)(struct S_FDD, struct S_FDD, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDP f19_S_SSP_FDP(struct S_FDP p0, struct S_FDP p1, void* p2,  struct S_FDP (*cb)(struct S_FDP, struct S_FDP, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPI f19_S_SSP_FPI(struct S_FPI p0, struct S_FPI p1, void* p2,  struct S_FPI (*cb)(struct S_FPI, struct S_FPI, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPF f19_S_SSP_FPF(struct S_FPF p0, struct S_FPF p1, void* p2,  struct S_FPF (*cb)(struct S_FPF, struct S_FPF, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPD f19_S_SSP_FPD(struct S_FPD p0, struct S_FPD p1, void* p2,  struct S_FPD (*cb)(struct S_FPD, struct S_FPD, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPP f19_S_SSP_FPP(struct S_FPP p0, struct S_FPP p1, void* p2,  struct S_FPP (*cb)(struct S_FPP, struct S_FPP, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DII f19_S_SSP_DII(struct S_DII p0, struct S_DII p1, void* p2,  struct S_DII (*cb)(struct S_DII, struct S_DII, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DIF f19_S_SSP_DIF(struct S_DIF p0, struct S_DIF p1, void* p2,  struct S_DIF (*cb)(struct S_DIF, struct S_DIF, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DID f19_S_SSP_DID(struct S_DID p0, struct S_DID p1, void* p2,  struct S_DID (*cb)(struct S_DID, struct S_DID, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DIP f19_S_SSP_DIP(struct S_DIP p0, struct S_DIP p1, void* p2,  struct S_DIP (*cb)(struct S_DIP, struct S_DIP, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFI f19_S_SSP_DFI(struct S_DFI p0, struct S_DFI p1, void* p2,  struct S_DFI (*cb)(struct S_DFI, struct S_DFI, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFF f19_S_SSP_DFF(struct S_DFF p0, struct S_DFF p1, void* p2,  struct S_DFF (*cb)(struct S_DFF, struct S_DFF, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFD f19_S_SSP_DFD(struct S_DFD p0, struct S_DFD p1, void* p2,  struct S_DFD (*cb)(struct S_DFD, struct S_DFD, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFP f19_S_SSP_DFP(struct S_DFP p0, struct S_DFP p1, void* p2,  struct S_DFP (*cb)(struct S_DFP, struct S_DFP, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDI f19_S_SSP_DDI(struct S_DDI p0, struct S_DDI p1, void* p2,  struct S_DDI (*cb)(struct S_DDI, struct S_DDI, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDF f19_S_SSP_DDF(struct S_DDF p0, struct S_DDF p1, void* p2,  struct S_DDF (*cb)(struct S_DDF, struct S_DDF, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDD f19_S_SSP_DDD(struct S_DDD p0, struct S_DDD p1, void* p2,  struct S_DDD (*cb)(struct S_DDD, struct S_DDD, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDP f19_S_SSP_DDP(struct S_DDP p0, struct S_DDP p1, void* p2,  struct S_DDP (*cb)(struct S_DDP, struct S_DDP, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPI f19_S_SSP_DPI(struct S_DPI p0, struct S_DPI p1, void* p2,  struct S_DPI (*cb)(struct S_DPI, struct S_DPI, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPF f19_S_SSP_DPF(struct S_DPF p0, struct S_DPF p1, void* p2,  struct S_DPF (*cb)(struct S_DPF, struct S_DPF, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPD f19_S_SSP_DPD(struct S_DPD p0, struct S_DPD p1, void* p2,  struct S_DPD (*cb)(struct S_DPD, struct S_DPD, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPP f19_S_SSP_DPP(struct S_DPP p0, struct S_DPP p1, void* p2,  struct S_DPP (*cb)(struct S_DPP, struct S_DPP, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PII f19_S_SSP_PII(struct S_PII p0, struct S_PII p1, void* p2,  struct S_PII (*cb)(struct S_PII, struct S_PII, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PIF f19_S_SSP_PIF(struct S_PIF p0, struct S_PIF p1, void* p2,  struct S_PIF (*cb)(struct S_PIF, struct S_PIF, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PID f19_S_SSP_PID(struct S_PID p0, struct S_PID p1, void* p2,  struct S_PID (*cb)(struct S_PID, struct S_PID, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PIP f20_S_SSP_PIP(struct S_PIP p0, struct S_PIP p1, void* p2,  struct S_PIP (*cb)(struct S_PIP, struct S_PIP, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFI f20_S_SSP_PFI(struct S_PFI p0, struct S_PFI p1, void* p2,  struct S_PFI (*cb)(struct S_PFI, struct S_PFI, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFF f20_S_SSP_PFF(struct S_PFF p0, struct S_PFF p1, void* p2,  struct S_PFF (*cb)(struct S_PFF, struct S_PFF, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFD f20_S_SSP_PFD(struct S_PFD p0, struct S_PFD p1, void* p2,  struct S_PFD (*cb)(struct S_PFD, struct S_PFD, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFP f20_S_SSP_PFP(struct S_PFP p0, struct S_PFP p1, void* p2,  struct S_PFP (*cb)(struct S_PFP, struct S_PFP, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDI f20_S_SSP_PDI(struct S_PDI p0, struct S_PDI p1, void* p2,  struct S_PDI (*cb)(struct S_PDI, struct S_PDI, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDF f20_S_SSP_PDF(struct S_PDF p0, struct S_PDF p1, void* p2,  struct S_PDF (*cb)(struct S_PDF, struct S_PDF, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDD f20_S_SSP_PDD(struct S_PDD p0, struct S_PDD p1, void* p2,  struct S_PDD (*cb)(struct S_PDD, struct S_PDD, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDP f20_S_SSP_PDP(struct S_PDP p0, struct S_PDP p1, void* p2,  struct S_PDP (*cb)(struct S_PDP, struct S_PDP, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPI f20_S_SSP_PPI(struct S_PPI p0, struct S_PPI p1, void* p2,  struct S_PPI (*cb)(struct S_PPI, struct S_PPI, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPF f20_S_SSP_PPF(struct S_PPF p0, struct S_PPF p1, void* p2,  struct S_PPF (*cb)(struct S_PPF, struct S_PPF, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPD f20_S_SSP_PPD(struct S_PPD p0, struct S_PPD p1, void* p2,  struct S_PPD (*cb)(struct S_PPD, struct S_PPD, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPP f20_S_SSP_PPP(struct S_PPP p0, struct S_PPP p1, void* p2,  struct S_PPP (*cb)(struct S_PPP, struct S_PPP, void*)) { return cb(p0,p1,p2); }
+EXPORT struct S_I f20_S_SSS_I(struct S_I p0, struct S_I p1, struct S_I p2,  struct S_I (*cb)(struct S_I, struct S_I, struct S_I)) { return cb(p0,p1,p2); }
+EXPORT struct S_F f20_S_SSS_F(struct S_F p0, struct S_F p1, struct S_F p2,  struct S_F (*cb)(struct S_F, struct S_F, struct S_F)) { return cb(p0,p1,p2); }
+EXPORT struct S_D f20_S_SSS_D(struct S_D p0, struct S_D p1, struct S_D p2,  struct S_D (*cb)(struct S_D, struct S_D, struct S_D)) { return cb(p0,p1,p2); }
+EXPORT struct S_P f20_S_SSS_P(struct S_P p0, struct S_P p1, struct S_P p2,  struct S_P (*cb)(struct S_P, struct S_P, struct S_P)) { return cb(p0,p1,p2); }
+EXPORT struct S_II f20_S_SSS_II(struct S_II p0, struct S_II p1, struct S_II p2,  struct S_II (*cb)(struct S_II, struct S_II, struct S_II)) { return cb(p0,p1,p2); }
+EXPORT struct S_IF f20_S_SSS_IF(struct S_IF p0, struct S_IF p1, struct S_IF p2,  struct S_IF (*cb)(struct S_IF, struct S_IF, struct S_IF)) { return cb(p0,p1,p2); }
+EXPORT struct S_ID f20_S_SSS_ID(struct S_ID p0, struct S_ID p1, struct S_ID p2,  struct S_ID (*cb)(struct S_ID, struct S_ID, struct S_ID)) { return cb(p0,p1,p2); }
+EXPORT struct S_IP f20_S_SSS_IP(struct S_IP p0, struct S_IP p1, struct S_IP p2,  struct S_IP (*cb)(struct S_IP, struct S_IP, struct S_IP)) { return cb(p0,p1,p2); }
+EXPORT struct S_FI f20_S_SSS_FI(struct S_FI p0, struct S_FI p1, struct S_FI p2,  struct S_FI (*cb)(struct S_FI, struct S_FI, struct S_FI)) { return cb(p0,p1,p2); }
+EXPORT struct S_FF f20_S_SSS_FF(struct S_FF p0, struct S_FF p1, struct S_FF p2,  struct S_FF (*cb)(struct S_FF, struct S_FF, struct S_FF)) { return cb(p0,p1,p2); }
+EXPORT struct S_FD f20_S_SSS_FD(struct S_FD p0, struct S_FD p1, struct S_FD p2,  struct S_FD (*cb)(struct S_FD, struct S_FD, struct S_FD)) { return cb(p0,p1,p2); }
+EXPORT struct S_FP f20_S_SSS_FP(struct S_FP p0, struct S_FP p1, struct S_FP p2,  struct S_FP (*cb)(struct S_FP, struct S_FP, struct S_FP)) { return cb(p0,p1,p2); }
+EXPORT struct S_DI f20_S_SSS_DI(struct S_DI p0, struct S_DI p1, struct S_DI p2,  struct S_DI (*cb)(struct S_DI, struct S_DI, struct S_DI)) { return cb(p0,p1,p2); }
+EXPORT struct S_DF f20_S_SSS_DF(struct S_DF p0, struct S_DF p1, struct S_DF p2,  struct S_DF (*cb)(struct S_DF, struct S_DF, struct S_DF)) { return cb(p0,p1,p2); }
+EXPORT struct S_DD f20_S_SSS_DD(struct S_DD p0, struct S_DD p1, struct S_DD p2,  struct S_DD (*cb)(struct S_DD, struct S_DD, struct S_DD)) { return cb(p0,p1,p2); }
+EXPORT struct S_DP f20_S_SSS_DP(struct S_DP p0, struct S_DP p1, struct S_DP p2,  struct S_DP (*cb)(struct S_DP, struct S_DP, struct S_DP)) { return cb(p0,p1,p2); }
+EXPORT struct S_PI f20_S_SSS_PI(struct S_PI p0, struct S_PI p1, struct S_PI p2,  struct S_PI (*cb)(struct S_PI, struct S_PI, struct S_PI)) { return cb(p0,p1,p2); }
+EXPORT struct S_PF f20_S_SSS_PF(struct S_PF p0, struct S_PF p1, struct S_PF p2,  struct S_PF (*cb)(struct S_PF, struct S_PF, struct S_PF)) { return cb(p0,p1,p2); }
+EXPORT struct S_PD f20_S_SSS_PD(struct S_PD p0, struct S_PD p1, struct S_PD p2,  struct S_PD (*cb)(struct S_PD, struct S_PD, struct S_PD)) { return cb(p0,p1,p2); }
+EXPORT struct S_PP f20_S_SSS_PP(struct S_PP p0, struct S_PP p1, struct S_PP p2,  struct S_PP (*cb)(struct S_PP, struct S_PP, struct S_PP)) { return cb(p0,p1,p2); }
+EXPORT struct S_III f20_S_SSS_III(struct S_III p0, struct S_III p1, struct S_III p2,  struct S_III (*cb)(struct S_III, struct S_III, struct S_III)) { return cb(p0,p1,p2); }
+EXPORT struct S_IIF f20_S_SSS_IIF(struct S_IIF p0, struct S_IIF p1, struct S_IIF p2,  struct S_IIF (*cb)(struct S_IIF, struct S_IIF, struct S_IIF)) { return cb(p0,p1,p2); }
+EXPORT struct S_IID f20_S_SSS_IID(struct S_IID p0, struct S_IID p1, struct S_IID p2,  struct S_IID (*cb)(struct S_IID, struct S_IID, struct S_IID)) { return cb(p0,p1,p2); }
+EXPORT struct S_IIP f20_S_SSS_IIP(struct S_IIP p0, struct S_IIP p1, struct S_IIP p2,  struct S_IIP (*cb)(struct S_IIP, struct S_IIP, struct S_IIP)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFI f20_S_SSS_IFI(struct S_IFI p0, struct S_IFI p1, struct S_IFI p2,  struct S_IFI (*cb)(struct S_IFI, struct S_IFI, struct S_IFI)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFF f20_S_SSS_IFF(struct S_IFF p0, struct S_IFF p1, struct S_IFF p2,  struct S_IFF (*cb)(struct S_IFF, struct S_IFF, struct S_IFF)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFD f20_S_SSS_IFD(struct S_IFD p0, struct S_IFD p1, struct S_IFD p2,  struct S_IFD (*cb)(struct S_IFD, struct S_IFD, struct S_IFD)) { return cb(p0,p1,p2); }
+EXPORT struct S_IFP f20_S_SSS_IFP(struct S_IFP p0, struct S_IFP p1, struct S_IFP p2,  struct S_IFP (*cb)(struct S_IFP, struct S_IFP, struct S_IFP)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDI f20_S_SSS_IDI(struct S_IDI p0, struct S_IDI p1, struct S_IDI p2,  struct S_IDI (*cb)(struct S_IDI, struct S_IDI, struct S_IDI)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDF f20_S_SSS_IDF(struct S_IDF p0, struct S_IDF p1, struct S_IDF p2,  struct S_IDF (*cb)(struct S_IDF, struct S_IDF, struct S_IDF)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDD f20_S_SSS_IDD(struct S_IDD p0, struct S_IDD p1, struct S_IDD p2,  struct S_IDD (*cb)(struct S_IDD, struct S_IDD, struct S_IDD)) { return cb(p0,p1,p2); }
+EXPORT struct S_IDP f20_S_SSS_IDP(struct S_IDP p0, struct S_IDP p1, struct S_IDP p2,  struct S_IDP (*cb)(struct S_IDP, struct S_IDP, struct S_IDP)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPI f20_S_SSS_IPI(struct S_IPI p0, struct S_IPI p1, struct S_IPI p2,  struct S_IPI (*cb)(struct S_IPI, struct S_IPI, struct S_IPI)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPF f20_S_SSS_IPF(struct S_IPF p0, struct S_IPF p1, struct S_IPF p2,  struct S_IPF (*cb)(struct S_IPF, struct S_IPF, struct S_IPF)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPD f20_S_SSS_IPD(struct S_IPD p0, struct S_IPD p1, struct S_IPD p2,  struct S_IPD (*cb)(struct S_IPD, struct S_IPD, struct S_IPD)) { return cb(p0,p1,p2); }
+EXPORT struct S_IPP f20_S_SSS_IPP(struct S_IPP p0, struct S_IPP p1, struct S_IPP p2,  struct S_IPP (*cb)(struct S_IPP, struct S_IPP, struct S_IPP)) { return cb(p0,p1,p2); }
+EXPORT struct S_FII f20_S_SSS_FII(struct S_FII p0, struct S_FII p1, struct S_FII p2,  struct S_FII (*cb)(struct S_FII, struct S_FII, struct S_FII)) { return cb(p0,p1,p2); }
+EXPORT struct S_FIF f20_S_SSS_FIF(struct S_FIF p0, struct S_FIF p1, struct S_FIF p2,  struct S_FIF (*cb)(struct S_FIF, struct S_FIF, struct S_FIF)) { return cb(p0,p1,p2); }
+EXPORT struct S_FID f20_S_SSS_FID(struct S_FID p0, struct S_FID p1, struct S_FID p2,  struct S_FID (*cb)(struct S_FID, struct S_FID, struct S_FID)) { return cb(p0,p1,p2); }
+EXPORT struct S_FIP f20_S_SSS_FIP(struct S_FIP p0, struct S_FIP p1, struct S_FIP p2,  struct S_FIP (*cb)(struct S_FIP, struct S_FIP, struct S_FIP)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFI f20_S_SSS_FFI(struct S_FFI p0, struct S_FFI p1, struct S_FFI p2,  struct S_FFI (*cb)(struct S_FFI, struct S_FFI, struct S_FFI)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFF f20_S_SSS_FFF(struct S_FFF p0, struct S_FFF p1, struct S_FFF p2,  struct S_FFF (*cb)(struct S_FFF, struct S_FFF, struct S_FFF)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFD f20_S_SSS_FFD(struct S_FFD p0, struct S_FFD p1, struct S_FFD p2,  struct S_FFD (*cb)(struct S_FFD, struct S_FFD, struct S_FFD)) { return cb(p0,p1,p2); }
+EXPORT struct S_FFP f20_S_SSS_FFP(struct S_FFP p0, struct S_FFP p1, struct S_FFP p2,  struct S_FFP (*cb)(struct S_FFP, struct S_FFP, struct S_FFP)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDI f20_S_SSS_FDI(struct S_FDI p0, struct S_FDI p1, struct S_FDI p2,  struct S_FDI (*cb)(struct S_FDI, struct S_FDI, struct S_FDI)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDF f20_S_SSS_FDF(struct S_FDF p0, struct S_FDF p1, struct S_FDF p2,  struct S_FDF (*cb)(struct S_FDF, struct S_FDF, struct S_FDF)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDD f20_S_SSS_FDD(struct S_FDD p0, struct S_FDD p1, struct S_FDD p2,  struct S_FDD (*cb)(struct S_FDD, struct S_FDD, struct S_FDD)) { return cb(p0,p1,p2); }
+EXPORT struct S_FDP f20_S_SSS_FDP(struct S_FDP p0, struct S_FDP p1, struct S_FDP p2,  struct S_FDP (*cb)(struct S_FDP, struct S_FDP, struct S_FDP)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPI f20_S_SSS_FPI(struct S_FPI p0, struct S_FPI p1, struct S_FPI p2,  struct S_FPI (*cb)(struct S_FPI, struct S_FPI, struct S_FPI)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPF f20_S_SSS_FPF(struct S_FPF p0, struct S_FPF p1, struct S_FPF p2,  struct S_FPF (*cb)(struct S_FPF, struct S_FPF, struct S_FPF)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPD f20_S_SSS_FPD(struct S_FPD p0, struct S_FPD p1, struct S_FPD p2,  struct S_FPD (*cb)(struct S_FPD, struct S_FPD, struct S_FPD)) { return cb(p0,p1,p2); }
+EXPORT struct S_FPP f20_S_SSS_FPP(struct S_FPP p0, struct S_FPP p1, struct S_FPP p2,  struct S_FPP (*cb)(struct S_FPP, struct S_FPP, struct S_FPP)) { return cb(p0,p1,p2); }
+EXPORT struct S_DII f20_S_SSS_DII(struct S_DII p0, struct S_DII p1, struct S_DII p2,  struct S_DII (*cb)(struct S_DII, struct S_DII, struct S_DII)) { return cb(p0,p1,p2); }
+EXPORT struct S_DIF f20_S_SSS_DIF(struct S_DIF p0, struct S_DIF p1, struct S_DIF p2,  struct S_DIF (*cb)(struct S_DIF, struct S_DIF, struct S_DIF)) { return cb(p0,p1,p2); }
+EXPORT struct S_DID f20_S_SSS_DID(struct S_DID p0, struct S_DID p1, struct S_DID p2,  struct S_DID (*cb)(struct S_DID, struct S_DID, struct S_DID)) { return cb(p0,p1,p2); }
+EXPORT struct S_DIP f20_S_SSS_DIP(struct S_DIP p0, struct S_DIP p1, struct S_DIP p2,  struct S_DIP (*cb)(struct S_DIP, struct S_DIP, struct S_DIP)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFI f20_S_SSS_DFI(struct S_DFI p0, struct S_DFI p1, struct S_DFI p2,  struct S_DFI (*cb)(struct S_DFI, struct S_DFI, struct S_DFI)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFF f20_S_SSS_DFF(struct S_DFF p0, struct S_DFF p1, struct S_DFF p2,  struct S_DFF (*cb)(struct S_DFF, struct S_DFF, struct S_DFF)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFD f20_S_SSS_DFD(struct S_DFD p0, struct S_DFD p1, struct S_DFD p2,  struct S_DFD (*cb)(struct S_DFD, struct S_DFD, struct S_DFD)) { return cb(p0,p1,p2); }
+EXPORT struct S_DFP f20_S_SSS_DFP(struct S_DFP p0, struct S_DFP p1, struct S_DFP p2,  struct S_DFP (*cb)(struct S_DFP, struct S_DFP, struct S_DFP)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDI f20_S_SSS_DDI(struct S_DDI p0, struct S_DDI p1, struct S_DDI p2,  struct S_DDI (*cb)(struct S_DDI, struct S_DDI, struct S_DDI)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDF f20_S_SSS_DDF(struct S_DDF p0, struct S_DDF p1, struct S_DDF p2,  struct S_DDF (*cb)(struct S_DDF, struct S_DDF, struct S_DDF)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDD f20_S_SSS_DDD(struct S_DDD p0, struct S_DDD p1, struct S_DDD p2,  struct S_DDD (*cb)(struct S_DDD, struct S_DDD, struct S_DDD)) { return cb(p0,p1,p2); }
+EXPORT struct S_DDP f20_S_SSS_DDP(struct S_DDP p0, struct S_DDP p1, struct S_DDP p2,  struct S_DDP (*cb)(struct S_DDP, struct S_DDP, struct S_DDP)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPI f20_S_SSS_DPI(struct S_DPI p0, struct S_DPI p1, struct S_DPI p2,  struct S_DPI (*cb)(struct S_DPI, struct S_DPI, struct S_DPI)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPF f20_S_SSS_DPF(struct S_DPF p0, struct S_DPF p1, struct S_DPF p2,  struct S_DPF (*cb)(struct S_DPF, struct S_DPF, struct S_DPF)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPD f20_S_SSS_DPD(struct S_DPD p0, struct S_DPD p1, struct S_DPD p2,  struct S_DPD (*cb)(struct S_DPD, struct S_DPD, struct S_DPD)) { return cb(p0,p1,p2); }
+EXPORT struct S_DPP f20_S_SSS_DPP(struct S_DPP p0, struct S_DPP p1, struct S_DPP p2,  struct S_DPP (*cb)(struct S_DPP, struct S_DPP, struct S_DPP)) { return cb(p0,p1,p2); }
+EXPORT struct S_PII f20_S_SSS_PII(struct S_PII p0, struct S_PII p1, struct S_PII p2,  struct S_PII (*cb)(struct S_PII, struct S_PII, struct S_PII)) { return cb(p0,p1,p2); }
+EXPORT struct S_PIF f20_S_SSS_PIF(struct S_PIF p0, struct S_PIF p1, struct S_PIF p2,  struct S_PIF (*cb)(struct S_PIF, struct S_PIF, struct S_PIF)) { return cb(p0,p1,p2); }
+EXPORT struct S_PID f20_S_SSS_PID(struct S_PID p0, struct S_PID p1, struct S_PID p2,  struct S_PID (*cb)(struct S_PID, struct S_PID, struct S_PID)) { return cb(p0,p1,p2); }
+EXPORT struct S_PIP f20_S_SSS_PIP(struct S_PIP p0, struct S_PIP p1, struct S_PIP p2,  struct S_PIP (*cb)(struct S_PIP, struct S_PIP, struct S_PIP)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFI f20_S_SSS_PFI(struct S_PFI p0, struct S_PFI p1, struct S_PFI p2,  struct S_PFI (*cb)(struct S_PFI, struct S_PFI, struct S_PFI)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFF f20_S_SSS_PFF(struct S_PFF p0, struct S_PFF p1, struct S_PFF p2,  struct S_PFF (*cb)(struct S_PFF, struct S_PFF, struct S_PFF)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFD f20_S_SSS_PFD(struct S_PFD p0, struct S_PFD p1, struct S_PFD p2,  struct S_PFD (*cb)(struct S_PFD, struct S_PFD, struct S_PFD)) { return cb(p0,p1,p2); }
+EXPORT struct S_PFP f20_S_SSS_PFP(struct S_PFP p0, struct S_PFP p1, struct S_PFP p2,  struct S_PFP (*cb)(struct S_PFP, struct S_PFP, struct S_PFP)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDI f20_S_SSS_PDI(struct S_PDI p0, struct S_PDI p1, struct S_PDI p2,  struct S_PDI (*cb)(struct S_PDI, struct S_PDI, struct S_PDI)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDF f20_S_SSS_PDF(struct S_PDF p0, struct S_PDF p1, struct S_PDF p2,  struct S_PDF (*cb)(struct S_PDF, struct S_PDF, struct S_PDF)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDD f20_S_SSS_PDD(struct S_PDD p0, struct S_PDD p1, struct S_PDD p2,  struct S_PDD (*cb)(struct S_PDD, struct S_PDD, struct S_PDD)) { return cb(p0,p1,p2); }
+EXPORT struct S_PDP f20_S_SSS_PDP(struct S_PDP p0, struct S_PDP p1, struct S_PDP p2,  struct S_PDP (*cb)(struct S_PDP, struct S_PDP, struct S_PDP)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPI f20_S_SSS_PPI(struct S_PPI p0, struct S_PPI p1, struct S_PPI p2,  struct S_PPI (*cb)(struct S_PPI, struct S_PPI, struct S_PPI)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPF f20_S_SSS_PPF(struct S_PPF p0, struct S_PPF p1, struct S_PPF p2,  struct S_PPF (*cb)(struct S_PPF, struct S_PPF, struct S_PPF)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPD f20_S_SSS_PPD(struct S_PPD p0, struct S_PPD p1, struct S_PPD p2,  struct S_PPD (*cb)(struct S_PPD, struct S_PPD, struct S_PPD)) { return cb(p0,p1,p2); }
+EXPORT struct S_PPP f20_S_SSS_PPP(struct S_PPP p0, struct S_PPP p1, struct S_PPP p2,  struct S_PPP (*cb)(struct S_PPP, struct S_PPP, struct S_PPP)) { return cb(p0,p1,p2); }
diff --git a/test/jdk/java/foreign/libTestUpcall.h b/test/jdk/java/foreign/libTestUpcall.h
new file mode 100644
index 0000000000000..6d0937a15ded1
--- /dev/null
+++ b/test/jdk/java/foreign/libTestUpcall.h
@@ -0,0 +1,12210 @@
+/*
+ * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+#ifdef _WIN64
+#define EXPORT __declspec(dllexport)
+#else
+#define EXPORT
+#endif
+
+struct S_I { int p0; };
+struct S_F { float p0; };
+struct S_D { double p0; };
+struct S_P { void* p0; };
+struct S_II { int p0; int p1; };
+struct S_IF { int p0; float p1; };
+struct S_ID { int p0; double p1; };
+struct S_IP { int p0; void* p1; };
+struct S_FI { float p0; int p1; };
+struct S_FF { float p0; float p1; };
+struct S_FD { float p0; double p1; };
+struct S_FP { float p0; void* p1; };
+struct S_DI { double p0; int p1; };
+struct S_DF { double p0; float p1; };
+struct S_DD { double p0; double p1; };
+struct S_DP { double p0; void* p1; };
+struct S_PI { void* p0; int p1; };
+struct S_PF { void* p0; float p1; };
+struct S_PD { void* p0; double p1; };
+struct S_PP { void* p0; void* p1; };
+struct S_III { int p0; int p1; int p2; };
+struct S_IIF { int p0; int p1; float p2; };
+struct S_IID { int p0; int p1; double p2; };
+struct S_IIP { int p0; int p1; void* p2; };
+struct S_IFI { int p0; float p1; int p2; };
+struct S_IFF { int p0; float p1; float p2; };
+struct S_IFD { int p0; float p1; double p2; };
+struct S_IFP { int p0; float p1; void* p2; };
+struct S_IDI { int p0; double p1; int p2; };
+struct S_IDF { int p0; double p1; float p2; };
+struct S_IDD { int p0; double p1; double p2; };
+struct S_IDP { int p0; double p1; void* p2; };
+struct S_IPI { int p0; void* p1; int p2; };
+struct S_IPF { int p0; void* p1; float p2; };
+struct S_IPD { int p0; void* p1; double p2; };
+struct S_IPP { int p0; void* p1; void* p2; };
+struct S_FII { float p0; int p1; int p2; };
+struct S_FIF { float p0; int p1; float p2; };
+struct S_FID { float p0; int p1; double p2; };
+struct S_FIP { float p0; int p1; void* p2; };
+struct S_FFI { float p0; float p1; int p2; };
+struct S_FFF { float p0; float p1; float p2; };
+struct S_FFD { float p0; float p1; double p2; };
+struct S_FFP { float p0; float p1; void* p2; };
+struct S_FDI { float p0; double p1; int p2; };
+struct S_FDF { float p0; double p1; float p2; };
+struct S_FDD { float p0; double p1; double p2; };
+struct S_FDP { float p0; double p1; void* p2; };
+struct S_FPI { float p0; void* p1; int p2; };
+struct S_FPF { float p0; void* p1; float p2; };
+struct S_FPD { float p0; void* p1; double p2; };
+struct S_FPP { float p0; void* p1; void* p2; };
+struct S_DII { double p0; int p1; int p2; };
+struct S_DIF { double p0; int p1; float p2; };
+struct S_DID { double p0; int p1; double p2; };
+struct S_DIP { double p0; int p1; void* p2; };
+struct S_DFI { double p0; float p1; int p2; };
+struct S_DFF { double p0; float p1; float p2; };
+struct S_DFD { double p0; float p1; double p2; };
+struct S_DFP { double p0; float p1; void* p2; };
+struct S_DDI { double p0; double p1; int p2; };
+struct S_DDF { double p0; double p1; float p2; };
+struct S_DDD { double p0; double p1; double p2; };
+struct S_DDP { double p0; double p1; void* p2; };
+struct S_DPI { double p0; void* p1; int p2; };
+struct S_DPF { double p0; void* p1; float p2; };
+struct S_DPD { double p0; void* p1; double p2; };
+struct S_DPP { double p0; void* p1; void* p2; };
+struct S_PII { void* p0; int p1; int p2; };
+struct S_PIF { void* p0; int p1; float p2; };
+struct S_PID { void* p0; int p1; double p2; };
+struct S_PIP { void* p0; int p1; void* p2; };
+struct S_PFI { void* p0; float p1; int p2; };
+struct S_PFF { void* p0; float p1; float p2; };
+struct S_PFD { void* p0; float p1; double p2; };
+struct S_PFP { void* p0; float p1; void* p2; };
+struct S_PDI { void* p0; double p1; int p2; };
+struct S_PDF { void* p0; double p1; float p2; };
+struct S_PDD { void* p0; double p1; double p2; };
+struct S_PDP { void* p0; double p1; void* p2; };
+struct S_PPI { void* p0; void* p1; int p2; };
+struct S_PPF { void* p0; void* p1; float p2; };
+struct S_PPD { void* p0; void* p1; double p2; };
+struct S_PPP { void* p0; void* p1; void* p2; };
+EXPORT void f0_V__( void (*cb)(void)) ;
+EXPORT void f0_V_I_(int p0,  void (*cb)(int)) ;
+EXPORT void f0_V_F_(float p0,  void (*cb)(float)) ;
+EXPORT void f0_V_D_(double p0,  void (*cb)(double)) ;
+EXPORT void f0_V_P_(void* p0,  void (*cb)(void*)) ;
+EXPORT void f0_V_S_I(struct S_I p0,  void (*cb)(struct S_I)) ;
+EXPORT void f0_V_S_F(struct S_F p0,  void (*cb)(struct S_F)) ;
+EXPORT void f0_V_S_D(struct S_D p0,  void (*cb)(struct S_D)) ;
+EXPORT void f0_V_S_P(struct S_P p0,  void (*cb)(struct S_P)) ;
+EXPORT void f0_V_S_II(struct S_II p0,  void (*cb)(struct S_II)) ;
+EXPORT void f0_V_S_IF(struct S_IF p0,  void (*cb)(struct S_IF)) ;
+EXPORT void f0_V_S_ID(struct S_ID p0,  void (*cb)(struct S_ID)) ;
+EXPORT void f0_V_S_IP(struct S_IP p0,  void (*cb)(struct S_IP)) ;
+EXPORT void f0_V_S_FI(struct S_FI p0,  void (*cb)(struct S_FI)) ;
+EXPORT void f0_V_S_FF(struct S_FF p0,  void (*cb)(struct S_FF)) ;
+EXPORT void f0_V_S_FD(struct S_FD p0,  void (*cb)(struct S_FD)) ;
+EXPORT void f0_V_S_FP(struct S_FP p0,  void (*cb)(struct S_FP)) ;
+EXPORT void f0_V_S_DI(struct S_DI p0,  void (*cb)(struct S_DI)) ;
+EXPORT void f0_V_S_DF(struct S_DF p0,  void (*cb)(struct S_DF)) ;
+EXPORT void f0_V_S_DD(struct S_DD p0,  void (*cb)(struct S_DD)) ;
+EXPORT void f0_V_S_DP(struct S_DP p0,  void (*cb)(struct S_DP)) ;
+EXPORT void f0_V_S_PI(struct S_PI p0,  void (*cb)(struct S_PI)) ;
+EXPORT void f0_V_S_PF(struct S_PF p0,  void (*cb)(struct S_PF)) ;
+EXPORT void f0_V_S_PD(struct S_PD p0,  void (*cb)(struct S_PD)) ;
+EXPORT void f0_V_S_PP(struct S_PP p0,  void (*cb)(struct S_PP)) ;
+EXPORT void f0_V_S_III(struct S_III p0,  void (*cb)(struct S_III)) ;
+EXPORT void f0_V_S_IIF(struct S_IIF p0,  void (*cb)(struct S_IIF)) ;
+EXPORT void f0_V_S_IID(struct S_IID p0,  void (*cb)(struct S_IID)) ;
+EXPORT void f0_V_S_IIP(struct S_IIP p0,  void (*cb)(struct S_IIP)) ;
+EXPORT void f0_V_S_IFI(struct S_IFI p0,  void (*cb)(struct S_IFI)) ;
+EXPORT void f0_V_S_IFF(struct S_IFF p0,  void (*cb)(struct S_IFF)) ;
+EXPORT void f0_V_S_IFD(struct S_IFD p0,  void (*cb)(struct S_IFD)) ;
+EXPORT void f0_V_S_IFP(struct S_IFP p0,  void (*cb)(struct S_IFP)) ;
+EXPORT void f0_V_S_IDI(struct S_IDI p0,  void (*cb)(struct S_IDI)) ;
+EXPORT void f0_V_S_IDF(struct S_IDF p0,  void (*cb)(struct S_IDF)) ;
+EXPORT void f0_V_S_IDD(struct S_IDD p0,  void (*cb)(struct S_IDD)) ;
+EXPORT void f0_V_S_IDP(struct S_IDP p0,  void (*cb)(struct S_IDP)) ;
+EXPORT void f0_V_S_IPI(struct S_IPI p0,  void (*cb)(struct S_IPI)) ;
+EXPORT void f0_V_S_IPF(struct S_IPF p0,  void (*cb)(struct S_IPF)) ;
+EXPORT void f0_V_S_IPD(struct S_IPD p0,  void (*cb)(struct S_IPD)) ;
+EXPORT void f0_V_S_IPP(struct S_IPP p0,  void (*cb)(struct S_IPP)) ;
+EXPORT void f0_V_S_FII(struct S_FII p0,  void (*cb)(struct S_FII)) ;
+EXPORT void f0_V_S_FIF(struct S_FIF p0,  void (*cb)(struct S_FIF)) ;
+EXPORT void f0_V_S_FID(struct S_FID p0,  void (*cb)(struct S_FID)) ;
+EXPORT void f0_V_S_FIP(struct S_FIP p0,  void (*cb)(struct S_FIP)) ;
+EXPORT void f0_V_S_FFI(struct S_FFI p0,  void (*cb)(struct S_FFI)) ;
+EXPORT void f0_V_S_FFF(struct S_FFF p0,  void (*cb)(struct S_FFF)) ;
+EXPORT void f0_V_S_FFD(struct S_FFD p0,  void (*cb)(struct S_FFD)) ;
+EXPORT void f0_V_S_FFP(struct S_FFP p0,  void (*cb)(struct S_FFP)) ;
+EXPORT void f0_V_S_FDI(struct S_FDI p0,  void (*cb)(struct S_FDI)) ;
+EXPORT void f0_V_S_FDF(struct S_FDF p0,  void (*cb)(struct S_FDF)) ;
+EXPORT void f0_V_S_FDD(struct S_FDD p0,  void (*cb)(struct S_FDD)) ;
+EXPORT void f0_V_S_FDP(struct S_FDP p0,  void (*cb)(struct S_FDP)) ;
+EXPORT void f0_V_S_FPI(struct S_FPI p0,  void (*cb)(struct S_FPI)) ;
+EXPORT void f0_V_S_FPF(struct S_FPF p0,  void (*cb)(struct S_FPF)) ;
+EXPORT void f0_V_S_FPD(struct S_FPD p0,  void (*cb)(struct S_FPD)) ;
+EXPORT void f0_V_S_FPP(struct S_FPP p0,  void (*cb)(struct S_FPP)) ;
+EXPORT void f0_V_S_DII(struct S_DII p0,  void (*cb)(struct S_DII)) ;
+EXPORT void f0_V_S_DIF(struct S_DIF p0,  void (*cb)(struct S_DIF)) ;
+EXPORT void f0_V_S_DID(struct S_DID p0,  void (*cb)(struct S_DID)) ;
+EXPORT void f0_V_S_DIP(struct S_DIP p0,  void (*cb)(struct S_DIP)) ;
+EXPORT void f0_V_S_DFI(struct S_DFI p0,  void (*cb)(struct S_DFI)) ;
+EXPORT void f0_V_S_DFF(struct S_DFF p0,  void (*cb)(struct S_DFF)) ;
+EXPORT void f0_V_S_DFD(struct S_DFD p0,  void (*cb)(struct S_DFD)) ;
+EXPORT void f0_V_S_DFP(struct S_DFP p0,  void (*cb)(struct S_DFP)) ;
+EXPORT void f0_V_S_DDI(struct S_DDI p0,  void (*cb)(struct S_DDI)) ;
+EXPORT void f0_V_S_DDF(struct S_DDF p0,  void (*cb)(struct S_DDF)) ;
+EXPORT void f0_V_S_DDD(struct S_DDD p0,  void (*cb)(struct S_DDD)) ;
+EXPORT void f0_V_S_DDP(struct S_DDP p0,  void (*cb)(struct S_DDP)) ;
+EXPORT void f0_V_S_DPI(struct S_DPI p0,  void (*cb)(struct S_DPI)) ;
+EXPORT void f0_V_S_DPF(struct S_DPF p0,  void (*cb)(struct S_DPF)) ;
+EXPORT void f0_V_S_DPD(struct S_DPD p0,  void (*cb)(struct S_DPD)) ;
+EXPORT void f0_V_S_DPP(struct S_DPP p0,  void (*cb)(struct S_DPP)) ;
+EXPORT void f0_V_S_PII(struct S_PII p0,  void (*cb)(struct S_PII)) ;
+EXPORT void f0_V_S_PIF(struct S_PIF p0,  void (*cb)(struct S_PIF)) ;
+EXPORT void f0_V_S_PID(struct S_PID p0,  void (*cb)(struct S_PID)) ;
+EXPORT void f0_V_S_PIP(struct S_PIP p0,  void (*cb)(struct S_PIP)) ;
+EXPORT void f0_V_S_PFI(struct S_PFI p0,  void (*cb)(struct S_PFI)) ;
+EXPORT void f0_V_S_PFF(struct S_PFF p0,  void (*cb)(struct S_PFF)) ;
+EXPORT void f0_V_S_PFD(struct S_PFD p0,  void (*cb)(struct S_PFD)) ;
+EXPORT void f0_V_S_PFP(struct S_PFP p0,  void (*cb)(struct S_PFP)) ;
+EXPORT void f0_V_S_PDI(struct S_PDI p0,  void (*cb)(struct S_PDI)) ;
+EXPORT void f0_V_S_PDF(struct S_PDF p0,  void (*cb)(struct S_PDF)) ;
+EXPORT void f0_V_S_PDD(struct S_PDD p0,  void (*cb)(struct S_PDD)) ;
+EXPORT void f0_V_S_PDP(struct S_PDP p0,  void (*cb)(struct S_PDP)) ;
+EXPORT void f0_V_S_PPI(struct S_PPI p0,  void (*cb)(struct S_PPI)) ;
+EXPORT void f0_V_S_PPF(struct S_PPF p0,  void (*cb)(struct S_PPF)) ;
+EXPORT void f0_V_S_PPD(struct S_PPD p0,  void (*cb)(struct S_PPD)) ;
+EXPORT void f0_V_S_PPP(struct S_PPP p0,  void (*cb)(struct S_PPP)) ;
+EXPORT void f0_V_II_(int p0, int p1,  void (*cb)(int, int)) ;
+EXPORT void f0_V_IF_(int p0, float p1,  void (*cb)(int, float)) ;
+EXPORT void f0_V_ID_(int p0, double p1,  void (*cb)(int, double)) ;
+EXPORT void f0_V_IP_(int p0, void* p1,  void (*cb)(int, void*)) ;
+EXPORT void f0_V_IS_I(int p0, struct S_I p1,  void (*cb)(int, struct S_I)) ;
+EXPORT void f0_V_IS_F(int p0, struct S_F p1,  void (*cb)(int, struct S_F)) ;
+EXPORT void f0_V_IS_D(int p0, struct S_D p1,  void (*cb)(int, struct S_D)) ;
+EXPORT void f0_V_IS_P(int p0, struct S_P p1,  void (*cb)(int, struct S_P)) ;
+EXPORT void f0_V_IS_II(int p0, struct S_II p1,  void (*cb)(int, struct S_II)) ;
+EXPORT void f0_V_IS_IF(int p0, struct S_IF p1,  void (*cb)(int, struct S_IF)) ;
+EXPORT void f0_V_IS_ID(int p0, struct S_ID p1,  void (*cb)(int, struct S_ID)) ;
+EXPORT void f0_V_IS_IP(int p0, struct S_IP p1,  void (*cb)(int, struct S_IP)) ;
+EXPORT void f0_V_IS_FI(int p0, struct S_FI p1,  void (*cb)(int, struct S_FI)) ;
+EXPORT void f0_V_IS_FF(int p0, struct S_FF p1,  void (*cb)(int, struct S_FF)) ;
+EXPORT void f0_V_IS_FD(int p0, struct S_FD p1,  void (*cb)(int, struct S_FD)) ;
+EXPORT void f0_V_IS_FP(int p0, struct S_FP p1,  void (*cb)(int, struct S_FP)) ;
+EXPORT void f0_V_IS_DI(int p0, struct S_DI p1,  void (*cb)(int, struct S_DI)) ;
+EXPORT void f0_V_IS_DF(int p0, struct S_DF p1,  void (*cb)(int, struct S_DF)) ;
+EXPORT void f0_V_IS_DD(int p0, struct S_DD p1,  void (*cb)(int, struct S_DD)) ;
+EXPORT void f0_V_IS_DP(int p0, struct S_DP p1,  void (*cb)(int, struct S_DP)) ;
+EXPORT void f0_V_IS_PI(int p0, struct S_PI p1,  void (*cb)(int, struct S_PI)) ;
+EXPORT void f0_V_IS_PF(int p0, struct S_PF p1,  void (*cb)(int, struct S_PF)) ;
+EXPORT void f0_V_IS_PD(int p0, struct S_PD p1,  void (*cb)(int, struct S_PD)) ;
+EXPORT void f0_V_IS_PP(int p0, struct S_PP p1,  void (*cb)(int, struct S_PP)) ;
+EXPORT void f0_V_IS_III(int p0, struct S_III p1,  void (*cb)(int, struct S_III)) ;
+EXPORT void f0_V_IS_IIF(int p0, struct S_IIF p1,  void (*cb)(int, struct S_IIF)) ;
+EXPORT void f0_V_IS_IID(int p0, struct S_IID p1,  void (*cb)(int, struct S_IID)) ;
+EXPORT void f0_V_IS_IIP(int p0, struct S_IIP p1,  void (*cb)(int, struct S_IIP)) ;
+EXPORT void f0_V_IS_IFI(int p0, struct S_IFI p1,  void (*cb)(int, struct S_IFI)) ;
+EXPORT void f0_V_IS_IFF(int p0, struct S_IFF p1,  void (*cb)(int, struct S_IFF)) ;
+EXPORT void f0_V_IS_IFD(int p0, struct S_IFD p1,  void (*cb)(int, struct S_IFD)) ;
+EXPORT void f0_V_IS_IFP(int p0, struct S_IFP p1,  void (*cb)(int, struct S_IFP)) ;
+EXPORT void f0_V_IS_IDI(int p0, struct S_IDI p1,  void (*cb)(int, struct S_IDI)) ;
+EXPORT void f0_V_IS_IDF(int p0, struct S_IDF p1,  void (*cb)(int, struct S_IDF)) ;
+EXPORT void f0_V_IS_IDD(int p0, struct S_IDD p1,  void (*cb)(int, struct S_IDD)) ;
+EXPORT void f0_V_IS_IDP(int p0, struct S_IDP p1,  void (*cb)(int, struct S_IDP)) ;
+EXPORT void f0_V_IS_IPI(int p0, struct S_IPI p1,  void (*cb)(int, struct S_IPI)) ;
+EXPORT void f0_V_IS_IPF(int p0, struct S_IPF p1,  void (*cb)(int, struct S_IPF)) ;
+EXPORT void f0_V_IS_IPD(int p0, struct S_IPD p1,  void (*cb)(int, struct S_IPD)) ;
+EXPORT void f0_V_IS_IPP(int p0, struct S_IPP p1,  void (*cb)(int, struct S_IPP)) ;
+EXPORT void f0_V_IS_FII(int p0, struct S_FII p1,  void (*cb)(int, struct S_FII)) ;
+EXPORT void f0_V_IS_FIF(int p0, struct S_FIF p1,  void (*cb)(int, struct S_FIF)) ;
+EXPORT void f0_V_IS_FID(int p0, struct S_FID p1,  void (*cb)(int, struct S_FID)) ;
+EXPORT void f0_V_IS_FIP(int p0, struct S_FIP p1,  void (*cb)(int, struct S_FIP)) ;
+EXPORT void f0_V_IS_FFI(int p0, struct S_FFI p1,  void (*cb)(int, struct S_FFI)) ;
+EXPORT void f0_V_IS_FFF(int p0, struct S_FFF p1,  void (*cb)(int, struct S_FFF)) ;
+EXPORT void f0_V_IS_FFD(int p0, struct S_FFD p1,  void (*cb)(int, struct S_FFD)) ;
+EXPORT void f0_V_IS_FFP(int p0, struct S_FFP p1,  void (*cb)(int, struct S_FFP)) ;
+EXPORT void f0_V_IS_FDI(int p0, struct S_FDI p1,  void (*cb)(int, struct S_FDI)) ;
+EXPORT void f0_V_IS_FDF(int p0, struct S_FDF p1,  void (*cb)(int, struct S_FDF)) ;
+EXPORT void f0_V_IS_FDD(int p0, struct S_FDD p1,  void (*cb)(int, struct S_FDD)) ;
+EXPORT void f0_V_IS_FDP(int p0, struct S_FDP p1,  void (*cb)(int, struct S_FDP)) ;
+EXPORT void f0_V_IS_FPI(int p0, struct S_FPI p1,  void (*cb)(int, struct S_FPI)) ;
+EXPORT void f0_V_IS_FPF(int p0, struct S_FPF p1,  void (*cb)(int, struct S_FPF)) ;
+EXPORT void f0_V_IS_FPD(int p0, struct S_FPD p1,  void (*cb)(int, struct S_FPD)) ;
+EXPORT void f0_V_IS_FPP(int p0, struct S_FPP p1,  void (*cb)(int, struct S_FPP)) ;
+EXPORT void f0_V_IS_DII(int p0, struct S_DII p1,  void (*cb)(int, struct S_DII)) ;
+EXPORT void f0_V_IS_DIF(int p0, struct S_DIF p1,  void (*cb)(int, struct S_DIF)) ;
+EXPORT void f0_V_IS_DID(int p0, struct S_DID p1,  void (*cb)(int, struct S_DID)) ;
+EXPORT void f0_V_IS_DIP(int p0, struct S_DIP p1,  void (*cb)(int, struct S_DIP)) ;
+EXPORT void f0_V_IS_DFI(int p0, struct S_DFI p1,  void (*cb)(int, struct S_DFI)) ;
+EXPORT void f0_V_IS_DFF(int p0, struct S_DFF p1,  void (*cb)(int, struct S_DFF)) ;
+EXPORT void f0_V_IS_DFD(int p0, struct S_DFD p1,  void (*cb)(int, struct S_DFD)) ;
+EXPORT void f0_V_IS_DFP(int p0, struct S_DFP p1,  void (*cb)(int, struct S_DFP)) ;
+EXPORT void f0_V_IS_DDI(int p0, struct S_DDI p1,  void (*cb)(int, struct S_DDI)) ;
+EXPORT void f0_V_IS_DDF(int p0, struct S_DDF p1,  void (*cb)(int, struct S_DDF)) ;
+EXPORT void f0_V_IS_DDD(int p0, struct S_DDD p1,  void (*cb)(int, struct S_DDD)) ;
+EXPORT void f0_V_IS_DDP(int p0, struct S_DDP p1,  void (*cb)(int, struct S_DDP)) ;
+EXPORT void f0_V_IS_DPI(int p0, struct S_DPI p1,  void (*cb)(int, struct S_DPI)) ;
+EXPORT void f0_V_IS_DPF(int p0, struct S_DPF p1,  void (*cb)(int, struct S_DPF)) ;
+EXPORT void f0_V_IS_DPD(int p0, struct S_DPD p1,  void (*cb)(int, struct S_DPD)) ;
+EXPORT void f0_V_IS_DPP(int p0, struct S_DPP p1,  void (*cb)(int, struct S_DPP)) ;
+EXPORT void f0_V_IS_PII(int p0, struct S_PII p1,  void (*cb)(int, struct S_PII)) ;
+EXPORT void f0_V_IS_PIF(int p0, struct S_PIF p1,  void (*cb)(int, struct S_PIF)) ;
+EXPORT void f0_V_IS_PID(int p0, struct S_PID p1,  void (*cb)(int, struct S_PID)) ;
+EXPORT void f0_V_IS_PIP(int p0, struct S_PIP p1,  void (*cb)(int, struct S_PIP)) ;
+EXPORT void f0_V_IS_PFI(int p0, struct S_PFI p1,  void (*cb)(int, struct S_PFI)) ;
+EXPORT void f0_V_IS_PFF(int p0, struct S_PFF p1,  void (*cb)(int, struct S_PFF)) ;
+EXPORT void f0_V_IS_PFD(int p0, struct S_PFD p1,  void (*cb)(int, struct S_PFD)) ;
+EXPORT void f0_V_IS_PFP(int p0, struct S_PFP p1,  void (*cb)(int, struct S_PFP)) ;
+EXPORT void f0_V_IS_PDI(int p0, struct S_PDI p1,  void (*cb)(int, struct S_PDI)) ;
+EXPORT void f0_V_IS_PDF(int p0, struct S_PDF p1,  void (*cb)(int, struct S_PDF)) ;
+EXPORT void f0_V_IS_PDD(int p0, struct S_PDD p1,  void (*cb)(int, struct S_PDD)) ;
+EXPORT void f0_V_IS_PDP(int p0, struct S_PDP p1,  void (*cb)(int, struct S_PDP)) ;
+EXPORT void f0_V_IS_PPI(int p0, struct S_PPI p1,  void (*cb)(int, struct S_PPI)) ;
+EXPORT void f0_V_IS_PPF(int p0, struct S_PPF p1,  void (*cb)(int, struct S_PPF)) ;
+EXPORT void f0_V_IS_PPD(int p0, struct S_PPD p1,  void (*cb)(int, struct S_PPD)) ;
+EXPORT void f0_V_IS_PPP(int p0, struct S_PPP p1,  void (*cb)(int, struct S_PPP)) ;
+EXPORT void f0_V_FI_(float p0, int p1,  void (*cb)(float, int)) ;
+EXPORT void f0_V_FF_(float p0, float p1,  void (*cb)(float, float)) ;
+EXPORT void f0_V_FD_(float p0, double p1,  void (*cb)(float, double)) ;
+EXPORT void f0_V_FP_(float p0, void* p1,  void (*cb)(float, void*)) ;
+EXPORT void f0_V_FS_I(float p0, struct S_I p1,  void (*cb)(float, struct S_I)) ;
+EXPORT void f0_V_FS_F(float p0, struct S_F p1,  void (*cb)(float, struct S_F)) ;
+EXPORT void f0_V_FS_D(float p0, struct S_D p1,  void (*cb)(float, struct S_D)) ;
+EXPORT void f0_V_FS_P(float p0, struct S_P p1,  void (*cb)(float, struct S_P)) ;
+EXPORT void f0_V_FS_II(float p0, struct S_II p1,  void (*cb)(float, struct S_II)) ;
+EXPORT void f0_V_FS_IF(float p0, struct S_IF p1,  void (*cb)(float, struct S_IF)) ;
+EXPORT void f0_V_FS_ID(float p0, struct S_ID p1,  void (*cb)(float, struct S_ID)) ;
+EXPORT void f0_V_FS_IP(float p0, struct S_IP p1,  void (*cb)(float, struct S_IP)) ;
+EXPORT void f0_V_FS_FI(float p0, struct S_FI p1,  void (*cb)(float, struct S_FI)) ;
+EXPORT void f0_V_FS_FF(float p0, struct S_FF p1,  void (*cb)(float, struct S_FF)) ;
+EXPORT void f0_V_FS_FD(float p0, struct S_FD p1,  void (*cb)(float, struct S_FD)) ;
+EXPORT void f0_V_FS_FP(float p0, struct S_FP p1,  void (*cb)(float, struct S_FP)) ;
+EXPORT void f0_V_FS_DI(float p0, struct S_DI p1,  void (*cb)(float, struct S_DI)) ;
+EXPORT void f0_V_FS_DF(float p0, struct S_DF p1,  void (*cb)(float, struct S_DF)) ;
+EXPORT void f0_V_FS_DD(float p0, struct S_DD p1,  void (*cb)(float, struct S_DD)) ;
+EXPORT void f0_V_FS_DP(float p0, struct S_DP p1,  void (*cb)(float, struct S_DP)) ;
+EXPORT void f0_V_FS_PI(float p0, struct S_PI p1,  void (*cb)(float, struct S_PI)) ;
+EXPORT void f0_V_FS_PF(float p0, struct S_PF p1,  void (*cb)(float, struct S_PF)) ;
+EXPORT void f0_V_FS_PD(float p0, struct S_PD p1,  void (*cb)(float, struct S_PD)) ;
+EXPORT void f0_V_FS_PP(float p0, struct S_PP p1,  void (*cb)(float, struct S_PP)) ;
+EXPORT void f0_V_FS_III(float p0, struct S_III p1,  void (*cb)(float, struct S_III)) ;
+EXPORT void f0_V_FS_IIF(float p0, struct S_IIF p1,  void (*cb)(float, struct S_IIF)) ;
+EXPORT void f0_V_FS_IID(float p0, struct S_IID p1,  void (*cb)(float, struct S_IID)) ;
+EXPORT void f0_V_FS_IIP(float p0, struct S_IIP p1,  void (*cb)(float, struct S_IIP)) ;
+EXPORT void f0_V_FS_IFI(float p0, struct S_IFI p1,  void (*cb)(float, struct S_IFI)) ;
+EXPORT void f0_V_FS_IFF(float p0, struct S_IFF p1,  void (*cb)(float, struct S_IFF)) ;
+EXPORT void f0_V_FS_IFD(float p0, struct S_IFD p1,  void (*cb)(float, struct S_IFD)) ;
+EXPORT void f0_V_FS_IFP(float p0, struct S_IFP p1,  void (*cb)(float, struct S_IFP)) ;
+EXPORT void f0_V_FS_IDI(float p0, struct S_IDI p1,  void (*cb)(float, struct S_IDI)) ;
+EXPORT void f0_V_FS_IDF(float p0, struct S_IDF p1,  void (*cb)(float, struct S_IDF)) ;
+EXPORT void f0_V_FS_IDD(float p0, struct S_IDD p1,  void (*cb)(float, struct S_IDD)) ;
+EXPORT void f0_V_FS_IDP(float p0, struct S_IDP p1,  void (*cb)(float, struct S_IDP)) ;
+EXPORT void f0_V_FS_IPI(float p0, struct S_IPI p1,  void (*cb)(float, struct S_IPI)) ;
+EXPORT void f0_V_FS_IPF(float p0, struct S_IPF p1,  void (*cb)(float, struct S_IPF)) ;
+EXPORT void f0_V_FS_IPD(float p0, struct S_IPD p1,  void (*cb)(float, struct S_IPD)) ;
+EXPORT void f0_V_FS_IPP(float p0, struct S_IPP p1,  void (*cb)(float, struct S_IPP)) ;
+EXPORT void f0_V_FS_FII(float p0, struct S_FII p1,  void (*cb)(float, struct S_FII)) ;
+EXPORT void f0_V_FS_FIF(float p0, struct S_FIF p1,  void (*cb)(float, struct S_FIF)) ;
+EXPORT void f0_V_FS_FID(float p0, struct S_FID p1,  void (*cb)(float, struct S_FID)) ;
+EXPORT void f0_V_FS_FIP(float p0, struct S_FIP p1,  void (*cb)(float, struct S_FIP)) ;
+EXPORT void f0_V_FS_FFI(float p0, struct S_FFI p1,  void (*cb)(float, struct S_FFI)) ;
+EXPORT void f0_V_FS_FFF(float p0, struct S_FFF p1,  void (*cb)(float, struct S_FFF)) ;
+EXPORT void f0_V_FS_FFD(float p0, struct S_FFD p1,  void (*cb)(float, struct S_FFD)) ;
+EXPORT void f0_V_FS_FFP(float p0, struct S_FFP p1,  void (*cb)(float, struct S_FFP)) ;
+EXPORT void f0_V_FS_FDI(float p0, struct S_FDI p1,  void (*cb)(float, struct S_FDI)) ;
+EXPORT void f0_V_FS_FDF(float p0, struct S_FDF p1,  void (*cb)(float, struct S_FDF)) ;
+EXPORT void f0_V_FS_FDD(float p0, struct S_FDD p1,  void (*cb)(float, struct S_FDD)) ;
+EXPORT void f0_V_FS_FDP(float p0, struct S_FDP p1,  void (*cb)(float, struct S_FDP)) ;
+EXPORT void f0_V_FS_FPI(float p0, struct S_FPI p1,  void (*cb)(float, struct S_FPI)) ;
+EXPORT void f0_V_FS_FPF(float p0, struct S_FPF p1,  void (*cb)(float, struct S_FPF)) ;
+EXPORT void f0_V_FS_FPD(float p0, struct S_FPD p1,  void (*cb)(float, struct S_FPD)) ;
+EXPORT void f0_V_FS_FPP(float p0, struct S_FPP p1,  void (*cb)(float, struct S_FPP)) ;
+EXPORT void f0_V_FS_DII(float p0, struct S_DII p1,  void (*cb)(float, struct S_DII)) ;
+EXPORT void f0_V_FS_DIF(float p0, struct S_DIF p1,  void (*cb)(float, struct S_DIF)) ;
+EXPORT void f0_V_FS_DID(float p0, struct S_DID p1,  void (*cb)(float, struct S_DID)) ;
+EXPORT void f0_V_FS_DIP(float p0, struct S_DIP p1,  void (*cb)(float, struct S_DIP)) ;
+EXPORT void f0_V_FS_DFI(float p0, struct S_DFI p1,  void (*cb)(float, struct S_DFI)) ;
+EXPORT void f0_V_FS_DFF(float p0, struct S_DFF p1,  void (*cb)(float, struct S_DFF)) ;
+EXPORT void f0_V_FS_DFD(float p0, struct S_DFD p1,  void (*cb)(float, struct S_DFD)) ;
+EXPORT void f0_V_FS_DFP(float p0, struct S_DFP p1,  void (*cb)(float, struct S_DFP)) ;
+EXPORT void f0_V_FS_DDI(float p0, struct S_DDI p1,  void (*cb)(float, struct S_DDI)) ;
+EXPORT void f0_V_FS_DDF(float p0, struct S_DDF p1,  void (*cb)(float, struct S_DDF)) ;
+EXPORT void f0_V_FS_DDD(float p0, struct S_DDD p1,  void (*cb)(float, struct S_DDD)) ;
+EXPORT void f0_V_FS_DDP(float p0, struct S_DDP p1,  void (*cb)(float, struct S_DDP)) ;
+EXPORT void f0_V_FS_DPI(float p0, struct S_DPI p1,  void (*cb)(float, struct S_DPI)) ;
+EXPORT void f0_V_FS_DPF(float p0, struct S_DPF p1,  void (*cb)(float, struct S_DPF)) ;
+EXPORT void f0_V_FS_DPD(float p0, struct S_DPD p1,  void (*cb)(float, struct S_DPD)) ;
+EXPORT void f0_V_FS_DPP(float p0, struct S_DPP p1,  void (*cb)(float, struct S_DPP)) ;
+EXPORT void f0_V_FS_PII(float p0, struct S_PII p1,  void (*cb)(float, struct S_PII)) ;
+EXPORT void f0_V_FS_PIF(float p0, struct S_PIF p1,  void (*cb)(float, struct S_PIF)) ;
+EXPORT void f0_V_FS_PID(float p0, struct S_PID p1,  void (*cb)(float, struct S_PID)) ;
+EXPORT void f0_V_FS_PIP(float p0, struct S_PIP p1,  void (*cb)(float, struct S_PIP)) ;
+EXPORT void f0_V_FS_PFI(float p0, struct S_PFI p1,  void (*cb)(float, struct S_PFI)) ;
+EXPORT void f0_V_FS_PFF(float p0, struct S_PFF p1,  void (*cb)(float, struct S_PFF)) ;
+EXPORT void f0_V_FS_PFD(float p0, struct S_PFD p1,  void (*cb)(float, struct S_PFD)) ;
+EXPORT void f0_V_FS_PFP(float p0, struct S_PFP p1,  void (*cb)(float, struct S_PFP)) ;
+EXPORT void f0_V_FS_PDI(float p0, struct S_PDI p1,  void (*cb)(float, struct S_PDI)) ;
+EXPORT void f0_V_FS_PDF(float p0, struct S_PDF p1,  void (*cb)(float, struct S_PDF)) ;
+EXPORT void f0_V_FS_PDD(float p0, struct S_PDD p1,  void (*cb)(float, struct S_PDD)) ;
+EXPORT void f0_V_FS_PDP(float p0, struct S_PDP p1,  void (*cb)(float, struct S_PDP)) ;
+EXPORT void f0_V_FS_PPI(float p0, struct S_PPI p1,  void (*cb)(float, struct S_PPI)) ;
+EXPORT void f0_V_FS_PPF(float p0, struct S_PPF p1,  void (*cb)(float, struct S_PPF)) ;
+EXPORT void f0_V_FS_PPD(float p0, struct S_PPD p1,  void (*cb)(float, struct S_PPD)) ;
+EXPORT void f0_V_FS_PPP(float p0, struct S_PPP p1,  void (*cb)(float, struct S_PPP)) ;
+EXPORT void f0_V_DI_(double p0, int p1,  void (*cb)(double, int)) ;
+EXPORT void f0_V_DF_(double p0, float p1,  void (*cb)(double, float)) ;
+EXPORT void f0_V_DD_(double p0, double p1,  void (*cb)(double, double)) ;
+EXPORT void f0_V_DP_(double p0, void* p1,  void (*cb)(double, void*)) ;
+EXPORT void f0_V_DS_I(double p0, struct S_I p1,  void (*cb)(double, struct S_I)) ;
+EXPORT void f0_V_DS_F(double p0, struct S_F p1,  void (*cb)(double, struct S_F)) ;
+EXPORT void f0_V_DS_D(double p0, struct S_D p1,  void (*cb)(double, struct S_D)) ;
+EXPORT void f0_V_DS_P(double p0, struct S_P p1,  void (*cb)(double, struct S_P)) ;
+EXPORT void f0_V_DS_II(double p0, struct S_II p1,  void (*cb)(double, struct S_II)) ;
+EXPORT void f0_V_DS_IF(double p0, struct S_IF p1,  void (*cb)(double, struct S_IF)) ;
+EXPORT void f0_V_DS_ID(double p0, struct S_ID p1,  void (*cb)(double, struct S_ID)) ;
+EXPORT void f0_V_DS_IP(double p0, struct S_IP p1,  void (*cb)(double, struct S_IP)) ;
+EXPORT void f0_V_DS_FI(double p0, struct S_FI p1,  void (*cb)(double, struct S_FI)) ;
+EXPORT void f0_V_DS_FF(double p0, struct S_FF p1,  void (*cb)(double, struct S_FF)) ;
+EXPORT void f0_V_DS_FD(double p0, struct S_FD p1,  void (*cb)(double, struct S_FD)) ;
+EXPORT void f0_V_DS_FP(double p0, struct S_FP p1,  void (*cb)(double, struct S_FP)) ;
+EXPORT void f0_V_DS_DI(double p0, struct S_DI p1,  void (*cb)(double, struct S_DI)) ;
+EXPORT void f0_V_DS_DF(double p0, struct S_DF p1,  void (*cb)(double, struct S_DF)) ;
+EXPORT void f0_V_DS_DD(double p0, struct S_DD p1,  void (*cb)(double, struct S_DD)) ;
+EXPORT void f0_V_DS_DP(double p0, struct S_DP p1,  void (*cb)(double, struct S_DP)) ;
+EXPORT void f0_V_DS_PI(double p0, struct S_PI p1,  void (*cb)(double, struct S_PI)) ;
+EXPORT void f0_V_DS_PF(double p0, struct S_PF p1,  void (*cb)(double, struct S_PF)) ;
+EXPORT void f0_V_DS_PD(double p0, struct S_PD p1,  void (*cb)(double, struct S_PD)) ;
+EXPORT void f0_V_DS_PP(double p0, struct S_PP p1,  void (*cb)(double, struct S_PP)) ;
+EXPORT void f0_V_DS_III(double p0, struct S_III p1,  void (*cb)(double, struct S_III)) ;
+EXPORT void f0_V_DS_IIF(double p0, struct S_IIF p1,  void (*cb)(double, struct S_IIF)) ;
+EXPORT void f0_V_DS_IID(double p0, struct S_IID p1,  void (*cb)(double, struct S_IID)) ;
+EXPORT void f0_V_DS_IIP(double p0, struct S_IIP p1,  void (*cb)(double, struct S_IIP)) ;
+EXPORT void f0_V_DS_IFI(double p0, struct S_IFI p1,  void (*cb)(double, struct S_IFI)) ;
+EXPORT void f0_V_DS_IFF(double p0, struct S_IFF p1,  void (*cb)(double, struct S_IFF)) ;
+EXPORT void f0_V_DS_IFD(double p0, struct S_IFD p1,  void (*cb)(double, struct S_IFD)) ;
+EXPORT void f0_V_DS_IFP(double p0, struct S_IFP p1,  void (*cb)(double, struct S_IFP)) ;
+EXPORT void f0_V_DS_IDI(double p0, struct S_IDI p1,  void (*cb)(double, struct S_IDI)) ;
+EXPORT void f0_V_DS_IDF(double p0, struct S_IDF p1,  void (*cb)(double, struct S_IDF)) ;
+EXPORT void f0_V_DS_IDD(double p0, struct S_IDD p1,  void (*cb)(double, struct S_IDD)) ;
+EXPORT void f0_V_DS_IDP(double p0, struct S_IDP p1,  void (*cb)(double, struct S_IDP)) ;
+EXPORT void f0_V_DS_IPI(double p0, struct S_IPI p1,  void (*cb)(double, struct S_IPI)) ;
+EXPORT void f0_V_DS_IPF(double p0, struct S_IPF p1,  void (*cb)(double, struct S_IPF)) ;
+EXPORT void f0_V_DS_IPD(double p0, struct S_IPD p1,  void (*cb)(double, struct S_IPD)) ;
+EXPORT void f0_V_DS_IPP(double p0, struct S_IPP p1,  void (*cb)(double, struct S_IPP)) ;
+EXPORT void f0_V_DS_FII(double p0, struct S_FII p1,  void (*cb)(double, struct S_FII)) ;
+EXPORT void f0_V_DS_FIF(double p0, struct S_FIF p1,  void (*cb)(double, struct S_FIF)) ;
+EXPORT void f0_V_DS_FID(double p0, struct S_FID p1,  void (*cb)(double, struct S_FID)) ;
+EXPORT void f0_V_DS_FIP(double p0, struct S_FIP p1,  void (*cb)(double, struct S_FIP)) ;
+EXPORT void f0_V_DS_FFI(double p0, struct S_FFI p1,  void (*cb)(double, struct S_FFI)) ;
+EXPORT void f0_V_DS_FFF(double p0, struct S_FFF p1,  void (*cb)(double, struct S_FFF)) ;
+EXPORT void f0_V_DS_FFD(double p0, struct S_FFD p1,  void (*cb)(double, struct S_FFD)) ;
+EXPORT void f0_V_DS_FFP(double p0, struct S_FFP p1,  void (*cb)(double, struct S_FFP)) ;
+EXPORT void f0_V_DS_FDI(double p0, struct S_FDI p1,  void (*cb)(double, struct S_FDI)) ;
+EXPORT void f0_V_DS_FDF(double p0, struct S_FDF p1,  void (*cb)(double, struct S_FDF)) ;
+EXPORT void f0_V_DS_FDD(double p0, struct S_FDD p1,  void (*cb)(double, struct S_FDD)) ;
+EXPORT void f0_V_DS_FDP(double p0, struct S_FDP p1,  void (*cb)(double, struct S_FDP)) ;
+EXPORT void f0_V_DS_FPI(double p0, struct S_FPI p1,  void (*cb)(double, struct S_FPI)) ;
+EXPORT void f0_V_DS_FPF(double p0, struct S_FPF p1,  void (*cb)(double, struct S_FPF)) ;
+EXPORT void f0_V_DS_FPD(double p0, struct S_FPD p1,  void (*cb)(double, struct S_FPD)) ;
+EXPORT void f0_V_DS_FPP(double p0, struct S_FPP p1,  void (*cb)(double, struct S_FPP)) ;
+EXPORT void f0_V_DS_DII(double p0, struct S_DII p1,  void (*cb)(double, struct S_DII)) ;
+EXPORT void f0_V_DS_DIF(double p0, struct S_DIF p1,  void (*cb)(double, struct S_DIF)) ;
+EXPORT void f0_V_DS_DID(double p0, struct S_DID p1,  void (*cb)(double, struct S_DID)) ;
+EXPORT void f0_V_DS_DIP(double p0, struct S_DIP p1,  void (*cb)(double, struct S_DIP)) ;
+EXPORT void f0_V_DS_DFI(double p0, struct S_DFI p1,  void (*cb)(double, struct S_DFI)) ;
+EXPORT void f0_V_DS_DFF(double p0, struct S_DFF p1,  void (*cb)(double, struct S_DFF)) ;
+EXPORT void f0_V_DS_DFD(double p0, struct S_DFD p1,  void (*cb)(double, struct S_DFD)) ;
+EXPORT void f0_V_DS_DFP(double p0, struct S_DFP p1,  void (*cb)(double, struct S_DFP)) ;
+EXPORT void f0_V_DS_DDI(double p0, struct S_DDI p1,  void (*cb)(double, struct S_DDI)) ;
+EXPORT void f0_V_DS_DDF(double p0, struct S_DDF p1,  void (*cb)(double, struct S_DDF)) ;
+EXPORT void f0_V_DS_DDD(double p0, struct S_DDD p1,  void (*cb)(double, struct S_DDD)) ;
+EXPORT void f0_V_DS_DDP(double p0, struct S_DDP p1,  void (*cb)(double, struct S_DDP)) ;
+EXPORT void f0_V_DS_DPI(double p0, struct S_DPI p1,  void (*cb)(double, struct S_DPI)) ;
+EXPORT void f0_V_DS_DPF(double p0, struct S_DPF p1,  void (*cb)(double, struct S_DPF)) ;
+EXPORT void f0_V_DS_DPD(double p0, struct S_DPD p1,  void (*cb)(double, struct S_DPD)) ;
+EXPORT void f0_V_DS_DPP(double p0, struct S_DPP p1,  void (*cb)(double, struct S_DPP)) ;
+EXPORT void f0_V_DS_PII(double p0, struct S_PII p1,  void (*cb)(double, struct S_PII)) ;
+EXPORT void f0_V_DS_PIF(double p0, struct S_PIF p1,  void (*cb)(double, struct S_PIF)) ;
+EXPORT void f0_V_DS_PID(double p0, struct S_PID p1,  void (*cb)(double, struct S_PID)) ;
+EXPORT void f0_V_DS_PIP(double p0, struct S_PIP p1,  void (*cb)(double, struct S_PIP)) ;
+EXPORT void f0_V_DS_PFI(double p0, struct S_PFI p1,  void (*cb)(double, struct S_PFI)) ;
+EXPORT void f0_V_DS_PFF(double p0, struct S_PFF p1,  void (*cb)(double, struct S_PFF)) ;
+EXPORT void f0_V_DS_PFD(double p0, struct S_PFD p1,  void (*cb)(double, struct S_PFD)) ;
+EXPORT void f0_V_DS_PFP(double p0, struct S_PFP p1,  void (*cb)(double, struct S_PFP)) ;
+EXPORT void f0_V_DS_PDI(double p0, struct S_PDI p1,  void (*cb)(double, struct S_PDI)) ;
+EXPORT void f0_V_DS_PDF(double p0, struct S_PDF p1,  void (*cb)(double, struct S_PDF)) ;
+EXPORT void f0_V_DS_PDD(double p0, struct S_PDD p1,  void (*cb)(double, struct S_PDD)) ;
+EXPORT void f0_V_DS_PDP(double p0, struct S_PDP p1,  void (*cb)(double, struct S_PDP)) ;
+EXPORT void f0_V_DS_PPI(double p0, struct S_PPI p1,  void (*cb)(double, struct S_PPI)) ;
+EXPORT void f0_V_DS_PPF(double p0, struct S_PPF p1,  void (*cb)(double, struct S_PPF)) ;
+EXPORT void f0_V_DS_PPD(double p0, struct S_PPD p1,  void (*cb)(double, struct S_PPD)) ;
+EXPORT void f0_V_DS_PPP(double p0, struct S_PPP p1,  void (*cb)(double, struct S_PPP)) ;
+EXPORT void f0_V_PI_(void* p0, int p1,  void (*cb)(void*, int)) ;
+EXPORT void f0_V_PF_(void* p0, float p1,  void (*cb)(void*, float)) ;
+EXPORT void f0_V_PD_(void* p0, double p1,  void (*cb)(void*, double)) ;
+EXPORT void f0_V_PP_(void* p0, void* p1,  void (*cb)(void*, void*)) ;
+EXPORT void f0_V_PS_I(void* p0, struct S_I p1,  void (*cb)(void*, struct S_I)) ;
+EXPORT void f0_V_PS_F(void* p0, struct S_F p1,  void (*cb)(void*, struct S_F)) ;
+EXPORT void f0_V_PS_D(void* p0, struct S_D p1,  void (*cb)(void*, struct S_D)) ;
+EXPORT void f0_V_PS_P(void* p0, struct S_P p1,  void (*cb)(void*, struct S_P)) ;
+EXPORT void f0_V_PS_II(void* p0, struct S_II p1,  void (*cb)(void*, struct S_II)) ;
+EXPORT void f0_V_PS_IF(void* p0, struct S_IF p1,  void (*cb)(void*, struct S_IF)) ;
+EXPORT void f0_V_PS_ID(void* p0, struct S_ID p1,  void (*cb)(void*, struct S_ID)) ;
+EXPORT void f0_V_PS_IP(void* p0, struct S_IP p1,  void (*cb)(void*, struct S_IP)) ;
+EXPORT void f0_V_PS_FI(void* p0, struct S_FI p1,  void (*cb)(void*, struct S_FI)) ;
+EXPORT void f0_V_PS_FF(void* p0, struct S_FF p1,  void (*cb)(void*, struct S_FF)) ;
+EXPORT void f0_V_PS_FD(void* p0, struct S_FD p1,  void (*cb)(void*, struct S_FD)) ;
+EXPORT void f0_V_PS_FP(void* p0, struct S_FP p1,  void (*cb)(void*, struct S_FP)) ;
+EXPORT void f0_V_PS_DI(void* p0, struct S_DI p1,  void (*cb)(void*, struct S_DI)) ;
+EXPORT void f0_V_PS_DF(void* p0, struct S_DF p1,  void (*cb)(void*, struct S_DF)) ;
+EXPORT void f0_V_PS_DD(void* p0, struct S_DD p1,  void (*cb)(void*, struct S_DD)) ;
+EXPORT void f0_V_PS_DP(void* p0, struct S_DP p1,  void (*cb)(void*, struct S_DP)) ;
+EXPORT void f0_V_PS_PI(void* p0, struct S_PI p1,  void (*cb)(void*, struct S_PI)) ;
+EXPORT void f0_V_PS_PF(void* p0, struct S_PF p1,  void (*cb)(void*, struct S_PF)) ;
+EXPORT void f0_V_PS_PD(void* p0, struct S_PD p1,  void (*cb)(void*, struct S_PD)) ;
+EXPORT void f0_V_PS_PP(void* p0, struct S_PP p1,  void (*cb)(void*, struct S_PP)) ;
+EXPORT void f0_V_PS_III(void* p0, struct S_III p1,  void (*cb)(void*, struct S_III)) ;
+EXPORT void f0_V_PS_IIF(void* p0, struct S_IIF p1,  void (*cb)(void*, struct S_IIF)) ;
+EXPORT void f0_V_PS_IID(void* p0, struct S_IID p1,  void (*cb)(void*, struct S_IID)) ;
+EXPORT void f0_V_PS_IIP(void* p0, struct S_IIP p1,  void (*cb)(void*, struct S_IIP)) ;
+EXPORT void f0_V_PS_IFI(void* p0, struct S_IFI p1,  void (*cb)(void*, struct S_IFI)) ;
+EXPORT void f0_V_PS_IFF(void* p0, struct S_IFF p1,  void (*cb)(void*, struct S_IFF)) ;
+EXPORT void f0_V_PS_IFD(void* p0, struct S_IFD p1,  void (*cb)(void*, struct S_IFD)) ;
+EXPORT void f0_V_PS_IFP(void* p0, struct S_IFP p1,  void (*cb)(void*, struct S_IFP)) ;
+EXPORT void f0_V_PS_IDI(void* p0, struct S_IDI p1,  void (*cb)(void*, struct S_IDI)) ;
+EXPORT void f0_V_PS_IDF(void* p0, struct S_IDF p1,  void (*cb)(void*, struct S_IDF)) ;
+EXPORT void f0_V_PS_IDD(void* p0, struct S_IDD p1,  void (*cb)(void*, struct S_IDD)) ;
+EXPORT void f0_V_PS_IDP(void* p0, struct S_IDP p1,  void (*cb)(void*, struct S_IDP)) ;
+EXPORT void f0_V_PS_IPI(void* p0, struct S_IPI p1,  void (*cb)(void*, struct S_IPI)) ;
+EXPORT void f0_V_PS_IPF(void* p0, struct S_IPF p1,  void (*cb)(void*, struct S_IPF)) ;
+EXPORT void f0_V_PS_IPD(void* p0, struct S_IPD p1,  void (*cb)(void*, struct S_IPD)) ;
+EXPORT void f0_V_PS_IPP(void* p0, struct S_IPP p1,  void (*cb)(void*, struct S_IPP)) ;
+EXPORT void f0_V_PS_FII(void* p0, struct S_FII p1,  void (*cb)(void*, struct S_FII)) ;
+EXPORT void f0_V_PS_FIF(void* p0, struct S_FIF p1,  void (*cb)(void*, struct S_FIF)) ;
+EXPORT void f0_V_PS_FID(void* p0, struct S_FID p1,  void (*cb)(void*, struct S_FID)) ;
+EXPORT void f0_V_PS_FIP(void* p0, struct S_FIP p1,  void (*cb)(void*, struct S_FIP)) ;
+EXPORT void f0_V_PS_FFI(void* p0, struct S_FFI p1,  void (*cb)(void*, struct S_FFI)) ;
+EXPORT void f0_V_PS_FFF(void* p0, struct S_FFF p1,  void (*cb)(void*, struct S_FFF)) ;
+EXPORT void f0_V_PS_FFD(void* p0, struct S_FFD p1,  void (*cb)(void*, struct S_FFD)) ;
+EXPORT void f0_V_PS_FFP(void* p0, struct S_FFP p1,  void (*cb)(void*, struct S_FFP)) ;
+EXPORT void f0_V_PS_FDI(void* p0, struct S_FDI p1,  void (*cb)(void*, struct S_FDI)) ;
+EXPORT void f0_V_PS_FDF(void* p0, struct S_FDF p1,  void (*cb)(void*, struct S_FDF)) ;
+EXPORT void f0_V_PS_FDD(void* p0, struct S_FDD p1,  void (*cb)(void*, struct S_FDD)) ;
+EXPORT void f0_V_PS_FDP(void* p0, struct S_FDP p1,  void (*cb)(void*, struct S_FDP)) ;
+EXPORT void f0_V_PS_FPI(void* p0, struct S_FPI p1,  void (*cb)(void*, struct S_FPI)) ;
+EXPORT void f0_V_PS_FPF(void* p0, struct S_FPF p1,  void (*cb)(void*, struct S_FPF)) ;
+EXPORT void f0_V_PS_FPD(void* p0, struct S_FPD p1,  void (*cb)(void*, struct S_FPD)) ;
+EXPORT void f0_V_PS_FPP(void* p0, struct S_FPP p1,  void (*cb)(void*, struct S_FPP)) ;
+EXPORT void f0_V_PS_DII(void* p0, struct S_DII p1,  void (*cb)(void*, struct S_DII)) ;
+EXPORT void f0_V_PS_DIF(void* p0, struct S_DIF p1,  void (*cb)(void*, struct S_DIF)) ;
+EXPORT void f0_V_PS_DID(void* p0, struct S_DID p1,  void (*cb)(void*, struct S_DID)) ;
+EXPORT void f0_V_PS_DIP(void* p0, struct S_DIP p1,  void (*cb)(void*, struct S_DIP)) ;
+EXPORT void f0_V_PS_DFI(void* p0, struct S_DFI p1,  void (*cb)(void*, struct S_DFI)) ;
+EXPORT void f0_V_PS_DFF(void* p0, struct S_DFF p1,  void (*cb)(void*, struct S_DFF)) ;
+EXPORT void f0_V_PS_DFD(void* p0, struct S_DFD p1,  void (*cb)(void*, struct S_DFD)) ;
+EXPORT void f0_V_PS_DFP(void* p0, struct S_DFP p1,  void (*cb)(void*, struct S_DFP)) ;
+EXPORT void f0_V_PS_DDI(void* p0, struct S_DDI p1,  void (*cb)(void*, struct S_DDI)) ;
+EXPORT void f0_V_PS_DDF(void* p0, struct S_DDF p1,  void (*cb)(void*, struct S_DDF)) ;
+EXPORT void f0_V_PS_DDD(void* p0, struct S_DDD p1,  void (*cb)(void*, struct S_DDD)) ;
+EXPORT void f0_V_PS_DDP(void* p0, struct S_DDP p1,  void (*cb)(void*, struct S_DDP)) ;
+EXPORT void f0_V_PS_DPI(void* p0, struct S_DPI p1,  void (*cb)(void*, struct S_DPI)) ;
+EXPORT void f0_V_PS_DPF(void* p0, struct S_DPF p1,  void (*cb)(void*, struct S_DPF)) ;
+EXPORT void f0_V_PS_DPD(void* p0, struct S_DPD p1,  void (*cb)(void*, struct S_DPD)) ;
+EXPORT void f0_V_PS_DPP(void* p0, struct S_DPP p1,  void (*cb)(void*, struct S_DPP)) ;
+EXPORT void f0_V_PS_PII(void* p0, struct S_PII p1,  void (*cb)(void*, struct S_PII)) ;
+EXPORT void f0_V_PS_PIF(void* p0, struct S_PIF p1,  void (*cb)(void*, struct S_PIF)) ;
+EXPORT void f0_V_PS_PID(void* p0, struct S_PID p1,  void (*cb)(void*, struct S_PID)) ;
+EXPORT void f0_V_PS_PIP(void* p0, struct S_PIP p1,  void (*cb)(void*, struct S_PIP)) ;
+EXPORT void f0_V_PS_PFI(void* p0, struct S_PFI p1,  void (*cb)(void*, struct S_PFI)) ;
+EXPORT void f0_V_PS_PFF(void* p0, struct S_PFF p1,  void (*cb)(void*, struct S_PFF)) ;
+EXPORT void f0_V_PS_PFD(void* p0, struct S_PFD p1,  void (*cb)(void*, struct S_PFD)) ;
+EXPORT void f0_V_PS_PFP(void* p0, struct S_PFP p1,  void (*cb)(void*, struct S_PFP)) ;
+EXPORT void f0_V_PS_PDI(void* p0, struct S_PDI p1,  void (*cb)(void*, struct S_PDI)) ;
+EXPORT void f0_V_PS_PDF(void* p0, struct S_PDF p1,  void (*cb)(void*, struct S_PDF)) ;
+EXPORT void f0_V_PS_PDD(void* p0, struct S_PDD p1,  void (*cb)(void*, struct S_PDD)) ;
+EXPORT void f0_V_PS_PDP(void* p0, struct S_PDP p1,  void (*cb)(void*, struct S_PDP)) ;
+EXPORT void f0_V_PS_PPI(void* p0, struct S_PPI p1,  void (*cb)(void*, struct S_PPI)) ;
+EXPORT void f0_V_PS_PPF(void* p0, struct S_PPF p1,  void (*cb)(void*, struct S_PPF)) ;
+EXPORT void f0_V_PS_PPD(void* p0, struct S_PPD p1,  void (*cb)(void*, struct S_PPD)) ;
+EXPORT void f0_V_PS_PPP(void* p0, struct S_PPP p1,  void (*cb)(void*, struct S_PPP)) ;
+EXPORT void f0_V_SI_I(struct S_I p0, int p1,  void (*cb)(struct S_I, int)) ;
+EXPORT void f0_V_SI_F(struct S_F p0, int p1,  void (*cb)(struct S_F, int)) ;
+EXPORT void f0_V_SI_D(struct S_D p0, int p1,  void (*cb)(struct S_D, int)) ;
+EXPORT void f0_V_SI_P(struct S_P p0, int p1,  void (*cb)(struct S_P, int)) ;
+EXPORT void f0_V_SI_II(struct S_II p0, int p1,  void (*cb)(struct S_II, int)) ;
+EXPORT void f0_V_SI_IF(struct S_IF p0, int p1,  void (*cb)(struct S_IF, int)) ;
+EXPORT void f0_V_SI_ID(struct S_ID p0, int p1,  void (*cb)(struct S_ID, int)) ;
+EXPORT void f0_V_SI_IP(struct S_IP p0, int p1,  void (*cb)(struct S_IP, int)) ;
+EXPORT void f0_V_SI_FI(struct S_FI p0, int p1,  void (*cb)(struct S_FI, int)) ;
+EXPORT void f0_V_SI_FF(struct S_FF p0, int p1,  void (*cb)(struct S_FF, int)) ;
+EXPORT void f0_V_SI_FD(struct S_FD p0, int p1,  void (*cb)(struct S_FD, int)) ;
+EXPORT void f0_V_SI_FP(struct S_FP p0, int p1,  void (*cb)(struct S_FP, int)) ;
+EXPORT void f0_V_SI_DI(struct S_DI p0, int p1,  void (*cb)(struct S_DI, int)) ;
+EXPORT void f0_V_SI_DF(struct S_DF p0, int p1,  void (*cb)(struct S_DF, int)) ;
+EXPORT void f0_V_SI_DD(struct S_DD p0, int p1,  void (*cb)(struct S_DD, int)) ;
+EXPORT void f0_V_SI_DP(struct S_DP p0, int p1,  void (*cb)(struct S_DP, int)) ;
+EXPORT void f0_V_SI_PI(struct S_PI p0, int p1,  void (*cb)(struct S_PI, int)) ;
+EXPORT void f0_V_SI_PF(struct S_PF p0, int p1,  void (*cb)(struct S_PF, int)) ;
+EXPORT void f0_V_SI_PD(struct S_PD p0, int p1,  void (*cb)(struct S_PD, int)) ;
+EXPORT void f0_V_SI_PP(struct S_PP p0, int p1,  void (*cb)(struct S_PP, int)) ;
+EXPORT void f0_V_SI_III(struct S_III p0, int p1,  void (*cb)(struct S_III, int)) ;
+EXPORT void f0_V_SI_IIF(struct S_IIF p0, int p1,  void (*cb)(struct S_IIF, int)) ;
+EXPORT void f0_V_SI_IID(struct S_IID p0, int p1,  void (*cb)(struct S_IID, int)) ;
+EXPORT void f0_V_SI_IIP(struct S_IIP p0, int p1,  void (*cb)(struct S_IIP, int)) ;
+EXPORT void f0_V_SI_IFI(struct S_IFI p0, int p1,  void (*cb)(struct S_IFI, int)) ;
+EXPORT void f0_V_SI_IFF(struct S_IFF p0, int p1,  void (*cb)(struct S_IFF, int)) ;
+EXPORT void f0_V_SI_IFD(struct S_IFD p0, int p1,  void (*cb)(struct S_IFD, int)) ;
+EXPORT void f0_V_SI_IFP(struct S_IFP p0, int p1,  void (*cb)(struct S_IFP, int)) ;
+EXPORT void f0_V_SI_IDI(struct S_IDI p0, int p1,  void (*cb)(struct S_IDI, int)) ;
+EXPORT void f0_V_SI_IDF(struct S_IDF p0, int p1,  void (*cb)(struct S_IDF, int)) ;
+EXPORT void f0_V_SI_IDD(struct S_IDD p0, int p1,  void (*cb)(struct S_IDD, int)) ;
+EXPORT void f0_V_SI_IDP(struct S_IDP p0, int p1,  void (*cb)(struct S_IDP, int)) ;
+EXPORT void f0_V_SI_IPI(struct S_IPI p0, int p1,  void (*cb)(struct S_IPI, int)) ;
+EXPORT void f0_V_SI_IPF(struct S_IPF p0, int p1,  void (*cb)(struct S_IPF, int)) ;
+EXPORT void f0_V_SI_IPD(struct S_IPD p0, int p1,  void (*cb)(struct S_IPD, int)) ;
+EXPORT void f0_V_SI_IPP(struct S_IPP p0, int p1,  void (*cb)(struct S_IPP, int)) ;
+EXPORT void f0_V_SI_FII(struct S_FII p0, int p1,  void (*cb)(struct S_FII, int)) ;
+EXPORT void f0_V_SI_FIF(struct S_FIF p0, int p1,  void (*cb)(struct S_FIF, int)) ;
+EXPORT void f0_V_SI_FID(struct S_FID p0, int p1,  void (*cb)(struct S_FID, int)) ;
+EXPORT void f0_V_SI_FIP(struct S_FIP p0, int p1,  void (*cb)(struct S_FIP, int)) ;
+EXPORT void f0_V_SI_FFI(struct S_FFI p0, int p1,  void (*cb)(struct S_FFI, int)) ;
+EXPORT void f0_V_SI_FFF(struct S_FFF p0, int p1,  void (*cb)(struct S_FFF, int)) ;
+EXPORT void f0_V_SI_FFD(struct S_FFD p0, int p1,  void (*cb)(struct S_FFD, int)) ;
+EXPORT void f0_V_SI_FFP(struct S_FFP p0, int p1,  void (*cb)(struct S_FFP, int)) ;
+EXPORT void f0_V_SI_FDI(struct S_FDI p0, int p1,  void (*cb)(struct S_FDI, int)) ;
+EXPORT void f0_V_SI_FDF(struct S_FDF p0, int p1,  void (*cb)(struct S_FDF, int)) ;
+EXPORT void f0_V_SI_FDD(struct S_FDD p0, int p1,  void (*cb)(struct S_FDD, int)) ;
+EXPORT void f0_V_SI_FDP(struct S_FDP p0, int p1,  void (*cb)(struct S_FDP, int)) ;
+EXPORT void f0_V_SI_FPI(struct S_FPI p0, int p1,  void (*cb)(struct S_FPI, int)) ;
+EXPORT void f0_V_SI_FPF(struct S_FPF p0, int p1,  void (*cb)(struct S_FPF, int)) ;
+EXPORT void f0_V_SI_FPD(struct S_FPD p0, int p1,  void (*cb)(struct S_FPD, int)) ;
+EXPORT void f0_V_SI_FPP(struct S_FPP p0, int p1,  void (*cb)(struct S_FPP, int)) ;
+EXPORT void f0_V_SI_DII(struct S_DII p0, int p1,  void (*cb)(struct S_DII, int)) ;
+EXPORT void f0_V_SI_DIF(struct S_DIF p0, int p1,  void (*cb)(struct S_DIF, int)) ;
+EXPORT void f0_V_SI_DID(struct S_DID p0, int p1,  void (*cb)(struct S_DID, int)) ;
+EXPORT void f0_V_SI_DIP(struct S_DIP p0, int p1,  void (*cb)(struct S_DIP, int)) ;
+EXPORT void f0_V_SI_DFI(struct S_DFI p0, int p1,  void (*cb)(struct S_DFI, int)) ;
+EXPORT void f0_V_SI_DFF(struct S_DFF p0, int p1,  void (*cb)(struct S_DFF, int)) ;
+EXPORT void f0_V_SI_DFD(struct S_DFD p0, int p1,  void (*cb)(struct S_DFD, int)) ;
+EXPORT void f0_V_SI_DFP(struct S_DFP p0, int p1,  void (*cb)(struct S_DFP, int)) ;
+EXPORT void f0_V_SI_DDI(struct S_DDI p0, int p1,  void (*cb)(struct S_DDI, int)) ;
+EXPORT void f0_V_SI_DDF(struct S_DDF p0, int p1,  void (*cb)(struct S_DDF, int)) ;
+EXPORT void f0_V_SI_DDD(struct S_DDD p0, int p1,  void (*cb)(struct S_DDD, int)) ;
+EXPORT void f0_V_SI_DDP(struct S_DDP p0, int p1,  void (*cb)(struct S_DDP, int)) ;
+EXPORT void f0_V_SI_DPI(struct S_DPI p0, int p1,  void (*cb)(struct S_DPI, int)) ;
+EXPORT void f0_V_SI_DPF(struct S_DPF p0, int p1,  void (*cb)(struct S_DPF, int)) ;
+EXPORT void f0_V_SI_DPD(struct S_DPD p0, int p1,  void (*cb)(struct S_DPD, int)) ;
+EXPORT void f0_V_SI_DPP(struct S_DPP p0, int p1,  void (*cb)(struct S_DPP, int)) ;
+EXPORT void f0_V_SI_PII(struct S_PII p0, int p1,  void (*cb)(struct S_PII, int)) ;
+EXPORT void f0_V_SI_PIF(struct S_PIF p0, int p1,  void (*cb)(struct S_PIF, int)) ;
+EXPORT void f0_V_SI_PID(struct S_PID p0, int p1,  void (*cb)(struct S_PID, int)) ;
+EXPORT void f0_V_SI_PIP(struct S_PIP p0, int p1,  void (*cb)(struct S_PIP, int)) ;
+EXPORT void f0_V_SI_PFI(struct S_PFI p0, int p1,  void (*cb)(struct S_PFI, int)) ;
+EXPORT void f0_V_SI_PFF(struct S_PFF p0, int p1,  void (*cb)(struct S_PFF, int)) ;
+EXPORT void f0_V_SI_PFD(struct S_PFD p0, int p1,  void (*cb)(struct S_PFD, int)) ;
+EXPORT void f0_V_SI_PFP(struct S_PFP p0, int p1,  void (*cb)(struct S_PFP, int)) ;
+EXPORT void f0_V_SI_PDI(struct S_PDI p0, int p1,  void (*cb)(struct S_PDI, int)) ;
+EXPORT void f0_V_SI_PDF(struct S_PDF p0, int p1,  void (*cb)(struct S_PDF, int)) ;
+EXPORT void f0_V_SI_PDD(struct S_PDD p0, int p1,  void (*cb)(struct S_PDD, int)) ;
+EXPORT void f0_V_SI_PDP(struct S_PDP p0, int p1,  void (*cb)(struct S_PDP, int)) ;
+EXPORT void f0_V_SI_PPI(struct S_PPI p0, int p1,  void (*cb)(struct S_PPI, int)) ;
+EXPORT void f0_V_SI_PPF(struct S_PPF p0, int p1,  void (*cb)(struct S_PPF, int)) ;
+EXPORT void f0_V_SI_PPD(struct S_PPD p0, int p1,  void (*cb)(struct S_PPD, int)) ;
+EXPORT void f0_V_SI_PPP(struct S_PPP p0, int p1,  void (*cb)(struct S_PPP, int)) ;
+EXPORT void f0_V_SF_I(struct S_I p0, float p1,  void (*cb)(struct S_I, float)) ;
+EXPORT void f0_V_SF_F(struct S_F p0, float p1,  void (*cb)(struct S_F, float)) ;
+EXPORT void f0_V_SF_D(struct S_D p0, float p1,  void (*cb)(struct S_D, float)) ;
+EXPORT void f0_V_SF_P(struct S_P p0, float p1,  void (*cb)(struct S_P, float)) ;
+EXPORT void f0_V_SF_II(struct S_II p0, float p1,  void (*cb)(struct S_II, float)) ;
+EXPORT void f0_V_SF_IF(struct S_IF p0, float p1,  void (*cb)(struct S_IF, float)) ;
+EXPORT void f0_V_SF_ID(struct S_ID p0, float p1,  void (*cb)(struct S_ID, float)) ;
+EXPORT void f0_V_SF_IP(struct S_IP p0, float p1,  void (*cb)(struct S_IP, float)) ;
+EXPORT void f0_V_SF_FI(struct S_FI p0, float p1,  void (*cb)(struct S_FI, float)) ;
+EXPORT void f0_V_SF_FF(struct S_FF p0, float p1,  void (*cb)(struct S_FF, float)) ;
+EXPORT void f0_V_SF_FD(struct S_FD p0, float p1,  void (*cb)(struct S_FD, float)) ;
+EXPORT void f0_V_SF_FP(struct S_FP p0, float p1,  void (*cb)(struct S_FP, float)) ;
+EXPORT void f0_V_SF_DI(struct S_DI p0, float p1,  void (*cb)(struct S_DI, float)) ;
+EXPORT void f0_V_SF_DF(struct S_DF p0, float p1,  void (*cb)(struct S_DF, float)) ;
+EXPORT void f0_V_SF_DD(struct S_DD p0, float p1,  void (*cb)(struct S_DD, float)) ;
+EXPORT void f0_V_SF_DP(struct S_DP p0, float p1,  void (*cb)(struct S_DP, float)) ;
+EXPORT void f0_V_SF_PI(struct S_PI p0, float p1,  void (*cb)(struct S_PI, float)) ;
+EXPORT void f0_V_SF_PF(struct S_PF p0, float p1,  void (*cb)(struct S_PF, float)) ;
+EXPORT void f0_V_SF_PD(struct S_PD p0, float p1,  void (*cb)(struct S_PD, float)) ;
+EXPORT void f0_V_SF_PP(struct S_PP p0, float p1,  void (*cb)(struct S_PP, float)) ;
+EXPORT void f0_V_SF_III(struct S_III p0, float p1,  void (*cb)(struct S_III, float)) ;
+EXPORT void f0_V_SF_IIF(struct S_IIF p0, float p1,  void (*cb)(struct S_IIF, float)) ;
+EXPORT void f0_V_SF_IID(struct S_IID p0, float p1,  void (*cb)(struct S_IID, float)) ;
+EXPORT void f0_V_SF_IIP(struct S_IIP p0, float p1,  void (*cb)(struct S_IIP, float)) ;
+EXPORT void f0_V_SF_IFI(struct S_IFI p0, float p1,  void (*cb)(struct S_IFI, float)) ;
+EXPORT void f0_V_SF_IFF(struct S_IFF p0, float p1,  void (*cb)(struct S_IFF, float)) ;
+EXPORT void f0_V_SF_IFD(struct S_IFD p0, float p1,  void (*cb)(struct S_IFD, float)) ;
+EXPORT void f0_V_SF_IFP(struct S_IFP p0, float p1,  void (*cb)(struct S_IFP, float)) ;
+EXPORT void f0_V_SF_IDI(struct S_IDI p0, float p1,  void (*cb)(struct S_IDI, float)) ;
+EXPORT void f0_V_SF_IDF(struct S_IDF p0, float p1,  void (*cb)(struct S_IDF, float)) ;
+EXPORT void f0_V_SF_IDD(struct S_IDD p0, float p1,  void (*cb)(struct S_IDD, float)) ;
+EXPORT void f0_V_SF_IDP(struct S_IDP p0, float p1,  void (*cb)(struct S_IDP, float)) ;
+EXPORT void f0_V_SF_IPI(struct S_IPI p0, float p1,  void (*cb)(struct S_IPI, float)) ;
+EXPORT void f0_V_SF_IPF(struct S_IPF p0, float p1,  void (*cb)(struct S_IPF, float)) ;
+EXPORT void f0_V_SF_IPD(struct S_IPD p0, float p1,  void (*cb)(struct S_IPD, float)) ;
+EXPORT void f0_V_SF_IPP(struct S_IPP p0, float p1,  void (*cb)(struct S_IPP, float)) ;
+EXPORT void f0_V_SF_FII(struct S_FII p0, float p1,  void (*cb)(struct S_FII, float)) ;
+EXPORT void f0_V_SF_FIF(struct S_FIF p0, float p1,  void (*cb)(struct S_FIF, float)) ;
+EXPORT void f0_V_SF_FID(struct S_FID p0, float p1,  void (*cb)(struct S_FID, float)) ;
+EXPORT void f0_V_SF_FIP(struct S_FIP p0, float p1,  void (*cb)(struct S_FIP, float)) ;
+EXPORT void f0_V_SF_FFI(struct S_FFI p0, float p1,  void (*cb)(struct S_FFI, float)) ;
+EXPORT void f0_V_SF_FFF(struct S_FFF p0, float p1,  void (*cb)(struct S_FFF, float)) ;
+EXPORT void f0_V_SF_FFD(struct S_FFD p0, float p1,  void (*cb)(struct S_FFD, float)) ;
+EXPORT void f0_V_SF_FFP(struct S_FFP p0, float p1,  void (*cb)(struct S_FFP, float)) ;
+EXPORT void f0_V_SF_FDI(struct S_FDI p0, float p1,  void (*cb)(struct S_FDI, float)) ;
+EXPORT void f0_V_SF_FDF(struct S_FDF p0, float p1,  void (*cb)(struct S_FDF, float)) ;
+EXPORT void f0_V_SF_FDD(struct S_FDD p0, float p1,  void (*cb)(struct S_FDD, float)) ;
+EXPORT void f0_V_SF_FDP(struct S_FDP p0, float p1,  void (*cb)(struct S_FDP, float)) ;
+EXPORT void f0_V_SF_FPI(struct S_FPI p0, float p1,  void (*cb)(struct S_FPI, float)) ;
+EXPORT void f0_V_SF_FPF(struct S_FPF p0, float p1,  void (*cb)(struct S_FPF, float)) ;
+EXPORT void f0_V_SF_FPD(struct S_FPD p0, float p1,  void (*cb)(struct S_FPD, float)) ;
+EXPORT void f0_V_SF_FPP(struct S_FPP p0, float p1,  void (*cb)(struct S_FPP, float)) ;
+EXPORT void f0_V_SF_DII(struct S_DII p0, float p1,  void (*cb)(struct S_DII, float)) ;
+EXPORT void f0_V_SF_DIF(struct S_DIF p0, float p1,  void (*cb)(struct S_DIF, float)) ;
+EXPORT void f0_V_SF_DID(struct S_DID p0, float p1,  void (*cb)(struct S_DID, float)) ;
+EXPORT void f0_V_SF_DIP(struct S_DIP p0, float p1,  void (*cb)(struct S_DIP, float)) ;
+EXPORT void f0_V_SF_DFI(struct S_DFI p0, float p1,  void (*cb)(struct S_DFI, float)) ;
+EXPORT void f0_V_SF_DFF(struct S_DFF p0, float p1,  void (*cb)(struct S_DFF, float)) ;
+EXPORT void f0_V_SF_DFD(struct S_DFD p0, float p1,  void (*cb)(struct S_DFD, float)) ;
+EXPORT void f0_V_SF_DFP(struct S_DFP p0, float p1,  void (*cb)(struct S_DFP, float)) ;
+EXPORT void f0_V_SF_DDI(struct S_DDI p0, float p1,  void (*cb)(struct S_DDI, float)) ;
+EXPORT void f0_V_SF_DDF(struct S_DDF p0, float p1,  void (*cb)(struct S_DDF, float)) ;
+EXPORT void f0_V_SF_DDD(struct S_DDD p0, float p1,  void (*cb)(struct S_DDD, float)) ;
+EXPORT void f0_V_SF_DDP(struct S_DDP p0, float p1,  void (*cb)(struct S_DDP, float)) ;
+EXPORT void f0_V_SF_DPI(struct S_DPI p0, float p1,  void (*cb)(struct S_DPI, float)) ;
+EXPORT void f0_V_SF_DPF(struct S_DPF p0, float p1,  void (*cb)(struct S_DPF, float)) ;
+EXPORT void f0_V_SF_DPD(struct S_DPD p0, float p1,  void (*cb)(struct S_DPD, float)) ;
+EXPORT void f0_V_SF_DPP(struct S_DPP p0, float p1,  void (*cb)(struct S_DPP, float)) ;
+EXPORT void f0_V_SF_PII(struct S_PII p0, float p1,  void (*cb)(struct S_PII, float)) ;
+EXPORT void f0_V_SF_PIF(struct S_PIF p0, float p1,  void (*cb)(struct S_PIF, float)) ;
+EXPORT void f0_V_SF_PID(struct S_PID p0, float p1,  void (*cb)(struct S_PID, float)) ;
+EXPORT void f0_V_SF_PIP(struct S_PIP p0, float p1,  void (*cb)(struct S_PIP, float)) ;
+EXPORT void f0_V_SF_PFI(struct S_PFI p0, float p1,  void (*cb)(struct S_PFI, float)) ;
+EXPORT void f0_V_SF_PFF(struct S_PFF p0, float p1,  void (*cb)(struct S_PFF, float)) ;
+EXPORT void f0_V_SF_PFD(struct S_PFD p0, float p1,  void (*cb)(struct S_PFD, float)) ;
+EXPORT void f1_V_SF_PFP(struct S_PFP p0, float p1,  void (*cb)(struct S_PFP, float)) ;
+EXPORT void f1_V_SF_PDI(struct S_PDI p0, float p1,  void (*cb)(struct S_PDI, float)) ;
+EXPORT void f1_V_SF_PDF(struct S_PDF p0, float p1,  void (*cb)(struct S_PDF, float)) ;
+EXPORT void f1_V_SF_PDD(struct S_PDD p0, float p1,  void (*cb)(struct S_PDD, float)) ;
+EXPORT void f1_V_SF_PDP(struct S_PDP p0, float p1,  void (*cb)(struct S_PDP, float)) ;
+EXPORT void f1_V_SF_PPI(struct S_PPI p0, float p1,  void (*cb)(struct S_PPI, float)) ;
+EXPORT void f1_V_SF_PPF(struct S_PPF p0, float p1,  void (*cb)(struct S_PPF, float)) ;
+EXPORT void f1_V_SF_PPD(struct S_PPD p0, float p1,  void (*cb)(struct S_PPD, float)) ;
+EXPORT void f1_V_SF_PPP(struct S_PPP p0, float p1,  void (*cb)(struct S_PPP, float)) ;
+EXPORT void f1_V_SD_I(struct S_I p0, double p1,  void (*cb)(struct S_I, double)) ;
+EXPORT void f1_V_SD_F(struct S_F p0, double p1,  void (*cb)(struct S_F, double)) ;
+EXPORT void f1_V_SD_D(struct S_D p0, double p1,  void (*cb)(struct S_D, double)) ;
+EXPORT void f1_V_SD_P(struct S_P p0, double p1,  void (*cb)(struct S_P, double)) ;
+EXPORT void f1_V_SD_II(struct S_II p0, double p1,  void (*cb)(struct S_II, double)) ;
+EXPORT void f1_V_SD_IF(struct S_IF p0, double p1,  void (*cb)(struct S_IF, double)) ;
+EXPORT void f1_V_SD_ID(struct S_ID p0, double p1,  void (*cb)(struct S_ID, double)) ;
+EXPORT void f1_V_SD_IP(struct S_IP p0, double p1,  void (*cb)(struct S_IP, double)) ;
+EXPORT void f1_V_SD_FI(struct S_FI p0, double p1,  void (*cb)(struct S_FI, double)) ;
+EXPORT void f1_V_SD_FF(struct S_FF p0, double p1,  void (*cb)(struct S_FF, double)) ;
+EXPORT void f1_V_SD_FD(struct S_FD p0, double p1,  void (*cb)(struct S_FD, double)) ;
+EXPORT void f1_V_SD_FP(struct S_FP p0, double p1,  void (*cb)(struct S_FP, double)) ;
+EXPORT void f1_V_SD_DI(struct S_DI p0, double p1,  void (*cb)(struct S_DI, double)) ;
+EXPORT void f1_V_SD_DF(struct S_DF p0, double p1,  void (*cb)(struct S_DF, double)) ;
+EXPORT void f1_V_SD_DD(struct S_DD p0, double p1,  void (*cb)(struct S_DD, double)) ;
+EXPORT void f1_V_SD_DP(struct S_DP p0, double p1,  void (*cb)(struct S_DP, double)) ;
+EXPORT void f1_V_SD_PI(struct S_PI p0, double p1,  void (*cb)(struct S_PI, double)) ;
+EXPORT void f1_V_SD_PF(struct S_PF p0, double p1,  void (*cb)(struct S_PF, double)) ;
+EXPORT void f1_V_SD_PD(struct S_PD p0, double p1,  void (*cb)(struct S_PD, double)) ;
+EXPORT void f1_V_SD_PP(struct S_PP p0, double p1,  void (*cb)(struct S_PP, double)) ;
+EXPORT void f1_V_SD_III(struct S_III p0, double p1,  void (*cb)(struct S_III, double)) ;
+EXPORT void f1_V_SD_IIF(struct S_IIF p0, double p1,  void (*cb)(struct S_IIF, double)) ;
+EXPORT void f1_V_SD_IID(struct S_IID p0, double p1,  void (*cb)(struct S_IID, double)) ;
+EXPORT void f1_V_SD_IIP(struct S_IIP p0, double p1,  void (*cb)(struct S_IIP, double)) ;
+EXPORT void f1_V_SD_IFI(struct S_IFI p0, double p1,  void (*cb)(struct S_IFI, double)) ;
+EXPORT void f1_V_SD_IFF(struct S_IFF p0, double p1,  void (*cb)(struct S_IFF, double)) ;
+EXPORT void f1_V_SD_IFD(struct S_IFD p0, double p1,  void (*cb)(struct S_IFD, double)) ;
+EXPORT void f1_V_SD_IFP(struct S_IFP p0, double p1,  void (*cb)(struct S_IFP, double)) ;
+EXPORT void f1_V_SD_IDI(struct S_IDI p0, double p1,  void (*cb)(struct S_IDI, double)) ;
+EXPORT void f1_V_SD_IDF(struct S_IDF p0, double p1,  void (*cb)(struct S_IDF, double)) ;
+EXPORT void f1_V_SD_IDD(struct S_IDD p0, double p1,  void (*cb)(struct S_IDD, double)) ;
+EXPORT void f1_V_SD_IDP(struct S_IDP p0, double p1,  void (*cb)(struct S_IDP, double)) ;
+EXPORT void f1_V_SD_IPI(struct S_IPI p0, double p1,  void (*cb)(struct S_IPI, double)) ;
+EXPORT void f1_V_SD_IPF(struct S_IPF p0, double p1,  void (*cb)(struct S_IPF, double)) ;
+EXPORT void f1_V_SD_IPD(struct S_IPD p0, double p1,  void (*cb)(struct S_IPD, double)) ;
+EXPORT void f1_V_SD_IPP(struct S_IPP p0, double p1,  void (*cb)(struct S_IPP, double)) ;
+EXPORT void f1_V_SD_FII(struct S_FII p0, double p1,  void (*cb)(struct S_FII, double)) ;
+EXPORT void f1_V_SD_FIF(struct S_FIF p0, double p1,  void (*cb)(struct S_FIF, double)) ;
+EXPORT void f1_V_SD_FID(struct S_FID p0, double p1,  void (*cb)(struct S_FID, double)) ;
+EXPORT void f1_V_SD_FIP(struct S_FIP p0, double p1,  void (*cb)(struct S_FIP, double)) ;
+EXPORT void f1_V_SD_FFI(struct S_FFI p0, double p1,  void (*cb)(struct S_FFI, double)) ;
+EXPORT void f1_V_SD_FFF(struct S_FFF p0, double p1,  void (*cb)(struct S_FFF, double)) ;
+EXPORT void f1_V_SD_FFD(struct S_FFD p0, double p1,  void (*cb)(struct S_FFD, double)) ;
+EXPORT void f1_V_SD_FFP(struct S_FFP p0, double p1,  void (*cb)(struct S_FFP, double)) ;
+EXPORT void f1_V_SD_FDI(struct S_FDI p0, double p1,  void (*cb)(struct S_FDI, double)) ;
+EXPORT void f1_V_SD_FDF(struct S_FDF p0, double p1,  void (*cb)(struct S_FDF, double)) ;
+EXPORT void f1_V_SD_FDD(struct S_FDD p0, double p1,  void (*cb)(struct S_FDD, double)) ;
+EXPORT void f1_V_SD_FDP(struct S_FDP p0, double p1,  void (*cb)(struct S_FDP, double)) ;
+EXPORT void f1_V_SD_FPI(struct S_FPI p0, double p1,  void (*cb)(struct S_FPI, double)) ;
+EXPORT void f1_V_SD_FPF(struct S_FPF p0, double p1,  void (*cb)(struct S_FPF, double)) ;
+EXPORT void f1_V_SD_FPD(struct S_FPD p0, double p1,  void (*cb)(struct S_FPD, double)) ;
+EXPORT void f1_V_SD_FPP(struct S_FPP p0, double p1,  void (*cb)(struct S_FPP, double)) ;
+EXPORT void f1_V_SD_DII(struct S_DII p0, double p1,  void (*cb)(struct S_DII, double)) ;
+EXPORT void f1_V_SD_DIF(struct S_DIF p0, double p1,  void (*cb)(struct S_DIF, double)) ;
+EXPORT void f1_V_SD_DID(struct S_DID p0, double p1,  void (*cb)(struct S_DID, double)) ;
+EXPORT void f1_V_SD_DIP(struct S_DIP p0, double p1,  void (*cb)(struct S_DIP, double)) ;
+EXPORT void f1_V_SD_DFI(struct S_DFI p0, double p1,  void (*cb)(struct S_DFI, double)) ;
+EXPORT void f1_V_SD_DFF(struct S_DFF p0, double p1,  void (*cb)(struct S_DFF, double)) ;
+EXPORT void f1_V_SD_DFD(struct S_DFD p0, double p1,  void (*cb)(struct S_DFD, double)) ;
+EXPORT void f1_V_SD_DFP(struct S_DFP p0, double p1,  void (*cb)(struct S_DFP, double)) ;
+EXPORT void f1_V_SD_DDI(struct S_DDI p0, double p1,  void (*cb)(struct S_DDI, double)) ;
+EXPORT void f1_V_SD_DDF(struct S_DDF p0, double p1,  void (*cb)(struct S_DDF, double)) ;
+EXPORT void f1_V_SD_DDD(struct S_DDD p0, double p1,  void (*cb)(struct S_DDD, double)) ;
+EXPORT void f1_V_SD_DDP(struct S_DDP p0, double p1,  void (*cb)(struct S_DDP, double)) ;
+EXPORT void f1_V_SD_DPI(struct S_DPI p0, double p1,  void (*cb)(struct S_DPI, double)) ;
+EXPORT void f1_V_SD_DPF(struct S_DPF p0, double p1,  void (*cb)(struct S_DPF, double)) ;
+EXPORT void f1_V_SD_DPD(struct S_DPD p0, double p1,  void (*cb)(struct S_DPD, double)) ;
+EXPORT void f1_V_SD_DPP(struct S_DPP p0, double p1,  void (*cb)(struct S_DPP, double)) ;
+EXPORT void f1_V_SD_PII(struct S_PII p0, double p1,  void (*cb)(struct S_PII, double)) ;
+EXPORT void f1_V_SD_PIF(struct S_PIF p0, double p1,  void (*cb)(struct S_PIF, double)) ;
+EXPORT void f1_V_SD_PID(struct S_PID p0, double p1,  void (*cb)(struct S_PID, double)) ;
+EXPORT void f1_V_SD_PIP(struct S_PIP p0, double p1,  void (*cb)(struct S_PIP, double)) ;
+EXPORT void f1_V_SD_PFI(struct S_PFI p0, double p1,  void (*cb)(struct S_PFI, double)) ;
+EXPORT void f1_V_SD_PFF(struct S_PFF p0, double p1,  void (*cb)(struct S_PFF, double)) ;
+EXPORT void f1_V_SD_PFD(struct S_PFD p0, double p1,  void (*cb)(struct S_PFD, double)) ;
+EXPORT void f1_V_SD_PFP(struct S_PFP p0, double p1,  void (*cb)(struct S_PFP, double)) ;
+EXPORT void f1_V_SD_PDI(struct S_PDI p0, double p1,  void (*cb)(struct S_PDI, double)) ;
+EXPORT void f1_V_SD_PDF(struct S_PDF p0, double p1,  void (*cb)(struct S_PDF, double)) ;
+EXPORT void f1_V_SD_PDD(struct S_PDD p0, double p1,  void (*cb)(struct S_PDD, double)) ;
+EXPORT void f1_V_SD_PDP(struct S_PDP p0, double p1,  void (*cb)(struct S_PDP, double)) ;
+EXPORT void f1_V_SD_PPI(struct S_PPI p0, double p1,  void (*cb)(struct S_PPI, double)) ;
+EXPORT void f1_V_SD_PPF(struct S_PPF p0, double p1,  void (*cb)(struct S_PPF, double)) ;
+EXPORT void f1_V_SD_PPD(struct S_PPD p0, double p1,  void (*cb)(struct S_PPD, double)) ;
+EXPORT void f1_V_SD_PPP(struct S_PPP p0, double p1,  void (*cb)(struct S_PPP, double)) ;
+EXPORT void f1_V_SP_I(struct S_I p0, void* p1,  void (*cb)(struct S_I, void*)) ;
+EXPORT void f1_V_SP_F(struct S_F p0, void* p1,  void (*cb)(struct S_F, void*)) ;
+EXPORT void f1_V_SP_D(struct S_D p0, void* p1,  void (*cb)(struct S_D, void*)) ;
+EXPORT void f1_V_SP_P(struct S_P p0, void* p1,  void (*cb)(struct S_P, void*)) ;
+EXPORT void f1_V_SP_II(struct S_II p0, void* p1,  void (*cb)(struct S_II, void*)) ;
+EXPORT void f1_V_SP_IF(struct S_IF p0, void* p1,  void (*cb)(struct S_IF, void*)) ;
+EXPORT void f1_V_SP_ID(struct S_ID p0, void* p1,  void (*cb)(struct S_ID, void*)) ;
+EXPORT void f1_V_SP_IP(struct S_IP p0, void* p1,  void (*cb)(struct S_IP, void*)) ;
+EXPORT void f1_V_SP_FI(struct S_FI p0, void* p1,  void (*cb)(struct S_FI, void*)) ;
+EXPORT void f1_V_SP_FF(struct S_FF p0, void* p1,  void (*cb)(struct S_FF, void*)) ;
+EXPORT void f1_V_SP_FD(struct S_FD p0, void* p1,  void (*cb)(struct S_FD, void*)) ;
+EXPORT void f1_V_SP_FP(struct S_FP p0, void* p1,  void (*cb)(struct S_FP, void*)) ;
+EXPORT void f1_V_SP_DI(struct S_DI p0, void* p1,  void (*cb)(struct S_DI, void*)) ;
+EXPORT void f1_V_SP_DF(struct S_DF p0, void* p1,  void (*cb)(struct S_DF, void*)) ;
+EXPORT void f1_V_SP_DD(struct S_DD p0, void* p1,  void (*cb)(struct S_DD, void*)) ;
+EXPORT void f1_V_SP_DP(struct S_DP p0, void* p1,  void (*cb)(struct S_DP, void*)) ;
+EXPORT void f1_V_SP_PI(struct S_PI p0, void* p1,  void (*cb)(struct S_PI, void*)) ;
+EXPORT void f1_V_SP_PF(struct S_PF p0, void* p1,  void (*cb)(struct S_PF, void*)) ;
+EXPORT void f1_V_SP_PD(struct S_PD p0, void* p1,  void (*cb)(struct S_PD, void*)) ;
+EXPORT void f1_V_SP_PP(struct S_PP p0, void* p1,  void (*cb)(struct S_PP, void*)) ;
+EXPORT void f1_V_SP_III(struct S_III p0, void* p1,  void (*cb)(struct S_III, void*)) ;
+EXPORT void f1_V_SP_IIF(struct S_IIF p0, void* p1,  void (*cb)(struct S_IIF, void*)) ;
+EXPORT void f1_V_SP_IID(struct S_IID p0, void* p1,  void (*cb)(struct S_IID, void*)) ;
+EXPORT void f1_V_SP_IIP(struct S_IIP p0, void* p1,  void (*cb)(struct S_IIP, void*)) ;
+EXPORT void f1_V_SP_IFI(struct S_IFI p0, void* p1,  void (*cb)(struct S_IFI, void*)) ;
+EXPORT void f1_V_SP_IFF(struct S_IFF p0, void* p1,  void (*cb)(struct S_IFF, void*)) ;
+EXPORT void f1_V_SP_IFD(struct S_IFD p0, void* p1,  void (*cb)(struct S_IFD, void*)) ;
+EXPORT void f1_V_SP_IFP(struct S_IFP p0, void* p1,  void (*cb)(struct S_IFP, void*)) ;
+EXPORT void f1_V_SP_IDI(struct S_IDI p0, void* p1,  void (*cb)(struct S_IDI, void*)) ;
+EXPORT void f1_V_SP_IDF(struct S_IDF p0, void* p1,  void (*cb)(struct S_IDF, void*)) ;
+EXPORT void f1_V_SP_IDD(struct S_IDD p0, void* p1,  void (*cb)(struct S_IDD, void*)) ;
+EXPORT void f1_V_SP_IDP(struct S_IDP p0, void* p1,  void (*cb)(struct S_IDP, void*)) ;
+EXPORT void f1_V_SP_IPI(struct S_IPI p0, void* p1,  void (*cb)(struct S_IPI, void*)) ;
+EXPORT void f1_V_SP_IPF(struct S_IPF p0, void* p1,  void (*cb)(struct S_IPF, void*)) ;
+EXPORT void f1_V_SP_IPD(struct S_IPD p0, void* p1,  void (*cb)(struct S_IPD, void*)) ;
+EXPORT void f1_V_SP_IPP(struct S_IPP p0, void* p1,  void (*cb)(struct S_IPP, void*)) ;
+EXPORT void f1_V_SP_FII(struct S_FII p0, void* p1,  void (*cb)(struct S_FII, void*)) ;
+EXPORT void f1_V_SP_FIF(struct S_FIF p0, void* p1,  void (*cb)(struct S_FIF, void*)) ;
+EXPORT void f1_V_SP_FID(struct S_FID p0, void* p1,  void (*cb)(struct S_FID, void*)) ;
+EXPORT void f1_V_SP_FIP(struct S_FIP p0, void* p1,  void (*cb)(struct S_FIP, void*)) ;
+EXPORT void f1_V_SP_FFI(struct S_FFI p0, void* p1,  void (*cb)(struct S_FFI, void*)) ;
+EXPORT void f1_V_SP_FFF(struct S_FFF p0, void* p1,  void (*cb)(struct S_FFF, void*)) ;
+EXPORT void f1_V_SP_FFD(struct S_FFD p0, void* p1,  void (*cb)(struct S_FFD, void*)) ;
+EXPORT void f1_V_SP_FFP(struct S_FFP p0, void* p1,  void (*cb)(struct S_FFP, void*)) ;
+EXPORT void f1_V_SP_FDI(struct S_FDI p0, void* p1,  void (*cb)(struct S_FDI, void*)) ;
+EXPORT void f1_V_SP_FDF(struct S_FDF p0, void* p1,  void (*cb)(struct S_FDF, void*)) ;
+EXPORT void f1_V_SP_FDD(struct S_FDD p0, void* p1,  void (*cb)(struct S_FDD, void*)) ;
+EXPORT void f1_V_SP_FDP(struct S_FDP p0, void* p1,  void (*cb)(struct S_FDP, void*)) ;
+EXPORT void f1_V_SP_FPI(struct S_FPI p0, void* p1,  void (*cb)(struct S_FPI, void*)) ;
+EXPORT void f1_V_SP_FPF(struct S_FPF p0, void* p1,  void (*cb)(struct S_FPF, void*)) ;
+EXPORT void f1_V_SP_FPD(struct S_FPD p0, void* p1,  void (*cb)(struct S_FPD, void*)) ;
+EXPORT void f1_V_SP_FPP(struct S_FPP p0, void* p1,  void (*cb)(struct S_FPP, void*)) ;
+EXPORT void f1_V_SP_DII(struct S_DII p0, void* p1,  void (*cb)(struct S_DII, void*)) ;
+EXPORT void f1_V_SP_DIF(struct S_DIF p0, void* p1,  void (*cb)(struct S_DIF, void*)) ;
+EXPORT void f1_V_SP_DID(struct S_DID p0, void* p1,  void (*cb)(struct S_DID, void*)) ;
+EXPORT void f1_V_SP_DIP(struct S_DIP p0, void* p1,  void (*cb)(struct S_DIP, void*)) ;
+EXPORT void f1_V_SP_DFI(struct S_DFI p0, void* p1,  void (*cb)(struct S_DFI, void*)) ;
+EXPORT void f1_V_SP_DFF(struct S_DFF p0, void* p1,  void (*cb)(struct S_DFF, void*)) ;
+EXPORT void f1_V_SP_DFD(struct S_DFD p0, void* p1,  void (*cb)(struct S_DFD, void*)) ;
+EXPORT void f1_V_SP_DFP(struct S_DFP p0, void* p1,  void (*cb)(struct S_DFP, void*)) ;
+EXPORT void f1_V_SP_DDI(struct S_DDI p0, void* p1,  void (*cb)(struct S_DDI, void*)) ;
+EXPORT void f1_V_SP_DDF(struct S_DDF p0, void* p1,  void (*cb)(struct S_DDF, void*)) ;
+EXPORT void f1_V_SP_DDD(struct S_DDD p0, void* p1,  void (*cb)(struct S_DDD, void*)) ;
+EXPORT void f1_V_SP_DDP(struct S_DDP p0, void* p1,  void (*cb)(struct S_DDP, void*)) ;
+EXPORT void f1_V_SP_DPI(struct S_DPI p0, void* p1,  void (*cb)(struct S_DPI, void*)) ;
+EXPORT void f1_V_SP_DPF(struct S_DPF p0, void* p1,  void (*cb)(struct S_DPF, void*)) ;
+EXPORT void f1_V_SP_DPD(struct S_DPD p0, void* p1,  void (*cb)(struct S_DPD, void*)) ;
+EXPORT void f1_V_SP_DPP(struct S_DPP p0, void* p1,  void (*cb)(struct S_DPP, void*)) ;
+EXPORT void f1_V_SP_PII(struct S_PII p0, void* p1,  void (*cb)(struct S_PII, void*)) ;
+EXPORT void f1_V_SP_PIF(struct S_PIF p0, void* p1,  void (*cb)(struct S_PIF, void*)) ;
+EXPORT void f1_V_SP_PID(struct S_PID p0, void* p1,  void (*cb)(struct S_PID, void*)) ;
+EXPORT void f1_V_SP_PIP(struct S_PIP p0, void* p1,  void (*cb)(struct S_PIP, void*)) ;
+EXPORT void f1_V_SP_PFI(struct S_PFI p0, void* p1,  void (*cb)(struct S_PFI, void*)) ;
+EXPORT void f1_V_SP_PFF(struct S_PFF p0, void* p1,  void (*cb)(struct S_PFF, void*)) ;
+EXPORT void f1_V_SP_PFD(struct S_PFD p0, void* p1,  void (*cb)(struct S_PFD, void*)) ;
+EXPORT void f1_V_SP_PFP(struct S_PFP p0, void* p1,  void (*cb)(struct S_PFP, void*)) ;
+EXPORT void f1_V_SP_PDI(struct S_PDI p0, void* p1,  void (*cb)(struct S_PDI, void*)) ;
+EXPORT void f1_V_SP_PDF(struct S_PDF p0, void* p1,  void (*cb)(struct S_PDF, void*)) ;
+EXPORT void f1_V_SP_PDD(struct S_PDD p0, void* p1,  void (*cb)(struct S_PDD, void*)) ;
+EXPORT void f1_V_SP_PDP(struct S_PDP p0, void* p1,  void (*cb)(struct S_PDP, void*)) ;
+EXPORT void f1_V_SP_PPI(struct S_PPI p0, void* p1,  void (*cb)(struct S_PPI, void*)) ;
+EXPORT void f1_V_SP_PPF(struct S_PPF p0, void* p1,  void (*cb)(struct S_PPF, void*)) ;
+EXPORT void f1_V_SP_PPD(struct S_PPD p0, void* p1,  void (*cb)(struct S_PPD, void*)) ;
+EXPORT void f1_V_SP_PPP(struct S_PPP p0, void* p1,  void (*cb)(struct S_PPP, void*)) ;
+EXPORT void f1_V_SS_I(struct S_I p0, struct S_I p1,  void (*cb)(struct S_I, struct S_I)) ;
+EXPORT void f1_V_SS_F(struct S_F p0, struct S_F p1,  void (*cb)(struct S_F, struct S_F)) ;
+EXPORT void f1_V_SS_D(struct S_D p0, struct S_D p1,  void (*cb)(struct S_D, struct S_D)) ;
+EXPORT void f1_V_SS_P(struct S_P p0, struct S_P p1,  void (*cb)(struct S_P, struct S_P)) ;
+EXPORT void f1_V_SS_II(struct S_II p0, struct S_II p1,  void (*cb)(struct S_II, struct S_II)) ;
+EXPORT void f1_V_SS_IF(struct S_IF p0, struct S_IF p1,  void (*cb)(struct S_IF, struct S_IF)) ;
+EXPORT void f1_V_SS_ID(struct S_ID p0, struct S_ID p1,  void (*cb)(struct S_ID, struct S_ID)) ;
+EXPORT void f1_V_SS_IP(struct S_IP p0, struct S_IP p1,  void (*cb)(struct S_IP, struct S_IP)) ;
+EXPORT void f1_V_SS_FI(struct S_FI p0, struct S_FI p1,  void (*cb)(struct S_FI, struct S_FI)) ;
+EXPORT void f1_V_SS_FF(struct S_FF p0, struct S_FF p1,  void (*cb)(struct S_FF, struct S_FF)) ;
+EXPORT void f1_V_SS_FD(struct S_FD p0, struct S_FD p1,  void (*cb)(struct S_FD, struct S_FD)) ;
+EXPORT void f1_V_SS_FP(struct S_FP p0, struct S_FP p1,  void (*cb)(struct S_FP, struct S_FP)) ;
+EXPORT void f1_V_SS_DI(struct S_DI p0, struct S_DI p1,  void (*cb)(struct S_DI, struct S_DI)) ;
+EXPORT void f1_V_SS_DF(struct S_DF p0, struct S_DF p1,  void (*cb)(struct S_DF, struct S_DF)) ;
+EXPORT void f1_V_SS_DD(struct S_DD p0, struct S_DD p1,  void (*cb)(struct S_DD, struct S_DD)) ;
+EXPORT void f1_V_SS_DP(struct S_DP p0, struct S_DP p1,  void (*cb)(struct S_DP, struct S_DP)) ;
+EXPORT void f1_V_SS_PI(struct S_PI p0, struct S_PI p1,  void (*cb)(struct S_PI, struct S_PI)) ;
+EXPORT void f1_V_SS_PF(struct S_PF p0, struct S_PF p1,  void (*cb)(struct S_PF, struct S_PF)) ;
+EXPORT void f1_V_SS_PD(struct S_PD p0, struct S_PD p1,  void (*cb)(struct S_PD, struct S_PD)) ;
+EXPORT void f1_V_SS_PP(struct S_PP p0, struct S_PP p1,  void (*cb)(struct S_PP, struct S_PP)) ;
+EXPORT void f1_V_SS_III(struct S_III p0, struct S_III p1,  void (*cb)(struct S_III, struct S_III)) ;
+EXPORT void f1_V_SS_IIF(struct S_IIF p0, struct S_IIF p1,  void (*cb)(struct S_IIF, struct S_IIF)) ;
+EXPORT void f1_V_SS_IID(struct S_IID p0, struct S_IID p1,  void (*cb)(struct S_IID, struct S_IID)) ;
+EXPORT void f1_V_SS_IIP(struct S_IIP p0, struct S_IIP p1,  void (*cb)(struct S_IIP, struct S_IIP)) ;
+EXPORT void f1_V_SS_IFI(struct S_IFI p0, struct S_IFI p1,  void (*cb)(struct S_IFI, struct S_IFI)) ;
+EXPORT void f1_V_SS_IFF(struct S_IFF p0, struct S_IFF p1,  void (*cb)(struct S_IFF, struct S_IFF)) ;
+EXPORT void f1_V_SS_IFD(struct S_IFD p0, struct S_IFD p1,  void (*cb)(struct S_IFD, struct S_IFD)) ;
+EXPORT void f1_V_SS_IFP(struct S_IFP p0, struct S_IFP p1,  void (*cb)(struct S_IFP, struct S_IFP)) ;
+EXPORT void f1_V_SS_IDI(struct S_IDI p0, struct S_IDI p1,  void (*cb)(struct S_IDI, struct S_IDI)) ;
+EXPORT void f1_V_SS_IDF(struct S_IDF p0, struct S_IDF p1,  void (*cb)(struct S_IDF, struct S_IDF)) ;
+EXPORT void f1_V_SS_IDD(struct S_IDD p0, struct S_IDD p1,  void (*cb)(struct S_IDD, struct S_IDD)) ;
+EXPORT void f1_V_SS_IDP(struct S_IDP p0, struct S_IDP p1,  void (*cb)(struct S_IDP, struct S_IDP)) ;
+EXPORT void f1_V_SS_IPI(struct S_IPI p0, struct S_IPI p1,  void (*cb)(struct S_IPI, struct S_IPI)) ;
+EXPORT void f1_V_SS_IPF(struct S_IPF p0, struct S_IPF p1,  void (*cb)(struct S_IPF, struct S_IPF)) ;
+EXPORT void f1_V_SS_IPD(struct S_IPD p0, struct S_IPD p1,  void (*cb)(struct S_IPD, struct S_IPD)) ;
+EXPORT void f1_V_SS_IPP(struct S_IPP p0, struct S_IPP p1,  void (*cb)(struct S_IPP, struct S_IPP)) ;
+EXPORT void f1_V_SS_FII(struct S_FII p0, struct S_FII p1,  void (*cb)(struct S_FII, struct S_FII)) ;
+EXPORT void f1_V_SS_FIF(struct S_FIF p0, struct S_FIF p1,  void (*cb)(struct S_FIF, struct S_FIF)) ;
+EXPORT void f1_V_SS_FID(struct S_FID p0, struct S_FID p1,  void (*cb)(struct S_FID, struct S_FID)) ;
+EXPORT void f1_V_SS_FIP(struct S_FIP p0, struct S_FIP p1,  void (*cb)(struct S_FIP, struct S_FIP)) ;
+EXPORT void f1_V_SS_FFI(struct S_FFI p0, struct S_FFI p1,  void (*cb)(struct S_FFI, struct S_FFI)) ;
+EXPORT void f1_V_SS_FFF(struct S_FFF p0, struct S_FFF p1,  void (*cb)(struct S_FFF, struct S_FFF)) ;
+EXPORT void f1_V_SS_FFD(struct S_FFD p0, struct S_FFD p1,  void (*cb)(struct S_FFD, struct S_FFD)) ;
+EXPORT void f1_V_SS_FFP(struct S_FFP p0, struct S_FFP p1,  void (*cb)(struct S_FFP, struct S_FFP)) ;
+EXPORT void f1_V_SS_FDI(struct S_FDI p0, struct S_FDI p1,  void (*cb)(struct S_FDI, struct S_FDI)) ;
+EXPORT void f1_V_SS_FDF(struct S_FDF p0, struct S_FDF p1,  void (*cb)(struct S_FDF, struct S_FDF)) ;
+EXPORT void f1_V_SS_FDD(struct S_FDD p0, struct S_FDD p1,  void (*cb)(struct S_FDD, struct S_FDD)) ;
+EXPORT void f1_V_SS_FDP(struct S_FDP p0, struct S_FDP p1,  void (*cb)(struct S_FDP, struct S_FDP)) ;
+EXPORT void f1_V_SS_FPI(struct S_FPI p0, struct S_FPI p1,  void (*cb)(struct S_FPI, struct S_FPI)) ;
+EXPORT void f1_V_SS_FPF(struct S_FPF p0, struct S_FPF p1,  void (*cb)(struct S_FPF, struct S_FPF)) ;
+EXPORT void f1_V_SS_FPD(struct S_FPD p0, struct S_FPD p1,  void (*cb)(struct S_FPD, struct S_FPD)) ;
+EXPORT void f1_V_SS_FPP(struct S_FPP p0, struct S_FPP p1,  void (*cb)(struct S_FPP, struct S_FPP)) ;
+EXPORT void f1_V_SS_DII(struct S_DII p0, struct S_DII p1,  void (*cb)(struct S_DII, struct S_DII)) ;
+EXPORT void f1_V_SS_DIF(struct S_DIF p0, struct S_DIF p1,  void (*cb)(struct S_DIF, struct S_DIF)) ;
+EXPORT void f1_V_SS_DID(struct S_DID p0, struct S_DID p1,  void (*cb)(struct S_DID, struct S_DID)) ;
+EXPORT void f1_V_SS_DIP(struct S_DIP p0, struct S_DIP p1,  void (*cb)(struct S_DIP, struct S_DIP)) ;
+EXPORT void f1_V_SS_DFI(struct S_DFI p0, struct S_DFI p1,  void (*cb)(struct S_DFI, struct S_DFI)) ;
+EXPORT void f1_V_SS_DFF(struct S_DFF p0, struct S_DFF p1,  void (*cb)(struct S_DFF, struct S_DFF)) ;
+EXPORT void f1_V_SS_DFD(struct S_DFD p0, struct S_DFD p1,  void (*cb)(struct S_DFD, struct S_DFD)) ;
+EXPORT void f1_V_SS_DFP(struct S_DFP p0, struct S_DFP p1,  void (*cb)(struct S_DFP, struct S_DFP)) ;
+EXPORT void f1_V_SS_DDI(struct S_DDI p0, struct S_DDI p1,  void (*cb)(struct S_DDI, struct S_DDI)) ;
+EXPORT void f1_V_SS_DDF(struct S_DDF p0, struct S_DDF p1,  void (*cb)(struct S_DDF, struct S_DDF)) ;
+EXPORT void f1_V_SS_DDD(struct S_DDD p0, struct S_DDD p1,  void (*cb)(struct S_DDD, struct S_DDD)) ;
+EXPORT void f1_V_SS_DDP(struct S_DDP p0, struct S_DDP p1,  void (*cb)(struct S_DDP, struct S_DDP)) ;
+EXPORT void f1_V_SS_DPI(struct S_DPI p0, struct S_DPI p1,  void (*cb)(struct S_DPI, struct S_DPI)) ;
+EXPORT void f1_V_SS_DPF(struct S_DPF p0, struct S_DPF p1,  void (*cb)(struct S_DPF, struct S_DPF)) ;
+EXPORT void f1_V_SS_DPD(struct S_DPD p0, struct S_DPD p1,  void (*cb)(struct S_DPD, struct S_DPD)) ;
+EXPORT void f1_V_SS_DPP(struct S_DPP p0, struct S_DPP p1,  void (*cb)(struct S_DPP, struct S_DPP)) ;
+EXPORT void f1_V_SS_PII(struct S_PII p0, struct S_PII p1,  void (*cb)(struct S_PII, struct S_PII)) ;
+EXPORT void f1_V_SS_PIF(struct S_PIF p0, struct S_PIF p1,  void (*cb)(struct S_PIF, struct S_PIF)) ;
+EXPORT void f1_V_SS_PID(struct S_PID p0, struct S_PID p1,  void (*cb)(struct S_PID, struct S_PID)) ;
+EXPORT void f1_V_SS_PIP(struct S_PIP p0, struct S_PIP p1,  void (*cb)(struct S_PIP, struct S_PIP)) ;
+EXPORT void f1_V_SS_PFI(struct S_PFI p0, struct S_PFI p1,  void (*cb)(struct S_PFI, struct S_PFI)) ;
+EXPORT void f1_V_SS_PFF(struct S_PFF p0, struct S_PFF p1,  void (*cb)(struct S_PFF, struct S_PFF)) ;
+EXPORT void f1_V_SS_PFD(struct S_PFD p0, struct S_PFD p1,  void (*cb)(struct S_PFD, struct S_PFD)) ;
+EXPORT void f1_V_SS_PFP(struct S_PFP p0, struct S_PFP p1,  void (*cb)(struct S_PFP, struct S_PFP)) ;
+EXPORT void f1_V_SS_PDI(struct S_PDI p0, struct S_PDI p1,  void (*cb)(struct S_PDI, struct S_PDI)) ;
+EXPORT void f1_V_SS_PDF(struct S_PDF p0, struct S_PDF p1,  void (*cb)(struct S_PDF, struct S_PDF)) ;
+EXPORT void f1_V_SS_PDD(struct S_PDD p0, struct S_PDD p1,  void (*cb)(struct S_PDD, struct S_PDD)) ;
+EXPORT void f1_V_SS_PDP(struct S_PDP p0, struct S_PDP p1,  void (*cb)(struct S_PDP, struct S_PDP)) ;
+EXPORT void f1_V_SS_PPI(struct S_PPI p0, struct S_PPI p1,  void (*cb)(struct S_PPI, struct S_PPI)) ;
+EXPORT void f1_V_SS_PPF(struct S_PPF p0, struct S_PPF p1,  void (*cb)(struct S_PPF, struct S_PPF)) ;
+EXPORT void f1_V_SS_PPD(struct S_PPD p0, struct S_PPD p1,  void (*cb)(struct S_PPD, struct S_PPD)) ;
+EXPORT void f1_V_SS_PPP(struct S_PPP p0, struct S_PPP p1,  void (*cb)(struct S_PPP, struct S_PPP)) ;
+EXPORT void f1_V_III_(int p0, int p1, int p2,  void (*cb)(int, int, int)) ;
+EXPORT void f1_V_IIF_(int p0, int p1, float p2,  void (*cb)(int, int, float)) ;
+EXPORT void f1_V_IID_(int p0, int p1, double p2,  void (*cb)(int, int, double)) ;
+EXPORT void f1_V_IIP_(int p0, int p1, void* p2,  void (*cb)(int, int, void*)) ;
+EXPORT void f1_V_IIS_I(int p0, int p1, struct S_I p2,  void (*cb)(int, int, struct S_I)) ;
+EXPORT void f1_V_IIS_F(int p0, int p1, struct S_F p2,  void (*cb)(int, int, struct S_F)) ;
+EXPORT void f1_V_IIS_D(int p0, int p1, struct S_D p2,  void (*cb)(int, int, struct S_D)) ;
+EXPORT void f1_V_IIS_P(int p0, int p1, struct S_P p2,  void (*cb)(int, int, struct S_P)) ;
+EXPORT void f1_V_IIS_II(int p0, int p1, struct S_II p2,  void (*cb)(int, int, struct S_II)) ;
+EXPORT void f1_V_IIS_IF(int p0, int p1, struct S_IF p2,  void (*cb)(int, int, struct S_IF)) ;
+EXPORT void f1_V_IIS_ID(int p0, int p1, struct S_ID p2,  void (*cb)(int, int, struct S_ID)) ;
+EXPORT void f1_V_IIS_IP(int p0, int p1, struct S_IP p2,  void (*cb)(int, int, struct S_IP)) ;
+EXPORT void f1_V_IIS_FI(int p0, int p1, struct S_FI p2,  void (*cb)(int, int, struct S_FI)) ;
+EXPORT void f1_V_IIS_FF(int p0, int p1, struct S_FF p2,  void (*cb)(int, int, struct S_FF)) ;
+EXPORT void f1_V_IIS_FD(int p0, int p1, struct S_FD p2,  void (*cb)(int, int, struct S_FD)) ;
+EXPORT void f1_V_IIS_FP(int p0, int p1, struct S_FP p2,  void (*cb)(int, int, struct S_FP)) ;
+EXPORT void f1_V_IIS_DI(int p0, int p1, struct S_DI p2,  void (*cb)(int, int, struct S_DI)) ;
+EXPORT void f1_V_IIS_DF(int p0, int p1, struct S_DF p2,  void (*cb)(int, int, struct S_DF)) ;
+EXPORT void f1_V_IIS_DD(int p0, int p1, struct S_DD p2,  void (*cb)(int, int, struct S_DD)) ;
+EXPORT void f1_V_IIS_DP(int p0, int p1, struct S_DP p2,  void (*cb)(int, int, struct S_DP)) ;
+EXPORT void f1_V_IIS_PI(int p0, int p1, struct S_PI p2,  void (*cb)(int, int, struct S_PI)) ;
+EXPORT void f1_V_IIS_PF(int p0, int p1, struct S_PF p2,  void (*cb)(int, int, struct S_PF)) ;
+EXPORT void f1_V_IIS_PD(int p0, int p1, struct S_PD p2,  void (*cb)(int, int, struct S_PD)) ;
+EXPORT void f1_V_IIS_PP(int p0, int p1, struct S_PP p2,  void (*cb)(int, int, struct S_PP)) ;
+EXPORT void f1_V_IIS_III(int p0, int p1, struct S_III p2,  void (*cb)(int, int, struct S_III)) ;
+EXPORT void f1_V_IIS_IIF(int p0, int p1, struct S_IIF p2,  void (*cb)(int, int, struct S_IIF)) ;
+EXPORT void f1_V_IIS_IID(int p0, int p1, struct S_IID p2,  void (*cb)(int, int, struct S_IID)) ;
+EXPORT void f1_V_IIS_IIP(int p0, int p1, struct S_IIP p2,  void (*cb)(int, int, struct S_IIP)) ;
+EXPORT void f1_V_IIS_IFI(int p0, int p1, struct S_IFI p2,  void (*cb)(int, int, struct S_IFI)) ;
+EXPORT void f1_V_IIS_IFF(int p0, int p1, struct S_IFF p2,  void (*cb)(int, int, struct S_IFF)) ;
+EXPORT void f1_V_IIS_IFD(int p0, int p1, struct S_IFD p2,  void (*cb)(int, int, struct S_IFD)) ;
+EXPORT void f1_V_IIS_IFP(int p0, int p1, struct S_IFP p2,  void (*cb)(int, int, struct S_IFP)) ;
+EXPORT void f1_V_IIS_IDI(int p0, int p1, struct S_IDI p2,  void (*cb)(int, int, struct S_IDI)) ;
+EXPORT void f1_V_IIS_IDF(int p0, int p1, struct S_IDF p2,  void (*cb)(int, int, struct S_IDF)) ;
+EXPORT void f1_V_IIS_IDD(int p0, int p1, struct S_IDD p2,  void (*cb)(int, int, struct S_IDD)) ;
+EXPORT void f1_V_IIS_IDP(int p0, int p1, struct S_IDP p2,  void (*cb)(int, int, struct S_IDP)) ;
+EXPORT void f1_V_IIS_IPI(int p0, int p1, struct S_IPI p2,  void (*cb)(int, int, struct S_IPI)) ;
+EXPORT void f1_V_IIS_IPF(int p0, int p1, struct S_IPF p2,  void (*cb)(int, int, struct S_IPF)) ;
+EXPORT void f1_V_IIS_IPD(int p0, int p1, struct S_IPD p2,  void (*cb)(int, int, struct S_IPD)) ;
+EXPORT void f1_V_IIS_IPP(int p0, int p1, struct S_IPP p2,  void (*cb)(int, int, struct S_IPP)) ;
+EXPORT void f1_V_IIS_FII(int p0, int p1, struct S_FII p2,  void (*cb)(int, int, struct S_FII)) ;
+EXPORT void f1_V_IIS_FIF(int p0, int p1, struct S_FIF p2,  void (*cb)(int, int, struct S_FIF)) ;
+EXPORT void f1_V_IIS_FID(int p0, int p1, struct S_FID p2,  void (*cb)(int, int, struct S_FID)) ;
+EXPORT void f1_V_IIS_FIP(int p0, int p1, struct S_FIP p2,  void (*cb)(int, int, struct S_FIP)) ;
+EXPORT void f1_V_IIS_FFI(int p0, int p1, struct S_FFI p2,  void (*cb)(int, int, struct S_FFI)) ;
+EXPORT void f1_V_IIS_FFF(int p0, int p1, struct S_FFF p2,  void (*cb)(int, int, struct S_FFF)) ;
+EXPORT void f1_V_IIS_FFD(int p0, int p1, struct S_FFD p2,  void (*cb)(int, int, struct S_FFD)) ;
+EXPORT void f1_V_IIS_FFP(int p0, int p1, struct S_FFP p2,  void (*cb)(int, int, struct S_FFP)) ;
+EXPORT void f1_V_IIS_FDI(int p0, int p1, struct S_FDI p2,  void (*cb)(int, int, struct S_FDI)) ;
+EXPORT void f1_V_IIS_FDF(int p0, int p1, struct S_FDF p2,  void (*cb)(int, int, struct S_FDF)) ;
+EXPORT void f1_V_IIS_FDD(int p0, int p1, struct S_FDD p2,  void (*cb)(int, int, struct S_FDD)) ;
+EXPORT void f1_V_IIS_FDP(int p0, int p1, struct S_FDP p2,  void (*cb)(int, int, struct S_FDP)) ;
+EXPORT void f1_V_IIS_FPI(int p0, int p1, struct S_FPI p2,  void (*cb)(int, int, struct S_FPI)) ;
+EXPORT void f1_V_IIS_FPF(int p0, int p1, struct S_FPF p2,  void (*cb)(int, int, struct S_FPF)) ;
+EXPORT void f1_V_IIS_FPD(int p0, int p1, struct S_FPD p2,  void (*cb)(int, int, struct S_FPD)) ;
+EXPORT void f1_V_IIS_FPP(int p0, int p1, struct S_FPP p2,  void (*cb)(int, int, struct S_FPP)) ;
+EXPORT void f1_V_IIS_DII(int p0, int p1, struct S_DII p2,  void (*cb)(int, int, struct S_DII)) ;
+EXPORT void f1_V_IIS_DIF(int p0, int p1, struct S_DIF p2,  void (*cb)(int, int, struct S_DIF)) ;
+EXPORT void f1_V_IIS_DID(int p0, int p1, struct S_DID p2,  void (*cb)(int, int, struct S_DID)) ;
+EXPORT void f1_V_IIS_DIP(int p0, int p1, struct S_DIP p2,  void (*cb)(int, int, struct S_DIP)) ;
+EXPORT void f1_V_IIS_DFI(int p0, int p1, struct S_DFI p2,  void (*cb)(int, int, struct S_DFI)) ;
+EXPORT void f1_V_IIS_DFF(int p0, int p1, struct S_DFF p2,  void (*cb)(int, int, struct S_DFF)) ;
+EXPORT void f1_V_IIS_DFD(int p0, int p1, struct S_DFD p2,  void (*cb)(int, int, struct S_DFD)) ;
+EXPORT void f1_V_IIS_DFP(int p0, int p1, struct S_DFP p2,  void (*cb)(int, int, struct S_DFP)) ;
+EXPORT void f1_V_IIS_DDI(int p0, int p1, struct S_DDI p2,  void (*cb)(int, int, struct S_DDI)) ;
+EXPORT void f1_V_IIS_DDF(int p0, int p1, struct S_DDF p2,  void (*cb)(int, int, struct S_DDF)) ;
+EXPORT void f1_V_IIS_DDD(int p0, int p1, struct S_DDD p2,  void (*cb)(int, int, struct S_DDD)) ;
+EXPORT void f1_V_IIS_DDP(int p0, int p1, struct S_DDP p2,  void (*cb)(int, int, struct S_DDP)) ;
+EXPORT void f1_V_IIS_DPI(int p0, int p1, struct S_DPI p2,  void (*cb)(int, int, struct S_DPI)) ;
+EXPORT void f1_V_IIS_DPF(int p0, int p1, struct S_DPF p2,  void (*cb)(int, int, struct S_DPF)) ;
+EXPORT void f1_V_IIS_DPD(int p0, int p1, struct S_DPD p2,  void (*cb)(int, int, struct S_DPD)) ;
+EXPORT void f1_V_IIS_DPP(int p0, int p1, struct S_DPP p2,  void (*cb)(int, int, struct S_DPP)) ;
+EXPORT void f1_V_IIS_PII(int p0, int p1, struct S_PII p2,  void (*cb)(int, int, struct S_PII)) ;
+EXPORT void f1_V_IIS_PIF(int p0, int p1, struct S_PIF p2,  void (*cb)(int, int, struct S_PIF)) ;
+EXPORT void f1_V_IIS_PID(int p0, int p1, struct S_PID p2,  void (*cb)(int, int, struct S_PID)) ;
+EXPORT void f1_V_IIS_PIP(int p0, int p1, struct S_PIP p2,  void (*cb)(int, int, struct S_PIP)) ;
+EXPORT void f1_V_IIS_PFI(int p0, int p1, struct S_PFI p2,  void (*cb)(int, int, struct S_PFI)) ;
+EXPORT void f1_V_IIS_PFF(int p0, int p1, struct S_PFF p2,  void (*cb)(int, int, struct S_PFF)) ;
+EXPORT void f1_V_IIS_PFD(int p0, int p1, struct S_PFD p2,  void (*cb)(int, int, struct S_PFD)) ;
+EXPORT void f1_V_IIS_PFP(int p0, int p1, struct S_PFP p2,  void (*cb)(int, int, struct S_PFP)) ;
+EXPORT void f1_V_IIS_PDI(int p0, int p1, struct S_PDI p2,  void (*cb)(int, int, struct S_PDI)) ;
+EXPORT void f1_V_IIS_PDF(int p0, int p1, struct S_PDF p2,  void (*cb)(int, int, struct S_PDF)) ;
+EXPORT void f1_V_IIS_PDD(int p0, int p1, struct S_PDD p2,  void (*cb)(int, int, struct S_PDD)) ;
+EXPORT void f1_V_IIS_PDP(int p0, int p1, struct S_PDP p2,  void (*cb)(int, int, struct S_PDP)) ;
+EXPORT void f1_V_IIS_PPI(int p0, int p1, struct S_PPI p2,  void (*cb)(int, int, struct S_PPI)) ;
+EXPORT void f1_V_IIS_PPF(int p0, int p1, struct S_PPF p2,  void (*cb)(int, int, struct S_PPF)) ;
+EXPORT void f1_V_IIS_PPD(int p0, int p1, struct S_PPD p2,  void (*cb)(int, int, struct S_PPD)) ;
+EXPORT void f1_V_IIS_PPP(int p0, int p1, struct S_PPP p2,  void (*cb)(int, int, struct S_PPP)) ;
+EXPORT void f1_V_IFI_(int p0, float p1, int p2,  void (*cb)(int, float, int)) ;
+EXPORT void f1_V_IFF_(int p0, float p1, float p2,  void (*cb)(int, float, float)) ;
+EXPORT void f1_V_IFD_(int p0, float p1, double p2,  void (*cb)(int, float, double)) ;
+EXPORT void f1_V_IFP_(int p0, float p1, void* p2,  void (*cb)(int, float, void*)) ;
+EXPORT void f1_V_IFS_I(int p0, float p1, struct S_I p2,  void (*cb)(int, float, struct S_I)) ;
+EXPORT void f1_V_IFS_F(int p0, float p1, struct S_F p2,  void (*cb)(int, float, struct S_F)) ;
+EXPORT void f1_V_IFS_D(int p0, float p1, struct S_D p2,  void (*cb)(int, float, struct S_D)) ;
+EXPORT void f1_V_IFS_P(int p0, float p1, struct S_P p2,  void (*cb)(int, float, struct S_P)) ;
+EXPORT void f1_V_IFS_II(int p0, float p1, struct S_II p2,  void (*cb)(int, float, struct S_II)) ;
+EXPORT void f1_V_IFS_IF(int p0, float p1, struct S_IF p2,  void (*cb)(int, float, struct S_IF)) ;
+EXPORT void f1_V_IFS_ID(int p0, float p1, struct S_ID p2,  void (*cb)(int, float, struct S_ID)) ;
+EXPORT void f1_V_IFS_IP(int p0, float p1, struct S_IP p2,  void (*cb)(int, float, struct S_IP)) ;
+EXPORT void f1_V_IFS_FI(int p0, float p1, struct S_FI p2,  void (*cb)(int, float, struct S_FI)) ;
+EXPORT void f1_V_IFS_FF(int p0, float p1, struct S_FF p2,  void (*cb)(int, float, struct S_FF)) ;
+EXPORT void f1_V_IFS_FD(int p0, float p1, struct S_FD p2,  void (*cb)(int, float, struct S_FD)) ;
+EXPORT void f1_V_IFS_FP(int p0, float p1, struct S_FP p2,  void (*cb)(int, float, struct S_FP)) ;
+EXPORT void f1_V_IFS_DI(int p0, float p1, struct S_DI p2,  void (*cb)(int, float, struct S_DI)) ;
+EXPORT void f1_V_IFS_DF(int p0, float p1, struct S_DF p2,  void (*cb)(int, float, struct S_DF)) ;
+EXPORT void f1_V_IFS_DD(int p0, float p1, struct S_DD p2,  void (*cb)(int, float, struct S_DD)) ;
+EXPORT void f1_V_IFS_DP(int p0, float p1, struct S_DP p2,  void (*cb)(int, float, struct S_DP)) ;
+EXPORT void f1_V_IFS_PI(int p0, float p1, struct S_PI p2,  void (*cb)(int, float, struct S_PI)) ;
+EXPORT void f1_V_IFS_PF(int p0, float p1, struct S_PF p2,  void (*cb)(int, float, struct S_PF)) ;
+EXPORT void f1_V_IFS_PD(int p0, float p1, struct S_PD p2,  void (*cb)(int, float, struct S_PD)) ;
+EXPORT void f1_V_IFS_PP(int p0, float p1, struct S_PP p2,  void (*cb)(int, float, struct S_PP)) ;
+EXPORT void f1_V_IFS_III(int p0, float p1, struct S_III p2,  void (*cb)(int, float, struct S_III)) ;
+EXPORT void f1_V_IFS_IIF(int p0, float p1, struct S_IIF p2,  void (*cb)(int, float, struct S_IIF)) ;
+EXPORT void f1_V_IFS_IID(int p0, float p1, struct S_IID p2,  void (*cb)(int, float, struct S_IID)) ;
+EXPORT void f1_V_IFS_IIP(int p0, float p1, struct S_IIP p2,  void (*cb)(int, float, struct S_IIP)) ;
+EXPORT void f1_V_IFS_IFI(int p0, float p1, struct S_IFI p2,  void (*cb)(int, float, struct S_IFI)) ;
+EXPORT void f1_V_IFS_IFF(int p0, float p1, struct S_IFF p2,  void (*cb)(int, float, struct S_IFF)) ;
+EXPORT void f1_V_IFS_IFD(int p0, float p1, struct S_IFD p2,  void (*cb)(int, float, struct S_IFD)) ;
+EXPORT void f1_V_IFS_IFP(int p0, float p1, struct S_IFP p2,  void (*cb)(int, float, struct S_IFP)) ;
+EXPORT void f1_V_IFS_IDI(int p0, float p1, struct S_IDI p2,  void (*cb)(int, float, struct S_IDI)) ;
+EXPORT void f1_V_IFS_IDF(int p0, float p1, struct S_IDF p2,  void (*cb)(int, float, struct S_IDF)) ;
+EXPORT void f1_V_IFS_IDD(int p0, float p1, struct S_IDD p2,  void (*cb)(int, float, struct S_IDD)) ;
+EXPORT void f1_V_IFS_IDP(int p0, float p1, struct S_IDP p2,  void (*cb)(int, float, struct S_IDP)) ;
+EXPORT void f1_V_IFS_IPI(int p0, float p1, struct S_IPI p2,  void (*cb)(int, float, struct S_IPI)) ;
+EXPORT void f1_V_IFS_IPF(int p0, float p1, struct S_IPF p2,  void (*cb)(int, float, struct S_IPF)) ;
+EXPORT void f1_V_IFS_IPD(int p0, float p1, struct S_IPD p2,  void (*cb)(int, float, struct S_IPD)) ;
+EXPORT void f1_V_IFS_IPP(int p0, float p1, struct S_IPP p2,  void (*cb)(int, float, struct S_IPP)) ;
+EXPORT void f1_V_IFS_FII(int p0, float p1, struct S_FII p2,  void (*cb)(int, float, struct S_FII)) ;
+EXPORT void f1_V_IFS_FIF(int p0, float p1, struct S_FIF p2,  void (*cb)(int, float, struct S_FIF)) ;
+EXPORT void f1_V_IFS_FID(int p0, float p1, struct S_FID p2,  void (*cb)(int, float, struct S_FID)) ;
+EXPORT void f1_V_IFS_FIP(int p0, float p1, struct S_FIP p2,  void (*cb)(int, float, struct S_FIP)) ;
+EXPORT void f1_V_IFS_FFI(int p0, float p1, struct S_FFI p2,  void (*cb)(int, float, struct S_FFI)) ;
+EXPORT void f1_V_IFS_FFF(int p0, float p1, struct S_FFF p2,  void (*cb)(int, float, struct S_FFF)) ;
+EXPORT void f1_V_IFS_FFD(int p0, float p1, struct S_FFD p2,  void (*cb)(int, float, struct S_FFD)) ;
+EXPORT void f1_V_IFS_FFP(int p0, float p1, struct S_FFP p2,  void (*cb)(int, float, struct S_FFP)) ;
+EXPORT void f1_V_IFS_FDI(int p0, float p1, struct S_FDI p2,  void (*cb)(int, float, struct S_FDI)) ;
+EXPORT void f1_V_IFS_FDF(int p0, float p1, struct S_FDF p2,  void (*cb)(int, float, struct S_FDF)) ;
+EXPORT void f1_V_IFS_FDD(int p0, float p1, struct S_FDD p2,  void (*cb)(int, float, struct S_FDD)) ;
+EXPORT void f1_V_IFS_FDP(int p0, float p1, struct S_FDP p2,  void (*cb)(int, float, struct S_FDP)) ;
+EXPORT void f1_V_IFS_FPI(int p0, float p1, struct S_FPI p2,  void (*cb)(int, float, struct S_FPI)) ;
+EXPORT void f1_V_IFS_FPF(int p0, float p1, struct S_FPF p2,  void (*cb)(int, float, struct S_FPF)) ;
+EXPORT void f1_V_IFS_FPD(int p0, float p1, struct S_FPD p2,  void (*cb)(int, float, struct S_FPD)) ;
+EXPORT void f1_V_IFS_FPP(int p0, float p1, struct S_FPP p2,  void (*cb)(int, float, struct S_FPP)) ;
+EXPORT void f1_V_IFS_DII(int p0, float p1, struct S_DII p2,  void (*cb)(int, float, struct S_DII)) ;
+EXPORT void f1_V_IFS_DIF(int p0, float p1, struct S_DIF p2,  void (*cb)(int, float, struct S_DIF)) ;
+EXPORT void f1_V_IFS_DID(int p0, float p1, struct S_DID p2,  void (*cb)(int, float, struct S_DID)) ;
+EXPORT void f1_V_IFS_DIP(int p0, float p1, struct S_DIP p2,  void (*cb)(int, float, struct S_DIP)) ;
+EXPORT void f1_V_IFS_DFI(int p0, float p1, struct S_DFI p2,  void (*cb)(int, float, struct S_DFI)) ;
+EXPORT void f1_V_IFS_DFF(int p0, float p1, struct S_DFF p2,  void (*cb)(int, float, struct S_DFF)) ;
+EXPORT void f1_V_IFS_DFD(int p0, float p1, struct S_DFD p2,  void (*cb)(int, float, struct S_DFD)) ;
+EXPORT void f1_V_IFS_DFP(int p0, float p1, struct S_DFP p2,  void (*cb)(int, float, struct S_DFP)) ;
+EXPORT void f1_V_IFS_DDI(int p0, float p1, struct S_DDI p2,  void (*cb)(int, float, struct S_DDI)) ;
+EXPORT void f1_V_IFS_DDF(int p0, float p1, struct S_DDF p2,  void (*cb)(int, float, struct S_DDF)) ;
+EXPORT void f1_V_IFS_DDD(int p0, float p1, struct S_DDD p2,  void (*cb)(int, float, struct S_DDD)) ;
+EXPORT void f1_V_IFS_DDP(int p0, float p1, struct S_DDP p2,  void (*cb)(int, float, struct S_DDP)) ;
+EXPORT void f1_V_IFS_DPI(int p0, float p1, struct S_DPI p2,  void (*cb)(int, float, struct S_DPI)) ;
+EXPORT void f1_V_IFS_DPF(int p0, float p1, struct S_DPF p2,  void (*cb)(int, float, struct S_DPF)) ;
+EXPORT void f1_V_IFS_DPD(int p0, float p1, struct S_DPD p2,  void (*cb)(int, float, struct S_DPD)) ;
+EXPORT void f1_V_IFS_DPP(int p0, float p1, struct S_DPP p2,  void (*cb)(int, float, struct S_DPP)) ;
+EXPORT void f1_V_IFS_PII(int p0, float p1, struct S_PII p2,  void (*cb)(int, float, struct S_PII)) ;
+EXPORT void f1_V_IFS_PIF(int p0, float p1, struct S_PIF p2,  void (*cb)(int, float, struct S_PIF)) ;
+EXPORT void f1_V_IFS_PID(int p0, float p1, struct S_PID p2,  void (*cb)(int, float, struct S_PID)) ;
+EXPORT void f1_V_IFS_PIP(int p0, float p1, struct S_PIP p2,  void (*cb)(int, float, struct S_PIP)) ;
+EXPORT void f1_V_IFS_PFI(int p0, float p1, struct S_PFI p2,  void (*cb)(int, float, struct S_PFI)) ;
+EXPORT void f1_V_IFS_PFF(int p0, float p1, struct S_PFF p2,  void (*cb)(int, float, struct S_PFF)) ;
+EXPORT void f1_V_IFS_PFD(int p0, float p1, struct S_PFD p2,  void (*cb)(int, float, struct S_PFD)) ;
+EXPORT void f1_V_IFS_PFP(int p0, float p1, struct S_PFP p2,  void (*cb)(int, float, struct S_PFP)) ;
+EXPORT void f1_V_IFS_PDI(int p0, float p1, struct S_PDI p2,  void (*cb)(int, float, struct S_PDI)) ;
+EXPORT void f1_V_IFS_PDF(int p0, float p1, struct S_PDF p2,  void (*cb)(int, float, struct S_PDF)) ;
+EXPORT void f1_V_IFS_PDD(int p0, float p1, struct S_PDD p2,  void (*cb)(int, float, struct S_PDD)) ;
+EXPORT void f1_V_IFS_PDP(int p0, float p1, struct S_PDP p2,  void (*cb)(int, float, struct S_PDP)) ;
+EXPORT void f1_V_IFS_PPI(int p0, float p1, struct S_PPI p2,  void (*cb)(int, float, struct S_PPI)) ;
+EXPORT void f1_V_IFS_PPF(int p0, float p1, struct S_PPF p2,  void (*cb)(int, float, struct S_PPF)) ;
+EXPORT void f1_V_IFS_PPD(int p0, float p1, struct S_PPD p2,  void (*cb)(int, float, struct S_PPD)) ;
+EXPORT void f1_V_IFS_PPP(int p0, float p1, struct S_PPP p2,  void (*cb)(int, float, struct S_PPP)) ;
+EXPORT void f1_V_IDI_(int p0, double p1, int p2,  void (*cb)(int, double, int)) ;
+EXPORT void f1_V_IDF_(int p0, double p1, float p2,  void (*cb)(int, double, float)) ;
+EXPORT void f1_V_IDD_(int p0, double p1, double p2,  void (*cb)(int, double, double)) ;
+EXPORT void f1_V_IDP_(int p0, double p1, void* p2,  void (*cb)(int, double, void*)) ;
+EXPORT void f1_V_IDS_I(int p0, double p1, struct S_I p2,  void (*cb)(int, double, struct S_I)) ;
+EXPORT void f1_V_IDS_F(int p0, double p1, struct S_F p2,  void (*cb)(int, double, struct S_F)) ;
+EXPORT void f1_V_IDS_D(int p0, double p1, struct S_D p2,  void (*cb)(int, double, struct S_D)) ;
+EXPORT void f1_V_IDS_P(int p0, double p1, struct S_P p2,  void (*cb)(int, double, struct S_P)) ;
+EXPORT void f1_V_IDS_II(int p0, double p1, struct S_II p2,  void (*cb)(int, double, struct S_II)) ;
+EXPORT void f1_V_IDS_IF(int p0, double p1, struct S_IF p2,  void (*cb)(int, double, struct S_IF)) ;
+EXPORT void f1_V_IDS_ID(int p0, double p1, struct S_ID p2,  void (*cb)(int, double, struct S_ID)) ;
+EXPORT void f1_V_IDS_IP(int p0, double p1, struct S_IP p2,  void (*cb)(int, double, struct S_IP)) ;
+EXPORT void f1_V_IDS_FI(int p0, double p1, struct S_FI p2,  void (*cb)(int, double, struct S_FI)) ;
+EXPORT void f1_V_IDS_FF(int p0, double p1, struct S_FF p2,  void (*cb)(int, double, struct S_FF)) ;
+EXPORT void f1_V_IDS_FD(int p0, double p1, struct S_FD p2,  void (*cb)(int, double, struct S_FD)) ;
+EXPORT void f1_V_IDS_FP(int p0, double p1, struct S_FP p2,  void (*cb)(int, double, struct S_FP)) ;
+EXPORT void f1_V_IDS_DI(int p0, double p1, struct S_DI p2,  void (*cb)(int, double, struct S_DI)) ;
+EXPORT void f1_V_IDS_DF(int p0, double p1, struct S_DF p2,  void (*cb)(int, double, struct S_DF)) ;
+EXPORT void f1_V_IDS_DD(int p0, double p1, struct S_DD p2,  void (*cb)(int, double, struct S_DD)) ;
+EXPORT void f1_V_IDS_DP(int p0, double p1, struct S_DP p2,  void (*cb)(int, double, struct S_DP)) ;
+EXPORT void f1_V_IDS_PI(int p0, double p1, struct S_PI p2,  void (*cb)(int, double, struct S_PI)) ;
+EXPORT void f1_V_IDS_PF(int p0, double p1, struct S_PF p2,  void (*cb)(int, double, struct S_PF)) ;
+EXPORT void f1_V_IDS_PD(int p0, double p1, struct S_PD p2,  void (*cb)(int, double, struct S_PD)) ;
+EXPORT void f1_V_IDS_PP(int p0, double p1, struct S_PP p2,  void (*cb)(int, double, struct S_PP)) ;
+EXPORT void f1_V_IDS_III(int p0, double p1, struct S_III p2,  void (*cb)(int, double, struct S_III)) ;
+EXPORT void f1_V_IDS_IIF(int p0, double p1, struct S_IIF p2,  void (*cb)(int, double, struct S_IIF)) ;
+EXPORT void f1_V_IDS_IID(int p0, double p1, struct S_IID p2,  void (*cb)(int, double, struct S_IID)) ;
+EXPORT void f1_V_IDS_IIP(int p0, double p1, struct S_IIP p2,  void (*cb)(int, double, struct S_IIP)) ;
+EXPORT void f1_V_IDS_IFI(int p0, double p1, struct S_IFI p2,  void (*cb)(int, double, struct S_IFI)) ;
+EXPORT void f1_V_IDS_IFF(int p0, double p1, struct S_IFF p2,  void (*cb)(int, double, struct S_IFF)) ;
+EXPORT void f1_V_IDS_IFD(int p0, double p1, struct S_IFD p2,  void (*cb)(int, double, struct S_IFD)) ;
+EXPORT void f1_V_IDS_IFP(int p0, double p1, struct S_IFP p2,  void (*cb)(int, double, struct S_IFP)) ;
+EXPORT void f1_V_IDS_IDI(int p0, double p1, struct S_IDI p2,  void (*cb)(int, double, struct S_IDI)) ;
+EXPORT void f1_V_IDS_IDF(int p0, double p1, struct S_IDF p2,  void (*cb)(int, double, struct S_IDF)) ;
+EXPORT void f1_V_IDS_IDD(int p0, double p1, struct S_IDD p2,  void (*cb)(int, double, struct S_IDD)) ;
+EXPORT void f1_V_IDS_IDP(int p0, double p1, struct S_IDP p2,  void (*cb)(int, double, struct S_IDP)) ;
+EXPORT void f1_V_IDS_IPI(int p0, double p1, struct S_IPI p2,  void (*cb)(int, double, struct S_IPI)) ;
+EXPORT void f1_V_IDS_IPF(int p0, double p1, struct S_IPF p2,  void (*cb)(int, double, struct S_IPF)) ;
+EXPORT void f1_V_IDS_IPD(int p0, double p1, struct S_IPD p2,  void (*cb)(int, double, struct S_IPD)) ;
+EXPORT void f1_V_IDS_IPP(int p0, double p1, struct S_IPP p2,  void (*cb)(int, double, struct S_IPP)) ;
+EXPORT void f1_V_IDS_FII(int p0, double p1, struct S_FII p2,  void (*cb)(int, double, struct S_FII)) ;
+EXPORT void f1_V_IDS_FIF(int p0, double p1, struct S_FIF p2,  void (*cb)(int, double, struct S_FIF)) ;
+EXPORT void f1_V_IDS_FID(int p0, double p1, struct S_FID p2,  void (*cb)(int, double, struct S_FID)) ;
+EXPORT void f1_V_IDS_FIP(int p0, double p1, struct S_FIP p2,  void (*cb)(int, double, struct S_FIP)) ;
+EXPORT void f1_V_IDS_FFI(int p0, double p1, struct S_FFI p2,  void (*cb)(int, double, struct S_FFI)) ;
+EXPORT void f1_V_IDS_FFF(int p0, double p1, struct S_FFF p2,  void (*cb)(int, double, struct S_FFF)) ;
+EXPORT void f1_V_IDS_FFD(int p0, double p1, struct S_FFD p2,  void (*cb)(int, double, struct S_FFD)) ;
+EXPORT void f1_V_IDS_FFP(int p0, double p1, struct S_FFP p2,  void (*cb)(int, double, struct S_FFP)) ;
+EXPORT void f1_V_IDS_FDI(int p0, double p1, struct S_FDI p2,  void (*cb)(int, double, struct S_FDI)) ;
+EXPORT void f1_V_IDS_FDF(int p0, double p1, struct S_FDF p2,  void (*cb)(int, double, struct S_FDF)) ;
+EXPORT void f1_V_IDS_FDD(int p0, double p1, struct S_FDD p2,  void (*cb)(int, double, struct S_FDD)) ;
+EXPORT void f1_V_IDS_FDP(int p0, double p1, struct S_FDP p2,  void (*cb)(int, double, struct S_FDP)) ;
+EXPORT void f1_V_IDS_FPI(int p0, double p1, struct S_FPI p2,  void (*cb)(int, double, struct S_FPI)) ;
+EXPORT void f1_V_IDS_FPF(int p0, double p1, struct S_FPF p2,  void (*cb)(int, double, struct S_FPF)) ;
+EXPORT void f1_V_IDS_FPD(int p0, double p1, struct S_FPD p2,  void (*cb)(int, double, struct S_FPD)) ;
+EXPORT void f1_V_IDS_FPP(int p0, double p1, struct S_FPP p2,  void (*cb)(int, double, struct S_FPP)) ;
+EXPORT void f1_V_IDS_DII(int p0, double p1, struct S_DII p2,  void (*cb)(int, double, struct S_DII)) ;
+EXPORT void f1_V_IDS_DIF(int p0, double p1, struct S_DIF p2,  void (*cb)(int, double, struct S_DIF)) ;
+EXPORT void f1_V_IDS_DID(int p0, double p1, struct S_DID p2,  void (*cb)(int, double, struct S_DID)) ;
+EXPORT void f1_V_IDS_DIP(int p0, double p1, struct S_DIP p2,  void (*cb)(int, double, struct S_DIP)) ;
+EXPORT void f1_V_IDS_DFI(int p0, double p1, struct S_DFI p2,  void (*cb)(int, double, struct S_DFI)) ;
+EXPORT void f1_V_IDS_DFF(int p0, double p1, struct S_DFF p2,  void (*cb)(int, double, struct S_DFF)) ;
+EXPORT void f1_V_IDS_DFD(int p0, double p1, struct S_DFD p2,  void (*cb)(int, double, struct S_DFD)) ;
+EXPORT void f1_V_IDS_DFP(int p0, double p1, struct S_DFP p2,  void (*cb)(int, double, struct S_DFP)) ;
+EXPORT void f1_V_IDS_DDI(int p0, double p1, struct S_DDI p2,  void (*cb)(int, double, struct S_DDI)) ;
+EXPORT void f1_V_IDS_DDF(int p0, double p1, struct S_DDF p2,  void (*cb)(int, double, struct S_DDF)) ;
+EXPORT void f1_V_IDS_DDD(int p0, double p1, struct S_DDD p2,  void (*cb)(int, double, struct S_DDD)) ;
+EXPORT void f1_V_IDS_DDP(int p0, double p1, struct S_DDP p2,  void (*cb)(int, double, struct S_DDP)) ;
+EXPORT void f1_V_IDS_DPI(int p0, double p1, struct S_DPI p2,  void (*cb)(int, double, struct S_DPI)) ;
+EXPORT void f1_V_IDS_DPF(int p0, double p1, struct S_DPF p2,  void (*cb)(int, double, struct S_DPF)) ;
+EXPORT void f1_V_IDS_DPD(int p0, double p1, struct S_DPD p2,  void (*cb)(int, double, struct S_DPD)) ;
+EXPORT void f1_V_IDS_DPP(int p0, double p1, struct S_DPP p2,  void (*cb)(int, double, struct S_DPP)) ;
+EXPORT void f1_V_IDS_PII(int p0, double p1, struct S_PII p2,  void (*cb)(int, double, struct S_PII)) ;
+EXPORT void f1_V_IDS_PIF(int p0, double p1, struct S_PIF p2,  void (*cb)(int, double, struct S_PIF)) ;
+EXPORT void f1_V_IDS_PID(int p0, double p1, struct S_PID p2,  void (*cb)(int, double, struct S_PID)) ;
+EXPORT void f1_V_IDS_PIP(int p0, double p1, struct S_PIP p2,  void (*cb)(int, double, struct S_PIP)) ;
+EXPORT void f1_V_IDS_PFI(int p0, double p1, struct S_PFI p2,  void (*cb)(int, double, struct S_PFI)) ;
+EXPORT void f1_V_IDS_PFF(int p0, double p1, struct S_PFF p2,  void (*cb)(int, double, struct S_PFF)) ;
+EXPORT void f1_V_IDS_PFD(int p0, double p1, struct S_PFD p2,  void (*cb)(int, double, struct S_PFD)) ;
+EXPORT void f1_V_IDS_PFP(int p0, double p1, struct S_PFP p2,  void (*cb)(int, double, struct S_PFP)) ;
+EXPORT void f1_V_IDS_PDI(int p0, double p1, struct S_PDI p2,  void (*cb)(int, double, struct S_PDI)) ;
+EXPORT void f1_V_IDS_PDF(int p0, double p1, struct S_PDF p2,  void (*cb)(int, double, struct S_PDF)) ;
+EXPORT void f1_V_IDS_PDD(int p0, double p1, struct S_PDD p2,  void (*cb)(int, double, struct S_PDD)) ;
+EXPORT void f1_V_IDS_PDP(int p0, double p1, struct S_PDP p2,  void (*cb)(int, double, struct S_PDP)) ;
+EXPORT void f1_V_IDS_PPI(int p0, double p1, struct S_PPI p2,  void (*cb)(int, double, struct S_PPI)) ;
+EXPORT void f1_V_IDS_PPF(int p0, double p1, struct S_PPF p2,  void (*cb)(int, double, struct S_PPF)) ;
+EXPORT void f1_V_IDS_PPD(int p0, double p1, struct S_PPD p2,  void (*cb)(int, double, struct S_PPD)) ;
+EXPORT void f1_V_IDS_PPP(int p0, double p1, struct S_PPP p2,  void (*cb)(int, double, struct S_PPP)) ;
+EXPORT void f1_V_IPI_(int p0, void* p1, int p2,  void (*cb)(int, void*, int)) ;
+EXPORT void f1_V_IPF_(int p0, void* p1, float p2,  void (*cb)(int, void*, float)) ;
+EXPORT void f1_V_IPD_(int p0, void* p1, double p2,  void (*cb)(int, void*, double)) ;
+EXPORT void f1_V_IPP_(int p0, void* p1, void* p2,  void (*cb)(int, void*, void*)) ;
+EXPORT void f1_V_IPS_I(int p0, void* p1, struct S_I p2,  void (*cb)(int, void*, struct S_I)) ;
+EXPORT void f1_V_IPS_F(int p0, void* p1, struct S_F p2,  void (*cb)(int, void*, struct S_F)) ;
+EXPORT void f1_V_IPS_D(int p0, void* p1, struct S_D p2,  void (*cb)(int, void*, struct S_D)) ;
+EXPORT void f1_V_IPS_P(int p0, void* p1, struct S_P p2,  void (*cb)(int, void*, struct S_P)) ;
+EXPORT void f1_V_IPS_II(int p0, void* p1, struct S_II p2,  void (*cb)(int, void*, struct S_II)) ;
+EXPORT void f1_V_IPS_IF(int p0, void* p1, struct S_IF p2,  void (*cb)(int, void*, struct S_IF)) ;
+EXPORT void f1_V_IPS_ID(int p0, void* p1, struct S_ID p2,  void (*cb)(int, void*, struct S_ID)) ;
+EXPORT void f1_V_IPS_IP(int p0, void* p1, struct S_IP p2,  void (*cb)(int, void*, struct S_IP)) ;
+EXPORT void f1_V_IPS_FI(int p0, void* p1, struct S_FI p2,  void (*cb)(int, void*, struct S_FI)) ;
+EXPORT void f1_V_IPS_FF(int p0, void* p1, struct S_FF p2,  void (*cb)(int, void*, struct S_FF)) ;
+EXPORT void f1_V_IPS_FD(int p0, void* p1, struct S_FD p2,  void (*cb)(int, void*, struct S_FD)) ;
+EXPORT void f1_V_IPS_FP(int p0, void* p1, struct S_FP p2,  void (*cb)(int, void*, struct S_FP)) ;
+EXPORT void f1_V_IPS_DI(int p0, void* p1, struct S_DI p2,  void (*cb)(int, void*, struct S_DI)) ;
+EXPORT void f1_V_IPS_DF(int p0, void* p1, struct S_DF p2,  void (*cb)(int, void*, struct S_DF)) ;
+EXPORT void f1_V_IPS_DD(int p0, void* p1, struct S_DD p2,  void (*cb)(int, void*, struct S_DD)) ;
+EXPORT void f1_V_IPS_DP(int p0, void* p1, struct S_DP p2,  void (*cb)(int, void*, struct S_DP)) ;
+EXPORT void f1_V_IPS_PI(int p0, void* p1, struct S_PI p2,  void (*cb)(int, void*, struct S_PI)) ;
+EXPORT void f1_V_IPS_PF(int p0, void* p1, struct S_PF p2,  void (*cb)(int, void*, struct S_PF)) ;
+EXPORT void f1_V_IPS_PD(int p0, void* p1, struct S_PD p2,  void (*cb)(int, void*, struct S_PD)) ;
+EXPORT void f1_V_IPS_PP(int p0, void* p1, struct S_PP p2,  void (*cb)(int, void*, struct S_PP)) ;
+EXPORT void f1_V_IPS_III(int p0, void* p1, struct S_III p2,  void (*cb)(int, void*, struct S_III)) ;
+EXPORT void f1_V_IPS_IIF(int p0, void* p1, struct S_IIF p2,  void (*cb)(int, void*, struct S_IIF)) ;
+EXPORT void f1_V_IPS_IID(int p0, void* p1, struct S_IID p2,  void (*cb)(int, void*, struct S_IID)) ;
+EXPORT void f1_V_IPS_IIP(int p0, void* p1, struct S_IIP p2,  void (*cb)(int, void*, struct S_IIP)) ;
+EXPORT void f1_V_IPS_IFI(int p0, void* p1, struct S_IFI p2,  void (*cb)(int, void*, struct S_IFI)) ;
+EXPORT void f1_V_IPS_IFF(int p0, void* p1, struct S_IFF p2,  void (*cb)(int, void*, struct S_IFF)) ;
+EXPORT void f1_V_IPS_IFD(int p0, void* p1, struct S_IFD p2,  void (*cb)(int, void*, struct S_IFD)) ;
+EXPORT void f1_V_IPS_IFP(int p0, void* p1, struct S_IFP p2,  void (*cb)(int, void*, struct S_IFP)) ;
+EXPORT void f1_V_IPS_IDI(int p0, void* p1, struct S_IDI p2,  void (*cb)(int, void*, struct S_IDI)) ;
+EXPORT void f1_V_IPS_IDF(int p0, void* p1, struct S_IDF p2,  void (*cb)(int, void*, struct S_IDF)) ;
+EXPORT void f1_V_IPS_IDD(int p0, void* p1, struct S_IDD p2,  void (*cb)(int, void*, struct S_IDD)) ;
+EXPORT void f1_V_IPS_IDP(int p0, void* p1, struct S_IDP p2,  void (*cb)(int, void*, struct S_IDP)) ;
+EXPORT void f1_V_IPS_IPI(int p0, void* p1, struct S_IPI p2,  void (*cb)(int, void*, struct S_IPI)) ;
+EXPORT void f1_V_IPS_IPF(int p0, void* p1, struct S_IPF p2,  void (*cb)(int, void*, struct S_IPF)) ;
+EXPORT void f1_V_IPS_IPD(int p0, void* p1, struct S_IPD p2,  void (*cb)(int, void*, struct S_IPD)) ;
+EXPORT void f1_V_IPS_IPP(int p0, void* p1, struct S_IPP p2,  void (*cb)(int, void*, struct S_IPP)) ;
+EXPORT void f1_V_IPS_FII(int p0, void* p1, struct S_FII p2,  void (*cb)(int, void*, struct S_FII)) ;
+EXPORT void f1_V_IPS_FIF(int p0, void* p1, struct S_FIF p2,  void (*cb)(int, void*, struct S_FIF)) ;
+EXPORT void f1_V_IPS_FID(int p0, void* p1, struct S_FID p2,  void (*cb)(int, void*, struct S_FID)) ;
+EXPORT void f1_V_IPS_FIP(int p0, void* p1, struct S_FIP p2,  void (*cb)(int, void*, struct S_FIP)) ;
+EXPORT void f1_V_IPS_FFI(int p0, void* p1, struct S_FFI p2,  void (*cb)(int, void*, struct S_FFI)) ;
+EXPORT void f1_V_IPS_FFF(int p0, void* p1, struct S_FFF p2,  void (*cb)(int, void*, struct S_FFF)) ;
+EXPORT void f1_V_IPS_FFD(int p0, void* p1, struct S_FFD p2,  void (*cb)(int, void*, struct S_FFD)) ;
+EXPORT void f1_V_IPS_FFP(int p0, void* p1, struct S_FFP p2,  void (*cb)(int, void*, struct S_FFP)) ;
+EXPORT void f1_V_IPS_FDI(int p0, void* p1, struct S_FDI p2,  void (*cb)(int, void*, struct S_FDI)) ;
+EXPORT void f1_V_IPS_FDF(int p0, void* p1, struct S_FDF p2,  void (*cb)(int, void*, struct S_FDF)) ;
+EXPORT void f1_V_IPS_FDD(int p0, void* p1, struct S_FDD p2,  void (*cb)(int, void*, struct S_FDD)) ;
+EXPORT void f1_V_IPS_FDP(int p0, void* p1, struct S_FDP p2,  void (*cb)(int, void*, struct S_FDP)) ;
+EXPORT void f1_V_IPS_FPI(int p0, void* p1, struct S_FPI p2,  void (*cb)(int, void*, struct S_FPI)) ;
+EXPORT void f1_V_IPS_FPF(int p0, void* p1, struct S_FPF p2,  void (*cb)(int, void*, struct S_FPF)) ;
+EXPORT void f1_V_IPS_FPD(int p0, void* p1, struct S_FPD p2,  void (*cb)(int, void*, struct S_FPD)) ;
+EXPORT void f1_V_IPS_FPP(int p0, void* p1, struct S_FPP p2,  void (*cb)(int, void*, struct S_FPP)) ;
+EXPORT void f1_V_IPS_DII(int p0, void* p1, struct S_DII p2,  void (*cb)(int, void*, struct S_DII)) ;
+EXPORT void f1_V_IPS_DIF(int p0, void* p1, struct S_DIF p2,  void (*cb)(int, void*, struct S_DIF)) ;
+EXPORT void f1_V_IPS_DID(int p0, void* p1, struct S_DID p2,  void (*cb)(int, void*, struct S_DID)) ;
+EXPORT void f1_V_IPS_DIP(int p0, void* p1, struct S_DIP p2,  void (*cb)(int, void*, struct S_DIP)) ;
+EXPORT void f1_V_IPS_DFI(int p0, void* p1, struct S_DFI p2,  void (*cb)(int, void*, struct S_DFI)) ;
+EXPORT void f1_V_IPS_DFF(int p0, void* p1, struct S_DFF p2,  void (*cb)(int, void*, struct S_DFF)) ;
+EXPORT void f1_V_IPS_DFD(int p0, void* p1, struct S_DFD p2,  void (*cb)(int, void*, struct S_DFD)) ;
+EXPORT void f1_V_IPS_DFP(int p0, void* p1, struct S_DFP p2,  void (*cb)(int, void*, struct S_DFP)) ;
+EXPORT void f1_V_IPS_DDI(int p0, void* p1, struct S_DDI p2,  void (*cb)(int, void*, struct S_DDI)) ;
+EXPORT void f1_V_IPS_DDF(int p0, void* p1, struct S_DDF p2,  void (*cb)(int, void*, struct S_DDF)) ;
+EXPORT void f1_V_IPS_DDD(int p0, void* p1, struct S_DDD p2,  void (*cb)(int, void*, struct S_DDD)) ;
+EXPORT void f1_V_IPS_DDP(int p0, void* p1, struct S_DDP p2,  void (*cb)(int, void*, struct S_DDP)) ;
+EXPORT void f1_V_IPS_DPI(int p0, void* p1, struct S_DPI p2,  void (*cb)(int, void*, struct S_DPI)) ;
+EXPORT void f1_V_IPS_DPF(int p0, void* p1, struct S_DPF p2,  void (*cb)(int, void*, struct S_DPF)) ;
+EXPORT void f1_V_IPS_DPD(int p0, void* p1, struct S_DPD p2,  void (*cb)(int, void*, struct S_DPD)) ;
+EXPORT void f1_V_IPS_DPP(int p0, void* p1, struct S_DPP p2,  void (*cb)(int, void*, struct S_DPP)) ;
+EXPORT void f1_V_IPS_PII(int p0, void* p1, struct S_PII p2,  void (*cb)(int, void*, struct S_PII)) ;
+EXPORT void f1_V_IPS_PIF(int p0, void* p1, struct S_PIF p2,  void (*cb)(int, void*, struct S_PIF)) ;
+EXPORT void f1_V_IPS_PID(int p0, void* p1, struct S_PID p2,  void (*cb)(int, void*, struct S_PID)) ;
+EXPORT void f2_V_IPS_PIP(int p0, void* p1, struct S_PIP p2,  void (*cb)(int, void*, struct S_PIP)) ;
+EXPORT void f2_V_IPS_PFI(int p0, void* p1, struct S_PFI p2,  void (*cb)(int, void*, struct S_PFI)) ;
+EXPORT void f2_V_IPS_PFF(int p0, void* p1, struct S_PFF p2,  void (*cb)(int, void*, struct S_PFF)) ;
+EXPORT void f2_V_IPS_PFD(int p0, void* p1, struct S_PFD p2,  void (*cb)(int, void*, struct S_PFD)) ;
+EXPORT void f2_V_IPS_PFP(int p0, void* p1, struct S_PFP p2,  void (*cb)(int, void*, struct S_PFP)) ;
+EXPORT void f2_V_IPS_PDI(int p0, void* p1, struct S_PDI p2,  void (*cb)(int, void*, struct S_PDI)) ;
+EXPORT void f2_V_IPS_PDF(int p0, void* p1, struct S_PDF p2,  void (*cb)(int, void*, struct S_PDF)) ;
+EXPORT void f2_V_IPS_PDD(int p0, void* p1, struct S_PDD p2,  void (*cb)(int, void*, struct S_PDD)) ;
+EXPORT void f2_V_IPS_PDP(int p0, void* p1, struct S_PDP p2,  void (*cb)(int, void*, struct S_PDP)) ;
+EXPORT void f2_V_IPS_PPI(int p0, void* p1, struct S_PPI p2,  void (*cb)(int, void*, struct S_PPI)) ;
+EXPORT void f2_V_IPS_PPF(int p0, void* p1, struct S_PPF p2,  void (*cb)(int, void*, struct S_PPF)) ;
+EXPORT void f2_V_IPS_PPD(int p0, void* p1, struct S_PPD p2,  void (*cb)(int, void*, struct S_PPD)) ;
+EXPORT void f2_V_IPS_PPP(int p0, void* p1, struct S_PPP p2,  void (*cb)(int, void*, struct S_PPP)) ;
+EXPORT void f2_V_ISI_I(int p0, struct S_I p1, int p2,  void (*cb)(int, struct S_I, int)) ;
+EXPORT void f2_V_ISI_F(int p0, struct S_F p1, int p2,  void (*cb)(int, struct S_F, int)) ;
+EXPORT void f2_V_ISI_D(int p0, struct S_D p1, int p2,  void (*cb)(int, struct S_D, int)) ;
+EXPORT void f2_V_ISI_P(int p0, struct S_P p1, int p2,  void (*cb)(int, struct S_P, int)) ;
+EXPORT void f2_V_ISI_II(int p0, struct S_II p1, int p2,  void (*cb)(int, struct S_II, int)) ;
+EXPORT void f2_V_ISI_IF(int p0, struct S_IF p1, int p2,  void (*cb)(int, struct S_IF, int)) ;
+EXPORT void f2_V_ISI_ID(int p0, struct S_ID p1, int p2,  void (*cb)(int, struct S_ID, int)) ;
+EXPORT void f2_V_ISI_IP(int p0, struct S_IP p1, int p2,  void (*cb)(int, struct S_IP, int)) ;
+EXPORT void f2_V_ISI_FI(int p0, struct S_FI p1, int p2,  void (*cb)(int, struct S_FI, int)) ;
+EXPORT void f2_V_ISI_FF(int p0, struct S_FF p1, int p2,  void (*cb)(int, struct S_FF, int)) ;
+EXPORT void f2_V_ISI_FD(int p0, struct S_FD p1, int p2,  void (*cb)(int, struct S_FD, int)) ;
+EXPORT void f2_V_ISI_FP(int p0, struct S_FP p1, int p2,  void (*cb)(int, struct S_FP, int)) ;
+EXPORT void f2_V_ISI_DI(int p0, struct S_DI p1, int p2,  void (*cb)(int, struct S_DI, int)) ;
+EXPORT void f2_V_ISI_DF(int p0, struct S_DF p1, int p2,  void (*cb)(int, struct S_DF, int)) ;
+EXPORT void f2_V_ISI_DD(int p0, struct S_DD p1, int p2,  void (*cb)(int, struct S_DD, int)) ;
+EXPORT void f2_V_ISI_DP(int p0, struct S_DP p1, int p2,  void (*cb)(int, struct S_DP, int)) ;
+EXPORT void f2_V_ISI_PI(int p0, struct S_PI p1, int p2,  void (*cb)(int, struct S_PI, int)) ;
+EXPORT void f2_V_ISI_PF(int p0, struct S_PF p1, int p2,  void (*cb)(int, struct S_PF, int)) ;
+EXPORT void f2_V_ISI_PD(int p0, struct S_PD p1, int p2,  void (*cb)(int, struct S_PD, int)) ;
+EXPORT void f2_V_ISI_PP(int p0, struct S_PP p1, int p2,  void (*cb)(int, struct S_PP, int)) ;
+EXPORT void f2_V_ISI_III(int p0, struct S_III p1, int p2,  void (*cb)(int, struct S_III, int)) ;
+EXPORT void f2_V_ISI_IIF(int p0, struct S_IIF p1, int p2,  void (*cb)(int, struct S_IIF, int)) ;
+EXPORT void f2_V_ISI_IID(int p0, struct S_IID p1, int p2,  void (*cb)(int, struct S_IID, int)) ;
+EXPORT void f2_V_ISI_IIP(int p0, struct S_IIP p1, int p2,  void (*cb)(int, struct S_IIP, int)) ;
+EXPORT void f2_V_ISI_IFI(int p0, struct S_IFI p1, int p2,  void (*cb)(int, struct S_IFI, int)) ;
+EXPORT void f2_V_ISI_IFF(int p0, struct S_IFF p1, int p2,  void (*cb)(int, struct S_IFF, int)) ;
+EXPORT void f2_V_ISI_IFD(int p0, struct S_IFD p1, int p2,  void (*cb)(int, struct S_IFD, int)) ;
+EXPORT void f2_V_ISI_IFP(int p0, struct S_IFP p1, int p2,  void (*cb)(int, struct S_IFP, int)) ;
+EXPORT void f2_V_ISI_IDI(int p0, struct S_IDI p1, int p2,  void (*cb)(int, struct S_IDI, int)) ;
+EXPORT void f2_V_ISI_IDF(int p0, struct S_IDF p1, int p2,  void (*cb)(int, struct S_IDF, int)) ;
+EXPORT void f2_V_ISI_IDD(int p0, struct S_IDD p1, int p2,  void (*cb)(int, struct S_IDD, int)) ;
+EXPORT void f2_V_ISI_IDP(int p0, struct S_IDP p1, int p2,  void (*cb)(int, struct S_IDP, int)) ;
+EXPORT void f2_V_ISI_IPI(int p0, struct S_IPI p1, int p2,  void (*cb)(int, struct S_IPI, int)) ;
+EXPORT void f2_V_ISI_IPF(int p0, struct S_IPF p1, int p2,  void (*cb)(int, struct S_IPF, int)) ;
+EXPORT void f2_V_ISI_IPD(int p0, struct S_IPD p1, int p2,  void (*cb)(int, struct S_IPD, int)) ;
+EXPORT void f2_V_ISI_IPP(int p0, struct S_IPP p1, int p2,  void (*cb)(int, struct S_IPP, int)) ;
+EXPORT void f2_V_ISI_FII(int p0, struct S_FII p1, int p2,  void (*cb)(int, struct S_FII, int)) ;
+EXPORT void f2_V_ISI_FIF(int p0, struct S_FIF p1, int p2,  void (*cb)(int, struct S_FIF, int)) ;
+EXPORT void f2_V_ISI_FID(int p0, struct S_FID p1, int p2,  void (*cb)(int, struct S_FID, int)) ;
+EXPORT void f2_V_ISI_FIP(int p0, struct S_FIP p1, int p2,  void (*cb)(int, struct S_FIP, int)) ;
+EXPORT void f2_V_ISI_FFI(int p0, struct S_FFI p1, int p2,  void (*cb)(int, struct S_FFI, int)) ;
+EXPORT void f2_V_ISI_FFF(int p0, struct S_FFF p1, int p2,  void (*cb)(int, struct S_FFF, int)) ;
+EXPORT void f2_V_ISI_FFD(int p0, struct S_FFD p1, int p2,  void (*cb)(int, struct S_FFD, int)) ;
+EXPORT void f2_V_ISI_FFP(int p0, struct S_FFP p1, int p2,  void (*cb)(int, struct S_FFP, int)) ;
+EXPORT void f2_V_ISI_FDI(int p0, struct S_FDI p1, int p2,  void (*cb)(int, struct S_FDI, int)) ;
+EXPORT void f2_V_ISI_FDF(int p0, struct S_FDF p1, int p2,  void (*cb)(int, struct S_FDF, int)) ;
+EXPORT void f2_V_ISI_FDD(int p0, struct S_FDD p1, int p2,  void (*cb)(int, struct S_FDD, int)) ;
+EXPORT void f2_V_ISI_FDP(int p0, struct S_FDP p1, int p2,  void (*cb)(int, struct S_FDP, int)) ;
+EXPORT void f2_V_ISI_FPI(int p0, struct S_FPI p1, int p2,  void (*cb)(int, struct S_FPI, int)) ;
+EXPORT void f2_V_ISI_FPF(int p0, struct S_FPF p1, int p2,  void (*cb)(int, struct S_FPF, int)) ;
+EXPORT void f2_V_ISI_FPD(int p0, struct S_FPD p1, int p2,  void (*cb)(int, struct S_FPD, int)) ;
+EXPORT void f2_V_ISI_FPP(int p0, struct S_FPP p1, int p2,  void (*cb)(int, struct S_FPP, int)) ;
+EXPORT void f2_V_ISI_DII(int p0, struct S_DII p1, int p2,  void (*cb)(int, struct S_DII, int)) ;
+EXPORT void f2_V_ISI_DIF(int p0, struct S_DIF p1, int p2,  void (*cb)(int, struct S_DIF, int)) ;
+EXPORT void f2_V_ISI_DID(int p0, struct S_DID p1, int p2,  void (*cb)(int, struct S_DID, int)) ;
+EXPORT void f2_V_ISI_DIP(int p0, struct S_DIP p1, int p2,  void (*cb)(int, struct S_DIP, int)) ;
+EXPORT void f2_V_ISI_DFI(int p0, struct S_DFI p1, int p2,  void (*cb)(int, struct S_DFI, int)) ;
+EXPORT void f2_V_ISI_DFF(int p0, struct S_DFF p1, int p2,  void (*cb)(int, struct S_DFF, int)) ;
+EXPORT void f2_V_ISI_DFD(int p0, struct S_DFD p1, int p2,  void (*cb)(int, struct S_DFD, int)) ;
+EXPORT void f2_V_ISI_DFP(int p0, struct S_DFP p1, int p2,  void (*cb)(int, struct S_DFP, int)) ;
+EXPORT void f2_V_ISI_DDI(int p0, struct S_DDI p1, int p2,  void (*cb)(int, struct S_DDI, int)) ;
+EXPORT void f2_V_ISI_DDF(int p0, struct S_DDF p1, int p2,  void (*cb)(int, struct S_DDF, int)) ;
+EXPORT void f2_V_ISI_DDD(int p0, struct S_DDD p1, int p2,  void (*cb)(int, struct S_DDD, int)) ;
+EXPORT void f2_V_ISI_DDP(int p0, struct S_DDP p1, int p2,  void (*cb)(int, struct S_DDP, int)) ;
+EXPORT void f2_V_ISI_DPI(int p0, struct S_DPI p1, int p2,  void (*cb)(int, struct S_DPI, int)) ;
+EXPORT void f2_V_ISI_DPF(int p0, struct S_DPF p1, int p2,  void (*cb)(int, struct S_DPF, int)) ;
+EXPORT void f2_V_ISI_DPD(int p0, struct S_DPD p1, int p2,  void (*cb)(int, struct S_DPD, int)) ;
+EXPORT void f2_V_ISI_DPP(int p0, struct S_DPP p1, int p2,  void (*cb)(int, struct S_DPP, int)) ;
+EXPORT void f2_V_ISI_PII(int p0, struct S_PII p1, int p2,  void (*cb)(int, struct S_PII, int)) ;
+EXPORT void f2_V_ISI_PIF(int p0, struct S_PIF p1, int p2,  void (*cb)(int, struct S_PIF, int)) ;
+EXPORT void f2_V_ISI_PID(int p0, struct S_PID p1, int p2,  void (*cb)(int, struct S_PID, int)) ;
+EXPORT void f2_V_ISI_PIP(int p0, struct S_PIP p1, int p2,  void (*cb)(int, struct S_PIP, int)) ;
+EXPORT void f2_V_ISI_PFI(int p0, struct S_PFI p1, int p2,  void (*cb)(int, struct S_PFI, int)) ;
+EXPORT void f2_V_ISI_PFF(int p0, struct S_PFF p1, int p2,  void (*cb)(int, struct S_PFF, int)) ;
+EXPORT void f2_V_ISI_PFD(int p0, struct S_PFD p1, int p2,  void (*cb)(int, struct S_PFD, int)) ;
+EXPORT void f2_V_ISI_PFP(int p0, struct S_PFP p1, int p2,  void (*cb)(int, struct S_PFP, int)) ;
+EXPORT void f2_V_ISI_PDI(int p0, struct S_PDI p1, int p2,  void (*cb)(int, struct S_PDI, int)) ;
+EXPORT void f2_V_ISI_PDF(int p0, struct S_PDF p1, int p2,  void (*cb)(int, struct S_PDF, int)) ;
+EXPORT void f2_V_ISI_PDD(int p0, struct S_PDD p1, int p2,  void (*cb)(int, struct S_PDD, int)) ;
+EXPORT void f2_V_ISI_PDP(int p0, struct S_PDP p1, int p2,  void (*cb)(int, struct S_PDP, int)) ;
+EXPORT void f2_V_ISI_PPI(int p0, struct S_PPI p1, int p2,  void (*cb)(int, struct S_PPI, int)) ;
+EXPORT void f2_V_ISI_PPF(int p0, struct S_PPF p1, int p2,  void (*cb)(int, struct S_PPF, int)) ;
+EXPORT void f2_V_ISI_PPD(int p0, struct S_PPD p1, int p2,  void (*cb)(int, struct S_PPD, int)) ;
+EXPORT void f2_V_ISI_PPP(int p0, struct S_PPP p1, int p2,  void (*cb)(int, struct S_PPP, int)) ;
+EXPORT void f2_V_ISF_I(int p0, struct S_I p1, float p2,  void (*cb)(int, struct S_I, float)) ;
+EXPORT void f2_V_ISF_F(int p0, struct S_F p1, float p2,  void (*cb)(int, struct S_F, float)) ;
+EXPORT void f2_V_ISF_D(int p0, struct S_D p1, float p2,  void (*cb)(int, struct S_D, float)) ;
+EXPORT void f2_V_ISF_P(int p0, struct S_P p1, float p2,  void (*cb)(int, struct S_P, float)) ;
+EXPORT void f2_V_ISF_II(int p0, struct S_II p1, float p2,  void (*cb)(int, struct S_II, float)) ;
+EXPORT void f2_V_ISF_IF(int p0, struct S_IF p1, float p2,  void (*cb)(int, struct S_IF, float)) ;
+EXPORT void f2_V_ISF_ID(int p0, struct S_ID p1, float p2,  void (*cb)(int, struct S_ID, float)) ;
+EXPORT void f2_V_ISF_IP(int p0, struct S_IP p1, float p2,  void (*cb)(int, struct S_IP, float)) ;
+EXPORT void f2_V_ISF_FI(int p0, struct S_FI p1, float p2,  void (*cb)(int, struct S_FI, float)) ;
+EXPORT void f2_V_ISF_FF(int p0, struct S_FF p1, float p2,  void (*cb)(int, struct S_FF, float)) ;
+EXPORT void f2_V_ISF_FD(int p0, struct S_FD p1, float p2,  void (*cb)(int, struct S_FD, float)) ;
+EXPORT void f2_V_ISF_FP(int p0, struct S_FP p1, float p2,  void (*cb)(int, struct S_FP, float)) ;
+EXPORT void f2_V_ISF_DI(int p0, struct S_DI p1, float p2,  void (*cb)(int, struct S_DI, float)) ;
+EXPORT void f2_V_ISF_DF(int p0, struct S_DF p1, float p2,  void (*cb)(int, struct S_DF, float)) ;
+EXPORT void f2_V_ISF_DD(int p0, struct S_DD p1, float p2,  void (*cb)(int, struct S_DD, float)) ;
+EXPORT void f2_V_ISF_DP(int p0, struct S_DP p1, float p2,  void (*cb)(int, struct S_DP, float)) ;
+EXPORT void f2_V_ISF_PI(int p0, struct S_PI p1, float p2,  void (*cb)(int, struct S_PI, float)) ;
+EXPORT void f2_V_ISF_PF(int p0, struct S_PF p1, float p2,  void (*cb)(int, struct S_PF, float)) ;
+EXPORT void f2_V_ISF_PD(int p0, struct S_PD p1, float p2,  void (*cb)(int, struct S_PD, float)) ;
+EXPORT void f2_V_ISF_PP(int p0, struct S_PP p1, float p2,  void (*cb)(int, struct S_PP, float)) ;
+EXPORT void f2_V_ISF_III(int p0, struct S_III p1, float p2,  void (*cb)(int, struct S_III, float)) ;
+EXPORT void f2_V_ISF_IIF(int p0, struct S_IIF p1, float p2,  void (*cb)(int, struct S_IIF, float)) ;
+EXPORT void f2_V_ISF_IID(int p0, struct S_IID p1, float p2,  void (*cb)(int, struct S_IID, float)) ;
+EXPORT void f2_V_ISF_IIP(int p0, struct S_IIP p1, float p2,  void (*cb)(int, struct S_IIP, float)) ;
+EXPORT void f2_V_ISF_IFI(int p0, struct S_IFI p1, float p2,  void (*cb)(int, struct S_IFI, float)) ;
+EXPORT void f2_V_ISF_IFF(int p0, struct S_IFF p1, float p2,  void (*cb)(int, struct S_IFF, float)) ;
+EXPORT void f2_V_ISF_IFD(int p0, struct S_IFD p1, float p2,  void (*cb)(int, struct S_IFD, float)) ;
+EXPORT void f2_V_ISF_IFP(int p0, struct S_IFP p1, float p2,  void (*cb)(int, struct S_IFP, float)) ;
+EXPORT void f2_V_ISF_IDI(int p0, struct S_IDI p1, float p2,  void (*cb)(int, struct S_IDI, float)) ;
+EXPORT void f2_V_ISF_IDF(int p0, struct S_IDF p1, float p2,  void (*cb)(int, struct S_IDF, float)) ;
+EXPORT void f2_V_ISF_IDD(int p0, struct S_IDD p1, float p2,  void (*cb)(int, struct S_IDD, float)) ;
+EXPORT void f2_V_ISF_IDP(int p0, struct S_IDP p1, float p2,  void (*cb)(int, struct S_IDP, float)) ;
+EXPORT void f2_V_ISF_IPI(int p0, struct S_IPI p1, float p2,  void (*cb)(int, struct S_IPI, float)) ;
+EXPORT void f2_V_ISF_IPF(int p0, struct S_IPF p1, float p2,  void (*cb)(int, struct S_IPF, float)) ;
+EXPORT void f2_V_ISF_IPD(int p0, struct S_IPD p1, float p2,  void (*cb)(int, struct S_IPD, float)) ;
+EXPORT void f2_V_ISF_IPP(int p0, struct S_IPP p1, float p2,  void (*cb)(int, struct S_IPP, float)) ;
+EXPORT void f2_V_ISF_FII(int p0, struct S_FII p1, float p2,  void (*cb)(int, struct S_FII, float)) ;
+EXPORT void f2_V_ISF_FIF(int p0, struct S_FIF p1, float p2,  void (*cb)(int, struct S_FIF, float)) ;
+EXPORT void f2_V_ISF_FID(int p0, struct S_FID p1, float p2,  void (*cb)(int, struct S_FID, float)) ;
+EXPORT void f2_V_ISF_FIP(int p0, struct S_FIP p1, float p2,  void (*cb)(int, struct S_FIP, float)) ;
+EXPORT void f2_V_ISF_FFI(int p0, struct S_FFI p1, float p2,  void (*cb)(int, struct S_FFI, float)) ;
+EXPORT void f2_V_ISF_FFF(int p0, struct S_FFF p1, float p2,  void (*cb)(int, struct S_FFF, float)) ;
+EXPORT void f2_V_ISF_FFD(int p0, struct S_FFD p1, float p2,  void (*cb)(int, struct S_FFD, float)) ;
+EXPORT void f2_V_ISF_FFP(int p0, struct S_FFP p1, float p2,  void (*cb)(int, struct S_FFP, float)) ;
+EXPORT void f2_V_ISF_FDI(int p0, struct S_FDI p1, float p2,  void (*cb)(int, struct S_FDI, float)) ;
+EXPORT void f2_V_ISF_FDF(int p0, struct S_FDF p1, float p2,  void (*cb)(int, struct S_FDF, float)) ;
+EXPORT void f2_V_ISF_FDD(int p0, struct S_FDD p1, float p2,  void (*cb)(int, struct S_FDD, float)) ;
+EXPORT void f2_V_ISF_FDP(int p0, struct S_FDP p1, float p2,  void (*cb)(int, struct S_FDP, float)) ;
+EXPORT void f2_V_ISF_FPI(int p0, struct S_FPI p1, float p2,  void (*cb)(int, struct S_FPI, float)) ;
+EXPORT void f2_V_ISF_FPF(int p0, struct S_FPF p1, float p2,  void (*cb)(int, struct S_FPF, float)) ;
+EXPORT void f2_V_ISF_FPD(int p0, struct S_FPD p1, float p2,  void (*cb)(int, struct S_FPD, float)) ;
+EXPORT void f2_V_ISF_FPP(int p0, struct S_FPP p1, float p2,  void (*cb)(int, struct S_FPP, float)) ;
+EXPORT void f2_V_ISF_DII(int p0, struct S_DII p1, float p2,  void (*cb)(int, struct S_DII, float)) ;
+EXPORT void f2_V_ISF_DIF(int p0, struct S_DIF p1, float p2,  void (*cb)(int, struct S_DIF, float)) ;
+EXPORT void f2_V_ISF_DID(int p0, struct S_DID p1, float p2,  void (*cb)(int, struct S_DID, float)) ;
+EXPORT void f2_V_ISF_DIP(int p0, struct S_DIP p1, float p2,  void (*cb)(int, struct S_DIP, float)) ;
+EXPORT void f2_V_ISF_DFI(int p0, struct S_DFI p1, float p2,  void (*cb)(int, struct S_DFI, float)) ;
+EXPORT void f2_V_ISF_DFF(int p0, struct S_DFF p1, float p2,  void (*cb)(int, struct S_DFF, float)) ;
+EXPORT void f2_V_ISF_DFD(int p0, struct S_DFD p1, float p2,  void (*cb)(int, struct S_DFD, float)) ;
+EXPORT void f2_V_ISF_DFP(int p0, struct S_DFP p1, float p2,  void (*cb)(int, struct S_DFP, float)) ;
+EXPORT void f2_V_ISF_DDI(int p0, struct S_DDI p1, float p2,  void (*cb)(int, struct S_DDI, float)) ;
+EXPORT void f2_V_ISF_DDF(int p0, struct S_DDF p1, float p2,  void (*cb)(int, struct S_DDF, float)) ;
+EXPORT void f2_V_ISF_DDD(int p0, struct S_DDD p1, float p2,  void (*cb)(int, struct S_DDD, float)) ;
+EXPORT void f2_V_ISF_DDP(int p0, struct S_DDP p1, float p2,  void (*cb)(int, struct S_DDP, float)) ;
+EXPORT void f2_V_ISF_DPI(int p0, struct S_DPI p1, float p2,  void (*cb)(int, struct S_DPI, float)) ;
+EXPORT void f2_V_ISF_DPF(int p0, struct S_DPF p1, float p2,  void (*cb)(int, struct S_DPF, float)) ;
+EXPORT void f2_V_ISF_DPD(int p0, struct S_DPD p1, float p2,  void (*cb)(int, struct S_DPD, float)) ;
+EXPORT void f2_V_ISF_DPP(int p0, struct S_DPP p1, float p2,  void (*cb)(int, struct S_DPP, float)) ;
+EXPORT void f2_V_ISF_PII(int p0, struct S_PII p1, float p2,  void (*cb)(int, struct S_PII, float)) ;
+EXPORT void f2_V_ISF_PIF(int p0, struct S_PIF p1, float p2,  void (*cb)(int, struct S_PIF, float)) ;
+EXPORT void f2_V_ISF_PID(int p0, struct S_PID p1, float p2,  void (*cb)(int, struct S_PID, float)) ;
+EXPORT void f2_V_ISF_PIP(int p0, struct S_PIP p1, float p2,  void (*cb)(int, struct S_PIP, float)) ;
+EXPORT void f2_V_ISF_PFI(int p0, struct S_PFI p1, float p2,  void (*cb)(int, struct S_PFI, float)) ;
+EXPORT void f2_V_ISF_PFF(int p0, struct S_PFF p1, float p2,  void (*cb)(int, struct S_PFF, float)) ;
+EXPORT void f2_V_ISF_PFD(int p0, struct S_PFD p1, float p2,  void (*cb)(int, struct S_PFD, float)) ;
+EXPORT void f2_V_ISF_PFP(int p0, struct S_PFP p1, float p2,  void (*cb)(int, struct S_PFP, float)) ;
+EXPORT void f2_V_ISF_PDI(int p0, struct S_PDI p1, float p2,  void (*cb)(int, struct S_PDI, float)) ;
+EXPORT void f2_V_ISF_PDF(int p0, struct S_PDF p1, float p2,  void (*cb)(int, struct S_PDF, float)) ;
+EXPORT void f2_V_ISF_PDD(int p0, struct S_PDD p1, float p2,  void (*cb)(int, struct S_PDD, float)) ;
+EXPORT void f2_V_ISF_PDP(int p0, struct S_PDP p1, float p2,  void (*cb)(int, struct S_PDP, float)) ;
+EXPORT void f2_V_ISF_PPI(int p0, struct S_PPI p1, float p2,  void (*cb)(int, struct S_PPI, float)) ;
+EXPORT void f2_V_ISF_PPF(int p0, struct S_PPF p1, float p2,  void (*cb)(int, struct S_PPF, float)) ;
+EXPORT void f2_V_ISF_PPD(int p0, struct S_PPD p1, float p2,  void (*cb)(int, struct S_PPD, float)) ;
+EXPORT void f2_V_ISF_PPP(int p0, struct S_PPP p1, float p2,  void (*cb)(int, struct S_PPP, float)) ;
+EXPORT void f2_V_ISD_I(int p0, struct S_I p1, double p2,  void (*cb)(int, struct S_I, double)) ;
+EXPORT void f2_V_ISD_F(int p0, struct S_F p1, double p2,  void (*cb)(int, struct S_F, double)) ;
+EXPORT void f2_V_ISD_D(int p0, struct S_D p1, double p2,  void (*cb)(int, struct S_D, double)) ;
+EXPORT void f2_V_ISD_P(int p0, struct S_P p1, double p2,  void (*cb)(int, struct S_P, double)) ;
+EXPORT void f2_V_ISD_II(int p0, struct S_II p1, double p2,  void (*cb)(int, struct S_II, double)) ;
+EXPORT void f2_V_ISD_IF(int p0, struct S_IF p1, double p2,  void (*cb)(int, struct S_IF, double)) ;
+EXPORT void f2_V_ISD_ID(int p0, struct S_ID p1, double p2,  void (*cb)(int, struct S_ID, double)) ;
+EXPORT void f2_V_ISD_IP(int p0, struct S_IP p1, double p2,  void (*cb)(int, struct S_IP, double)) ;
+EXPORT void f2_V_ISD_FI(int p0, struct S_FI p1, double p2,  void (*cb)(int, struct S_FI, double)) ;
+EXPORT void f2_V_ISD_FF(int p0, struct S_FF p1, double p2,  void (*cb)(int, struct S_FF, double)) ;
+EXPORT void f2_V_ISD_FD(int p0, struct S_FD p1, double p2,  void (*cb)(int, struct S_FD, double)) ;
+EXPORT void f2_V_ISD_FP(int p0, struct S_FP p1, double p2,  void (*cb)(int, struct S_FP, double)) ;
+EXPORT void f2_V_ISD_DI(int p0, struct S_DI p1, double p2,  void (*cb)(int, struct S_DI, double)) ;
+EXPORT void f2_V_ISD_DF(int p0, struct S_DF p1, double p2,  void (*cb)(int, struct S_DF, double)) ;
+EXPORT void f2_V_ISD_DD(int p0, struct S_DD p1, double p2,  void (*cb)(int, struct S_DD, double)) ;
+EXPORT void f2_V_ISD_DP(int p0, struct S_DP p1, double p2,  void (*cb)(int, struct S_DP, double)) ;
+EXPORT void f2_V_ISD_PI(int p0, struct S_PI p1, double p2,  void (*cb)(int, struct S_PI, double)) ;
+EXPORT void f2_V_ISD_PF(int p0, struct S_PF p1, double p2,  void (*cb)(int, struct S_PF, double)) ;
+EXPORT void f2_V_ISD_PD(int p0, struct S_PD p1, double p2,  void (*cb)(int, struct S_PD, double)) ;
+EXPORT void f2_V_ISD_PP(int p0, struct S_PP p1, double p2,  void (*cb)(int, struct S_PP, double)) ;
+EXPORT void f2_V_ISD_III(int p0, struct S_III p1, double p2,  void (*cb)(int, struct S_III, double)) ;
+EXPORT void f2_V_ISD_IIF(int p0, struct S_IIF p1, double p2,  void (*cb)(int, struct S_IIF, double)) ;
+EXPORT void f2_V_ISD_IID(int p0, struct S_IID p1, double p2,  void (*cb)(int, struct S_IID, double)) ;
+EXPORT void f2_V_ISD_IIP(int p0, struct S_IIP p1, double p2,  void (*cb)(int, struct S_IIP, double)) ;
+EXPORT void f2_V_ISD_IFI(int p0, struct S_IFI p1, double p2,  void (*cb)(int, struct S_IFI, double)) ;
+EXPORT void f2_V_ISD_IFF(int p0, struct S_IFF p1, double p2,  void (*cb)(int, struct S_IFF, double)) ;
+EXPORT void f2_V_ISD_IFD(int p0, struct S_IFD p1, double p2,  void (*cb)(int, struct S_IFD, double)) ;
+EXPORT void f2_V_ISD_IFP(int p0, struct S_IFP p1, double p2,  void (*cb)(int, struct S_IFP, double)) ;
+EXPORT void f2_V_ISD_IDI(int p0, struct S_IDI p1, double p2,  void (*cb)(int, struct S_IDI, double)) ;
+EXPORT void f2_V_ISD_IDF(int p0, struct S_IDF p1, double p2,  void (*cb)(int, struct S_IDF, double)) ;
+EXPORT void f2_V_ISD_IDD(int p0, struct S_IDD p1, double p2,  void (*cb)(int, struct S_IDD, double)) ;
+EXPORT void f2_V_ISD_IDP(int p0, struct S_IDP p1, double p2,  void (*cb)(int, struct S_IDP, double)) ;
+EXPORT void f2_V_ISD_IPI(int p0, struct S_IPI p1, double p2,  void (*cb)(int, struct S_IPI, double)) ;
+EXPORT void f2_V_ISD_IPF(int p0, struct S_IPF p1, double p2,  void (*cb)(int, struct S_IPF, double)) ;
+EXPORT void f2_V_ISD_IPD(int p0, struct S_IPD p1, double p2,  void (*cb)(int, struct S_IPD, double)) ;
+EXPORT void f2_V_ISD_IPP(int p0, struct S_IPP p1, double p2,  void (*cb)(int, struct S_IPP, double)) ;
+EXPORT void f2_V_ISD_FII(int p0, struct S_FII p1, double p2,  void (*cb)(int, struct S_FII, double)) ;
+EXPORT void f2_V_ISD_FIF(int p0, struct S_FIF p1, double p2,  void (*cb)(int, struct S_FIF, double)) ;
+EXPORT void f2_V_ISD_FID(int p0, struct S_FID p1, double p2,  void (*cb)(int, struct S_FID, double)) ;
+EXPORT void f2_V_ISD_FIP(int p0, struct S_FIP p1, double p2,  void (*cb)(int, struct S_FIP, double)) ;
+EXPORT void f2_V_ISD_FFI(int p0, struct S_FFI p1, double p2,  void (*cb)(int, struct S_FFI, double)) ;
+EXPORT void f2_V_ISD_FFF(int p0, struct S_FFF p1, double p2,  void (*cb)(int, struct S_FFF, double)) ;
+EXPORT void f2_V_ISD_FFD(int p0, struct S_FFD p1, double p2,  void (*cb)(int, struct S_FFD, double)) ;
+EXPORT void f2_V_ISD_FFP(int p0, struct S_FFP p1, double p2,  void (*cb)(int, struct S_FFP, double)) ;
+EXPORT void f2_V_ISD_FDI(int p0, struct S_FDI p1, double p2,  void (*cb)(int, struct S_FDI, double)) ;
+EXPORT void f2_V_ISD_FDF(int p0, struct S_FDF p1, double p2,  void (*cb)(int, struct S_FDF, double)) ;
+EXPORT void f2_V_ISD_FDD(int p0, struct S_FDD p1, double p2,  void (*cb)(int, struct S_FDD, double)) ;
+EXPORT void f2_V_ISD_FDP(int p0, struct S_FDP p1, double p2,  void (*cb)(int, struct S_FDP, double)) ;
+EXPORT void f2_V_ISD_FPI(int p0, struct S_FPI p1, double p2,  void (*cb)(int, struct S_FPI, double)) ;
+EXPORT void f2_V_ISD_FPF(int p0, struct S_FPF p1, double p2,  void (*cb)(int, struct S_FPF, double)) ;
+EXPORT void f2_V_ISD_FPD(int p0, struct S_FPD p1, double p2,  void (*cb)(int, struct S_FPD, double)) ;
+EXPORT void f2_V_ISD_FPP(int p0, struct S_FPP p1, double p2,  void (*cb)(int, struct S_FPP, double)) ;
+EXPORT void f2_V_ISD_DII(int p0, struct S_DII p1, double p2,  void (*cb)(int, struct S_DII, double)) ;
+EXPORT void f2_V_ISD_DIF(int p0, struct S_DIF p1, double p2,  void (*cb)(int, struct S_DIF, double)) ;
+EXPORT void f2_V_ISD_DID(int p0, struct S_DID p1, double p2,  void (*cb)(int, struct S_DID, double)) ;
+EXPORT void f2_V_ISD_DIP(int p0, struct S_DIP p1, double p2,  void (*cb)(int, struct S_DIP, double)) ;
+EXPORT void f2_V_ISD_DFI(int p0, struct S_DFI p1, double p2,  void (*cb)(int, struct S_DFI, double)) ;
+EXPORT void f2_V_ISD_DFF(int p0, struct S_DFF p1, double p2,  void (*cb)(int, struct S_DFF, double)) ;
+EXPORT void f2_V_ISD_DFD(int p0, struct S_DFD p1, double p2,  void (*cb)(int, struct S_DFD, double)) ;
+EXPORT void f2_V_ISD_DFP(int p0, struct S_DFP p1, double p2,  void (*cb)(int, struct S_DFP, double)) ;
+EXPORT void f2_V_ISD_DDI(int p0, struct S_DDI p1, double p2,  void (*cb)(int, struct S_DDI, double)) ;
+EXPORT void f2_V_ISD_DDF(int p0, struct S_DDF p1, double p2,  void (*cb)(int, struct S_DDF, double)) ;
+EXPORT void f2_V_ISD_DDD(int p0, struct S_DDD p1, double p2,  void (*cb)(int, struct S_DDD, double)) ;
+EXPORT void f2_V_ISD_DDP(int p0, struct S_DDP p1, double p2,  void (*cb)(int, struct S_DDP, double)) ;
+EXPORT void f2_V_ISD_DPI(int p0, struct S_DPI p1, double p2,  void (*cb)(int, struct S_DPI, double)) ;
+EXPORT void f2_V_ISD_DPF(int p0, struct S_DPF p1, double p2,  void (*cb)(int, struct S_DPF, double)) ;
+EXPORT void f2_V_ISD_DPD(int p0, struct S_DPD p1, double p2,  void (*cb)(int, struct S_DPD, double)) ;
+EXPORT void f2_V_ISD_DPP(int p0, struct S_DPP p1, double p2,  void (*cb)(int, struct S_DPP, double)) ;
+EXPORT void f2_V_ISD_PII(int p0, struct S_PII p1, double p2,  void (*cb)(int, struct S_PII, double)) ;
+EXPORT void f2_V_ISD_PIF(int p0, struct S_PIF p1, double p2,  void (*cb)(int, struct S_PIF, double)) ;
+EXPORT void f2_V_ISD_PID(int p0, struct S_PID p1, double p2,  void (*cb)(int, struct S_PID, double)) ;
+EXPORT void f2_V_ISD_PIP(int p0, struct S_PIP p1, double p2,  void (*cb)(int, struct S_PIP, double)) ;
+EXPORT void f2_V_ISD_PFI(int p0, struct S_PFI p1, double p2,  void (*cb)(int, struct S_PFI, double)) ;
+EXPORT void f2_V_ISD_PFF(int p0, struct S_PFF p1, double p2,  void (*cb)(int, struct S_PFF, double)) ;
+EXPORT void f2_V_ISD_PFD(int p0, struct S_PFD p1, double p2,  void (*cb)(int, struct S_PFD, double)) ;
+EXPORT void f2_V_ISD_PFP(int p0, struct S_PFP p1, double p2,  void (*cb)(int, struct S_PFP, double)) ;
+EXPORT void f2_V_ISD_PDI(int p0, struct S_PDI p1, double p2,  void (*cb)(int, struct S_PDI, double)) ;
+EXPORT void f2_V_ISD_PDF(int p0, struct S_PDF p1, double p2,  void (*cb)(int, struct S_PDF, double)) ;
+EXPORT void f2_V_ISD_PDD(int p0, struct S_PDD p1, double p2,  void (*cb)(int, struct S_PDD, double)) ;
+EXPORT void f2_V_ISD_PDP(int p0, struct S_PDP p1, double p2,  void (*cb)(int, struct S_PDP, double)) ;
+EXPORT void f2_V_ISD_PPI(int p0, struct S_PPI p1, double p2,  void (*cb)(int, struct S_PPI, double)) ;
+EXPORT void f2_V_ISD_PPF(int p0, struct S_PPF p1, double p2,  void (*cb)(int, struct S_PPF, double)) ;
+EXPORT void f2_V_ISD_PPD(int p0, struct S_PPD p1, double p2,  void (*cb)(int, struct S_PPD, double)) ;
+EXPORT void f2_V_ISD_PPP(int p0, struct S_PPP p1, double p2,  void (*cb)(int, struct S_PPP, double)) ;
+EXPORT void f2_V_ISP_I(int p0, struct S_I p1, void* p2,  void (*cb)(int, struct S_I, void*)) ;
+EXPORT void f2_V_ISP_F(int p0, struct S_F p1, void* p2,  void (*cb)(int, struct S_F, void*)) ;
+EXPORT void f2_V_ISP_D(int p0, struct S_D p1, void* p2,  void (*cb)(int, struct S_D, void*)) ;
+EXPORT void f2_V_ISP_P(int p0, struct S_P p1, void* p2,  void (*cb)(int, struct S_P, void*)) ;
+EXPORT void f2_V_ISP_II(int p0, struct S_II p1, void* p2,  void (*cb)(int, struct S_II, void*)) ;
+EXPORT void f2_V_ISP_IF(int p0, struct S_IF p1, void* p2,  void (*cb)(int, struct S_IF, void*)) ;
+EXPORT void f2_V_ISP_ID(int p0, struct S_ID p1, void* p2,  void (*cb)(int, struct S_ID, void*)) ;
+EXPORT void f2_V_ISP_IP(int p0, struct S_IP p1, void* p2,  void (*cb)(int, struct S_IP, void*)) ;
+EXPORT void f2_V_ISP_FI(int p0, struct S_FI p1, void* p2,  void (*cb)(int, struct S_FI, void*)) ;
+EXPORT void f2_V_ISP_FF(int p0, struct S_FF p1, void* p2,  void (*cb)(int, struct S_FF, void*)) ;
+EXPORT void f2_V_ISP_FD(int p0, struct S_FD p1, void* p2,  void (*cb)(int, struct S_FD, void*)) ;
+EXPORT void f2_V_ISP_FP(int p0, struct S_FP p1, void* p2,  void (*cb)(int, struct S_FP, void*)) ;
+EXPORT void f2_V_ISP_DI(int p0, struct S_DI p1, void* p2,  void (*cb)(int, struct S_DI, void*)) ;
+EXPORT void f2_V_ISP_DF(int p0, struct S_DF p1, void* p2,  void (*cb)(int, struct S_DF, void*)) ;
+EXPORT void f2_V_ISP_DD(int p0, struct S_DD p1, void* p2,  void (*cb)(int, struct S_DD, void*)) ;
+EXPORT void f2_V_ISP_DP(int p0, struct S_DP p1, void* p2,  void (*cb)(int, struct S_DP, void*)) ;
+EXPORT void f2_V_ISP_PI(int p0, struct S_PI p1, void* p2,  void (*cb)(int, struct S_PI, void*)) ;
+EXPORT void f2_V_ISP_PF(int p0, struct S_PF p1, void* p2,  void (*cb)(int, struct S_PF, void*)) ;
+EXPORT void f2_V_ISP_PD(int p0, struct S_PD p1, void* p2,  void (*cb)(int, struct S_PD, void*)) ;
+EXPORT void f2_V_ISP_PP(int p0, struct S_PP p1, void* p2,  void (*cb)(int, struct S_PP, void*)) ;
+EXPORT void f2_V_ISP_III(int p0, struct S_III p1, void* p2,  void (*cb)(int, struct S_III, void*)) ;
+EXPORT void f2_V_ISP_IIF(int p0, struct S_IIF p1, void* p2,  void (*cb)(int, struct S_IIF, void*)) ;
+EXPORT void f2_V_ISP_IID(int p0, struct S_IID p1, void* p2,  void (*cb)(int, struct S_IID, void*)) ;
+EXPORT void f2_V_ISP_IIP(int p0, struct S_IIP p1, void* p2,  void (*cb)(int, struct S_IIP, void*)) ;
+EXPORT void f2_V_ISP_IFI(int p0, struct S_IFI p1, void* p2,  void (*cb)(int, struct S_IFI, void*)) ;
+EXPORT void f2_V_ISP_IFF(int p0, struct S_IFF p1, void* p2,  void (*cb)(int, struct S_IFF, void*)) ;
+EXPORT void f2_V_ISP_IFD(int p0, struct S_IFD p1, void* p2,  void (*cb)(int, struct S_IFD, void*)) ;
+EXPORT void f2_V_ISP_IFP(int p0, struct S_IFP p1, void* p2,  void (*cb)(int, struct S_IFP, void*)) ;
+EXPORT void f2_V_ISP_IDI(int p0, struct S_IDI p1, void* p2,  void (*cb)(int, struct S_IDI, void*)) ;
+EXPORT void f2_V_ISP_IDF(int p0, struct S_IDF p1, void* p2,  void (*cb)(int, struct S_IDF, void*)) ;
+EXPORT void f2_V_ISP_IDD(int p0, struct S_IDD p1, void* p2,  void (*cb)(int, struct S_IDD, void*)) ;
+EXPORT void f2_V_ISP_IDP(int p0, struct S_IDP p1, void* p2,  void (*cb)(int, struct S_IDP, void*)) ;
+EXPORT void f2_V_ISP_IPI(int p0, struct S_IPI p1, void* p2,  void (*cb)(int, struct S_IPI, void*)) ;
+EXPORT void f2_V_ISP_IPF(int p0, struct S_IPF p1, void* p2,  void (*cb)(int, struct S_IPF, void*)) ;
+EXPORT void f2_V_ISP_IPD(int p0, struct S_IPD p1, void* p2,  void (*cb)(int, struct S_IPD, void*)) ;
+EXPORT void f2_V_ISP_IPP(int p0, struct S_IPP p1, void* p2,  void (*cb)(int, struct S_IPP, void*)) ;
+EXPORT void f2_V_ISP_FII(int p0, struct S_FII p1, void* p2,  void (*cb)(int, struct S_FII, void*)) ;
+EXPORT void f2_V_ISP_FIF(int p0, struct S_FIF p1, void* p2,  void (*cb)(int, struct S_FIF, void*)) ;
+EXPORT void f2_V_ISP_FID(int p0, struct S_FID p1, void* p2,  void (*cb)(int, struct S_FID, void*)) ;
+EXPORT void f2_V_ISP_FIP(int p0, struct S_FIP p1, void* p2,  void (*cb)(int, struct S_FIP, void*)) ;
+EXPORT void f2_V_ISP_FFI(int p0, struct S_FFI p1, void* p2,  void (*cb)(int, struct S_FFI, void*)) ;
+EXPORT void f2_V_ISP_FFF(int p0, struct S_FFF p1, void* p2,  void (*cb)(int, struct S_FFF, void*)) ;
+EXPORT void f2_V_ISP_FFD(int p0, struct S_FFD p1, void* p2,  void (*cb)(int, struct S_FFD, void*)) ;
+EXPORT void f2_V_ISP_FFP(int p0, struct S_FFP p1, void* p2,  void (*cb)(int, struct S_FFP, void*)) ;
+EXPORT void f2_V_ISP_FDI(int p0, struct S_FDI p1, void* p2,  void (*cb)(int, struct S_FDI, void*)) ;
+EXPORT void f2_V_ISP_FDF(int p0, struct S_FDF p1, void* p2,  void (*cb)(int, struct S_FDF, void*)) ;
+EXPORT void f2_V_ISP_FDD(int p0, struct S_FDD p1, void* p2,  void (*cb)(int, struct S_FDD, void*)) ;
+EXPORT void f2_V_ISP_FDP(int p0, struct S_FDP p1, void* p2,  void (*cb)(int, struct S_FDP, void*)) ;
+EXPORT void f2_V_ISP_FPI(int p0, struct S_FPI p1, void* p2,  void (*cb)(int, struct S_FPI, void*)) ;
+EXPORT void f2_V_ISP_FPF(int p0, struct S_FPF p1, void* p2,  void (*cb)(int, struct S_FPF, void*)) ;
+EXPORT void f2_V_ISP_FPD(int p0, struct S_FPD p1, void* p2,  void (*cb)(int, struct S_FPD, void*)) ;
+EXPORT void f2_V_ISP_FPP(int p0, struct S_FPP p1, void* p2,  void (*cb)(int, struct S_FPP, void*)) ;
+EXPORT void f2_V_ISP_DII(int p0, struct S_DII p1, void* p2,  void (*cb)(int, struct S_DII, void*)) ;
+EXPORT void f2_V_ISP_DIF(int p0, struct S_DIF p1, void* p2,  void (*cb)(int, struct S_DIF, void*)) ;
+EXPORT void f2_V_ISP_DID(int p0, struct S_DID p1, void* p2,  void (*cb)(int, struct S_DID, void*)) ;
+EXPORT void f2_V_ISP_DIP(int p0, struct S_DIP p1, void* p2,  void (*cb)(int, struct S_DIP, void*)) ;
+EXPORT void f2_V_ISP_DFI(int p0, struct S_DFI p1, void* p2,  void (*cb)(int, struct S_DFI, void*)) ;
+EXPORT void f2_V_ISP_DFF(int p0, struct S_DFF p1, void* p2,  void (*cb)(int, struct S_DFF, void*)) ;
+EXPORT void f2_V_ISP_DFD(int p0, struct S_DFD p1, void* p2,  void (*cb)(int, struct S_DFD, void*)) ;
+EXPORT void f2_V_ISP_DFP(int p0, struct S_DFP p1, void* p2,  void (*cb)(int, struct S_DFP, void*)) ;
+EXPORT void f2_V_ISP_DDI(int p0, struct S_DDI p1, void* p2,  void (*cb)(int, struct S_DDI, void*)) ;
+EXPORT void f2_V_ISP_DDF(int p0, struct S_DDF p1, void* p2,  void (*cb)(int, struct S_DDF, void*)) ;
+EXPORT void f2_V_ISP_DDD(int p0, struct S_DDD p1, void* p2,  void (*cb)(int, struct S_DDD, void*)) ;
+EXPORT void f2_V_ISP_DDP(int p0, struct S_DDP p1, void* p2,  void (*cb)(int, struct S_DDP, void*)) ;
+EXPORT void f2_V_ISP_DPI(int p0, struct S_DPI p1, void* p2,  void (*cb)(int, struct S_DPI, void*)) ;
+EXPORT void f2_V_ISP_DPF(int p0, struct S_DPF p1, void* p2,  void (*cb)(int, struct S_DPF, void*)) ;
+EXPORT void f2_V_ISP_DPD(int p0, struct S_DPD p1, void* p2,  void (*cb)(int, struct S_DPD, void*)) ;
+EXPORT void f2_V_ISP_DPP(int p0, struct S_DPP p1, void* p2,  void (*cb)(int, struct S_DPP, void*)) ;
+EXPORT void f2_V_ISP_PII(int p0, struct S_PII p1, void* p2,  void (*cb)(int, struct S_PII, void*)) ;
+EXPORT void f2_V_ISP_PIF(int p0, struct S_PIF p1, void* p2,  void (*cb)(int, struct S_PIF, void*)) ;
+EXPORT void f2_V_ISP_PID(int p0, struct S_PID p1, void* p2,  void (*cb)(int, struct S_PID, void*)) ;
+EXPORT void f2_V_ISP_PIP(int p0, struct S_PIP p1, void* p2,  void (*cb)(int, struct S_PIP, void*)) ;
+EXPORT void f2_V_ISP_PFI(int p0, struct S_PFI p1, void* p2,  void (*cb)(int, struct S_PFI, void*)) ;
+EXPORT void f2_V_ISP_PFF(int p0, struct S_PFF p1, void* p2,  void (*cb)(int, struct S_PFF, void*)) ;
+EXPORT void f2_V_ISP_PFD(int p0, struct S_PFD p1, void* p2,  void (*cb)(int, struct S_PFD, void*)) ;
+EXPORT void f2_V_ISP_PFP(int p0, struct S_PFP p1, void* p2,  void (*cb)(int, struct S_PFP, void*)) ;
+EXPORT void f2_V_ISP_PDI(int p0, struct S_PDI p1, void* p2,  void (*cb)(int, struct S_PDI, void*)) ;
+EXPORT void f2_V_ISP_PDF(int p0, struct S_PDF p1, void* p2,  void (*cb)(int, struct S_PDF, void*)) ;
+EXPORT void f2_V_ISP_PDD(int p0, struct S_PDD p1, void* p2,  void (*cb)(int, struct S_PDD, void*)) ;
+EXPORT void f2_V_ISP_PDP(int p0, struct S_PDP p1, void* p2,  void (*cb)(int, struct S_PDP, void*)) ;
+EXPORT void f2_V_ISP_PPI(int p0, struct S_PPI p1, void* p2,  void (*cb)(int, struct S_PPI, void*)) ;
+EXPORT void f2_V_ISP_PPF(int p0, struct S_PPF p1, void* p2,  void (*cb)(int, struct S_PPF, void*)) ;
+EXPORT void f2_V_ISP_PPD(int p0, struct S_PPD p1, void* p2,  void (*cb)(int, struct S_PPD, void*)) ;
+EXPORT void f2_V_ISP_PPP(int p0, struct S_PPP p1, void* p2,  void (*cb)(int, struct S_PPP, void*)) ;
+EXPORT void f2_V_ISS_I(int p0, struct S_I p1, struct S_I p2,  void (*cb)(int, struct S_I, struct S_I)) ;
+EXPORT void f2_V_ISS_F(int p0, struct S_F p1, struct S_F p2,  void (*cb)(int, struct S_F, struct S_F)) ;
+EXPORT void f2_V_ISS_D(int p0, struct S_D p1, struct S_D p2,  void (*cb)(int, struct S_D, struct S_D)) ;
+EXPORT void f2_V_ISS_P(int p0, struct S_P p1, struct S_P p2,  void (*cb)(int, struct S_P, struct S_P)) ;
+EXPORT void f2_V_ISS_II(int p0, struct S_II p1, struct S_II p2,  void (*cb)(int, struct S_II, struct S_II)) ;
+EXPORT void f2_V_ISS_IF(int p0, struct S_IF p1, struct S_IF p2,  void (*cb)(int, struct S_IF, struct S_IF)) ;
+EXPORT void f2_V_ISS_ID(int p0, struct S_ID p1, struct S_ID p2,  void (*cb)(int, struct S_ID, struct S_ID)) ;
+EXPORT void f2_V_ISS_IP(int p0, struct S_IP p1, struct S_IP p2,  void (*cb)(int, struct S_IP, struct S_IP)) ;
+EXPORT void f2_V_ISS_FI(int p0, struct S_FI p1, struct S_FI p2,  void (*cb)(int, struct S_FI, struct S_FI)) ;
+EXPORT void f2_V_ISS_FF(int p0, struct S_FF p1, struct S_FF p2,  void (*cb)(int, struct S_FF, struct S_FF)) ;
+EXPORT void f2_V_ISS_FD(int p0, struct S_FD p1, struct S_FD p2,  void (*cb)(int, struct S_FD, struct S_FD)) ;
+EXPORT void f2_V_ISS_FP(int p0, struct S_FP p1, struct S_FP p2,  void (*cb)(int, struct S_FP, struct S_FP)) ;
+EXPORT void f2_V_ISS_DI(int p0, struct S_DI p1, struct S_DI p2,  void (*cb)(int, struct S_DI, struct S_DI)) ;
+EXPORT void f2_V_ISS_DF(int p0, struct S_DF p1, struct S_DF p2,  void (*cb)(int, struct S_DF, struct S_DF)) ;
+EXPORT void f2_V_ISS_DD(int p0, struct S_DD p1, struct S_DD p2,  void (*cb)(int, struct S_DD, struct S_DD)) ;
+EXPORT void f2_V_ISS_DP(int p0, struct S_DP p1, struct S_DP p2,  void (*cb)(int, struct S_DP, struct S_DP)) ;
+EXPORT void f2_V_ISS_PI(int p0, struct S_PI p1, struct S_PI p2,  void (*cb)(int, struct S_PI, struct S_PI)) ;
+EXPORT void f2_V_ISS_PF(int p0, struct S_PF p1, struct S_PF p2,  void (*cb)(int, struct S_PF, struct S_PF)) ;
+EXPORT void f2_V_ISS_PD(int p0, struct S_PD p1, struct S_PD p2,  void (*cb)(int, struct S_PD, struct S_PD)) ;
+EXPORT void f2_V_ISS_PP(int p0, struct S_PP p1, struct S_PP p2,  void (*cb)(int, struct S_PP, struct S_PP)) ;
+EXPORT void f2_V_ISS_III(int p0, struct S_III p1, struct S_III p2,  void (*cb)(int, struct S_III, struct S_III)) ;
+EXPORT void f2_V_ISS_IIF(int p0, struct S_IIF p1, struct S_IIF p2,  void (*cb)(int, struct S_IIF, struct S_IIF)) ;
+EXPORT void f2_V_ISS_IID(int p0, struct S_IID p1, struct S_IID p2,  void (*cb)(int, struct S_IID, struct S_IID)) ;
+EXPORT void f2_V_ISS_IIP(int p0, struct S_IIP p1, struct S_IIP p2,  void (*cb)(int, struct S_IIP, struct S_IIP)) ;
+EXPORT void f2_V_ISS_IFI(int p0, struct S_IFI p1, struct S_IFI p2,  void (*cb)(int, struct S_IFI, struct S_IFI)) ;
+EXPORT void f2_V_ISS_IFF(int p0, struct S_IFF p1, struct S_IFF p2,  void (*cb)(int, struct S_IFF, struct S_IFF)) ;
+EXPORT void f2_V_ISS_IFD(int p0, struct S_IFD p1, struct S_IFD p2,  void (*cb)(int, struct S_IFD, struct S_IFD)) ;
+EXPORT void f2_V_ISS_IFP(int p0, struct S_IFP p1, struct S_IFP p2,  void (*cb)(int, struct S_IFP, struct S_IFP)) ;
+EXPORT void f2_V_ISS_IDI(int p0, struct S_IDI p1, struct S_IDI p2,  void (*cb)(int, struct S_IDI, struct S_IDI)) ;
+EXPORT void f2_V_ISS_IDF(int p0, struct S_IDF p1, struct S_IDF p2,  void (*cb)(int, struct S_IDF, struct S_IDF)) ;
+EXPORT void f2_V_ISS_IDD(int p0, struct S_IDD p1, struct S_IDD p2,  void (*cb)(int, struct S_IDD, struct S_IDD)) ;
+EXPORT void f2_V_ISS_IDP(int p0, struct S_IDP p1, struct S_IDP p2,  void (*cb)(int, struct S_IDP, struct S_IDP)) ;
+EXPORT void f2_V_ISS_IPI(int p0, struct S_IPI p1, struct S_IPI p2,  void (*cb)(int, struct S_IPI, struct S_IPI)) ;
+EXPORT void f2_V_ISS_IPF(int p0, struct S_IPF p1, struct S_IPF p2,  void (*cb)(int, struct S_IPF, struct S_IPF)) ;
+EXPORT void f2_V_ISS_IPD(int p0, struct S_IPD p1, struct S_IPD p2,  void (*cb)(int, struct S_IPD, struct S_IPD)) ;
+EXPORT void f2_V_ISS_IPP(int p0, struct S_IPP p1, struct S_IPP p2,  void (*cb)(int, struct S_IPP, struct S_IPP)) ;
+EXPORT void f2_V_ISS_FII(int p0, struct S_FII p1, struct S_FII p2,  void (*cb)(int, struct S_FII, struct S_FII)) ;
+EXPORT void f2_V_ISS_FIF(int p0, struct S_FIF p1, struct S_FIF p2,  void (*cb)(int, struct S_FIF, struct S_FIF)) ;
+EXPORT void f2_V_ISS_FID(int p0, struct S_FID p1, struct S_FID p2,  void (*cb)(int, struct S_FID, struct S_FID)) ;
+EXPORT void f2_V_ISS_FIP(int p0, struct S_FIP p1, struct S_FIP p2,  void (*cb)(int, struct S_FIP, struct S_FIP)) ;
+EXPORT void f2_V_ISS_FFI(int p0, struct S_FFI p1, struct S_FFI p2,  void (*cb)(int, struct S_FFI, struct S_FFI)) ;
+EXPORT void f2_V_ISS_FFF(int p0, struct S_FFF p1, struct S_FFF p2,  void (*cb)(int, struct S_FFF, struct S_FFF)) ;
+EXPORT void f2_V_ISS_FFD(int p0, struct S_FFD p1, struct S_FFD p2,  void (*cb)(int, struct S_FFD, struct S_FFD)) ;
+EXPORT void f2_V_ISS_FFP(int p0, struct S_FFP p1, struct S_FFP p2,  void (*cb)(int, struct S_FFP, struct S_FFP)) ;
+EXPORT void f2_V_ISS_FDI(int p0, struct S_FDI p1, struct S_FDI p2,  void (*cb)(int, struct S_FDI, struct S_FDI)) ;
+EXPORT void f2_V_ISS_FDF(int p0, struct S_FDF p1, struct S_FDF p2,  void (*cb)(int, struct S_FDF, struct S_FDF)) ;
+EXPORT void f2_V_ISS_FDD(int p0, struct S_FDD p1, struct S_FDD p2,  void (*cb)(int, struct S_FDD, struct S_FDD)) ;
+EXPORT void f2_V_ISS_FDP(int p0, struct S_FDP p1, struct S_FDP p2,  void (*cb)(int, struct S_FDP, struct S_FDP)) ;
+EXPORT void f2_V_ISS_FPI(int p0, struct S_FPI p1, struct S_FPI p2,  void (*cb)(int, struct S_FPI, struct S_FPI)) ;
+EXPORT void f2_V_ISS_FPF(int p0, struct S_FPF p1, struct S_FPF p2,  void (*cb)(int, struct S_FPF, struct S_FPF)) ;
+EXPORT void f2_V_ISS_FPD(int p0, struct S_FPD p1, struct S_FPD p2,  void (*cb)(int, struct S_FPD, struct S_FPD)) ;
+EXPORT void f2_V_ISS_FPP(int p0, struct S_FPP p1, struct S_FPP p2,  void (*cb)(int, struct S_FPP, struct S_FPP)) ;
+EXPORT void f2_V_ISS_DII(int p0, struct S_DII p1, struct S_DII p2,  void (*cb)(int, struct S_DII, struct S_DII)) ;
+EXPORT void f2_V_ISS_DIF(int p0, struct S_DIF p1, struct S_DIF p2,  void (*cb)(int, struct S_DIF, struct S_DIF)) ;
+EXPORT void f2_V_ISS_DID(int p0, struct S_DID p1, struct S_DID p2,  void (*cb)(int, struct S_DID, struct S_DID)) ;
+EXPORT void f2_V_ISS_DIP(int p0, struct S_DIP p1, struct S_DIP p2,  void (*cb)(int, struct S_DIP, struct S_DIP)) ;
+EXPORT void f2_V_ISS_DFI(int p0, struct S_DFI p1, struct S_DFI p2,  void (*cb)(int, struct S_DFI, struct S_DFI)) ;
+EXPORT void f2_V_ISS_DFF(int p0, struct S_DFF p1, struct S_DFF p2,  void (*cb)(int, struct S_DFF, struct S_DFF)) ;
+EXPORT void f2_V_ISS_DFD(int p0, struct S_DFD p1, struct S_DFD p2,  void (*cb)(int, struct S_DFD, struct S_DFD)) ;
+EXPORT void f2_V_ISS_DFP(int p0, struct S_DFP p1, struct S_DFP p2,  void (*cb)(int, struct S_DFP, struct S_DFP)) ;
+EXPORT void f2_V_ISS_DDI(int p0, struct S_DDI p1, struct S_DDI p2,  void (*cb)(int, struct S_DDI, struct S_DDI)) ;
+EXPORT void f2_V_ISS_DDF(int p0, struct S_DDF p1, struct S_DDF p2,  void (*cb)(int, struct S_DDF, struct S_DDF)) ;
+EXPORT void f2_V_ISS_DDD(int p0, struct S_DDD p1, struct S_DDD p2,  void (*cb)(int, struct S_DDD, struct S_DDD)) ;
+EXPORT void f2_V_ISS_DDP(int p0, struct S_DDP p1, struct S_DDP p2,  void (*cb)(int, struct S_DDP, struct S_DDP)) ;
+EXPORT void f2_V_ISS_DPI(int p0, struct S_DPI p1, struct S_DPI p2,  void (*cb)(int, struct S_DPI, struct S_DPI)) ;
+EXPORT void f2_V_ISS_DPF(int p0, struct S_DPF p1, struct S_DPF p2,  void (*cb)(int, struct S_DPF, struct S_DPF)) ;
+EXPORT void f2_V_ISS_DPD(int p0, struct S_DPD p1, struct S_DPD p2,  void (*cb)(int, struct S_DPD, struct S_DPD)) ;
+EXPORT void f2_V_ISS_DPP(int p0, struct S_DPP p1, struct S_DPP p2,  void (*cb)(int, struct S_DPP, struct S_DPP)) ;
+EXPORT void f2_V_ISS_PII(int p0, struct S_PII p1, struct S_PII p2,  void (*cb)(int, struct S_PII, struct S_PII)) ;
+EXPORT void f2_V_ISS_PIF(int p0, struct S_PIF p1, struct S_PIF p2,  void (*cb)(int, struct S_PIF, struct S_PIF)) ;
+EXPORT void f2_V_ISS_PID(int p0, struct S_PID p1, struct S_PID p2,  void (*cb)(int, struct S_PID, struct S_PID)) ;
+EXPORT void f2_V_ISS_PIP(int p0, struct S_PIP p1, struct S_PIP p2,  void (*cb)(int, struct S_PIP, struct S_PIP)) ;
+EXPORT void f2_V_ISS_PFI(int p0, struct S_PFI p1, struct S_PFI p2,  void (*cb)(int, struct S_PFI, struct S_PFI)) ;
+EXPORT void f2_V_ISS_PFF(int p0, struct S_PFF p1, struct S_PFF p2,  void (*cb)(int, struct S_PFF, struct S_PFF)) ;
+EXPORT void f2_V_ISS_PFD(int p0, struct S_PFD p1, struct S_PFD p2,  void (*cb)(int, struct S_PFD, struct S_PFD)) ;
+EXPORT void f2_V_ISS_PFP(int p0, struct S_PFP p1, struct S_PFP p2,  void (*cb)(int, struct S_PFP, struct S_PFP)) ;
+EXPORT void f2_V_ISS_PDI(int p0, struct S_PDI p1, struct S_PDI p2,  void (*cb)(int, struct S_PDI, struct S_PDI)) ;
+EXPORT void f2_V_ISS_PDF(int p0, struct S_PDF p1, struct S_PDF p2,  void (*cb)(int, struct S_PDF, struct S_PDF)) ;
+EXPORT void f2_V_ISS_PDD(int p0, struct S_PDD p1, struct S_PDD p2,  void (*cb)(int, struct S_PDD, struct S_PDD)) ;
+EXPORT void f2_V_ISS_PDP(int p0, struct S_PDP p1, struct S_PDP p2,  void (*cb)(int, struct S_PDP, struct S_PDP)) ;
+EXPORT void f2_V_ISS_PPI(int p0, struct S_PPI p1, struct S_PPI p2,  void (*cb)(int, struct S_PPI, struct S_PPI)) ;
+EXPORT void f2_V_ISS_PPF(int p0, struct S_PPF p1, struct S_PPF p2,  void (*cb)(int, struct S_PPF, struct S_PPF)) ;
+EXPORT void f2_V_ISS_PPD(int p0, struct S_PPD p1, struct S_PPD p2,  void (*cb)(int, struct S_PPD, struct S_PPD)) ;
+EXPORT void f2_V_ISS_PPP(int p0, struct S_PPP p1, struct S_PPP p2,  void (*cb)(int, struct S_PPP, struct S_PPP)) ;
+EXPORT void f2_V_FII_(float p0, int p1, int p2,  void (*cb)(float, int, int)) ;
+EXPORT void f2_V_FIF_(float p0, int p1, float p2,  void (*cb)(float, int, float)) ;
+EXPORT void f2_V_FID_(float p0, int p1, double p2,  void (*cb)(float, int, double)) ;
+EXPORT void f2_V_FIP_(float p0, int p1, void* p2,  void (*cb)(float, int, void*)) ;
+EXPORT void f2_V_FIS_I(float p0, int p1, struct S_I p2,  void (*cb)(float, int, struct S_I)) ;
+EXPORT void f2_V_FIS_F(float p0, int p1, struct S_F p2,  void (*cb)(float, int, struct S_F)) ;
+EXPORT void f2_V_FIS_D(float p0, int p1, struct S_D p2,  void (*cb)(float, int, struct S_D)) ;
+EXPORT void f2_V_FIS_P(float p0, int p1, struct S_P p2,  void (*cb)(float, int, struct S_P)) ;
+EXPORT void f2_V_FIS_II(float p0, int p1, struct S_II p2,  void (*cb)(float, int, struct S_II)) ;
+EXPORT void f2_V_FIS_IF(float p0, int p1, struct S_IF p2,  void (*cb)(float, int, struct S_IF)) ;
+EXPORT void f2_V_FIS_ID(float p0, int p1, struct S_ID p2,  void (*cb)(float, int, struct S_ID)) ;
+EXPORT void f2_V_FIS_IP(float p0, int p1, struct S_IP p2,  void (*cb)(float, int, struct S_IP)) ;
+EXPORT void f2_V_FIS_FI(float p0, int p1, struct S_FI p2,  void (*cb)(float, int, struct S_FI)) ;
+EXPORT void f2_V_FIS_FF(float p0, int p1, struct S_FF p2,  void (*cb)(float, int, struct S_FF)) ;
+EXPORT void f2_V_FIS_FD(float p0, int p1, struct S_FD p2,  void (*cb)(float, int, struct S_FD)) ;
+EXPORT void f2_V_FIS_FP(float p0, int p1, struct S_FP p2,  void (*cb)(float, int, struct S_FP)) ;
+EXPORT void f2_V_FIS_DI(float p0, int p1, struct S_DI p2,  void (*cb)(float, int, struct S_DI)) ;
+EXPORT void f2_V_FIS_DF(float p0, int p1, struct S_DF p2,  void (*cb)(float, int, struct S_DF)) ;
+EXPORT void f2_V_FIS_DD(float p0, int p1, struct S_DD p2,  void (*cb)(float, int, struct S_DD)) ;
+EXPORT void f2_V_FIS_DP(float p0, int p1, struct S_DP p2,  void (*cb)(float, int, struct S_DP)) ;
+EXPORT void f2_V_FIS_PI(float p0, int p1, struct S_PI p2,  void (*cb)(float, int, struct S_PI)) ;
+EXPORT void f2_V_FIS_PF(float p0, int p1, struct S_PF p2,  void (*cb)(float, int, struct S_PF)) ;
+EXPORT void f2_V_FIS_PD(float p0, int p1, struct S_PD p2,  void (*cb)(float, int, struct S_PD)) ;
+EXPORT void f2_V_FIS_PP(float p0, int p1, struct S_PP p2,  void (*cb)(float, int, struct S_PP)) ;
+EXPORT void f2_V_FIS_III(float p0, int p1, struct S_III p2,  void (*cb)(float, int, struct S_III)) ;
+EXPORT void f2_V_FIS_IIF(float p0, int p1, struct S_IIF p2,  void (*cb)(float, int, struct S_IIF)) ;
+EXPORT void f2_V_FIS_IID(float p0, int p1, struct S_IID p2,  void (*cb)(float, int, struct S_IID)) ;
+EXPORT void f2_V_FIS_IIP(float p0, int p1, struct S_IIP p2,  void (*cb)(float, int, struct S_IIP)) ;
+EXPORT void f2_V_FIS_IFI(float p0, int p1, struct S_IFI p2,  void (*cb)(float, int, struct S_IFI)) ;
+EXPORT void f2_V_FIS_IFF(float p0, int p1, struct S_IFF p2,  void (*cb)(float, int, struct S_IFF)) ;
+EXPORT void f2_V_FIS_IFD(float p0, int p1, struct S_IFD p2,  void (*cb)(float, int, struct S_IFD)) ;
+EXPORT void f2_V_FIS_IFP(float p0, int p1, struct S_IFP p2,  void (*cb)(float, int, struct S_IFP)) ;
+EXPORT void f2_V_FIS_IDI(float p0, int p1, struct S_IDI p2,  void (*cb)(float, int, struct S_IDI)) ;
+EXPORT void f2_V_FIS_IDF(float p0, int p1, struct S_IDF p2,  void (*cb)(float, int, struct S_IDF)) ;
+EXPORT void f2_V_FIS_IDD(float p0, int p1, struct S_IDD p2,  void (*cb)(float, int, struct S_IDD)) ;
+EXPORT void f2_V_FIS_IDP(float p0, int p1, struct S_IDP p2,  void (*cb)(float, int, struct S_IDP)) ;
+EXPORT void f2_V_FIS_IPI(float p0, int p1, struct S_IPI p2,  void (*cb)(float, int, struct S_IPI)) ;
+EXPORT void f2_V_FIS_IPF(float p0, int p1, struct S_IPF p2,  void (*cb)(float, int, struct S_IPF)) ;
+EXPORT void f2_V_FIS_IPD(float p0, int p1, struct S_IPD p2,  void (*cb)(float, int, struct S_IPD)) ;
+EXPORT void f2_V_FIS_IPP(float p0, int p1, struct S_IPP p2,  void (*cb)(float, int, struct S_IPP)) ;
+EXPORT void f2_V_FIS_FII(float p0, int p1, struct S_FII p2,  void (*cb)(float, int, struct S_FII)) ;
+EXPORT void f2_V_FIS_FIF(float p0, int p1, struct S_FIF p2,  void (*cb)(float, int, struct S_FIF)) ;
+EXPORT void f2_V_FIS_FID(float p0, int p1, struct S_FID p2,  void (*cb)(float, int, struct S_FID)) ;
+EXPORT void f2_V_FIS_FIP(float p0, int p1, struct S_FIP p2,  void (*cb)(float, int, struct S_FIP)) ;
+EXPORT void f2_V_FIS_FFI(float p0, int p1, struct S_FFI p2,  void (*cb)(float, int, struct S_FFI)) ;
+EXPORT void f2_V_FIS_FFF(float p0, int p1, struct S_FFF p2,  void (*cb)(float, int, struct S_FFF)) ;
+EXPORT void f2_V_FIS_FFD(float p0, int p1, struct S_FFD p2,  void (*cb)(float, int, struct S_FFD)) ;
+EXPORT void f2_V_FIS_FFP(float p0, int p1, struct S_FFP p2,  void (*cb)(float, int, struct S_FFP)) ;
+EXPORT void f2_V_FIS_FDI(float p0, int p1, struct S_FDI p2,  void (*cb)(float, int, struct S_FDI)) ;
+EXPORT void f2_V_FIS_FDF(float p0, int p1, struct S_FDF p2,  void (*cb)(float, int, struct S_FDF)) ;
+EXPORT void f2_V_FIS_FDD(float p0, int p1, struct S_FDD p2,  void (*cb)(float, int, struct S_FDD)) ;
+EXPORT void f2_V_FIS_FDP(float p0, int p1, struct S_FDP p2,  void (*cb)(float, int, struct S_FDP)) ;
+EXPORT void f2_V_FIS_FPI(float p0, int p1, struct S_FPI p2,  void (*cb)(float, int, struct S_FPI)) ;
+EXPORT void f2_V_FIS_FPF(float p0, int p1, struct S_FPF p2,  void (*cb)(float, int, struct S_FPF)) ;
+EXPORT void f2_V_FIS_FPD(float p0, int p1, struct S_FPD p2,  void (*cb)(float, int, struct S_FPD)) ;
+EXPORT void f2_V_FIS_FPP(float p0, int p1, struct S_FPP p2,  void (*cb)(float, int, struct S_FPP)) ;
+EXPORT void f2_V_FIS_DII(float p0, int p1, struct S_DII p2,  void (*cb)(float, int, struct S_DII)) ;
+EXPORT void f2_V_FIS_DIF(float p0, int p1, struct S_DIF p2,  void (*cb)(float, int, struct S_DIF)) ;
+EXPORT void f2_V_FIS_DID(float p0, int p1, struct S_DID p2,  void (*cb)(float, int, struct S_DID)) ;
+EXPORT void f2_V_FIS_DIP(float p0, int p1, struct S_DIP p2,  void (*cb)(float, int, struct S_DIP)) ;
+EXPORT void f2_V_FIS_DFI(float p0, int p1, struct S_DFI p2,  void (*cb)(float, int, struct S_DFI)) ;
+EXPORT void f2_V_FIS_DFF(float p0, int p1, struct S_DFF p2,  void (*cb)(float, int, struct S_DFF)) ;
+EXPORT void f2_V_FIS_DFD(float p0, int p1, struct S_DFD p2,  void (*cb)(float, int, struct S_DFD)) ;
+EXPORT void f2_V_FIS_DFP(float p0, int p1, struct S_DFP p2,  void (*cb)(float, int, struct S_DFP)) ;
+EXPORT void f2_V_FIS_DDI(float p0, int p1, struct S_DDI p2,  void (*cb)(float, int, struct S_DDI)) ;
+EXPORT void f2_V_FIS_DDF(float p0, int p1, struct S_DDF p2,  void (*cb)(float, int, struct S_DDF)) ;
+EXPORT void f2_V_FIS_DDD(float p0, int p1, struct S_DDD p2,  void (*cb)(float, int, struct S_DDD)) ;
+EXPORT void f2_V_FIS_DDP(float p0, int p1, struct S_DDP p2,  void (*cb)(float, int, struct S_DDP)) ;
+EXPORT void f2_V_FIS_DPI(float p0, int p1, struct S_DPI p2,  void (*cb)(float, int, struct S_DPI)) ;
+EXPORT void f2_V_FIS_DPF(float p0, int p1, struct S_DPF p2,  void (*cb)(float, int, struct S_DPF)) ;
+EXPORT void f2_V_FIS_DPD(float p0, int p1, struct S_DPD p2,  void (*cb)(float, int, struct S_DPD)) ;
+EXPORT void f2_V_FIS_DPP(float p0, int p1, struct S_DPP p2,  void (*cb)(float, int, struct S_DPP)) ;
+EXPORT void f2_V_FIS_PII(float p0, int p1, struct S_PII p2,  void (*cb)(float, int, struct S_PII)) ;
+EXPORT void f2_V_FIS_PIF(float p0, int p1, struct S_PIF p2,  void (*cb)(float, int, struct S_PIF)) ;
+EXPORT void f2_V_FIS_PID(float p0, int p1, struct S_PID p2,  void (*cb)(float, int, struct S_PID)) ;
+EXPORT void f2_V_FIS_PIP(float p0, int p1, struct S_PIP p2,  void (*cb)(float, int, struct S_PIP)) ;
+EXPORT void f2_V_FIS_PFI(float p0, int p1, struct S_PFI p2,  void (*cb)(float, int, struct S_PFI)) ;
+EXPORT void f2_V_FIS_PFF(float p0, int p1, struct S_PFF p2,  void (*cb)(float, int, struct S_PFF)) ;
+EXPORT void f2_V_FIS_PFD(float p0, int p1, struct S_PFD p2,  void (*cb)(float, int, struct S_PFD)) ;
+EXPORT void f2_V_FIS_PFP(float p0, int p1, struct S_PFP p2,  void (*cb)(float, int, struct S_PFP)) ;
+EXPORT void f2_V_FIS_PDI(float p0, int p1, struct S_PDI p2,  void (*cb)(float, int, struct S_PDI)) ;
+EXPORT void f2_V_FIS_PDF(float p0, int p1, struct S_PDF p2,  void (*cb)(float, int, struct S_PDF)) ;
+EXPORT void f2_V_FIS_PDD(float p0, int p1, struct S_PDD p2,  void (*cb)(float, int, struct S_PDD)) ;
+EXPORT void f2_V_FIS_PDP(float p0, int p1, struct S_PDP p2,  void (*cb)(float, int, struct S_PDP)) ;
+EXPORT void f2_V_FIS_PPI(float p0, int p1, struct S_PPI p2,  void (*cb)(float, int, struct S_PPI)) ;
+EXPORT void f2_V_FIS_PPF(float p0, int p1, struct S_PPF p2,  void (*cb)(float, int, struct S_PPF)) ;
+EXPORT void f2_V_FIS_PPD(float p0, int p1, struct S_PPD p2,  void (*cb)(float, int, struct S_PPD)) ;
+EXPORT void f2_V_FIS_PPP(float p0, int p1, struct S_PPP p2,  void (*cb)(float, int, struct S_PPP)) ;
+EXPORT void f2_V_FFI_(float p0, float p1, int p2,  void (*cb)(float, float, int)) ;
+EXPORT void f2_V_FFF_(float p0, float p1, float p2,  void (*cb)(float, float, float)) ;
+EXPORT void f2_V_FFD_(float p0, float p1, double p2,  void (*cb)(float, float, double)) ;
+EXPORT void f2_V_FFP_(float p0, float p1, void* p2,  void (*cb)(float, float, void*)) ;
+EXPORT void f2_V_FFS_I(float p0, float p1, struct S_I p2,  void (*cb)(float, float, struct S_I)) ;
+EXPORT void f2_V_FFS_F(float p0, float p1, struct S_F p2,  void (*cb)(float, float, struct S_F)) ;
+EXPORT void f2_V_FFS_D(float p0, float p1, struct S_D p2,  void (*cb)(float, float, struct S_D)) ;
+EXPORT void f2_V_FFS_P(float p0, float p1, struct S_P p2,  void (*cb)(float, float, struct S_P)) ;
+EXPORT void f2_V_FFS_II(float p0, float p1, struct S_II p2,  void (*cb)(float, float, struct S_II)) ;
+EXPORT void f2_V_FFS_IF(float p0, float p1, struct S_IF p2,  void (*cb)(float, float, struct S_IF)) ;
+EXPORT void f2_V_FFS_ID(float p0, float p1, struct S_ID p2,  void (*cb)(float, float, struct S_ID)) ;
+EXPORT void f2_V_FFS_IP(float p0, float p1, struct S_IP p2,  void (*cb)(float, float, struct S_IP)) ;
+EXPORT void f2_V_FFS_FI(float p0, float p1, struct S_FI p2,  void (*cb)(float, float, struct S_FI)) ;
+EXPORT void f2_V_FFS_FF(float p0, float p1, struct S_FF p2,  void (*cb)(float, float, struct S_FF)) ;
+EXPORT void f2_V_FFS_FD(float p0, float p1, struct S_FD p2,  void (*cb)(float, float, struct S_FD)) ;
+EXPORT void f2_V_FFS_FP(float p0, float p1, struct S_FP p2,  void (*cb)(float, float, struct S_FP)) ;
+EXPORT void f2_V_FFS_DI(float p0, float p1, struct S_DI p2,  void (*cb)(float, float, struct S_DI)) ;
+EXPORT void f2_V_FFS_DF(float p0, float p1, struct S_DF p2,  void (*cb)(float, float, struct S_DF)) ;
+EXPORT void f2_V_FFS_DD(float p0, float p1, struct S_DD p2,  void (*cb)(float, float, struct S_DD)) ;
+EXPORT void f2_V_FFS_DP(float p0, float p1, struct S_DP p2,  void (*cb)(float, float, struct S_DP)) ;
+EXPORT void f2_V_FFS_PI(float p0, float p1, struct S_PI p2,  void (*cb)(float, float, struct S_PI)) ;
+EXPORT void f2_V_FFS_PF(float p0, float p1, struct S_PF p2,  void (*cb)(float, float, struct S_PF)) ;
+EXPORT void f2_V_FFS_PD(float p0, float p1, struct S_PD p2,  void (*cb)(float, float, struct S_PD)) ;
+EXPORT void f2_V_FFS_PP(float p0, float p1, struct S_PP p2,  void (*cb)(float, float, struct S_PP)) ;
+EXPORT void f2_V_FFS_III(float p0, float p1, struct S_III p2,  void (*cb)(float, float, struct S_III)) ;
+EXPORT void f2_V_FFS_IIF(float p0, float p1, struct S_IIF p2,  void (*cb)(float, float, struct S_IIF)) ;
+EXPORT void f2_V_FFS_IID(float p0, float p1, struct S_IID p2,  void (*cb)(float, float, struct S_IID)) ;
+EXPORT void f2_V_FFS_IIP(float p0, float p1, struct S_IIP p2,  void (*cb)(float, float, struct S_IIP)) ;
+EXPORT void f2_V_FFS_IFI(float p0, float p1, struct S_IFI p2,  void (*cb)(float, float, struct S_IFI)) ;
+EXPORT void f2_V_FFS_IFF(float p0, float p1, struct S_IFF p2,  void (*cb)(float, float, struct S_IFF)) ;
+EXPORT void f2_V_FFS_IFD(float p0, float p1, struct S_IFD p2,  void (*cb)(float, float, struct S_IFD)) ;
+EXPORT void f2_V_FFS_IFP(float p0, float p1, struct S_IFP p2,  void (*cb)(float, float, struct S_IFP)) ;
+EXPORT void f2_V_FFS_IDI(float p0, float p1, struct S_IDI p2,  void (*cb)(float, float, struct S_IDI)) ;
+EXPORT void f2_V_FFS_IDF(float p0, float p1, struct S_IDF p2,  void (*cb)(float, float, struct S_IDF)) ;
+EXPORT void f2_V_FFS_IDD(float p0, float p1, struct S_IDD p2,  void (*cb)(float, float, struct S_IDD)) ;
+EXPORT void f2_V_FFS_IDP(float p0, float p1, struct S_IDP p2,  void (*cb)(float, float, struct S_IDP)) ;
+EXPORT void f2_V_FFS_IPI(float p0, float p1, struct S_IPI p2,  void (*cb)(float, float, struct S_IPI)) ;
+EXPORT void f2_V_FFS_IPF(float p0, float p1, struct S_IPF p2,  void (*cb)(float, float, struct S_IPF)) ;
+EXPORT void f2_V_FFS_IPD(float p0, float p1, struct S_IPD p2,  void (*cb)(float, float, struct S_IPD)) ;
+EXPORT void f2_V_FFS_IPP(float p0, float p1, struct S_IPP p2,  void (*cb)(float, float, struct S_IPP)) ;
+EXPORT void f2_V_FFS_FII(float p0, float p1, struct S_FII p2,  void (*cb)(float, float, struct S_FII)) ;
+EXPORT void f2_V_FFS_FIF(float p0, float p1, struct S_FIF p2,  void (*cb)(float, float, struct S_FIF)) ;
+EXPORT void f2_V_FFS_FID(float p0, float p1, struct S_FID p2,  void (*cb)(float, float, struct S_FID)) ;
+EXPORT void f2_V_FFS_FIP(float p0, float p1, struct S_FIP p2,  void (*cb)(float, float, struct S_FIP)) ;
+EXPORT void f2_V_FFS_FFI(float p0, float p1, struct S_FFI p2,  void (*cb)(float, float, struct S_FFI)) ;
+EXPORT void f2_V_FFS_FFF(float p0, float p1, struct S_FFF p2,  void (*cb)(float, float, struct S_FFF)) ;
+EXPORT void f2_V_FFS_FFD(float p0, float p1, struct S_FFD p2,  void (*cb)(float, float, struct S_FFD)) ;
+EXPORT void f2_V_FFS_FFP(float p0, float p1, struct S_FFP p2,  void (*cb)(float, float, struct S_FFP)) ;
+EXPORT void f2_V_FFS_FDI(float p0, float p1, struct S_FDI p2,  void (*cb)(float, float, struct S_FDI)) ;
+EXPORT void f2_V_FFS_FDF(float p0, float p1, struct S_FDF p2,  void (*cb)(float, float, struct S_FDF)) ;
+EXPORT void f2_V_FFS_FDD(float p0, float p1, struct S_FDD p2,  void (*cb)(float, float, struct S_FDD)) ;
+EXPORT void f2_V_FFS_FDP(float p0, float p1, struct S_FDP p2,  void (*cb)(float, float, struct S_FDP)) ;
+EXPORT void f2_V_FFS_FPI(float p0, float p1, struct S_FPI p2,  void (*cb)(float, float, struct S_FPI)) ;
+EXPORT void f2_V_FFS_FPF(float p0, float p1, struct S_FPF p2,  void (*cb)(float, float, struct S_FPF)) ;
+EXPORT void f2_V_FFS_FPD(float p0, float p1, struct S_FPD p2,  void (*cb)(float, float, struct S_FPD)) ;
+EXPORT void f2_V_FFS_FPP(float p0, float p1, struct S_FPP p2,  void (*cb)(float, float, struct S_FPP)) ;
+EXPORT void f2_V_FFS_DII(float p0, float p1, struct S_DII p2,  void (*cb)(float, float, struct S_DII)) ;
+EXPORT void f2_V_FFS_DIF(float p0, float p1, struct S_DIF p2,  void (*cb)(float, float, struct S_DIF)) ;
+EXPORT void f2_V_FFS_DID(float p0, float p1, struct S_DID p2,  void (*cb)(float, float, struct S_DID)) ;
+EXPORT void f2_V_FFS_DIP(float p0, float p1, struct S_DIP p2,  void (*cb)(float, float, struct S_DIP)) ;
+EXPORT void f2_V_FFS_DFI(float p0, float p1, struct S_DFI p2,  void (*cb)(float, float, struct S_DFI)) ;
+EXPORT void f2_V_FFS_DFF(float p0, float p1, struct S_DFF p2,  void (*cb)(float, float, struct S_DFF)) ;
+EXPORT void f2_V_FFS_DFD(float p0, float p1, struct S_DFD p2,  void (*cb)(float, float, struct S_DFD)) ;
+EXPORT void f2_V_FFS_DFP(float p0, float p1, struct S_DFP p2,  void (*cb)(float, float, struct S_DFP)) ;
+EXPORT void f2_V_FFS_DDI(float p0, float p1, struct S_DDI p2,  void (*cb)(float, float, struct S_DDI)) ;
+EXPORT void f2_V_FFS_DDF(float p0, float p1, struct S_DDF p2,  void (*cb)(float, float, struct S_DDF)) ;
+EXPORT void f2_V_FFS_DDD(float p0, float p1, struct S_DDD p2,  void (*cb)(float, float, struct S_DDD)) ;
+EXPORT void f2_V_FFS_DDP(float p0, float p1, struct S_DDP p2,  void (*cb)(float, float, struct S_DDP)) ;
+EXPORT void f2_V_FFS_DPI(float p0, float p1, struct S_DPI p2,  void (*cb)(float, float, struct S_DPI)) ;
+EXPORT void f2_V_FFS_DPF(float p0, float p1, struct S_DPF p2,  void (*cb)(float, float, struct S_DPF)) ;
+EXPORT void f2_V_FFS_DPD(float p0, float p1, struct S_DPD p2,  void (*cb)(float, float, struct S_DPD)) ;
+EXPORT void f2_V_FFS_DPP(float p0, float p1, struct S_DPP p2,  void (*cb)(float, float, struct S_DPP)) ;
+EXPORT void f2_V_FFS_PII(float p0, float p1, struct S_PII p2,  void (*cb)(float, float, struct S_PII)) ;
+EXPORT void f2_V_FFS_PIF(float p0, float p1, struct S_PIF p2,  void (*cb)(float, float, struct S_PIF)) ;
+EXPORT void f2_V_FFS_PID(float p0, float p1, struct S_PID p2,  void (*cb)(float, float, struct S_PID)) ;
+EXPORT void f2_V_FFS_PIP(float p0, float p1, struct S_PIP p2,  void (*cb)(float, float, struct S_PIP)) ;
+EXPORT void f2_V_FFS_PFI(float p0, float p1, struct S_PFI p2,  void (*cb)(float, float, struct S_PFI)) ;
+EXPORT void f2_V_FFS_PFF(float p0, float p1, struct S_PFF p2,  void (*cb)(float, float, struct S_PFF)) ;
+EXPORT void f2_V_FFS_PFD(float p0, float p1, struct S_PFD p2,  void (*cb)(float, float, struct S_PFD)) ;
+EXPORT void f3_V_FFS_PFP(float p0, float p1, struct S_PFP p2,  void (*cb)(float, float, struct S_PFP)) ;
+EXPORT void f3_V_FFS_PDI(float p0, float p1, struct S_PDI p2,  void (*cb)(float, float, struct S_PDI)) ;
+EXPORT void f3_V_FFS_PDF(float p0, float p1, struct S_PDF p2,  void (*cb)(float, float, struct S_PDF)) ;
+EXPORT void f3_V_FFS_PDD(float p0, float p1, struct S_PDD p2,  void (*cb)(float, float, struct S_PDD)) ;
+EXPORT void f3_V_FFS_PDP(float p0, float p1, struct S_PDP p2,  void (*cb)(float, float, struct S_PDP)) ;
+EXPORT void f3_V_FFS_PPI(float p0, float p1, struct S_PPI p2,  void (*cb)(float, float, struct S_PPI)) ;
+EXPORT void f3_V_FFS_PPF(float p0, float p1, struct S_PPF p2,  void (*cb)(float, float, struct S_PPF)) ;
+EXPORT void f3_V_FFS_PPD(float p0, float p1, struct S_PPD p2,  void (*cb)(float, float, struct S_PPD)) ;
+EXPORT void f3_V_FFS_PPP(float p0, float p1, struct S_PPP p2,  void (*cb)(float, float, struct S_PPP)) ;
+EXPORT void f3_V_FDI_(float p0, double p1, int p2,  void (*cb)(float, double, int)) ;
+EXPORT void f3_V_FDF_(float p0, double p1, float p2,  void (*cb)(float, double, float)) ;
+EXPORT void f3_V_FDD_(float p0, double p1, double p2,  void (*cb)(float, double, double)) ;
+EXPORT void f3_V_FDP_(float p0, double p1, void* p2,  void (*cb)(float, double, void*)) ;
+EXPORT void f3_V_FDS_I(float p0, double p1, struct S_I p2,  void (*cb)(float, double, struct S_I)) ;
+EXPORT void f3_V_FDS_F(float p0, double p1, struct S_F p2,  void (*cb)(float, double, struct S_F)) ;
+EXPORT void f3_V_FDS_D(float p0, double p1, struct S_D p2,  void (*cb)(float, double, struct S_D)) ;
+EXPORT void f3_V_FDS_P(float p0, double p1, struct S_P p2,  void (*cb)(float, double, struct S_P)) ;
+EXPORT void f3_V_FDS_II(float p0, double p1, struct S_II p2,  void (*cb)(float, double, struct S_II)) ;
+EXPORT void f3_V_FDS_IF(float p0, double p1, struct S_IF p2,  void (*cb)(float, double, struct S_IF)) ;
+EXPORT void f3_V_FDS_ID(float p0, double p1, struct S_ID p2,  void (*cb)(float, double, struct S_ID)) ;
+EXPORT void f3_V_FDS_IP(float p0, double p1, struct S_IP p2,  void (*cb)(float, double, struct S_IP)) ;
+EXPORT void f3_V_FDS_FI(float p0, double p1, struct S_FI p2,  void (*cb)(float, double, struct S_FI)) ;
+EXPORT void f3_V_FDS_FF(float p0, double p1, struct S_FF p2,  void (*cb)(float, double, struct S_FF)) ;
+EXPORT void f3_V_FDS_FD(float p0, double p1, struct S_FD p2,  void (*cb)(float, double, struct S_FD)) ;
+EXPORT void f3_V_FDS_FP(float p0, double p1, struct S_FP p2,  void (*cb)(float, double, struct S_FP)) ;
+EXPORT void f3_V_FDS_DI(float p0, double p1, struct S_DI p2,  void (*cb)(float, double, struct S_DI)) ;
+EXPORT void f3_V_FDS_DF(float p0, double p1, struct S_DF p2,  void (*cb)(float, double, struct S_DF)) ;
+EXPORT void f3_V_FDS_DD(float p0, double p1, struct S_DD p2,  void (*cb)(float, double, struct S_DD)) ;
+EXPORT void f3_V_FDS_DP(float p0, double p1, struct S_DP p2,  void (*cb)(float, double, struct S_DP)) ;
+EXPORT void f3_V_FDS_PI(float p0, double p1, struct S_PI p2,  void (*cb)(float, double, struct S_PI)) ;
+EXPORT void f3_V_FDS_PF(float p0, double p1, struct S_PF p2,  void (*cb)(float, double, struct S_PF)) ;
+EXPORT void f3_V_FDS_PD(float p0, double p1, struct S_PD p2,  void (*cb)(float, double, struct S_PD)) ;
+EXPORT void f3_V_FDS_PP(float p0, double p1, struct S_PP p2,  void (*cb)(float, double, struct S_PP)) ;
+EXPORT void f3_V_FDS_III(float p0, double p1, struct S_III p2,  void (*cb)(float, double, struct S_III)) ;
+EXPORT void f3_V_FDS_IIF(float p0, double p1, struct S_IIF p2,  void (*cb)(float, double, struct S_IIF)) ;
+EXPORT void f3_V_FDS_IID(float p0, double p1, struct S_IID p2,  void (*cb)(float, double, struct S_IID)) ;
+EXPORT void f3_V_FDS_IIP(float p0, double p1, struct S_IIP p2,  void (*cb)(float, double, struct S_IIP)) ;
+EXPORT void f3_V_FDS_IFI(float p0, double p1, struct S_IFI p2,  void (*cb)(float, double, struct S_IFI)) ;
+EXPORT void f3_V_FDS_IFF(float p0, double p1, struct S_IFF p2,  void (*cb)(float, double, struct S_IFF)) ;
+EXPORT void f3_V_FDS_IFD(float p0, double p1, struct S_IFD p2,  void (*cb)(float, double, struct S_IFD)) ;
+EXPORT void f3_V_FDS_IFP(float p0, double p1, struct S_IFP p2,  void (*cb)(float, double, struct S_IFP)) ;
+EXPORT void f3_V_FDS_IDI(float p0, double p1, struct S_IDI p2,  void (*cb)(float, double, struct S_IDI)) ;
+EXPORT void f3_V_FDS_IDF(float p0, double p1, struct S_IDF p2,  void (*cb)(float, double, struct S_IDF)) ;
+EXPORT void f3_V_FDS_IDD(float p0, double p1, struct S_IDD p2,  void (*cb)(float, double, struct S_IDD)) ;
+EXPORT void f3_V_FDS_IDP(float p0, double p1, struct S_IDP p2,  void (*cb)(float, double, struct S_IDP)) ;
+EXPORT void f3_V_FDS_IPI(float p0, double p1, struct S_IPI p2,  void (*cb)(float, double, struct S_IPI)) ;
+EXPORT void f3_V_FDS_IPF(float p0, double p1, struct S_IPF p2,  void (*cb)(float, double, struct S_IPF)) ;
+EXPORT void f3_V_FDS_IPD(float p0, double p1, struct S_IPD p2,  void (*cb)(float, double, struct S_IPD)) ;
+EXPORT void f3_V_FDS_IPP(float p0, double p1, struct S_IPP p2,  void (*cb)(float, double, struct S_IPP)) ;
+EXPORT void f3_V_FDS_FII(float p0, double p1, struct S_FII p2,  void (*cb)(float, double, struct S_FII)) ;
+EXPORT void f3_V_FDS_FIF(float p0, double p1, struct S_FIF p2,  void (*cb)(float, double, struct S_FIF)) ;
+EXPORT void f3_V_FDS_FID(float p0, double p1, struct S_FID p2,  void (*cb)(float, double, struct S_FID)) ;
+EXPORT void f3_V_FDS_FIP(float p0, double p1, struct S_FIP p2,  void (*cb)(float, double, struct S_FIP)) ;
+EXPORT void f3_V_FDS_FFI(float p0, double p1, struct S_FFI p2,  void (*cb)(float, double, struct S_FFI)) ;
+EXPORT void f3_V_FDS_FFF(float p0, double p1, struct S_FFF p2,  void (*cb)(float, double, struct S_FFF)) ;
+EXPORT void f3_V_FDS_FFD(float p0, double p1, struct S_FFD p2,  void (*cb)(float, double, struct S_FFD)) ;
+EXPORT void f3_V_FDS_FFP(float p0, double p1, struct S_FFP p2,  void (*cb)(float, double, struct S_FFP)) ;
+EXPORT void f3_V_FDS_FDI(float p0, double p1, struct S_FDI p2,  void (*cb)(float, double, struct S_FDI)) ;
+EXPORT void f3_V_FDS_FDF(float p0, double p1, struct S_FDF p2,  void (*cb)(float, double, struct S_FDF)) ;
+EXPORT void f3_V_FDS_FDD(float p0, double p1, struct S_FDD p2,  void (*cb)(float, double, struct S_FDD)) ;
+EXPORT void f3_V_FDS_FDP(float p0, double p1, struct S_FDP p2,  void (*cb)(float, double, struct S_FDP)) ;
+EXPORT void f3_V_FDS_FPI(float p0, double p1, struct S_FPI p2,  void (*cb)(float, double, struct S_FPI)) ;
+EXPORT void f3_V_FDS_FPF(float p0, double p1, struct S_FPF p2,  void (*cb)(float, double, struct S_FPF)) ;
+EXPORT void f3_V_FDS_FPD(float p0, double p1, struct S_FPD p2,  void (*cb)(float, double, struct S_FPD)) ;
+EXPORT void f3_V_FDS_FPP(float p0, double p1, struct S_FPP p2,  void (*cb)(float, double, struct S_FPP)) ;
+EXPORT void f3_V_FDS_DII(float p0, double p1, struct S_DII p2,  void (*cb)(float, double, struct S_DII)) ;
+EXPORT void f3_V_FDS_DIF(float p0, double p1, struct S_DIF p2,  void (*cb)(float, double, struct S_DIF)) ;
+EXPORT void f3_V_FDS_DID(float p0, double p1, struct S_DID p2,  void (*cb)(float, double, struct S_DID)) ;
+EXPORT void f3_V_FDS_DIP(float p0, double p1, struct S_DIP p2,  void (*cb)(float, double, struct S_DIP)) ;
+EXPORT void f3_V_FDS_DFI(float p0, double p1, struct S_DFI p2,  void (*cb)(float, double, struct S_DFI)) ;
+EXPORT void f3_V_FDS_DFF(float p0, double p1, struct S_DFF p2,  void (*cb)(float, double, struct S_DFF)) ;
+EXPORT void f3_V_FDS_DFD(float p0, double p1, struct S_DFD p2,  void (*cb)(float, double, struct S_DFD)) ;
+EXPORT void f3_V_FDS_DFP(float p0, double p1, struct S_DFP p2,  void (*cb)(float, double, struct S_DFP)) ;
+EXPORT void f3_V_FDS_DDI(float p0, double p1, struct S_DDI p2,  void (*cb)(float, double, struct S_DDI)) ;
+EXPORT void f3_V_FDS_DDF(float p0, double p1, struct S_DDF p2,  void (*cb)(float, double, struct S_DDF)) ;
+EXPORT void f3_V_FDS_DDD(float p0, double p1, struct S_DDD p2,  void (*cb)(float, double, struct S_DDD)) ;
+EXPORT void f3_V_FDS_DDP(float p0, double p1, struct S_DDP p2,  void (*cb)(float, double, struct S_DDP)) ;
+EXPORT void f3_V_FDS_DPI(float p0, double p1, struct S_DPI p2,  void (*cb)(float, double, struct S_DPI)) ;
+EXPORT void f3_V_FDS_DPF(float p0, double p1, struct S_DPF p2,  void (*cb)(float, double, struct S_DPF)) ;
+EXPORT void f3_V_FDS_DPD(float p0, double p1, struct S_DPD p2,  void (*cb)(float, double, struct S_DPD)) ;
+EXPORT void f3_V_FDS_DPP(float p0, double p1, struct S_DPP p2,  void (*cb)(float, double, struct S_DPP)) ;
+EXPORT void f3_V_FDS_PII(float p0, double p1, struct S_PII p2,  void (*cb)(float, double, struct S_PII)) ;
+EXPORT void f3_V_FDS_PIF(float p0, double p1, struct S_PIF p2,  void (*cb)(float, double, struct S_PIF)) ;
+EXPORT void f3_V_FDS_PID(float p0, double p1, struct S_PID p2,  void (*cb)(float, double, struct S_PID)) ;
+EXPORT void f3_V_FDS_PIP(float p0, double p1, struct S_PIP p2,  void (*cb)(float, double, struct S_PIP)) ;
+EXPORT void f3_V_FDS_PFI(float p0, double p1, struct S_PFI p2,  void (*cb)(float, double, struct S_PFI)) ;
+EXPORT void f3_V_FDS_PFF(float p0, double p1, struct S_PFF p2,  void (*cb)(float, double, struct S_PFF)) ;
+EXPORT void f3_V_FDS_PFD(float p0, double p1, struct S_PFD p2,  void (*cb)(float, double, struct S_PFD)) ;
+EXPORT void f3_V_FDS_PFP(float p0, double p1, struct S_PFP p2,  void (*cb)(float, double, struct S_PFP)) ;
+EXPORT void f3_V_FDS_PDI(float p0, double p1, struct S_PDI p2,  void (*cb)(float, double, struct S_PDI)) ;
+EXPORT void f3_V_FDS_PDF(float p0, double p1, struct S_PDF p2,  void (*cb)(float, double, struct S_PDF)) ;
+EXPORT void f3_V_FDS_PDD(float p0, double p1, struct S_PDD p2,  void (*cb)(float, double, struct S_PDD)) ;
+EXPORT void f3_V_FDS_PDP(float p0, double p1, struct S_PDP p2,  void (*cb)(float, double, struct S_PDP)) ;
+EXPORT void f3_V_FDS_PPI(float p0, double p1, struct S_PPI p2,  void (*cb)(float, double, struct S_PPI)) ;
+EXPORT void f3_V_FDS_PPF(float p0, double p1, struct S_PPF p2,  void (*cb)(float, double, struct S_PPF)) ;
+EXPORT void f3_V_FDS_PPD(float p0, double p1, struct S_PPD p2,  void (*cb)(float, double, struct S_PPD)) ;
+EXPORT void f3_V_FDS_PPP(float p0, double p1, struct S_PPP p2,  void (*cb)(float, double, struct S_PPP)) ;
+EXPORT void f3_V_FPI_(float p0, void* p1, int p2,  void (*cb)(float, void*, int)) ;
+EXPORT void f3_V_FPF_(float p0, void* p1, float p2,  void (*cb)(float, void*, float)) ;
+EXPORT void f3_V_FPD_(float p0, void* p1, double p2,  void (*cb)(float, void*, double)) ;
+EXPORT void f3_V_FPP_(float p0, void* p1, void* p2,  void (*cb)(float, void*, void*)) ;
+EXPORT void f3_V_FPS_I(float p0, void* p1, struct S_I p2,  void (*cb)(float, void*, struct S_I)) ;
+EXPORT void f3_V_FPS_F(float p0, void* p1, struct S_F p2,  void (*cb)(float, void*, struct S_F)) ;
+EXPORT void f3_V_FPS_D(float p0, void* p1, struct S_D p2,  void (*cb)(float, void*, struct S_D)) ;
+EXPORT void f3_V_FPS_P(float p0, void* p1, struct S_P p2,  void (*cb)(float, void*, struct S_P)) ;
+EXPORT void f3_V_FPS_II(float p0, void* p1, struct S_II p2,  void (*cb)(float, void*, struct S_II)) ;
+EXPORT void f3_V_FPS_IF(float p0, void* p1, struct S_IF p2,  void (*cb)(float, void*, struct S_IF)) ;
+EXPORT void f3_V_FPS_ID(float p0, void* p1, struct S_ID p2,  void (*cb)(float, void*, struct S_ID)) ;
+EXPORT void f3_V_FPS_IP(float p0, void* p1, struct S_IP p2,  void (*cb)(float, void*, struct S_IP)) ;
+EXPORT void f3_V_FPS_FI(float p0, void* p1, struct S_FI p2,  void (*cb)(float, void*, struct S_FI)) ;
+EXPORT void f3_V_FPS_FF(float p0, void* p1, struct S_FF p2,  void (*cb)(float, void*, struct S_FF)) ;
+EXPORT void f3_V_FPS_FD(float p0, void* p1, struct S_FD p2,  void (*cb)(float, void*, struct S_FD)) ;
+EXPORT void f3_V_FPS_FP(float p0, void* p1, struct S_FP p2,  void (*cb)(float, void*, struct S_FP)) ;
+EXPORT void f3_V_FPS_DI(float p0, void* p1, struct S_DI p2,  void (*cb)(float, void*, struct S_DI)) ;
+EXPORT void f3_V_FPS_DF(float p0, void* p1, struct S_DF p2,  void (*cb)(float, void*, struct S_DF)) ;
+EXPORT void f3_V_FPS_DD(float p0, void* p1, struct S_DD p2,  void (*cb)(float, void*, struct S_DD)) ;
+EXPORT void f3_V_FPS_DP(float p0, void* p1, struct S_DP p2,  void (*cb)(float, void*, struct S_DP)) ;
+EXPORT void f3_V_FPS_PI(float p0, void* p1, struct S_PI p2,  void (*cb)(float, void*, struct S_PI)) ;
+EXPORT void f3_V_FPS_PF(float p0, void* p1, struct S_PF p2,  void (*cb)(float, void*, struct S_PF)) ;
+EXPORT void f3_V_FPS_PD(float p0, void* p1, struct S_PD p2,  void (*cb)(float, void*, struct S_PD)) ;
+EXPORT void f3_V_FPS_PP(float p0, void* p1, struct S_PP p2,  void (*cb)(float, void*, struct S_PP)) ;
+EXPORT void f3_V_FPS_III(float p0, void* p1, struct S_III p2,  void (*cb)(float, void*, struct S_III)) ;
+EXPORT void f3_V_FPS_IIF(float p0, void* p1, struct S_IIF p2,  void (*cb)(float, void*, struct S_IIF)) ;
+EXPORT void f3_V_FPS_IID(float p0, void* p1, struct S_IID p2,  void (*cb)(float, void*, struct S_IID)) ;
+EXPORT void f3_V_FPS_IIP(float p0, void* p1, struct S_IIP p2,  void (*cb)(float, void*, struct S_IIP)) ;
+EXPORT void f3_V_FPS_IFI(float p0, void* p1, struct S_IFI p2,  void (*cb)(float, void*, struct S_IFI)) ;
+EXPORT void f3_V_FPS_IFF(float p0, void* p1, struct S_IFF p2,  void (*cb)(float, void*, struct S_IFF)) ;
+EXPORT void f3_V_FPS_IFD(float p0, void* p1, struct S_IFD p2,  void (*cb)(float, void*, struct S_IFD)) ;
+EXPORT void f3_V_FPS_IFP(float p0, void* p1, struct S_IFP p2,  void (*cb)(float, void*, struct S_IFP)) ;
+EXPORT void f3_V_FPS_IDI(float p0, void* p1, struct S_IDI p2,  void (*cb)(float, void*, struct S_IDI)) ;
+EXPORT void f3_V_FPS_IDF(float p0, void* p1, struct S_IDF p2,  void (*cb)(float, void*, struct S_IDF)) ;
+EXPORT void f3_V_FPS_IDD(float p0, void* p1, struct S_IDD p2,  void (*cb)(float, void*, struct S_IDD)) ;
+EXPORT void f3_V_FPS_IDP(float p0, void* p1, struct S_IDP p2,  void (*cb)(float, void*, struct S_IDP)) ;
+EXPORT void f3_V_FPS_IPI(float p0, void* p1, struct S_IPI p2,  void (*cb)(float, void*, struct S_IPI)) ;
+EXPORT void f3_V_FPS_IPF(float p0, void* p1, struct S_IPF p2,  void (*cb)(float, void*, struct S_IPF)) ;
+EXPORT void f3_V_FPS_IPD(float p0, void* p1, struct S_IPD p2,  void (*cb)(float, void*, struct S_IPD)) ;
+EXPORT void f3_V_FPS_IPP(float p0, void* p1, struct S_IPP p2,  void (*cb)(float, void*, struct S_IPP)) ;
+EXPORT void f3_V_FPS_FII(float p0, void* p1, struct S_FII p2,  void (*cb)(float, void*, struct S_FII)) ;
+EXPORT void f3_V_FPS_FIF(float p0, void* p1, struct S_FIF p2,  void (*cb)(float, void*, struct S_FIF)) ;
+EXPORT void f3_V_FPS_FID(float p0, void* p1, struct S_FID p2,  void (*cb)(float, void*, struct S_FID)) ;
+EXPORT void f3_V_FPS_FIP(float p0, void* p1, struct S_FIP p2,  void (*cb)(float, void*, struct S_FIP)) ;
+EXPORT void f3_V_FPS_FFI(float p0, void* p1, struct S_FFI p2,  void (*cb)(float, void*, struct S_FFI)) ;
+EXPORT void f3_V_FPS_FFF(float p0, void* p1, struct S_FFF p2,  void (*cb)(float, void*, struct S_FFF)) ;
+EXPORT void f3_V_FPS_FFD(float p0, void* p1, struct S_FFD p2,  void (*cb)(float, void*, struct S_FFD)) ;
+EXPORT void f3_V_FPS_FFP(float p0, void* p1, struct S_FFP p2,  void (*cb)(float, void*, struct S_FFP)) ;
+EXPORT void f3_V_FPS_FDI(float p0, void* p1, struct S_FDI p2,  void (*cb)(float, void*, struct S_FDI)) ;
+EXPORT void f3_V_FPS_FDF(float p0, void* p1, struct S_FDF p2,  void (*cb)(float, void*, struct S_FDF)) ;
+EXPORT void f3_V_FPS_FDD(float p0, void* p1, struct S_FDD p2,  void (*cb)(float, void*, struct S_FDD)) ;
+EXPORT void f3_V_FPS_FDP(float p0, void* p1, struct S_FDP p2,  void (*cb)(float, void*, struct S_FDP)) ;
+EXPORT void f3_V_FPS_FPI(float p0, void* p1, struct S_FPI p2,  void (*cb)(float, void*, struct S_FPI)) ;
+EXPORT void f3_V_FPS_FPF(float p0, void* p1, struct S_FPF p2,  void (*cb)(float, void*, struct S_FPF)) ;
+EXPORT void f3_V_FPS_FPD(float p0, void* p1, struct S_FPD p2,  void (*cb)(float, void*, struct S_FPD)) ;
+EXPORT void f3_V_FPS_FPP(float p0, void* p1, struct S_FPP p2,  void (*cb)(float, void*, struct S_FPP)) ;
+EXPORT void f3_V_FPS_DII(float p0, void* p1, struct S_DII p2,  void (*cb)(float, void*, struct S_DII)) ;
+EXPORT void f3_V_FPS_DIF(float p0, void* p1, struct S_DIF p2,  void (*cb)(float, void*, struct S_DIF)) ;
+EXPORT void f3_V_FPS_DID(float p0, void* p1, struct S_DID p2,  void (*cb)(float, void*, struct S_DID)) ;
+EXPORT void f3_V_FPS_DIP(float p0, void* p1, struct S_DIP p2,  void (*cb)(float, void*, struct S_DIP)) ;
+EXPORT void f3_V_FPS_DFI(float p0, void* p1, struct S_DFI p2,  void (*cb)(float, void*, struct S_DFI)) ;
+EXPORT void f3_V_FPS_DFF(float p0, void* p1, struct S_DFF p2,  void (*cb)(float, void*, struct S_DFF)) ;
+EXPORT void f3_V_FPS_DFD(float p0, void* p1, struct S_DFD p2,  void (*cb)(float, void*, struct S_DFD)) ;
+EXPORT void f3_V_FPS_DFP(float p0, void* p1, struct S_DFP p2,  void (*cb)(float, void*, struct S_DFP)) ;
+EXPORT void f3_V_FPS_DDI(float p0, void* p1, struct S_DDI p2,  void (*cb)(float, void*, struct S_DDI)) ;
+EXPORT void f3_V_FPS_DDF(float p0, void* p1, struct S_DDF p2,  void (*cb)(float, void*, struct S_DDF)) ;
+EXPORT void f3_V_FPS_DDD(float p0, void* p1, struct S_DDD p2,  void (*cb)(float, void*, struct S_DDD)) ;
+EXPORT void f3_V_FPS_DDP(float p0, void* p1, struct S_DDP p2,  void (*cb)(float, void*, struct S_DDP)) ;
+EXPORT void f3_V_FPS_DPI(float p0, void* p1, struct S_DPI p2,  void (*cb)(float, void*, struct S_DPI)) ;
+EXPORT void f3_V_FPS_DPF(float p0, void* p1, struct S_DPF p2,  void (*cb)(float, void*, struct S_DPF)) ;
+EXPORT void f3_V_FPS_DPD(float p0, void* p1, struct S_DPD p2,  void (*cb)(float, void*, struct S_DPD)) ;
+EXPORT void f3_V_FPS_DPP(float p0, void* p1, struct S_DPP p2,  void (*cb)(float, void*, struct S_DPP)) ;
+EXPORT void f3_V_FPS_PII(float p0, void* p1, struct S_PII p2,  void (*cb)(float, void*, struct S_PII)) ;
+EXPORT void f3_V_FPS_PIF(float p0, void* p1, struct S_PIF p2,  void (*cb)(float, void*, struct S_PIF)) ;
+EXPORT void f3_V_FPS_PID(float p0, void* p1, struct S_PID p2,  void (*cb)(float, void*, struct S_PID)) ;
+EXPORT void f3_V_FPS_PIP(float p0, void* p1, struct S_PIP p2,  void (*cb)(float, void*, struct S_PIP)) ;
+EXPORT void f3_V_FPS_PFI(float p0, void* p1, struct S_PFI p2,  void (*cb)(float, void*, struct S_PFI)) ;
+EXPORT void f3_V_FPS_PFF(float p0, void* p1, struct S_PFF p2,  void (*cb)(float, void*, struct S_PFF)) ;
+EXPORT void f3_V_FPS_PFD(float p0, void* p1, struct S_PFD p2,  void (*cb)(float, void*, struct S_PFD)) ;
+EXPORT void f3_V_FPS_PFP(float p0, void* p1, struct S_PFP p2,  void (*cb)(float, void*, struct S_PFP)) ;
+EXPORT void f3_V_FPS_PDI(float p0, void* p1, struct S_PDI p2,  void (*cb)(float, void*, struct S_PDI)) ;
+EXPORT void f3_V_FPS_PDF(float p0, void* p1, struct S_PDF p2,  void (*cb)(float, void*, struct S_PDF)) ;
+EXPORT void f3_V_FPS_PDD(float p0, void* p1, struct S_PDD p2,  void (*cb)(float, void*, struct S_PDD)) ;
+EXPORT void f3_V_FPS_PDP(float p0, void* p1, struct S_PDP p2,  void (*cb)(float, void*, struct S_PDP)) ;
+EXPORT void f3_V_FPS_PPI(float p0, void* p1, struct S_PPI p2,  void (*cb)(float, void*, struct S_PPI)) ;
+EXPORT void f3_V_FPS_PPF(float p0, void* p1, struct S_PPF p2,  void (*cb)(float, void*, struct S_PPF)) ;
+EXPORT void f3_V_FPS_PPD(float p0, void* p1, struct S_PPD p2,  void (*cb)(float, void*, struct S_PPD)) ;
+EXPORT void f3_V_FPS_PPP(float p0, void* p1, struct S_PPP p2,  void (*cb)(float, void*, struct S_PPP)) ;
+EXPORT void f3_V_FSI_I(float p0, struct S_I p1, int p2,  void (*cb)(float, struct S_I, int)) ;
+EXPORT void f3_V_FSI_F(float p0, struct S_F p1, int p2,  void (*cb)(float, struct S_F, int)) ;
+EXPORT void f3_V_FSI_D(float p0, struct S_D p1, int p2,  void (*cb)(float, struct S_D, int)) ;
+EXPORT void f3_V_FSI_P(float p0, struct S_P p1, int p2,  void (*cb)(float, struct S_P, int)) ;
+EXPORT void f3_V_FSI_II(float p0, struct S_II p1, int p2,  void (*cb)(float, struct S_II, int)) ;
+EXPORT void f3_V_FSI_IF(float p0, struct S_IF p1, int p2,  void (*cb)(float, struct S_IF, int)) ;
+EXPORT void f3_V_FSI_ID(float p0, struct S_ID p1, int p2,  void (*cb)(float, struct S_ID, int)) ;
+EXPORT void f3_V_FSI_IP(float p0, struct S_IP p1, int p2,  void (*cb)(float, struct S_IP, int)) ;
+EXPORT void f3_V_FSI_FI(float p0, struct S_FI p1, int p2,  void (*cb)(float, struct S_FI, int)) ;
+EXPORT void f3_V_FSI_FF(float p0, struct S_FF p1, int p2,  void (*cb)(float, struct S_FF, int)) ;
+EXPORT void f3_V_FSI_FD(float p0, struct S_FD p1, int p2,  void (*cb)(float, struct S_FD, int)) ;
+EXPORT void f3_V_FSI_FP(float p0, struct S_FP p1, int p2,  void (*cb)(float, struct S_FP, int)) ;
+EXPORT void f3_V_FSI_DI(float p0, struct S_DI p1, int p2,  void (*cb)(float, struct S_DI, int)) ;
+EXPORT void f3_V_FSI_DF(float p0, struct S_DF p1, int p2,  void (*cb)(float, struct S_DF, int)) ;
+EXPORT void f3_V_FSI_DD(float p0, struct S_DD p1, int p2,  void (*cb)(float, struct S_DD, int)) ;
+EXPORT void f3_V_FSI_DP(float p0, struct S_DP p1, int p2,  void (*cb)(float, struct S_DP, int)) ;
+EXPORT void f3_V_FSI_PI(float p0, struct S_PI p1, int p2,  void (*cb)(float, struct S_PI, int)) ;
+EXPORT void f3_V_FSI_PF(float p0, struct S_PF p1, int p2,  void (*cb)(float, struct S_PF, int)) ;
+EXPORT void f3_V_FSI_PD(float p0, struct S_PD p1, int p2,  void (*cb)(float, struct S_PD, int)) ;
+EXPORT void f3_V_FSI_PP(float p0, struct S_PP p1, int p2,  void (*cb)(float, struct S_PP, int)) ;
+EXPORT void f3_V_FSI_III(float p0, struct S_III p1, int p2,  void (*cb)(float, struct S_III, int)) ;
+EXPORT void f3_V_FSI_IIF(float p0, struct S_IIF p1, int p2,  void (*cb)(float, struct S_IIF, int)) ;
+EXPORT void f3_V_FSI_IID(float p0, struct S_IID p1, int p2,  void (*cb)(float, struct S_IID, int)) ;
+EXPORT void f3_V_FSI_IIP(float p0, struct S_IIP p1, int p2,  void (*cb)(float, struct S_IIP, int)) ;
+EXPORT void f3_V_FSI_IFI(float p0, struct S_IFI p1, int p2,  void (*cb)(float, struct S_IFI, int)) ;
+EXPORT void f3_V_FSI_IFF(float p0, struct S_IFF p1, int p2,  void (*cb)(float, struct S_IFF, int)) ;
+EXPORT void f3_V_FSI_IFD(float p0, struct S_IFD p1, int p2,  void (*cb)(float, struct S_IFD, int)) ;
+EXPORT void f3_V_FSI_IFP(float p0, struct S_IFP p1, int p2,  void (*cb)(float, struct S_IFP, int)) ;
+EXPORT void f3_V_FSI_IDI(float p0, struct S_IDI p1, int p2,  void (*cb)(float, struct S_IDI, int)) ;
+EXPORT void f3_V_FSI_IDF(float p0, struct S_IDF p1, int p2,  void (*cb)(float, struct S_IDF, int)) ;
+EXPORT void f3_V_FSI_IDD(float p0, struct S_IDD p1, int p2,  void (*cb)(float, struct S_IDD, int)) ;
+EXPORT void f3_V_FSI_IDP(float p0, struct S_IDP p1, int p2,  void (*cb)(float, struct S_IDP, int)) ;
+EXPORT void f3_V_FSI_IPI(float p0, struct S_IPI p1, int p2,  void (*cb)(float, struct S_IPI, int)) ;
+EXPORT void f3_V_FSI_IPF(float p0, struct S_IPF p1, int p2,  void (*cb)(float, struct S_IPF, int)) ;
+EXPORT void f3_V_FSI_IPD(float p0, struct S_IPD p1, int p2,  void (*cb)(float, struct S_IPD, int)) ;
+EXPORT void f3_V_FSI_IPP(float p0, struct S_IPP p1, int p2,  void (*cb)(float, struct S_IPP, int)) ;
+EXPORT void f3_V_FSI_FII(float p0, struct S_FII p1, int p2,  void (*cb)(float, struct S_FII, int)) ;
+EXPORT void f3_V_FSI_FIF(float p0, struct S_FIF p1, int p2,  void (*cb)(float, struct S_FIF, int)) ;
+EXPORT void f3_V_FSI_FID(float p0, struct S_FID p1, int p2,  void (*cb)(float, struct S_FID, int)) ;
+EXPORT void f3_V_FSI_FIP(float p0, struct S_FIP p1, int p2,  void (*cb)(float, struct S_FIP, int)) ;
+EXPORT void f3_V_FSI_FFI(float p0, struct S_FFI p1, int p2,  void (*cb)(float, struct S_FFI, int)) ;
+EXPORT void f3_V_FSI_FFF(float p0, struct S_FFF p1, int p2,  void (*cb)(float, struct S_FFF, int)) ;
+EXPORT void f3_V_FSI_FFD(float p0, struct S_FFD p1, int p2,  void (*cb)(float, struct S_FFD, int)) ;
+EXPORT void f3_V_FSI_FFP(float p0, struct S_FFP p1, int p2,  void (*cb)(float, struct S_FFP, int)) ;
+EXPORT void f3_V_FSI_FDI(float p0, struct S_FDI p1, int p2,  void (*cb)(float, struct S_FDI, int)) ;
+EXPORT void f3_V_FSI_FDF(float p0, struct S_FDF p1, int p2,  void (*cb)(float, struct S_FDF, int)) ;
+EXPORT void f3_V_FSI_FDD(float p0, struct S_FDD p1, int p2,  void (*cb)(float, struct S_FDD, int)) ;
+EXPORT void f3_V_FSI_FDP(float p0, struct S_FDP p1, int p2,  void (*cb)(float, struct S_FDP, int)) ;
+EXPORT void f3_V_FSI_FPI(float p0, struct S_FPI p1, int p2,  void (*cb)(float, struct S_FPI, int)) ;
+EXPORT void f3_V_FSI_FPF(float p0, struct S_FPF p1, int p2,  void (*cb)(float, struct S_FPF, int)) ;
+EXPORT void f3_V_FSI_FPD(float p0, struct S_FPD p1, int p2,  void (*cb)(float, struct S_FPD, int)) ;
+EXPORT void f3_V_FSI_FPP(float p0, struct S_FPP p1, int p2,  void (*cb)(float, struct S_FPP, int)) ;
+EXPORT void f3_V_FSI_DII(float p0, struct S_DII p1, int p2,  void (*cb)(float, struct S_DII, int)) ;
+EXPORT void f3_V_FSI_DIF(float p0, struct S_DIF p1, int p2,  void (*cb)(float, struct S_DIF, int)) ;
+EXPORT void f3_V_FSI_DID(float p0, struct S_DID p1, int p2,  void (*cb)(float, struct S_DID, int)) ;
+EXPORT void f3_V_FSI_DIP(float p0, struct S_DIP p1, int p2,  void (*cb)(float, struct S_DIP, int)) ;
+EXPORT void f3_V_FSI_DFI(float p0, struct S_DFI p1, int p2,  void (*cb)(float, struct S_DFI, int)) ;
+EXPORT void f3_V_FSI_DFF(float p0, struct S_DFF p1, int p2,  void (*cb)(float, struct S_DFF, int)) ;
+EXPORT void f3_V_FSI_DFD(float p0, struct S_DFD p1, int p2,  void (*cb)(float, struct S_DFD, int)) ;
+EXPORT void f3_V_FSI_DFP(float p0, struct S_DFP p1, int p2,  void (*cb)(float, struct S_DFP, int)) ;
+EXPORT void f3_V_FSI_DDI(float p0, struct S_DDI p1, int p2,  void (*cb)(float, struct S_DDI, int)) ;
+EXPORT void f3_V_FSI_DDF(float p0, struct S_DDF p1, int p2,  void (*cb)(float, struct S_DDF, int)) ;
+EXPORT void f3_V_FSI_DDD(float p0, struct S_DDD p1, int p2,  void (*cb)(float, struct S_DDD, int)) ;
+EXPORT void f3_V_FSI_DDP(float p0, struct S_DDP p1, int p2,  void (*cb)(float, struct S_DDP, int)) ;
+EXPORT void f3_V_FSI_DPI(float p0, struct S_DPI p1, int p2,  void (*cb)(float, struct S_DPI, int)) ;
+EXPORT void f3_V_FSI_DPF(float p0, struct S_DPF p1, int p2,  void (*cb)(float, struct S_DPF, int)) ;
+EXPORT void f3_V_FSI_DPD(float p0, struct S_DPD p1, int p2,  void (*cb)(float, struct S_DPD, int)) ;
+EXPORT void f3_V_FSI_DPP(float p0, struct S_DPP p1, int p2,  void (*cb)(float, struct S_DPP, int)) ;
+EXPORT void f3_V_FSI_PII(float p0, struct S_PII p1, int p2,  void (*cb)(float, struct S_PII, int)) ;
+EXPORT void f3_V_FSI_PIF(float p0, struct S_PIF p1, int p2,  void (*cb)(float, struct S_PIF, int)) ;
+EXPORT void f3_V_FSI_PID(float p0, struct S_PID p1, int p2,  void (*cb)(float, struct S_PID, int)) ;
+EXPORT void f3_V_FSI_PIP(float p0, struct S_PIP p1, int p2,  void (*cb)(float, struct S_PIP, int)) ;
+EXPORT void f3_V_FSI_PFI(float p0, struct S_PFI p1, int p2,  void (*cb)(float, struct S_PFI, int)) ;
+EXPORT void f3_V_FSI_PFF(float p0, struct S_PFF p1, int p2,  void (*cb)(float, struct S_PFF, int)) ;
+EXPORT void f3_V_FSI_PFD(float p0, struct S_PFD p1, int p2,  void (*cb)(float, struct S_PFD, int)) ;
+EXPORT void f3_V_FSI_PFP(float p0, struct S_PFP p1, int p2,  void (*cb)(float, struct S_PFP, int)) ;
+EXPORT void f3_V_FSI_PDI(float p0, struct S_PDI p1, int p2,  void (*cb)(float, struct S_PDI, int)) ;
+EXPORT void f3_V_FSI_PDF(float p0, struct S_PDF p1, int p2,  void (*cb)(float, struct S_PDF, int)) ;
+EXPORT void f3_V_FSI_PDD(float p0, struct S_PDD p1, int p2,  void (*cb)(float, struct S_PDD, int)) ;
+EXPORT void f3_V_FSI_PDP(float p0, struct S_PDP p1, int p2,  void (*cb)(float, struct S_PDP, int)) ;
+EXPORT void f3_V_FSI_PPI(float p0, struct S_PPI p1, int p2,  void (*cb)(float, struct S_PPI, int)) ;
+EXPORT void f3_V_FSI_PPF(float p0, struct S_PPF p1, int p2,  void (*cb)(float, struct S_PPF, int)) ;
+EXPORT void f3_V_FSI_PPD(float p0, struct S_PPD p1, int p2,  void (*cb)(float, struct S_PPD, int)) ;
+EXPORT void f3_V_FSI_PPP(float p0, struct S_PPP p1, int p2,  void (*cb)(float, struct S_PPP, int)) ;
+EXPORT void f3_V_FSF_I(float p0, struct S_I p1, float p2,  void (*cb)(float, struct S_I, float)) ;
+EXPORT void f3_V_FSF_F(float p0, struct S_F p1, float p2,  void (*cb)(float, struct S_F, float)) ;
+EXPORT void f3_V_FSF_D(float p0, struct S_D p1, float p2,  void (*cb)(float, struct S_D, float)) ;
+EXPORT void f3_V_FSF_P(float p0, struct S_P p1, float p2,  void (*cb)(float, struct S_P, float)) ;
+EXPORT void f3_V_FSF_II(float p0, struct S_II p1, float p2,  void (*cb)(float, struct S_II, float)) ;
+EXPORT void f3_V_FSF_IF(float p0, struct S_IF p1, float p2,  void (*cb)(float, struct S_IF, float)) ;
+EXPORT void f3_V_FSF_ID(float p0, struct S_ID p1, float p2,  void (*cb)(float, struct S_ID, float)) ;
+EXPORT void f3_V_FSF_IP(float p0, struct S_IP p1, float p2,  void (*cb)(float, struct S_IP, float)) ;
+EXPORT void f3_V_FSF_FI(float p0, struct S_FI p1, float p2,  void (*cb)(float, struct S_FI, float)) ;
+EXPORT void f3_V_FSF_FF(float p0, struct S_FF p1, float p2,  void (*cb)(float, struct S_FF, float)) ;
+EXPORT void f3_V_FSF_FD(float p0, struct S_FD p1, float p2,  void (*cb)(float, struct S_FD, float)) ;
+EXPORT void f3_V_FSF_FP(float p0, struct S_FP p1, float p2,  void (*cb)(float, struct S_FP, float)) ;
+EXPORT void f3_V_FSF_DI(float p0, struct S_DI p1, float p2,  void (*cb)(float, struct S_DI, float)) ;
+EXPORT void f3_V_FSF_DF(float p0, struct S_DF p1, float p2,  void (*cb)(float, struct S_DF, float)) ;
+EXPORT void f3_V_FSF_DD(float p0, struct S_DD p1, float p2,  void (*cb)(float, struct S_DD, float)) ;
+EXPORT void f3_V_FSF_DP(float p0, struct S_DP p1, float p2,  void (*cb)(float, struct S_DP, float)) ;
+EXPORT void f3_V_FSF_PI(float p0, struct S_PI p1, float p2,  void (*cb)(float, struct S_PI, float)) ;
+EXPORT void f3_V_FSF_PF(float p0, struct S_PF p1, float p2,  void (*cb)(float, struct S_PF, float)) ;
+EXPORT void f3_V_FSF_PD(float p0, struct S_PD p1, float p2,  void (*cb)(float, struct S_PD, float)) ;
+EXPORT void f3_V_FSF_PP(float p0, struct S_PP p1, float p2,  void (*cb)(float, struct S_PP, float)) ;
+EXPORT void f3_V_FSF_III(float p0, struct S_III p1, float p2,  void (*cb)(float, struct S_III, float)) ;
+EXPORT void f3_V_FSF_IIF(float p0, struct S_IIF p1, float p2,  void (*cb)(float, struct S_IIF, float)) ;
+EXPORT void f3_V_FSF_IID(float p0, struct S_IID p1, float p2,  void (*cb)(float, struct S_IID, float)) ;
+EXPORT void f3_V_FSF_IIP(float p0, struct S_IIP p1, float p2,  void (*cb)(float, struct S_IIP, float)) ;
+EXPORT void f3_V_FSF_IFI(float p0, struct S_IFI p1, float p2,  void (*cb)(float, struct S_IFI, float)) ;
+EXPORT void f3_V_FSF_IFF(float p0, struct S_IFF p1, float p2,  void (*cb)(float, struct S_IFF, float)) ;
+EXPORT void f3_V_FSF_IFD(float p0, struct S_IFD p1, float p2,  void (*cb)(float, struct S_IFD, float)) ;
+EXPORT void f3_V_FSF_IFP(float p0, struct S_IFP p1, float p2,  void (*cb)(float, struct S_IFP, float)) ;
+EXPORT void f3_V_FSF_IDI(float p0, struct S_IDI p1, float p2,  void (*cb)(float, struct S_IDI, float)) ;
+EXPORT void f3_V_FSF_IDF(float p0, struct S_IDF p1, float p2,  void (*cb)(float, struct S_IDF, float)) ;
+EXPORT void f3_V_FSF_IDD(float p0, struct S_IDD p1, float p2,  void (*cb)(float, struct S_IDD, float)) ;
+EXPORT void f3_V_FSF_IDP(float p0, struct S_IDP p1, float p2,  void (*cb)(float, struct S_IDP, float)) ;
+EXPORT void f3_V_FSF_IPI(float p0, struct S_IPI p1, float p2,  void (*cb)(float, struct S_IPI, float)) ;
+EXPORT void f3_V_FSF_IPF(float p0, struct S_IPF p1, float p2,  void (*cb)(float, struct S_IPF, float)) ;
+EXPORT void f3_V_FSF_IPD(float p0, struct S_IPD p1, float p2,  void (*cb)(float, struct S_IPD, float)) ;
+EXPORT void f3_V_FSF_IPP(float p0, struct S_IPP p1, float p2,  void (*cb)(float, struct S_IPP, float)) ;
+EXPORT void f3_V_FSF_FII(float p0, struct S_FII p1, float p2,  void (*cb)(float, struct S_FII, float)) ;
+EXPORT void f3_V_FSF_FIF(float p0, struct S_FIF p1, float p2,  void (*cb)(float, struct S_FIF, float)) ;
+EXPORT void f3_V_FSF_FID(float p0, struct S_FID p1, float p2,  void (*cb)(float, struct S_FID, float)) ;
+EXPORT void f3_V_FSF_FIP(float p0, struct S_FIP p1, float p2,  void (*cb)(float, struct S_FIP, float)) ;
+EXPORT void f3_V_FSF_FFI(float p0, struct S_FFI p1, float p2,  void (*cb)(float, struct S_FFI, float)) ;
+EXPORT void f3_V_FSF_FFF(float p0, struct S_FFF p1, float p2,  void (*cb)(float, struct S_FFF, float)) ;
+EXPORT void f3_V_FSF_FFD(float p0, struct S_FFD p1, float p2,  void (*cb)(float, struct S_FFD, float)) ;
+EXPORT void f3_V_FSF_FFP(float p0, struct S_FFP p1, float p2,  void (*cb)(float, struct S_FFP, float)) ;
+EXPORT void f3_V_FSF_FDI(float p0, struct S_FDI p1, float p2,  void (*cb)(float, struct S_FDI, float)) ;
+EXPORT void f3_V_FSF_FDF(float p0, struct S_FDF p1, float p2,  void (*cb)(float, struct S_FDF, float)) ;
+EXPORT void f3_V_FSF_FDD(float p0, struct S_FDD p1, float p2,  void (*cb)(float, struct S_FDD, float)) ;
+EXPORT void f3_V_FSF_FDP(float p0, struct S_FDP p1, float p2,  void (*cb)(float, struct S_FDP, float)) ;
+EXPORT void f3_V_FSF_FPI(float p0, struct S_FPI p1, float p2,  void (*cb)(float, struct S_FPI, float)) ;
+EXPORT void f3_V_FSF_FPF(float p0, struct S_FPF p1, float p2,  void (*cb)(float, struct S_FPF, float)) ;
+EXPORT void f3_V_FSF_FPD(float p0, struct S_FPD p1, float p2,  void (*cb)(float, struct S_FPD, float)) ;
+EXPORT void f3_V_FSF_FPP(float p0, struct S_FPP p1, float p2,  void (*cb)(float, struct S_FPP, float)) ;
+EXPORT void f3_V_FSF_DII(float p0, struct S_DII p1, float p2,  void (*cb)(float, struct S_DII, float)) ;
+EXPORT void f3_V_FSF_DIF(float p0, struct S_DIF p1, float p2,  void (*cb)(float, struct S_DIF, float)) ;
+EXPORT void f3_V_FSF_DID(float p0, struct S_DID p1, float p2,  void (*cb)(float, struct S_DID, float)) ;
+EXPORT void f3_V_FSF_DIP(float p0, struct S_DIP p1, float p2,  void (*cb)(float, struct S_DIP, float)) ;
+EXPORT void f3_V_FSF_DFI(float p0, struct S_DFI p1, float p2,  void (*cb)(float, struct S_DFI, float)) ;
+EXPORT void f3_V_FSF_DFF(float p0, struct S_DFF p1, float p2,  void (*cb)(float, struct S_DFF, float)) ;
+EXPORT void f3_V_FSF_DFD(float p0, struct S_DFD p1, float p2,  void (*cb)(float, struct S_DFD, float)) ;
+EXPORT void f3_V_FSF_DFP(float p0, struct S_DFP p1, float p2,  void (*cb)(float, struct S_DFP, float)) ;
+EXPORT void f3_V_FSF_DDI(float p0, struct S_DDI p1, float p2,  void (*cb)(float, struct S_DDI, float)) ;
+EXPORT void f3_V_FSF_DDF(float p0, struct S_DDF p1, float p2,  void (*cb)(float, struct S_DDF, float)) ;
+EXPORT void f3_V_FSF_DDD(float p0, struct S_DDD p1, float p2,  void (*cb)(float, struct S_DDD, float)) ;
+EXPORT void f3_V_FSF_DDP(float p0, struct S_DDP p1, float p2,  void (*cb)(float, struct S_DDP, float)) ;
+EXPORT void f3_V_FSF_DPI(float p0, struct S_DPI p1, float p2,  void (*cb)(float, struct S_DPI, float)) ;
+EXPORT void f3_V_FSF_DPF(float p0, struct S_DPF p1, float p2,  void (*cb)(float, struct S_DPF, float)) ;
+EXPORT void f3_V_FSF_DPD(float p0, struct S_DPD p1, float p2,  void (*cb)(float, struct S_DPD, float)) ;
+EXPORT void f3_V_FSF_DPP(float p0, struct S_DPP p1, float p2,  void (*cb)(float, struct S_DPP, float)) ;
+EXPORT void f3_V_FSF_PII(float p0, struct S_PII p1, float p2,  void (*cb)(float, struct S_PII, float)) ;
+EXPORT void f3_V_FSF_PIF(float p0, struct S_PIF p1, float p2,  void (*cb)(float, struct S_PIF, float)) ;
+EXPORT void f3_V_FSF_PID(float p0, struct S_PID p1, float p2,  void (*cb)(float, struct S_PID, float)) ;
+EXPORT void f3_V_FSF_PIP(float p0, struct S_PIP p1, float p2,  void (*cb)(float, struct S_PIP, float)) ;
+EXPORT void f3_V_FSF_PFI(float p0, struct S_PFI p1, float p2,  void (*cb)(float, struct S_PFI, float)) ;
+EXPORT void f3_V_FSF_PFF(float p0, struct S_PFF p1, float p2,  void (*cb)(float, struct S_PFF, float)) ;
+EXPORT void f3_V_FSF_PFD(float p0, struct S_PFD p1, float p2,  void (*cb)(float, struct S_PFD, float)) ;
+EXPORT void f3_V_FSF_PFP(float p0, struct S_PFP p1, float p2,  void (*cb)(float, struct S_PFP, float)) ;
+EXPORT void f3_V_FSF_PDI(float p0, struct S_PDI p1, float p2,  void (*cb)(float, struct S_PDI, float)) ;
+EXPORT void f3_V_FSF_PDF(float p0, struct S_PDF p1, float p2,  void (*cb)(float, struct S_PDF, float)) ;
+EXPORT void f3_V_FSF_PDD(float p0, struct S_PDD p1, float p2,  void (*cb)(float, struct S_PDD, float)) ;
+EXPORT void f3_V_FSF_PDP(float p0, struct S_PDP p1, float p2,  void (*cb)(float, struct S_PDP, float)) ;
+EXPORT void f3_V_FSF_PPI(float p0, struct S_PPI p1, float p2,  void (*cb)(float, struct S_PPI, float)) ;
+EXPORT void f3_V_FSF_PPF(float p0, struct S_PPF p1, float p2,  void (*cb)(float, struct S_PPF, float)) ;
+EXPORT void f3_V_FSF_PPD(float p0, struct S_PPD p1, float p2,  void (*cb)(float, struct S_PPD, float)) ;
+EXPORT void f3_V_FSF_PPP(float p0, struct S_PPP p1, float p2,  void (*cb)(float, struct S_PPP, float)) ;
+EXPORT void f3_V_FSD_I(float p0, struct S_I p1, double p2,  void (*cb)(float, struct S_I, double)) ;
+EXPORT void f3_V_FSD_F(float p0, struct S_F p1, double p2,  void (*cb)(float, struct S_F, double)) ;
+EXPORT void f3_V_FSD_D(float p0, struct S_D p1, double p2,  void (*cb)(float, struct S_D, double)) ;
+EXPORT void f3_V_FSD_P(float p0, struct S_P p1, double p2,  void (*cb)(float, struct S_P, double)) ;
+EXPORT void f3_V_FSD_II(float p0, struct S_II p1, double p2,  void (*cb)(float, struct S_II, double)) ;
+EXPORT void f3_V_FSD_IF(float p0, struct S_IF p1, double p2,  void (*cb)(float, struct S_IF, double)) ;
+EXPORT void f3_V_FSD_ID(float p0, struct S_ID p1, double p2,  void (*cb)(float, struct S_ID, double)) ;
+EXPORT void f3_V_FSD_IP(float p0, struct S_IP p1, double p2,  void (*cb)(float, struct S_IP, double)) ;
+EXPORT void f3_V_FSD_FI(float p0, struct S_FI p1, double p2,  void (*cb)(float, struct S_FI, double)) ;
+EXPORT void f3_V_FSD_FF(float p0, struct S_FF p1, double p2,  void (*cb)(float, struct S_FF, double)) ;
+EXPORT void f3_V_FSD_FD(float p0, struct S_FD p1, double p2,  void (*cb)(float, struct S_FD, double)) ;
+EXPORT void f3_V_FSD_FP(float p0, struct S_FP p1, double p2,  void (*cb)(float, struct S_FP, double)) ;
+EXPORT void f3_V_FSD_DI(float p0, struct S_DI p1, double p2,  void (*cb)(float, struct S_DI, double)) ;
+EXPORT void f3_V_FSD_DF(float p0, struct S_DF p1, double p2,  void (*cb)(float, struct S_DF, double)) ;
+EXPORT void f3_V_FSD_DD(float p0, struct S_DD p1, double p2,  void (*cb)(float, struct S_DD, double)) ;
+EXPORT void f3_V_FSD_DP(float p0, struct S_DP p1, double p2,  void (*cb)(float, struct S_DP, double)) ;
+EXPORT void f3_V_FSD_PI(float p0, struct S_PI p1, double p2,  void (*cb)(float, struct S_PI, double)) ;
+EXPORT void f3_V_FSD_PF(float p0, struct S_PF p1, double p2,  void (*cb)(float, struct S_PF, double)) ;
+EXPORT void f3_V_FSD_PD(float p0, struct S_PD p1, double p2,  void (*cb)(float, struct S_PD, double)) ;
+EXPORT void f3_V_FSD_PP(float p0, struct S_PP p1, double p2,  void (*cb)(float, struct S_PP, double)) ;
+EXPORT void f3_V_FSD_III(float p0, struct S_III p1, double p2,  void (*cb)(float, struct S_III, double)) ;
+EXPORT void f3_V_FSD_IIF(float p0, struct S_IIF p1, double p2,  void (*cb)(float, struct S_IIF, double)) ;
+EXPORT void f3_V_FSD_IID(float p0, struct S_IID p1, double p2,  void (*cb)(float, struct S_IID, double)) ;
+EXPORT void f3_V_FSD_IIP(float p0, struct S_IIP p1, double p2,  void (*cb)(float, struct S_IIP, double)) ;
+EXPORT void f3_V_FSD_IFI(float p0, struct S_IFI p1, double p2,  void (*cb)(float, struct S_IFI, double)) ;
+EXPORT void f3_V_FSD_IFF(float p0, struct S_IFF p1, double p2,  void (*cb)(float, struct S_IFF, double)) ;
+EXPORT void f3_V_FSD_IFD(float p0, struct S_IFD p1, double p2,  void (*cb)(float, struct S_IFD, double)) ;
+EXPORT void f3_V_FSD_IFP(float p0, struct S_IFP p1, double p2,  void (*cb)(float, struct S_IFP, double)) ;
+EXPORT void f3_V_FSD_IDI(float p0, struct S_IDI p1, double p2,  void (*cb)(float, struct S_IDI, double)) ;
+EXPORT void f3_V_FSD_IDF(float p0, struct S_IDF p1, double p2,  void (*cb)(float, struct S_IDF, double)) ;
+EXPORT void f3_V_FSD_IDD(float p0, struct S_IDD p1, double p2,  void (*cb)(float, struct S_IDD, double)) ;
+EXPORT void f3_V_FSD_IDP(float p0, struct S_IDP p1, double p2,  void (*cb)(float, struct S_IDP, double)) ;
+EXPORT void f3_V_FSD_IPI(float p0, struct S_IPI p1, double p2,  void (*cb)(float, struct S_IPI, double)) ;
+EXPORT void f3_V_FSD_IPF(float p0, struct S_IPF p1, double p2,  void (*cb)(float, struct S_IPF, double)) ;
+EXPORT void f3_V_FSD_IPD(float p0, struct S_IPD p1, double p2,  void (*cb)(float, struct S_IPD, double)) ;
+EXPORT void f3_V_FSD_IPP(float p0, struct S_IPP p1, double p2,  void (*cb)(float, struct S_IPP, double)) ;
+EXPORT void f3_V_FSD_FII(float p0, struct S_FII p1, double p2,  void (*cb)(float, struct S_FII, double)) ;
+EXPORT void f3_V_FSD_FIF(float p0, struct S_FIF p1, double p2,  void (*cb)(float, struct S_FIF, double)) ;
+EXPORT void f3_V_FSD_FID(float p0, struct S_FID p1, double p2,  void (*cb)(float, struct S_FID, double)) ;
+EXPORT void f3_V_FSD_FIP(float p0, struct S_FIP p1, double p2,  void (*cb)(float, struct S_FIP, double)) ;
+EXPORT void f3_V_FSD_FFI(float p0, struct S_FFI p1, double p2,  void (*cb)(float, struct S_FFI, double)) ;
+EXPORT void f3_V_FSD_FFF(float p0, struct S_FFF p1, double p2,  void (*cb)(float, struct S_FFF, double)) ;
+EXPORT void f3_V_FSD_FFD(float p0, struct S_FFD p1, double p2,  void (*cb)(float, struct S_FFD, double)) ;
+EXPORT void f3_V_FSD_FFP(float p0, struct S_FFP p1, double p2,  void (*cb)(float, struct S_FFP, double)) ;
+EXPORT void f3_V_FSD_FDI(float p0, struct S_FDI p1, double p2,  void (*cb)(float, struct S_FDI, double)) ;
+EXPORT void f3_V_FSD_FDF(float p0, struct S_FDF p1, double p2,  void (*cb)(float, struct S_FDF, double)) ;
+EXPORT void f3_V_FSD_FDD(float p0, struct S_FDD p1, double p2,  void (*cb)(float, struct S_FDD, double)) ;
+EXPORT void f3_V_FSD_FDP(float p0, struct S_FDP p1, double p2,  void (*cb)(float, struct S_FDP, double)) ;
+EXPORT void f3_V_FSD_FPI(float p0, struct S_FPI p1, double p2,  void (*cb)(float, struct S_FPI, double)) ;
+EXPORT void f3_V_FSD_FPF(float p0, struct S_FPF p1, double p2,  void (*cb)(float, struct S_FPF, double)) ;
+EXPORT void f3_V_FSD_FPD(float p0, struct S_FPD p1, double p2,  void (*cb)(float, struct S_FPD, double)) ;
+EXPORT void f3_V_FSD_FPP(float p0, struct S_FPP p1, double p2,  void (*cb)(float, struct S_FPP, double)) ;
+EXPORT void f3_V_FSD_DII(float p0, struct S_DII p1, double p2,  void (*cb)(float, struct S_DII, double)) ;
+EXPORT void f3_V_FSD_DIF(float p0, struct S_DIF p1, double p2,  void (*cb)(float, struct S_DIF, double)) ;
+EXPORT void f3_V_FSD_DID(float p0, struct S_DID p1, double p2,  void (*cb)(float, struct S_DID, double)) ;
+EXPORT void f3_V_FSD_DIP(float p0, struct S_DIP p1, double p2,  void (*cb)(float, struct S_DIP, double)) ;
+EXPORT void f3_V_FSD_DFI(float p0, struct S_DFI p1, double p2,  void (*cb)(float, struct S_DFI, double)) ;
+EXPORT void f3_V_FSD_DFF(float p0, struct S_DFF p1, double p2,  void (*cb)(float, struct S_DFF, double)) ;
+EXPORT void f3_V_FSD_DFD(float p0, struct S_DFD p1, double p2,  void (*cb)(float, struct S_DFD, double)) ;
+EXPORT void f3_V_FSD_DFP(float p0, struct S_DFP p1, double p2,  void (*cb)(float, struct S_DFP, double)) ;
+EXPORT void f3_V_FSD_DDI(float p0, struct S_DDI p1, double p2,  void (*cb)(float, struct S_DDI, double)) ;
+EXPORT void f3_V_FSD_DDF(float p0, struct S_DDF p1, double p2,  void (*cb)(float, struct S_DDF, double)) ;
+EXPORT void f3_V_FSD_DDD(float p0, struct S_DDD p1, double p2,  void (*cb)(float, struct S_DDD, double)) ;
+EXPORT void f3_V_FSD_DDP(float p0, struct S_DDP p1, double p2,  void (*cb)(float, struct S_DDP, double)) ;
+EXPORT void f3_V_FSD_DPI(float p0, struct S_DPI p1, double p2,  void (*cb)(float, struct S_DPI, double)) ;
+EXPORT void f3_V_FSD_DPF(float p0, struct S_DPF p1, double p2,  void (*cb)(float, struct S_DPF, double)) ;
+EXPORT void f3_V_FSD_DPD(float p0, struct S_DPD p1, double p2,  void (*cb)(float, struct S_DPD, double)) ;
+EXPORT void f3_V_FSD_DPP(float p0, struct S_DPP p1, double p2,  void (*cb)(float, struct S_DPP, double)) ;
+EXPORT void f3_V_FSD_PII(float p0, struct S_PII p1, double p2,  void (*cb)(float, struct S_PII, double)) ;
+EXPORT void f3_V_FSD_PIF(float p0, struct S_PIF p1, double p2,  void (*cb)(float, struct S_PIF, double)) ;
+EXPORT void f3_V_FSD_PID(float p0, struct S_PID p1, double p2,  void (*cb)(float, struct S_PID, double)) ;
+EXPORT void f3_V_FSD_PIP(float p0, struct S_PIP p1, double p2,  void (*cb)(float, struct S_PIP, double)) ;
+EXPORT void f3_V_FSD_PFI(float p0, struct S_PFI p1, double p2,  void (*cb)(float, struct S_PFI, double)) ;
+EXPORT void f3_V_FSD_PFF(float p0, struct S_PFF p1, double p2,  void (*cb)(float, struct S_PFF, double)) ;
+EXPORT void f3_V_FSD_PFD(float p0, struct S_PFD p1, double p2,  void (*cb)(float, struct S_PFD, double)) ;
+EXPORT void f3_V_FSD_PFP(float p0, struct S_PFP p1, double p2,  void (*cb)(float, struct S_PFP, double)) ;
+EXPORT void f3_V_FSD_PDI(float p0, struct S_PDI p1, double p2,  void (*cb)(float, struct S_PDI, double)) ;
+EXPORT void f3_V_FSD_PDF(float p0, struct S_PDF p1, double p2,  void (*cb)(float, struct S_PDF, double)) ;
+EXPORT void f3_V_FSD_PDD(float p0, struct S_PDD p1, double p2,  void (*cb)(float, struct S_PDD, double)) ;
+EXPORT void f3_V_FSD_PDP(float p0, struct S_PDP p1, double p2,  void (*cb)(float, struct S_PDP, double)) ;
+EXPORT void f3_V_FSD_PPI(float p0, struct S_PPI p1, double p2,  void (*cb)(float, struct S_PPI, double)) ;
+EXPORT void f3_V_FSD_PPF(float p0, struct S_PPF p1, double p2,  void (*cb)(float, struct S_PPF, double)) ;
+EXPORT void f3_V_FSD_PPD(float p0, struct S_PPD p1, double p2,  void (*cb)(float, struct S_PPD, double)) ;
+EXPORT void f3_V_FSD_PPP(float p0, struct S_PPP p1, double p2,  void (*cb)(float, struct S_PPP, double)) ;
+EXPORT void f3_V_FSP_I(float p0, struct S_I p1, void* p2,  void (*cb)(float, struct S_I, void*)) ;
+EXPORT void f3_V_FSP_F(float p0, struct S_F p1, void* p2,  void (*cb)(float, struct S_F, void*)) ;
+EXPORT void f3_V_FSP_D(float p0, struct S_D p1, void* p2,  void (*cb)(float, struct S_D, void*)) ;
+EXPORT void f3_V_FSP_P(float p0, struct S_P p1, void* p2,  void (*cb)(float, struct S_P, void*)) ;
+EXPORT void f3_V_FSP_II(float p0, struct S_II p1, void* p2,  void (*cb)(float, struct S_II, void*)) ;
+EXPORT void f3_V_FSP_IF(float p0, struct S_IF p1, void* p2,  void (*cb)(float, struct S_IF, void*)) ;
+EXPORT void f3_V_FSP_ID(float p0, struct S_ID p1, void* p2,  void (*cb)(float, struct S_ID, void*)) ;
+EXPORT void f3_V_FSP_IP(float p0, struct S_IP p1, void* p2,  void (*cb)(float, struct S_IP, void*)) ;
+EXPORT void f3_V_FSP_FI(float p0, struct S_FI p1, void* p2,  void (*cb)(float, struct S_FI, void*)) ;
+EXPORT void f3_V_FSP_FF(float p0, struct S_FF p1, void* p2,  void (*cb)(float, struct S_FF, void*)) ;
+EXPORT void f3_V_FSP_FD(float p0, struct S_FD p1, void* p2,  void (*cb)(float, struct S_FD, void*)) ;
+EXPORT void f3_V_FSP_FP(float p0, struct S_FP p1, void* p2,  void (*cb)(float, struct S_FP, void*)) ;
+EXPORT void f3_V_FSP_DI(float p0, struct S_DI p1, void* p2,  void (*cb)(float, struct S_DI, void*)) ;
+EXPORT void f3_V_FSP_DF(float p0, struct S_DF p1, void* p2,  void (*cb)(float, struct S_DF, void*)) ;
+EXPORT void f3_V_FSP_DD(float p0, struct S_DD p1, void* p2,  void (*cb)(float, struct S_DD, void*)) ;
+EXPORT void f3_V_FSP_DP(float p0, struct S_DP p1, void* p2,  void (*cb)(float, struct S_DP, void*)) ;
+EXPORT void f3_V_FSP_PI(float p0, struct S_PI p1, void* p2,  void (*cb)(float, struct S_PI, void*)) ;
+EXPORT void f3_V_FSP_PF(float p0, struct S_PF p1, void* p2,  void (*cb)(float, struct S_PF, void*)) ;
+EXPORT void f3_V_FSP_PD(float p0, struct S_PD p1, void* p2,  void (*cb)(float, struct S_PD, void*)) ;
+EXPORT void f3_V_FSP_PP(float p0, struct S_PP p1, void* p2,  void (*cb)(float, struct S_PP, void*)) ;
+EXPORT void f3_V_FSP_III(float p0, struct S_III p1, void* p2,  void (*cb)(float, struct S_III, void*)) ;
+EXPORT void f3_V_FSP_IIF(float p0, struct S_IIF p1, void* p2,  void (*cb)(float, struct S_IIF, void*)) ;
+EXPORT void f3_V_FSP_IID(float p0, struct S_IID p1, void* p2,  void (*cb)(float, struct S_IID, void*)) ;
+EXPORT void f3_V_FSP_IIP(float p0, struct S_IIP p1, void* p2,  void (*cb)(float, struct S_IIP, void*)) ;
+EXPORT void f3_V_FSP_IFI(float p0, struct S_IFI p1, void* p2,  void (*cb)(float, struct S_IFI, void*)) ;
+EXPORT void f3_V_FSP_IFF(float p0, struct S_IFF p1, void* p2,  void (*cb)(float, struct S_IFF, void*)) ;
+EXPORT void f3_V_FSP_IFD(float p0, struct S_IFD p1, void* p2,  void (*cb)(float, struct S_IFD, void*)) ;
+EXPORT void f3_V_FSP_IFP(float p0, struct S_IFP p1, void* p2,  void (*cb)(float, struct S_IFP, void*)) ;
+EXPORT void f3_V_FSP_IDI(float p0, struct S_IDI p1, void* p2,  void (*cb)(float, struct S_IDI, void*)) ;
+EXPORT void f3_V_FSP_IDF(float p0, struct S_IDF p1, void* p2,  void (*cb)(float, struct S_IDF, void*)) ;
+EXPORT void f3_V_FSP_IDD(float p0, struct S_IDD p1, void* p2,  void (*cb)(float, struct S_IDD, void*)) ;
+EXPORT void f3_V_FSP_IDP(float p0, struct S_IDP p1, void* p2,  void (*cb)(float, struct S_IDP, void*)) ;
+EXPORT void f3_V_FSP_IPI(float p0, struct S_IPI p1, void* p2,  void (*cb)(float, struct S_IPI, void*)) ;
+EXPORT void f3_V_FSP_IPF(float p0, struct S_IPF p1, void* p2,  void (*cb)(float, struct S_IPF, void*)) ;
+EXPORT void f3_V_FSP_IPD(float p0, struct S_IPD p1, void* p2,  void (*cb)(float, struct S_IPD, void*)) ;
+EXPORT void f3_V_FSP_IPP(float p0, struct S_IPP p1, void* p2,  void (*cb)(float, struct S_IPP, void*)) ;
+EXPORT void f3_V_FSP_FII(float p0, struct S_FII p1, void* p2,  void (*cb)(float, struct S_FII, void*)) ;
+EXPORT void f3_V_FSP_FIF(float p0, struct S_FIF p1, void* p2,  void (*cb)(float, struct S_FIF, void*)) ;
+EXPORT void f3_V_FSP_FID(float p0, struct S_FID p1, void* p2,  void (*cb)(float, struct S_FID, void*)) ;
+EXPORT void f3_V_FSP_FIP(float p0, struct S_FIP p1, void* p2,  void (*cb)(float, struct S_FIP, void*)) ;
+EXPORT void f3_V_FSP_FFI(float p0, struct S_FFI p1, void* p2,  void (*cb)(float, struct S_FFI, void*)) ;
+EXPORT void f3_V_FSP_FFF(float p0, struct S_FFF p1, void* p2,  void (*cb)(float, struct S_FFF, void*)) ;
+EXPORT void f3_V_FSP_FFD(float p0, struct S_FFD p1, void* p2,  void (*cb)(float, struct S_FFD, void*)) ;
+EXPORT void f3_V_FSP_FFP(float p0, struct S_FFP p1, void* p2,  void (*cb)(float, struct S_FFP, void*)) ;
+EXPORT void f3_V_FSP_FDI(float p0, struct S_FDI p1, void* p2,  void (*cb)(float, struct S_FDI, void*)) ;
+EXPORT void f3_V_FSP_FDF(float p0, struct S_FDF p1, void* p2,  void (*cb)(float, struct S_FDF, void*)) ;
+EXPORT void f3_V_FSP_FDD(float p0, struct S_FDD p1, void* p2,  void (*cb)(float, struct S_FDD, void*)) ;
+EXPORT void f3_V_FSP_FDP(float p0, struct S_FDP p1, void* p2,  void (*cb)(float, struct S_FDP, void*)) ;
+EXPORT void f3_V_FSP_FPI(float p0, struct S_FPI p1, void* p2,  void (*cb)(float, struct S_FPI, void*)) ;
+EXPORT void f3_V_FSP_FPF(float p0, struct S_FPF p1, void* p2,  void (*cb)(float, struct S_FPF, void*)) ;
+EXPORT void f3_V_FSP_FPD(float p0, struct S_FPD p1, void* p2,  void (*cb)(float, struct S_FPD, void*)) ;
+EXPORT void f3_V_FSP_FPP(float p0, struct S_FPP p1, void* p2,  void (*cb)(float, struct S_FPP, void*)) ;
+EXPORT void f3_V_FSP_DII(float p0, struct S_DII p1, void* p2,  void (*cb)(float, struct S_DII, void*)) ;
+EXPORT void f3_V_FSP_DIF(float p0, struct S_DIF p1, void* p2,  void (*cb)(float, struct S_DIF, void*)) ;
+EXPORT void f3_V_FSP_DID(float p0, struct S_DID p1, void* p2,  void (*cb)(float, struct S_DID, void*)) ;
+EXPORT void f3_V_FSP_DIP(float p0, struct S_DIP p1, void* p2,  void (*cb)(float, struct S_DIP, void*)) ;
+EXPORT void f3_V_FSP_DFI(float p0, struct S_DFI p1, void* p2,  void (*cb)(float, struct S_DFI, void*)) ;
+EXPORT void f3_V_FSP_DFF(float p0, struct S_DFF p1, void* p2,  void (*cb)(float, struct S_DFF, void*)) ;
+EXPORT void f3_V_FSP_DFD(float p0, struct S_DFD p1, void* p2,  void (*cb)(float, struct S_DFD, void*)) ;
+EXPORT void f3_V_FSP_DFP(float p0, struct S_DFP p1, void* p2,  void (*cb)(float, struct S_DFP, void*)) ;
+EXPORT void f3_V_FSP_DDI(float p0, struct S_DDI p1, void* p2,  void (*cb)(float, struct S_DDI, void*)) ;
+EXPORT void f3_V_FSP_DDF(float p0, struct S_DDF p1, void* p2,  void (*cb)(float, struct S_DDF, void*)) ;
+EXPORT void f3_V_FSP_DDD(float p0, struct S_DDD p1, void* p2,  void (*cb)(float, struct S_DDD, void*)) ;
+EXPORT void f3_V_FSP_DDP(float p0, struct S_DDP p1, void* p2,  void (*cb)(float, struct S_DDP, void*)) ;
+EXPORT void f3_V_FSP_DPI(float p0, struct S_DPI p1, void* p2,  void (*cb)(float, struct S_DPI, void*)) ;
+EXPORT void f3_V_FSP_DPF(float p0, struct S_DPF p1, void* p2,  void (*cb)(float, struct S_DPF, void*)) ;
+EXPORT void f3_V_FSP_DPD(float p0, struct S_DPD p1, void* p2,  void (*cb)(float, struct S_DPD, void*)) ;
+EXPORT void f3_V_FSP_DPP(float p0, struct S_DPP p1, void* p2,  void (*cb)(float, struct S_DPP, void*)) ;
+EXPORT void f3_V_FSP_PII(float p0, struct S_PII p1, void* p2,  void (*cb)(float, struct S_PII, void*)) ;
+EXPORT void f3_V_FSP_PIF(float p0, struct S_PIF p1, void* p2,  void (*cb)(float, struct S_PIF, void*)) ;
+EXPORT void f3_V_FSP_PID(float p0, struct S_PID p1, void* p2,  void (*cb)(float, struct S_PID, void*)) ;
+EXPORT void f3_V_FSP_PIP(float p0, struct S_PIP p1, void* p2,  void (*cb)(float, struct S_PIP, void*)) ;
+EXPORT void f3_V_FSP_PFI(float p0, struct S_PFI p1, void* p2,  void (*cb)(float, struct S_PFI, void*)) ;
+EXPORT void f3_V_FSP_PFF(float p0, struct S_PFF p1, void* p2,  void (*cb)(float, struct S_PFF, void*)) ;
+EXPORT void f3_V_FSP_PFD(float p0, struct S_PFD p1, void* p2,  void (*cb)(float, struct S_PFD, void*)) ;
+EXPORT void f3_V_FSP_PFP(float p0, struct S_PFP p1, void* p2,  void (*cb)(float, struct S_PFP, void*)) ;
+EXPORT void f3_V_FSP_PDI(float p0, struct S_PDI p1, void* p2,  void (*cb)(float, struct S_PDI, void*)) ;
+EXPORT void f3_V_FSP_PDF(float p0, struct S_PDF p1, void* p2,  void (*cb)(float, struct S_PDF, void*)) ;
+EXPORT void f3_V_FSP_PDD(float p0, struct S_PDD p1, void* p2,  void (*cb)(float, struct S_PDD, void*)) ;
+EXPORT void f3_V_FSP_PDP(float p0, struct S_PDP p1, void* p2,  void (*cb)(float, struct S_PDP, void*)) ;
+EXPORT void f3_V_FSP_PPI(float p0, struct S_PPI p1, void* p2,  void (*cb)(float, struct S_PPI, void*)) ;
+EXPORT void f3_V_FSP_PPF(float p0, struct S_PPF p1, void* p2,  void (*cb)(float, struct S_PPF, void*)) ;
+EXPORT void f3_V_FSP_PPD(float p0, struct S_PPD p1, void* p2,  void (*cb)(float, struct S_PPD, void*)) ;
+EXPORT void f3_V_FSP_PPP(float p0, struct S_PPP p1, void* p2,  void (*cb)(float, struct S_PPP, void*)) ;
+EXPORT void f3_V_FSS_I(float p0, struct S_I p1, struct S_I p2,  void (*cb)(float, struct S_I, struct S_I)) ;
+EXPORT void f3_V_FSS_F(float p0, struct S_F p1, struct S_F p2,  void (*cb)(float, struct S_F, struct S_F)) ;
+EXPORT void f3_V_FSS_D(float p0, struct S_D p1, struct S_D p2,  void (*cb)(float, struct S_D, struct S_D)) ;
+EXPORT void f3_V_FSS_P(float p0, struct S_P p1, struct S_P p2,  void (*cb)(float, struct S_P, struct S_P)) ;
+EXPORT void f3_V_FSS_II(float p0, struct S_II p1, struct S_II p2,  void (*cb)(float, struct S_II, struct S_II)) ;
+EXPORT void f3_V_FSS_IF(float p0, struct S_IF p1, struct S_IF p2,  void (*cb)(float, struct S_IF, struct S_IF)) ;
+EXPORT void f3_V_FSS_ID(float p0, struct S_ID p1, struct S_ID p2,  void (*cb)(float, struct S_ID, struct S_ID)) ;
+EXPORT void f3_V_FSS_IP(float p0, struct S_IP p1, struct S_IP p2,  void (*cb)(float, struct S_IP, struct S_IP)) ;
+EXPORT void f3_V_FSS_FI(float p0, struct S_FI p1, struct S_FI p2,  void (*cb)(float, struct S_FI, struct S_FI)) ;
+EXPORT void f3_V_FSS_FF(float p0, struct S_FF p1, struct S_FF p2,  void (*cb)(float, struct S_FF, struct S_FF)) ;
+EXPORT void f3_V_FSS_FD(float p0, struct S_FD p1, struct S_FD p2,  void (*cb)(float, struct S_FD, struct S_FD)) ;
+EXPORT void f3_V_FSS_FP(float p0, struct S_FP p1, struct S_FP p2,  void (*cb)(float, struct S_FP, struct S_FP)) ;
+EXPORT void f3_V_FSS_DI(float p0, struct S_DI p1, struct S_DI p2,  void (*cb)(float, struct S_DI, struct S_DI)) ;
+EXPORT void f3_V_FSS_DF(float p0, struct S_DF p1, struct S_DF p2,  void (*cb)(float, struct S_DF, struct S_DF)) ;
+EXPORT void f3_V_FSS_DD(float p0, struct S_DD p1, struct S_DD p2,  void (*cb)(float, struct S_DD, struct S_DD)) ;
+EXPORT void f3_V_FSS_DP(float p0, struct S_DP p1, struct S_DP p2,  void (*cb)(float, struct S_DP, struct S_DP)) ;
+EXPORT void f3_V_FSS_PI(float p0, struct S_PI p1, struct S_PI p2,  void (*cb)(float, struct S_PI, struct S_PI)) ;
+EXPORT void f3_V_FSS_PF(float p0, struct S_PF p1, struct S_PF p2,  void (*cb)(float, struct S_PF, struct S_PF)) ;
+EXPORT void f3_V_FSS_PD(float p0, struct S_PD p1, struct S_PD p2,  void (*cb)(float, struct S_PD, struct S_PD)) ;
+EXPORT void f3_V_FSS_PP(float p0, struct S_PP p1, struct S_PP p2,  void (*cb)(float, struct S_PP, struct S_PP)) ;
+EXPORT void f3_V_FSS_III(float p0, struct S_III p1, struct S_III p2,  void (*cb)(float, struct S_III, struct S_III)) ;
+EXPORT void f3_V_FSS_IIF(float p0, struct S_IIF p1, struct S_IIF p2,  void (*cb)(float, struct S_IIF, struct S_IIF)) ;
+EXPORT void f3_V_FSS_IID(float p0, struct S_IID p1, struct S_IID p2,  void (*cb)(float, struct S_IID, struct S_IID)) ;
+EXPORT void f3_V_FSS_IIP(float p0, struct S_IIP p1, struct S_IIP p2,  void (*cb)(float, struct S_IIP, struct S_IIP)) ;
+EXPORT void f3_V_FSS_IFI(float p0, struct S_IFI p1, struct S_IFI p2,  void (*cb)(float, struct S_IFI, struct S_IFI)) ;
+EXPORT void f3_V_FSS_IFF(float p0, struct S_IFF p1, struct S_IFF p2,  void (*cb)(float, struct S_IFF, struct S_IFF)) ;
+EXPORT void f3_V_FSS_IFD(float p0, struct S_IFD p1, struct S_IFD p2,  void (*cb)(float, struct S_IFD, struct S_IFD)) ;
+EXPORT void f3_V_FSS_IFP(float p0, struct S_IFP p1, struct S_IFP p2,  void (*cb)(float, struct S_IFP, struct S_IFP)) ;
+EXPORT void f3_V_FSS_IDI(float p0, struct S_IDI p1, struct S_IDI p2,  void (*cb)(float, struct S_IDI, struct S_IDI)) ;
+EXPORT void f3_V_FSS_IDF(float p0, struct S_IDF p1, struct S_IDF p2,  void (*cb)(float, struct S_IDF, struct S_IDF)) ;
+EXPORT void f3_V_FSS_IDD(float p0, struct S_IDD p1, struct S_IDD p2,  void (*cb)(float, struct S_IDD, struct S_IDD)) ;
+EXPORT void f3_V_FSS_IDP(float p0, struct S_IDP p1, struct S_IDP p2,  void (*cb)(float, struct S_IDP, struct S_IDP)) ;
+EXPORT void f3_V_FSS_IPI(float p0, struct S_IPI p1, struct S_IPI p2,  void (*cb)(float, struct S_IPI, struct S_IPI)) ;
+EXPORT void f3_V_FSS_IPF(float p0, struct S_IPF p1, struct S_IPF p2,  void (*cb)(float, struct S_IPF, struct S_IPF)) ;
+EXPORT void f3_V_FSS_IPD(float p0, struct S_IPD p1, struct S_IPD p2,  void (*cb)(float, struct S_IPD, struct S_IPD)) ;
+EXPORT void f3_V_FSS_IPP(float p0, struct S_IPP p1, struct S_IPP p2,  void (*cb)(float, struct S_IPP, struct S_IPP)) ;
+EXPORT void f3_V_FSS_FII(float p0, struct S_FII p1, struct S_FII p2,  void (*cb)(float, struct S_FII, struct S_FII)) ;
+EXPORT void f3_V_FSS_FIF(float p0, struct S_FIF p1, struct S_FIF p2,  void (*cb)(float, struct S_FIF, struct S_FIF)) ;
+EXPORT void f3_V_FSS_FID(float p0, struct S_FID p1, struct S_FID p2,  void (*cb)(float, struct S_FID, struct S_FID)) ;
+EXPORT void f3_V_FSS_FIP(float p0, struct S_FIP p1, struct S_FIP p2,  void (*cb)(float, struct S_FIP, struct S_FIP)) ;
+EXPORT void f3_V_FSS_FFI(float p0, struct S_FFI p1, struct S_FFI p2,  void (*cb)(float, struct S_FFI, struct S_FFI)) ;
+EXPORT void f3_V_FSS_FFF(float p0, struct S_FFF p1, struct S_FFF p2,  void (*cb)(float, struct S_FFF, struct S_FFF)) ;
+EXPORT void f3_V_FSS_FFD(float p0, struct S_FFD p1, struct S_FFD p2,  void (*cb)(float, struct S_FFD, struct S_FFD)) ;
+EXPORT void f3_V_FSS_FFP(float p0, struct S_FFP p1, struct S_FFP p2,  void (*cb)(float, struct S_FFP, struct S_FFP)) ;
+EXPORT void f3_V_FSS_FDI(float p0, struct S_FDI p1, struct S_FDI p2,  void (*cb)(float, struct S_FDI, struct S_FDI)) ;
+EXPORT void f3_V_FSS_FDF(float p0, struct S_FDF p1, struct S_FDF p2,  void (*cb)(float, struct S_FDF, struct S_FDF)) ;
+EXPORT void f3_V_FSS_FDD(float p0, struct S_FDD p1, struct S_FDD p2,  void (*cb)(float, struct S_FDD, struct S_FDD)) ;
+EXPORT void f3_V_FSS_FDP(float p0, struct S_FDP p1, struct S_FDP p2,  void (*cb)(float, struct S_FDP, struct S_FDP)) ;
+EXPORT void f3_V_FSS_FPI(float p0, struct S_FPI p1, struct S_FPI p2,  void (*cb)(float, struct S_FPI, struct S_FPI)) ;
+EXPORT void f3_V_FSS_FPF(float p0, struct S_FPF p1, struct S_FPF p2,  void (*cb)(float, struct S_FPF, struct S_FPF)) ;
+EXPORT void f3_V_FSS_FPD(float p0, struct S_FPD p1, struct S_FPD p2,  void (*cb)(float, struct S_FPD, struct S_FPD)) ;
+EXPORT void f3_V_FSS_FPP(float p0, struct S_FPP p1, struct S_FPP p2,  void (*cb)(float, struct S_FPP, struct S_FPP)) ;
+EXPORT void f3_V_FSS_DII(float p0, struct S_DII p1, struct S_DII p2,  void (*cb)(float, struct S_DII, struct S_DII)) ;
+EXPORT void f3_V_FSS_DIF(float p0, struct S_DIF p1, struct S_DIF p2,  void (*cb)(float, struct S_DIF, struct S_DIF)) ;
+EXPORT void f3_V_FSS_DID(float p0, struct S_DID p1, struct S_DID p2,  void (*cb)(float, struct S_DID, struct S_DID)) ;
+EXPORT void f3_V_FSS_DIP(float p0, struct S_DIP p1, struct S_DIP p2,  void (*cb)(float, struct S_DIP, struct S_DIP)) ;
+EXPORT void f3_V_FSS_DFI(float p0, struct S_DFI p1, struct S_DFI p2,  void (*cb)(float, struct S_DFI, struct S_DFI)) ;
+EXPORT void f3_V_FSS_DFF(float p0, struct S_DFF p1, struct S_DFF p2,  void (*cb)(float, struct S_DFF, struct S_DFF)) ;
+EXPORT void f3_V_FSS_DFD(float p0, struct S_DFD p1, struct S_DFD p2,  void (*cb)(float, struct S_DFD, struct S_DFD)) ;
+EXPORT void f3_V_FSS_DFP(float p0, struct S_DFP p1, struct S_DFP p2,  void (*cb)(float, struct S_DFP, struct S_DFP)) ;
+EXPORT void f3_V_FSS_DDI(float p0, struct S_DDI p1, struct S_DDI p2,  void (*cb)(float, struct S_DDI, struct S_DDI)) ;
+EXPORT void f3_V_FSS_DDF(float p0, struct S_DDF p1, struct S_DDF p2,  void (*cb)(float, struct S_DDF, struct S_DDF)) ;
+EXPORT void f3_V_FSS_DDD(float p0, struct S_DDD p1, struct S_DDD p2,  void (*cb)(float, struct S_DDD, struct S_DDD)) ;
+EXPORT void f3_V_FSS_DDP(float p0, struct S_DDP p1, struct S_DDP p2,  void (*cb)(float, struct S_DDP, struct S_DDP)) ;
+EXPORT void f3_V_FSS_DPI(float p0, struct S_DPI p1, struct S_DPI p2,  void (*cb)(float, struct S_DPI, struct S_DPI)) ;
+EXPORT void f3_V_FSS_DPF(float p0, struct S_DPF p1, struct S_DPF p2,  void (*cb)(float, struct S_DPF, struct S_DPF)) ;
+EXPORT void f3_V_FSS_DPD(float p0, struct S_DPD p1, struct S_DPD p2,  void (*cb)(float, struct S_DPD, struct S_DPD)) ;
+EXPORT void f3_V_FSS_DPP(float p0, struct S_DPP p1, struct S_DPP p2,  void (*cb)(float, struct S_DPP, struct S_DPP)) ;
+EXPORT void f3_V_FSS_PII(float p0, struct S_PII p1, struct S_PII p2,  void (*cb)(float, struct S_PII, struct S_PII)) ;
+EXPORT void f3_V_FSS_PIF(float p0, struct S_PIF p1, struct S_PIF p2,  void (*cb)(float, struct S_PIF, struct S_PIF)) ;
+EXPORT void f3_V_FSS_PID(float p0, struct S_PID p1, struct S_PID p2,  void (*cb)(float, struct S_PID, struct S_PID)) ;
+EXPORT void f3_V_FSS_PIP(float p0, struct S_PIP p1, struct S_PIP p2,  void (*cb)(float, struct S_PIP, struct S_PIP)) ;
+EXPORT void f3_V_FSS_PFI(float p0, struct S_PFI p1, struct S_PFI p2,  void (*cb)(float, struct S_PFI, struct S_PFI)) ;
+EXPORT void f3_V_FSS_PFF(float p0, struct S_PFF p1, struct S_PFF p2,  void (*cb)(float, struct S_PFF, struct S_PFF)) ;
+EXPORT void f3_V_FSS_PFD(float p0, struct S_PFD p1, struct S_PFD p2,  void (*cb)(float, struct S_PFD, struct S_PFD)) ;
+EXPORT void f3_V_FSS_PFP(float p0, struct S_PFP p1, struct S_PFP p2,  void (*cb)(float, struct S_PFP, struct S_PFP)) ;
+EXPORT void f3_V_FSS_PDI(float p0, struct S_PDI p1, struct S_PDI p2,  void (*cb)(float, struct S_PDI, struct S_PDI)) ;
+EXPORT void f3_V_FSS_PDF(float p0, struct S_PDF p1, struct S_PDF p2,  void (*cb)(float, struct S_PDF, struct S_PDF)) ;
+EXPORT void f3_V_FSS_PDD(float p0, struct S_PDD p1, struct S_PDD p2,  void (*cb)(float, struct S_PDD, struct S_PDD)) ;
+EXPORT void f4_V_FSS_PDP(float p0, struct S_PDP p1, struct S_PDP p2,  void (*cb)(float, struct S_PDP, struct S_PDP)) ;
+EXPORT void f4_V_FSS_PPI(float p0, struct S_PPI p1, struct S_PPI p2,  void (*cb)(float, struct S_PPI, struct S_PPI)) ;
+EXPORT void f4_V_FSS_PPF(float p0, struct S_PPF p1, struct S_PPF p2,  void (*cb)(float, struct S_PPF, struct S_PPF)) ;
+EXPORT void f4_V_FSS_PPD(float p0, struct S_PPD p1, struct S_PPD p2,  void (*cb)(float, struct S_PPD, struct S_PPD)) ;
+EXPORT void f4_V_FSS_PPP(float p0, struct S_PPP p1, struct S_PPP p2,  void (*cb)(float, struct S_PPP, struct S_PPP)) ;
+EXPORT void f4_V_DII_(double p0, int p1, int p2,  void (*cb)(double, int, int)) ;
+EXPORT void f4_V_DIF_(double p0, int p1, float p2,  void (*cb)(double, int, float)) ;
+EXPORT void f4_V_DID_(double p0, int p1, double p2,  void (*cb)(double, int, double)) ;
+EXPORT void f4_V_DIP_(double p0, int p1, void* p2,  void (*cb)(double, int, void*)) ;
+EXPORT void f4_V_DIS_I(double p0, int p1, struct S_I p2,  void (*cb)(double, int, struct S_I)) ;
+EXPORT void f4_V_DIS_F(double p0, int p1, struct S_F p2,  void (*cb)(double, int, struct S_F)) ;
+EXPORT void f4_V_DIS_D(double p0, int p1, struct S_D p2,  void (*cb)(double, int, struct S_D)) ;
+EXPORT void f4_V_DIS_P(double p0, int p1, struct S_P p2,  void (*cb)(double, int, struct S_P)) ;
+EXPORT void f4_V_DIS_II(double p0, int p1, struct S_II p2,  void (*cb)(double, int, struct S_II)) ;
+EXPORT void f4_V_DIS_IF(double p0, int p1, struct S_IF p2,  void (*cb)(double, int, struct S_IF)) ;
+EXPORT void f4_V_DIS_ID(double p0, int p1, struct S_ID p2,  void (*cb)(double, int, struct S_ID)) ;
+EXPORT void f4_V_DIS_IP(double p0, int p1, struct S_IP p2,  void (*cb)(double, int, struct S_IP)) ;
+EXPORT void f4_V_DIS_FI(double p0, int p1, struct S_FI p2,  void (*cb)(double, int, struct S_FI)) ;
+EXPORT void f4_V_DIS_FF(double p0, int p1, struct S_FF p2,  void (*cb)(double, int, struct S_FF)) ;
+EXPORT void f4_V_DIS_FD(double p0, int p1, struct S_FD p2,  void (*cb)(double, int, struct S_FD)) ;
+EXPORT void f4_V_DIS_FP(double p0, int p1, struct S_FP p2,  void (*cb)(double, int, struct S_FP)) ;
+EXPORT void f4_V_DIS_DI(double p0, int p1, struct S_DI p2,  void (*cb)(double, int, struct S_DI)) ;
+EXPORT void f4_V_DIS_DF(double p0, int p1, struct S_DF p2,  void (*cb)(double, int, struct S_DF)) ;
+EXPORT void f4_V_DIS_DD(double p0, int p1, struct S_DD p2,  void (*cb)(double, int, struct S_DD)) ;
+EXPORT void f4_V_DIS_DP(double p0, int p1, struct S_DP p2,  void (*cb)(double, int, struct S_DP)) ;
+EXPORT void f4_V_DIS_PI(double p0, int p1, struct S_PI p2,  void (*cb)(double, int, struct S_PI)) ;
+EXPORT void f4_V_DIS_PF(double p0, int p1, struct S_PF p2,  void (*cb)(double, int, struct S_PF)) ;
+EXPORT void f4_V_DIS_PD(double p0, int p1, struct S_PD p2,  void (*cb)(double, int, struct S_PD)) ;
+EXPORT void f4_V_DIS_PP(double p0, int p1, struct S_PP p2,  void (*cb)(double, int, struct S_PP)) ;
+EXPORT void f4_V_DIS_III(double p0, int p1, struct S_III p2,  void (*cb)(double, int, struct S_III)) ;
+EXPORT void f4_V_DIS_IIF(double p0, int p1, struct S_IIF p2,  void (*cb)(double, int, struct S_IIF)) ;
+EXPORT void f4_V_DIS_IID(double p0, int p1, struct S_IID p2,  void (*cb)(double, int, struct S_IID)) ;
+EXPORT void f4_V_DIS_IIP(double p0, int p1, struct S_IIP p2,  void (*cb)(double, int, struct S_IIP)) ;
+EXPORT void f4_V_DIS_IFI(double p0, int p1, struct S_IFI p2,  void (*cb)(double, int, struct S_IFI)) ;
+EXPORT void f4_V_DIS_IFF(double p0, int p1, struct S_IFF p2,  void (*cb)(double, int, struct S_IFF)) ;
+EXPORT void f4_V_DIS_IFD(double p0, int p1, struct S_IFD p2,  void (*cb)(double, int, struct S_IFD)) ;
+EXPORT void f4_V_DIS_IFP(double p0, int p1, struct S_IFP p2,  void (*cb)(double, int, struct S_IFP)) ;
+EXPORT void f4_V_DIS_IDI(double p0, int p1, struct S_IDI p2,  void (*cb)(double, int, struct S_IDI)) ;
+EXPORT void f4_V_DIS_IDF(double p0, int p1, struct S_IDF p2,  void (*cb)(double, int, struct S_IDF)) ;
+EXPORT void f4_V_DIS_IDD(double p0, int p1, struct S_IDD p2,  void (*cb)(double, int, struct S_IDD)) ;
+EXPORT void f4_V_DIS_IDP(double p0, int p1, struct S_IDP p2,  void (*cb)(double, int, struct S_IDP)) ;
+EXPORT void f4_V_DIS_IPI(double p0, int p1, struct S_IPI p2,  void (*cb)(double, int, struct S_IPI)) ;
+EXPORT void f4_V_DIS_IPF(double p0, int p1, struct S_IPF p2,  void (*cb)(double, int, struct S_IPF)) ;
+EXPORT void f4_V_DIS_IPD(double p0, int p1, struct S_IPD p2,  void (*cb)(double, int, struct S_IPD)) ;
+EXPORT void f4_V_DIS_IPP(double p0, int p1, struct S_IPP p2,  void (*cb)(double, int, struct S_IPP)) ;
+EXPORT void f4_V_DIS_FII(double p0, int p1, struct S_FII p2,  void (*cb)(double, int, struct S_FII)) ;
+EXPORT void f4_V_DIS_FIF(double p0, int p1, struct S_FIF p2,  void (*cb)(double, int, struct S_FIF)) ;
+EXPORT void f4_V_DIS_FID(double p0, int p1, struct S_FID p2,  void (*cb)(double, int, struct S_FID)) ;
+EXPORT void f4_V_DIS_FIP(double p0, int p1, struct S_FIP p2,  void (*cb)(double, int, struct S_FIP)) ;
+EXPORT void f4_V_DIS_FFI(double p0, int p1, struct S_FFI p2,  void (*cb)(double, int, struct S_FFI)) ;
+EXPORT void f4_V_DIS_FFF(double p0, int p1, struct S_FFF p2,  void (*cb)(double, int, struct S_FFF)) ;
+EXPORT void f4_V_DIS_FFD(double p0, int p1, struct S_FFD p2,  void (*cb)(double, int, struct S_FFD)) ;
+EXPORT void f4_V_DIS_FFP(double p0, int p1, struct S_FFP p2,  void (*cb)(double, int, struct S_FFP)) ;
+EXPORT void f4_V_DIS_FDI(double p0, int p1, struct S_FDI p2,  void (*cb)(double, int, struct S_FDI)) ;
+EXPORT void f4_V_DIS_FDF(double p0, int p1, struct S_FDF p2,  void (*cb)(double, int, struct S_FDF)) ;
+EXPORT void f4_V_DIS_FDD(double p0, int p1, struct S_FDD p2,  void (*cb)(double, int, struct S_FDD)) ;
+EXPORT void f4_V_DIS_FDP(double p0, int p1, struct S_FDP p2,  void (*cb)(double, int, struct S_FDP)) ;
+EXPORT void f4_V_DIS_FPI(double p0, int p1, struct S_FPI p2,  void (*cb)(double, int, struct S_FPI)) ;
+EXPORT void f4_V_DIS_FPF(double p0, int p1, struct S_FPF p2,  void (*cb)(double, int, struct S_FPF)) ;
+EXPORT void f4_V_DIS_FPD(double p0, int p1, struct S_FPD p2,  void (*cb)(double, int, struct S_FPD)) ;
+EXPORT void f4_V_DIS_FPP(double p0, int p1, struct S_FPP p2,  void (*cb)(double, int, struct S_FPP)) ;
+EXPORT void f4_V_DIS_DII(double p0, int p1, struct S_DII p2,  void (*cb)(double, int, struct S_DII)) ;
+EXPORT void f4_V_DIS_DIF(double p0, int p1, struct S_DIF p2,  void (*cb)(double, int, struct S_DIF)) ;
+EXPORT void f4_V_DIS_DID(double p0, int p1, struct S_DID p2,  void (*cb)(double, int, struct S_DID)) ;
+EXPORT void f4_V_DIS_DIP(double p0, int p1, struct S_DIP p2,  void (*cb)(double, int, struct S_DIP)) ;
+EXPORT void f4_V_DIS_DFI(double p0, int p1, struct S_DFI p2,  void (*cb)(double, int, struct S_DFI)) ;
+EXPORT void f4_V_DIS_DFF(double p0, int p1, struct S_DFF p2,  void (*cb)(double, int, struct S_DFF)) ;
+EXPORT void f4_V_DIS_DFD(double p0, int p1, struct S_DFD p2,  void (*cb)(double, int, struct S_DFD)) ;
+EXPORT void f4_V_DIS_DFP(double p0, int p1, struct S_DFP p2,  void (*cb)(double, int, struct S_DFP)) ;
+EXPORT void f4_V_DIS_DDI(double p0, int p1, struct S_DDI p2,  void (*cb)(double, int, struct S_DDI)) ;
+EXPORT void f4_V_DIS_DDF(double p0, int p1, struct S_DDF p2,  void (*cb)(double, int, struct S_DDF)) ;
+EXPORT void f4_V_DIS_DDD(double p0, int p1, struct S_DDD p2,  void (*cb)(double, int, struct S_DDD)) ;
+EXPORT void f4_V_DIS_DDP(double p0, int p1, struct S_DDP p2,  void (*cb)(double, int, struct S_DDP)) ;
+EXPORT void f4_V_DIS_DPI(double p0, int p1, struct S_DPI p2,  void (*cb)(double, int, struct S_DPI)) ;
+EXPORT void f4_V_DIS_DPF(double p0, int p1, struct S_DPF p2,  void (*cb)(double, int, struct S_DPF)) ;
+EXPORT void f4_V_DIS_DPD(double p0, int p1, struct S_DPD p2,  void (*cb)(double, int, struct S_DPD)) ;
+EXPORT void f4_V_DIS_DPP(double p0, int p1, struct S_DPP p2,  void (*cb)(double, int, struct S_DPP)) ;
+EXPORT void f4_V_DIS_PII(double p0, int p1, struct S_PII p2,  void (*cb)(double, int, struct S_PII)) ;
+EXPORT void f4_V_DIS_PIF(double p0, int p1, struct S_PIF p2,  void (*cb)(double, int, struct S_PIF)) ;
+EXPORT void f4_V_DIS_PID(double p0, int p1, struct S_PID p2,  void (*cb)(double, int, struct S_PID)) ;
+EXPORT void f4_V_DIS_PIP(double p0, int p1, struct S_PIP p2,  void (*cb)(double, int, struct S_PIP)) ;
+EXPORT void f4_V_DIS_PFI(double p0, int p1, struct S_PFI p2,  void (*cb)(double, int, struct S_PFI)) ;
+EXPORT void f4_V_DIS_PFF(double p0, int p1, struct S_PFF p2,  void (*cb)(double, int, struct S_PFF)) ;
+EXPORT void f4_V_DIS_PFD(double p0, int p1, struct S_PFD p2,  void (*cb)(double, int, struct S_PFD)) ;
+EXPORT void f4_V_DIS_PFP(double p0, int p1, struct S_PFP p2,  void (*cb)(double, int, struct S_PFP)) ;
+EXPORT void f4_V_DIS_PDI(double p0, int p1, struct S_PDI p2,  void (*cb)(double, int, struct S_PDI)) ;
+EXPORT void f4_V_DIS_PDF(double p0, int p1, struct S_PDF p2,  void (*cb)(double, int, struct S_PDF)) ;
+EXPORT void f4_V_DIS_PDD(double p0, int p1, struct S_PDD p2,  void (*cb)(double, int, struct S_PDD)) ;
+EXPORT void f4_V_DIS_PDP(double p0, int p1, struct S_PDP p2,  void (*cb)(double, int, struct S_PDP)) ;
+EXPORT void f4_V_DIS_PPI(double p0, int p1, struct S_PPI p2,  void (*cb)(double, int, struct S_PPI)) ;
+EXPORT void f4_V_DIS_PPF(double p0, int p1, struct S_PPF p2,  void (*cb)(double, int, struct S_PPF)) ;
+EXPORT void f4_V_DIS_PPD(double p0, int p1, struct S_PPD p2,  void (*cb)(double, int, struct S_PPD)) ;
+EXPORT void f4_V_DIS_PPP(double p0, int p1, struct S_PPP p2,  void (*cb)(double, int, struct S_PPP)) ;
+EXPORT void f4_V_DFI_(double p0, float p1, int p2,  void (*cb)(double, float, int)) ;
+EXPORT void f4_V_DFF_(double p0, float p1, float p2,  void (*cb)(double, float, float)) ;
+EXPORT void f4_V_DFD_(double p0, float p1, double p2,  void (*cb)(double, float, double)) ;
+EXPORT void f4_V_DFP_(double p0, float p1, void* p2,  void (*cb)(double, float, void*)) ;
+EXPORT void f4_V_DFS_I(double p0, float p1, struct S_I p2,  void (*cb)(double, float, struct S_I)) ;
+EXPORT void f4_V_DFS_F(double p0, float p1, struct S_F p2,  void (*cb)(double, float, struct S_F)) ;
+EXPORT void f4_V_DFS_D(double p0, float p1, struct S_D p2,  void (*cb)(double, float, struct S_D)) ;
+EXPORT void f4_V_DFS_P(double p0, float p1, struct S_P p2,  void (*cb)(double, float, struct S_P)) ;
+EXPORT void f4_V_DFS_II(double p0, float p1, struct S_II p2,  void (*cb)(double, float, struct S_II)) ;
+EXPORT void f4_V_DFS_IF(double p0, float p1, struct S_IF p2,  void (*cb)(double, float, struct S_IF)) ;
+EXPORT void f4_V_DFS_ID(double p0, float p1, struct S_ID p2,  void (*cb)(double, float, struct S_ID)) ;
+EXPORT void f4_V_DFS_IP(double p0, float p1, struct S_IP p2,  void (*cb)(double, float, struct S_IP)) ;
+EXPORT void f4_V_DFS_FI(double p0, float p1, struct S_FI p2,  void (*cb)(double, float, struct S_FI)) ;
+EXPORT void f4_V_DFS_FF(double p0, float p1, struct S_FF p2,  void (*cb)(double, float, struct S_FF)) ;
+EXPORT void f4_V_DFS_FD(double p0, float p1, struct S_FD p2,  void (*cb)(double, float, struct S_FD)) ;
+EXPORT void f4_V_DFS_FP(double p0, float p1, struct S_FP p2,  void (*cb)(double, float, struct S_FP)) ;
+EXPORT void f4_V_DFS_DI(double p0, float p1, struct S_DI p2,  void (*cb)(double, float, struct S_DI)) ;
+EXPORT void f4_V_DFS_DF(double p0, float p1, struct S_DF p2,  void (*cb)(double, float, struct S_DF)) ;
+EXPORT void f4_V_DFS_DD(double p0, float p1, struct S_DD p2,  void (*cb)(double, float, struct S_DD)) ;
+EXPORT void f4_V_DFS_DP(double p0, float p1, struct S_DP p2,  void (*cb)(double, float, struct S_DP)) ;
+EXPORT void f4_V_DFS_PI(double p0, float p1, struct S_PI p2,  void (*cb)(double, float, struct S_PI)) ;
+EXPORT void f4_V_DFS_PF(double p0, float p1, struct S_PF p2,  void (*cb)(double, float, struct S_PF)) ;
+EXPORT void f4_V_DFS_PD(double p0, float p1, struct S_PD p2,  void (*cb)(double, float, struct S_PD)) ;
+EXPORT void f4_V_DFS_PP(double p0, float p1, struct S_PP p2,  void (*cb)(double, float, struct S_PP)) ;
+EXPORT void f4_V_DFS_III(double p0, float p1, struct S_III p2,  void (*cb)(double, float, struct S_III)) ;
+EXPORT void f4_V_DFS_IIF(double p0, float p1, struct S_IIF p2,  void (*cb)(double, float, struct S_IIF)) ;
+EXPORT void f4_V_DFS_IID(double p0, float p1, struct S_IID p2,  void (*cb)(double, float, struct S_IID)) ;
+EXPORT void f4_V_DFS_IIP(double p0, float p1, struct S_IIP p2,  void (*cb)(double, float, struct S_IIP)) ;
+EXPORT void f4_V_DFS_IFI(double p0, float p1, struct S_IFI p2,  void (*cb)(double, float, struct S_IFI)) ;
+EXPORT void f4_V_DFS_IFF(double p0, float p1, struct S_IFF p2,  void (*cb)(double, float, struct S_IFF)) ;
+EXPORT void f4_V_DFS_IFD(double p0, float p1, struct S_IFD p2,  void (*cb)(double, float, struct S_IFD)) ;
+EXPORT void f4_V_DFS_IFP(double p0, float p1, struct S_IFP p2,  void (*cb)(double, float, struct S_IFP)) ;
+EXPORT void f4_V_DFS_IDI(double p0, float p1, struct S_IDI p2,  void (*cb)(double, float, struct S_IDI)) ;
+EXPORT void f4_V_DFS_IDF(double p0, float p1, struct S_IDF p2,  void (*cb)(double, float, struct S_IDF)) ;
+EXPORT void f4_V_DFS_IDD(double p0, float p1, struct S_IDD p2,  void (*cb)(double, float, struct S_IDD)) ;
+EXPORT void f4_V_DFS_IDP(double p0, float p1, struct S_IDP p2,  void (*cb)(double, float, struct S_IDP)) ;
+EXPORT void f4_V_DFS_IPI(double p0, float p1, struct S_IPI p2,  void (*cb)(double, float, struct S_IPI)) ;
+EXPORT void f4_V_DFS_IPF(double p0, float p1, struct S_IPF p2,  void (*cb)(double, float, struct S_IPF)) ;
+EXPORT void f4_V_DFS_IPD(double p0, float p1, struct S_IPD p2,  void (*cb)(double, float, struct S_IPD)) ;
+EXPORT void f4_V_DFS_IPP(double p0, float p1, struct S_IPP p2,  void (*cb)(double, float, struct S_IPP)) ;
+EXPORT void f4_V_DFS_FII(double p0, float p1, struct S_FII p2,  void (*cb)(double, float, struct S_FII)) ;
+EXPORT void f4_V_DFS_FIF(double p0, float p1, struct S_FIF p2,  void (*cb)(double, float, struct S_FIF)) ;
+EXPORT void f4_V_DFS_FID(double p0, float p1, struct S_FID p2,  void (*cb)(double, float, struct S_FID)) ;
+EXPORT void f4_V_DFS_FIP(double p0, float p1, struct S_FIP p2,  void (*cb)(double, float, struct S_FIP)) ;
+EXPORT void f4_V_DFS_FFI(double p0, float p1, struct S_FFI p2,  void (*cb)(double, float, struct S_FFI)) ;
+EXPORT void f4_V_DFS_FFF(double p0, float p1, struct S_FFF p2,  void (*cb)(double, float, struct S_FFF)) ;
+EXPORT void f4_V_DFS_FFD(double p0, float p1, struct S_FFD p2,  void (*cb)(double, float, struct S_FFD)) ;
+EXPORT void f4_V_DFS_FFP(double p0, float p1, struct S_FFP p2,  void (*cb)(double, float, struct S_FFP)) ;
+EXPORT void f4_V_DFS_FDI(double p0, float p1, struct S_FDI p2,  void (*cb)(double, float, struct S_FDI)) ;
+EXPORT void f4_V_DFS_FDF(double p0, float p1, struct S_FDF p2,  void (*cb)(double, float, struct S_FDF)) ;
+EXPORT void f4_V_DFS_FDD(double p0, float p1, struct S_FDD p2,  void (*cb)(double, float, struct S_FDD)) ;
+EXPORT void f4_V_DFS_FDP(double p0, float p1, struct S_FDP p2,  void (*cb)(double, float, struct S_FDP)) ;
+EXPORT void f4_V_DFS_FPI(double p0, float p1, struct S_FPI p2,  void (*cb)(double, float, struct S_FPI)) ;
+EXPORT void f4_V_DFS_FPF(double p0, float p1, struct S_FPF p2,  void (*cb)(double, float, struct S_FPF)) ;
+EXPORT void f4_V_DFS_FPD(double p0, float p1, struct S_FPD p2,  void (*cb)(double, float, struct S_FPD)) ;
+EXPORT void f4_V_DFS_FPP(double p0, float p1, struct S_FPP p2,  void (*cb)(double, float, struct S_FPP)) ;
+EXPORT void f4_V_DFS_DII(double p0, float p1, struct S_DII p2,  void (*cb)(double, float, struct S_DII)) ;
+EXPORT void f4_V_DFS_DIF(double p0, float p1, struct S_DIF p2,  void (*cb)(double, float, struct S_DIF)) ;
+EXPORT void f4_V_DFS_DID(double p0, float p1, struct S_DID p2,  void (*cb)(double, float, struct S_DID)) ;
+EXPORT void f4_V_DFS_DIP(double p0, float p1, struct S_DIP p2,  void (*cb)(double, float, struct S_DIP)) ;
+EXPORT void f4_V_DFS_DFI(double p0, float p1, struct S_DFI p2,  void (*cb)(double, float, struct S_DFI)) ;
+EXPORT void f4_V_DFS_DFF(double p0, float p1, struct S_DFF p2,  void (*cb)(double, float, struct S_DFF)) ;
+EXPORT void f4_V_DFS_DFD(double p0, float p1, struct S_DFD p2,  void (*cb)(double, float, struct S_DFD)) ;
+EXPORT void f4_V_DFS_DFP(double p0, float p1, struct S_DFP p2,  void (*cb)(double, float, struct S_DFP)) ;
+EXPORT void f4_V_DFS_DDI(double p0, float p1, struct S_DDI p2,  void (*cb)(double, float, struct S_DDI)) ;
+EXPORT void f4_V_DFS_DDF(double p0, float p1, struct S_DDF p2,  void (*cb)(double, float, struct S_DDF)) ;
+EXPORT void f4_V_DFS_DDD(double p0, float p1, struct S_DDD p2,  void (*cb)(double, float, struct S_DDD)) ;
+EXPORT void f4_V_DFS_DDP(double p0, float p1, struct S_DDP p2,  void (*cb)(double, float, struct S_DDP)) ;
+EXPORT void f4_V_DFS_DPI(double p0, float p1, struct S_DPI p2,  void (*cb)(double, float, struct S_DPI)) ;
+EXPORT void f4_V_DFS_DPF(double p0, float p1, struct S_DPF p2,  void (*cb)(double, float, struct S_DPF)) ;
+EXPORT void f4_V_DFS_DPD(double p0, float p1, struct S_DPD p2,  void (*cb)(double, float, struct S_DPD)) ;
+EXPORT void f4_V_DFS_DPP(double p0, float p1, struct S_DPP p2,  void (*cb)(double, float, struct S_DPP)) ;
+EXPORT void f4_V_DFS_PII(double p0, float p1, struct S_PII p2,  void (*cb)(double, float, struct S_PII)) ;
+EXPORT void f4_V_DFS_PIF(double p0, float p1, struct S_PIF p2,  void (*cb)(double, float, struct S_PIF)) ;
+EXPORT void f4_V_DFS_PID(double p0, float p1, struct S_PID p2,  void (*cb)(double, float, struct S_PID)) ;
+EXPORT void f4_V_DFS_PIP(double p0, float p1, struct S_PIP p2,  void (*cb)(double, float, struct S_PIP)) ;
+EXPORT void f4_V_DFS_PFI(double p0, float p1, struct S_PFI p2,  void (*cb)(double, float, struct S_PFI)) ;
+EXPORT void f4_V_DFS_PFF(double p0, float p1, struct S_PFF p2,  void (*cb)(double, float, struct S_PFF)) ;
+EXPORT void f4_V_DFS_PFD(double p0, float p1, struct S_PFD p2,  void (*cb)(double, float, struct S_PFD)) ;
+EXPORT void f4_V_DFS_PFP(double p0, float p1, struct S_PFP p2,  void (*cb)(double, float, struct S_PFP)) ;
+EXPORT void f4_V_DFS_PDI(double p0, float p1, struct S_PDI p2,  void (*cb)(double, float, struct S_PDI)) ;
+EXPORT void f4_V_DFS_PDF(double p0, float p1, struct S_PDF p2,  void (*cb)(double, float, struct S_PDF)) ;
+EXPORT void f4_V_DFS_PDD(double p0, float p1, struct S_PDD p2,  void (*cb)(double, float, struct S_PDD)) ;
+EXPORT void f4_V_DFS_PDP(double p0, float p1, struct S_PDP p2,  void (*cb)(double, float, struct S_PDP)) ;
+EXPORT void f4_V_DFS_PPI(double p0, float p1, struct S_PPI p2,  void (*cb)(double, float, struct S_PPI)) ;
+EXPORT void f4_V_DFS_PPF(double p0, float p1, struct S_PPF p2,  void (*cb)(double, float, struct S_PPF)) ;
+EXPORT void f4_V_DFS_PPD(double p0, float p1, struct S_PPD p2,  void (*cb)(double, float, struct S_PPD)) ;
+EXPORT void f4_V_DFS_PPP(double p0, float p1, struct S_PPP p2,  void (*cb)(double, float, struct S_PPP)) ;
+EXPORT void f4_V_DDI_(double p0, double p1, int p2,  void (*cb)(double, double, int)) ;
+EXPORT void f4_V_DDF_(double p0, double p1, float p2,  void (*cb)(double, double, float)) ;
+EXPORT void f4_V_DDD_(double p0, double p1, double p2,  void (*cb)(double, double, double)) ;
+EXPORT void f4_V_DDP_(double p0, double p1, void* p2,  void (*cb)(double, double, void*)) ;
+EXPORT void f4_V_DDS_I(double p0, double p1, struct S_I p2,  void (*cb)(double, double, struct S_I)) ;
+EXPORT void f4_V_DDS_F(double p0, double p1, struct S_F p2,  void (*cb)(double, double, struct S_F)) ;
+EXPORT void f4_V_DDS_D(double p0, double p1, struct S_D p2,  void (*cb)(double, double, struct S_D)) ;
+EXPORT void f4_V_DDS_P(double p0, double p1, struct S_P p2,  void (*cb)(double, double, struct S_P)) ;
+EXPORT void f4_V_DDS_II(double p0, double p1, struct S_II p2,  void (*cb)(double, double, struct S_II)) ;
+EXPORT void f4_V_DDS_IF(double p0, double p1, struct S_IF p2,  void (*cb)(double, double, struct S_IF)) ;
+EXPORT void f4_V_DDS_ID(double p0, double p1, struct S_ID p2,  void (*cb)(double, double, struct S_ID)) ;
+EXPORT void f4_V_DDS_IP(double p0, double p1, struct S_IP p2,  void (*cb)(double, double, struct S_IP)) ;
+EXPORT void f4_V_DDS_FI(double p0, double p1, struct S_FI p2,  void (*cb)(double, double, struct S_FI)) ;
+EXPORT void f4_V_DDS_FF(double p0, double p1, struct S_FF p2,  void (*cb)(double, double, struct S_FF)) ;
+EXPORT void f4_V_DDS_FD(double p0, double p1, struct S_FD p2,  void (*cb)(double, double, struct S_FD)) ;
+EXPORT void f4_V_DDS_FP(double p0, double p1, struct S_FP p2,  void (*cb)(double, double, struct S_FP)) ;
+EXPORT void f4_V_DDS_DI(double p0, double p1, struct S_DI p2,  void (*cb)(double, double, struct S_DI)) ;
+EXPORT void f4_V_DDS_DF(double p0, double p1, struct S_DF p2,  void (*cb)(double, double, struct S_DF)) ;
+EXPORT void f4_V_DDS_DD(double p0, double p1, struct S_DD p2,  void (*cb)(double, double, struct S_DD)) ;
+EXPORT void f4_V_DDS_DP(double p0, double p1, struct S_DP p2,  void (*cb)(double, double, struct S_DP)) ;
+EXPORT void f4_V_DDS_PI(double p0, double p1, struct S_PI p2,  void (*cb)(double, double, struct S_PI)) ;
+EXPORT void f4_V_DDS_PF(double p0, double p1, struct S_PF p2,  void (*cb)(double, double, struct S_PF)) ;
+EXPORT void f4_V_DDS_PD(double p0, double p1, struct S_PD p2,  void (*cb)(double, double, struct S_PD)) ;
+EXPORT void f4_V_DDS_PP(double p0, double p1, struct S_PP p2,  void (*cb)(double, double, struct S_PP)) ;
+EXPORT void f4_V_DDS_III(double p0, double p1, struct S_III p2,  void (*cb)(double, double, struct S_III)) ;
+EXPORT void f4_V_DDS_IIF(double p0, double p1, struct S_IIF p2,  void (*cb)(double, double, struct S_IIF)) ;
+EXPORT void f4_V_DDS_IID(double p0, double p1, struct S_IID p2,  void (*cb)(double, double, struct S_IID)) ;
+EXPORT void f4_V_DDS_IIP(double p0, double p1, struct S_IIP p2,  void (*cb)(double, double, struct S_IIP)) ;
+EXPORT void f4_V_DDS_IFI(double p0, double p1, struct S_IFI p2,  void (*cb)(double, double, struct S_IFI)) ;
+EXPORT void f4_V_DDS_IFF(double p0, double p1, struct S_IFF p2,  void (*cb)(double, double, struct S_IFF)) ;
+EXPORT void f4_V_DDS_IFD(double p0, double p1, struct S_IFD p2,  void (*cb)(double, double, struct S_IFD)) ;
+EXPORT void f4_V_DDS_IFP(double p0, double p1, struct S_IFP p2,  void (*cb)(double, double, struct S_IFP)) ;
+EXPORT void f4_V_DDS_IDI(double p0, double p1, struct S_IDI p2,  void (*cb)(double, double, struct S_IDI)) ;
+EXPORT void f4_V_DDS_IDF(double p0, double p1, struct S_IDF p2,  void (*cb)(double, double, struct S_IDF)) ;
+EXPORT void f4_V_DDS_IDD(double p0, double p1, struct S_IDD p2,  void (*cb)(double, double, struct S_IDD)) ;
+EXPORT void f4_V_DDS_IDP(double p0, double p1, struct S_IDP p2,  void (*cb)(double, double, struct S_IDP)) ;
+EXPORT void f4_V_DDS_IPI(double p0, double p1, struct S_IPI p2,  void (*cb)(double, double, struct S_IPI)) ;
+EXPORT void f4_V_DDS_IPF(double p0, double p1, struct S_IPF p2,  void (*cb)(double, double, struct S_IPF)) ;
+EXPORT void f4_V_DDS_IPD(double p0, double p1, struct S_IPD p2,  void (*cb)(double, double, struct S_IPD)) ;
+EXPORT void f4_V_DDS_IPP(double p0, double p1, struct S_IPP p2,  void (*cb)(double, double, struct S_IPP)) ;
+EXPORT void f4_V_DDS_FII(double p0, double p1, struct S_FII p2,  void (*cb)(double, double, struct S_FII)) ;
+EXPORT void f4_V_DDS_FIF(double p0, double p1, struct S_FIF p2,  void (*cb)(double, double, struct S_FIF)) ;
+EXPORT void f4_V_DDS_FID(double p0, double p1, struct S_FID p2,  void (*cb)(double, double, struct S_FID)) ;
+EXPORT void f4_V_DDS_FIP(double p0, double p1, struct S_FIP p2,  void (*cb)(double, double, struct S_FIP)) ;
+EXPORT void f4_V_DDS_FFI(double p0, double p1, struct S_FFI p2,  void (*cb)(double, double, struct S_FFI)) ;
+EXPORT void f4_V_DDS_FFF(double p0, double p1, struct S_FFF p2,  void (*cb)(double, double, struct S_FFF)) ;
+EXPORT void f4_V_DDS_FFD(double p0, double p1, struct S_FFD p2,  void (*cb)(double, double, struct S_FFD)) ;
+EXPORT void f4_V_DDS_FFP(double p0, double p1, struct S_FFP p2,  void (*cb)(double, double, struct S_FFP)) ;
+EXPORT void f4_V_DDS_FDI(double p0, double p1, struct S_FDI p2,  void (*cb)(double, double, struct S_FDI)) ;
+EXPORT void f4_V_DDS_FDF(double p0, double p1, struct S_FDF p2,  void (*cb)(double, double, struct S_FDF)) ;
+EXPORT void f4_V_DDS_FDD(double p0, double p1, struct S_FDD p2,  void (*cb)(double, double, struct S_FDD)) ;
+EXPORT void f4_V_DDS_FDP(double p0, double p1, struct S_FDP p2,  void (*cb)(double, double, struct S_FDP)) ;
+EXPORT void f4_V_DDS_FPI(double p0, double p1, struct S_FPI p2,  void (*cb)(double, double, struct S_FPI)) ;
+EXPORT void f4_V_DDS_FPF(double p0, double p1, struct S_FPF p2,  void (*cb)(double, double, struct S_FPF)) ;
+EXPORT void f4_V_DDS_FPD(double p0, double p1, struct S_FPD p2,  void (*cb)(double, double, struct S_FPD)) ;
+EXPORT void f4_V_DDS_FPP(double p0, double p1, struct S_FPP p2,  void (*cb)(double, double, struct S_FPP)) ;
+EXPORT void f4_V_DDS_DII(double p0, double p1, struct S_DII p2,  void (*cb)(double, double, struct S_DII)) ;
+EXPORT void f4_V_DDS_DIF(double p0, double p1, struct S_DIF p2,  void (*cb)(double, double, struct S_DIF)) ;
+EXPORT void f4_V_DDS_DID(double p0, double p1, struct S_DID p2,  void (*cb)(double, double, struct S_DID)) ;
+EXPORT void f4_V_DDS_DIP(double p0, double p1, struct S_DIP p2,  void (*cb)(double, double, struct S_DIP)) ;
+EXPORT void f4_V_DDS_DFI(double p0, double p1, struct S_DFI p2,  void (*cb)(double, double, struct S_DFI)) ;
+EXPORT void f4_V_DDS_DFF(double p0, double p1, struct S_DFF p2,  void (*cb)(double, double, struct S_DFF)) ;
+EXPORT void f4_V_DDS_DFD(double p0, double p1, struct S_DFD p2,  void (*cb)(double, double, struct S_DFD)) ;
+EXPORT void f4_V_DDS_DFP(double p0, double p1, struct S_DFP p2,  void (*cb)(double, double, struct S_DFP)) ;
+EXPORT void f4_V_DDS_DDI(double p0, double p1, struct S_DDI p2,  void (*cb)(double, double, struct S_DDI)) ;
+EXPORT void f4_V_DDS_DDF(double p0, double p1, struct S_DDF p2,  void (*cb)(double, double, struct S_DDF)) ;
+EXPORT void f4_V_DDS_DDD(double p0, double p1, struct S_DDD p2,  void (*cb)(double, double, struct S_DDD)) ;
+EXPORT void f4_V_DDS_DDP(double p0, double p1, struct S_DDP p2,  void (*cb)(double, double, struct S_DDP)) ;
+EXPORT void f4_V_DDS_DPI(double p0, double p1, struct S_DPI p2,  void (*cb)(double, double, struct S_DPI)) ;
+EXPORT void f4_V_DDS_DPF(double p0, double p1, struct S_DPF p2,  void (*cb)(double, double, struct S_DPF)) ;
+EXPORT void f4_V_DDS_DPD(double p0, double p1, struct S_DPD p2,  void (*cb)(double, double, struct S_DPD)) ;
+EXPORT void f4_V_DDS_DPP(double p0, double p1, struct S_DPP p2,  void (*cb)(double, double, struct S_DPP)) ;
+EXPORT void f4_V_DDS_PII(double p0, double p1, struct S_PII p2,  void (*cb)(double, double, struct S_PII)) ;
+EXPORT void f4_V_DDS_PIF(double p0, double p1, struct S_PIF p2,  void (*cb)(double, double, struct S_PIF)) ;
+EXPORT void f4_V_DDS_PID(double p0, double p1, struct S_PID p2,  void (*cb)(double, double, struct S_PID)) ;
+EXPORT void f4_V_DDS_PIP(double p0, double p1, struct S_PIP p2,  void (*cb)(double, double, struct S_PIP)) ;
+EXPORT void f4_V_DDS_PFI(double p0, double p1, struct S_PFI p2,  void (*cb)(double, double, struct S_PFI)) ;
+EXPORT void f4_V_DDS_PFF(double p0, double p1, struct S_PFF p2,  void (*cb)(double, double, struct S_PFF)) ;
+EXPORT void f4_V_DDS_PFD(double p0, double p1, struct S_PFD p2,  void (*cb)(double, double, struct S_PFD)) ;
+EXPORT void f4_V_DDS_PFP(double p0, double p1, struct S_PFP p2,  void (*cb)(double, double, struct S_PFP)) ;
+EXPORT void f4_V_DDS_PDI(double p0, double p1, struct S_PDI p2,  void (*cb)(double, double, struct S_PDI)) ;
+EXPORT void f4_V_DDS_PDF(double p0, double p1, struct S_PDF p2,  void (*cb)(double, double, struct S_PDF)) ;
+EXPORT void f4_V_DDS_PDD(double p0, double p1, struct S_PDD p2,  void (*cb)(double, double, struct S_PDD)) ;
+EXPORT void f4_V_DDS_PDP(double p0, double p1, struct S_PDP p2,  void (*cb)(double, double, struct S_PDP)) ;
+EXPORT void f4_V_DDS_PPI(double p0, double p1, struct S_PPI p2,  void (*cb)(double, double, struct S_PPI)) ;
+EXPORT void f4_V_DDS_PPF(double p0, double p1, struct S_PPF p2,  void (*cb)(double, double, struct S_PPF)) ;
+EXPORT void f4_V_DDS_PPD(double p0, double p1, struct S_PPD p2,  void (*cb)(double, double, struct S_PPD)) ;
+EXPORT void f4_V_DDS_PPP(double p0, double p1, struct S_PPP p2,  void (*cb)(double, double, struct S_PPP)) ;
+EXPORT void f4_V_DPI_(double p0, void* p1, int p2,  void (*cb)(double, void*, int)) ;
+EXPORT void f4_V_DPF_(double p0, void* p1, float p2,  void (*cb)(double, void*, float)) ;
+EXPORT void f4_V_DPD_(double p0, void* p1, double p2,  void (*cb)(double, void*, double)) ;
+EXPORT void f4_V_DPP_(double p0, void* p1, void* p2,  void (*cb)(double, void*, void*)) ;
+EXPORT void f4_V_DPS_I(double p0, void* p1, struct S_I p2,  void (*cb)(double, void*, struct S_I)) ;
+EXPORT void f4_V_DPS_F(double p0, void* p1, struct S_F p2,  void (*cb)(double, void*, struct S_F)) ;
+EXPORT void f4_V_DPS_D(double p0, void* p1, struct S_D p2,  void (*cb)(double, void*, struct S_D)) ;
+EXPORT void f4_V_DPS_P(double p0, void* p1, struct S_P p2,  void (*cb)(double, void*, struct S_P)) ;
+EXPORT void f4_V_DPS_II(double p0, void* p1, struct S_II p2,  void (*cb)(double, void*, struct S_II)) ;
+EXPORT void f4_V_DPS_IF(double p0, void* p1, struct S_IF p2,  void (*cb)(double, void*, struct S_IF)) ;
+EXPORT void f4_V_DPS_ID(double p0, void* p1, struct S_ID p2,  void (*cb)(double, void*, struct S_ID)) ;
+EXPORT void f4_V_DPS_IP(double p0, void* p1, struct S_IP p2,  void (*cb)(double, void*, struct S_IP)) ;
+EXPORT void f4_V_DPS_FI(double p0, void* p1, struct S_FI p2,  void (*cb)(double, void*, struct S_FI)) ;
+EXPORT void f4_V_DPS_FF(double p0, void* p1, struct S_FF p2,  void (*cb)(double, void*, struct S_FF)) ;
+EXPORT void f4_V_DPS_FD(double p0, void* p1, struct S_FD p2,  void (*cb)(double, void*, struct S_FD)) ;
+EXPORT void f4_V_DPS_FP(double p0, void* p1, struct S_FP p2,  void (*cb)(double, void*, struct S_FP)) ;
+EXPORT void f4_V_DPS_DI(double p0, void* p1, struct S_DI p2,  void (*cb)(double, void*, struct S_DI)) ;
+EXPORT void f4_V_DPS_DF(double p0, void* p1, struct S_DF p2,  void (*cb)(double, void*, struct S_DF)) ;
+EXPORT void f4_V_DPS_DD(double p0, void* p1, struct S_DD p2,  void (*cb)(double, void*, struct S_DD)) ;
+EXPORT void f4_V_DPS_DP(double p0, void* p1, struct S_DP p2,  void (*cb)(double, void*, struct S_DP)) ;
+EXPORT void f4_V_DPS_PI(double p0, void* p1, struct S_PI p2,  void (*cb)(double, void*, struct S_PI)) ;
+EXPORT void f4_V_DPS_PF(double p0, void* p1, struct S_PF p2,  void (*cb)(double, void*, struct S_PF)) ;
+EXPORT void f4_V_DPS_PD(double p0, void* p1, struct S_PD p2,  void (*cb)(double, void*, struct S_PD)) ;
+EXPORT void f4_V_DPS_PP(double p0, void* p1, struct S_PP p2,  void (*cb)(double, void*, struct S_PP)) ;
+EXPORT void f4_V_DPS_III(double p0, void* p1, struct S_III p2,  void (*cb)(double, void*, struct S_III)) ;
+EXPORT void f4_V_DPS_IIF(double p0, void* p1, struct S_IIF p2,  void (*cb)(double, void*, struct S_IIF)) ;
+EXPORT void f4_V_DPS_IID(double p0, void* p1, struct S_IID p2,  void (*cb)(double, void*, struct S_IID)) ;
+EXPORT void f4_V_DPS_IIP(double p0, void* p1, struct S_IIP p2,  void (*cb)(double, void*, struct S_IIP)) ;
+EXPORT void f4_V_DPS_IFI(double p0, void* p1, struct S_IFI p2,  void (*cb)(double, void*, struct S_IFI)) ;
+EXPORT void f4_V_DPS_IFF(double p0, void* p1, struct S_IFF p2,  void (*cb)(double, void*, struct S_IFF)) ;
+EXPORT void f4_V_DPS_IFD(double p0, void* p1, struct S_IFD p2,  void (*cb)(double, void*, struct S_IFD)) ;
+EXPORT void f4_V_DPS_IFP(double p0, void* p1, struct S_IFP p2,  void (*cb)(double, void*, struct S_IFP)) ;
+EXPORT void f4_V_DPS_IDI(double p0, void* p1, struct S_IDI p2,  void (*cb)(double, void*, struct S_IDI)) ;
+EXPORT void f4_V_DPS_IDF(double p0, void* p1, struct S_IDF p2,  void (*cb)(double, void*, struct S_IDF)) ;
+EXPORT void f4_V_DPS_IDD(double p0, void* p1, struct S_IDD p2,  void (*cb)(double, void*, struct S_IDD)) ;
+EXPORT void f4_V_DPS_IDP(double p0, void* p1, struct S_IDP p2,  void (*cb)(double, void*, struct S_IDP)) ;
+EXPORT void f4_V_DPS_IPI(double p0, void* p1, struct S_IPI p2,  void (*cb)(double, void*, struct S_IPI)) ;
+EXPORT void f4_V_DPS_IPF(double p0, void* p1, struct S_IPF p2,  void (*cb)(double, void*, struct S_IPF)) ;
+EXPORT void f4_V_DPS_IPD(double p0, void* p1, struct S_IPD p2,  void (*cb)(double, void*, struct S_IPD)) ;
+EXPORT void f4_V_DPS_IPP(double p0, void* p1, struct S_IPP p2,  void (*cb)(double, void*, struct S_IPP)) ;
+EXPORT void f4_V_DPS_FII(double p0, void* p1, struct S_FII p2,  void (*cb)(double, void*, struct S_FII)) ;
+EXPORT void f4_V_DPS_FIF(double p0, void* p1, struct S_FIF p2,  void (*cb)(double, void*, struct S_FIF)) ;
+EXPORT void f4_V_DPS_FID(double p0, void* p1, struct S_FID p2,  void (*cb)(double, void*, struct S_FID)) ;
+EXPORT void f4_V_DPS_FIP(double p0, void* p1, struct S_FIP p2,  void (*cb)(double, void*, struct S_FIP)) ;
+EXPORT void f4_V_DPS_FFI(double p0, void* p1, struct S_FFI p2,  void (*cb)(double, void*, struct S_FFI)) ;
+EXPORT void f4_V_DPS_FFF(double p0, void* p1, struct S_FFF p2,  void (*cb)(double, void*, struct S_FFF)) ;
+EXPORT void f4_V_DPS_FFD(double p0, void* p1, struct S_FFD p2,  void (*cb)(double, void*, struct S_FFD)) ;
+EXPORT void f4_V_DPS_FFP(double p0, void* p1, struct S_FFP p2,  void (*cb)(double, void*, struct S_FFP)) ;
+EXPORT void f4_V_DPS_FDI(double p0, void* p1, struct S_FDI p2,  void (*cb)(double, void*, struct S_FDI)) ;
+EXPORT void f4_V_DPS_FDF(double p0, void* p1, struct S_FDF p2,  void (*cb)(double, void*, struct S_FDF)) ;
+EXPORT void f4_V_DPS_FDD(double p0, void* p1, struct S_FDD p2,  void (*cb)(double, void*, struct S_FDD)) ;
+EXPORT void f4_V_DPS_FDP(double p0, void* p1, struct S_FDP p2,  void (*cb)(double, void*, struct S_FDP)) ;
+EXPORT void f4_V_DPS_FPI(double p0, void* p1, struct S_FPI p2,  void (*cb)(double, void*, struct S_FPI)) ;
+EXPORT void f4_V_DPS_FPF(double p0, void* p1, struct S_FPF p2,  void (*cb)(double, void*, struct S_FPF)) ;
+EXPORT void f4_V_DPS_FPD(double p0, void* p1, struct S_FPD p2,  void (*cb)(double, void*, struct S_FPD)) ;
+EXPORT void f4_V_DPS_FPP(double p0, void* p1, struct S_FPP p2,  void (*cb)(double, void*, struct S_FPP)) ;
+EXPORT void f4_V_DPS_DII(double p0, void* p1, struct S_DII p2,  void (*cb)(double, void*, struct S_DII)) ;
+EXPORT void f4_V_DPS_DIF(double p0, void* p1, struct S_DIF p2,  void (*cb)(double, void*, struct S_DIF)) ;
+EXPORT void f4_V_DPS_DID(double p0, void* p1, struct S_DID p2,  void (*cb)(double, void*, struct S_DID)) ;
+EXPORT void f4_V_DPS_DIP(double p0, void* p1, struct S_DIP p2,  void (*cb)(double, void*, struct S_DIP)) ;
+EXPORT void f4_V_DPS_DFI(double p0, void* p1, struct S_DFI p2,  void (*cb)(double, void*, struct S_DFI)) ;
+EXPORT void f4_V_DPS_DFF(double p0, void* p1, struct S_DFF p2,  void (*cb)(double, void*, struct S_DFF)) ;
+EXPORT void f4_V_DPS_DFD(double p0, void* p1, struct S_DFD p2,  void (*cb)(double, void*, struct S_DFD)) ;
+EXPORT void f4_V_DPS_DFP(double p0, void* p1, struct S_DFP p2,  void (*cb)(double, void*, struct S_DFP)) ;
+EXPORT void f4_V_DPS_DDI(double p0, void* p1, struct S_DDI p2,  void (*cb)(double, void*, struct S_DDI)) ;
+EXPORT void f4_V_DPS_DDF(double p0, void* p1, struct S_DDF p2,  void (*cb)(double, void*, struct S_DDF)) ;
+EXPORT void f4_V_DPS_DDD(double p0, void* p1, struct S_DDD p2,  void (*cb)(double, void*, struct S_DDD)) ;
+EXPORT void f4_V_DPS_DDP(double p0, void* p1, struct S_DDP p2,  void (*cb)(double, void*, struct S_DDP)) ;
+EXPORT void f4_V_DPS_DPI(double p0, void* p1, struct S_DPI p2,  void (*cb)(double, void*, struct S_DPI)) ;
+EXPORT void f4_V_DPS_DPF(double p0, void* p1, struct S_DPF p2,  void (*cb)(double, void*, struct S_DPF)) ;
+EXPORT void f4_V_DPS_DPD(double p0, void* p1, struct S_DPD p2,  void (*cb)(double, void*, struct S_DPD)) ;
+EXPORT void f4_V_DPS_DPP(double p0, void* p1, struct S_DPP p2,  void (*cb)(double, void*, struct S_DPP)) ;
+EXPORT void f4_V_DPS_PII(double p0, void* p1, struct S_PII p2,  void (*cb)(double, void*, struct S_PII)) ;
+EXPORT void f4_V_DPS_PIF(double p0, void* p1, struct S_PIF p2,  void (*cb)(double, void*, struct S_PIF)) ;
+EXPORT void f4_V_DPS_PID(double p0, void* p1, struct S_PID p2,  void (*cb)(double, void*, struct S_PID)) ;
+EXPORT void f4_V_DPS_PIP(double p0, void* p1, struct S_PIP p2,  void (*cb)(double, void*, struct S_PIP)) ;
+EXPORT void f4_V_DPS_PFI(double p0, void* p1, struct S_PFI p2,  void (*cb)(double, void*, struct S_PFI)) ;
+EXPORT void f4_V_DPS_PFF(double p0, void* p1, struct S_PFF p2,  void (*cb)(double, void*, struct S_PFF)) ;
+EXPORT void f4_V_DPS_PFD(double p0, void* p1, struct S_PFD p2,  void (*cb)(double, void*, struct S_PFD)) ;
+EXPORT void f4_V_DPS_PFP(double p0, void* p1, struct S_PFP p2,  void (*cb)(double, void*, struct S_PFP)) ;
+EXPORT void f4_V_DPS_PDI(double p0, void* p1, struct S_PDI p2,  void (*cb)(double, void*, struct S_PDI)) ;
+EXPORT void f4_V_DPS_PDF(double p0, void* p1, struct S_PDF p2,  void (*cb)(double, void*, struct S_PDF)) ;
+EXPORT void f4_V_DPS_PDD(double p0, void* p1, struct S_PDD p2,  void (*cb)(double, void*, struct S_PDD)) ;
+EXPORT void f4_V_DPS_PDP(double p0, void* p1, struct S_PDP p2,  void (*cb)(double, void*, struct S_PDP)) ;
+EXPORT void f4_V_DPS_PPI(double p0, void* p1, struct S_PPI p2,  void (*cb)(double, void*, struct S_PPI)) ;
+EXPORT void f4_V_DPS_PPF(double p0, void* p1, struct S_PPF p2,  void (*cb)(double, void*, struct S_PPF)) ;
+EXPORT void f4_V_DPS_PPD(double p0, void* p1, struct S_PPD p2,  void (*cb)(double, void*, struct S_PPD)) ;
+EXPORT void f4_V_DPS_PPP(double p0, void* p1, struct S_PPP p2,  void (*cb)(double, void*, struct S_PPP)) ;
+EXPORT void f4_V_DSI_I(double p0, struct S_I p1, int p2,  void (*cb)(double, struct S_I, int)) ;
+EXPORT void f4_V_DSI_F(double p0, struct S_F p1, int p2,  void (*cb)(double, struct S_F, int)) ;
+EXPORT void f4_V_DSI_D(double p0, struct S_D p1, int p2,  void (*cb)(double, struct S_D, int)) ;
+EXPORT void f4_V_DSI_P(double p0, struct S_P p1, int p2,  void (*cb)(double, struct S_P, int)) ;
+EXPORT void f4_V_DSI_II(double p0, struct S_II p1, int p2,  void (*cb)(double, struct S_II, int)) ;
+EXPORT void f4_V_DSI_IF(double p0, struct S_IF p1, int p2,  void (*cb)(double, struct S_IF, int)) ;
+EXPORT void f4_V_DSI_ID(double p0, struct S_ID p1, int p2,  void (*cb)(double, struct S_ID, int)) ;
+EXPORT void f4_V_DSI_IP(double p0, struct S_IP p1, int p2,  void (*cb)(double, struct S_IP, int)) ;
+EXPORT void f4_V_DSI_FI(double p0, struct S_FI p1, int p2,  void (*cb)(double, struct S_FI, int)) ;
+EXPORT void f4_V_DSI_FF(double p0, struct S_FF p1, int p2,  void (*cb)(double, struct S_FF, int)) ;
+EXPORT void f4_V_DSI_FD(double p0, struct S_FD p1, int p2,  void (*cb)(double, struct S_FD, int)) ;
+EXPORT void f4_V_DSI_FP(double p0, struct S_FP p1, int p2,  void (*cb)(double, struct S_FP, int)) ;
+EXPORT void f4_V_DSI_DI(double p0, struct S_DI p1, int p2,  void (*cb)(double, struct S_DI, int)) ;
+EXPORT void f4_V_DSI_DF(double p0, struct S_DF p1, int p2,  void (*cb)(double, struct S_DF, int)) ;
+EXPORT void f4_V_DSI_DD(double p0, struct S_DD p1, int p2,  void (*cb)(double, struct S_DD, int)) ;
+EXPORT void f4_V_DSI_DP(double p0, struct S_DP p1, int p2,  void (*cb)(double, struct S_DP, int)) ;
+EXPORT void f4_V_DSI_PI(double p0, struct S_PI p1, int p2,  void (*cb)(double, struct S_PI, int)) ;
+EXPORT void f4_V_DSI_PF(double p0, struct S_PF p1, int p2,  void (*cb)(double, struct S_PF, int)) ;
+EXPORT void f4_V_DSI_PD(double p0, struct S_PD p1, int p2,  void (*cb)(double, struct S_PD, int)) ;
+EXPORT void f4_V_DSI_PP(double p0, struct S_PP p1, int p2,  void (*cb)(double, struct S_PP, int)) ;
+EXPORT void f4_V_DSI_III(double p0, struct S_III p1, int p2,  void (*cb)(double, struct S_III, int)) ;
+EXPORT void f4_V_DSI_IIF(double p0, struct S_IIF p1, int p2,  void (*cb)(double, struct S_IIF, int)) ;
+EXPORT void f4_V_DSI_IID(double p0, struct S_IID p1, int p2,  void (*cb)(double, struct S_IID, int)) ;
+EXPORT void f4_V_DSI_IIP(double p0, struct S_IIP p1, int p2,  void (*cb)(double, struct S_IIP, int)) ;
+EXPORT void f4_V_DSI_IFI(double p0, struct S_IFI p1, int p2,  void (*cb)(double, struct S_IFI, int)) ;
+EXPORT void f4_V_DSI_IFF(double p0, struct S_IFF p1, int p2,  void (*cb)(double, struct S_IFF, int)) ;
+EXPORT void f4_V_DSI_IFD(double p0, struct S_IFD p1, int p2,  void (*cb)(double, struct S_IFD, int)) ;
+EXPORT void f4_V_DSI_IFP(double p0, struct S_IFP p1, int p2,  void (*cb)(double, struct S_IFP, int)) ;
+EXPORT void f4_V_DSI_IDI(double p0, struct S_IDI p1, int p2,  void (*cb)(double, struct S_IDI, int)) ;
+EXPORT void f4_V_DSI_IDF(double p0, struct S_IDF p1, int p2,  void (*cb)(double, struct S_IDF, int)) ;
+EXPORT void f4_V_DSI_IDD(double p0, struct S_IDD p1, int p2,  void (*cb)(double, struct S_IDD, int)) ;
+EXPORT void f4_V_DSI_IDP(double p0, struct S_IDP p1, int p2,  void (*cb)(double, struct S_IDP, int)) ;
+EXPORT void f4_V_DSI_IPI(double p0, struct S_IPI p1, int p2,  void (*cb)(double, struct S_IPI, int)) ;
+EXPORT void f4_V_DSI_IPF(double p0, struct S_IPF p1, int p2,  void (*cb)(double, struct S_IPF, int)) ;
+EXPORT void f4_V_DSI_IPD(double p0, struct S_IPD p1, int p2,  void (*cb)(double, struct S_IPD, int)) ;
+EXPORT void f4_V_DSI_IPP(double p0, struct S_IPP p1, int p2,  void (*cb)(double, struct S_IPP, int)) ;
+EXPORT void f4_V_DSI_FII(double p0, struct S_FII p1, int p2,  void (*cb)(double, struct S_FII, int)) ;
+EXPORT void f4_V_DSI_FIF(double p0, struct S_FIF p1, int p2,  void (*cb)(double, struct S_FIF, int)) ;
+EXPORT void f4_V_DSI_FID(double p0, struct S_FID p1, int p2,  void (*cb)(double, struct S_FID, int)) ;
+EXPORT void f4_V_DSI_FIP(double p0, struct S_FIP p1, int p2,  void (*cb)(double, struct S_FIP, int)) ;
+EXPORT void f4_V_DSI_FFI(double p0, struct S_FFI p1, int p2,  void (*cb)(double, struct S_FFI, int)) ;
+EXPORT void f4_V_DSI_FFF(double p0, struct S_FFF p1, int p2,  void (*cb)(double, struct S_FFF, int)) ;
+EXPORT void f4_V_DSI_FFD(double p0, struct S_FFD p1, int p2,  void (*cb)(double, struct S_FFD, int)) ;
+EXPORT void f4_V_DSI_FFP(double p0, struct S_FFP p1, int p2,  void (*cb)(double, struct S_FFP, int)) ;
+EXPORT void f4_V_DSI_FDI(double p0, struct S_FDI p1, int p2,  void (*cb)(double, struct S_FDI, int)) ;
+EXPORT void f4_V_DSI_FDF(double p0, struct S_FDF p1, int p2,  void (*cb)(double, struct S_FDF, int)) ;
+EXPORT void f4_V_DSI_FDD(double p0, struct S_FDD p1, int p2,  void (*cb)(double, struct S_FDD, int)) ;
+EXPORT void f4_V_DSI_FDP(double p0, struct S_FDP p1, int p2,  void (*cb)(double, struct S_FDP, int)) ;
+EXPORT void f4_V_DSI_FPI(double p0, struct S_FPI p1, int p2,  void (*cb)(double, struct S_FPI, int)) ;
+EXPORT void f4_V_DSI_FPF(double p0, struct S_FPF p1, int p2,  void (*cb)(double, struct S_FPF, int)) ;
+EXPORT void f4_V_DSI_FPD(double p0, struct S_FPD p1, int p2,  void (*cb)(double, struct S_FPD, int)) ;
+EXPORT void f4_V_DSI_FPP(double p0, struct S_FPP p1, int p2,  void (*cb)(double, struct S_FPP, int)) ;
+EXPORT void f4_V_DSI_DII(double p0, struct S_DII p1, int p2,  void (*cb)(double, struct S_DII, int)) ;
+EXPORT void f4_V_DSI_DIF(double p0, struct S_DIF p1, int p2,  void (*cb)(double, struct S_DIF, int)) ;
+EXPORT void f4_V_DSI_DID(double p0, struct S_DID p1, int p2,  void (*cb)(double, struct S_DID, int)) ;
+EXPORT void f4_V_DSI_DIP(double p0, struct S_DIP p1, int p2,  void (*cb)(double, struct S_DIP, int)) ;
+EXPORT void f4_V_DSI_DFI(double p0, struct S_DFI p1, int p2,  void (*cb)(double, struct S_DFI, int)) ;
+EXPORT void f4_V_DSI_DFF(double p0, struct S_DFF p1, int p2,  void (*cb)(double, struct S_DFF, int)) ;
+EXPORT void f4_V_DSI_DFD(double p0, struct S_DFD p1, int p2,  void (*cb)(double, struct S_DFD, int)) ;
+EXPORT void f4_V_DSI_DFP(double p0, struct S_DFP p1, int p2,  void (*cb)(double, struct S_DFP, int)) ;
+EXPORT void f4_V_DSI_DDI(double p0, struct S_DDI p1, int p2,  void (*cb)(double, struct S_DDI, int)) ;
+EXPORT void f4_V_DSI_DDF(double p0, struct S_DDF p1, int p2,  void (*cb)(double, struct S_DDF, int)) ;
+EXPORT void f4_V_DSI_DDD(double p0, struct S_DDD p1, int p2,  void (*cb)(double, struct S_DDD, int)) ;
+EXPORT void f4_V_DSI_DDP(double p0, struct S_DDP p1, int p2,  void (*cb)(double, struct S_DDP, int)) ;
+EXPORT void f4_V_DSI_DPI(double p0, struct S_DPI p1, int p2,  void (*cb)(double, struct S_DPI, int)) ;
+EXPORT void f4_V_DSI_DPF(double p0, struct S_DPF p1, int p2,  void (*cb)(double, struct S_DPF, int)) ;
+EXPORT void f4_V_DSI_DPD(double p0, struct S_DPD p1, int p2,  void (*cb)(double, struct S_DPD, int)) ;
+EXPORT void f4_V_DSI_DPP(double p0, struct S_DPP p1, int p2,  void (*cb)(double, struct S_DPP, int)) ;
+EXPORT void f4_V_DSI_PII(double p0, struct S_PII p1, int p2,  void (*cb)(double, struct S_PII, int)) ;
+EXPORT void f4_V_DSI_PIF(double p0, struct S_PIF p1, int p2,  void (*cb)(double, struct S_PIF, int)) ;
+EXPORT void f4_V_DSI_PID(double p0, struct S_PID p1, int p2,  void (*cb)(double, struct S_PID, int)) ;
+EXPORT void f4_V_DSI_PIP(double p0, struct S_PIP p1, int p2,  void (*cb)(double, struct S_PIP, int)) ;
+EXPORT void f4_V_DSI_PFI(double p0, struct S_PFI p1, int p2,  void (*cb)(double, struct S_PFI, int)) ;
+EXPORT void f4_V_DSI_PFF(double p0, struct S_PFF p1, int p2,  void (*cb)(double, struct S_PFF, int)) ;
+EXPORT void f4_V_DSI_PFD(double p0, struct S_PFD p1, int p2,  void (*cb)(double, struct S_PFD, int)) ;
+EXPORT void f4_V_DSI_PFP(double p0, struct S_PFP p1, int p2,  void (*cb)(double, struct S_PFP, int)) ;
+EXPORT void f4_V_DSI_PDI(double p0, struct S_PDI p1, int p2,  void (*cb)(double, struct S_PDI, int)) ;
+EXPORT void f4_V_DSI_PDF(double p0, struct S_PDF p1, int p2,  void (*cb)(double, struct S_PDF, int)) ;
+EXPORT void f4_V_DSI_PDD(double p0, struct S_PDD p1, int p2,  void (*cb)(double, struct S_PDD, int)) ;
+EXPORT void f4_V_DSI_PDP(double p0, struct S_PDP p1, int p2,  void (*cb)(double, struct S_PDP, int)) ;
+EXPORT void f4_V_DSI_PPI(double p0, struct S_PPI p1, int p2,  void (*cb)(double, struct S_PPI, int)) ;
+EXPORT void f4_V_DSI_PPF(double p0, struct S_PPF p1, int p2,  void (*cb)(double, struct S_PPF, int)) ;
+EXPORT void f4_V_DSI_PPD(double p0, struct S_PPD p1, int p2,  void (*cb)(double, struct S_PPD, int)) ;
+EXPORT void f4_V_DSI_PPP(double p0, struct S_PPP p1, int p2,  void (*cb)(double, struct S_PPP, int)) ;
+EXPORT void f4_V_DSF_I(double p0, struct S_I p1, float p2,  void (*cb)(double, struct S_I, float)) ;
+EXPORT void f4_V_DSF_F(double p0, struct S_F p1, float p2,  void (*cb)(double, struct S_F, float)) ;
+EXPORT void f4_V_DSF_D(double p0, struct S_D p1, float p2,  void (*cb)(double, struct S_D, float)) ;
+EXPORT void f4_V_DSF_P(double p0, struct S_P p1, float p2,  void (*cb)(double, struct S_P, float)) ;
+EXPORT void f4_V_DSF_II(double p0, struct S_II p1, float p2,  void (*cb)(double, struct S_II, float)) ;
+EXPORT void f4_V_DSF_IF(double p0, struct S_IF p1, float p2,  void (*cb)(double, struct S_IF, float)) ;
+EXPORT void f4_V_DSF_ID(double p0, struct S_ID p1, float p2,  void (*cb)(double, struct S_ID, float)) ;
+EXPORT void f4_V_DSF_IP(double p0, struct S_IP p1, float p2,  void (*cb)(double, struct S_IP, float)) ;
+EXPORT void f4_V_DSF_FI(double p0, struct S_FI p1, float p2,  void (*cb)(double, struct S_FI, float)) ;
+EXPORT void f4_V_DSF_FF(double p0, struct S_FF p1, float p2,  void (*cb)(double, struct S_FF, float)) ;
+EXPORT void f4_V_DSF_FD(double p0, struct S_FD p1, float p2,  void (*cb)(double, struct S_FD, float)) ;
+EXPORT void f4_V_DSF_FP(double p0, struct S_FP p1, float p2,  void (*cb)(double, struct S_FP, float)) ;
+EXPORT void f4_V_DSF_DI(double p0, struct S_DI p1, float p2,  void (*cb)(double, struct S_DI, float)) ;
+EXPORT void f4_V_DSF_DF(double p0, struct S_DF p1, float p2,  void (*cb)(double, struct S_DF, float)) ;
+EXPORT void f4_V_DSF_DD(double p0, struct S_DD p1, float p2,  void (*cb)(double, struct S_DD, float)) ;
+EXPORT void f4_V_DSF_DP(double p0, struct S_DP p1, float p2,  void (*cb)(double, struct S_DP, float)) ;
+EXPORT void f4_V_DSF_PI(double p0, struct S_PI p1, float p2,  void (*cb)(double, struct S_PI, float)) ;
+EXPORT void f4_V_DSF_PF(double p0, struct S_PF p1, float p2,  void (*cb)(double, struct S_PF, float)) ;
+EXPORT void f4_V_DSF_PD(double p0, struct S_PD p1, float p2,  void (*cb)(double, struct S_PD, float)) ;
+EXPORT void f4_V_DSF_PP(double p0, struct S_PP p1, float p2,  void (*cb)(double, struct S_PP, float)) ;
+EXPORT void f4_V_DSF_III(double p0, struct S_III p1, float p2,  void (*cb)(double, struct S_III, float)) ;
+EXPORT void f4_V_DSF_IIF(double p0, struct S_IIF p1, float p2,  void (*cb)(double, struct S_IIF, float)) ;
+EXPORT void f4_V_DSF_IID(double p0, struct S_IID p1, float p2,  void (*cb)(double, struct S_IID, float)) ;
+EXPORT void f4_V_DSF_IIP(double p0, struct S_IIP p1, float p2,  void (*cb)(double, struct S_IIP, float)) ;
+EXPORT void f4_V_DSF_IFI(double p0, struct S_IFI p1, float p2,  void (*cb)(double, struct S_IFI, float)) ;
+EXPORT void f4_V_DSF_IFF(double p0, struct S_IFF p1, float p2,  void (*cb)(double, struct S_IFF, float)) ;
+EXPORT void f4_V_DSF_IFD(double p0, struct S_IFD p1, float p2,  void (*cb)(double, struct S_IFD, float)) ;
+EXPORT void f4_V_DSF_IFP(double p0, struct S_IFP p1, float p2,  void (*cb)(double, struct S_IFP, float)) ;
+EXPORT void f4_V_DSF_IDI(double p0, struct S_IDI p1, float p2,  void (*cb)(double, struct S_IDI, float)) ;
+EXPORT void f4_V_DSF_IDF(double p0, struct S_IDF p1, float p2,  void (*cb)(double, struct S_IDF, float)) ;
+EXPORT void f4_V_DSF_IDD(double p0, struct S_IDD p1, float p2,  void (*cb)(double, struct S_IDD, float)) ;
+EXPORT void f4_V_DSF_IDP(double p0, struct S_IDP p1, float p2,  void (*cb)(double, struct S_IDP, float)) ;
+EXPORT void f4_V_DSF_IPI(double p0, struct S_IPI p1, float p2,  void (*cb)(double, struct S_IPI, float)) ;
+EXPORT void f4_V_DSF_IPF(double p0, struct S_IPF p1, float p2,  void (*cb)(double, struct S_IPF, float)) ;
+EXPORT void f4_V_DSF_IPD(double p0, struct S_IPD p1, float p2,  void (*cb)(double, struct S_IPD, float)) ;
+EXPORT void f4_V_DSF_IPP(double p0, struct S_IPP p1, float p2,  void (*cb)(double, struct S_IPP, float)) ;
+EXPORT void f4_V_DSF_FII(double p0, struct S_FII p1, float p2,  void (*cb)(double, struct S_FII, float)) ;
+EXPORT void f4_V_DSF_FIF(double p0, struct S_FIF p1, float p2,  void (*cb)(double, struct S_FIF, float)) ;
+EXPORT void f4_V_DSF_FID(double p0, struct S_FID p1, float p2,  void (*cb)(double, struct S_FID, float)) ;
+EXPORT void f4_V_DSF_FIP(double p0, struct S_FIP p1, float p2,  void (*cb)(double, struct S_FIP, float)) ;
+EXPORT void f4_V_DSF_FFI(double p0, struct S_FFI p1, float p2,  void (*cb)(double, struct S_FFI, float)) ;
+EXPORT void f4_V_DSF_FFF(double p0, struct S_FFF p1, float p2,  void (*cb)(double, struct S_FFF, float)) ;
+EXPORT void f4_V_DSF_FFD(double p0, struct S_FFD p1, float p2,  void (*cb)(double, struct S_FFD, float)) ;
+EXPORT void f4_V_DSF_FFP(double p0, struct S_FFP p1, float p2,  void (*cb)(double, struct S_FFP, float)) ;
+EXPORT void f4_V_DSF_FDI(double p0, struct S_FDI p1, float p2,  void (*cb)(double, struct S_FDI, float)) ;
+EXPORT void f4_V_DSF_FDF(double p0, struct S_FDF p1, float p2,  void (*cb)(double, struct S_FDF, float)) ;
+EXPORT void f4_V_DSF_FDD(double p0, struct S_FDD p1, float p2,  void (*cb)(double, struct S_FDD, float)) ;
+EXPORT void f4_V_DSF_FDP(double p0, struct S_FDP p1, float p2,  void (*cb)(double, struct S_FDP, float)) ;
+EXPORT void f4_V_DSF_FPI(double p0, struct S_FPI p1, float p2,  void (*cb)(double, struct S_FPI, float)) ;
+EXPORT void f4_V_DSF_FPF(double p0, struct S_FPF p1, float p2,  void (*cb)(double, struct S_FPF, float)) ;
+EXPORT void f4_V_DSF_FPD(double p0, struct S_FPD p1, float p2,  void (*cb)(double, struct S_FPD, float)) ;
+EXPORT void f4_V_DSF_FPP(double p0, struct S_FPP p1, float p2,  void (*cb)(double, struct S_FPP, float)) ;
+EXPORT void f4_V_DSF_DII(double p0, struct S_DII p1, float p2,  void (*cb)(double, struct S_DII, float)) ;
+EXPORT void f4_V_DSF_DIF(double p0, struct S_DIF p1, float p2,  void (*cb)(double, struct S_DIF, float)) ;
+EXPORT void f4_V_DSF_DID(double p0, struct S_DID p1, float p2,  void (*cb)(double, struct S_DID, float)) ;
+EXPORT void f4_V_DSF_DIP(double p0, struct S_DIP p1, float p2,  void (*cb)(double, struct S_DIP, float)) ;
+EXPORT void f4_V_DSF_DFI(double p0, struct S_DFI p1, float p2,  void (*cb)(double, struct S_DFI, float)) ;
+EXPORT void f4_V_DSF_DFF(double p0, struct S_DFF p1, float p2,  void (*cb)(double, struct S_DFF, float)) ;
+EXPORT void f4_V_DSF_DFD(double p0, struct S_DFD p1, float p2,  void (*cb)(double, struct S_DFD, float)) ;
+EXPORT void f4_V_DSF_DFP(double p0, struct S_DFP p1, float p2,  void (*cb)(double, struct S_DFP, float)) ;
+EXPORT void f4_V_DSF_DDI(double p0, struct S_DDI p1, float p2,  void (*cb)(double, struct S_DDI, float)) ;
+EXPORT void f4_V_DSF_DDF(double p0, struct S_DDF p1, float p2,  void (*cb)(double, struct S_DDF, float)) ;
+EXPORT void f4_V_DSF_DDD(double p0, struct S_DDD p1, float p2,  void (*cb)(double, struct S_DDD, float)) ;
+EXPORT void f4_V_DSF_DDP(double p0, struct S_DDP p1, float p2,  void (*cb)(double, struct S_DDP, float)) ;
+EXPORT void f4_V_DSF_DPI(double p0, struct S_DPI p1, float p2,  void (*cb)(double, struct S_DPI, float)) ;
+EXPORT void f4_V_DSF_DPF(double p0, struct S_DPF p1, float p2,  void (*cb)(double, struct S_DPF, float)) ;
+EXPORT void f4_V_DSF_DPD(double p0, struct S_DPD p1, float p2,  void (*cb)(double, struct S_DPD, float)) ;
+EXPORT void f4_V_DSF_DPP(double p0, struct S_DPP p1, float p2,  void (*cb)(double, struct S_DPP, float)) ;
+EXPORT void f4_V_DSF_PII(double p0, struct S_PII p1, float p2,  void (*cb)(double, struct S_PII, float)) ;
+EXPORT void f4_V_DSF_PIF(double p0, struct S_PIF p1, float p2,  void (*cb)(double, struct S_PIF, float)) ;
+EXPORT void f4_V_DSF_PID(double p0, struct S_PID p1, float p2,  void (*cb)(double, struct S_PID, float)) ;
+EXPORT void f4_V_DSF_PIP(double p0, struct S_PIP p1, float p2,  void (*cb)(double, struct S_PIP, float)) ;
+EXPORT void f4_V_DSF_PFI(double p0, struct S_PFI p1, float p2,  void (*cb)(double, struct S_PFI, float)) ;
+EXPORT void f4_V_DSF_PFF(double p0, struct S_PFF p1, float p2,  void (*cb)(double, struct S_PFF, float)) ;
+EXPORT void f4_V_DSF_PFD(double p0, struct S_PFD p1, float p2,  void (*cb)(double, struct S_PFD, float)) ;
+EXPORT void f4_V_DSF_PFP(double p0, struct S_PFP p1, float p2,  void (*cb)(double, struct S_PFP, float)) ;
+EXPORT void f4_V_DSF_PDI(double p0, struct S_PDI p1, float p2,  void (*cb)(double, struct S_PDI, float)) ;
+EXPORT void f4_V_DSF_PDF(double p0, struct S_PDF p1, float p2,  void (*cb)(double, struct S_PDF, float)) ;
+EXPORT void f4_V_DSF_PDD(double p0, struct S_PDD p1, float p2,  void (*cb)(double, struct S_PDD, float)) ;
+EXPORT void f4_V_DSF_PDP(double p0, struct S_PDP p1, float p2,  void (*cb)(double, struct S_PDP, float)) ;
+EXPORT void f4_V_DSF_PPI(double p0, struct S_PPI p1, float p2,  void (*cb)(double, struct S_PPI, float)) ;
+EXPORT void f4_V_DSF_PPF(double p0, struct S_PPF p1, float p2,  void (*cb)(double, struct S_PPF, float)) ;
+EXPORT void f4_V_DSF_PPD(double p0, struct S_PPD p1, float p2,  void (*cb)(double, struct S_PPD, float)) ;
+EXPORT void f4_V_DSF_PPP(double p0, struct S_PPP p1, float p2,  void (*cb)(double, struct S_PPP, float)) ;
+EXPORT void f4_V_DSD_I(double p0, struct S_I p1, double p2,  void (*cb)(double, struct S_I, double)) ;
+EXPORT void f4_V_DSD_F(double p0, struct S_F p1, double p2,  void (*cb)(double, struct S_F, double)) ;
+EXPORT void f4_V_DSD_D(double p0, struct S_D p1, double p2,  void (*cb)(double, struct S_D, double)) ;
+EXPORT void f4_V_DSD_P(double p0, struct S_P p1, double p2,  void (*cb)(double, struct S_P, double)) ;
+EXPORT void f4_V_DSD_II(double p0, struct S_II p1, double p2,  void (*cb)(double, struct S_II, double)) ;
+EXPORT void f4_V_DSD_IF(double p0, struct S_IF p1, double p2,  void (*cb)(double, struct S_IF, double)) ;
+EXPORT void f4_V_DSD_ID(double p0, struct S_ID p1, double p2,  void (*cb)(double, struct S_ID, double)) ;
+EXPORT void f4_V_DSD_IP(double p0, struct S_IP p1, double p2,  void (*cb)(double, struct S_IP, double)) ;
+EXPORT void f4_V_DSD_FI(double p0, struct S_FI p1, double p2,  void (*cb)(double, struct S_FI, double)) ;
+EXPORT void f4_V_DSD_FF(double p0, struct S_FF p1, double p2,  void (*cb)(double, struct S_FF, double)) ;
+EXPORT void f4_V_DSD_FD(double p0, struct S_FD p1, double p2,  void (*cb)(double, struct S_FD, double)) ;
+EXPORT void f4_V_DSD_FP(double p0, struct S_FP p1, double p2,  void (*cb)(double, struct S_FP, double)) ;
+EXPORT void f4_V_DSD_DI(double p0, struct S_DI p1, double p2,  void (*cb)(double, struct S_DI, double)) ;
+EXPORT void f4_V_DSD_DF(double p0, struct S_DF p1, double p2,  void (*cb)(double, struct S_DF, double)) ;
+EXPORT void f4_V_DSD_DD(double p0, struct S_DD p1, double p2,  void (*cb)(double, struct S_DD, double)) ;
+EXPORT void f4_V_DSD_DP(double p0, struct S_DP p1, double p2,  void (*cb)(double, struct S_DP, double)) ;
+EXPORT void f4_V_DSD_PI(double p0, struct S_PI p1, double p2,  void (*cb)(double, struct S_PI, double)) ;
+EXPORT void f4_V_DSD_PF(double p0, struct S_PF p1, double p2,  void (*cb)(double, struct S_PF, double)) ;
+EXPORT void f4_V_DSD_PD(double p0, struct S_PD p1, double p2,  void (*cb)(double, struct S_PD, double)) ;
+EXPORT void f4_V_DSD_PP(double p0, struct S_PP p1, double p2,  void (*cb)(double, struct S_PP, double)) ;
+EXPORT void f4_V_DSD_III(double p0, struct S_III p1, double p2,  void (*cb)(double, struct S_III, double)) ;
+EXPORT void f4_V_DSD_IIF(double p0, struct S_IIF p1, double p2,  void (*cb)(double, struct S_IIF, double)) ;
+EXPORT void f4_V_DSD_IID(double p0, struct S_IID p1, double p2,  void (*cb)(double, struct S_IID, double)) ;
+EXPORT void f4_V_DSD_IIP(double p0, struct S_IIP p1, double p2,  void (*cb)(double, struct S_IIP, double)) ;
+EXPORT void f4_V_DSD_IFI(double p0, struct S_IFI p1, double p2,  void (*cb)(double, struct S_IFI, double)) ;
+EXPORT void f4_V_DSD_IFF(double p0, struct S_IFF p1, double p2,  void (*cb)(double, struct S_IFF, double)) ;
+EXPORT void f4_V_DSD_IFD(double p0, struct S_IFD p1, double p2,  void (*cb)(double, struct S_IFD, double)) ;
+EXPORT void f4_V_DSD_IFP(double p0, struct S_IFP p1, double p2,  void (*cb)(double, struct S_IFP, double)) ;
+EXPORT void f4_V_DSD_IDI(double p0, struct S_IDI p1, double p2,  void (*cb)(double, struct S_IDI, double)) ;
+EXPORT void f4_V_DSD_IDF(double p0, struct S_IDF p1, double p2,  void (*cb)(double, struct S_IDF, double)) ;
+EXPORT void f4_V_DSD_IDD(double p0, struct S_IDD p1, double p2,  void (*cb)(double, struct S_IDD, double)) ;
+EXPORT void f4_V_DSD_IDP(double p0, struct S_IDP p1, double p2,  void (*cb)(double, struct S_IDP, double)) ;
+EXPORT void f4_V_DSD_IPI(double p0, struct S_IPI p1, double p2,  void (*cb)(double, struct S_IPI, double)) ;
+EXPORT void f4_V_DSD_IPF(double p0, struct S_IPF p1, double p2,  void (*cb)(double, struct S_IPF, double)) ;
+EXPORT void f4_V_DSD_IPD(double p0, struct S_IPD p1, double p2,  void (*cb)(double, struct S_IPD, double)) ;
+EXPORT void f4_V_DSD_IPP(double p0, struct S_IPP p1, double p2,  void (*cb)(double, struct S_IPP, double)) ;
+EXPORT void f4_V_DSD_FII(double p0, struct S_FII p1, double p2,  void (*cb)(double, struct S_FII, double)) ;
+EXPORT void f4_V_DSD_FIF(double p0, struct S_FIF p1, double p2,  void (*cb)(double, struct S_FIF, double)) ;
+EXPORT void f4_V_DSD_FID(double p0, struct S_FID p1, double p2,  void (*cb)(double, struct S_FID, double)) ;
+EXPORT void f4_V_DSD_FIP(double p0, struct S_FIP p1, double p2,  void (*cb)(double, struct S_FIP, double)) ;
+EXPORT void f4_V_DSD_FFI(double p0, struct S_FFI p1, double p2,  void (*cb)(double, struct S_FFI, double)) ;
+EXPORT void f4_V_DSD_FFF(double p0, struct S_FFF p1, double p2,  void (*cb)(double, struct S_FFF, double)) ;
+EXPORT void f4_V_DSD_FFD(double p0, struct S_FFD p1, double p2,  void (*cb)(double, struct S_FFD, double)) ;
+EXPORT void f4_V_DSD_FFP(double p0, struct S_FFP p1, double p2,  void (*cb)(double, struct S_FFP, double)) ;
+EXPORT void f4_V_DSD_FDI(double p0, struct S_FDI p1, double p2,  void (*cb)(double, struct S_FDI, double)) ;
+EXPORT void f4_V_DSD_FDF(double p0, struct S_FDF p1, double p2,  void (*cb)(double, struct S_FDF, double)) ;
+EXPORT void f4_V_DSD_FDD(double p0, struct S_FDD p1, double p2,  void (*cb)(double, struct S_FDD, double)) ;
+EXPORT void f4_V_DSD_FDP(double p0, struct S_FDP p1, double p2,  void (*cb)(double, struct S_FDP, double)) ;
+EXPORT void f4_V_DSD_FPI(double p0, struct S_FPI p1, double p2,  void (*cb)(double, struct S_FPI, double)) ;
+EXPORT void f4_V_DSD_FPF(double p0, struct S_FPF p1, double p2,  void (*cb)(double, struct S_FPF, double)) ;
+EXPORT void f4_V_DSD_FPD(double p0, struct S_FPD p1, double p2,  void (*cb)(double, struct S_FPD, double)) ;
+EXPORT void f4_V_DSD_FPP(double p0, struct S_FPP p1, double p2,  void (*cb)(double, struct S_FPP, double)) ;
+EXPORT void f4_V_DSD_DII(double p0, struct S_DII p1, double p2,  void (*cb)(double, struct S_DII, double)) ;
+EXPORT void f4_V_DSD_DIF(double p0, struct S_DIF p1, double p2,  void (*cb)(double, struct S_DIF, double)) ;
+EXPORT void f4_V_DSD_DID(double p0, struct S_DID p1, double p2,  void (*cb)(double, struct S_DID, double)) ;
+EXPORT void f4_V_DSD_DIP(double p0, struct S_DIP p1, double p2,  void (*cb)(double, struct S_DIP, double)) ;
+EXPORT void f4_V_DSD_DFI(double p0, struct S_DFI p1, double p2,  void (*cb)(double, struct S_DFI, double)) ;
+EXPORT void f4_V_DSD_DFF(double p0, struct S_DFF p1, double p2,  void (*cb)(double, struct S_DFF, double)) ;
+EXPORT void f4_V_DSD_DFD(double p0, struct S_DFD p1, double p2,  void (*cb)(double, struct S_DFD, double)) ;
+EXPORT void f4_V_DSD_DFP(double p0, struct S_DFP p1, double p2,  void (*cb)(double, struct S_DFP, double)) ;
+EXPORT void f4_V_DSD_DDI(double p0, struct S_DDI p1, double p2,  void (*cb)(double, struct S_DDI, double)) ;
+EXPORT void f4_V_DSD_DDF(double p0, struct S_DDF p1, double p2,  void (*cb)(double, struct S_DDF, double)) ;
+EXPORT void f4_V_DSD_DDD(double p0, struct S_DDD p1, double p2,  void (*cb)(double, struct S_DDD, double)) ;
+EXPORT void f4_V_DSD_DDP(double p0, struct S_DDP p1, double p2,  void (*cb)(double, struct S_DDP, double)) ;
+EXPORT void f4_V_DSD_DPI(double p0, struct S_DPI p1, double p2,  void (*cb)(double, struct S_DPI, double)) ;
+EXPORT void f4_V_DSD_DPF(double p0, struct S_DPF p1, double p2,  void (*cb)(double, struct S_DPF, double)) ;
+EXPORT void f4_V_DSD_DPD(double p0, struct S_DPD p1, double p2,  void (*cb)(double, struct S_DPD, double)) ;
+EXPORT void f4_V_DSD_DPP(double p0, struct S_DPP p1, double p2,  void (*cb)(double, struct S_DPP, double)) ;
+EXPORT void f4_V_DSD_PII(double p0, struct S_PII p1, double p2,  void (*cb)(double, struct S_PII, double)) ;
+EXPORT void f4_V_DSD_PIF(double p0, struct S_PIF p1, double p2,  void (*cb)(double, struct S_PIF, double)) ;
+EXPORT void f4_V_DSD_PID(double p0, struct S_PID p1, double p2,  void (*cb)(double, struct S_PID, double)) ;
+EXPORT void f4_V_DSD_PIP(double p0, struct S_PIP p1, double p2,  void (*cb)(double, struct S_PIP, double)) ;
+EXPORT void f4_V_DSD_PFI(double p0, struct S_PFI p1, double p2,  void (*cb)(double, struct S_PFI, double)) ;
+EXPORT void f4_V_DSD_PFF(double p0, struct S_PFF p1, double p2,  void (*cb)(double, struct S_PFF, double)) ;
+EXPORT void f4_V_DSD_PFD(double p0, struct S_PFD p1, double p2,  void (*cb)(double, struct S_PFD, double)) ;
+EXPORT void f5_V_DSD_PFP(double p0, struct S_PFP p1, double p2,  void (*cb)(double, struct S_PFP, double)) ;
+EXPORT void f5_V_DSD_PDI(double p0, struct S_PDI p1, double p2,  void (*cb)(double, struct S_PDI, double)) ;
+EXPORT void f5_V_DSD_PDF(double p0, struct S_PDF p1, double p2,  void (*cb)(double, struct S_PDF, double)) ;
+EXPORT void f5_V_DSD_PDD(double p0, struct S_PDD p1, double p2,  void (*cb)(double, struct S_PDD, double)) ;
+EXPORT void f5_V_DSD_PDP(double p0, struct S_PDP p1, double p2,  void (*cb)(double, struct S_PDP, double)) ;
+EXPORT void f5_V_DSD_PPI(double p0, struct S_PPI p1, double p2,  void (*cb)(double, struct S_PPI, double)) ;
+EXPORT void f5_V_DSD_PPF(double p0, struct S_PPF p1, double p2,  void (*cb)(double, struct S_PPF, double)) ;
+EXPORT void f5_V_DSD_PPD(double p0, struct S_PPD p1, double p2,  void (*cb)(double, struct S_PPD, double)) ;
+EXPORT void f5_V_DSD_PPP(double p0, struct S_PPP p1, double p2,  void (*cb)(double, struct S_PPP, double)) ;
+EXPORT void f5_V_DSP_I(double p0, struct S_I p1, void* p2,  void (*cb)(double, struct S_I, void*)) ;
+EXPORT void f5_V_DSP_F(double p0, struct S_F p1, void* p2,  void (*cb)(double, struct S_F, void*)) ;
+EXPORT void f5_V_DSP_D(double p0, struct S_D p1, void* p2,  void (*cb)(double, struct S_D, void*)) ;
+EXPORT void f5_V_DSP_P(double p0, struct S_P p1, void* p2,  void (*cb)(double, struct S_P, void*)) ;
+EXPORT void f5_V_DSP_II(double p0, struct S_II p1, void* p2,  void (*cb)(double, struct S_II, void*)) ;
+EXPORT void f5_V_DSP_IF(double p0, struct S_IF p1, void* p2,  void (*cb)(double, struct S_IF, void*)) ;
+EXPORT void f5_V_DSP_ID(double p0, struct S_ID p1, void* p2,  void (*cb)(double, struct S_ID, void*)) ;
+EXPORT void f5_V_DSP_IP(double p0, struct S_IP p1, void* p2,  void (*cb)(double, struct S_IP, void*)) ;
+EXPORT void f5_V_DSP_FI(double p0, struct S_FI p1, void* p2,  void (*cb)(double, struct S_FI, void*)) ;
+EXPORT void f5_V_DSP_FF(double p0, struct S_FF p1, void* p2,  void (*cb)(double, struct S_FF, void*)) ;
+EXPORT void f5_V_DSP_FD(double p0, struct S_FD p1, void* p2,  void (*cb)(double, struct S_FD, void*)) ;
+EXPORT void f5_V_DSP_FP(double p0, struct S_FP p1, void* p2,  void (*cb)(double, struct S_FP, void*)) ;
+EXPORT void f5_V_DSP_DI(double p0, struct S_DI p1, void* p2,  void (*cb)(double, struct S_DI, void*)) ;
+EXPORT void f5_V_DSP_DF(double p0, struct S_DF p1, void* p2,  void (*cb)(double, struct S_DF, void*)) ;
+EXPORT void f5_V_DSP_DD(double p0, struct S_DD p1, void* p2,  void (*cb)(double, struct S_DD, void*)) ;
+EXPORT void f5_V_DSP_DP(double p0, struct S_DP p1, void* p2,  void (*cb)(double, struct S_DP, void*)) ;
+EXPORT void f5_V_DSP_PI(double p0, struct S_PI p1, void* p2,  void (*cb)(double, struct S_PI, void*)) ;
+EXPORT void f5_V_DSP_PF(double p0, struct S_PF p1, void* p2,  void (*cb)(double, struct S_PF, void*)) ;
+EXPORT void f5_V_DSP_PD(double p0, struct S_PD p1, void* p2,  void (*cb)(double, struct S_PD, void*)) ;
+EXPORT void f5_V_DSP_PP(double p0, struct S_PP p1, void* p2,  void (*cb)(double, struct S_PP, void*)) ;
+EXPORT void f5_V_DSP_III(double p0, struct S_III p1, void* p2,  void (*cb)(double, struct S_III, void*)) ;
+EXPORT void f5_V_DSP_IIF(double p0, struct S_IIF p1, void* p2,  void (*cb)(double, struct S_IIF, void*)) ;
+EXPORT void f5_V_DSP_IID(double p0, struct S_IID p1, void* p2,  void (*cb)(double, struct S_IID, void*)) ;
+EXPORT void f5_V_DSP_IIP(double p0, struct S_IIP p1, void* p2,  void (*cb)(double, struct S_IIP, void*)) ;
+EXPORT void f5_V_DSP_IFI(double p0, struct S_IFI p1, void* p2,  void (*cb)(double, struct S_IFI, void*)) ;
+EXPORT void f5_V_DSP_IFF(double p0, struct S_IFF p1, void* p2,  void (*cb)(double, struct S_IFF, void*)) ;
+EXPORT void f5_V_DSP_IFD(double p0, struct S_IFD p1, void* p2,  void (*cb)(double, struct S_IFD, void*)) ;
+EXPORT void f5_V_DSP_IFP(double p0, struct S_IFP p1, void* p2,  void (*cb)(double, struct S_IFP, void*)) ;
+EXPORT void f5_V_DSP_IDI(double p0, struct S_IDI p1, void* p2,  void (*cb)(double, struct S_IDI, void*)) ;
+EXPORT void f5_V_DSP_IDF(double p0, struct S_IDF p1, void* p2,  void (*cb)(double, struct S_IDF, void*)) ;
+EXPORT void f5_V_DSP_IDD(double p0, struct S_IDD p1, void* p2,  void (*cb)(double, struct S_IDD, void*)) ;
+EXPORT void f5_V_DSP_IDP(double p0, struct S_IDP p1, void* p2,  void (*cb)(double, struct S_IDP, void*)) ;
+EXPORT void f5_V_DSP_IPI(double p0, struct S_IPI p1, void* p2,  void (*cb)(double, struct S_IPI, void*)) ;
+EXPORT void f5_V_DSP_IPF(double p0, struct S_IPF p1, void* p2,  void (*cb)(double, struct S_IPF, void*)) ;
+EXPORT void f5_V_DSP_IPD(double p0, struct S_IPD p1, void* p2,  void (*cb)(double, struct S_IPD, void*)) ;
+EXPORT void f5_V_DSP_IPP(double p0, struct S_IPP p1, void* p2,  void (*cb)(double, struct S_IPP, void*)) ;
+EXPORT void f5_V_DSP_FII(double p0, struct S_FII p1, void* p2,  void (*cb)(double, struct S_FII, void*)) ;
+EXPORT void f5_V_DSP_FIF(double p0, struct S_FIF p1, void* p2,  void (*cb)(double, struct S_FIF, void*)) ;
+EXPORT void f5_V_DSP_FID(double p0, struct S_FID p1, void* p2,  void (*cb)(double, struct S_FID, void*)) ;
+EXPORT void f5_V_DSP_FIP(double p0, struct S_FIP p1, void* p2,  void (*cb)(double, struct S_FIP, void*)) ;
+EXPORT void f5_V_DSP_FFI(double p0, struct S_FFI p1, void* p2,  void (*cb)(double, struct S_FFI, void*)) ;
+EXPORT void f5_V_DSP_FFF(double p0, struct S_FFF p1, void* p2,  void (*cb)(double, struct S_FFF, void*)) ;
+EXPORT void f5_V_DSP_FFD(double p0, struct S_FFD p1, void* p2,  void (*cb)(double, struct S_FFD, void*)) ;
+EXPORT void f5_V_DSP_FFP(double p0, struct S_FFP p1, void* p2,  void (*cb)(double, struct S_FFP, void*)) ;
+EXPORT void f5_V_DSP_FDI(double p0, struct S_FDI p1, void* p2,  void (*cb)(double, struct S_FDI, void*)) ;
+EXPORT void f5_V_DSP_FDF(double p0, struct S_FDF p1, void* p2,  void (*cb)(double, struct S_FDF, void*)) ;
+EXPORT void f5_V_DSP_FDD(double p0, struct S_FDD p1, void* p2,  void (*cb)(double, struct S_FDD, void*)) ;
+EXPORT void f5_V_DSP_FDP(double p0, struct S_FDP p1, void* p2,  void (*cb)(double, struct S_FDP, void*)) ;
+EXPORT void f5_V_DSP_FPI(double p0, struct S_FPI p1, void* p2,  void (*cb)(double, struct S_FPI, void*)) ;
+EXPORT void f5_V_DSP_FPF(double p0, struct S_FPF p1, void* p2,  void (*cb)(double, struct S_FPF, void*)) ;
+EXPORT void f5_V_DSP_FPD(double p0, struct S_FPD p1, void* p2,  void (*cb)(double, struct S_FPD, void*)) ;
+EXPORT void f5_V_DSP_FPP(double p0, struct S_FPP p1, void* p2,  void (*cb)(double, struct S_FPP, void*)) ;
+EXPORT void f5_V_DSP_DII(double p0, struct S_DII p1, void* p2,  void (*cb)(double, struct S_DII, void*)) ;
+EXPORT void f5_V_DSP_DIF(double p0, struct S_DIF p1, void* p2,  void (*cb)(double, struct S_DIF, void*)) ;
+EXPORT void f5_V_DSP_DID(double p0, struct S_DID p1, void* p2,  void (*cb)(double, struct S_DID, void*)) ;
+EXPORT void f5_V_DSP_DIP(double p0, struct S_DIP p1, void* p2,  void (*cb)(double, struct S_DIP, void*)) ;
+EXPORT void f5_V_DSP_DFI(double p0, struct S_DFI p1, void* p2,  void (*cb)(double, struct S_DFI, void*)) ;
+EXPORT void f5_V_DSP_DFF(double p0, struct S_DFF p1, void* p2,  void (*cb)(double, struct S_DFF, void*)) ;
+EXPORT void f5_V_DSP_DFD(double p0, struct S_DFD p1, void* p2,  void (*cb)(double, struct S_DFD, void*)) ;
+EXPORT void f5_V_DSP_DFP(double p0, struct S_DFP p1, void* p2,  void (*cb)(double, struct S_DFP, void*)) ;
+EXPORT void f5_V_DSP_DDI(double p0, struct S_DDI p1, void* p2,  void (*cb)(double, struct S_DDI, void*)) ;
+EXPORT void f5_V_DSP_DDF(double p0, struct S_DDF p1, void* p2,  void (*cb)(double, struct S_DDF, void*)) ;
+EXPORT void f5_V_DSP_DDD(double p0, struct S_DDD p1, void* p2,  void (*cb)(double, struct S_DDD, void*)) ;
+EXPORT void f5_V_DSP_DDP(double p0, struct S_DDP p1, void* p2,  void (*cb)(double, struct S_DDP, void*)) ;
+EXPORT void f5_V_DSP_DPI(double p0, struct S_DPI p1, void* p2,  void (*cb)(double, struct S_DPI, void*)) ;
+EXPORT void f5_V_DSP_DPF(double p0, struct S_DPF p1, void* p2,  void (*cb)(double, struct S_DPF, void*)) ;
+EXPORT void f5_V_DSP_DPD(double p0, struct S_DPD p1, void* p2,  void (*cb)(double, struct S_DPD, void*)) ;
+EXPORT void f5_V_DSP_DPP(double p0, struct S_DPP p1, void* p2,  void (*cb)(double, struct S_DPP, void*)) ;
+EXPORT void f5_V_DSP_PII(double p0, struct S_PII p1, void* p2,  void (*cb)(double, struct S_PII, void*)) ;
+EXPORT void f5_V_DSP_PIF(double p0, struct S_PIF p1, void* p2,  void (*cb)(double, struct S_PIF, void*)) ;
+EXPORT void f5_V_DSP_PID(double p0, struct S_PID p1, void* p2,  void (*cb)(double, struct S_PID, void*)) ;
+EXPORT void f5_V_DSP_PIP(double p0, struct S_PIP p1, void* p2,  void (*cb)(double, struct S_PIP, void*)) ;
+EXPORT void f5_V_DSP_PFI(double p0, struct S_PFI p1, void* p2,  void (*cb)(double, struct S_PFI, void*)) ;
+EXPORT void f5_V_DSP_PFF(double p0, struct S_PFF p1, void* p2,  void (*cb)(double, struct S_PFF, void*)) ;
+EXPORT void f5_V_DSP_PFD(double p0, struct S_PFD p1, void* p2,  void (*cb)(double, struct S_PFD, void*)) ;
+EXPORT void f5_V_DSP_PFP(double p0, struct S_PFP p1, void* p2,  void (*cb)(double, struct S_PFP, void*)) ;
+EXPORT void f5_V_DSP_PDI(double p0, struct S_PDI p1, void* p2,  void (*cb)(double, struct S_PDI, void*)) ;
+EXPORT void f5_V_DSP_PDF(double p0, struct S_PDF p1, void* p2,  void (*cb)(double, struct S_PDF, void*)) ;
+EXPORT void f5_V_DSP_PDD(double p0, struct S_PDD p1, void* p2,  void (*cb)(double, struct S_PDD, void*)) ;
+EXPORT void f5_V_DSP_PDP(double p0, struct S_PDP p1, void* p2,  void (*cb)(double, struct S_PDP, void*)) ;
+EXPORT void f5_V_DSP_PPI(double p0, struct S_PPI p1, void* p2,  void (*cb)(double, struct S_PPI, void*)) ;
+EXPORT void f5_V_DSP_PPF(double p0, struct S_PPF p1, void* p2,  void (*cb)(double, struct S_PPF, void*)) ;
+EXPORT void f5_V_DSP_PPD(double p0, struct S_PPD p1, void* p2,  void (*cb)(double, struct S_PPD, void*)) ;
+EXPORT void f5_V_DSP_PPP(double p0, struct S_PPP p1, void* p2,  void (*cb)(double, struct S_PPP, void*)) ;
+EXPORT void f5_V_DSS_I(double p0, struct S_I p1, struct S_I p2,  void (*cb)(double, struct S_I, struct S_I)) ;
+EXPORT void f5_V_DSS_F(double p0, struct S_F p1, struct S_F p2,  void (*cb)(double, struct S_F, struct S_F)) ;
+EXPORT void f5_V_DSS_D(double p0, struct S_D p1, struct S_D p2,  void (*cb)(double, struct S_D, struct S_D)) ;
+EXPORT void f5_V_DSS_P(double p0, struct S_P p1, struct S_P p2,  void (*cb)(double, struct S_P, struct S_P)) ;
+EXPORT void f5_V_DSS_II(double p0, struct S_II p1, struct S_II p2,  void (*cb)(double, struct S_II, struct S_II)) ;
+EXPORT void f5_V_DSS_IF(double p0, struct S_IF p1, struct S_IF p2,  void (*cb)(double, struct S_IF, struct S_IF)) ;
+EXPORT void f5_V_DSS_ID(double p0, struct S_ID p1, struct S_ID p2,  void (*cb)(double, struct S_ID, struct S_ID)) ;
+EXPORT void f5_V_DSS_IP(double p0, struct S_IP p1, struct S_IP p2,  void (*cb)(double, struct S_IP, struct S_IP)) ;
+EXPORT void f5_V_DSS_FI(double p0, struct S_FI p1, struct S_FI p2,  void (*cb)(double, struct S_FI, struct S_FI)) ;
+EXPORT void f5_V_DSS_FF(double p0, struct S_FF p1, struct S_FF p2,  void (*cb)(double, struct S_FF, struct S_FF)) ;
+EXPORT void f5_V_DSS_FD(double p0, struct S_FD p1, struct S_FD p2,  void (*cb)(double, struct S_FD, struct S_FD)) ;
+EXPORT void f5_V_DSS_FP(double p0, struct S_FP p1, struct S_FP p2,  void (*cb)(double, struct S_FP, struct S_FP)) ;
+EXPORT void f5_V_DSS_DI(double p0, struct S_DI p1, struct S_DI p2,  void (*cb)(double, struct S_DI, struct S_DI)) ;
+EXPORT void f5_V_DSS_DF(double p0, struct S_DF p1, struct S_DF p2,  void (*cb)(double, struct S_DF, struct S_DF)) ;
+EXPORT void f5_V_DSS_DD(double p0, struct S_DD p1, struct S_DD p2,  void (*cb)(double, struct S_DD, struct S_DD)) ;
+EXPORT void f5_V_DSS_DP(double p0, struct S_DP p1, struct S_DP p2,  void (*cb)(double, struct S_DP, struct S_DP)) ;
+EXPORT void f5_V_DSS_PI(double p0, struct S_PI p1, struct S_PI p2,  void (*cb)(double, struct S_PI, struct S_PI)) ;
+EXPORT void f5_V_DSS_PF(double p0, struct S_PF p1, struct S_PF p2,  void (*cb)(double, struct S_PF, struct S_PF)) ;
+EXPORT void f5_V_DSS_PD(double p0, struct S_PD p1, struct S_PD p2,  void (*cb)(double, struct S_PD, struct S_PD)) ;
+EXPORT void f5_V_DSS_PP(double p0, struct S_PP p1, struct S_PP p2,  void (*cb)(double, struct S_PP, struct S_PP)) ;
+EXPORT void f5_V_DSS_III(double p0, struct S_III p1, struct S_III p2,  void (*cb)(double, struct S_III, struct S_III)) ;
+EXPORT void f5_V_DSS_IIF(double p0, struct S_IIF p1, struct S_IIF p2,  void (*cb)(double, struct S_IIF, struct S_IIF)) ;
+EXPORT void f5_V_DSS_IID(double p0, struct S_IID p1, struct S_IID p2,  void (*cb)(double, struct S_IID, struct S_IID)) ;
+EXPORT void f5_V_DSS_IIP(double p0, struct S_IIP p1, struct S_IIP p2,  void (*cb)(double, struct S_IIP, struct S_IIP)) ;
+EXPORT void f5_V_DSS_IFI(double p0, struct S_IFI p1, struct S_IFI p2,  void (*cb)(double, struct S_IFI, struct S_IFI)) ;
+EXPORT void f5_V_DSS_IFF(double p0, struct S_IFF p1, struct S_IFF p2,  void (*cb)(double, struct S_IFF, struct S_IFF)) ;
+EXPORT void f5_V_DSS_IFD(double p0, struct S_IFD p1, struct S_IFD p2,  void (*cb)(double, struct S_IFD, struct S_IFD)) ;
+EXPORT void f5_V_DSS_IFP(double p0, struct S_IFP p1, struct S_IFP p2,  void (*cb)(double, struct S_IFP, struct S_IFP)) ;
+EXPORT void f5_V_DSS_IDI(double p0, struct S_IDI p1, struct S_IDI p2,  void (*cb)(double, struct S_IDI, struct S_IDI)) ;
+EXPORT void f5_V_DSS_IDF(double p0, struct S_IDF p1, struct S_IDF p2,  void (*cb)(double, struct S_IDF, struct S_IDF)) ;
+EXPORT void f5_V_DSS_IDD(double p0, struct S_IDD p1, struct S_IDD p2,  void (*cb)(double, struct S_IDD, struct S_IDD)) ;
+EXPORT void f5_V_DSS_IDP(double p0, struct S_IDP p1, struct S_IDP p2,  void (*cb)(double, struct S_IDP, struct S_IDP)) ;
+EXPORT void f5_V_DSS_IPI(double p0, struct S_IPI p1, struct S_IPI p2,  void (*cb)(double, struct S_IPI, struct S_IPI)) ;
+EXPORT void f5_V_DSS_IPF(double p0, struct S_IPF p1, struct S_IPF p2,  void (*cb)(double, struct S_IPF, struct S_IPF)) ;
+EXPORT void f5_V_DSS_IPD(double p0, struct S_IPD p1, struct S_IPD p2,  void (*cb)(double, struct S_IPD, struct S_IPD)) ;
+EXPORT void f5_V_DSS_IPP(double p0, struct S_IPP p1, struct S_IPP p2,  void (*cb)(double, struct S_IPP, struct S_IPP)) ;
+EXPORT void f5_V_DSS_FII(double p0, struct S_FII p1, struct S_FII p2,  void (*cb)(double, struct S_FII, struct S_FII)) ;
+EXPORT void f5_V_DSS_FIF(double p0, struct S_FIF p1, struct S_FIF p2,  void (*cb)(double, struct S_FIF, struct S_FIF)) ;
+EXPORT void f5_V_DSS_FID(double p0, struct S_FID p1, struct S_FID p2,  void (*cb)(double, struct S_FID, struct S_FID)) ;
+EXPORT void f5_V_DSS_FIP(double p0, struct S_FIP p1, struct S_FIP p2,  void (*cb)(double, struct S_FIP, struct S_FIP)) ;
+EXPORT void f5_V_DSS_FFI(double p0, struct S_FFI p1, struct S_FFI p2,  void (*cb)(double, struct S_FFI, struct S_FFI)) ;
+EXPORT void f5_V_DSS_FFF(double p0, struct S_FFF p1, struct S_FFF p2,  void (*cb)(double, struct S_FFF, struct S_FFF)) ;
+EXPORT void f5_V_DSS_FFD(double p0, struct S_FFD p1, struct S_FFD p2,  void (*cb)(double, struct S_FFD, struct S_FFD)) ;
+EXPORT void f5_V_DSS_FFP(double p0, struct S_FFP p1, struct S_FFP p2,  void (*cb)(double, struct S_FFP, struct S_FFP)) ;
+EXPORT void f5_V_DSS_FDI(double p0, struct S_FDI p1, struct S_FDI p2,  void (*cb)(double, struct S_FDI, struct S_FDI)) ;
+EXPORT void f5_V_DSS_FDF(double p0, struct S_FDF p1, struct S_FDF p2,  void (*cb)(double, struct S_FDF, struct S_FDF)) ;
+EXPORT void f5_V_DSS_FDD(double p0, struct S_FDD p1, struct S_FDD p2,  void (*cb)(double, struct S_FDD, struct S_FDD)) ;
+EXPORT void f5_V_DSS_FDP(double p0, struct S_FDP p1, struct S_FDP p2,  void (*cb)(double, struct S_FDP, struct S_FDP)) ;
+EXPORT void f5_V_DSS_FPI(double p0, struct S_FPI p1, struct S_FPI p2,  void (*cb)(double, struct S_FPI, struct S_FPI)) ;
+EXPORT void f5_V_DSS_FPF(double p0, struct S_FPF p1, struct S_FPF p2,  void (*cb)(double, struct S_FPF, struct S_FPF)) ;
+EXPORT void f5_V_DSS_FPD(double p0, struct S_FPD p1, struct S_FPD p2,  void (*cb)(double, struct S_FPD, struct S_FPD)) ;
+EXPORT void f5_V_DSS_FPP(double p0, struct S_FPP p1, struct S_FPP p2,  void (*cb)(double, struct S_FPP, struct S_FPP)) ;
+EXPORT void f5_V_DSS_DII(double p0, struct S_DII p1, struct S_DII p2,  void (*cb)(double, struct S_DII, struct S_DII)) ;
+EXPORT void f5_V_DSS_DIF(double p0, struct S_DIF p1, struct S_DIF p2,  void (*cb)(double, struct S_DIF, struct S_DIF)) ;
+EXPORT void f5_V_DSS_DID(double p0, struct S_DID p1, struct S_DID p2,  void (*cb)(double, struct S_DID, struct S_DID)) ;
+EXPORT void f5_V_DSS_DIP(double p0, struct S_DIP p1, struct S_DIP p2,  void (*cb)(double, struct S_DIP, struct S_DIP)) ;
+EXPORT void f5_V_DSS_DFI(double p0, struct S_DFI p1, struct S_DFI p2,  void (*cb)(double, struct S_DFI, struct S_DFI)) ;
+EXPORT void f5_V_DSS_DFF(double p0, struct S_DFF p1, struct S_DFF p2,  void (*cb)(double, struct S_DFF, struct S_DFF)) ;
+EXPORT void f5_V_DSS_DFD(double p0, struct S_DFD p1, struct S_DFD p2,  void (*cb)(double, struct S_DFD, struct S_DFD)) ;
+EXPORT void f5_V_DSS_DFP(double p0, struct S_DFP p1, struct S_DFP p2,  void (*cb)(double, struct S_DFP, struct S_DFP)) ;
+EXPORT void f5_V_DSS_DDI(double p0, struct S_DDI p1, struct S_DDI p2,  void (*cb)(double, struct S_DDI, struct S_DDI)) ;
+EXPORT void f5_V_DSS_DDF(double p0, struct S_DDF p1, struct S_DDF p2,  void (*cb)(double, struct S_DDF, struct S_DDF)) ;
+EXPORT void f5_V_DSS_DDD(double p0, struct S_DDD p1, struct S_DDD p2,  void (*cb)(double, struct S_DDD, struct S_DDD)) ;
+EXPORT void f5_V_DSS_DDP(double p0, struct S_DDP p1, struct S_DDP p2,  void (*cb)(double, struct S_DDP, struct S_DDP)) ;
+EXPORT void f5_V_DSS_DPI(double p0, struct S_DPI p1, struct S_DPI p2,  void (*cb)(double, struct S_DPI, struct S_DPI)) ;
+EXPORT void f5_V_DSS_DPF(double p0, struct S_DPF p1, struct S_DPF p2,  void (*cb)(double, struct S_DPF, struct S_DPF)) ;
+EXPORT void f5_V_DSS_DPD(double p0, struct S_DPD p1, struct S_DPD p2,  void (*cb)(double, struct S_DPD, struct S_DPD)) ;
+EXPORT void f5_V_DSS_DPP(double p0, struct S_DPP p1, struct S_DPP p2,  void (*cb)(double, struct S_DPP, struct S_DPP)) ;
+EXPORT void f5_V_DSS_PII(double p0, struct S_PII p1, struct S_PII p2,  void (*cb)(double, struct S_PII, struct S_PII)) ;
+EXPORT void f5_V_DSS_PIF(double p0, struct S_PIF p1, struct S_PIF p2,  void (*cb)(double, struct S_PIF, struct S_PIF)) ;
+EXPORT void f5_V_DSS_PID(double p0, struct S_PID p1, struct S_PID p2,  void (*cb)(double, struct S_PID, struct S_PID)) ;
+EXPORT void f5_V_DSS_PIP(double p0, struct S_PIP p1, struct S_PIP p2,  void (*cb)(double, struct S_PIP, struct S_PIP)) ;
+EXPORT void f5_V_DSS_PFI(double p0, struct S_PFI p1, struct S_PFI p2,  void (*cb)(double, struct S_PFI, struct S_PFI)) ;
+EXPORT void f5_V_DSS_PFF(double p0, struct S_PFF p1, struct S_PFF p2,  void (*cb)(double, struct S_PFF, struct S_PFF)) ;
+EXPORT void f5_V_DSS_PFD(double p0, struct S_PFD p1, struct S_PFD p2,  void (*cb)(double, struct S_PFD, struct S_PFD)) ;
+EXPORT void f5_V_DSS_PFP(double p0, struct S_PFP p1, struct S_PFP p2,  void (*cb)(double, struct S_PFP, struct S_PFP)) ;
+EXPORT void f5_V_DSS_PDI(double p0, struct S_PDI p1, struct S_PDI p2,  void (*cb)(double, struct S_PDI, struct S_PDI)) ;
+EXPORT void f5_V_DSS_PDF(double p0, struct S_PDF p1, struct S_PDF p2,  void (*cb)(double, struct S_PDF, struct S_PDF)) ;
+EXPORT void f5_V_DSS_PDD(double p0, struct S_PDD p1, struct S_PDD p2,  void (*cb)(double, struct S_PDD, struct S_PDD)) ;
+EXPORT void f5_V_DSS_PDP(double p0, struct S_PDP p1, struct S_PDP p2,  void (*cb)(double, struct S_PDP, struct S_PDP)) ;
+EXPORT void f5_V_DSS_PPI(double p0, struct S_PPI p1, struct S_PPI p2,  void (*cb)(double, struct S_PPI, struct S_PPI)) ;
+EXPORT void f5_V_DSS_PPF(double p0, struct S_PPF p1, struct S_PPF p2,  void (*cb)(double, struct S_PPF, struct S_PPF)) ;
+EXPORT void f5_V_DSS_PPD(double p0, struct S_PPD p1, struct S_PPD p2,  void (*cb)(double, struct S_PPD, struct S_PPD)) ;
+EXPORT void f5_V_DSS_PPP(double p0, struct S_PPP p1, struct S_PPP p2,  void (*cb)(double, struct S_PPP, struct S_PPP)) ;
+EXPORT void f5_V_PII_(void* p0, int p1, int p2,  void (*cb)(void*, int, int)) ;
+EXPORT void f5_V_PIF_(void* p0, int p1, float p2,  void (*cb)(void*, int, float)) ;
+EXPORT void f5_V_PID_(void* p0, int p1, double p2,  void (*cb)(void*, int, double)) ;
+EXPORT void f5_V_PIP_(void* p0, int p1, void* p2,  void (*cb)(void*, int, void*)) ;
+EXPORT void f5_V_PIS_I(void* p0, int p1, struct S_I p2,  void (*cb)(void*, int, struct S_I)) ;
+EXPORT void f5_V_PIS_F(void* p0, int p1, struct S_F p2,  void (*cb)(void*, int, struct S_F)) ;
+EXPORT void f5_V_PIS_D(void* p0, int p1, struct S_D p2,  void (*cb)(void*, int, struct S_D)) ;
+EXPORT void f5_V_PIS_P(void* p0, int p1, struct S_P p2,  void (*cb)(void*, int, struct S_P)) ;
+EXPORT void f5_V_PIS_II(void* p0, int p1, struct S_II p2,  void (*cb)(void*, int, struct S_II)) ;
+EXPORT void f5_V_PIS_IF(void* p0, int p1, struct S_IF p2,  void (*cb)(void*, int, struct S_IF)) ;
+EXPORT void f5_V_PIS_ID(void* p0, int p1, struct S_ID p2,  void (*cb)(void*, int, struct S_ID)) ;
+EXPORT void f5_V_PIS_IP(void* p0, int p1, struct S_IP p2,  void (*cb)(void*, int, struct S_IP)) ;
+EXPORT void f5_V_PIS_FI(void* p0, int p1, struct S_FI p2,  void (*cb)(void*, int, struct S_FI)) ;
+EXPORT void f5_V_PIS_FF(void* p0, int p1, struct S_FF p2,  void (*cb)(void*, int, struct S_FF)) ;
+EXPORT void f5_V_PIS_FD(void* p0, int p1, struct S_FD p2,  void (*cb)(void*, int, struct S_FD)) ;
+EXPORT void f5_V_PIS_FP(void* p0, int p1, struct S_FP p2,  void (*cb)(void*, int, struct S_FP)) ;
+EXPORT void f5_V_PIS_DI(void* p0, int p1, struct S_DI p2,  void (*cb)(void*, int, struct S_DI)) ;
+EXPORT void f5_V_PIS_DF(void* p0, int p1, struct S_DF p2,  void (*cb)(void*, int, struct S_DF)) ;
+EXPORT void f5_V_PIS_DD(void* p0, int p1, struct S_DD p2,  void (*cb)(void*, int, struct S_DD)) ;
+EXPORT void f5_V_PIS_DP(void* p0, int p1, struct S_DP p2,  void (*cb)(void*, int, struct S_DP)) ;
+EXPORT void f5_V_PIS_PI(void* p0, int p1, struct S_PI p2,  void (*cb)(void*, int, struct S_PI)) ;
+EXPORT void f5_V_PIS_PF(void* p0, int p1, struct S_PF p2,  void (*cb)(void*, int, struct S_PF)) ;
+EXPORT void f5_V_PIS_PD(void* p0, int p1, struct S_PD p2,  void (*cb)(void*, int, struct S_PD)) ;
+EXPORT void f5_V_PIS_PP(void* p0, int p1, struct S_PP p2,  void (*cb)(void*, int, struct S_PP)) ;
+EXPORT void f5_V_PIS_III(void* p0, int p1, struct S_III p2,  void (*cb)(void*, int, struct S_III)) ;
+EXPORT void f5_V_PIS_IIF(void* p0, int p1, struct S_IIF p2,  void (*cb)(void*, int, struct S_IIF)) ;
+EXPORT void f5_V_PIS_IID(void* p0, int p1, struct S_IID p2,  void (*cb)(void*, int, struct S_IID)) ;
+EXPORT void f5_V_PIS_IIP(void* p0, int p1, struct S_IIP p2,  void (*cb)(void*, int, struct S_IIP)) ;
+EXPORT void f5_V_PIS_IFI(void* p0, int p1, struct S_IFI p2,  void (*cb)(void*, int, struct S_IFI)) ;
+EXPORT void f5_V_PIS_IFF(void* p0, int p1, struct S_IFF p2,  void (*cb)(void*, int, struct S_IFF)) ;
+EXPORT void f5_V_PIS_IFD(void* p0, int p1, struct S_IFD p2,  void (*cb)(void*, int, struct S_IFD)) ;
+EXPORT void f5_V_PIS_IFP(void* p0, int p1, struct S_IFP p2,  void (*cb)(void*, int, struct S_IFP)) ;
+EXPORT void f5_V_PIS_IDI(void* p0, int p1, struct S_IDI p2,  void (*cb)(void*, int, struct S_IDI)) ;
+EXPORT void f5_V_PIS_IDF(void* p0, int p1, struct S_IDF p2,  void (*cb)(void*, int, struct S_IDF)) ;
+EXPORT void f5_V_PIS_IDD(void* p0, int p1, struct S_IDD p2,  void (*cb)(void*, int, struct S_IDD)) ;
+EXPORT void f5_V_PIS_IDP(void* p0, int p1, struct S_IDP p2,  void (*cb)(void*, int, struct S_IDP)) ;
+EXPORT void f5_V_PIS_IPI(void* p0, int p1, struct S_IPI p2,  void (*cb)(void*, int, struct S_IPI)) ;
+EXPORT void f5_V_PIS_IPF(void* p0, int p1, struct S_IPF p2,  void (*cb)(void*, int, struct S_IPF)) ;
+EXPORT void f5_V_PIS_IPD(void* p0, int p1, struct S_IPD p2,  void (*cb)(void*, int, struct S_IPD)) ;
+EXPORT void f5_V_PIS_IPP(void* p0, int p1, struct S_IPP p2,  void (*cb)(void*, int, struct S_IPP)) ;
+EXPORT void f5_V_PIS_FII(void* p0, int p1, struct S_FII p2,  void (*cb)(void*, int, struct S_FII)) ;
+EXPORT void f5_V_PIS_FIF(void* p0, int p1, struct S_FIF p2,  void (*cb)(void*, int, struct S_FIF)) ;
+EXPORT void f5_V_PIS_FID(void* p0, int p1, struct S_FID p2,  void (*cb)(void*, int, struct S_FID)) ;
+EXPORT void f5_V_PIS_FIP(void* p0, int p1, struct S_FIP p2,  void (*cb)(void*, int, struct S_FIP)) ;
+EXPORT void f5_V_PIS_FFI(void* p0, int p1, struct S_FFI p2,  void (*cb)(void*, int, struct S_FFI)) ;
+EXPORT void f5_V_PIS_FFF(void* p0, int p1, struct S_FFF p2,  void (*cb)(void*, int, struct S_FFF)) ;
+EXPORT void f5_V_PIS_FFD(void* p0, int p1, struct S_FFD p2,  void (*cb)(void*, int, struct S_FFD)) ;
+EXPORT void f5_V_PIS_FFP(void* p0, int p1, struct S_FFP p2,  void (*cb)(void*, int, struct S_FFP)) ;
+EXPORT void f5_V_PIS_FDI(void* p0, int p1, struct S_FDI p2,  void (*cb)(void*, int, struct S_FDI)) ;
+EXPORT void f5_V_PIS_FDF(void* p0, int p1, struct S_FDF p2,  void (*cb)(void*, int, struct S_FDF)) ;
+EXPORT void f5_V_PIS_FDD(void* p0, int p1, struct S_FDD p2,  void (*cb)(void*, int, struct S_FDD)) ;
+EXPORT void f5_V_PIS_FDP(void* p0, int p1, struct S_FDP p2,  void (*cb)(void*, int, struct S_FDP)) ;
+EXPORT void f5_V_PIS_FPI(void* p0, int p1, struct S_FPI p2,  void (*cb)(void*, int, struct S_FPI)) ;
+EXPORT void f5_V_PIS_FPF(void* p0, int p1, struct S_FPF p2,  void (*cb)(void*, int, struct S_FPF)) ;
+EXPORT void f5_V_PIS_FPD(void* p0, int p1, struct S_FPD p2,  void (*cb)(void*, int, struct S_FPD)) ;
+EXPORT void f5_V_PIS_FPP(void* p0, int p1, struct S_FPP p2,  void (*cb)(void*, int, struct S_FPP)) ;
+EXPORT void f5_V_PIS_DII(void* p0, int p1, struct S_DII p2,  void (*cb)(void*, int, struct S_DII)) ;
+EXPORT void f5_V_PIS_DIF(void* p0, int p1, struct S_DIF p2,  void (*cb)(void*, int, struct S_DIF)) ;
+EXPORT void f5_V_PIS_DID(void* p0, int p1, struct S_DID p2,  void (*cb)(void*, int, struct S_DID)) ;
+EXPORT void f5_V_PIS_DIP(void* p0, int p1, struct S_DIP p2,  void (*cb)(void*, int, struct S_DIP)) ;
+EXPORT void f5_V_PIS_DFI(void* p0, int p1, struct S_DFI p2,  void (*cb)(void*, int, struct S_DFI)) ;
+EXPORT void f5_V_PIS_DFF(void* p0, int p1, struct S_DFF p2,  void (*cb)(void*, int, struct S_DFF)) ;
+EXPORT void f5_V_PIS_DFD(void* p0, int p1, struct S_DFD p2,  void (*cb)(void*, int, struct S_DFD)) ;
+EXPORT void f5_V_PIS_DFP(void* p0, int p1, struct S_DFP p2,  void (*cb)(void*, int, struct S_DFP)) ;
+EXPORT void f5_V_PIS_DDI(void* p0, int p1, struct S_DDI p2,  void (*cb)(void*, int, struct S_DDI)) ;
+EXPORT void f5_V_PIS_DDF(void* p0, int p1, struct S_DDF p2,  void (*cb)(void*, int, struct S_DDF)) ;
+EXPORT void f5_V_PIS_DDD(void* p0, int p1, struct S_DDD p2,  void (*cb)(void*, int, struct S_DDD)) ;
+EXPORT void f5_V_PIS_DDP(void* p0, int p1, struct S_DDP p2,  void (*cb)(void*, int, struct S_DDP)) ;
+EXPORT void f5_V_PIS_DPI(void* p0, int p1, struct S_DPI p2,  void (*cb)(void*, int, struct S_DPI)) ;
+EXPORT void f5_V_PIS_DPF(void* p0, int p1, struct S_DPF p2,  void (*cb)(void*, int, struct S_DPF)) ;
+EXPORT void f5_V_PIS_DPD(void* p0, int p1, struct S_DPD p2,  void (*cb)(void*, int, struct S_DPD)) ;
+EXPORT void f5_V_PIS_DPP(void* p0, int p1, struct S_DPP p2,  void (*cb)(void*, int, struct S_DPP)) ;
+EXPORT void f5_V_PIS_PII(void* p0, int p1, struct S_PII p2,  void (*cb)(void*, int, struct S_PII)) ;
+EXPORT void f5_V_PIS_PIF(void* p0, int p1, struct S_PIF p2,  void (*cb)(void*, int, struct S_PIF)) ;
+EXPORT void f5_V_PIS_PID(void* p0, int p1, struct S_PID p2,  void (*cb)(void*, int, struct S_PID)) ;
+EXPORT void f5_V_PIS_PIP(void* p0, int p1, struct S_PIP p2,  void (*cb)(void*, int, struct S_PIP)) ;
+EXPORT void f5_V_PIS_PFI(void* p0, int p1, struct S_PFI p2,  void (*cb)(void*, int, struct S_PFI)) ;
+EXPORT void f5_V_PIS_PFF(void* p0, int p1, struct S_PFF p2,  void (*cb)(void*, int, struct S_PFF)) ;
+EXPORT void f5_V_PIS_PFD(void* p0, int p1, struct S_PFD p2,  void (*cb)(void*, int, struct S_PFD)) ;
+EXPORT void f5_V_PIS_PFP(void* p0, int p1, struct S_PFP p2,  void (*cb)(void*, int, struct S_PFP)) ;
+EXPORT void f5_V_PIS_PDI(void* p0, int p1, struct S_PDI p2,  void (*cb)(void*, int, struct S_PDI)) ;
+EXPORT void f5_V_PIS_PDF(void* p0, int p1, struct S_PDF p2,  void (*cb)(void*, int, struct S_PDF)) ;
+EXPORT void f5_V_PIS_PDD(void* p0, int p1, struct S_PDD p2,  void (*cb)(void*, int, struct S_PDD)) ;
+EXPORT void f5_V_PIS_PDP(void* p0, int p1, struct S_PDP p2,  void (*cb)(void*, int, struct S_PDP)) ;
+EXPORT void f5_V_PIS_PPI(void* p0, int p1, struct S_PPI p2,  void (*cb)(void*, int, struct S_PPI)) ;
+EXPORT void f5_V_PIS_PPF(void* p0, int p1, struct S_PPF p2,  void (*cb)(void*, int, struct S_PPF)) ;
+EXPORT void f5_V_PIS_PPD(void* p0, int p1, struct S_PPD p2,  void (*cb)(void*, int, struct S_PPD)) ;
+EXPORT void f5_V_PIS_PPP(void* p0, int p1, struct S_PPP p2,  void (*cb)(void*, int, struct S_PPP)) ;
+EXPORT void f5_V_PFI_(void* p0, float p1, int p2,  void (*cb)(void*, float, int)) ;
+EXPORT void f5_V_PFF_(void* p0, float p1, float p2,  void (*cb)(void*, float, float)) ;
+EXPORT void f5_V_PFD_(void* p0, float p1, double p2,  void (*cb)(void*, float, double)) ;
+EXPORT void f5_V_PFP_(void* p0, float p1, void* p2,  void (*cb)(void*, float, void*)) ;
+EXPORT void f5_V_PFS_I(void* p0, float p1, struct S_I p2,  void (*cb)(void*, float, struct S_I)) ;
+EXPORT void f5_V_PFS_F(void* p0, float p1, struct S_F p2,  void (*cb)(void*, float, struct S_F)) ;
+EXPORT void f5_V_PFS_D(void* p0, float p1, struct S_D p2,  void (*cb)(void*, float, struct S_D)) ;
+EXPORT void f5_V_PFS_P(void* p0, float p1, struct S_P p2,  void (*cb)(void*, float, struct S_P)) ;
+EXPORT void f5_V_PFS_II(void* p0, float p1, struct S_II p2,  void (*cb)(void*, float, struct S_II)) ;
+EXPORT void f5_V_PFS_IF(void* p0, float p1, struct S_IF p2,  void (*cb)(void*, float, struct S_IF)) ;
+EXPORT void f5_V_PFS_ID(void* p0, float p1, struct S_ID p2,  void (*cb)(void*, float, struct S_ID)) ;
+EXPORT void f5_V_PFS_IP(void* p0, float p1, struct S_IP p2,  void (*cb)(void*, float, struct S_IP)) ;
+EXPORT void f5_V_PFS_FI(void* p0, float p1, struct S_FI p2,  void (*cb)(void*, float, struct S_FI)) ;
+EXPORT void f5_V_PFS_FF(void* p0, float p1, struct S_FF p2,  void (*cb)(void*, float, struct S_FF)) ;
+EXPORT void f5_V_PFS_FD(void* p0, float p1, struct S_FD p2,  void (*cb)(void*, float, struct S_FD)) ;
+EXPORT void f5_V_PFS_FP(void* p0, float p1, struct S_FP p2,  void (*cb)(void*, float, struct S_FP)) ;
+EXPORT void f5_V_PFS_DI(void* p0, float p1, struct S_DI p2,  void (*cb)(void*, float, struct S_DI)) ;
+EXPORT void f5_V_PFS_DF(void* p0, float p1, struct S_DF p2,  void (*cb)(void*, float, struct S_DF)) ;
+EXPORT void f5_V_PFS_DD(void* p0, float p1, struct S_DD p2,  void (*cb)(void*, float, struct S_DD)) ;
+EXPORT void f5_V_PFS_DP(void* p0, float p1, struct S_DP p2,  void (*cb)(void*, float, struct S_DP)) ;
+EXPORT void f5_V_PFS_PI(void* p0, float p1, struct S_PI p2,  void (*cb)(void*, float, struct S_PI)) ;
+EXPORT void f5_V_PFS_PF(void* p0, float p1, struct S_PF p2,  void (*cb)(void*, float, struct S_PF)) ;
+EXPORT void f5_V_PFS_PD(void* p0, float p1, struct S_PD p2,  void (*cb)(void*, float, struct S_PD)) ;
+EXPORT void f5_V_PFS_PP(void* p0, float p1, struct S_PP p2,  void (*cb)(void*, float, struct S_PP)) ;
+EXPORT void f5_V_PFS_III(void* p0, float p1, struct S_III p2,  void (*cb)(void*, float, struct S_III)) ;
+EXPORT void f5_V_PFS_IIF(void* p0, float p1, struct S_IIF p2,  void (*cb)(void*, float, struct S_IIF)) ;
+EXPORT void f5_V_PFS_IID(void* p0, float p1, struct S_IID p2,  void (*cb)(void*, float, struct S_IID)) ;
+EXPORT void f5_V_PFS_IIP(void* p0, float p1, struct S_IIP p2,  void (*cb)(void*, float, struct S_IIP)) ;
+EXPORT void f5_V_PFS_IFI(void* p0, float p1, struct S_IFI p2,  void (*cb)(void*, float, struct S_IFI)) ;
+EXPORT void f5_V_PFS_IFF(void* p0, float p1, struct S_IFF p2,  void (*cb)(void*, float, struct S_IFF)) ;
+EXPORT void f5_V_PFS_IFD(void* p0, float p1, struct S_IFD p2,  void (*cb)(void*, float, struct S_IFD)) ;
+EXPORT void f5_V_PFS_IFP(void* p0, float p1, struct S_IFP p2,  void (*cb)(void*, float, struct S_IFP)) ;
+EXPORT void f5_V_PFS_IDI(void* p0, float p1, struct S_IDI p2,  void (*cb)(void*, float, struct S_IDI)) ;
+EXPORT void f5_V_PFS_IDF(void* p0, float p1, struct S_IDF p2,  void (*cb)(void*, float, struct S_IDF)) ;
+EXPORT void f5_V_PFS_IDD(void* p0, float p1, struct S_IDD p2,  void (*cb)(void*, float, struct S_IDD)) ;
+EXPORT void f5_V_PFS_IDP(void* p0, float p1, struct S_IDP p2,  void (*cb)(void*, float, struct S_IDP)) ;
+EXPORT void f5_V_PFS_IPI(void* p0, float p1, struct S_IPI p2,  void (*cb)(void*, float, struct S_IPI)) ;
+EXPORT void f5_V_PFS_IPF(void* p0, float p1, struct S_IPF p2,  void (*cb)(void*, float, struct S_IPF)) ;
+EXPORT void f5_V_PFS_IPD(void* p0, float p1, struct S_IPD p2,  void (*cb)(void*, float, struct S_IPD)) ;
+EXPORT void f5_V_PFS_IPP(void* p0, float p1, struct S_IPP p2,  void (*cb)(void*, float, struct S_IPP)) ;
+EXPORT void f5_V_PFS_FII(void* p0, float p1, struct S_FII p2,  void (*cb)(void*, float, struct S_FII)) ;
+EXPORT void f5_V_PFS_FIF(void* p0, float p1, struct S_FIF p2,  void (*cb)(void*, float, struct S_FIF)) ;
+EXPORT void f5_V_PFS_FID(void* p0, float p1, struct S_FID p2,  void (*cb)(void*, float, struct S_FID)) ;
+EXPORT void f5_V_PFS_FIP(void* p0, float p1, struct S_FIP p2,  void (*cb)(void*, float, struct S_FIP)) ;
+EXPORT void f5_V_PFS_FFI(void* p0, float p1, struct S_FFI p2,  void (*cb)(void*, float, struct S_FFI)) ;
+EXPORT void f5_V_PFS_FFF(void* p0, float p1, struct S_FFF p2,  void (*cb)(void*, float, struct S_FFF)) ;
+EXPORT void f5_V_PFS_FFD(void* p0, float p1, struct S_FFD p2,  void (*cb)(void*, float, struct S_FFD)) ;
+EXPORT void f5_V_PFS_FFP(void* p0, float p1, struct S_FFP p2,  void (*cb)(void*, float, struct S_FFP)) ;
+EXPORT void f5_V_PFS_FDI(void* p0, float p1, struct S_FDI p2,  void (*cb)(void*, float, struct S_FDI)) ;
+EXPORT void f5_V_PFS_FDF(void* p0, float p1, struct S_FDF p2,  void (*cb)(void*, float, struct S_FDF)) ;
+EXPORT void f5_V_PFS_FDD(void* p0, float p1, struct S_FDD p2,  void (*cb)(void*, float, struct S_FDD)) ;
+EXPORT void f5_V_PFS_FDP(void* p0, float p1, struct S_FDP p2,  void (*cb)(void*, float, struct S_FDP)) ;
+EXPORT void f5_V_PFS_FPI(void* p0, float p1, struct S_FPI p2,  void (*cb)(void*, float, struct S_FPI)) ;
+EXPORT void f5_V_PFS_FPF(void* p0, float p1, struct S_FPF p2,  void (*cb)(void*, float, struct S_FPF)) ;
+EXPORT void f5_V_PFS_FPD(void* p0, float p1, struct S_FPD p2,  void (*cb)(void*, float, struct S_FPD)) ;
+EXPORT void f5_V_PFS_FPP(void* p0, float p1, struct S_FPP p2,  void (*cb)(void*, float, struct S_FPP)) ;
+EXPORT void f5_V_PFS_DII(void* p0, float p1, struct S_DII p2,  void (*cb)(void*, float, struct S_DII)) ;
+EXPORT void f5_V_PFS_DIF(void* p0, float p1, struct S_DIF p2,  void (*cb)(void*, float, struct S_DIF)) ;
+EXPORT void f5_V_PFS_DID(void* p0, float p1, struct S_DID p2,  void (*cb)(void*, float, struct S_DID)) ;
+EXPORT void f5_V_PFS_DIP(void* p0, float p1, struct S_DIP p2,  void (*cb)(void*, float, struct S_DIP)) ;
+EXPORT void f5_V_PFS_DFI(void* p0, float p1, struct S_DFI p2,  void (*cb)(void*, float, struct S_DFI)) ;
+EXPORT void f5_V_PFS_DFF(void* p0, float p1, struct S_DFF p2,  void (*cb)(void*, float, struct S_DFF)) ;
+EXPORT void f5_V_PFS_DFD(void* p0, float p1, struct S_DFD p2,  void (*cb)(void*, float, struct S_DFD)) ;
+EXPORT void f5_V_PFS_DFP(void* p0, float p1, struct S_DFP p2,  void (*cb)(void*, float, struct S_DFP)) ;
+EXPORT void f5_V_PFS_DDI(void* p0, float p1, struct S_DDI p2,  void (*cb)(void*, float, struct S_DDI)) ;
+EXPORT void f5_V_PFS_DDF(void* p0, float p1, struct S_DDF p2,  void (*cb)(void*, float, struct S_DDF)) ;
+EXPORT void f5_V_PFS_DDD(void* p0, float p1, struct S_DDD p2,  void (*cb)(void*, float, struct S_DDD)) ;
+EXPORT void f5_V_PFS_DDP(void* p0, float p1, struct S_DDP p2,  void (*cb)(void*, float, struct S_DDP)) ;
+EXPORT void f5_V_PFS_DPI(void* p0, float p1, struct S_DPI p2,  void (*cb)(void*, float, struct S_DPI)) ;
+EXPORT void f5_V_PFS_DPF(void* p0, float p1, struct S_DPF p2,  void (*cb)(void*, float, struct S_DPF)) ;
+EXPORT void f5_V_PFS_DPD(void* p0, float p1, struct S_DPD p2,  void (*cb)(void*, float, struct S_DPD)) ;
+EXPORT void f5_V_PFS_DPP(void* p0, float p1, struct S_DPP p2,  void (*cb)(void*, float, struct S_DPP)) ;
+EXPORT void f5_V_PFS_PII(void* p0, float p1, struct S_PII p2,  void (*cb)(void*, float, struct S_PII)) ;
+EXPORT void f5_V_PFS_PIF(void* p0, float p1, struct S_PIF p2,  void (*cb)(void*, float, struct S_PIF)) ;
+EXPORT void f5_V_PFS_PID(void* p0, float p1, struct S_PID p2,  void (*cb)(void*, float, struct S_PID)) ;
+EXPORT void f5_V_PFS_PIP(void* p0, float p1, struct S_PIP p2,  void (*cb)(void*, float, struct S_PIP)) ;
+EXPORT void f5_V_PFS_PFI(void* p0, float p1, struct S_PFI p2,  void (*cb)(void*, float, struct S_PFI)) ;
+EXPORT void f5_V_PFS_PFF(void* p0, float p1, struct S_PFF p2,  void (*cb)(void*, float, struct S_PFF)) ;
+EXPORT void f5_V_PFS_PFD(void* p0, float p1, struct S_PFD p2,  void (*cb)(void*, float, struct S_PFD)) ;
+EXPORT void f5_V_PFS_PFP(void* p0, float p1, struct S_PFP p2,  void (*cb)(void*, float, struct S_PFP)) ;
+EXPORT void f5_V_PFS_PDI(void* p0, float p1, struct S_PDI p2,  void (*cb)(void*, float, struct S_PDI)) ;
+EXPORT void f5_V_PFS_PDF(void* p0, float p1, struct S_PDF p2,  void (*cb)(void*, float, struct S_PDF)) ;
+EXPORT void f5_V_PFS_PDD(void* p0, float p1, struct S_PDD p2,  void (*cb)(void*, float, struct S_PDD)) ;
+EXPORT void f5_V_PFS_PDP(void* p0, float p1, struct S_PDP p2,  void (*cb)(void*, float, struct S_PDP)) ;
+EXPORT void f5_V_PFS_PPI(void* p0, float p1, struct S_PPI p2,  void (*cb)(void*, float, struct S_PPI)) ;
+EXPORT void f5_V_PFS_PPF(void* p0, float p1, struct S_PPF p2,  void (*cb)(void*, float, struct S_PPF)) ;
+EXPORT void f5_V_PFS_PPD(void* p0, float p1, struct S_PPD p2,  void (*cb)(void*, float, struct S_PPD)) ;
+EXPORT void f5_V_PFS_PPP(void* p0, float p1, struct S_PPP p2,  void (*cb)(void*, float, struct S_PPP)) ;
+EXPORT void f5_V_PDI_(void* p0, double p1, int p2,  void (*cb)(void*, double, int)) ;
+EXPORT void f5_V_PDF_(void* p0, double p1, float p2,  void (*cb)(void*, double, float)) ;
+EXPORT void f5_V_PDD_(void* p0, double p1, double p2,  void (*cb)(void*, double, double)) ;
+EXPORT void f5_V_PDP_(void* p0, double p1, void* p2,  void (*cb)(void*, double, void*)) ;
+EXPORT void f5_V_PDS_I(void* p0, double p1, struct S_I p2,  void (*cb)(void*, double, struct S_I)) ;
+EXPORT void f5_V_PDS_F(void* p0, double p1, struct S_F p2,  void (*cb)(void*, double, struct S_F)) ;
+EXPORT void f5_V_PDS_D(void* p0, double p1, struct S_D p2,  void (*cb)(void*, double, struct S_D)) ;
+EXPORT void f5_V_PDS_P(void* p0, double p1, struct S_P p2,  void (*cb)(void*, double, struct S_P)) ;
+EXPORT void f5_V_PDS_II(void* p0, double p1, struct S_II p2,  void (*cb)(void*, double, struct S_II)) ;
+EXPORT void f5_V_PDS_IF(void* p0, double p1, struct S_IF p2,  void (*cb)(void*, double, struct S_IF)) ;
+EXPORT void f5_V_PDS_ID(void* p0, double p1, struct S_ID p2,  void (*cb)(void*, double, struct S_ID)) ;
+EXPORT void f5_V_PDS_IP(void* p0, double p1, struct S_IP p2,  void (*cb)(void*, double, struct S_IP)) ;
+EXPORT void f5_V_PDS_FI(void* p0, double p1, struct S_FI p2,  void (*cb)(void*, double, struct S_FI)) ;
+EXPORT void f5_V_PDS_FF(void* p0, double p1, struct S_FF p2,  void (*cb)(void*, double, struct S_FF)) ;
+EXPORT void f5_V_PDS_FD(void* p0, double p1, struct S_FD p2,  void (*cb)(void*, double, struct S_FD)) ;
+EXPORT void f5_V_PDS_FP(void* p0, double p1, struct S_FP p2,  void (*cb)(void*, double, struct S_FP)) ;
+EXPORT void f5_V_PDS_DI(void* p0, double p1, struct S_DI p2,  void (*cb)(void*, double, struct S_DI)) ;
+EXPORT void f5_V_PDS_DF(void* p0, double p1, struct S_DF p2,  void (*cb)(void*, double, struct S_DF)) ;
+EXPORT void f5_V_PDS_DD(void* p0, double p1, struct S_DD p2,  void (*cb)(void*, double, struct S_DD)) ;
+EXPORT void f5_V_PDS_DP(void* p0, double p1, struct S_DP p2,  void (*cb)(void*, double, struct S_DP)) ;
+EXPORT void f5_V_PDS_PI(void* p0, double p1, struct S_PI p2,  void (*cb)(void*, double, struct S_PI)) ;
+EXPORT void f5_V_PDS_PF(void* p0, double p1, struct S_PF p2,  void (*cb)(void*, double, struct S_PF)) ;
+EXPORT void f5_V_PDS_PD(void* p0, double p1, struct S_PD p2,  void (*cb)(void*, double, struct S_PD)) ;
+EXPORT void f5_V_PDS_PP(void* p0, double p1, struct S_PP p2,  void (*cb)(void*, double, struct S_PP)) ;
+EXPORT void f5_V_PDS_III(void* p0, double p1, struct S_III p2,  void (*cb)(void*, double, struct S_III)) ;
+EXPORT void f5_V_PDS_IIF(void* p0, double p1, struct S_IIF p2,  void (*cb)(void*, double, struct S_IIF)) ;
+EXPORT void f5_V_PDS_IID(void* p0, double p1, struct S_IID p2,  void (*cb)(void*, double, struct S_IID)) ;
+EXPORT void f5_V_PDS_IIP(void* p0, double p1, struct S_IIP p2,  void (*cb)(void*, double, struct S_IIP)) ;
+EXPORT void f5_V_PDS_IFI(void* p0, double p1, struct S_IFI p2,  void (*cb)(void*, double, struct S_IFI)) ;
+EXPORT void f5_V_PDS_IFF(void* p0, double p1, struct S_IFF p2,  void (*cb)(void*, double, struct S_IFF)) ;
+EXPORT void f5_V_PDS_IFD(void* p0, double p1, struct S_IFD p2,  void (*cb)(void*, double, struct S_IFD)) ;
+EXPORT void f5_V_PDS_IFP(void* p0, double p1, struct S_IFP p2,  void (*cb)(void*, double, struct S_IFP)) ;
+EXPORT void f5_V_PDS_IDI(void* p0, double p1, struct S_IDI p2,  void (*cb)(void*, double, struct S_IDI)) ;
+EXPORT void f5_V_PDS_IDF(void* p0, double p1, struct S_IDF p2,  void (*cb)(void*, double, struct S_IDF)) ;
+EXPORT void f5_V_PDS_IDD(void* p0, double p1, struct S_IDD p2,  void (*cb)(void*, double, struct S_IDD)) ;
+EXPORT void f5_V_PDS_IDP(void* p0, double p1, struct S_IDP p2,  void (*cb)(void*, double, struct S_IDP)) ;
+EXPORT void f5_V_PDS_IPI(void* p0, double p1, struct S_IPI p2,  void (*cb)(void*, double, struct S_IPI)) ;
+EXPORT void f5_V_PDS_IPF(void* p0, double p1, struct S_IPF p2,  void (*cb)(void*, double, struct S_IPF)) ;
+EXPORT void f5_V_PDS_IPD(void* p0, double p1, struct S_IPD p2,  void (*cb)(void*, double, struct S_IPD)) ;
+EXPORT void f5_V_PDS_IPP(void* p0, double p1, struct S_IPP p2,  void (*cb)(void*, double, struct S_IPP)) ;
+EXPORT void f5_V_PDS_FII(void* p0, double p1, struct S_FII p2,  void (*cb)(void*, double, struct S_FII)) ;
+EXPORT void f5_V_PDS_FIF(void* p0, double p1, struct S_FIF p2,  void (*cb)(void*, double, struct S_FIF)) ;
+EXPORT void f5_V_PDS_FID(void* p0, double p1, struct S_FID p2,  void (*cb)(void*, double, struct S_FID)) ;
+EXPORT void f5_V_PDS_FIP(void* p0, double p1, struct S_FIP p2,  void (*cb)(void*, double, struct S_FIP)) ;
+EXPORT void f5_V_PDS_FFI(void* p0, double p1, struct S_FFI p2,  void (*cb)(void*, double, struct S_FFI)) ;
+EXPORT void f5_V_PDS_FFF(void* p0, double p1, struct S_FFF p2,  void (*cb)(void*, double, struct S_FFF)) ;
+EXPORT void f5_V_PDS_FFD(void* p0, double p1, struct S_FFD p2,  void (*cb)(void*, double, struct S_FFD)) ;
+EXPORT void f5_V_PDS_FFP(void* p0, double p1, struct S_FFP p2,  void (*cb)(void*, double, struct S_FFP)) ;
+EXPORT void f5_V_PDS_FDI(void* p0, double p1, struct S_FDI p2,  void (*cb)(void*, double, struct S_FDI)) ;
+EXPORT void f5_V_PDS_FDF(void* p0, double p1, struct S_FDF p2,  void (*cb)(void*, double, struct S_FDF)) ;
+EXPORT void f5_V_PDS_FDD(void* p0, double p1, struct S_FDD p2,  void (*cb)(void*, double, struct S_FDD)) ;
+EXPORT void f5_V_PDS_FDP(void* p0, double p1, struct S_FDP p2,  void (*cb)(void*, double, struct S_FDP)) ;
+EXPORT void f5_V_PDS_FPI(void* p0, double p1, struct S_FPI p2,  void (*cb)(void*, double, struct S_FPI)) ;
+EXPORT void f5_V_PDS_FPF(void* p0, double p1, struct S_FPF p2,  void (*cb)(void*, double, struct S_FPF)) ;
+EXPORT void f5_V_PDS_FPD(void* p0, double p1, struct S_FPD p2,  void (*cb)(void*, double, struct S_FPD)) ;
+EXPORT void f5_V_PDS_FPP(void* p0, double p1, struct S_FPP p2,  void (*cb)(void*, double, struct S_FPP)) ;
+EXPORT void f5_V_PDS_DII(void* p0, double p1, struct S_DII p2,  void (*cb)(void*, double, struct S_DII)) ;
+EXPORT void f5_V_PDS_DIF(void* p0, double p1, struct S_DIF p2,  void (*cb)(void*, double, struct S_DIF)) ;
+EXPORT void f5_V_PDS_DID(void* p0, double p1, struct S_DID p2,  void (*cb)(void*, double, struct S_DID)) ;
+EXPORT void f5_V_PDS_DIP(void* p0, double p1, struct S_DIP p2,  void (*cb)(void*, double, struct S_DIP)) ;
+EXPORT void f5_V_PDS_DFI(void* p0, double p1, struct S_DFI p2,  void (*cb)(void*, double, struct S_DFI)) ;
+EXPORT void f5_V_PDS_DFF(void* p0, double p1, struct S_DFF p2,  void (*cb)(void*, double, struct S_DFF)) ;
+EXPORT void f5_V_PDS_DFD(void* p0, double p1, struct S_DFD p2,  void (*cb)(void*, double, struct S_DFD)) ;
+EXPORT void f5_V_PDS_DFP(void* p0, double p1, struct S_DFP p2,  void (*cb)(void*, double, struct S_DFP)) ;
+EXPORT void f5_V_PDS_DDI(void* p0, double p1, struct S_DDI p2,  void (*cb)(void*, double, struct S_DDI)) ;
+EXPORT void f5_V_PDS_DDF(void* p0, double p1, struct S_DDF p2,  void (*cb)(void*, double, struct S_DDF)) ;
+EXPORT void f5_V_PDS_DDD(void* p0, double p1, struct S_DDD p2,  void (*cb)(void*, double, struct S_DDD)) ;
+EXPORT void f5_V_PDS_DDP(void* p0, double p1, struct S_DDP p2,  void (*cb)(void*, double, struct S_DDP)) ;
+EXPORT void f5_V_PDS_DPI(void* p0, double p1, struct S_DPI p2,  void (*cb)(void*, double, struct S_DPI)) ;
+EXPORT void f5_V_PDS_DPF(void* p0, double p1, struct S_DPF p2,  void (*cb)(void*, double, struct S_DPF)) ;
+EXPORT void f5_V_PDS_DPD(void* p0, double p1, struct S_DPD p2,  void (*cb)(void*, double, struct S_DPD)) ;
+EXPORT void f5_V_PDS_DPP(void* p0, double p1, struct S_DPP p2,  void (*cb)(void*, double, struct S_DPP)) ;
+EXPORT void f5_V_PDS_PII(void* p0, double p1, struct S_PII p2,  void (*cb)(void*, double, struct S_PII)) ;
+EXPORT void f5_V_PDS_PIF(void* p0, double p1, struct S_PIF p2,  void (*cb)(void*, double, struct S_PIF)) ;
+EXPORT void f5_V_PDS_PID(void* p0, double p1, struct S_PID p2,  void (*cb)(void*, double, struct S_PID)) ;
+EXPORT void f5_V_PDS_PIP(void* p0, double p1, struct S_PIP p2,  void (*cb)(void*, double, struct S_PIP)) ;
+EXPORT void f5_V_PDS_PFI(void* p0, double p1, struct S_PFI p2,  void (*cb)(void*, double, struct S_PFI)) ;
+EXPORT void f5_V_PDS_PFF(void* p0, double p1, struct S_PFF p2,  void (*cb)(void*, double, struct S_PFF)) ;
+EXPORT void f5_V_PDS_PFD(void* p0, double p1, struct S_PFD p2,  void (*cb)(void*, double, struct S_PFD)) ;
+EXPORT void f5_V_PDS_PFP(void* p0, double p1, struct S_PFP p2,  void (*cb)(void*, double, struct S_PFP)) ;
+EXPORT void f5_V_PDS_PDI(void* p0, double p1, struct S_PDI p2,  void (*cb)(void*, double, struct S_PDI)) ;
+EXPORT void f5_V_PDS_PDF(void* p0, double p1, struct S_PDF p2,  void (*cb)(void*, double, struct S_PDF)) ;
+EXPORT void f5_V_PDS_PDD(void* p0, double p1, struct S_PDD p2,  void (*cb)(void*, double, struct S_PDD)) ;
+EXPORT void f5_V_PDS_PDP(void* p0, double p1, struct S_PDP p2,  void (*cb)(void*, double, struct S_PDP)) ;
+EXPORT void f5_V_PDS_PPI(void* p0, double p1, struct S_PPI p2,  void (*cb)(void*, double, struct S_PPI)) ;
+EXPORT void f5_V_PDS_PPF(void* p0, double p1, struct S_PPF p2,  void (*cb)(void*, double, struct S_PPF)) ;
+EXPORT void f5_V_PDS_PPD(void* p0, double p1, struct S_PPD p2,  void (*cb)(void*, double, struct S_PPD)) ;
+EXPORT void f5_V_PDS_PPP(void* p0, double p1, struct S_PPP p2,  void (*cb)(void*, double, struct S_PPP)) ;
+EXPORT void f5_V_PPI_(void* p0, void* p1, int p2,  void (*cb)(void*, void*, int)) ;
+EXPORT void f5_V_PPF_(void* p0, void* p1, float p2,  void (*cb)(void*, void*, float)) ;
+EXPORT void f5_V_PPD_(void* p0, void* p1, double p2,  void (*cb)(void*, void*, double)) ;
+EXPORT void f5_V_PPP_(void* p0, void* p1, void* p2,  void (*cb)(void*, void*, void*)) ;
+EXPORT void f5_V_PPS_I(void* p0, void* p1, struct S_I p2,  void (*cb)(void*, void*, struct S_I)) ;
+EXPORT void f5_V_PPS_F(void* p0, void* p1, struct S_F p2,  void (*cb)(void*, void*, struct S_F)) ;
+EXPORT void f5_V_PPS_D(void* p0, void* p1, struct S_D p2,  void (*cb)(void*, void*, struct S_D)) ;
+EXPORT void f5_V_PPS_P(void* p0, void* p1, struct S_P p2,  void (*cb)(void*, void*, struct S_P)) ;
+EXPORT void f5_V_PPS_II(void* p0, void* p1, struct S_II p2,  void (*cb)(void*, void*, struct S_II)) ;
+EXPORT void f5_V_PPS_IF(void* p0, void* p1, struct S_IF p2,  void (*cb)(void*, void*, struct S_IF)) ;
+EXPORT void f5_V_PPS_ID(void* p0, void* p1, struct S_ID p2,  void (*cb)(void*, void*, struct S_ID)) ;
+EXPORT void f5_V_PPS_IP(void* p0, void* p1, struct S_IP p2,  void (*cb)(void*, void*, struct S_IP)) ;
+EXPORT void f5_V_PPS_FI(void* p0, void* p1, struct S_FI p2,  void (*cb)(void*, void*, struct S_FI)) ;
+EXPORT void f5_V_PPS_FF(void* p0, void* p1, struct S_FF p2,  void (*cb)(void*, void*, struct S_FF)) ;
+EXPORT void f5_V_PPS_FD(void* p0, void* p1, struct S_FD p2,  void (*cb)(void*, void*, struct S_FD)) ;
+EXPORT void f5_V_PPS_FP(void* p0, void* p1, struct S_FP p2,  void (*cb)(void*, void*, struct S_FP)) ;
+EXPORT void f5_V_PPS_DI(void* p0, void* p1, struct S_DI p2,  void (*cb)(void*, void*, struct S_DI)) ;
+EXPORT void f5_V_PPS_DF(void* p0, void* p1, struct S_DF p2,  void (*cb)(void*, void*, struct S_DF)) ;
+EXPORT void f5_V_PPS_DD(void* p0, void* p1, struct S_DD p2,  void (*cb)(void*, void*, struct S_DD)) ;
+EXPORT void f5_V_PPS_DP(void* p0, void* p1, struct S_DP p2,  void (*cb)(void*, void*, struct S_DP)) ;
+EXPORT void f5_V_PPS_PI(void* p0, void* p1, struct S_PI p2,  void (*cb)(void*, void*, struct S_PI)) ;
+EXPORT void f5_V_PPS_PF(void* p0, void* p1, struct S_PF p2,  void (*cb)(void*, void*, struct S_PF)) ;
+EXPORT void f5_V_PPS_PD(void* p0, void* p1, struct S_PD p2,  void (*cb)(void*, void*, struct S_PD)) ;
+EXPORT void f5_V_PPS_PP(void* p0, void* p1, struct S_PP p2,  void (*cb)(void*, void*, struct S_PP)) ;
+EXPORT void f5_V_PPS_III(void* p0, void* p1, struct S_III p2,  void (*cb)(void*, void*, struct S_III)) ;
+EXPORT void f5_V_PPS_IIF(void* p0, void* p1, struct S_IIF p2,  void (*cb)(void*, void*, struct S_IIF)) ;
+EXPORT void f5_V_PPS_IID(void* p0, void* p1, struct S_IID p2,  void (*cb)(void*, void*, struct S_IID)) ;
+EXPORT void f5_V_PPS_IIP(void* p0, void* p1, struct S_IIP p2,  void (*cb)(void*, void*, struct S_IIP)) ;
+EXPORT void f5_V_PPS_IFI(void* p0, void* p1, struct S_IFI p2,  void (*cb)(void*, void*, struct S_IFI)) ;
+EXPORT void f5_V_PPS_IFF(void* p0, void* p1, struct S_IFF p2,  void (*cb)(void*, void*, struct S_IFF)) ;
+EXPORT void f5_V_PPS_IFD(void* p0, void* p1, struct S_IFD p2,  void (*cb)(void*, void*, struct S_IFD)) ;
+EXPORT void f5_V_PPS_IFP(void* p0, void* p1, struct S_IFP p2,  void (*cb)(void*, void*, struct S_IFP)) ;
+EXPORT void f5_V_PPS_IDI(void* p0, void* p1, struct S_IDI p2,  void (*cb)(void*, void*, struct S_IDI)) ;
+EXPORT void f5_V_PPS_IDF(void* p0, void* p1, struct S_IDF p2,  void (*cb)(void*, void*, struct S_IDF)) ;
+EXPORT void f5_V_PPS_IDD(void* p0, void* p1, struct S_IDD p2,  void (*cb)(void*, void*, struct S_IDD)) ;
+EXPORT void f5_V_PPS_IDP(void* p0, void* p1, struct S_IDP p2,  void (*cb)(void*, void*, struct S_IDP)) ;
+EXPORT void f5_V_PPS_IPI(void* p0, void* p1, struct S_IPI p2,  void (*cb)(void*, void*, struct S_IPI)) ;
+EXPORT void f5_V_PPS_IPF(void* p0, void* p1, struct S_IPF p2,  void (*cb)(void*, void*, struct S_IPF)) ;
+EXPORT void f5_V_PPS_IPD(void* p0, void* p1, struct S_IPD p2,  void (*cb)(void*, void*, struct S_IPD)) ;
+EXPORT void f5_V_PPS_IPP(void* p0, void* p1, struct S_IPP p2,  void (*cb)(void*, void*, struct S_IPP)) ;
+EXPORT void f5_V_PPS_FII(void* p0, void* p1, struct S_FII p2,  void (*cb)(void*, void*, struct S_FII)) ;
+EXPORT void f5_V_PPS_FIF(void* p0, void* p1, struct S_FIF p2,  void (*cb)(void*, void*, struct S_FIF)) ;
+EXPORT void f5_V_PPS_FID(void* p0, void* p1, struct S_FID p2,  void (*cb)(void*, void*, struct S_FID)) ;
+EXPORT void f5_V_PPS_FIP(void* p0, void* p1, struct S_FIP p2,  void (*cb)(void*, void*, struct S_FIP)) ;
+EXPORT void f5_V_PPS_FFI(void* p0, void* p1, struct S_FFI p2,  void (*cb)(void*, void*, struct S_FFI)) ;
+EXPORT void f5_V_PPS_FFF(void* p0, void* p1, struct S_FFF p2,  void (*cb)(void*, void*, struct S_FFF)) ;
+EXPORT void f5_V_PPS_FFD(void* p0, void* p1, struct S_FFD p2,  void (*cb)(void*, void*, struct S_FFD)) ;
+EXPORT void f5_V_PPS_FFP(void* p0, void* p1, struct S_FFP p2,  void (*cb)(void*, void*, struct S_FFP)) ;
+EXPORT void f5_V_PPS_FDI(void* p0, void* p1, struct S_FDI p2,  void (*cb)(void*, void*, struct S_FDI)) ;
+EXPORT void f5_V_PPS_FDF(void* p0, void* p1, struct S_FDF p2,  void (*cb)(void*, void*, struct S_FDF)) ;
+EXPORT void f5_V_PPS_FDD(void* p0, void* p1, struct S_FDD p2,  void (*cb)(void*, void*, struct S_FDD)) ;
+EXPORT void f5_V_PPS_FDP(void* p0, void* p1, struct S_FDP p2,  void (*cb)(void*, void*, struct S_FDP)) ;
+EXPORT void f5_V_PPS_FPI(void* p0, void* p1, struct S_FPI p2,  void (*cb)(void*, void*, struct S_FPI)) ;
+EXPORT void f5_V_PPS_FPF(void* p0, void* p1, struct S_FPF p2,  void (*cb)(void*, void*, struct S_FPF)) ;
+EXPORT void f5_V_PPS_FPD(void* p0, void* p1, struct S_FPD p2,  void (*cb)(void*, void*, struct S_FPD)) ;
+EXPORT void f5_V_PPS_FPP(void* p0, void* p1, struct S_FPP p2,  void (*cb)(void*, void*, struct S_FPP)) ;
+EXPORT void f5_V_PPS_DII(void* p0, void* p1, struct S_DII p2,  void (*cb)(void*, void*, struct S_DII)) ;
+EXPORT void f5_V_PPS_DIF(void* p0, void* p1, struct S_DIF p2,  void (*cb)(void*, void*, struct S_DIF)) ;
+EXPORT void f5_V_PPS_DID(void* p0, void* p1, struct S_DID p2,  void (*cb)(void*, void*, struct S_DID)) ;
+EXPORT void f5_V_PPS_DIP(void* p0, void* p1, struct S_DIP p2,  void (*cb)(void*, void*, struct S_DIP)) ;
+EXPORT void f5_V_PPS_DFI(void* p0, void* p1, struct S_DFI p2,  void (*cb)(void*, void*, struct S_DFI)) ;
+EXPORT void f5_V_PPS_DFF(void* p0, void* p1, struct S_DFF p2,  void (*cb)(void*, void*, struct S_DFF)) ;
+EXPORT void f5_V_PPS_DFD(void* p0, void* p1, struct S_DFD p2,  void (*cb)(void*, void*, struct S_DFD)) ;
+EXPORT void f5_V_PPS_DFP(void* p0, void* p1, struct S_DFP p2,  void (*cb)(void*, void*, struct S_DFP)) ;
+EXPORT void f5_V_PPS_DDI(void* p0, void* p1, struct S_DDI p2,  void (*cb)(void*, void*, struct S_DDI)) ;
+EXPORT void f5_V_PPS_DDF(void* p0, void* p1, struct S_DDF p2,  void (*cb)(void*, void*, struct S_DDF)) ;
+EXPORT void f5_V_PPS_DDD(void* p0, void* p1, struct S_DDD p2,  void (*cb)(void*, void*, struct S_DDD)) ;
+EXPORT void f5_V_PPS_DDP(void* p0, void* p1, struct S_DDP p2,  void (*cb)(void*, void*, struct S_DDP)) ;
+EXPORT void f5_V_PPS_DPI(void* p0, void* p1, struct S_DPI p2,  void (*cb)(void*, void*, struct S_DPI)) ;
+EXPORT void f5_V_PPS_DPF(void* p0, void* p1, struct S_DPF p2,  void (*cb)(void*, void*, struct S_DPF)) ;
+EXPORT void f5_V_PPS_DPD(void* p0, void* p1, struct S_DPD p2,  void (*cb)(void*, void*, struct S_DPD)) ;
+EXPORT void f5_V_PPS_DPP(void* p0, void* p1, struct S_DPP p2,  void (*cb)(void*, void*, struct S_DPP)) ;
+EXPORT void f5_V_PPS_PII(void* p0, void* p1, struct S_PII p2,  void (*cb)(void*, void*, struct S_PII)) ;
+EXPORT void f5_V_PPS_PIF(void* p0, void* p1, struct S_PIF p2,  void (*cb)(void*, void*, struct S_PIF)) ;
+EXPORT void f5_V_PPS_PID(void* p0, void* p1, struct S_PID p2,  void (*cb)(void*, void*, struct S_PID)) ;
+EXPORT void f5_V_PPS_PIP(void* p0, void* p1, struct S_PIP p2,  void (*cb)(void*, void*, struct S_PIP)) ;
+EXPORT void f5_V_PPS_PFI(void* p0, void* p1, struct S_PFI p2,  void (*cb)(void*, void*, struct S_PFI)) ;
+EXPORT void f5_V_PPS_PFF(void* p0, void* p1, struct S_PFF p2,  void (*cb)(void*, void*, struct S_PFF)) ;
+EXPORT void f5_V_PPS_PFD(void* p0, void* p1, struct S_PFD p2,  void (*cb)(void*, void*, struct S_PFD)) ;
+EXPORT void f5_V_PPS_PFP(void* p0, void* p1, struct S_PFP p2,  void (*cb)(void*, void*, struct S_PFP)) ;
+EXPORT void f5_V_PPS_PDI(void* p0, void* p1, struct S_PDI p2,  void (*cb)(void*, void*, struct S_PDI)) ;
+EXPORT void f5_V_PPS_PDF(void* p0, void* p1, struct S_PDF p2,  void (*cb)(void*, void*, struct S_PDF)) ;
+EXPORT void f5_V_PPS_PDD(void* p0, void* p1, struct S_PDD p2,  void (*cb)(void*, void*, struct S_PDD)) ;
+EXPORT void f5_V_PPS_PDP(void* p0, void* p1, struct S_PDP p2,  void (*cb)(void*, void*, struct S_PDP)) ;
+EXPORT void f5_V_PPS_PPI(void* p0, void* p1, struct S_PPI p2,  void (*cb)(void*, void*, struct S_PPI)) ;
+EXPORT void f5_V_PPS_PPF(void* p0, void* p1, struct S_PPF p2,  void (*cb)(void*, void*, struct S_PPF)) ;
+EXPORT void f5_V_PPS_PPD(void* p0, void* p1, struct S_PPD p2,  void (*cb)(void*, void*, struct S_PPD)) ;
+EXPORT void f5_V_PPS_PPP(void* p0, void* p1, struct S_PPP p2,  void (*cb)(void*, void*, struct S_PPP)) ;
+EXPORT void f5_V_PSI_I(void* p0, struct S_I p1, int p2,  void (*cb)(void*, struct S_I, int)) ;
+EXPORT void f5_V_PSI_F(void* p0, struct S_F p1, int p2,  void (*cb)(void*, struct S_F, int)) ;
+EXPORT void f5_V_PSI_D(void* p0, struct S_D p1, int p2,  void (*cb)(void*, struct S_D, int)) ;
+EXPORT void f5_V_PSI_P(void* p0, struct S_P p1, int p2,  void (*cb)(void*, struct S_P, int)) ;
+EXPORT void f5_V_PSI_II(void* p0, struct S_II p1, int p2,  void (*cb)(void*, struct S_II, int)) ;
+EXPORT void f5_V_PSI_IF(void* p0, struct S_IF p1, int p2,  void (*cb)(void*, struct S_IF, int)) ;
+EXPORT void f5_V_PSI_ID(void* p0, struct S_ID p1, int p2,  void (*cb)(void*, struct S_ID, int)) ;
+EXPORT void f5_V_PSI_IP(void* p0, struct S_IP p1, int p2,  void (*cb)(void*, struct S_IP, int)) ;
+EXPORT void f5_V_PSI_FI(void* p0, struct S_FI p1, int p2,  void (*cb)(void*, struct S_FI, int)) ;
+EXPORT void f5_V_PSI_FF(void* p0, struct S_FF p1, int p2,  void (*cb)(void*, struct S_FF, int)) ;
+EXPORT void f5_V_PSI_FD(void* p0, struct S_FD p1, int p2,  void (*cb)(void*, struct S_FD, int)) ;
+EXPORT void f5_V_PSI_FP(void* p0, struct S_FP p1, int p2,  void (*cb)(void*, struct S_FP, int)) ;
+EXPORT void f5_V_PSI_DI(void* p0, struct S_DI p1, int p2,  void (*cb)(void*, struct S_DI, int)) ;
+EXPORT void f5_V_PSI_DF(void* p0, struct S_DF p1, int p2,  void (*cb)(void*, struct S_DF, int)) ;
+EXPORT void f5_V_PSI_DD(void* p0, struct S_DD p1, int p2,  void (*cb)(void*, struct S_DD, int)) ;
+EXPORT void f5_V_PSI_DP(void* p0, struct S_DP p1, int p2,  void (*cb)(void*, struct S_DP, int)) ;
+EXPORT void f5_V_PSI_PI(void* p0, struct S_PI p1, int p2,  void (*cb)(void*, struct S_PI, int)) ;
+EXPORT void f5_V_PSI_PF(void* p0, struct S_PF p1, int p2,  void (*cb)(void*, struct S_PF, int)) ;
+EXPORT void f5_V_PSI_PD(void* p0, struct S_PD p1, int p2,  void (*cb)(void*, struct S_PD, int)) ;
+EXPORT void f5_V_PSI_PP(void* p0, struct S_PP p1, int p2,  void (*cb)(void*, struct S_PP, int)) ;
+EXPORT void f5_V_PSI_III(void* p0, struct S_III p1, int p2,  void (*cb)(void*, struct S_III, int)) ;
+EXPORT void f5_V_PSI_IIF(void* p0, struct S_IIF p1, int p2,  void (*cb)(void*, struct S_IIF, int)) ;
+EXPORT void f5_V_PSI_IID(void* p0, struct S_IID p1, int p2,  void (*cb)(void*, struct S_IID, int)) ;
+EXPORT void f5_V_PSI_IIP(void* p0, struct S_IIP p1, int p2,  void (*cb)(void*, struct S_IIP, int)) ;
+EXPORT void f5_V_PSI_IFI(void* p0, struct S_IFI p1, int p2,  void (*cb)(void*, struct S_IFI, int)) ;
+EXPORT void f5_V_PSI_IFF(void* p0, struct S_IFF p1, int p2,  void (*cb)(void*, struct S_IFF, int)) ;
+EXPORT void f5_V_PSI_IFD(void* p0, struct S_IFD p1, int p2,  void (*cb)(void*, struct S_IFD, int)) ;
+EXPORT void f5_V_PSI_IFP(void* p0, struct S_IFP p1, int p2,  void (*cb)(void*, struct S_IFP, int)) ;
+EXPORT void f5_V_PSI_IDI(void* p0, struct S_IDI p1, int p2,  void (*cb)(void*, struct S_IDI, int)) ;
+EXPORT void f5_V_PSI_IDF(void* p0, struct S_IDF p1, int p2,  void (*cb)(void*, struct S_IDF, int)) ;
+EXPORT void f5_V_PSI_IDD(void* p0, struct S_IDD p1, int p2,  void (*cb)(void*, struct S_IDD, int)) ;
+EXPORT void f5_V_PSI_IDP(void* p0, struct S_IDP p1, int p2,  void (*cb)(void*, struct S_IDP, int)) ;
+EXPORT void f5_V_PSI_IPI(void* p0, struct S_IPI p1, int p2,  void (*cb)(void*, struct S_IPI, int)) ;
+EXPORT void f5_V_PSI_IPF(void* p0, struct S_IPF p1, int p2,  void (*cb)(void*, struct S_IPF, int)) ;
+EXPORT void f5_V_PSI_IPD(void* p0, struct S_IPD p1, int p2,  void (*cb)(void*, struct S_IPD, int)) ;
+EXPORT void f5_V_PSI_IPP(void* p0, struct S_IPP p1, int p2,  void (*cb)(void*, struct S_IPP, int)) ;
+EXPORT void f5_V_PSI_FII(void* p0, struct S_FII p1, int p2,  void (*cb)(void*, struct S_FII, int)) ;
+EXPORT void f5_V_PSI_FIF(void* p0, struct S_FIF p1, int p2,  void (*cb)(void*, struct S_FIF, int)) ;
+EXPORT void f5_V_PSI_FID(void* p0, struct S_FID p1, int p2,  void (*cb)(void*, struct S_FID, int)) ;
+EXPORT void f5_V_PSI_FIP(void* p0, struct S_FIP p1, int p2,  void (*cb)(void*, struct S_FIP, int)) ;
+EXPORT void f5_V_PSI_FFI(void* p0, struct S_FFI p1, int p2,  void (*cb)(void*, struct S_FFI, int)) ;
+EXPORT void f5_V_PSI_FFF(void* p0, struct S_FFF p1, int p2,  void (*cb)(void*, struct S_FFF, int)) ;
+EXPORT void f5_V_PSI_FFD(void* p0, struct S_FFD p1, int p2,  void (*cb)(void*, struct S_FFD, int)) ;
+EXPORT void f5_V_PSI_FFP(void* p0, struct S_FFP p1, int p2,  void (*cb)(void*, struct S_FFP, int)) ;
+EXPORT void f5_V_PSI_FDI(void* p0, struct S_FDI p1, int p2,  void (*cb)(void*, struct S_FDI, int)) ;
+EXPORT void f5_V_PSI_FDF(void* p0, struct S_FDF p1, int p2,  void (*cb)(void*, struct S_FDF, int)) ;
+EXPORT void f5_V_PSI_FDD(void* p0, struct S_FDD p1, int p2,  void (*cb)(void*, struct S_FDD, int)) ;
+EXPORT void f5_V_PSI_FDP(void* p0, struct S_FDP p1, int p2,  void (*cb)(void*, struct S_FDP, int)) ;
+EXPORT void f5_V_PSI_FPI(void* p0, struct S_FPI p1, int p2,  void (*cb)(void*, struct S_FPI, int)) ;
+EXPORT void f5_V_PSI_FPF(void* p0, struct S_FPF p1, int p2,  void (*cb)(void*, struct S_FPF, int)) ;
+EXPORT void f5_V_PSI_FPD(void* p0, struct S_FPD p1, int p2,  void (*cb)(void*, struct S_FPD, int)) ;
+EXPORT void f5_V_PSI_FPP(void* p0, struct S_FPP p1, int p2,  void (*cb)(void*, struct S_FPP, int)) ;
+EXPORT void f5_V_PSI_DII(void* p0, struct S_DII p1, int p2,  void (*cb)(void*, struct S_DII, int)) ;
+EXPORT void f5_V_PSI_DIF(void* p0, struct S_DIF p1, int p2,  void (*cb)(void*, struct S_DIF, int)) ;
+EXPORT void f5_V_PSI_DID(void* p0, struct S_DID p1, int p2,  void (*cb)(void*, struct S_DID, int)) ;
+EXPORT void f5_V_PSI_DIP(void* p0, struct S_DIP p1, int p2,  void (*cb)(void*, struct S_DIP, int)) ;
+EXPORT void f5_V_PSI_DFI(void* p0, struct S_DFI p1, int p2,  void (*cb)(void*, struct S_DFI, int)) ;
+EXPORT void f5_V_PSI_DFF(void* p0, struct S_DFF p1, int p2,  void (*cb)(void*, struct S_DFF, int)) ;
+EXPORT void f5_V_PSI_DFD(void* p0, struct S_DFD p1, int p2,  void (*cb)(void*, struct S_DFD, int)) ;
+EXPORT void f5_V_PSI_DFP(void* p0, struct S_DFP p1, int p2,  void (*cb)(void*, struct S_DFP, int)) ;
+EXPORT void f5_V_PSI_DDI(void* p0, struct S_DDI p1, int p2,  void (*cb)(void*, struct S_DDI, int)) ;
+EXPORT void f5_V_PSI_DDF(void* p0, struct S_DDF p1, int p2,  void (*cb)(void*, struct S_DDF, int)) ;
+EXPORT void f5_V_PSI_DDD(void* p0, struct S_DDD p1, int p2,  void (*cb)(void*, struct S_DDD, int)) ;
+EXPORT void f5_V_PSI_DDP(void* p0, struct S_DDP p1, int p2,  void (*cb)(void*, struct S_DDP, int)) ;
+EXPORT void f5_V_PSI_DPI(void* p0, struct S_DPI p1, int p2,  void (*cb)(void*, struct S_DPI, int)) ;
+EXPORT void f5_V_PSI_DPF(void* p0, struct S_DPF p1, int p2,  void (*cb)(void*, struct S_DPF, int)) ;
+EXPORT void f5_V_PSI_DPD(void* p0, struct S_DPD p1, int p2,  void (*cb)(void*, struct S_DPD, int)) ;
+EXPORT void f5_V_PSI_DPP(void* p0, struct S_DPP p1, int p2,  void (*cb)(void*, struct S_DPP, int)) ;
+EXPORT void f5_V_PSI_PII(void* p0, struct S_PII p1, int p2,  void (*cb)(void*, struct S_PII, int)) ;
+EXPORT void f5_V_PSI_PIF(void* p0, struct S_PIF p1, int p2,  void (*cb)(void*, struct S_PIF, int)) ;
+EXPORT void f5_V_PSI_PID(void* p0, struct S_PID p1, int p2,  void (*cb)(void*, struct S_PID, int)) ;
+EXPORT void f6_V_PSI_PIP(void* p0, struct S_PIP p1, int p2,  void (*cb)(void*, struct S_PIP, int)) ;
+EXPORT void f6_V_PSI_PFI(void* p0, struct S_PFI p1, int p2,  void (*cb)(void*, struct S_PFI, int)) ;
+EXPORT void f6_V_PSI_PFF(void* p0, struct S_PFF p1, int p2,  void (*cb)(void*, struct S_PFF, int)) ;
+EXPORT void f6_V_PSI_PFD(void* p0, struct S_PFD p1, int p2,  void (*cb)(void*, struct S_PFD, int)) ;
+EXPORT void f6_V_PSI_PFP(void* p0, struct S_PFP p1, int p2,  void (*cb)(void*, struct S_PFP, int)) ;
+EXPORT void f6_V_PSI_PDI(void* p0, struct S_PDI p1, int p2,  void (*cb)(void*, struct S_PDI, int)) ;
+EXPORT void f6_V_PSI_PDF(void* p0, struct S_PDF p1, int p2,  void (*cb)(void*, struct S_PDF, int)) ;
+EXPORT void f6_V_PSI_PDD(void* p0, struct S_PDD p1, int p2,  void (*cb)(void*, struct S_PDD, int)) ;
+EXPORT void f6_V_PSI_PDP(void* p0, struct S_PDP p1, int p2,  void (*cb)(void*, struct S_PDP, int)) ;
+EXPORT void f6_V_PSI_PPI(void* p0, struct S_PPI p1, int p2,  void (*cb)(void*, struct S_PPI, int)) ;
+EXPORT void f6_V_PSI_PPF(void* p0, struct S_PPF p1, int p2,  void (*cb)(void*, struct S_PPF, int)) ;
+EXPORT void f6_V_PSI_PPD(void* p0, struct S_PPD p1, int p2,  void (*cb)(void*, struct S_PPD, int)) ;
+EXPORT void f6_V_PSI_PPP(void* p0, struct S_PPP p1, int p2,  void (*cb)(void*, struct S_PPP, int)) ;
+EXPORT void f6_V_PSF_I(void* p0, struct S_I p1, float p2,  void (*cb)(void*, struct S_I, float)) ;
+EXPORT void f6_V_PSF_F(void* p0, struct S_F p1, float p2,  void (*cb)(void*, struct S_F, float)) ;
+EXPORT void f6_V_PSF_D(void* p0, struct S_D p1, float p2,  void (*cb)(void*, struct S_D, float)) ;
+EXPORT void f6_V_PSF_P(void* p0, struct S_P p1, float p2,  void (*cb)(void*, struct S_P, float)) ;
+EXPORT void f6_V_PSF_II(void* p0, struct S_II p1, float p2,  void (*cb)(void*, struct S_II, float)) ;
+EXPORT void f6_V_PSF_IF(void* p0, struct S_IF p1, float p2,  void (*cb)(void*, struct S_IF, float)) ;
+EXPORT void f6_V_PSF_ID(void* p0, struct S_ID p1, float p2,  void (*cb)(void*, struct S_ID, float)) ;
+EXPORT void f6_V_PSF_IP(void* p0, struct S_IP p1, float p2,  void (*cb)(void*, struct S_IP, float)) ;
+EXPORT void f6_V_PSF_FI(void* p0, struct S_FI p1, float p2,  void (*cb)(void*, struct S_FI, float)) ;
+EXPORT void f6_V_PSF_FF(void* p0, struct S_FF p1, float p2,  void (*cb)(void*, struct S_FF, float)) ;
+EXPORT void f6_V_PSF_FD(void* p0, struct S_FD p1, float p2,  void (*cb)(void*, struct S_FD, float)) ;
+EXPORT void f6_V_PSF_FP(void* p0, struct S_FP p1, float p2,  void (*cb)(void*, struct S_FP, float)) ;
+EXPORT void f6_V_PSF_DI(void* p0, struct S_DI p1, float p2,  void (*cb)(void*, struct S_DI, float)) ;
+EXPORT void f6_V_PSF_DF(void* p0, struct S_DF p1, float p2,  void (*cb)(void*, struct S_DF, float)) ;
+EXPORT void f6_V_PSF_DD(void* p0, struct S_DD p1, float p2,  void (*cb)(void*, struct S_DD, float)) ;
+EXPORT void f6_V_PSF_DP(void* p0, struct S_DP p1, float p2,  void (*cb)(void*, struct S_DP, float)) ;
+EXPORT void f6_V_PSF_PI(void* p0, struct S_PI p1, float p2,  void (*cb)(void*, struct S_PI, float)) ;
+EXPORT void f6_V_PSF_PF(void* p0, struct S_PF p1, float p2,  void (*cb)(void*, struct S_PF, float)) ;
+EXPORT void f6_V_PSF_PD(void* p0, struct S_PD p1, float p2,  void (*cb)(void*, struct S_PD, float)) ;
+EXPORT void f6_V_PSF_PP(void* p0, struct S_PP p1, float p2,  void (*cb)(void*, struct S_PP, float)) ;
+EXPORT void f6_V_PSF_III(void* p0, struct S_III p1, float p2,  void (*cb)(void*, struct S_III, float)) ;
+EXPORT void f6_V_PSF_IIF(void* p0, struct S_IIF p1, float p2,  void (*cb)(void*, struct S_IIF, float)) ;
+EXPORT void f6_V_PSF_IID(void* p0, struct S_IID p1, float p2,  void (*cb)(void*, struct S_IID, float)) ;
+EXPORT void f6_V_PSF_IIP(void* p0, struct S_IIP p1, float p2,  void (*cb)(void*, struct S_IIP, float)) ;
+EXPORT void f6_V_PSF_IFI(void* p0, struct S_IFI p1, float p2,  void (*cb)(void*, struct S_IFI, float)) ;
+EXPORT void f6_V_PSF_IFF(void* p0, struct S_IFF p1, float p2,  void (*cb)(void*, struct S_IFF, float)) ;
+EXPORT void f6_V_PSF_IFD(void* p0, struct S_IFD p1, float p2,  void (*cb)(void*, struct S_IFD, float)) ;
+EXPORT void f6_V_PSF_IFP(void* p0, struct S_IFP p1, float p2,  void (*cb)(void*, struct S_IFP, float)) ;
+EXPORT void f6_V_PSF_IDI(void* p0, struct S_IDI p1, float p2,  void (*cb)(void*, struct S_IDI, float)) ;
+EXPORT void f6_V_PSF_IDF(void* p0, struct S_IDF p1, float p2,  void (*cb)(void*, struct S_IDF, float)) ;
+EXPORT void f6_V_PSF_IDD(void* p0, struct S_IDD p1, float p2,  void (*cb)(void*, struct S_IDD, float)) ;
+EXPORT void f6_V_PSF_IDP(void* p0, struct S_IDP p1, float p2,  void (*cb)(void*, struct S_IDP, float)) ;
+EXPORT void f6_V_PSF_IPI(void* p0, struct S_IPI p1, float p2,  void (*cb)(void*, struct S_IPI, float)) ;
+EXPORT void f6_V_PSF_IPF(void* p0, struct S_IPF p1, float p2,  void (*cb)(void*, struct S_IPF, float)) ;
+EXPORT void f6_V_PSF_IPD(void* p0, struct S_IPD p1, float p2,  void (*cb)(void*, struct S_IPD, float)) ;
+EXPORT void f6_V_PSF_IPP(void* p0, struct S_IPP p1, float p2,  void (*cb)(void*, struct S_IPP, float)) ;
+EXPORT void f6_V_PSF_FII(void* p0, struct S_FII p1, float p2,  void (*cb)(void*, struct S_FII, float)) ;
+EXPORT void f6_V_PSF_FIF(void* p0, struct S_FIF p1, float p2,  void (*cb)(void*, struct S_FIF, float)) ;
+EXPORT void f6_V_PSF_FID(void* p0, struct S_FID p1, float p2,  void (*cb)(void*, struct S_FID, float)) ;
+EXPORT void f6_V_PSF_FIP(void* p0, struct S_FIP p1, float p2,  void (*cb)(void*, struct S_FIP, float)) ;
+EXPORT void f6_V_PSF_FFI(void* p0, struct S_FFI p1, float p2,  void (*cb)(void*, struct S_FFI, float)) ;
+EXPORT void f6_V_PSF_FFF(void* p0, struct S_FFF p1, float p2,  void (*cb)(void*, struct S_FFF, float)) ;
+EXPORT void f6_V_PSF_FFD(void* p0, struct S_FFD p1, float p2,  void (*cb)(void*, struct S_FFD, float)) ;
+EXPORT void f6_V_PSF_FFP(void* p0, struct S_FFP p1, float p2,  void (*cb)(void*, struct S_FFP, float)) ;
+EXPORT void f6_V_PSF_FDI(void* p0, struct S_FDI p1, float p2,  void (*cb)(void*, struct S_FDI, float)) ;
+EXPORT void f6_V_PSF_FDF(void* p0, struct S_FDF p1, float p2,  void (*cb)(void*, struct S_FDF, float)) ;
+EXPORT void f6_V_PSF_FDD(void* p0, struct S_FDD p1, float p2,  void (*cb)(void*, struct S_FDD, float)) ;
+EXPORT void f6_V_PSF_FDP(void* p0, struct S_FDP p1, float p2,  void (*cb)(void*, struct S_FDP, float)) ;
+EXPORT void f6_V_PSF_FPI(void* p0, struct S_FPI p1, float p2,  void (*cb)(void*, struct S_FPI, float)) ;
+EXPORT void f6_V_PSF_FPF(void* p0, struct S_FPF p1, float p2,  void (*cb)(void*, struct S_FPF, float)) ;
+EXPORT void f6_V_PSF_FPD(void* p0, struct S_FPD p1, float p2,  void (*cb)(void*, struct S_FPD, float)) ;
+EXPORT void f6_V_PSF_FPP(void* p0, struct S_FPP p1, float p2,  void (*cb)(void*, struct S_FPP, float)) ;
+EXPORT void f6_V_PSF_DII(void* p0, struct S_DII p1, float p2,  void (*cb)(void*, struct S_DII, float)) ;
+EXPORT void f6_V_PSF_DIF(void* p0, struct S_DIF p1, float p2,  void (*cb)(void*, struct S_DIF, float)) ;
+EXPORT void f6_V_PSF_DID(void* p0, struct S_DID p1, float p2,  void (*cb)(void*, struct S_DID, float)) ;
+EXPORT void f6_V_PSF_DIP(void* p0, struct S_DIP p1, float p2,  void (*cb)(void*, struct S_DIP, float)) ;
+EXPORT void f6_V_PSF_DFI(void* p0, struct S_DFI p1, float p2,  void (*cb)(void*, struct S_DFI, float)) ;
+EXPORT void f6_V_PSF_DFF(void* p0, struct S_DFF p1, float p2,  void (*cb)(void*, struct S_DFF, float)) ;
+EXPORT void f6_V_PSF_DFD(void* p0, struct S_DFD p1, float p2,  void (*cb)(void*, struct S_DFD, float)) ;
+EXPORT void f6_V_PSF_DFP(void* p0, struct S_DFP p1, float p2,  void (*cb)(void*, struct S_DFP, float)) ;
+EXPORT void f6_V_PSF_DDI(void* p0, struct S_DDI p1, float p2,  void (*cb)(void*, struct S_DDI, float)) ;
+EXPORT void f6_V_PSF_DDF(void* p0, struct S_DDF p1, float p2,  void (*cb)(void*, struct S_DDF, float)) ;
+EXPORT void f6_V_PSF_DDD(void* p0, struct S_DDD p1, float p2,  void (*cb)(void*, struct S_DDD, float)) ;
+EXPORT void f6_V_PSF_DDP(void* p0, struct S_DDP p1, float p2,  void (*cb)(void*, struct S_DDP, float)) ;
+EXPORT void f6_V_PSF_DPI(void* p0, struct S_DPI p1, float p2,  void (*cb)(void*, struct S_DPI, float)) ;
+EXPORT void f6_V_PSF_DPF(void* p0, struct S_DPF p1, float p2,  void (*cb)(void*, struct S_DPF, float)) ;
+EXPORT void f6_V_PSF_DPD(void* p0, struct S_DPD p1, float p2,  void (*cb)(void*, struct S_DPD, float)) ;
+EXPORT void f6_V_PSF_DPP(void* p0, struct S_DPP p1, float p2,  void (*cb)(void*, struct S_DPP, float)) ;
+EXPORT void f6_V_PSF_PII(void* p0, struct S_PII p1, float p2,  void (*cb)(void*, struct S_PII, float)) ;
+EXPORT void f6_V_PSF_PIF(void* p0, struct S_PIF p1, float p2,  void (*cb)(void*, struct S_PIF, float)) ;
+EXPORT void f6_V_PSF_PID(void* p0, struct S_PID p1, float p2,  void (*cb)(void*, struct S_PID, float)) ;
+EXPORT void f6_V_PSF_PIP(void* p0, struct S_PIP p1, float p2,  void (*cb)(void*, struct S_PIP, float)) ;
+EXPORT void f6_V_PSF_PFI(void* p0, struct S_PFI p1, float p2,  void (*cb)(void*, struct S_PFI, float)) ;
+EXPORT void f6_V_PSF_PFF(void* p0, struct S_PFF p1, float p2,  void (*cb)(void*, struct S_PFF, float)) ;
+EXPORT void f6_V_PSF_PFD(void* p0, struct S_PFD p1, float p2,  void (*cb)(void*, struct S_PFD, float)) ;
+EXPORT void f6_V_PSF_PFP(void* p0, struct S_PFP p1, float p2,  void (*cb)(void*, struct S_PFP, float)) ;
+EXPORT void f6_V_PSF_PDI(void* p0, struct S_PDI p1, float p2,  void (*cb)(void*, struct S_PDI, float)) ;
+EXPORT void f6_V_PSF_PDF(void* p0, struct S_PDF p1, float p2,  void (*cb)(void*, struct S_PDF, float)) ;
+EXPORT void f6_V_PSF_PDD(void* p0, struct S_PDD p1, float p2,  void (*cb)(void*, struct S_PDD, float)) ;
+EXPORT void f6_V_PSF_PDP(void* p0, struct S_PDP p1, float p2,  void (*cb)(void*, struct S_PDP, float)) ;
+EXPORT void f6_V_PSF_PPI(void* p0, struct S_PPI p1, float p2,  void (*cb)(void*, struct S_PPI, float)) ;
+EXPORT void f6_V_PSF_PPF(void* p0, struct S_PPF p1, float p2,  void (*cb)(void*, struct S_PPF, float)) ;
+EXPORT void f6_V_PSF_PPD(void* p0, struct S_PPD p1, float p2,  void (*cb)(void*, struct S_PPD, float)) ;
+EXPORT void f6_V_PSF_PPP(void* p0, struct S_PPP p1, float p2,  void (*cb)(void*, struct S_PPP, float)) ;
+EXPORT void f6_V_PSD_I(void* p0, struct S_I p1, double p2,  void (*cb)(void*, struct S_I, double)) ;
+EXPORT void f6_V_PSD_F(void* p0, struct S_F p1, double p2,  void (*cb)(void*, struct S_F, double)) ;
+EXPORT void f6_V_PSD_D(void* p0, struct S_D p1, double p2,  void (*cb)(void*, struct S_D, double)) ;
+EXPORT void f6_V_PSD_P(void* p0, struct S_P p1, double p2,  void (*cb)(void*, struct S_P, double)) ;
+EXPORT void f6_V_PSD_II(void* p0, struct S_II p1, double p2,  void (*cb)(void*, struct S_II, double)) ;
+EXPORT void f6_V_PSD_IF(void* p0, struct S_IF p1, double p2,  void (*cb)(void*, struct S_IF, double)) ;
+EXPORT void f6_V_PSD_ID(void* p0, struct S_ID p1, double p2,  void (*cb)(void*, struct S_ID, double)) ;
+EXPORT void f6_V_PSD_IP(void* p0, struct S_IP p1, double p2,  void (*cb)(void*, struct S_IP, double)) ;
+EXPORT void f6_V_PSD_FI(void* p0, struct S_FI p1, double p2,  void (*cb)(void*, struct S_FI, double)) ;
+EXPORT void f6_V_PSD_FF(void* p0, struct S_FF p1, double p2,  void (*cb)(void*, struct S_FF, double)) ;
+EXPORT void f6_V_PSD_FD(void* p0, struct S_FD p1, double p2,  void (*cb)(void*, struct S_FD, double)) ;
+EXPORT void f6_V_PSD_FP(void* p0, struct S_FP p1, double p2,  void (*cb)(void*, struct S_FP, double)) ;
+EXPORT void f6_V_PSD_DI(void* p0, struct S_DI p1, double p2,  void (*cb)(void*, struct S_DI, double)) ;
+EXPORT void f6_V_PSD_DF(void* p0, struct S_DF p1, double p2,  void (*cb)(void*, struct S_DF, double)) ;
+EXPORT void f6_V_PSD_DD(void* p0, struct S_DD p1, double p2,  void (*cb)(void*, struct S_DD, double)) ;
+EXPORT void f6_V_PSD_DP(void* p0, struct S_DP p1, double p2,  void (*cb)(void*, struct S_DP, double)) ;
+EXPORT void f6_V_PSD_PI(void* p0, struct S_PI p1, double p2,  void (*cb)(void*, struct S_PI, double)) ;
+EXPORT void f6_V_PSD_PF(void* p0, struct S_PF p1, double p2,  void (*cb)(void*, struct S_PF, double)) ;
+EXPORT void f6_V_PSD_PD(void* p0, struct S_PD p1, double p2,  void (*cb)(void*, struct S_PD, double)) ;
+EXPORT void f6_V_PSD_PP(void* p0, struct S_PP p1, double p2,  void (*cb)(void*, struct S_PP, double)) ;
+EXPORT void f6_V_PSD_III(void* p0, struct S_III p1, double p2,  void (*cb)(void*, struct S_III, double)) ;
+EXPORT void f6_V_PSD_IIF(void* p0, struct S_IIF p1, double p2,  void (*cb)(void*, struct S_IIF, double)) ;
+EXPORT void f6_V_PSD_IID(void* p0, struct S_IID p1, double p2,  void (*cb)(void*, struct S_IID, double)) ;
+EXPORT void f6_V_PSD_IIP(void* p0, struct S_IIP p1, double p2,  void (*cb)(void*, struct S_IIP, double)) ;
+EXPORT void f6_V_PSD_IFI(void* p0, struct S_IFI p1, double p2,  void (*cb)(void*, struct S_IFI, double)) ;
+EXPORT void f6_V_PSD_IFF(void* p0, struct S_IFF p1, double p2,  void (*cb)(void*, struct S_IFF, double)) ;
+EXPORT void f6_V_PSD_IFD(void* p0, struct S_IFD p1, double p2,  void (*cb)(void*, struct S_IFD, double)) ;
+EXPORT void f6_V_PSD_IFP(void* p0, struct S_IFP p1, double p2,  void (*cb)(void*, struct S_IFP, double)) ;
+EXPORT void f6_V_PSD_IDI(void* p0, struct S_IDI p1, double p2,  void (*cb)(void*, struct S_IDI, double)) ;
+EXPORT void f6_V_PSD_IDF(void* p0, struct S_IDF p1, double p2,  void (*cb)(void*, struct S_IDF, double)) ;
+EXPORT void f6_V_PSD_IDD(void* p0, struct S_IDD p1, double p2,  void (*cb)(void*, struct S_IDD, double)) ;
+EXPORT void f6_V_PSD_IDP(void* p0, struct S_IDP p1, double p2,  void (*cb)(void*, struct S_IDP, double)) ;
+EXPORT void f6_V_PSD_IPI(void* p0, struct S_IPI p1, double p2,  void (*cb)(void*, struct S_IPI, double)) ;
+EXPORT void f6_V_PSD_IPF(void* p0, struct S_IPF p1, double p2,  void (*cb)(void*, struct S_IPF, double)) ;
+EXPORT void f6_V_PSD_IPD(void* p0, struct S_IPD p1, double p2,  void (*cb)(void*, struct S_IPD, double)) ;
+EXPORT void f6_V_PSD_IPP(void* p0, struct S_IPP p1, double p2,  void (*cb)(void*, struct S_IPP, double)) ;
+EXPORT void f6_V_PSD_FII(void* p0, struct S_FII p1, double p2,  void (*cb)(void*, struct S_FII, double)) ;
+EXPORT void f6_V_PSD_FIF(void* p0, struct S_FIF p1, double p2,  void (*cb)(void*, struct S_FIF, double)) ;
+EXPORT void f6_V_PSD_FID(void* p0, struct S_FID p1, double p2,  void (*cb)(void*, struct S_FID, double)) ;
+EXPORT void f6_V_PSD_FIP(void* p0, struct S_FIP p1, double p2,  void (*cb)(void*, struct S_FIP, double)) ;
+EXPORT void f6_V_PSD_FFI(void* p0, struct S_FFI p1, double p2,  void (*cb)(void*, struct S_FFI, double)) ;
+EXPORT void f6_V_PSD_FFF(void* p0, struct S_FFF p1, double p2,  void (*cb)(void*, struct S_FFF, double)) ;
+EXPORT void f6_V_PSD_FFD(void* p0, struct S_FFD p1, double p2,  void (*cb)(void*, struct S_FFD, double)) ;
+EXPORT void f6_V_PSD_FFP(void* p0, struct S_FFP p1, double p2,  void (*cb)(void*, struct S_FFP, double)) ;
+EXPORT void f6_V_PSD_FDI(void* p0, struct S_FDI p1, double p2,  void (*cb)(void*, struct S_FDI, double)) ;
+EXPORT void f6_V_PSD_FDF(void* p0, struct S_FDF p1, double p2,  void (*cb)(void*, struct S_FDF, double)) ;
+EXPORT void f6_V_PSD_FDD(void* p0, struct S_FDD p1, double p2,  void (*cb)(void*, struct S_FDD, double)) ;
+EXPORT void f6_V_PSD_FDP(void* p0, struct S_FDP p1, double p2,  void (*cb)(void*, struct S_FDP, double)) ;
+EXPORT void f6_V_PSD_FPI(void* p0, struct S_FPI p1, double p2,  void (*cb)(void*, struct S_FPI, double)) ;
+EXPORT void f6_V_PSD_FPF(void* p0, struct S_FPF p1, double p2,  void (*cb)(void*, struct S_FPF, double)) ;
+EXPORT void f6_V_PSD_FPD(void* p0, struct S_FPD p1, double p2,  void (*cb)(void*, struct S_FPD, double)) ;
+EXPORT void f6_V_PSD_FPP(void* p0, struct S_FPP p1, double p2,  void (*cb)(void*, struct S_FPP, double)) ;
+EXPORT void f6_V_PSD_DII(void* p0, struct S_DII p1, double p2,  void (*cb)(void*, struct S_DII, double)) ;
+EXPORT void f6_V_PSD_DIF(void* p0, struct S_DIF p1, double p2,  void (*cb)(void*, struct S_DIF, double)) ;
+EXPORT void f6_V_PSD_DID(void* p0, struct S_DID p1, double p2,  void (*cb)(void*, struct S_DID, double)) ;
+EXPORT void f6_V_PSD_DIP(void* p0, struct S_DIP p1, double p2,  void (*cb)(void*, struct S_DIP, double)) ;
+EXPORT void f6_V_PSD_DFI(void* p0, struct S_DFI p1, double p2,  void (*cb)(void*, struct S_DFI, double)) ;
+EXPORT void f6_V_PSD_DFF(void* p0, struct S_DFF p1, double p2,  void (*cb)(void*, struct S_DFF, double)) ;
+EXPORT void f6_V_PSD_DFD(void* p0, struct S_DFD p1, double p2,  void (*cb)(void*, struct S_DFD, double)) ;
+EXPORT void f6_V_PSD_DFP(void* p0, struct S_DFP p1, double p2,  void (*cb)(void*, struct S_DFP, double)) ;
+EXPORT void f6_V_PSD_DDI(void* p0, struct S_DDI p1, double p2,  void (*cb)(void*, struct S_DDI, double)) ;
+EXPORT void f6_V_PSD_DDF(void* p0, struct S_DDF p1, double p2,  void (*cb)(void*, struct S_DDF, double)) ;
+EXPORT void f6_V_PSD_DDD(void* p0, struct S_DDD p1, double p2,  void (*cb)(void*, struct S_DDD, double)) ;
+EXPORT void f6_V_PSD_DDP(void* p0, struct S_DDP p1, double p2,  void (*cb)(void*, struct S_DDP, double)) ;
+EXPORT void f6_V_PSD_DPI(void* p0, struct S_DPI p1, double p2,  void (*cb)(void*, struct S_DPI, double)) ;
+EXPORT void f6_V_PSD_DPF(void* p0, struct S_DPF p1, double p2,  void (*cb)(void*, struct S_DPF, double)) ;
+EXPORT void f6_V_PSD_DPD(void* p0, struct S_DPD p1, double p2,  void (*cb)(void*, struct S_DPD, double)) ;
+EXPORT void f6_V_PSD_DPP(void* p0, struct S_DPP p1, double p2,  void (*cb)(void*, struct S_DPP, double)) ;
+EXPORT void f6_V_PSD_PII(void* p0, struct S_PII p1, double p2,  void (*cb)(void*, struct S_PII, double)) ;
+EXPORT void f6_V_PSD_PIF(void* p0, struct S_PIF p1, double p2,  void (*cb)(void*, struct S_PIF, double)) ;
+EXPORT void f6_V_PSD_PID(void* p0, struct S_PID p1, double p2,  void (*cb)(void*, struct S_PID, double)) ;
+EXPORT void f6_V_PSD_PIP(void* p0, struct S_PIP p1, double p2,  void (*cb)(void*, struct S_PIP, double)) ;
+EXPORT void f6_V_PSD_PFI(void* p0, struct S_PFI p1, double p2,  void (*cb)(void*, struct S_PFI, double)) ;
+EXPORT void f6_V_PSD_PFF(void* p0, struct S_PFF p1, double p2,  void (*cb)(void*, struct S_PFF, double)) ;
+EXPORT void f6_V_PSD_PFD(void* p0, struct S_PFD p1, double p2,  void (*cb)(void*, struct S_PFD, double)) ;
+EXPORT void f6_V_PSD_PFP(void* p0, struct S_PFP p1, double p2,  void (*cb)(void*, struct S_PFP, double)) ;
+EXPORT void f6_V_PSD_PDI(void* p0, struct S_PDI p1, double p2,  void (*cb)(void*, struct S_PDI, double)) ;
+EXPORT void f6_V_PSD_PDF(void* p0, struct S_PDF p1, double p2,  void (*cb)(void*, struct S_PDF, double)) ;
+EXPORT void f6_V_PSD_PDD(void* p0, struct S_PDD p1, double p2,  void (*cb)(void*, struct S_PDD, double)) ;
+EXPORT void f6_V_PSD_PDP(void* p0, struct S_PDP p1, double p2,  void (*cb)(void*, struct S_PDP, double)) ;
+EXPORT void f6_V_PSD_PPI(void* p0, struct S_PPI p1, double p2,  void (*cb)(void*, struct S_PPI, double)) ;
+EXPORT void f6_V_PSD_PPF(void* p0, struct S_PPF p1, double p2,  void (*cb)(void*, struct S_PPF, double)) ;
+EXPORT void f6_V_PSD_PPD(void* p0, struct S_PPD p1, double p2,  void (*cb)(void*, struct S_PPD, double)) ;
+EXPORT void f6_V_PSD_PPP(void* p0, struct S_PPP p1, double p2,  void (*cb)(void*, struct S_PPP, double)) ;
+EXPORT void f6_V_PSP_I(void* p0, struct S_I p1, void* p2,  void (*cb)(void*, struct S_I, void*)) ;
+EXPORT void f6_V_PSP_F(void* p0, struct S_F p1, void* p2,  void (*cb)(void*, struct S_F, void*)) ;
+EXPORT void f6_V_PSP_D(void* p0, struct S_D p1, void* p2,  void (*cb)(void*, struct S_D, void*)) ;
+EXPORT void f6_V_PSP_P(void* p0, struct S_P p1, void* p2,  void (*cb)(void*, struct S_P, void*)) ;
+EXPORT void f6_V_PSP_II(void* p0, struct S_II p1, void* p2,  void (*cb)(void*, struct S_II, void*)) ;
+EXPORT void f6_V_PSP_IF(void* p0, struct S_IF p1, void* p2,  void (*cb)(void*, struct S_IF, void*)) ;
+EXPORT void f6_V_PSP_ID(void* p0, struct S_ID p1, void* p2,  void (*cb)(void*, struct S_ID, void*)) ;
+EXPORT void f6_V_PSP_IP(void* p0, struct S_IP p1, void* p2,  void (*cb)(void*, struct S_IP, void*)) ;
+EXPORT void f6_V_PSP_FI(void* p0, struct S_FI p1, void* p2,  void (*cb)(void*, struct S_FI, void*)) ;
+EXPORT void f6_V_PSP_FF(void* p0, struct S_FF p1, void* p2,  void (*cb)(void*, struct S_FF, void*)) ;
+EXPORT void f6_V_PSP_FD(void* p0, struct S_FD p1, void* p2,  void (*cb)(void*, struct S_FD, void*)) ;
+EXPORT void f6_V_PSP_FP(void* p0, struct S_FP p1, void* p2,  void (*cb)(void*, struct S_FP, void*)) ;
+EXPORT void f6_V_PSP_DI(void* p0, struct S_DI p1, void* p2,  void (*cb)(void*, struct S_DI, void*)) ;
+EXPORT void f6_V_PSP_DF(void* p0, struct S_DF p1, void* p2,  void (*cb)(void*, struct S_DF, void*)) ;
+EXPORT void f6_V_PSP_DD(void* p0, struct S_DD p1, void* p2,  void (*cb)(void*, struct S_DD, void*)) ;
+EXPORT void f6_V_PSP_DP(void* p0, struct S_DP p1, void* p2,  void (*cb)(void*, struct S_DP, void*)) ;
+EXPORT void f6_V_PSP_PI(void* p0, struct S_PI p1, void* p2,  void (*cb)(void*, struct S_PI, void*)) ;
+EXPORT void f6_V_PSP_PF(void* p0, struct S_PF p1, void* p2,  void (*cb)(void*, struct S_PF, void*)) ;
+EXPORT void f6_V_PSP_PD(void* p0, struct S_PD p1, void* p2,  void (*cb)(void*, struct S_PD, void*)) ;
+EXPORT void f6_V_PSP_PP(void* p0, struct S_PP p1, void* p2,  void (*cb)(void*, struct S_PP, void*)) ;
+EXPORT void f6_V_PSP_III(void* p0, struct S_III p1, void* p2,  void (*cb)(void*, struct S_III, void*)) ;
+EXPORT void f6_V_PSP_IIF(void* p0, struct S_IIF p1, void* p2,  void (*cb)(void*, struct S_IIF, void*)) ;
+EXPORT void f6_V_PSP_IID(void* p0, struct S_IID p1, void* p2,  void (*cb)(void*, struct S_IID, void*)) ;
+EXPORT void f6_V_PSP_IIP(void* p0, struct S_IIP p1, void* p2,  void (*cb)(void*, struct S_IIP, void*)) ;
+EXPORT void f6_V_PSP_IFI(void* p0, struct S_IFI p1, void* p2,  void (*cb)(void*, struct S_IFI, void*)) ;
+EXPORT void f6_V_PSP_IFF(void* p0, struct S_IFF p1, void* p2,  void (*cb)(void*, struct S_IFF, void*)) ;
+EXPORT void f6_V_PSP_IFD(void* p0, struct S_IFD p1, void* p2,  void (*cb)(void*, struct S_IFD, void*)) ;
+EXPORT void f6_V_PSP_IFP(void* p0, struct S_IFP p1, void* p2,  void (*cb)(void*, struct S_IFP, void*)) ;
+EXPORT void f6_V_PSP_IDI(void* p0, struct S_IDI p1, void* p2,  void (*cb)(void*, struct S_IDI, void*)) ;
+EXPORT void f6_V_PSP_IDF(void* p0, struct S_IDF p1, void* p2,  void (*cb)(void*, struct S_IDF, void*)) ;
+EXPORT void f6_V_PSP_IDD(void* p0, struct S_IDD p1, void* p2,  void (*cb)(void*, struct S_IDD, void*)) ;
+EXPORT void f6_V_PSP_IDP(void* p0, struct S_IDP p1, void* p2,  void (*cb)(void*, struct S_IDP, void*)) ;
+EXPORT void f6_V_PSP_IPI(void* p0, struct S_IPI p1, void* p2,  void (*cb)(void*, struct S_IPI, void*)) ;
+EXPORT void f6_V_PSP_IPF(void* p0, struct S_IPF p1, void* p2,  void (*cb)(void*, struct S_IPF, void*)) ;
+EXPORT void f6_V_PSP_IPD(void* p0, struct S_IPD p1, void* p2,  void (*cb)(void*, struct S_IPD, void*)) ;
+EXPORT void f6_V_PSP_IPP(void* p0, struct S_IPP p1, void* p2,  void (*cb)(void*, struct S_IPP, void*)) ;
+EXPORT void f6_V_PSP_FII(void* p0, struct S_FII p1, void* p2,  void (*cb)(void*, struct S_FII, void*)) ;
+EXPORT void f6_V_PSP_FIF(void* p0, struct S_FIF p1, void* p2,  void (*cb)(void*, struct S_FIF, void*)) ;
+EXPORT void f6_V_PSP_FID(void* p0, struct S_FID p1, void* p2,  void (*cb)(void*, struct S_FID, void*)) ;
+EXPORT void f6_V_PSP_FIP(void* p0, struct S_FIP p1, void* p2,  void (*cb)(void*, struct S_FIP, void*)) ;
+EXPORT void f6_V_PSP_FFI(void* p0, struct S_FFI p1, void* p2,  void (*cb)(void*, struct S_FFI, void*)) ;
+EXPORT void f6_V_PSP_FFF(void* p0, struct S_FFF p1, void* p2,  void (*cb)(void*, struct S_FFF, void*)) ;
+EXPORT void f6_V_PSP_FFD(void* p0, struct S_FFD p1, void* p2,  void (*cb)(void*, struct S_FFD, void*)) ;
+EXPORT void f6_V_PSP_FFP(void* p0, struct S_FFP p1, void* p2,  void (*cb)(void*, struct S_FFP, void*)) ;
+EXPORT void f6_V_PSP_FDI(void* p0, struct S_FDI p1, void* p2,  void (*cb)(void*, struct S_FDI, void*)) ;
+EXPORT void f6_V_PSP_FDF(void* p0, struct S_FDF p1, void* p2,  void (*cb)(void*, struct S_FDF, void*)) ;
+EXPORT void f6_V_PSP_FDD(void* p0, struct S_FDD p1, void* p2,  void (*cb)(void*, struct S_FDD, void*)) ;
+EXPORT void f6_V_PSP_FDP(void* p0, struct S_FDP p1, void* p2,  void (*cb)(void*, struct S_FDP, void*)) ;
+EXPORT void f6_V_PSP_FPI(void* p0, struct S_FPI p1, void* p2,  void (*cb)(void*, struct S_FPI, void*)) ;
+EXPORT void f6_V_PSP_FPF(void* p0, struct S_FPF p1, void* p2,  void (*cb)(void*, struct S_FPF, void*)) ;
+EXPORT void f6_V_PSP_FPD(void* p0, struct S_FPD p1, void* p2,  void (*cb)(void*, struct S_FPD, void*)) ;
+EXPORT void f6_V_PSP_FPP(void* p0, struct S_FPP p1, void* p2,  void (*cb)(void*, struct S_FPP, void*)) ;
+EXPORT void f6_V_PSP_DII(void* p0, struct S_DII p1, void* p2,  void (*cb)(void*, struct S_DII, void*)) ;
+EXPORT void f6_V_PSP_DIF(void* p0, struct S_DIF p1, void* p2,  void (*cb)(void*, struct S_DIF, void*)) ;
+EXPORT void f6_V_PSP_DID(void* p0, struct S_DID p1, void* p2,  void (*cb)(void*, struct S_DID, void*)) ;
+EXPORT void f6_V_PSP_DIP(void* p0, struct S_DIP p1, void* p2,  void (*cb)(void*, struct S_DIP, void*)) ;
+EXPORT void f6_V_PSP_DFI(void* p0, struct S_DFI p1, void* p2,  void (*cb)(void*, struct S_DFI, void*)) ;
+EXPORT void f6_V_PSP_DFF(void* p0, struct S_DFF p1, void* p2,  void (*cb)(void*, struct S_DFF, void*)) ;
+EXPORT void f6_V_PSP_DFD(void* p0, struct S_DFD p1, void* p2,  void (*cb)(void*, struct S_DFD, void*)) ;
+EXPORT void f6_V_PSP_DFP(void* p0, struct S_DFP p1, void* p2,  void (*cb)(void*, struct S_DFP, void*)) ;
+EXPORT void f6_V_PSP_DDI(void* p0, struct S_DDI p1, void* p2,  void (*cb)(void*, struct S_DDI, void*)) ;
+EXPORT void f6_V_PSP_DDF(void* p0, struct S_DDF p1, void* p2,  void (*cb)(void*, struct S_DDF, void*)) ;
+EXPORT void f6_V_PSP_DDD(void* p0, struct S_DDD p1, void* p2,  void (*cb)(void*, struct S_DDD, void*)) ;
+EXPORT void f6_V_PSP_DDP(void* p0, struct S_DDP p1, void* p2,  void (*cb)(void*, struct S_DDP, void*)) ;
+EXPORT void f6_V_PSP_DPI(void* p0, struct S_DPI p1, void* p2,  void (*cb)(void*, struct S_DPI, void*)) ;
+EXPORT void f6_V_PSP_DPF(void* p0, struct S_DPF p1, void* p2,  void (*cb)(void*, struct S_DPF, void*)) ;
+EXPORT void f6_V_PSP_DPD(void* p0, struct S_DPD p1, void* p2,  void (*cb)(void*, struct S_DPD, void*)) ;
+EXPORT void f6_V_PSP_DPP(void* p0, struct S_DPP p1, void* p2,  void (*cb)(void*, struct S_DPP, void*)) ;
+EXPORT void f6_V_PSP_PII(void* p0, struct S_PII p1, void* p2,  void (*cb)(void*, struct S_PII, void*)) ;
+EXPORT void f6_V_PSP_PIF(void* p0, struct S_PIF p1, void* p2,  void (*cb)(void*, struct S_PIF, void*)) ;
+EXPORT void f6_V_PSP_PID(void* p0, struct S_PID p1, void* p2,  void (*cb)(void*, struct S_PID, void*)) ;
+EXPORT void f6_V_PSP_PIP(void* p0, struct S_PIP p1, void* p2,  void (*cb)(void*, struct S_PIP, void*)) ;
+EXPORT void f6_V_PSP_PFI(void* p0, struct S_PFI p1, void* p2,  void (*cb)(void*, struct S_PFI, void*)) ;
+EXPORT void f6_V_PSP_PFF(void* p0, struct S_PFF p1, void* p2,  void (*cb)(void*, struct S_PFF, void*)) ;
+EXPORT void f6_V_PSP_PFD(void* p0, struct S_PFD p1, void* p2,  void (*cb)(void*, struct S_PFD, void*)) ;
+EXPORT void f6_V_PSP_PFP(void* p0, struct S_PFP p1, void* p2,  void (*cb)(void*, struct S_PFP, void*)) ;
+EXPORT void f6_V_PSP_PDI(void* p0, struct S_PDI p1, void* p2,  void (*cb)(void*, struct S_PDI, void*)) ;
+EXPORT void f6_V_PSP_PDF(void* p0, struct S_PDF p1, void* p2,  void (*cb)(void*, struct S_PDF, void*)) ;
+EXPORT void f6_V_PSP_PDD(void* p0, struct S_PDD p1, void* p2,  void (*cb)(void*, struct S_PDD, void*)) ;
+EXPORT void f6_V_PSP_PDP(void* p0, struct S_PDP p1, void* p2,  void (*cb)(void*, struct S_PDP, void*)) ;
+EXPORT void f6_V_PSP_PPI(void* p0, struct S_PPI p1, void* p2,  void (*cb)(void*, struct S_PPI, void*)) ;
+EXPORT void f6_V_PSP_PPF(void* p0, struct S_PPF p1, void* p2,  void (*cb)(void*, struct S_PPF, void*)) ;
+EXPORT void f6_V_PSP_PPD(void* p0, struct S_PPD p1, void* p2,  void (*cb)(void*, struct S_PPD, void*)) ;
+EXPORT void f6_V_PSP_PPP(void* p0, struct S_PPP p1, void* p2,  void (*cb)(void*, struct S_PPP, void*)) ;
+EXPORT void f6_V_PSS_I(void* p0, struct S_I p1, struct S_I p2,  void (*cb)(void*, struct S_I, struct S_I)) ;
+EXPORT void f6_V_PSS_F(void* p0, struct S_F p1, struct S_F p2,  void (*cb)(void*, struct S_F, struct S_F)) ;
+EXPORT void f6_V_PSS_D(void* p0, struct S_D p1, struct S_D p2,  void (*cb)(void*, struct S_D, struct S_D)) ;
+EXPORT void f6_V_PSS_P(void* p0, struct S_P p1, struct S_P p2,  void (*cb)(void*, struct S_P, struct S_P)) ;
+EXPORT void f6_V_PSS_II(void* p0, struct S_II p1, struct S_II p2,  void (*cb)(void*, struct S_II, struct S_II)) ;
+EXPORT void f6_V_PSS_IF(void* p0, struct S_IF p1, struct S_IF p2,  void (*cb)(void*, struct S_IF, struct S_IF)) ;
+EXPORT void f6_V_PSS_ID(void* p0, struct S_ID p1, struct S_ID p2,  void (*cb)(void*, struct S_ID, struct S_ID)) ;
+EXPORT void f6_V_PSS_IP(void* p0, struct S_IP p1, struct S_IP p2,  void (*cb)(void*, struct S_IP, struct S_IP)) ;
+EXPORT void f6_V_PSS_FI(void* p0, struct S_FI p1, struct S_FI p2,  void (*cb)(void*, struct S_FI, struct S_FI)) ;
+EXPORT void f6_V_PSS_FF(void* p0, struct S_FF p1, struct S_FF p2,  void (*cb)(void*, struct S_FF, struct S_FF)) ;
+EXPORT void f6_V_PSS_FD(void* p0, struct S_FD p1, struct S_FD p2,  void (*cb)(void*, struct S_FD, struct S_FD)) ;
+EXPORT void f6_V_PSS_FP(void* p0, struct S_FP p1, struct S_FP p2,  void (*cb)(void*, struct S_FP, struct S_FP)) ;
+EXPORT void f6_V_PSS_DI(void* p0, struct S_DI p1, struct S_DI p2,  void (*cb)(void*, struct S_DI, struct S_DI)) ;
+EXPORT void f6_V_PSS_DF(void* p0, struct S_DF p1, struct S_DF p2,  void (*cb)(void*, struct S_DF, struct S_DF)) ;
+EXPORT void f6_V_PSS_DD(void* p0, struct S_DD p1, struct S_DD p2,  void (*cb)(void*, struct S_DD, struct S_DD)) ;
+EXPORT void f6_V_PSS_DP(void* p0, struct S_DP p1, struct S_DP p2,  void (*cb)(void*, struct S_DP, struct S_DP)) ;
+EXPORT void f6_V_PSS_PI(void* p0, struct S_PI p1, struct S_PI p2,  void (*cb)(void*, struct S_PI, struct S_PI)) ;
+EXPORT void f6_V_PSS_PF(void* p0, struct S_PF p1, struct S_PF p2,  void (*cb)(void*, struct S_PF, struct S_PF)) ;
+EXPORT void f6_V_PSS_PD(void* p0, struct S_PD p1, struct S_PD p2,  void (*cb)(void*, struct S_PD, struct S_PD)) ;
+EXPORT void f6_V_PSS_PP(void* p0, struct S_PP p1, struct S_PP p2,  void (*cb)(void*, struct S_PP, struct S_PP)) ;
+EXPORT void f6_V_PSS_III(void* p0, struct S_III p1, struct S_III p2,  void (*cb)(void*, struct S_III, struct S_III)) ;
+EXPORT void f6_V_PSS_IIF(void* p0, struct S_IIF p1, struct S_IIF p2,  void (*cb)(void*, struct S_IIF, struct S_IIF)) ;
+EXPORT void f6_V_PSS_IID(void* p0, struct S_IID p1, struct S_IID p2,  void (*cb)(void*, struct S_IID, struct S_IID)) ;
+EXPORT void f6_V_PSS_IIP(void* p0, struct S_IIP p1, struct S_IIP p2,  void (*cb)(void*, struct S_IIP, struct S_IIP)) ;
+EXPORT void f6_V_PSS_IFI(void* p0, struct S_IFI p1, struct S_IFI p2,  void (*cb)(void*, struct S_IFI, struct S_IFI)) ;
+EXPORT void f6_V_PSS_IFF(void* p0, struct S_IFF p1, struct S_IFF p2,  void (*cb)(void*, struct S_IFF, struct S_IFF)) ;
+EXPORT void f6_V_PSS_IFD(void* p0, struct S_IFD p1, struct S_IFD p2,  void (*cb)(void*, struct S_IFD, struct S_IFD)) ;
+EXPORT void f6_V_PSS_IFP(void* p0, struct S_IFP p1, struct S_IFP p2,  void (*cb)(void*, struct S_IFP, struct S_IFP)) ;
+EXPORT void f6_V_PSS_IDI(void* p0, struct S_IDI p1, struct S_IDI p2,  void (*cb)(void*, struct S_IDI, struct S_IDI)) ;
+EXPORT void f6_V_PSS_IDF(void* p0, struct S_IDF p1, struct S_IDF p2,  void (*cb)(void*, struct S_IDF, struct S_IDF)) ;
+EXPORT void f6_V_PSS_IDD(void* p0, struct S_IDD p1, struct S_IDD p2,  void (*cb)(void*, struct S_IDD, struct S_IDD)) ;
+EXPORT void f6_V_PSS_IDP(void* p0, struct S_IDP p1, struct S_IDP p2,  void (*cb)(void*, struct S_IDP, struct S_IDP)) ;
+EXPORT void f6_V_PSS_IPI(void* p0, struct S_IPI p1, struct S_IPI p2,  void (*cb)(void*, struct S_IPI, struct S_IPI)) ;
+EXPORT void f6_V_PSS_IPF(void* p0, struct S_IPF p1, struct S_IPF p2,  void (*cb)(void*, struct S_IPF, struct S_IPF)) ;
+EXPORT void f6_V_PSS_IPD(void* p0, struct S_IPD p1, struct S_IPD p2,  void (*cb)(void*, struct S_IPD, struct S_IPD)) ;
+EXPORT void f6_V_PSS_IPP(void* p0, struct S_IPP p1, struct S_IPP p2,  void (*cb)(void*, struct S_IPP, struct S_IPP)) ;
+EXPORT void f6_V_PSS_FII(void* p0, struct S_FII p1, struct S_FII p2,  void (*cb)(void*, struct S_FII, struct S_FII)) ;
+EXPORT void f6_V_PSS_FIF(void* p0, struct S_FIF p1, struct S_FIF p2,  void (*cb)(void*, struct S_FIF, struct S_FIF)) ;
+EXPORT void f6_V_PSS_FID(void* p0, struct S_FID p1, struct S_FID p2,  void (*cb)(void*, struct S_FID, struct S_FID)) ;
+EXPORT void f6_V_PSS_FIP(void* p0, struct S_FIP p1, struct S_FIP p2,  void (*cb)(void*, struct S_FIP, struct S_FIP)) ;
+EXPORT void f6_V_PSS_FFI(void* p0, struct S_FFI p1, struct S_FFI p2,  void (*cb)(void*, struct S_FFI, struct S_FFI)) ;
+EXPORT void f6_V_PSS_FFF(void* p0, struct S_FFF p1, struct S_FFF p2,  void (*cb)(void*, struct S_FFF, struct S_FFF)) ;
+EXPORT void f6_V_PSS_FFD(void* p0, struct S_FFD p1, struct S_FFD p2,  void (*cb)(void*, struct S_FFD, struct S_FFD)) ;
+EXPORT void f6_V_PSS_FFP(void* p0, struct S_FFP p1, struct S_FFP p2,  void (*cb)(void*, struct S_FFP, struct S_FFP)) ;
+EXPORT void f6_V_PSS_FDI(void* p0, struct S_FDI p1, struct S_FDI p2,  void (*cb)(void*, struct S_FDI, struct S_FDI)) ;
+EXPORT void f6_V_PSS_FDF(void* p0, struct S_FDF p1, struct S_FDF p2,  void (*cb)(void*, struct S_FDF, struct S_FDF)) ;
+EXPORT void f6_V_PSS_FDD(void* p0, struct S_FDD p1, struct S_FDD p2,  void (*cb)(void*, struct S_FDD, struct S_FDD)) ;
+EXPORT void f6_V_PSS_FDP(void* p0, struct S_FDP p1, struct S_FDP p2,  void (*cb)(void*, struct S_FDP, struct S_FDP)) ;
+EXPORT void f6_V_PSS_FPI(void* p0, struct S_FPI p1, struct S_FPI p2,  void (*cb)(void*, struct S_FPI, struct S_FPI)) ;
+EXPORT void f6_V_PSS_FPF(void* p0, struct S_FPF p1, struct S_FPF p2,  void (*cb)(void*, struct S_FPF, struct S_FPF)) ;
+EXPORT void f6_V_PSS_FPD(void* p0, struct S_FPD p1, struct S_FPD p2,  void (*cb)(void*, struct S_FPD, struct S_FPD)) ;
+EXPORT void f6_V_PSS_FPP(void* p0, struct S_FPP p1, struct S_FPP p2,  void (*cb)(void*, struct S_FPP, struct S_FPP)) ;
+EXPORT void f6_V_PSS_DII(void* p0, struct S_DII p1, struct S_DII p2,  void (*cb)(void*, struct S_DII, struct S_DII)) ;
+EXPORT void f6_V_PSS_DIF(void* p0, struct S_DIF p1, struct S_DIF p2,  void (*cb)(void*, struct S_DIF, struct S_DIF)) ;
+EXPORT void f6_V_PSS_DID(void* p0, struct S_DID p1, struct S_DID p2,  void (*cb)(void*, struct S_DID, struct S_DID)) ;
+EXPORT void f6_V_PSS_DIP(void* p0, struct S_DIP p1, struct S_DIP p2,  void (*cb)(void*, struct S_DIP, struct S_DIP)) ;
+EXPORT void f6_V_PSS_DFI(void* p0, struct S_DFI p1, struct S_DFI p2,  void (*cb)(void*, struct S_DFI, struct S_DFI)) ;
+EXPORT void f6_V_PSS_DFF(void* p0, struct S_DFF p1, struct S_DFF p2,  void (*cb)(void*, struct S_DFF, struct S_DFF)) ;
+EXPORT void f6_V_PSS_DFD(void* p0, struct S_DFD p1, struct S_DFD p2,  void (*cb)(void*, struct S_DFD, struct S_DFD)) ;
+EXPORT void f6_V_PSS_DFP(void* p0, struct S_DFP p1, struct S_DFP p2,  void (*cb)(void*, struct S_DFP, struct S_DFP)) ;
+EXPORT void f6_V_PSS_DDI(void* p0, struct S_DDI p1, struct S_DDI p2,  void (*cb)(void*, struct S_DDI, struct S_DDI)) ;
+EXPORT void f6_V_PSS_DDF(void* p0, struct S_DDF p1, struct S_DDF p2,  void (*cb)(void*, struct S_DDF, struct S_DDF)) ;
+EXPORT void f6_V_PSS_DDD(void* p0, struct S_DDD p1, struct S_DDD p2,  void (*cb)(void*, struct S_DDD, struct S_DDD)) ;
+EXPORT void f6_V_PSS_DDP(void* p0, struct S_DDP p1, struct S_DDP p2,  void (*cb)(void*, struct S_DDP, struct S_DDP)) ;
+EXPORT void f6_V_PSS_DPI(void* p0, struct S_DPI p1, struct S_DPI p2,  void (*cb)(void*, struct S_DPI, struct S_DPI)) ;
+EXPORT void f6_V_PSS_DPF(void* p0, struct S_DPF p1, struct S_DPF p2,  void (*cb)(void*, struct S_DPF, struct S_DPF)) ;
+EXPORT void f6_V_PSS_DPD(void* p0, struct S_DPD p1, struct S_DPD p2,  void (*cb)(void*, struct S_DPD, struct S_DPD)) ;
+EXPORT void f6_V_PSS_DPP(void* p0, struct S_DPP p1, struct S_DPP p2,  void (*cb)(void*, struct S_DPP, struct S_DPP)) ;
+EXPORT void f6_V_PSS_PII(void* p0, struct S_PII p1, struct S_PII p2,  void (*cb)(void*, struct S_PII, struct S_PII)) ;
+EXPORT void f6_V_PSS_PIF(void* p0, struct S_PIF p1, struct S_PIF p2,  void (*cb)(void*, struct S_PIF, struct S_PIF)) ;
+EXPORT void f6_V_PSS_PID(void* p0, struct S_PID p1, struct S_PID p2,  void (*cb)(void*, struct S_PID, struct S_PID)) ;
+EXPORT void f6_V_PSS_PIP(void* p0, struct S_PIP p1, struct S_PIP p2,  void (*cb)(void*, struct S_PIP, struct S_PIP)) ;
+EXPORT void f6_V_PSS_PFI(void* p0, struct S_PFI p1, struct S_PFI p2,  void (*cb)(void*, struct S_PFI, struct S_PFI)) ;
+EXPORT void f6_V_PSS_PFF(void* p0, struct S_PFF p1, struct S_PFF p2,  void (*cb)(void*, struct S_PFF, struct S_PFF)) ;
+EXPORT void f6_V_PSS_PFD(void* p0, struct S_PFD p1, struct S_PFD p2,  void (*cb)(void*, struct S_PFD, struct S_PFD)) ;
+EXPORT void f6_V_PSS_PFP(void* p0, struct S_PFP p1, struct S_PFP p2,  void (*cb)(void*, struct S_PFP, struct S_PFP)) ;
+EXPORT void f6_V_PSS_PDI(void* p0, struct S_PDI p1, struct S_PDI p2,  void (*cb)(void*, struct S_PDI, struct S_PDI)) ;
+EXPORT void f6_V_PSS_PDF(void* p0, struct S_PDF p1, struct S_PDF p2,  void (*cb)(void*, struct S_PDF, struct S_PDF)) ;
+EXPORT void f6_V_PSS_PDD(void* p0, struct S_PDD p1, struct S_PDD p2,  void (*cb)(void*, struct S_PDD, struct S_PDD)) ;
+EXPORT void f6_V_PSS_PDP(void* p0, struct S_PDP p1, struct S_PDP p2,  void (*cb)(void*, struct S_PDP, struct S_PDP)) ;
+EXPORT void f6_V_PSS_PPI(void* p0, struct S_PPI p1, struct S_PPI p2,  void (*cb)(void*, struct S_PPI, struct S_PPI)) ;
+EXPORT void f6_V_PSS_PPF(void* p0, struct S_PPF p1, struct S_PPF p2,  void (*cb)(void*, struct S_PPF, struct S_PPF)) ;
+EXPORT void f6_V_PSS_PPD(void* p0, struct S_PPD p1, struct S_PPD p2,  void (*cb)(void*, struct S_PPD, struct S_PPD)) ;
+EXPORT void f6_V_PSS_PPP(void* p0, struct S_PPP p1, struct S_PPP p2,  void (*cb)(void*, struct S_PPP, struct S_PPP)) ;
+EXPORT void f6_V_SII_I(struct S_I p0, int p1, int p2,  void (*cb)(struct S_I, int, int)) ;
+EXPORT void f6_V_SII_F(struct S_F p0, int p1, int p2,  void (*cb)(struct S_F, int, int)) ;
+EXPORT void f6_V_SII_D(struct S_D p0, int p1, int p2,  void (*cb)(struct S_D, int, int)) ;
+EXPORT void f6_V_SII_P(struct S_P p0, int p1, int p2,  void (*cb)(struct S_P, int, int)) ;
+EXPORT void f6_V_SII_II(struct S_II p0, int p1, int p2,  void (*cb)(struct S_II, int, int)) ;
+EXPORT void f6_V_SII_IF(struct S_IF p0, int p1, int p2,  void (*cb)(struct S_IF, int, int)) ;
+EXPORT void f6_V_SII_ID(struct S_ID p0, int p1, int p2,  void (*cb)(struct S_ID, int, int)) ;
+EXPORT void f6_V_SII_IP(struct S_IP p0, int p1, int p2,  void (*cb)(struct S_IP, int, int)) ;
+EXPORT void f6_V_SII_FI(struct S_FI p0, int p1, int p2,  void (*cb)(struct S_FI, int, int)) ;
+EXPORT void f6_V_SII_FF(struct S_FF p0, int p1, int p2,  void (*cb)(struct S_FF, int, int)) ;
+EXPORT void f6_V_SII_FD(struct S_FD p0, int p1, int p2,  void (*cb)(struct S_FD, int, int)) ;
+EXPORT void f6_V_SII_FP(struct S_FP p0, int p1, int p2,  void (*cb)(struct S_FP, int, int)) ;
+EXPORT void f6_V_SII_DI(struct S_DI p0, int p1, int p2,  void (*cb)(struct S_DI, int, int)) ;
+EXPORT void f6_V_SII_DF(struct S_DF p0, int p1, int p2,  void (*cb)(struct S_DF, int, int)) ;
+EXPORT void f6_V_SII_DD(struct S_DD p0, int p1, int p2,  void (*cb)(struct S_DD, int, int)) ;
+EXPORT void f6_V_SII_DP(struct S_DP p0, int p1, int p2,  void (*cb)(struct S_DP, int, int)) ;
+EXPORT void f6_V_SII_PI(struct S_PI p0, int p1, int p2,  void (*cb)(struct S_PI, int, int)) ;
+EXPORT void f6_V_SII_PF(struct S_PF p0, int p1, int p2,  void (*cb)(struct S_PF, int, int)) ;
+EXPORT void f6_V_SII_PD(struct S_PD p0, int p1, int p2,  void (*cb)(struct S_PD, int, int)) ;
+EXPORT void f6_V_SII_PP(struct S_PP p0, int p1, int p2,  void (*cb)(struct S_PP, int, int)) ;
+EXPORT void f6_V_SII_III(struct S_III p0, int p1, int p2,  void (*cb)(struct S_III, int, int)) ;
+EXPORT void f6_V_SII_IIF(struct S_IIF p0, int p1, int p2,  void (*cb)(struct S_IIF, int, int)) ;
+EXPORT void f6_V_SII_IID(struct S_IID p0, int p1, int p2,  void (*cb)(struct S_IID, int, int)) ;
+EXPORT void f6_V_SII_IIP(struct S_IIP p0, int p1, int p2,  void (*cb)(struct S_IIP, int, int)) ;
+EXPORT void f6_V_SII_IFI(struct S_IFI p0, int p1, int p2,  void (*cb)(struct S_IFI, int, int)) ;
+EXPORT void f6_V_SII_IFF(struct S_IFF p0, int p1, int p2,  void (*cb)(struct S_IFF, int, int)) ;
+EXPORT void f6_V_SII_IFD(struct S_IFD p0, int p1, int p2,  void (*cb)(struct S_IFD, int, int)) ;
+EXPORT void f6_V_SII_IFP(struct S_IFP p0, int p1, int p2,  void (*cb)(struct S_IFP, int, int)) ;
+EXPORT void f6_V_SII_IDI(struct S_IDI p0, int p1, int p2,  void (*cb)(struct S_IDI, int, int)) ;
+EXPORT void f6_V_SII_IDF(struct S_IDF p0, int p1, int p2,  void (*cb)(struct S_IDF, int, int)) ;
+EXPORT void f6_V_SII_IDD(struct S_IDD p0, int p1, int p2,  void (*cb)(struct S_IDD, int, int)) ;
+EXPORT void f6_V_SII_IDP(struct S_IDP p0, int p1, int p2,  void (*cb)(struct S_IDP, int, int)) ;
+EXPORT void f6_V_SII_IPI(struct S_IPI p0, int p1, int p2,  void (*cb)(struct S_IPI, int, int)) ;
+EXPORT void f6_V_SII_IPF(struct S_IPF p0, int p1, int p2,  void (*cb)(struct S_IPF, int, int)) ;
+EXPORT void f6_V_SII_IPD(struct S_IPD p0, int p1, int p2,  void (*cb)(struct S_IPD, int, int)) ;
+EXPORT void f6_V_SII_IPP(struct S_IPP p0, int p1, int p2,  void (*cb)(struct S_IPP, int, int)) ;
+EXPORT void f6_V_SII_FII(struct S_FII p0, int p1, int p2,  void (*cb)(struct S_FII, int, int)) ;
+EXPORT void f6_V_SII_FIF(struct S_FIF p0, int p1, int p2,  void (*cb)(struct S_FIF, int, int)) ;
+EXPORT void f6_V_SII_FID(struct S_FID p0, int p1, int p2,  void (*cb)(struct S_FID, int, int)) ;
+EXPORT void f6_V_SII_FIP(struct S_FIP p0, int p1, int p2,  void (*cb)(struct S_FIP, int, int)) ;
+EXPORT void f6_V_SII_FFI(struct S_FFI p0, int p1, int p2,  void (*cb)(struct S_FFI, int, int)) ;
+EXPORT void f6_V_SII_FFF(struct S_FFF p0, int p1, int p2,  void (*cb)(struct S_FFF, int, int)) ;
+EXPORT void f6_V_SII_FFD(struct S_FFD p0, int p1, int p2,  void (*cb)(struct S_FFD, int, int)) ;
+EXPORT void f6_V_SII_FFP(struct S_FFP p0, int p1, int p2,  void (*cb)(struct S_FFP, int, int)) ;
+EXPORT void f6_V_SII_FDI(struct S_FDI p0, int p1, int p2,  void (*cb)(struct S_FDI, int, int)) ;
+EXPORT void f6_V_SII_FDF(struct S_FDF p0, int p1, int p2,  void (*cb)(struct S_FDF, int, int)) ;
+EXPORT void f6_V_SII_FDD(struct S_FDD p0, int p1, int p2,  void (*cb)(struct S_FDD, int, int)) ;
+EXPORT void f6_V_SII_FDP(struct S_FDP p0, int p1, int p2,  void (*cb)(struct S_FDP, int, int)) ;
+EXPORT void f6_V_SII_FPI(struct S_FPI p0, int p1, int p2,  void (*cb)(struct S_FPI, int, int)) ;
+EXPORT void f6_V_SII_FPF(struct S_FPF p0, int p1, int p2,  void (*cb)(struct S_FPF, int, int)) ;
+EXPORT void f6_V_SII_FPD(struct S_FPD p0, int p1, int p2,  void (*cb)(struct S_FPD, int, int)) ;
+EXPORT void f6_V_SII_FPP(struct S_FPP p0, int p1, int p2,  void (*cb)(struct S_FPP, int, int)) ;
+EXPORT void f6_V_SII_DII(struct S_DII p0, int p1, int p2,  void (*cb)(struct S_DII, int, int)) ;
+EXPORT void f6_V_SII_DIF(struct S_DIF p0, int p1, int p2,  void (*cb)(struct S_DIF, int, int)) ;
+EXPORT void f6_V_SII_DID(struct S_DID p0, int p1, int p2,  void (*cb)(struct S_DID, int, int)) ;
+EXPORT void f6_V_SII_DIP(struct S_DIP p0, int p1, int p2,  void (*cb)(struct S_DIP, int, int)) ;
+EXPORT void f6_V_SII_DFI(struct S_DFI p0, int p1, int p2,  void (*cb)(struct S_DFI, int, int)) ;
+EXPORT void f6_V_SII_DFF(struct S_DFF p0, int p1, int p2,  void (*cb)(struct S_DFF, int, int)) ;
+EXPORT void f6_V_SII_DFD(struct S_DFD p0, int p1, int p2,  void (*cb)(struct S_DFD, int, int)) ;
+EXPORT void f6_V_SII_DFP(struct S_DFP p0, int p1, int p2,  void (*cb)(struct S_DFP, int, int)) ;
+EXPORT void f6_V_SII_DDI(struct S_DDI p0, int p1, int p2,  void (*cb)(struct S_DDI, int, int)) ;
+EXPORT void f6_V_SII_DDF(struct S_DDF p0, int p1, int p2,  void (*cb)(struct S_DDF, int, int)) ;
+EXPORT void f6_V_SII_DDD(struct S_DDD p0, int p1, int p2,  void (*cb)(struct S_DDD, int, int)) ;
+EXPORT void f6_V_SII_DDP(struct S_DDP p0, int p1, int p2,  void (*cb)(struct S_DDP, int, int)) ;
+EXPORT void f6_V_SII_DPI(struct S_DPI p0, int p1, int p2,  void (*cb)(struct S_DPI, int, int)) ;
+EXPORT void f6_V_SII_DPF(struct S_DPF p0, int p1, int p2,  void (*cb)(struct S_DPF, int, int)) ;
+EXPORT void f6_V_SII_DPD(struct S_DPD p0, int p1, int p2,  void (*cb)(struct S_DPD, int, int)) ;
+EXPORT void f6_V_SII_DPP(struct S_DPP p0, int p1, int p2,  void (*cb)(struct S_DPP, int, int)) ;
+EXPORT void f6_V_SII_PII(struct S_PII p0, int p1, int p2,  void (*cb)(struct S_PII, int, int)) ;
+EXPORT void f6_V_SII_PIF(struct S_PIF p0, int p1, int p2,  void (*cb)(struct S_PIF, int, int)) ;
+EXPORT void f6_V_SII_PID(struct S_PID p0, int p1, int p2,  void (*cb)(struct S_PID, int, int)) ;
+EXPORT void f6_V_SII_PIP(struct S_PIP p0, int p1, int p2,  void (*cb)(struct S_PIP, int, int)) ;
+EXPORT void f6_V_SII_PFI(struct S_PFI p0, int p1, int p2,  void (*cb)(struct S_PFI, int, int)) ;
+EXPORT void f6_V_SII_PFF(struct S_PFF p0, int p1, int p2,  void (*cb)(struct S_PFF, int, int)) ;
+EXPORT void f6_V_SII_PFD(struct S_PFD p0, int p1, int p2,  void (*cb)(struct S_PFD, int, int)) ;
+EXPORT void f6_V_SII_PFP(struct S_PFP p0, int p1, int p2,  void (*cb)(struct S_PFP, int, int)) ;
+EXPORT void f6_V_SII_PDI(struct S_PDI p0, int p1, int p2,  void (*cb)(struct S_PDI, int, int)) ;
+EXPORT void f6_V_SII_PDF(struct S_PDF p0, int p1, int p2,  void (*cb)(struct S_PDF, int, int)) ;
+EXPORT void f6_V_SII_PDD(struct S_PDD p0, int p1, int p2,  void (*cb)(struct S_PDD, int, int)) ;
+EXPORT void f6_V_SII_PDP(struct S_PDP p0, int p1, int p2,  void (*cb)(struct S_PDP, int, int)) ;
+EXPORT void f6_V_SII_PPI(struct S_PPI p0, int p1, int p2,  void (*cb)(struct S_PPI, int, int)) ;
+EXPORT void f6_V_SII_PPF(struct S_PPF p0, int p1, int p2,  void (*cb)(struct S_PPF, int, int)) ;
+EXPORT void f6_V_SII_PPD(struct S_PPD p0, int p1, int p2,  void (*cb)(struct S_PPD, int, int)) ;
+EXPORT void f6_V_SII_PPP(struct S_PPP p0, int p1, int p2,  void (*cb)(struct S_PPP, int, int)) ;
+EXPORT void f6_V_SIF_I(struct S_I p0, int p1, float p2,  void (*cb)(struct S_I, int, float)) ;
+EXPORT void f6_V_SIF_F(struct S_F p0, int p1, float p2,  void (*cb)(struct S_F, int, float)) ;
+EXPORT void f6_V_SIF_D(struct S_D p0, int p1, float p2,  void (*cb)(struct S_D, int, float)) ;
+EXPORT void f6_V_SIF_P(struct S_P p0, int p1, float p2,  void (*cb)(struct S_P, int, float)) ;
+EXPORT void f6_V_SIF_II(struct S_II p0, int p1, float p2,  void (*cb)(struct S_II, int, float)) ;
+EXPORT void f6_V_SIF_IF(struct S_IF p0, int p1, float p2,  void (*cb)(struct S_IF, int, float)) ;
+EXPORT void f6_V_SIF_ID(struct S_ID p0, int p1, float p2,  void (*cb)(struct S_ID, int, float)) ;
+EXPORT void f6_V_SIF_IP(struct S_IP p0, int p1, float p2,  void (*cb)(struct S_IP, int, float)) ;
+EXPORT void f6_V_SIF_FI(struct S_FI p0, int p1, float p2,  void (*cb)(struct S_FI, int, float)) ;
+EXPORT void f6_V_SIF_FF(struct S_FF p0, int p1, float p2,  void (*cb)(struct S_FF, int, float)) ;
+EXPORT void f6_V_SIF_FD(struct S_FD p0, int p1, float p2,  void (*cb)(struct S_FD, int, float)) ;
+EXPORT void f6_V_SIF_FP(struct S_FP p0, int p1, float p2,  void (*cb)(struct S_FP, int, float)) ;
+EXPORT void f6_V_SIF_DI(struct S_DI p0, int p1, float p2,  void (*cb)(struct S_DI, int, float)) ;
+EXPORT void f6_V_SIF_DF(struct S_DF p0, int p1, float p2,  void (*cb)(struct S_DF, int, float)) ;
+EXPORT void f6_V_SIF_DD(struct S_DD p0, int p1, float p2,  void (*cb)(struct S_DD, int, float)) ;
+EXPORT void f6_V_SIF_DP(struct S_DP p0, int p1, float p2,  void (*cb)(struct S_DP, int, float)) ;
+EXPORT void f6_V_SIF_PI(struct S_PI p0, int p1, float p2,  void (*cb)(struct S_PI, int, float)) ;
+EXPORT void f6_V_SIF_PF(struct S_PF p0, int p1, float p2,  void (*cb)(struct S_PF, int, float)) ;
+EXPORT void f6_V_SIF_PD(struct S_PD p0, int p1, float p2,  void (*cb)(struct S_PD, int, float)) ;
+EXPORT void f6_V_SIF_PP(struct S_PP p0, int p1, float p2,  void (*cb)(struct S_PP, int, float)) ;
+EXPORT void f6_V_SIF_III(struct S_III p0, int p1, float p2,  void (*cb)(struct S_III, int, float)) ;
+EXPORT void f6_V_SIF_IIF(struct S_IIF p0, int p1, float p2,  void (*cb)(struct S_IIF, int, float)) ;
+EXPORT void f6_V_SIF_IID(struct S_IID p0, int p1, float p2,  void (*cb)(struct S_IID, int, float)) ;
+EXPORT void f6_V_SIF_IIP(struct S_IIP p0, int p1, float p2,  void (*cb)(struct S_IIP, int, float)) ;
+EXPORT void f6_V_SIF_IFI(struct S_IFI p0, int p1, float p2,  void (*cb)(struct S_IFI, int, float)) ;
+EXPORT void f6_V_SIF_IFF(struct S_IFF p0, int p1, float p2,  void (*cb)(struct S_IFF, int, float)) ;
+EXPORT void f6_V_SIF_IFD(struct S_IFD p0, int p1, float p2,  void (*cb)(struct S_IFD, int, float)) ;
+EXPORT void f6_V_SIF_IFP(struct S_IFP p0, int p1, float p2,  void (*cb)(struct S_IFP, int, float)) ;
+EXPORT void f6_V_SIF_IDI(struct S_IDI p0, int p1, float p2,  void (*cb)(struct S_IDI, int, float)) ;
+EXPORT void f6_V_SIF_IDF(struct S_IDF p0, int p1, float p2,  void (*cb)(struct S_IDF, int, float)) ;
+EXPORT void f6_V_SIF_IDD(struct S_IDD p0, int p1, float p2,  void (*cb)(struct S_IDD, int, float)) ;
+EXPORT void f6_V_SIF_IDP(struct S_IDP p0, int p1, float p2,  void (*cb)(struct S_IDP, int, float)) ;
+EXPORT void f6_V_SIF_IPI(struct S_IPI p0, int p1, float p2,  void (*cb)(struct S_IPI, int, float)) ;
+EXPORT void f6_V_SIF_IPF(struct S_IPF p0, int p1, float p2,  void (*cb)(struct S_IPF, int, float)) ;
+EXPORT void f6_V_SIF_IPD(struct S_IPD p0, int p1, float p2,  void (*cb)(struct S_IPD, int, float)) ;
+EXPORT void f6_V_SIF_IPP(struct S_IPP p0, int p1, float p2,  void (*cb)(struct S_IPP, int, float)) ;
+EXPORT void f6_V_SIF_FII(struct S_FII p0, int p1, float p2,  void (*cb)(struct S_FII, int, float)) ;
+EXPORT void f6_V_SIF_FIF(struct S_FIF p0, int p1, float p2,  void (*cb)(struct S_FIF, int, float)) ;
+EXPORT void f6_V_SIF_FID(struct S_FID p0, int p1, float p2,  void (*cb)(struct S_FID, int, float)) ;
+EXPORT void f6_V_SIF_FIP(struct S_FIP p0, int p1, float p2,  void (*cb)(struct S_FIP, int, float)) ;
+EXPORT void f6_V_SIF_FFI(struct S_FFI p0, int p1, float p2,  void (*cb)(struct S_FFI, int, float)) ;
+EXPORT void f6_V_SIF_FFF(struct S_FFF p0, int p1, float p2,  void (*cb)(struct S_FFF, int, float)) ;
+EXPORT void f6_V_SIF_FFD(struct S_FFD p0, int p1, float p2,  void (*cb)(struct S_FFD, int, float)) ;
+EXPORT void f6_V_SIF_FFP(struct S_FFP p0, int p1, float p2,  void (*cb)(struct S_FFP, int, float)) ;
+EXPORT void f6_V_SIF_FDI(struct S_FDI p0, int p1, float p2,  void (*cb)(struct S_FDI, int, float)) ;
+EXPORT void f6_V_SIF_FDF(struct S_FDF p0, int p1, float p2,  void (*cb)(struct S_FDF, int, float)) ;
+EXPORT void f6_V_SIF_FDD(struct S_FDD p0, int p1, float p2,  void (*cb)(struct S_FDD, int, float)) ;
+EXPORT void f6_V_SIF_FDP(struct S_FDP p0, int p1, float p2,  void (*cb)(struct S_FDP, int, float)) ;
+EXPORT void f6_V_SIF_FPI(struct S_FPI p0, int p1, float p2,  void (*cb)(struct S_FPI, int, float)) ;
+EXPORT void f6_V_SIF_FPF(struct S_FPF p0, int p1, float p2,  void (*cb)(struct S_FPF, int, float)) ;
+EXPORT void f6_V_SIF_FPD(struct S_FPD p0, int p1, float p2,  void (*cb)(struct S_FPD, int, float)) ;
+EXPORT void f6_V_SIF_FPP(struct S_FPP p0, int p1, float p2,  void (*cb)(struct S_FPP, int, float)) ;
+EXPORT void f6_V_SIF_DII(struct S_DII p0, int p1, float p2,  void (*cb)(struct S_DII, int, float)) ;
+EXPORT void f6_V_SIF_DIF(struct S_DIF p0, int p1, float p2,  void (*cb)(struct S_DIF, int, float)) ;
+EXPORT void f6_V_SIF_DID(struct S_DID p0, int p1, float p2,  void (*cb)(struct S_DID, int, float)) ;
+EXPORT void f6_V_SIF_DIP(struct S_DIP p0, int p1, float p2,  void (*cb)(struct S_DIP, int, float)) ;
+EXPORT void f6_V_SIF_DFI(struct S_DFI p0, int p1, float p2,  void (*cb)(struct S_DFI, int, float)) ;
+EXPORT void f6_V_SIF_DFF(struct S_DFF p0, int p1, float p2,  void (*cb)(struct S_DFF, int, float)) ;
+EXPORT void f6_V_SIF_DFD(struct S_DFD p0, int p1, float p2,  void (*cb)(struct S_DFD, int, float)) ;
+EXPORT void f6_V_SIF_DFP(struct S_DFP p0, int p1, float p2,  void (*cb)(struct S_DFP, int, float)) ;
+EXPORT void f6_V_SIF_DDI(struct S_DDI p0, int p1, float p2,  void (*cb)(struct S_DDI, int, float)) ;
+EXPORT void f6_V_SIF_DDF(struct S_DDF p0, int p1, float p2,  void (*cb)(struct S_DDF, int, float)) ;
+EXPORT void f6_V_SIF_DDD(struct S_DDD p0, int p1, float p2,  void (*cb)(struct S_DDD, int, float)) ;
+EXPORT void f6_V_SIF_DDP(struct S_DDP p0, int p1, float p2,  void (*cb)(struct S_DDP, int, float)) ;
+EXPORT void f6_V_SIF_DPI(struct S_DPI p0, int p1, float p2,  void (*cb)(struct S_DPI, int, float)) ;
+EXPORT void f6_V_SIF_DPF(struct S_DPF p0, int p1, float p2,  void (*cb)(struct S_DPF, int, float)) ;
+EXPORT void f6_V_SIF_DPD(struct S_DPD p0, int p1, float p2,  void (*cb)(struct S_DPD, int, float)) ;
+EXPORT void f6_V_SIF_DPP(struct S_DPP p0, int p1, float p2,  void (*cb)(struct S_DPP, int, float)) ;
+EXPORT void f6_V_SIF_PII(struct S_PII p0, int p1, float p2,  void (*cb)(struct S_PII, int, float)) ;
+EXPORT void f6_V_SIF_PIF(struct S_PIF p0, int p1, float p2,  void (*cb)(struct S_PIF, int, float)) ;
+EXPORT void f6_V_SIF_PID(struct S_PID p0, int p1, float p2,  void (*cb)(struct S_PID, int, float)) ;
+EXPORT void f6_V_SIF_PIP(struct S_PIP p0, int p1, float p2,  void (*cb)(struct S_PIP, int, float)) ;
+EXPORT void f6_V_SIF_PFI(struct S_PFI p0, int p1, float p2,  void (*cb)(struct S_PFI, int, float)) ;
+EXPORT void f6_V_SIF_PFF(struct S_PFF p0, int p1, float p2,  void (*cb)(struct S_PFF, int, float)) ;
+EXPORT void f6_V_SIF_PFD(struct S_PFD p0, int p1, float p2,  void (*cb)(struct S_PFD, int, float)) ;
+EXPORT void f6_V_SIF_PFP(struct S_PFP p0, int p1, float p2,  void (*cb)(struct S_PFP, int, float)) ;
+EXPORT void f6_V_SIF_PDI(struct S_PDI p0, int p1, float p2,  void (*cb)(struct S_PDI, int, float)) ;
+EXPORT void f6_V_SIF_PDF(struct S_PDF p0, int p1, float p2,  void (*cb)(struct S_PDF, int, float)) ;
+EXPORT void f6_V_SIF_PDD(struct S_PDD p0, int p1, float p2,  void (*cb)(struct S_PDD, int, float)) ;
+EXPORT void f6_V_SIF_PDP(struct S_PDP p0, int p1, float p2,  void (*cb)(struct S_PDP, int, float)) ;
+EXPORT void f6_V_SIF_PPI(struct S_PPI p0, int p1, float p2,  void (*cb)(struct S_PPI, int, float)) ;
+EXPORT void f6_V_SIF_PPF(struct S_PPF p0, int p1, float p2,  void (*cb)(struct S_PPF, int, float)) ;
+EXPORT void f6_V_SIF_PPD(struct S_PPD p0, int p1, float p2,  void (*cb)(struct S_PPD, int, float)) ;
+EXPORT void f6_V_SIF_PPP(struct S_PPP p0, int p1, float p2,  void (*cb)(struct S_PPP, int, float)) ;
+EXPORT void f6_V_SID_I(struct S_I p0, int p1, double p2,  void (*cb)(struct S_I, int, double)) ;
+EXPORT void f6_V_SID_F(struct S_F p0, int p1, double p2,  void (*cb)(struct S_F, int, double)) ;
+EXPORT void f6_V_SID_D(struct S_D p0, int p1, double p2,  void (*cb)(struct S_D, int, double)) ;
+EXPORT void f6_V_SID_P(struct S_P p0, int p1, double p2,  void (*cb)(struct S_P, int, double)) ;
+EXPORT void f6_V_SID_II(struct S_II p0, int p1, double p2,  void (*cb)(struct S_II, int, double)) ;
+EXPORT void f6_V_SID_IF(struct S_IF p0, int p1, double p2,  void (*cb)(struct S_IF, int, double)) ;
+EXPORT void f6_V_SID_ID(struct S_ID p0, int p1, double p2,  void (*cb)(struct S_ID, int, double)) ;
+EXPORT void f6_V_SID_IP(struct S_IP p0, int p1, double p2,  void (*cb)(struct S_IP, int, double)) ;
+EXPORT void f6_V_SID_FI(struct S_FI p0, int p1, double p2,  void (*cb)(struct S_FI, int, double)) ;
+EXPORT void f6_V_SID_FF(struct S_FF p0, int p1, double p2,  void (*cb)(struct S_FF, int, double)) ;
+EXPORT void f6_V_SID_FD(struct S_FD p0, int p1, double p2,  void (*cb)(struct S_FD, int, double)) ;
+EXPORT void f6_V_SID_FP(struct S_FP p0, int p1, double p2,  void (*cb)(struct S_FP, int, double)) ;
+EXPORT void f6_V_SID_DI(struct S_DI p0, int p1, double p2,  void (*cb)(struct S_DI, int, double)) ;
+EXPORT void f6_V_SID_DF(struct S_DF p0, int p1, double p2,  void (*cb)(struct S_DF, int, double)) ;
+EXPORT void f6_V_SID_DD(struct S_DD p0, int p1, double p2,  void (*cb)(struct S_DD, int, double)) ;
+EXPORT void f6_V_SID_DP(struct S_DP p0, int p1, double p2,  void (*cb)(struct S_DP, int, double)) ;
+EXPORT void f6_V_SID_PI(struct S_PI p0, int p1, double p2,  void (*cb)(struct S_PI, int, double)) ;
+EXPORT void f6_V_SID_PF(struct S_PF p0, int p1, double p2,  void (*cb)(struct S_PF, int, double)) ;
+EXPORT void f6_V_SID_PD(struct S_PD p0, int p1, double p2,  void (*cb)(struct S_PD, int, double)) ;
+EXPORT void f6_V_SID_PP(struct S_PP p0, int p1, double p2,  void (*cb)(struct S_PP, int, double)) ;
+EXPORT void f6_V_SID_III(struct S_III p0, int p1, double p2,  void (*cb)(struct S_III, int, double)) ;
+EXPORT void f6_V_SID_IIF(struct S_IIF p0, int p1, double p2,  void (*cb)(struct S_IIF, int, double)) ;
+EXPORT void f6_V_SID_IID(struct S_IID p0, int p1, double p2,  void (*cb)(struct S_IID, int, double)) ;
+EXPORT void f6_V_SID_IIP(struct S_IIP p0, int p1, double p2,  void (*cb)(struct S_IIP, int, double)) ;
+EXPORT void f6_V_SID_IFI(struct S_IFI p0, int p1, double p2,  void (*cb)(struct S_IFI, int, double)) ;
+EXPORT void f6_V_SID_IFF(struct S_IFF p0, int p1, double p2,  void (*cb)(struct S_IFF, int, double)) ;
+EXPORT void f6_V_SID_IFD(struct S_IFD p0, int p1, double p2,  void (*cb)(struct S_IFD, int, double)) ;
+EXPORT void f6_V_SID_IFP(struct S_IFP p0, int p1, double p2,  void (*cb)(struct S_IFP, int, double)) ;
+EXPORT void f6_V_SID_IDI(struct S_IDI p0, int p1, double p2,  void (*cb)(struct S_IDI, int, double)) ;
+EXPORT void f6_V_SID_IDF(struct S_IDF p0, int p1, double p2,  void (*cb)(struct S_IDF, int, double)) ;
+EXPORT void f6_V_SID_IDD(struct S_IDD p0, int p1, double p2,  void (*cb)(struct S_IDD, int, double)) ;
+EXPORT void f6_V_SID_IDP(struct S_IDP p0, int p1, double p2,  void (*cb)(struct S_IDP, int, double)) ;
+EXPORT void f6_V_SID_IPI(struct S_IPI p0, int p1, double p2,  void (*cb)(struct S_IPI, int, double)) ;
+EXPORT void f6_V_SID_IPF(struct S_IPF p0, int p1, double p2,  void (*cb)(struct S_IPF, int, double)) ;
+EXPORT void f6_V_SID_IPD(struct S_IPD p0, int p1, double p2,  void (*cb)(struct S_IPD, int, double)) ;
+EXPORT void f6_V_SID_IPP(struct S_IPP p0, int p1, double p2,  void (*cb)(struct S_IPP, int, double)) ;
+EXPORT void f6_V_SID_FII(struct S_FII p0, int p1, double p2,  void (*cb)(struct S_FII, int, double)) ;
+EXPORT void f6_V_SID_FIF(struct S_FIF p0, int p1, double p2,  void (*cb)(struct S_FIF, int, double)) ;
+EXPORT void f6_V_SID_FID(struct S_FID p0, int p1, double p2,  void (*cb)(struct S_FID, int, double)) ;
+EXPORT void f6_V_SID_FIP(struct S_FIP p0, int p1, double p2,  void (*cb)(struct S_FIP, int, double)) ;
+EXPORT void f6_V_SID_FFI(struct S_FFI p0, int p1, double p2,  void (*cb)(struct S_FFI, int, double)) ;
+EXPORT void f6_V_SID_FFF(struct S_FFF p0, int p1, double p2,  void (*cb)(struct S_FFF, int, double)) ;
+EXPORT void f6_V_SID_FFD(struct S_FFD p0, int p1, double p2,  void (*cb)(struct S_FFD, int, double)) ;
+EXPORT void f6_V_SID_FFP(struct S_FFP p0, int p1, double p2,  void (*cb)(struct S_FFP, int, double)) ;
+EXPORT void f6_V_SID_FDI(struct S_FDI p0, int p1, double p2,  void (*cb)(struct S_FDI, int, double)) ;
+EXPORT void f6_V_SID_FDF(struct S_FDF p0, int p1, double p2,  void (*cb)(struct S_FDF, int, double)) ;
+EXPORT void f6_V_SID_FDD(struct S_FDD p0, int p1, double p2,  void (*cb)(struct S_FDD, int, double)) ;
+EXPORT void f6_V_SID_FDP(struct S_FDP p0, int p1, double p2,  void (*cb)(struct S_FDP, int, double)) ;
+EXPORT void f6_V_SID_FPI(struct S_FPI p0, int p1, double p2,  void (*cb)(struct S_FPI, int, double)) ;
+EXPORT void f6_V_SID_FPF(struct S_FPF p0, int p1, double p2,  void (*cb)(struct S_FPF, int, double)) ;
+EXPORT void f6_V_SID_FPD(struct S_FPD p0, int p1, double p2,  void (*cb)(struct S_FPD, int, double)) ;
+EXPORT void f6_V_SID_FPP(struct S_FPP p0, int p1, double p2,  void (*cb)(struct S_FPP, int, double)) ;
+EXPORT void f6_V_SID_DII(struct S_DII p0, int p1, double p2,  void (*cb)(struct S_DII, int, double)) ;
+EXPORT void f6_V_SID_DIF(struct S_DIF p0, int p1, double p2,  void (*cb)(struct S_DIF, int, double)) ;
+EXPORT void f6_V_SID_DID(struct S_DID p0, int p1, double p2,  void (*cb)(struct S_DID, int, double)) ;
+EXPORT void f6_V_SID_DIP(struct S_DIP p0, int p1, double p2,  void (*cb)(struct S_DIP, int, double)) ;
+EXPORT void f6_V_SID_DFI(struct S_DFI p0, int p1, double p2,  void (*cb)(struct S_DFI, int, double)) ;
+EXPORT void f6_V_SID_DFF(struct S_DFF p0, int p1, double p2,  void (*cb)(struct S_DFF, int, double)) ;
+EXPORT void f6_V_SID_DFD(struct S_DFD p0, int p1, double p2,  void (*cb)(struct S_DFD, int, double)) ;
+EXPORT void f6_V_SID_DFP(struct S_DFP p0, int p1, double p2,  void (*cb)(struct S_DFP, int, double)) ;
+EXPORT void f6_V_SID_DDI(struct S_DDI p0, int p1, double p2,  void (*cb)(struct S_DDI, int, double)) ;
+EXPORT void f6_V_SID_DDF(struct S_DDF p0, int p1, double p2,  void (*cb)(struct S_DDF, int, double)) ;
+EXPORT void f6_V_SID_DDD(struct S_DDD p0, int p1, double p2,  void (*cb)(struct S_DDD, int, double)) ;
+EXPORT void f6_V_SID_DDP(struct S_DDP p0, int p1, double p2,  void (*cb)(struct S_DDP, int, double)) ;
+EXPORT void f6_V_SID_DPI(struct S_DPI p0, int p1, double p2,  void (*cb)(struct S_DPI, int, double)) ;
+EXPORT void f6_V_SID_DPF(struct S_DPF p0, int p1, double p2,  void (*cb)(struct S_DPF, int, double)) ;
+EXPORT void f6_V_SID_DPD(struct S_DPD p0, int p1, double p2,  void (*cb)(struct S_DPD, int, double)) ;
+EXPORT void f6_V_SID_DPP(struct S_DPP p0, int p1, double p2,  void (*cb)(struct S_DPP, int, double)) ;
+EXPORT void f6_V_SID_PII(struct S_PII p0, int p1, double p2,  void (*cb)(struct S_PII, int, double)) ;
+EXPORT void f6_V_SID_PIF(struct S_PIF p0, int p1, double p2,  void (*cb)(struct S_PIF, int, double)) ;
+EXPORT void f6_V_SID_PID(struct S_PID p0, int p1, double p2,  void (*cb)(struct S_PID, int, double)) ;
+EXPORT void f6_V_SID_PIP(struct S_PIP p0, int p1, double p2,  void (*cb)(struct S_PIP, int, double)) ;
+EXPORT void f6_V_SID_PFI(struct S_PFI p0, int p1, double p2,  void (*cb)(struct S_PFI, int, double)) ;
+EXPORT void f6_V_SID_PFF(struct S_PFF p0, int p1, double p2,  void (*cb)(struct S_PFF, int, double)) ;
+EXPORT void f6_V_SID_PFD(struct S_PFD p0, int p1, double p2,  void (*cb)(struct S_PFD, int, double)) ;
+EXPORT void f6_V_SID_PFP(struct S_PFP p0, int p1, double p2,  void (*cb)(struct S_PFP, int, double)) ;
+EXPORT void f6_V_SID_PDI(struct S_PDI p0, int p1, double p2,  void (*cb)(struct S_PDI, int, double)) ;
+EXPORT void f6_V_SID_PDF(struct S_PDF p0, int p1, double p2,  void (*cb)(struct S_PDF, int, double)) ;
+EXPORT void f6_V_SID_PDD(struct S_PDD p0, int p1, double p2,  void (*cb)(struct S_PDD, int, double)) ;
+EXPORT void f6_V_SID_PDP(struct S_PDP p0, int p1, double p2,  void (*cb)(struct S_PDP, int, double)) ;
+EXPORT void f6_V_SID_PPI(struct S_PPI p0, int p1, double p2,  void (*cb)(struct S_PPI, int, double)) ;
+EXPORT void f6_V_SID_PPF(struct S_PPF p0, int p1, double p2,  void (*cb)(struct S_PPF, int, double)) ;
+EXPORT void f6_V_SID_PPD(struct S_PPD p0, int p1, double p2,  void (*cb)(struct S_PPD, int, double)) ;
+EXPORT void f7_V_SID_PPP(struct S_PPP p0, int p1, double p2,  void (*cb)(struct S_PPP, int, double)) ;
+EXPORT void f7_V_SIP_I(struct S_I p0, int p1, void* p2,  void (*cb)(struct S_I, int, void*)) ;
+EXPORT void f7_V_SIP_F(struct S_F p0, int p1, void* p2,  void (*cb)(struct S_F, int, void*)) ;
+EXPORT void f7_V_SIP_D(struct S_D p0, int p1, void* p2,  void (*cb)(struct S_D, int, void*)) ;
+EXPORT void f7_V_SIP_P(struct S_P p0, int p1, void* p2,  void (*cb)(struct S_P, int, void*)) ;
+EXPORT void f7_V_SIP_II(struct S_II p0, int p1, void* p2,  void (*cb)(struct S_II, int, void*)) ;
+EXPORT void f7_V_SIP_IF(struct S_IF p0, int p1, void* p2,  void (*cb)(struct S_IF, int, void*)) ;
+EXPORT void f7_V_SIP_ID(struct S_ID p0, int p1, void* p2,  void (*cb)(struct S_ID, int, void*)) ;
+EXPORT void f7_V_SIP_IP(struct S_IP p0, int p1, void* p2,  void (*cb)(struct S_IP, int, void*)) ;
+EXPORT void f7_V_SIP_FI(struct S_FI p0, int p1, void* p2,  void (*cb)(struct S_FI, int, void*)) ;
+EXPORT void f7_V_SIP_FF(struct S_FF p0, int p1, void* p2,  void (*cb)(struct S_FF, int, void*)) ;
+EXPORT void f7_V_SIP_FD(struct S_FD p0, int p1, void* p2,  void (*cb)(struct S_FD, int, void*)) ;
+EXPORT void f7_V_SIP_FP(struct S_FP p0, int p1, void* p2,  void (*cb)(struct S_FP, int, void*)) ;
+EXPORT void f7_V_SIP_DI(struct S_DI p0, int p1, void* p2,  void (*cb)(struct S_DI, int, void*)) ;
+EXPORT void f7_V_SIP_DF(struct S_DF p0, int p1, void* p2,  void (*cb)(struct S_DF, int, void*)) ;
+EXPORT void f7_V_SIP_DD(struct S_DD p0, int p1, void* p2,  void (*cb)(struct S_DD, int, void*)) ;
+EXPORT void f7_V_SIP_DP(struct S_DP p0, int p1, void* p2,  void (*cb)(struct S_DP, int, void*)) ;
+EXPORT void f7_V_SIP_PI(struct S_PI p0, int p1, void* p2,  void (*cb)(struct S_PI, int, void*)) ;
+EXPORT void f7_V_SIP_PF(struct S_PF p0, int p1, void* p2,  void (*cb)(struct S_PF, int, void*)) ;
+EXPORT void f7_V_SIP_PD(struct S_PD p0, int p1, void* p2,  void (*cb)(struct S_PD, int, void*)) ;
+EXPORT void f7_V_SIP_PP(struct S_PP p0, int p1, void* p2,  void (*cb)(struct S_PP, int, void*)) ;
+EXPORT void f7_V_SIP_III(struct S_III p0, int p1, void* p2,  void (*cb)(struct S_III, int, void*)) ;
+EXPORT void f7_V_SIP_IIF(struct S_IIF p0, int p1, void* p2,  void (*cb)(struct S_IIF, int, void*)) ;
+EXPORT void f7_V_SIP_IID(struct S_IID p0, int p1, void* p2,  void (*cb)(struct S_IID, int, void*)) ;
+EXPORT void f7_V_SIP_IIP(struct S_IIP p0, int p1, void* p2,  void (*cb)(struct S_IIP, int, void*)) ;
+EXPORT void f7_V_SIP_IFI(struct S_IFI p0, int p1, void* p2,  void (*cb)(struct S_IFI, int, void*)) ;
+EXPORT void f7_V_SIP_IFF(struct S_IFF p0, int p1, void* p2,  void (*cb)(struct S_IFF, int, void*)) ;
+EXPORT void f7_V_SIP_IFD(struct S_IFD p0, int p1, void* p2,  void (*cb)(struct S_IFD, int, void*)) ;
+EXPORT void f7_V_SIP_IFP(struct S_IFP p0, int p1, void* p2,  void (*cb)(struct S_IFP, int, void*)) ;
+EXPORT void f7_V_SIP_IDI(struct S_IDI p0, int p1, void* p2,  void (*cb)(struct S_IDI, int, void*)) ;
+EXPORT void f7_V_SIP_IDF(struct S_IDF p0, int p1, void* p2,  void (*cb)(struct S_IDF, int, void*)) ;
+EXPORT void f7_V_SIP_IDD(struct S_IDD p0, int p1, void* p2,  void (*cb)(struct S_IDD, int, void*)) ;
+EXPORT void f7_V_SIP_IDP(struct S_IDP p0, int p1, void* p2,  void (*cb)(struct S_IDP, int, void*)) ;
+EXPORT void f7_V_SIP_IPI(struct S_IPI p0, int p1, void* p2,  void (*cb)(struct S_IPI, int, void*)) ;
+EXPORT void f7_V_SIP_IPF(struct S_IPF p0, int p1, void* p2,  void (*cb)(struct S_IPF, int, void*)) ;
+EXPORT void f7_V_SIP_IPD(struct S_IPD p0, int p1, void* p2,  void (*cb)(struct S_IPD, int, void*)) ;
+EXPORT void f7_V_SIP_IPP(struct S_IPP p0, int p1, void* p2,  void (*cb)(struct S_IPP, int, void*)) ;
+EXPORT void f7_V_SIP_FII(struct S_FII p0, int p1, void* p2,  void (*cb)(struct S_FII, int, void*)) ;
+EXPORT void f7_V_SIP_FIF(struct S_FIF p0, int p1, void* p2,  void (*cb)(struct S_FIF, int, void*)) ;
+EXPORT void f7_V_SIP_FID(struct S_FID p0, int p1, void* p2,  void (*cb)(struct S_FID, int, void*)) ;
+EXPORT void f7_V_SIP_FIP(struct S_FIP p0, int p1, void* p2,  void (*cb)(struct S_FIP, int, void*)) ;
+EXPORT void f7_V_SIP_FFI(struct S_FFI p0, int p1, void* p2,  void (*cb)(struct S_FFI, int, void*)) ;
+EXPORT void f7_V_SIP_FFF(struct S_FFF p0, int p1, void* p2,  void (*cb)(struct S_FFF, int, void*)) ;
+EXPORT void f7_V_SIP_FFD(struct S_FFD p0, int p1, void* p2,  void (*cb)(struct S_FFD, int, void*)) ;
+EXPORT void f7_V_SIP_FFP(struct S_FFP p0, int p1, void* p2,  void (*cb)(struct S_FFP, int, void*)) ;
+EXPORT void f7_V_SIP_FDI(struct S_FDI p0, int p1, void* p2,  void (*cb)(struct S_FDI, int, void*)) ;
+EXPORT void f7_V_SIP_FDF(struct S_FDF p0, int p1, void* p2,  void (*cb)(struct S_FDF, int, void*)) ;
+EXPORT void f7_V_SIP_FDD(struct S_FDD p0, int p1, void* p2,  void (*cb)(struct S_FDD, int, void*)) ;
+EXPORT void f7_V_SIP_FDP(struct S_FDP p0, int p1, void* p2,  void (*cb)(struct S_FDP, int, void*)) ;
+EXPORT void f7_V_SIP_FPI(struct S_FPI p0, int p1, void* p2,  void (*cb)(struct S_FPI, int, void*)) ;
+EXPORT void f7_V_SIP_FPF(struct S_FPF p0, int p1, void* p2,  void (*cb)(struct S_FPF, int, void*)) ;
+EXPORT void f7_V_SIP_FPD(struct S_FPD p0, int p1, void* p2,  void (*cb)(struct S_FPD, int, void*)) ;
+EXPORT void f7_V_SIP_FPP(struct S_FPP p0, int p1, void* p2,  void (*cb)(struct S_FPP, int, void*)) ;
+EXPORT void f7_V_SIP_DII(struct S_DII p0, int p1, void* p2,  void (*cb)(struct S_DII, int, void*)) ;
+EXPORT void f7_V_SIP_DIF(struct S_DIF p0, int p1, void* p2,  void (*cb)(struct S_DIF, int, void*)) ;
+EXPORT void f7_V_SIP_DID(struct S_DID p0, int p1, void* p2,  void (*cb)(struct S_DID, int, void*)) ;
+EXPORT void f7_V_SIP_DIP(struct S_DIP p0, int p1, void* p2,  void (*cb)(struct S_DIP, int, void*)) ;
+EXPORT void f7_V_SIP_DFI(struct S_DFI p0, int p1, void* p2,  void (*cb)(struct S_DFI, int, void*)) ;
+EXPORT void f7_V_SIP_DFF(struct S_DFF p0, int p1, void* p2,  void (*cb)(struct S_DFF, int, void*)) ;
+EXPORT void f7_V_SIP_DFD(struct S_DFD p0, int p1, void* p2,  void (*cb)(struct S_DFD, int, void*)) ;
+EXPORT void f7_V_SIP_DFP(struct S_DFP p0, int p1, void* p2,  void (*cb)(struct S_DFP, int, void*)) ;
+EXPORT void f7_V_SIP_DDI(struct S_DDI p0, int p1, void* p2,  void (*cb)(struct S_DDI, int, void*)) ;
+EXPORT void f7_V_SIP_DDF(struct S_DDF p0, int p1, void* p2,  void (*cb)(struct S_DDF, int, void*)) ;
+EXPORT void f7_V_SIP_DDD(struct S_DDD p0, int p1, void* p2,  void (*cb)(struct S_DDD, int, void*)) ;
+EXPORT void f7_V_SIP_DDP(struct S_DDP p0, int p1, void* p2,  void (*cb)(struct S_DDP, int, void*)) ;
+EXPORT void f7_V_SIP_DPI(struct S_DPI p0, int p1, void* p2,  void (*cb)(struct S_DPI, int, void*)) ;
+EXPORT void f7_V_SIP_DPF(struct S_DPF p0, int p1, void* p2,  void (*cb)(struct S_DPF, int, void*)) ;
+EXPORT void f7_V_SIP_DPD(struct S_DPD p0, int p1, void* p2,  void (*cb)(struct S_DPD, int, void*)) ;
+EXPORT void f7_V_SIP_DPP(struct S_DPP p0, int p1, void* p2,  void (*cb)(struct S_DPP, int, void*)) ;
+EXPORT void f7_V_SIP_PII(struct S_PII p0, int p1, void* p2,  void (*cb)(struct S_PII, int, void*)) ;
+EXPORT void f7_V_SIP_PIF(struct S_PIF p0, int p1, void* p2,  void (*cb)(struct S_PIF, int, void*)) ;
+EXPORT void f7_V_SIP_PID(struct S_PID p0, int p1, void* p2,  void (*cb)(struct S_PID, int, void*)) ;
+EXPORT void f7_V_SIP_PIP(struct S_PIP p0, int p1, void* p2,  void (*cb)(struct S_PIP, int, void*)) ;
+EXPORT void f7_V_SIP_PFI(struct S_PFI p0, int p1, void* p2,  void (*cb)(struct S_PFI, int, void*)) ;
+EXPORT void f7_V_SIP_PFF(struct S_PFF p0, int p1, void* p2,  void (*cb)(struct S_PFF, int, void*)) ;
+EXPORT void f7_V_SIP_PFD(struct S_PFD p0, int p1, void* p2,  void (*cb)(struct S_PFD, int, void*)) ;
+EXPORT void f7_V_SIP_PFP(struct S_PFP p0, int p1, void* p2,  void (*cb)(struct S_PFP, int, void*)) ;
+EXPORT void f7_V_SIP_PDI(struct S_PDI p0, int p1, void* p2,  void (*cb)(struct S_PDI, int, void*)) ;
+EXPORT void f7_V_SIP_PDF(struct S_PDF p0, int p1, void* p2,  void (*cb)(struct S_PDF, int, void*)) ;
+EXPORT void f7_V_SIP_PDD(struct S_PDD p0, int p1, void* p2,  void (*cb)(struct S_PDD, int, void*)) ;
+EXPORT void f7_V_SIP_PDP(struct S_PDP p0, int p1, void* p2,  void (*cb)(struct S_PDP, int, void*)) ;
+EXPORT void f7_V_SIP_PPI(struct S_PPI p0, int p1, void* p2,  void (*cb)(struct S_PPI, int, void*)) ;
+EXPORT void f7_V_SIP_PPF(struct S_PPF p0, int p1, void* p2,  void (*cb)(struct S_PPF, int, void*)) ;
+EXPORT void f7_V_SIP_PPD(struct S_PPD p0, int p1, void* p2,  void (*cb)(struct S_PPD, int, void*)) ;
+EXPORT void f7_V_SIP_PPP(struct S_PPP p0, int p1, void* p2,  void (*cb)(struct S_PPP, int, void*)) ;
+EXPORT void f7_V_SIS_I(struct S_I p0, int p1, struct S_I p2,  void (*cb)(struct S_I, int, struct S_I)) ;
+EXPORT void f7_V_SIS_F(struct S_F p0, int p1, struct S_F p2,  void (*cb)(struct S_F, int, struct S_F)) ;
+EXPORT void f7_V_SIS_D(struct S_D p0, int p1, struct S_D p2,  void (*cb)(struct S_D, int, struct S_D)) ;
+EXPORT void f7_V_SIS_P(struct S_P p0, int p1, struct S_P p2,  void (*cb)(struct S_P, int, struct S_P)) ;
+EXPORT void f7_V_SIS_II(struct S_II p0, int p1, struct S_II p2,  void (*cb)(struct S_II, int, struct S_II)) ;
+EXPORT void f7_V_SIS_IF(struct S_IF p0, int p1, struct S_IF p2,  void (*cb)(struct S_IF, int, struct S_IF)) ;
+EXPORT void f7_V_SIS_ID(struct S_ID p0, int p1, struct S_ID p2,  void (*cb)(struct S_ID, int, struct S_ID)) ;
+EXPORT void f7_V_SIS_IP(struct S_IP p0, int p1, struct S_IP p2,  void (*cb)(struct S_IP, int, struct S_IP)) ;
+EXPORT void f7_V_SIS_FI(struct S_FI p0, int p1, struct S_FI p2,  void (*cb)(struct S_FI, int, struct S_FI)) ;
+EXPORT void f7_V_SIS_FF(struct S_FF p0, int p1, struct S_FF p2,  void (*cb)(struct S_FF, int, struct S_FF)) ;
+EXPORT void f7_V_SIS_FD(struct S_FD p0, int p1, struct S_FD p2,  void (*cb)(struct S_FD, int, struct S_FD)) ;
+EXPORT void f7_V_SIS_FP(struct S_FP p0, int p1, struct S_FP p2,  void (*cb)(struct S_FP, int, struct S_FP)) ;
+EXPORT void f7_V_SIS_DI(struct S_DI p0, int p1, struct S_DI p2,  void (*cb)(struct S_DI, int, struct S_DI)) ;
+EXPORT void f7_V_SIS_DF(struct S_DF p0, int p1, struct S_DF p2,  void (*cb)(struct S_DF, int, struct S_DF)) ;
+EXPORT void f7_V_SIS_DD(struct S_DD p0, int p1, struct S_DD p2,  void (*cb)(struct S_DD, int, struct S_DD)) ;
+EXPORT void f7_V_SIS_DP(struct S_DP p0, int p1, struct S_DP p2,  void (*cb)(struct S_DP, int, struct S_DP)) ;
+EXPORT void f7_V_SIS_PI(struct S_PI p0, int p1, struct S_PI p2,  void (*cb)(struct S_PI, int, struct S_PI)) ;
+EXPORT void f7_V_SIS_PF(struct S_PF p0, int p1, struct S_PF p2,  void (*cb)(struct S_PF, int, struct S_PF)) ;
+EXPORT void f7_V_SIS_PD(struct S_PD p0, int p1, struct S_PD p2,  void (*cb)(struct S_PD, int, struct S_PD)) ;
+EXPORT void f7_V_SIS_PP(struct S_PP p0, int p1, struct S_PP p2,  void (*cb)(struct S_PP, int, struct S_PP)) ;
+EXPORT void f7_V_SIS_III(struct S_III p0, int p1, struct S_III p2,  void (*cb)(struct S_III, int, struct S_III)) ;
+EXPORT void f7_V_SIS_IIF(struct S_IIF p0, int p1, struct S_IIF p2,  void (*cb)(struct S_IIF, int, struct S_IIF)) ;
+EXPORT void f7_V_SIS_IID(struct S_IID p0, int p1, struct S_IID p2,  void (*cb)(struct S_IID, int, struct S_IID)) ;
+EXPORT void f7_V_SIS_IIP(struct S_IIP p0, int p1, struct S_IIP p2,  void (*cb)(struct S_IIP, int, struct S_IIP)) ;
+EXPORT void f7_V_SIS_IFI(struct S_IFI p0, int p1, struct S_IFI p2,  void (*cb)(struct S_IFI, int, struct S_IFI)) ;
+EXPORT void f7_V_SIS_IFF(struct S_IFF p0, int p1, struct S_IFF p2,  void (*cb)(struct S_IFF, int, struct S_IFF)) ;
+EXPORT void f7_V_SIS_IFD(struct S_IFD p0, int p1, struct S_IFD p2,  void (*cb)(struct S_IFD, int, struct S_IFD)) ;
+EXPORT void f7_V_SIS_IFP(struct S_IFP p0, int p1, struct S_IFP p2,  void (*cb)(struct S_IFP, int, struct S_IFP)) ;
+EXPORT void f7_V_SIS_IDI(struct S_IDI p0, int p1, struct S_IDI p2,  void (*cb)(struct S_IDI, int, struct S_IDI)) ;
+EXPORT void f7_V_SIS_IDF(struct S_IDF p0, int p1, struct S_IDF p2,  void (*cb)(struct S_IDF, int, struct S_IDF)) ;
+EXPORT void f7_V_SIS_IDD(struct S_IDD p0, int p1, struct S_IDD p2,  void (*cb)(struct S_IDD, int, struct S_IDD)) ;
+EXPORT void f7_V_SIS_IDP(struct S_IDP p0, int p1, struct S_IDP p2,  void (*cb)(struct S_IDP, int, struct S_IDP)) ;
+EXPORT void f7_V_SIS_IPI(struct S_IPI p0, int p1, struct S_IPI p2,  void (*cb)(struct S_IPI, int, struct S_IPI)) ;
+EXPORT void f7_V_SIS_IPF(struct S_IPF p0, int p1, struct S_IPF p2,  void (*cb)(struct S_IPF, int, struct S_IPF)) ;
+EXPORT void f7_V_SIS_IPD(struct S_IPD p0, int p1, struct S_IPD p2,  void (*cb)(struct S_IPD, int, struct S_IPD)) ;
+EXPORT void f7_V_SIS_IPP(struct S_IPP p0, int p1, struct S_IPP p2,  void (*cb)(struct S_IPP, int, struct S_IPP)) ;
+EXPORT void f7_V_SIS_FII(struct S_FII p0, int p1, struct S_FII p2,  void (*cb)(struct S_FII, int, struct S_FII)) ;
+EXPORT void f7_V_SIS_FIF(struct S_FIF p0, int p1, struct S_FIF p2,  void (*cb)(struct S_FIF, int, struct S_FIF)) ;
+EXPORT void f7_V_SIS_FID(struct S_FID p0, int p1, struct S_FID p2,  void (*cb)(struct S_FID, int, struct S_FID)) ;
+EXPORT void f7_V_SIS_FIP(struct S_FIP p0, int p1, struct S_FIP p2,  void (*cb)(struct S_FIP, int, struct S_FIP)) ;
+EXPORT void f7_V_SIS_FFI(struct S_FFI p0, int p1, struct S_FFI p2,  void (*cb)(struct S_FFI, int, struct S_FFI)) ;
+EXPORT void f7_V_SIS_FFF(struct S_FFF p0, int p1, struct S_FFF p2,  void (*cb)(struct S_FFF, int, struct S_FFF)) ;
+EXPORT void f7_V_SIS_FFD(struct S_FFD p0, int p1, struct S_FFD p2,  void (*cb)(struct S_FFD, int, struct S_FFD)) ;
+EXPORT void f7_V_SIS_FFP(struct S_FFP p0, int p1, struct S_FFP p2,  void (*cb)(struct S_FFP, int, struct S_FFP)) ;
+EXPORT void f7_V_SIS_FDI(struct S_FDI p0, int p1, struct S_FDI p2,  void (*cb)(struct S_FDI, int, struct S_FDI)) ;
+EXPORT void f7_V_SIS_FDF(struct S_FDF p0, int p1, struct S_FDF p2,  void (*cb)(struct S_FDF, int, struct S_FDF)) ;
+EXPORT void f7_V_SIS_FDD(struct S_FDD p0, int p1, struct S_FDD p2,  void (*cb)(struct S_FDD, int, struct S_FDD)) ;
+EXPORT void f7_V_SIS_FDP(struct S_FDP p0, int p1, struct S_FDP p2,  void (*cb)(struct S_FDP, int, struct S_FDP)) ;
+EXPORT void f7_V_SIS_FPI(struct S_FPI p0, int p1, struct S_FPI p2,  void (*cb)(struct S_FPI, int, struct S_FPI)) ;
+EXPORT void f7_V_SIS_FPF(struct S_FPF p0, int p1, struct S_FPF p2,  void (*cb)(struct S_FPF, int, struct S_FPF)) ;
+EXPORT void f7_V_SIS_FPD(struct S_FPD p0, int p1, struct S_FPD p2,  void (*cb)(struct S_FPD, int, struct S_FPD)) ;
+EXPORT void f7_V_SIS_FPP(struct S_FPP p0, int p1, struct S_FPP p2,  void (*cb)(struct S_FPP, int, struct S_FPP)) ;
+EXPORT void f7_V_SIS_DII(struct S_DII p0, int p1, struct S_DII p2,  void (*cb)(struct S_DII, int, struct S_DII)) ;
+EXPORT void f7_V_SIS_DIF(struct S_DIF p0, int p1, struct S_DIF p2,  void (*cb)(struct S_DIF, int, struct S_DIF)) ;
+EXPORT void f7_V_SIS_DID(struct S_DID p0, int p1, struct S_DID p2,  void (*cb)(struct S_DID, int, struct S_DID)) ;
+EXPORT void f7_V_SIS_DIP(struct S_DIP p0, int p1, struct S_DIP p2,  void (*cb)(struct S_DIP, int, struct S_DIP)) ;
+EXPORT void f7_V_SIS_DFI(struct S_DFI p0, int p1, struct S_DFI p2,  void (*cb)(struct S_DFI, int, struct S_DFI)) ;
+EXPORT void f7_V_SIS_DFF(struct S_DFF p0, int p1, struct S_DFF p2,  void (*cb)(struct S_DFF, int, struct S_DFF)) ;
+EXPORT void f7_V_SIS_DFD(struct S_DFD p0, int p1, struct S_DFD p2,  void (*cb)(struct S_DFD, int, struct S_DFD)) ;
+EXPORT void f7_V_SIS_DFP(struct S_DFP p0, int p1, struct S_DFP p2,  void (*cb)(struct S_DFP, int, struct S_DFP)) ;
+EXPORT void f7_V_SIS_DDI(struct S_DDI p0, int p1, struct S_DDI p2,  void (*cb)(struct S_DDI, int, struct S_DDI)) ;
+EXPORT void f7_V_SIS_DDF(struct S_DDF p0, int p1, struct S_DDF p2,  void (*cb)(struct S_DDF, int, struct S_DDF)) ;
+EXPORT void f7_V_SIS_DDD(struct S_DDD p0, int p1, struct S_DDD p2,  void (*cb)(struct S_DDD, int, struct S_DDD)) ;
+EXPORT void f7_V_SIS_DDP(struct S_DDP p0, int p1, struct S_DDP p2,  void (*cb)(struct S_DDP, int, struct S_DDP)) ;
+EXPORT void f7_V_SIS_DPI(struct S_DPI p0, int p1, struct S_DPI p2,  void (*cb)(struct S_DPI, int, struct S_DPI)) ;
+EXPORT void f7_V_SIS_DPF(struct S_DPF p0, int p1, struct S_DPF p2,  void (*cb)(struct S_DPF, int, struct S_DPF)) ;
+EXPORT void f7_V_SIS_DPD(struct S_DPD p0, int p1, struct S_DPD p2,  void (*cb)(struct S_DPD, int, struct S_DPD)) ;
+EXPORT void f7_V_SIS_DPP(struct S_DPP p0, int p1, struct S_DPP p2,  void (*cb)(struct S_DPP, int, struct S_DPP)) ;
+EXPORT void f7_V_SIS_PII(struct S_PII p0, int p1, struct S_PII p2,  void (*cb)(struct S_PII, int, struct S_PII)) ;
+EXPORT void f7_V_SIS_PIF(struct S_PIF p0, int p1, struct S_PIF p2,  void (*cb)(struct S_PIF, int, struct S_PIF)) ;
+EXPORT void f7_V_SIS_PID(struct S_PID p0, int p1, struct S_PID p2,  void (*cb)(struct S_PID, int, struct S_PID)) ;
+EXPORT void f7_V_SIS_PIP(struct S_PIP p0, int p1, struct S_PIP p2,  void (*cb)(struct S_PIP, int, struct S_PIP)) ;
+EXPORT void f7_V_SIS_PFI(struct S_PFI p0, int p1, struct S_PFI p2,  void (*cb)(struct S_PFI, int, struct S_PFI)) ;
+EXPORT void f7_V_SIS_PFF(struct S_PFF p0, int p1, struct S_PFF p2,  void (*cb)(struct S_PFF, int, struct S_PFF)) ;
+EXPORT void f7_V_SIS_PFD(struct S_PFD p0, int p1, struct S_PFD p2,  void (*cb)(struct S_PFD, int, struct S_PFD)) ;
+EXPORT void f7_V_SIS_PFP(struct S_PFP p0, int p1, struct S_PFP p2,  void (*cb)(struct S_PFP, int, struct S_PFP)) ;
+EXPORT void f7_V_SIS_PDI(struct S_PDI p0, int p1, struct S_PDI p2,  void (*cb)(struct S_PDI, int, struct S_PDI)) ;
+EXPORT void f7_V_SIS_PDF(struct S_PDF p0, int p1, struct S_PDF p2,  void (*cb)(struct S_PDF, int, struct S_PDF)) ;
+EXPORT void f7_V_SIS_PDD(struct S_PDD p0, int p1, struct S_PDD p2,  void (*cb)(struct S_PDD, int, struct S_PDD)) ;
+EXPORT void f7_V_SIS_PDP(struct S_PDP p0, int p1, struct S_PDP p2,  void (*cb)(struct S_PDP, int, struct S_PDP)) ;
+EXPORT void f7_V_SIS_PPI(struct S_PPI p0, int p1, struct S_PPI p2,  void (*cb)(struct S_PPI, int, struct S_PPI)) ;
+EXPORT void f7_V_SIS_PPF(struct S_PPF p0, int p1, struct S_PPF p2,  void (*cb)(struct S_PPF, int, struct S_PPF)) ;
+EXPORT void f7_V_SIS_PPD(struct S_PPD p0, int p1, struct S_PPD p2,  void (*cb)(struct S_PPD, int, struct S_PPD)) ;
+EXPORT void f7_V_SIS_PPP(struct S_PPP p0, int p1, struct S_PPP p2,  void (*cb)(struct S_PPP, int, struct S_PPP)) ;
+EXPORT void f7_V_SFI_I(struct S_I p0, float p1, int p2,  void (*cb)(struct S_I, float, int)) ;
+EXPORT void f7_V_SFI_F(struct S_F p0, float p1, int p2,  void (*cb)(struct S_F, float, int)) ;
+EXPORT void f7_V_SFI_D(struct S_D p0, float p1, int p2,  void (*cb)(struct S_D, float, int)) ;
+EXPORT void f7_V_SFI_P(struct S_P p0, float p1, int p2,  void (*cb)(struct S_P, float, int)) ;
+EXPORT void f7_V_SFI_II(struct S_II p0, float p1, int p2,  void (*cb)(struct S_II, float, int)) ;
+EXPORT void f7_V_SFI_IF(struct S_IF p0, float p1, int p2,  void (*cb)(struct S_IF, float, int)) ;
+EXPORT void f7_V_SFI_ID(struct S_ID p0, float p1, int p2,  void (*cb)(struct S_ID, float, int)) ;
+EXPORT void f7_V_SFI_IP(struct S_IP p0, float p1, int p2,  void (*cb)(struct S_IP, float, int)) ;
+EXPORT void f7_V_SFI_FI(struct S_FI p0, float p1, int p2,  void (*cb)(struct S_FI, float, int)) ;
+EXPORT void f7_V_SFI_FF(struct S_FF p0, float p1, int p2,  void (*cb)(struct S_FF, float, int)) ;
+EXPORT void f7_V_SFI_FD(struct S_FD p0, float p1, int p2,  void (*cb)(struct S_FD, float, int)) ;
+EXPORT void f7_V_SFI_FP(struct S_FP p0, float p1, int p2,  void (*cb)(struct S_FP, float, int)) ;
+EXPORT void f7_V_SFI_DI(struct S_DI p0, float p1, int p2,  void (*cb)(struct S_DI, float, int)) ;
+EXPORT void f7_V_SFI_DF(struct S_DF p0, float p1, int p2,  void (*cb)(struct S_DF, float, int)) ;
+EXPORT void f7_V_SFI_DD(struct S_DD p0, float p1, int p2,  void (*cb)(struct S_DD, float, int)) ;
+EXPORT void f7_V_SFI_DP(struct S_DP p0, float p1, int p2,  void (*cb)(struct S_DP, float, int)) ;
+EXPORT void f7_V_SFI_PI(struct S_PI p0, float p1, int p2,  void (*cb)(struct S_PI, float, int)) ;
+EXPORT void f7_V_SFI_PF(struct S_PF p0, float p1, int p2,  void (*cb)(struct S_PF, float, int)) ;
+EXPORT void f7_V_SFI_PD(struct S_PD p0, float p1, int p2,  void (*cb)(struct S_PD, float, int)) ;
+EXPORT void f7_V_SFI_PP(struct S_PP p0, float p1, int p2,  void (*cb)(struct S_PP, float, int)) ;
+EXPORT void f7_V_SFI_III(struct S_III p0, float p1, int p2,  void (*cb)(struct S_III, float, int)) ;
+EXPORT void f7_V_SFI_IIF(struct S_IIF p0, float p1, int p2,  void (*cb)(struct S_IIF, float, int)) ;
+EXPORT void f7_V_SFI_IID(struct S_IID p0, float p1, int p2,  void (*cb)(struct S_IID, float, int)) ;
+EXPORT void f7_V_SFI_IIP(struct S_IIP p0, float p1, int p2,  void (*cb)(struct S_IIP, float, int)) ;
+EXPORT void f7_V_SFI_IFI(struct S_IFI p0, float p1, int p2,  void (*cb)(struct S_IFI, float, int)) ;
+EXPORT void f7_V_SFI_IFF(struct S_IFF p0, float p1, int p2,  void (*cb)(struct S_IFF, float, int)) ;
+EXPORT void f7_V_SFI_IFD(struct S_IFD p0, float p1, int p2,  void (*cb)(struct S_IFD, float, int)) ;
+EXPORT void f7_V_SFI_IFP(struct S_IFP p0, float p1, int p2,  void (*cb)(struct S_IFP, float, int)) ;
+EXPORT void f7_V_SFI_IDI(struct S_IDI p0, float p1, int p2,  void (*cb)(struct S_IDI, float, int)) ;
+EXPORT void f7_V_SFI_IDF(struct S_IDF p0, float p1, int p2,  void (*cb)(struct S_IDF, float, int)) ;
+EXPORT void f7_V_SFI_IDD(struct S_IDD p0, float p1, int p2,  void (*cb)(struct S_IDD, float, int)) ;
+EXPORT void f7_V_SFI_IDP(struct S_IDP p0, float p1, int p2,  void (*cb)(struct S_IDP, float, int)) ;
+EXPORT void f7_V_SFI_IPI(struct S_IPI p0, float p1, int p2,  void (*cb)(struct S_IPI, float, int)) ;
+EXPORT void f7_V_SFI_IPF(struct S_IPF p0, float p1, int p2,  void (*cb)(struct S_IPF, float, int)) ;
+EXPORT void f7_V_SFI_IPD(struct S_IPD p0, float p1, int p2,  void (*cb)(struct S_IPD, float, int)) ;
+EXPORT void f7_V_SFI_IPP(struct S_IPP p0, float p1, int p2,  void (*cb)(struct S_IPP, float, int)) ;
+EXPORT void f7_V_SFI_FII(struct S_FII p0, float p1, int p2,  void (*cb)(struct S_FII, float, int)) ;
+EXPORT void f7_V_SFI_FIF(struct S_FIF p0, float p1, int p2,  void (*cb)(struct S_FIF, float, int)) ;
+EXPORT void f7_V_SFI_FID(struct S_FID p0, float p1, int p2,  void (*cb)(struct S_FID, float, int)) ;
+EXPORT void f7_V_SFI_FIP(struct S_FIP p0, float p1, int p2,  void (*cb)(struct S_FIP, float, int)) ;
+EXPORT void f7_V_SFI_FFI(struct S_FFI p0, float p1, int p2,  void (*cb)(struct S_FFI, float, int)) ;
+EXPORT void f7_V_SFI_FFF(struct S_FFF p0, float p1, int p2,  void (*cb)(struct S_FFF, float, int)) ;
+EXPORT void f7_V_SFI_FFD(struct S_FFD p0, float p1, int p2,  void (*cb)(struct S_FFD, float, int)) ;
+EXPORT void f7_V_SFI_FFP(struct S_FFP p0, float p1, int p2,  void (*cb)(struct S_FFP, float, int)) ;
+EXPORT void f7_V_SFI_FDI(struct S_FDI p0, float p1, int p2,  void (*cb)(struct S_FDI, float, int)) ;
+EXPORT void f7_V_SFI_FDF(struct S_FDF p0, float p1, int p2,  void (*cb)(struct S_FDF, float, int)) ;
+EXPORT void f7_V_SFI_FDD(struct S_FDD p0, float p1, int p2,  void (*cb)(struct S_FDD, float, int)) ;
+EXPORT void f7_V_SFI_FDP(struct S_FDP p0, float p1, int p2,  void (*cb)(struct S_FDP, float, int)) ;
+EXPORT void f7_V_SFI_FPI(struct S_FPI p0, float p1, int p2,  void (*cb)(struct S_FPI, float, int)) ;
+EXPORT void f7_V_SFI_FPF(struct S_FPF p0, float p1, int p2,  void (*cb)(struct S_FPF, float, int)) ;
+EXPORT void f7_V_SFI_FPD(struct S_FPD p0, float p1, int p2,  void (*cb)(struct S_FPD, float, int)) ;
+EXPORT void f7_V_SFI_FPP(struct S_FPP p0, float p1, int p2,  void (*cb)(struct S_FPP, float, int)) ;
+EXPORT void f7_V_SFI_DII(struct S_DII p0, float p1, int p2,  void (*cb)(struct S_DII, float, int)) ;
+EXPORT void f7_V_SFI_DIF(struct S_DIF p0, float p1, int p2,  void (*cb)(struct S_DIF, float, int)) ;
+EXPORT void f7_V_SFI_DID(struct S_DID p0, float p1, int p2,  void (*cb)(struct S_DID, float, int)) ;
+EXPORT void f7_V_SFI_DIP(struct S_DIP p0, float p1, int p2,  void (*cb)(struct S_DIP, float, int)) ;
+EXPORT void f7_V_SFI_DFI(struct S_DFI p0, float p1, int p2,  void (*cb)(struct S_DFI, float, int)) ;
+EXPORT void f7_V_SFI_DFF(struct S_DFF p0, float p1, int p2,  void (*cb)(struct S_DFF, float, int)) ;
+EXPORT void f7_V_SFI_DFD(struct S_DFD p0, float p1, int p2,  void (*cb)(struct S_DFD, float, int)) ;
+EXPORT void f7_V_SFI_DFP(struct S_DFP p0, float p1, int p2,  void (*cb)(struct S_DFP, float, int)) ;
+EXPORT void f7_V_SFI_DDI(struct S_DDI p0, float p1, int p2,  void (*cb)(struct S_DDI, float, int)) ;
+EXPORT void f7_V_SFI_DDF(struct S_DDF p0, float p1, int p2,  void (*cb)(struct S_DDF, float, int)) ;
+EXPORT void f7_V_SFI_DDD(struct S_DDD p0, float p1, int p2,  void (*cb)(struct S_DDD, float, int)) ;
+EXPORT void f7_V_SFI_DDP(struct S_DDP p0, float p1, int p2,  void (*cb)(struct S_DDP, float, int)) ;
+EXPORT void f7_V_SFI_DPI(struct S_DPI p0, float p1, int p2,  void (*cb)(struct S_DPI, float, int)) ;
+EXPORT void f7_V_SFI_DPF(struct S_DPF p0, float p1, int p2,  void (*cb)(struct S_DPF, float, int)) ;
+EXPORT void f7_V_SFI_DPD(struct S_DPD p0, float p1, int p2,  void (*cb)(struct S_DPD, float, int)) ;
+EXPORT void f7_V_SFI_DPP(struct S_DPP p0, float p1, int p2,  void (*cb)(struct S_DPP, float, int)) ;
+EXPORT void f7_V_SFI_PII(struct S_PII p0, float p1, int p2,  void (*cb)(struct S_PII, float, int)) ;
+EXPORT void f7_V_SFI_PIF(struct S_PIF p0, float p1, int p2,  void (*cb)(struct S_PIF, float, int)) ;
+EXPORT void f7_V_SFI_PID(struct S_PID p0, float p1, int p2,  void (*cb)(struct S_PID, float, int)) ;
+EXPORT void f7_V_SFI_PIP(struct S_PIP p0, float p1, int p2,  void (*cb)(struct S_PIP, float, int)) ;
+EXPORT void f7_V_SFI_PFI(struct S_PFI p0, float p1, int p2,  void (*cb)(struct S_PFI, float, int)) ;
+EXPORT void f7_V_SFI_PFF(struct S_PFF p0, float p1, int p2,  void (*cb)(struct S_PFF, float, int)) ;
+EXPORT void f7_V_SFI_PFD(struct S_PFD p0, float p1, int p2,  void (*cb)(struct S_PFD, float, int)) ;
+EXPORT void f7_V_SFI_PFP(struct S_PFP p0, float p1, int p2,  void (*cb)(struct S_PFP, float, int)) ;
+EXPORT void f7_V_SFI_PDI(struct S_PDI p0, float p1, int p2,  void (*cb)(struct S_PDI, float, int)) ;
+EXPORT void f7_V_SFI_PDF(struct S_PDF p0, float p1, int p2,  void (*cb)(struct S_PDF, float, int)) ;
+EXPORT void f7_V_SFI_PDD(struct S_PDD p0, float p1, int p2,  void (*cb)(struct S_PDD, float, int)) ;
+EXPORT void f7_V_SFI_PDP(struct S_PDP p0, float p1, int p2,  void (*cb)(struct S_PDP, float, int)) ;
+EXPORT void f7_V_SFI_PPI(struct S_PPI p0, float p1, int p2,  void (*cb)(struct S_PPI, float, int)) ;
+EXPORT void f7_V_SFI_PPF(struct S_PPF p0, float p1, int p2,  void (*cb)(struct S_PPF, float, int)) ;
+EXPORT void f7_V_SFI_PPD(struct S_PPD p0, float p1, int p2,  void (*cb)(struct S_PPD, float, int)) ;
+EXPORT void f7_V_SFI_PPP(struct S_PPP p0, float p1, int p2,  void (*cb)(struct S_PPP, float, int)) ;
+EXPORT void f7_V_SFF_I(struct S_I p0, float p1, float p2,  void (*cb)(struct S_I, float, float)) ;
+EXPORT void f7_V_SFF_F(struct S_F p0, float p1, float p2,  void (*cb)(struct S_F, float, float)) ;
+EXPORT void f7_V_SFF_D(struct S_D p0, float p1, float p2,  void (*cb)(struct S_D, float, float)) ;
+EXPORT void f7_V_SFF_P(struct S_P p0, float p1, float p2,  void (*cb)(struct S_P, float, float)) ;
+EXPORT void f7_V_SFF_II(struct S_II p0, float p1, float p2,  void (*cb)(struct S_II, float, float)) ;
+EXPORT void f7_V_SFF_IF(struct S_IF p0, float p1, float p2,  void (*cb)(struct S_IF, float, float)) ;
+EXPORT void f7_V_SFF_ID(struct S_ID p0, float p1, float p2,  void (*cb)(struct S_ID, float, float)) ;
+EXPORT void f7_V_SFF_IP(struct S_IP p0, float p1, float p2,  void (*cb)(struct S_IP, float, float)) ;
+EXPORT void f7_V_SFF_FI(struct S_FI p0, float p1, float p2,  void (*cb)(struct S_FI, float, float)) ;
+EXPORT void f7_V_SFF_FF(struct S_FF p0, float p1, float p2,  void (*cb)(struct S_FF, float, float)) ;
+EXPORT void f7_V_SFF_FD(struct S_FD p0, float p1, float p2,  void (*cb)(struct S_FD, float, float)) ;
+EXPORT void f7_V_SFF_FP(struct S_FP p0, float p1, float p2,  void (*cb)(struct S_FP, float, float)) ;
+EXPORT void f7_V_SFF_DI(struct S_DI p0, float p1, float p2,  void (*cb)(struct S_DI, float, float)) ;
+EXPORT void f7_V_SFF_DF(struct S_DF p0, float p1, float p2,  void (*cb)(struct S_DF, float, float)) ;
+EXPORT void f7_V_SFF_DD(struct S_DD p0, float p1, float p2,  void (*cb)(struct S_DD, float, float)) ;
+EXPORT void f7_V_SFF_DP(struct S_DP p0, float p1, float p2,  void (*cb)(struct S_DP, float, float)) ;
+EXPORT void f7_V_SFF_PI(struct S_PI p0, float p1, float p2,  void (*cb)(struct S_PI, float, float)) ;
+EXPORT void f7_V_SFF_PF(struct S_PF p0, float p1, float p2,  void (*cb)(struct S_PF, float, float)) ;
+EXPORT void f7_V_SFF_PD(struct S_PD p0, float p1, float p2,  void (*cb)(struct S_PD, float, float)) ;
+EXPORT void f7_V_SFF_PP(struct S_PP p0, float p1, float p2,  void (*cb)(struct S_PP, float, float)) ;
+EXPORT void f7_V_SFF_III(struct S_III p0, float p1, float p2,  void (*cb)(struct S_III, float, float)) ;
+EXPORT void f7_V_SFF_IIF(struct S_IIF p0, float p1, float p2,  void (*cb)(struct S_IIF, float, float)) ;
+EXPORT void f7_V_SFF_IID(struct S_IID p0, float p1, float p2,  void (*cb)(struct S_IID, float, float)) ;
+EXPORT void f7_V_SFF_IIP(struct S_IIP p0, float p1, float p2,  void (*cb)(struct S_IIP, float, float)) ;
+EXPORT void f7_V_SFF_IFI(struct S_IFI p0, float p1, float p2,  void (*cb)(struct S_IFI, float, float)) ;
+EXPORT void f7_V_SFF_IFF(struct S_IFF p0, float p1, float p2,  void (*cb)(struct S_IFF, float, float)) ;
+EXPORT void f7_V_SFF_IFD(struct S_IFD p0, float p1, float p2,  void (*cb)(struct S_IFD, float, float)) ;
+EXPORT void f7_V_SFF_IFP(struct S_IFP p0, float p1, float p2,  void (*cb)(struct S_IFP, float, float)) ;
+EXPORT void f7_V_SFF_IDI(struct S_IDI p0, float p1, float p2,  void (*cb)(struct S_IDI, float, float)) ;
+EXPORT void f7_V_SFF_IDF(struct S_IDF p0, float p1, float p2,  void (*cb)(struct S_IDF, float, float)) ;
+EXPORT void f7_V_SFF_IDD(struct S_IDD p0, float p1, float p2,  void (*cb)(struct S_IDD, float, float)) ;
+EXPORT void f7_V_SFF_IDP(struct S_IDP p0, float p1, float p2,  void (*cb)(struct S_IDP, float, float)) ;
+EXPORT void f7_V_SFF_IPI(struct S_IPI p0, float p1, float p2,  void (*cb)(struct S_IPI, float, float)) ;
+EXPORT void f7_V_SFF_IPF(struct S_IPF p0, float p1, float p2,  void (*cb)(struct S_IPF, float, float)) ;
+EXPORT void f7_V_SFF_IPD(struct S_IPD p0, float p1, float p2,  void (*cb)(struct S_IPD, float, float)) ;
+EXPORT void f7_V_SFF_IPP(struct S_IPP p0, float p1, float p2,  void (*cb)(struct S_IPP, float, float)) ;
+EXPORT void f7_V_SFF_FII(struct S_FII p0, float p1, float p2,  void (*cb)(struct S_FII, float, float)) ;
+EXPORT void f7_V_SFF_FIF(struct S_FIF p0, float p1, float p2,  void (*cb)(struct S_FIF, float, float)) ;
+EXPORT void f7_V_SFF_FID(struct S_FID p0, float p1, float p2,  void (*cb)(struct S_FID, float, float)) ;
+EXPORT void f7_V_SFF_FIP(struct S_FIP p0, float p1, float p2,  void (*cb)(struct S_FIP, float, float)) ;
+EXPORT void f7_V_SFF_FFI(struct S_FFI p0, float p1, float p2,  void (*cb)(struct S_FFI, float, float)) ;
+EXPORT void f7_V_SFF_FFF(struct S_FFF p0, float p1, float p2,  void (*cb)(struct S_FFF, float, float)) ;
+EXPORT void f7_V_SFF_FFD(struct S_FFD p0, float p1, float p2,  void (*cb)(struct S_FFD, float, float)) ;
+EXPORT void f7_V_SFF_FFP(struct S_FFP p0, float p1, float p2,  void (*cb)(struct S_FFP, float, float)) ;
+EXPORT void f7_V_SFF_FDI(struct S_FDI p0, float p1, float p2,  void (*cb)(struct S_FDI, float, float)) ;
+EXPORT void f7_V_SFF_FDF(struct S_FDF p0, float p1, float p2,  void (*cb)(struct S_FDF, float, float)) ;
+EXPORT void f7_V_SFF_FDD(struct S_FDD p0, float p1, float p2,  void (*cb)(struct S_FDD, float, float)) ;
+EXPORT void f7_V_SFF_FDP(struct S_FDP p0, float p1, float p2,  void (*cb)(struct S_FDP, float, float)) ;
+EXPORT void f7_V_SFF_FPI(struct S_FPI p0, float p1, float p2,  void (*cb)(struct S_FPI, float, float)) ;
+EXPORT void f7_V_SFF_FPF(struct S_FPF p0, float p1, float p2,  void (*cb)(struct S_FPF, float, float)) ;
+EXPORT void f7_V_SFF_FPD(struct S_FPD p0, float p1, float p2,  void (*cb)(struct S_FPD, float, float)) ;
+EXPORT void f7_V_SFF_FPP(struct S_FPP p0, float p1, float p2,  void (*cb)(struct S_FPP, float, float)) ;
+EXPORT void f7_V_SFF_DII(struct S_DII p0, float p1, float p2,  void (*cb)(struct S_DII, float, float)) ;
+EXPORT void f7_V_SFF_DIF(struct S_DIF p0, float p1, float p2,  void (*cb)(struct S_DIF, float, float)) ;
+EXPORT void f7_V_SFF_DID(struct S_DID p0, float p1, float p2,  void (*cb)(struct S_DID, float, float)) ;
+EXPORT void f7_V_SFF_DIP(struct S_DIP p0, float p1, float p2,  void (*cb)(struct S_DIP, float, float)) ;
+EXPORT void f7_V_SFF_DFI(struct S_DFI p0, float p1, float p2,  void (*cb)(struct S_DFI, float, float)) ;
+EXPORT void f7_V_SFF_DFF(struct S_DFF p0, float p1, float p2,  void (*cb)(struct S_DFF, float, float)) ;
+EXPORT void f7_V_SFF_DFD(struct S_DFD p0, float p1, float p2,  void (*cb)(struct S_DFD, float, float)) ;
+EXPORT void f7_V_SFF_DFP(struct S_DFP p0, float p1, float p2,  void (*cb)(struct S_DFP, float, float)) ;
+EXPORT void f7_V_SFF_DDI(struct S_DDI p0, float p1, float p2,  void (*cb)(struct S_DDI, float, float)) ;
+EXPORT void f7_V_SFF_DDF(struct S_DDF p0, float p1, float p2,  void (*cb)(struct S_DDF, float, float)) ;
+EXPORT void f7_V_SFF_DDD(struct S_DDD p0, float p1, float p2,  void (*cb)(struct S_DDD, float, float)) ;
+EXPORT void f7_V_SFF_DDP(struct S_DDP p0, float p1, float p2,  void (*cb)(struct S_DDP, float, float)) ;
+EXPORT void f7_V_SFF_DPI(struct S_DPI p0, float p1, float p2,  void (*cb)(struct S_DPI, float, float)) ;
+EXPORT void f7_V_SFF_DPF(struct S_DPF p0, float p1, float p2,  void (*cb)(struct S_DPF, float, float)) ;
+EXPORT void f7_V_SFF_DPD(struct S_DPD p0, float p1, float p2,  void (*cb)(struct S_DPD, float, float)) ;
+EXPORT void f7_V_SFF_DPP(struct S_DPP p0, float p1, float p2,  void (*cb)(struct S_DPP, float, float)) ;
+EXPORT void f7_V_SFF_PII(struct S_PII p0, float p1, float p2,  void (*cb)(struct S_PII, float, float)) ;
+EXPORT void f7_V_SFF_PIF(struct S_PIF p0, float p1, float p2,  void (*cb)(struct S_PIF, float, float)) ;
+EXPORT void f7_V_SFF_PID(struct S_PID p0, float p1, float p2,  void (*cb)(struct S_PID, float, float)) ;
+EXPORT void f7_V_SFF_PIP(struct S_PIP p0, float p1, float p2,  void (*cb)(struct S_PIP, float, float)) ;
+EXPORT void f7_V_SFF_PFI(struct S_PFI p0, float p1, float p2,  void (*cb)(struct S_PFI, float, float)) ;
+EXPORT void f7_V_SFF_PFF(struct S_PFF p0, float p1, float p2,  void (*cb)(struct S_PFF, float, float)) ;
+EXPORT void f7_V_SFF_PFD(struct S_PFD p0, float p1, float p2,  void (*cb)(struct S_PFD, float, float)) ;
+EXPORT void f7_V_SFF_PFP(struct S_PFP p0, float p1, float p2,  void (*cb)(struct S_PFP, float, float)) ;
+EXPORT void f7_V_SFF_PDI(struct S_PDI p0, float p1, float p2,  void (*cb)(struct S_PDI, float, float)) ;
+EXPORT void f7_V_SFF_PDF(struct S_PDF p0, float p1, float p2,  void (*cb)(struct S_PDF, float, float)) ;
+EXPORT void f7_V_SFF_PDD(struct S_PDD p0, float p1, float p2,  void (*cb)(struct S_PDD, float, float)) ;
+EXPORT void f7_V_SFF_PDP(struct S_PDP p0, float p1, float p2,  void (*cb)(struct S_PDP, float, float)) ;
+EXPORT void f7_V_SFF_PPI(struct S_PPI p0, float p1, float p2,  void (*cb)(struct S_PPI, float, float)) ;
+EXPORT void f7_V_SFF_PPF(struct S_PPF p0, float p1, float p2,  void (*cb)(struct S_PPF, float, float)) ;
+EXPORT void f7_V_SFF_PPD(struct S_PPD p0, float p1, float p2,  void (*cb)(struct S_PPD, float, float)) ;
+EXPORT void f7_V_SFF_PPP(struct S_PPP p0, float p1, float p2,  void (*cb)(struct S_PPP, float, float)) ;
+EXPORT void f7_V_SFD_I(struct S_I p0, float p1, double p2,  void (*cb)(struct S_I, float, double)) ;
+EXPORT void f7_V_SFD_F(struct S_F p0, float p1, double p2,  void (*cb)(struct S_F, float, double)) ;
+EXPORT void f7_V_SFD_D(struct S_D p0, float p1, double p2,  void (*cb)(struct S_D, float, double)) ;
+EXPORT void f7_V_SFD_P(struct S_P p0, float p1, double p2,  void (*cb)(struct S_P, float, double)) ;
+EXPORT void f7_V_SFD_II(struct S_II p0, float p1, double p2,  void (*cb)(struct S_II, float, double)) ;
+EXPORT void f7_V_SFD_IF(struct S_IF p0, float p1, double p2,  void (*cb)(struct S_IF, float, double)) ;
+EXPORT void f7_V_SFD_ID(struct S_ID p0, float p1, double p2,  void (*cb)(struct S_ID, float, double)) ;
+EXPORT void f7_V_SFD_IP(struct S_IP p0, float p1, double p2,  void (*cb)(struct S_IP, float, double)) ;
+EXPORT void f7_V_SFD_FI(struct S_FI p0, float p1, double p2,  void (*cb)(struct S_FI, float, double)) ;
+EXPORT void f7_V_SFD_FF(struct S_FF p0, float p1, double p2,  void (*cb)(struct S_FF, float, double)) ;
+EXPORT void f7_V_SFD_FD(struct S_FD p0, float p1, double p2,  void (*cb)(struct S_FD, float, double)) ;
+EXPORT void f7_V_SFD_FP(struct S_FP p0, float p1, double p2,  void (*cb)(struct S_FP, float, double)) ;
+EXPORT void f7_V_SFD_DI(struct S_DI p0, float p1, double p2,  void (*cb)(struct S_DI, float, double)) ;
+EXPORT void f7_V_SFD_DF(struct S_DF p0, float p1, double p2,  void (*cb)(struct S_DF, float, double)) ;
+EXPORT void f7_V_SFD_DD(struct S_DD p0, float p1, double p2,  void (*cb)(struct S_DD, float, double)) ;
+EXPORT void f7_V_SFD_DP(struct S_DP p0, float p1, double p2,  void (*cb)(struct S_DP, float, double)) ;
+EXPORT void f7_V_SFD_PI(struct S_PI p0, float p1, double p2,  void (*cb)(struct S_PI, float, double)) ;
+EXPORT void f7_V_SFD_PF(struct S_PF p0, float p1, double p2,  void (*cb)(struct S_PF, float, double)) ;
+EXPORT void f7_V_SFD_PD(struct S_PD p0, float p1, double p2,  void (*cb)(struct S_PD, float, double)) ;
+EXPORT void f7_V_SFD_PP(struct S_PP p0, float p1, double p2,  void (*cb)(struct S_PP, float, double)) ;
+EXPORT void f7_V_SFD_III(struct S_III p0, float p1, double p2,  void (*cb)(struct S_III, float, double)) ;
+EXPORT void f7_V_SFD_IIF(struct S_IIF p0, float p1, double p2,  void (*cb)(struct S_IIF, float, double)) ;
+EXPORT void f7_V_SFD_IID(struct S_IID p0, float p1, double p2,  void (*cb)(struct S_IID, float, double)) ;
+EXPORT void f7_V_SFD_IIP(struct S_IIP p0, float p1, double p2,  void (*cb)(struct S_IIP, float, double)) ;
+EXPORT void f7_V_SFD_IFI(struct S_IFI p0, float p1, double p2,  void (*cb)(struct S_IFI, float, double)) ;
+EXPORT void f7_V_SFD_IFF(struct S_IFF p0, float p1, double p2,  void (*cb)(struct S_IFF, float, double)) ;
+EXPORT void f7_V_SFD_IFD(struct S_IFD p0, float p1, double p2,  void (*cb)(struct S_IFD, float, double)) ;
+EXPORT void f7_V_SFD_IFP(struct S_IFP p0, float p1, double p2,  void (*cb)(struct S_IFP, float, double)) ;
+EXPORT void f7_V_SFD_IDI(struct S_IDI p0, float p1, double p2,  void (*cb)(struct S_IDI, float, double)) ;
+EXPORT void f7_V_SFD_IDF(struct S_IDF p0, float p1, double p2,  void (*cb)(struct S_IDF, float, double)) ;
+EXPORT void f7_V_SFD_IDD(struct S_IDD p0, float p1, double p2,  void (*cb)(struct S_IDD, float, double)) ;
+EXPORT void f7_V_SFD_IDP(struct S_IDP p0, float p1, double p2,  void (*cb)(struct S_IDP, float, double)) ;
+EXPORT void f7_V_SFD_IPI(struct S_IPI p0, float p1, double p2,  void (*cb)(struct S_IPI, float, double)) ;
+EXPORT void f7_V_SFD_IPF(struct S_IPF p0, float p1, double p2,  void (*cb)(struct S_IPF, float, double)) ;
+EXPORT void f7_V_SFD_IPD(struct S_IPD p0, float p1, double p2,  void (*cb)(struct S_IPD, float, double)) ;
+EXPORT void f7_V_SFD_IPP(struct S_IPP p0, float p1, double p2,  void (*cb)(struct S_IPP, float, double)) ;
+EXPORT void f7_V_SFD_FII(struct S_FII p0, float p1, double p2,  void (*cb)(struct S_FII, float, double)) ;
+EXPORT void f7_V_SFD_FIF(struct S_FIF p0, float p1, double p2,  void (*cb)(struct S_FIF, float, double)) ;
+EXPORT void f7_V_SFD_FID(struct S_FID p0, float p1, double p2,  void (*cb)(struct S_FID, float, double)) ;
+EXPORT void f7_V_SFD_FIP(struct S_FIP p0, float p1, double p2,  void (*cb)(struct S_FIP, float, double)) ;
+EXPORT void f7_V_SFD_FFI(struct S_FFI p0, float p1, double p2,  void (*cb)(struct S_FFI, float, double)) ;
+EXPORT void f7_V_SFD_FFF(struct S_FFF p0, float p1, double p2,  void (*cb)(struct S_FFF, float, double)) ;
+EXPORT void f7_V_SFD_FFD(struct S_FFD p0, float p1, double p2,  void (*cb)(struct S_FFD, float, double)) ;
+EXPORT void f7_V_SFD_FFP(struct S_FFP p0, float p1, double p2,  void (*cb)(struct S_FFP, float, double)) ;
+EXPORT void f7_V_SFD_FDI(struct S_FDI p0, float p1, double p2,  void (*cb)(struct S_FDI, float, double)) ;
+EXPORT void f7_V_SFD_FDF(struct S_FDF p0, float p1, double p2,  void (*cb)(struct S_FDF, float, double)) ;
+EXPORT void f7_V_SFD_FDD(struct S_FDD p0, float p1, double p2,  void (*cb)(struct S_FDD, float, double)) ;
+EXPORT void f7_V_SFD_FDP(struct S_FDP p0, float p1, double p2,  void (*cb)(struct S_FDP, float, double)) ;
+EXPORT void f7_V_SFD_FPI(struct S_FPI p0, float p1, double p2,  void (*cb)(struct S_FPI, float, double)) ;
+EXPORT void f7_V_SFD_FPF(struct S_FPF p0, float p1, double p2,  void (*cb)(struct S_FPF, float, double)) ;
+EXPORT void f7_V_SFD_FPD(struct S_FPD p0, float p1, double p2,  void (*cb)(struct S_FPD, float, double)) ;
+EXPORT void f7_V_SFD_FPP(struct S_FPP p0, float p1, double p2,  void (*cb)(struct S_FPP, float, double)) ;
+EXPORT void f7_V_SFD_DII(struct S_DII p0, float p1, double p2,  void (*cb)(struct S_DII, float, double)) ;
+EXPORT void f7_V_SFD_DIF(struct S_DIF p0, float p1, double p2,  void (*cb)(struct S_DIF, float, double)) ;
+EXPORT void f7_V_SFD_DID(struct S_DID p0, float p1, double p2,  void (*cb)(struct S_DID, float, double)) ;
+EXPORT void f7_V_SFD_DIP(struct S_DIP p0, float p1, double p2,  void (*cb)(struct S_DIP, float, double)) ;
+EXPORT void f7_V_SFD_DFI(struct S_DFI p0, float p1, double p2,  void (*cb)(struct S_DFI, float, double)) ;
+EXPORT void f7_V_SFD_DFF(struct S_DFF p0, float p1, double p2,  void (*cb)(struct S_DFF, float, double)) ;
+EXPORT void f7_V_SFD_DFD(struct S_DFD p0, float p1, double p2,  void (*cb)(struct S_DFD, float, double)) ;
+EXPORT void f7_V_SFD_DFP(struct S_DFP p0, float p1, double p2,  void (*cb)(struct S_DFP, float, double)) ;
+EXPORT void f7_V_SFD_DDI(struct S_DDI p0, float p1, double p2,  void (*cb)(struct S_DDI, float, double)) ;
+EXPORT void f7_V_SFD_DDF(struct S_DDF p0, float p1, double p2,  void (*cb)(struct S_DDF, float, double)) ;
+EXPORT void f7_V_SFD_DDD(struct S_DDD p0, float p1, double p2,  void (*cb)(struct S_DDD, float, double)) ;
+EXPORT void f7_V_SFD_DDP(struct S_DDP p0, float p1, double p2,  void (*cb)(struct S_DDP, float, double)) ;
+EXPORT void f7_V_SFD_DPI(struct S_DPI p0, float p1, double p2,  void (*cb)(struct S_DPI, float, double)) ;
+EXPORT void f7_V_SFD_DPF(struct S_DPF p0, float p1, double p2,  void (*cb)(struct S_DPF, float, double)) ;
+EXPORT void f7_V_SFD_DPD(struct S_DPD p0, float p1, double p2,  void (*cb)(struct S_DPD, float, double)) ;
+EXPORT void f7_V_SFD_DPP(struct S_DPP p0, float p1, double p2,  void (*cb)(struct S_DPP, float, double)) ;
+EXPORT void f7_V_SFD_PII(struct S_PII p0, float p1, double p2,  void (*cb)(struct S_PII, float, double)) ;
+EXPORT void f7_V_SFD_PIF(struct S_PIF p0, float p1, double p2,  void (*cb)(struct S_PIF, float, double)) ;
+EXPORT void f7_V_SFD_PID(struct S_PID p0, float p1, double p2,  void (*cb)(struct S_PID, float, double)) ;
+EXPORT void f7_V_SFD_PIP(struct S_PIP p0, float p1, double p2,  void (*cb)(struct S_PIP, float, double)) ;
+EXPORT void f7_V_SFD_PFI(struct S_PFI p0, float p1, double p2,  void (*cb)(struct S_PFI, float, double)) ;
+EXPORT void f7_V_SFD_PFF(struct S_PFF p0, float p1, double p2,  void (*cb)(struct S_PFF, float, double)) ;
+EXPORT void f7_V_SFD_PFD(struct S_PFD p0, float p1, double p2,  void (*cb)(struct S_PFD, float, double)) ;
+EXPORT void f7_V_SFD_PFP(struct S_PFP p0, float p1, double p2,  void (*cb)(struct S_PFP, float, double)) ;
+EXPORT void f7_V_SFD_PDI(struct S_PDI p0, float p1, double p2,  void (*cb)(struct S_PDI, float, double)) ;
+EXPORT void f7_V_SFD_PDF(struct S_PDF p0, float p1, double p2,  void (*cb)(struct S_PDF, float, double)) ;
+EXPORT void f7_V_SFD_PDD(struct S_PDD p0, float p1, double p2,  void (*cb)(struct S_PDD, float, double)) ;
+EXPORT void f7_V_SFD_PDP(struct S_PDP p0, float p1, double p2,  void (*cb)(struct S_PDP, float, double)) ;
+EXPORT void f7_V_SFD_PPI(struct S_PPI p0, float p1, double p2,  void (*cb)(struct S_PPI, float, double)) ;
+EXPORT void f7_V_SFD_PPF(struct S_PPF p0, float p1, double p2,  void (*cb)(struct S_PPF, float, double)) ;
+EXPORT void f7_V_SFD_PPD(struct S_PPD p0, float p1, double p2,  void (*cb)(struct S_PPD, float, double)) ;
+EXPORT void f7_V_SFD_PPP(struct S_PPP p0, float p1, double p2,  void (*cb)(struct S_PPP, float, double)) ;
+EXPORT void f7_V_SFP_I(struct S_I p0, float p1, void* p2,  void (*cb)(struct S_I, float, void*)) ;
+EXPORT void f7_V_SFP_F(struct S_F p0, float p1, void* p2,  void (*cb)(struct S_F, float, void*)) ;
+EXPORT void f7_V_SFP_D(struct S_D p0, float p1, void* p2,  void (*cb)(struct S_D, float, void*)) ;
+EXPORT void f7_V_SFP_P(struct S_P p0, float p1, void* p2,  void (*cb)(struct S_P, float, void*)) ;
+EXPORT void f7_V_SFP_II(struct S_II p0, float p1, void* p2,  void (*cb)(struct S_II, float, void*)) ;
+EXPORT void f7_V_SFP_IF(struct S_IF p0, float p1, void* p2,  void (*cb)(struct S_IF, float, void*)) ;
+EXPORT void f7_V_SFP_ID(struct S_ID p0, float p1, void* p2,  void (*cb)(struct S_ID, float, void*)) ;
+EXPORT void f7_V_SFP_IP(struct S_IP p0, float p1, void* p2,  void (*cb)(struct S_IP, float, void*)) ;
+EXPORT void f7_V_SFP_FI(struct S_FI p0, float p1, void* p2,  void (*cb)(struct S_FI, float, void*)) ;
+EXPORT void f7_V_SFP_FF(struct S_FF p0, float p1, void* p2,  void (*cb)(struct S_FF, float, void*)) ;
+EXPORT void f7_V_SFP_FD(struct S_FD p0, float p1, void* p2,  void (*cb)(struct S_FD, float, void*)) ;
+EXPORT void f7_V_SFP_FP(struct S_FP p0, float p1, void* p2,  void (*cb)(struct S_FP, float, void*)) ;
+EXPORT void f7_V_SFP_DI(struct S_DI p0, float p1, void* p2,  void (*cb)(struct S_DI, float, void*)) ;
+EXPORT void f7_V_SFP_DF(struct S_DF p0, float p1, void* p2,  void (*cb)(struct S_DF, float, void*)) ;
+EXPORT void f7_V_SFP_DD(struct S_DD p0, float p1, void* p2,  void (*cb)(struct S_DD, float, void*)) ;
+EXPORT void f7_V_SFP_DP(struct S_DP p0, float p1, void* p2,  void (*cb)(struct S_DP, float, void*)) ;
+EXPORT void f7_V_SFP_PI(struct S_PI p0, float p1, void* p2,  void (*cb)(struct S_PI, float, void*)) ;
+EXPORT void f7_V_SFP_PF(struct S_PF p0, float p1, void* p2,  void (*cb)(struct S_PF, float, void*)) ;
+EXPORT void f7_V_SFP_PD(struct S_PD p0, float p1, void* p2,  void (*cb)(struct S_PD, float, void*)) ;
+EXPORT void f7_V_SFP_PP(struct S_PP p0, float p1, void* p2,  void (*cb)(struct S_PP, float, void*)) ;
+EXPORT void f7_V_SFP_III(struct S_III p0, float p1, void* p2,  void (*cb)(struct S_III, float, void*)) ;
+EXPORT void f7_V_SFP_IIF(struct S_IIF p0, float p1, void* p2,  void (*cb)(struct S_IIF, float, void*)) ;
+EXPORT void f7_V_SFP_IID(struct S_IID p0, float p1, void* p2,  void (*cb)(struct S_IID, float, void*)) ;
+EXPORT void f7_V_SFP_IIP(struct S_IIP p0, float p1, void* p2,  void (*cb)(struct S_IIP, float, void*)) ;
+EXPORT void f7_V_SFP_IFI(struct S_IFI p0, float p1, void* p2,  void (*cb)(struct S_IFI, float, void*)) ;
+EXPORT void f7_V_SFP_IFF(struct S_IFF p0, float p1, void* p2,  void (*cb)(struct S_IFF, float, void*)) ;
+EXPORT void f7_V_SFP_IFD(struct S_IFD p0, float p1, void* p2,  void (*cb)(struct S_IFD, float, void*)) ;
+EXPORT void f7_V_SFP_IFP(struct S_IFP p0, float p1, void* p2,  void (*cb)(struct S_IFP, float, void*)) ;
+EXPORT void f7_V_SFP_IDI(struct S_IDI p0, float p1, void* p2,  void (*cb)(struct S_IDI, float, void*)) ;
+EXPORT void f7_V_SFP_IDF(struct S_IDF p0, float p1, void* p2,  void (*cb)(struct S_IDF, float, void*)) ;
+EXPORT void f7_V_SFP_IDD(struct S_IDD p0, float p1, void* p2,  void (*cb)(struct S_IDD, float, void*)) ;
+EXPORT void f7_V_SFP_IDP(struct S_IDP p0, float p1, void* p2,  void (*cb)(struct S_IDP, float, void*)) ;
+EXPORT void f7_V_SFP_IPI(struct S_IPI p0, float p1, void* p2,  void (*cb)(struct S_IPI, float, void*)) ;
+EXPORT void f7_V_SFP_IPF(struct S_IPF p0, float p1, void* p2,  void (*cb)(struct S_IPF, float, void*)) ;
+EXPORT void f7_V_SFP_IPD(struct S_IPD p0, float p1, void* p2,  void (*cb)(struct S_IPD, float, void*)) ;
+EXPORT void f7_V_SFP_IPP(struct S_IPP p0, float p1, void* p2,  void (*cb)(struct S_IPP, float, void*)) ;
+EXPORT void f7_V_SFP_FII(struct S_FII p0, float p1, void* p2,  void (*cb)(struct S_FII, float, void*)) ;
+EXPORT void f7_V_SFP_FIF(struct S_FIF p0, float p1, void* p2,  void (*cb)(struct S_FIF, float, void*)) ;
+EXPORT void f7_V_SFP_FID(struct S_FID p0, float p1, void* p2,  void (*cb)(struct S_FID, float, void*)) ;
+EXPORT void f7_V_SFP_FIP(struct S_FIP p0, float p1, void* p2,  void (*cb)(struct S_FIP, float, void*)) ;
+EXPORT void f7_V_SFP_FFI(struct S_FFI p0, float p1, void* p2,  void (*cb)(struct S_FFI, float, void*)) ;
+EXPORT void f7_V_SFP_FFF(struct S_FFF p0, float p1, void* p2,  void (*cb)(struct S_FFF, float, void*)) ;
+EXPORT void f7_V_SFP_FFD(struct S_FFD p0, float p1, void* p2,  void (*cb)(struct S_FFD, float, void*)) ;
+EXPORT void f7_V_SFP_FFP(struct S_FFP p0, float p1, void* p2,  void (*cb)(struct S_FFP, float, void*)) ;
+EXPORT void f7_V_SFP_FDI(struct S_FDI p0, float p1, void* p2,  void (*cb)(struct S_FDI, float, void*)) ;
+EXPORT void f7_V_SFP_FDF(struct S_FDF p0, float p1, void* p2,  void (*cb)(struct S_FDF, float, void*)) ;
+EXPORT void f7_V_SFP_FDD(struct S_FDD p0, float p1, void* p2,  void (*cb)(struct S_FDD, float, void*)) ;
+EXPORT void f7_V_SFP_FDP(struct S_FDP p0, float p1, void* p2,  void (*cb)(struct S_FDP, float, void*)) ;
+EXPORT void f7_V_SFP_FPI(struct S_FPI p0, float p1, void* p2,  void (*cb)(struct S_FPI, float, void*)) ;
+EXPORT void f7_V_SFP_FPF(struct S_FPF p0, float p1, void* p2,  void (*cb)(struct S_FPF, float, void*)) ;
+EXPORT void f7_V_SFP_FPD(struct S_FPD p0, float p1, void* p2,  void (*cb)(struct S_FPD, float, void*)) ;
+EXPORT void f7_V_SFP_FPP(struct S_FPP p0, float p1, void* p2,  void (*cb)(struct S_FPP, float, void*)) ;
+EXPORT void f7_V_SFP_DII(struct S_DII p0, float p1, void* p2,  void (*cb)(struct S_DII, float, void*)) ;
+EXPORT void f7_V_SFP_DIF(struct S_DIF p0, float p1, void* p2,  void (*cb)(struct S_DIF, float, void*)) ;
+EXPORT void f7_V_SFP_DID(struct S_DID p0, float p1, void* p2,  void (*cb)(struct S_DID, float, void*)) ;
+EXPORT void f7_V_SFP_DIP(struct S_DIP p0, float p1, void* p2,  void (*cb)(struct S_DIP, float, void*)) ;
+EXPORT void f7_V_SFP_DFI(struct S_DFI p0, float p1, void* p2,  void (*cb)(struct S_DFI, float, void*)) ;
+EXPORT void f7_V_SFP_DFF(struct S_DFF p0, float p1, void* p2,  void (*cb)(struct S_DFF, float, void*)) ;
+EXPORT void f7_V_SFP_DFD(struct S_DFD p0, float p1, void* p2,  void (*cb)(struct S_DFD, float, void*)) ;
+EXPORT void f7_V_SFP_DFP(struct S_DFP p0, float p1, void* p2,  void (*cb)(struct S_DFP, float, void*)) ;
+EXPORT void f7_V_SFP_DDI(struct S_DDI p0, float p1, void* p2,  void (*cb)(struct S_DDI, float, void*)) ;
+EXPORT void f7_V_SFP_DDF(struct S_DDF p0, float p1, void* p2,  void (*cb)(struct S_DDF, float, void*)) ;
+EXPORT void f7_V_SFP_DDD(struct S_DDD p0, float p1, void* p2,  void (*cb)(struct S_DDD, float, void*)) ;
+EXPORT void f7_V_SFP_DDP(struct S_DDP p0, float p1, void* p2,  void (*cb)(struct S_DDP, float, void*)) ;
+EXPORT void f7_V_SFP_DPI(struct S_DPI p0, float p1, void* p2,  void (*cb)(struct S_DPI, float, void*)) ;
+EXPORT void f7_V_SFP_DPF(struct S_DPF p0, float p1, void* p2,  void (*cb)(struct S_DPF, float, void*)) ;
+EXPORT void f7_V_SFP_DPD(struct S_DPD p0, float p1, void* p2,  void (*cb)(struct S_DPD, float, void*)) ;
+EXPORT void f7_V_SFP_DPP(struct S_DPP p0, float p1, void* p2,  void (*cb)(struct S_DPP, float, void*)) ;
+EXPORT void f7_V_SFP_PII(struct S_PII p0, float p1, void* p2,  void (*cb)(struct S_PII, float, void*)) ;
+EXPORT void f7_V_SFP_PIF(struct S_PIF p0, float p1, void* p2,  void (*cb)(struct S_PIF, float, void*)) ;
+EXPORT void f7_V_SFP_PID(struct S_PID p0, float p1, void* p2,  void (*cb)(struct S_PID, float, void*)) ;
+EXPORT void f7_V_SFP_PIP(struct S_PIP p0, float p1, void* p2,  void (*cb)(struct S_PIP, float, void*)) ;
+EXPORT void f7_V_SFP_PFI(struct S_PFI p0, float p1, void* p2,  void (*cb)(struct S_PFI, float, void*)) ;
+EXPORT void f7_V_SFP_PFF(struct S_PFF p0, float p1, void* p2,  void (*cb)(struct S_PFF, float, void*)) ;
+EXPORT void f7_V_SFP_PFD(struct S_PFD p0, float p1, void* p2,  void (*cb)(struct S_PFD, float, void*)) ;
+EXPORT void f7_V_SFP_PFP(struct S_PFP p0, float p1, void* p2,  void (*cb)(struct S_PFP, float, void*)) ;
+EXPORT void f7_V_SFP_PDI(struct S_PDI p0, float p1, void* p2,  void (*cb)(struct S_PDI, float, void*)) ;
+EXPORT void f7_V_SFP_PDF(struct S_PDF p0, float p1, void* p2,  void (*cb)(struct S_PDF, float, void*)) ;
+EXPORT void f7_V_SFP_PDD(struct S_PDD p0, float p1, void* p2,  void (*cb)(struct S_PDD, float, void*)) ;
+EXPORT void f7_V_SFP_PDP(struct S_PDP p0, float p1, void* p2,  void (*cb)(struct S_PDP, float, void*)) ;
+EXPORT void f7_V_SFP_PPI(struct S_PPI p0, float p1, void* p2,  void (*cb)(struct S_PPI, float, void*)) ;
+EXPORT void f7_V_SFP_PPF(struct S_PPF p0, float p1, void* p2,  void (*cb)(struct S_PPF, float, void*)) ;
+EXPORT void f7_V_SFP_PPD(struct S_PPD p0, float p1, void* p2,  void (*cb)(struct S_PPD, float, void*)) ;
+EXPORT void f7_V_SFP_PPP(struct S_PPP p0, float p1, void* p2,  void (*cb)(struct S_PPP, float, void*)) ;
+EXPORT void f7_V_SFS_I(struct S_I p0, float p1, struct S_I p2,  void (*cb)(struct S_I, float, struct S_I)) ;
+EXPORT void f7_V_SFS_F(struct S_F p0, float p1, struct S_F p2,  void (*cb)(struct S_F, float, struct S_F)) ;
+EXPORT void f7_V_SFS_D(struct S_D p0, float p1, struct S_D p2,  void (*cb)(struct S_D, float, struct S_D)) ;
+EXPORT void f7_V_SFS_P(struct S_P p0, float p1, struct S_P p2,  void (*cb)(struct S_P, float, struct S_P)) ;
+EXPORT void f7_V_SFS_II(struct S_II p0, float p1, struct S_II p2,  void (*cb)(struct S_II, float, struct S_II)) ;
+EXPORT void f7_V_SFS_IF(struct S_IF p0, float p1, struct S_IF p2,  void (*cb)(struct S_IF, float, struct S_IF)) ;
+EXPORT void f7_V_SFS_ID(struct S_ID p0, float p1, struct S_ID p2,  void (*cb)(struct S_ID, float, struct S_ID)) ;
+EXPORT void f7_V_SFS_IP(struct S_IP p0, float p1, struct S_IP p2,  void (*cb)(struct S_IP, float, struct S_IP)) ;
+EXPORT void f7_V_SFS_FI(struct S_FI p0, float p1, struct S_FI p2,  void (*cb)(struct S_FI, float, struct S_FI)) ;
+EXPORT void f7_V_SFS_FF(struct S_FF p0, float p1, struct S_FF p2,  void (*cb)(struct S_FF, float, struct S_FF)) ;
+EXPORT void f7_V_SFS_FD(struct S_FD p0, float p1, struct S_FD p2,  void (*cb)(struct S_FD, float, struct S_FD)) ;
+EXPORT void f7_V_SFS_FP(struct S_FP p0, float p1, struct S_FP p2,  void (*cb)(struct S_FP, float, struct S_FP)) ;
+EXPORT void f7_V_SFS_DI(struct S_DI p0, float p1, struct S_DI p2,  void (*cb)(struct S_DI, float, struct S_DI)) ;
+EXPORT void f7_V_SFS_DF(struct S_DF p0, float p1, struct S_DF p2,  void (*cb)(struct S_DF, float, struct S_DF)) ;
+EXPORT void f7_V_SFS_DD(struct S_DD p0, float p1, struct S_DD p2,  void (*cb)(struct S_DD, float, struct S_DD)) ;
+EXPORT void f7_V_SFS_DP(struct S_DP p0, float p1, struct S_DP p2,  void (*cb)(struct S_DP, float, struct S_DP)) ;
+EXPORT void f7_V_SFS_PI(struct S_PI p0, float p1, struct S_PI p2,  void (*cb)(struct S_PI, float, struct S_PI)) ;
+EXPORT void f7_V_SFS_PF(struct S_PF p0, float p1, struct S_PF p2,  void (*cb)(struct S_PF, float, struct S_PF)) ;
+EXPORT void f7_V_SFS_PD(struct S_PD p0, float p1, struct S_PD p2,  void (*cb)(struct S_PD, float, struct S_PD)) ;
+EXPORT void f7_V_SFS_PP(struct S_PP p0, float p1, struct S_PP p2,  void (*cb)(struct S_PP, float, struct S_PP)) ;
+EXPORT void f7_V_SFS_III(struct S_III p0, float p1, struct S_III p2,  void (*cb)(struct S_III, float, struct S_III)) ;
+EXPORT void f7_V_SFS_IIF(struct S_IIF p0, float p1, struct S_IIF p2,  void (*cb)(struct S_IIF, float, struct S_IIF)) ;
+EXPORT void f7_V_SFS_IID(struct S_IID p0, float p1, struct S_IID p2,  void (*cb)(struct S_IID, float, struct S_IID)) ;
+EXPORT void f7_V_SFS_IIP(struct S_IIP p0, float p1, struct S_IIP p2,  void (*cb)(struct S_IIP, float, struct S_IIP)) ;
+EXPORT void f7_V_SFS_IFI(struct S_IFI p0, float p1, struct S_IFI p2,  void (*cb)(struct S_IFI, float, struct S_IFI)) ;
+EXPORT void f7_V_SFS_IFF(struct S_IFF p0, float p1, struct S_IFF p2,  void (*cb)(struct S_IFF, float, struct S_IFF)) ;
+EXPORT void f7_V_SFS_IFD(struct S_IFD p0, float p1, struct S_IFD p2,  void (*cb)(struct S_IFD, float, struct S_IFD)) ;
+EXPORT void f7_V_SFS_IFP(struct S_IFP p0, float p1, struct S_IFP p2,  void (*cb)(struct S_IFP, float, struct S_IFP)) ;
+EXPORT void f7_V_SFS_IDI(struct S_IDI p0, float p1, struct S_IDI p2,  void (*cb)(struct S_IDI, float, struct S_IDI)) ;
+EXPORT void f7_V_SFS_IDF(struct S_IDF p0, float p1, struct S_IDF p2,  void (*cb)(struct S_IDF, float, struct S_IDF)) ;
+EXPORT void f7_V_SFS_IDD(struct S_IDD p0, float p1, struct S_IDD p2,  void (*cb)(struct S_IDD, float, struct S_IDD)) ;
+EXPORT void f7_V_SFS_IDP(struct S_IDP p0, float p1, struct S_IDP p2,  void (*cb)(struct S_IDP, float, struct S_IDP)) ;
+EXPORT void f7_V_SFS_IPI(struct S_IPI p0, float p1, struct S_IPI p2,  void (*cb)(struct S_IPI, float, struct S_IPI)) ;
+EXPORT void f7_V_SFS_IPF(struct S_IPF p0, float p1, struct S_IPF p2,  void (*cb)(struct S_IPF, float, struct S_IPF)) ;
+EXPORT void f7_V_SFS_IPD(struct S_IPD p0, float p1, struct S_IPD p2,  void (*cb)(struct S_IPD, float, struct S_IPD)) ;
+EXPORT void f7_V_SFS_IPP(struct S_IPP p0, float p1, struct S_IPP p2,  void (*cb)(struct S_IPP, float, struct S_IPP)) ;
+EXPORT void f7_V_SFS_FII(struct S_FII p0, float p1, struct S_FII p2,  void (*cb)(struct S_FII, float, struct S_FII)) ;
+EXPORT void f7_V_SFS_FIF(struct S_FIF p0, float p1, struct S_FIF p2,  void (*cb)(struct S_FIF, float, struct S_FIF)) ;
+EXPORT void f7_V_SFS_FID(struct S_FID p0, float p1, struct S_FID p2,  void (*cb)(struct S_FID, float, struct S_FID)) ;
+EXPORT void f7_V_SFS_FIP(struct S_FIP p0, float p1, struct S_FIP p2,  void (*cb)(struct S_FIP, float, struct S_FIP)) ;
+EXPORT void f7_V_SFS_FFI(struct S_FFI p0, float p1, struct S_FFI p2,  void (*cb)(struct S_FFI, float, struct S_FFI)) ;
+EXPORT void f7_V_SFS_FFF(struct S_FFF p0, float p1, struct S_FFF p2,  void (*cb)(struct S_FFF, float, struct S_FFF)) ;
+EXPORT void f7_V_SFS_FFD(struct S_FFD p0, float p1, struct S_FFD p2,  void (*cb)(struct S_FFD, float, struct S_FFD)) ;
+EXPORT void f7_V_SFS_FFP(struct S_FFP p0, float p1, struct S_FFP p2,  void (*cb)(struct S_FFP, float, struct S_FFP)) ;
+EXPORT void f7_V_SFS_FDI(struct S_FDI p0, float p1, struct S_FDI p2,  void (*cb)(struct S_FDI, float, struct S_FDI)) ;
+EXPORT void f7_V_SFS_FDF(struct S_FDF p0, float p1, struct S_FDF p2,  void (*cb)(struct S_FDF, float, struct S_FDF)) ;
+EXPORT void f7_V_SFS_FDD(struct S_FDD p0, float p1, struct S_FDD p2,  void (*cb)(struct S_FDD, float, struct S_FDD)) ;
+EXPORT void f7_V_SFS_FDP(struct S_FDP p0, float p1, struct S_FDP p2,  void (*cb)(struct S_FDP, float, struct S_FDP)) ;
+EXPORT void f7_V_SFS_FPI(struct S_FPI p0, float p1, struct S_FPI p2,  void (*cb)(struct S_FPI, float, struct S_FPI)) ;
+EXPORT void f7_V_SFS_FPF(struct S_FPF p0, float p1, struct S_FPF p2,  void (*cb)(struct S_FPF, float, struct S_FPF)) ;
+EXPORT void f7_V_SFS_FPD(struct S_FPD p0, float p1, struct S_FPD p2,  void (*cb)(struct S_FPD, float, struct S_FPD)) ;
+EXPORT void f7_V_SFS_FPP(struct S_FPP p0, float p1, struct S_FPP p2,  void (*cb)(struct S_FPP, float, struct S_FPP)) ;
+EXPORT void f7_V_SFS_DII(struct S_DII p0, float p1, struct S_DII p2,  void (*cb)(struct S_DII, float, struct S_DII)) ;
+EXPORT void f7_V_SFS_DIF(struct S_DIF p0, float p1, struct S_DIF p2,  void (*cb)(struct S_DIF, float, struct S_DIF)) ;
+EXPORT void f7_V_SFS_DID(struct S_DID p0, float p1, struct S_DID p2,  void (*cb)(struct S_DID, float, struct S_DID)) ;
+EXPORT void f7_V_SFS_DIP(struct S_DIP p0, float p1, struct S_DIP p2,  void (*cb)(struct S_DIP, float, struct S_DIP)) ;
+EXPORT void f7_V_SFS_DFI(struct S_DFI p0, float p1, struct S_DFI p2,  void (*cb)(struct S_DFI, float, struct S_DFI)) ;
+EXPORT void f7_V_SFS_DFF(struct S_DFF p0, float p1, struct S_DFF p2,  void (*cb)(struct S_DFF, float, struct S_DFF)) ;
+EXPORT void f7_V_SFS_DFD(struct S_DFD p0, float p1, struct S_DFD p2,  void (*cb)(struct S_DFD, float, struct S_DFD)) ;
+EXPORT void f7_V_SFS_DFP(struct S_DFP p0, float p1, struct S_DFP p2,  void (*cb)(struct S_DFP, float, struct S_DFP)) ;
+EXPORT void f7_V_SFS_DDI(struct S_DDI p0, float p1, struct S_DDI p2,  void (*cb)(struct S_DDI, float, struct S_DDI)) ;
+EXPORT void f7_V_SFS_DDF(struct S_DDF p0, float p1, struct S_DDF p2,  void (*cb)(struct S_DDF, float, struct S_DDF)) ;
+EXPORT void f7_V_SFS_DDD(struct S_DDD p0, float p1, struct S_DDD p2,  void (*cb)(struct S_DDD, float, struct S_DDD)) ;
+EXPORT void f7_V_SFS_DDP(struct S_DDP p0, float p1, struct S_DDP p2,  void (*cb)(struct S_DDP, float, struct S_DDP)) ;
+EXPORT void f7_V_SFS_DPI(struct S_DPI p0, float p1, struct S_DPI p2,  void (*cb)(struct S_DPI, float, struct S_DPI)) ;
+EXPORT void f7_V_SFS_DPF(struct S_DPF p0, float p1, struct S_DPF p2,  void (*cb)(struct S_DPF, float, struct S_DPF)) ;
+EXPORT void f7_V_SFS_DPD(struct S_DPD p0, float p1, struct S_DPD p2,  void (*cb)(struct S_DPD, float, struct S_DPD)) ;
+EXPORT void f7_V_SFS_DPP(struct S_DPP p0, float p1, struct S_DPP p2,  void (*cb)(struct S_DPP, float, struct S_DPP)) ;
+EXPORT void f7_V_SFS_PII(struct S_PII p0, float p1, struct S_PII p2,  void (*cb)(struct S_PII, float, struct S_PII)) ;
+EXPORT void f7_V_SFS_PIF(struct S_PIF p0, float p1, struct S_PIF p2,  void (*cb)(struct S_PIF, float, struct S_PIF)) ;
+EXPORT void f7_V_SFS_PID(struct S_PID p0, float p1, struct S_PID p2,  void (*cb)(struct S_PID, float, struct S_PID)) ;
+EXPORT void f7_V_SFS_PIP(struct S_PIP p0, float p1, struct S_PIP p2,  void (*cb)(struct S_PIP, float, struct S_PIP)) ;
+EXPORT void f7_V_SFS_PFI(struct S_PFI p0, float p1, struct S_PFI p2,  void (*cb)(struct S_PFI, float, struct S_PFI)) ;
+EXPORT void f7_V_SFS_PFF(struct S_PFF p0, float p1, struct S_PFF p2,  void (*cb)(struct S_PFF, float, struct S_PFF)) ;
+EXPORT void f7_V_SFS_PFD(struct S_PFD p0, float p1, struct S_PFD p2,  void (*cb)(struct S_PFD, float, struct S_PFD)) ;
+EXPORT void f7_V_SFS_PFP(struct S_PFP p0, float p1, struct S_PFP p2,  void (*cb)(struct S_PFP, float, struct S_PFP)) ;
+EXPORT void f7_V_SFS_PDI(struct S_PDI p0, float p1, struct S_PDI p2,  void (*cb)(struct S_PDI, float, struct S_PDI)) ;
+EXPORT void f7_V_SFS_PDF(struct S_PDF p0, float p1, struct S_PDF p2,  void (*cb)(struct S_PDF, float, struct S_PDF)) ;
+EXPORT void f7_V_SFS_PDD(struct S_PDD p0, float p1, struct S_PDD p2,  void (*cb)(struct S_PDD, float, struct S_PDD)) ;
+EXPORT void f7_V_SFS_PDP(struct S_PDP p0, float p1, struct S_PDP p2,  void (*cb)(struct S_PDP, float, struct S_PDP)) ;
+EXPORT void f7_V_SFS_PPI(struct S_PPI p0, float p1, struct S_PPI p2,  void (*cb)(struct S_PPI, float, struct S_PPI)) ;
+EXPORT void f7_V_SFS_PPF(struct S_PPF p0, float p1, struct S_PPF p2,  void (*cb)(struct S_PPF, float, struct S_PPF)) ;
+EXPORT void f7_V_SFS_PPD(struct S_PPD p0, float p1, struct S_PPD p2,  void (*cb)(struct S_PPD, float, struct S_PPD)) ;
+EXPORT void f7_V_SFS_PPP(struct S_PPP p0, float p1, struct S_PPP p2,  void (*cb)(struct S_PPP, float, struct S_PPP)) ;
+EXPORT void f7_V_SDI_I(struct S_I p0, double p1, int p2,  void (*cb)(struct S_I, double, int)) ;
+EXPORT void f7_V_SDI_F(struct S_F p0, double p1, int p2,  void (*cb)(struct S_F, double, int)) ;
+EXPORT void f7_V_SDI_D(struct S_D p0, double p1, int p2,  void (*cb)(struct S_D, double, int)) ;
+EXPORT void f7_V_SDI_P(struct S_P p0, double p1, int p2,  void (*cb)(struct S_P, double, int)) ;
+EXPORT void f7_V_SDI_II(struct S_II p0, double p1, int p2,  void (*cb)(struct S_II, double, int)) ;
+EXPORT void f7_V_SDI_IF(struct S_IF p0, double p1, int p2,  void (*cb)(struct S_IF, double, int)) ;
+EXPORT void f7_V_SDI_ID(struct S_ID p0, double p1, int p2,  void (*cb)(struct S_ID, double, int)) ;
+EXPORT void f7_V_SDI_IP(struct S_IP p0, double p1, int p2,  void (*cb)(struct S_IP, double, int)) ;
+EXPORT void f7_V_SDI_FI(struct S_FI p0, double p1, int p2,  void (*cb)(struct S_FI, double, int)) ;
+EXPORT void f7_V_SDI_FF(struct S_FF p0, double p1, int p2,  void (*cb)(struct S_FF, double, int)) ;
+EXPORT void f7_V_SDI_FD(struct S_FD p0, double p1, int p2,  void (*cb)(struct S_FD, double, int)) ;
+EXPORT void f8_V_SDI_FP(struct S_FP p0, double p1, int p2,  void (*cb)(struct S_FP, double, int)) ;
+EXPORT void f8_V_SDI_DI(struct S_DI p0, double p1, int p2,  void (*cb)(struct S_DI, double, int)) ;
+EXPORT void f8_V_SDI_DF(struct S_DF p0, double p1, int p2,  void (*cb)(struct S_DF, double, int)) ;
+EXPORT void f8_V_SDI_DD(struct S_DD p0, double p1, int p2,  void (*cb)(struct S_DD, double, int)) ;
+EXPORT void f8_V_SDI_DP(struct S_DP p0, double p1, int p2,  void (*cb)(struct S_DP, double, int)) ;
+EXPORT void f8_V_SDI_PI(struct S_PI p0, double p1, int p2,  void (*cb)(struct S_PI, double, int)) ;
+EXPORT void f8_V_SDI_PF(struct S_PF p0, double p1, int p2,  void (*cb)(struct S_PF, double, int)) ;
+EXPORT void f8_V_SDI_PD(struct S_PD p0, double p1, int p2,  void (*cb)(struct S_PD, double, int)) ;
+EXPORT void f8_V_SDI_PP(struct S_PP p0, double p1, int p2,  void (*cb)(struct S_PP, double, int)) ;
+EXPORT void f8_V_SDI_III(struct S_III p0, double p1, int p2,  void (*cb)(struct S_III, double, int)) ;
+EXPORT void f8_V_SDI_IIF(struct S_IIF p0, double p1, int p2,  void (*cb)(struct S_IIF, double, int)) ;
+EXPORT void f8_V_SDI_IID(struct S_IID p0, double p1, int p2,  void (*cb)(struct S_IID, double, int)) ;
+EXPORT void f8_V_SDI_IIP(struct S_IIP p0, double p1, int p2,  void (*cb)(struct S_IIP, double, int)) ;
+EXPORT void f8_V_SDI_IFI(struct S_IFI p0, double p1, int p2,  void (*cb)(struct S_IFI, double, int)) ;
+EXPORT void f8_V_SDI_IFF(struct S_IFF p0, double p1, int p2,  void (*cb)(struct S_IFF, double, int)) ;
+EXPORT void f8_V_SDI_IFD(struct S_IFD p0, double p1, int p2,  void (*cb)(struct S_IFD, double, int)) ;
+EXPORT void f8_V_SDI_IFP(struct S_IFP p0, double p1, int p2,  void (*cb)(struct S_IFP, double, int)) ;
+EXPORT void f8_V_SDI_IDI(struct S_IDI p0, double p1, int p2,  void (*cb)(struct S_IDI, double, int)) ;
+EXPORT void f8_V_SDI_IDF(struct S_IDF p0, double p1, int p2,  void (*cb)(struct S_IDF, double, int)) ;
+EXPORT void f8_V_SDI_IDD(struct S_IDD p0, double p1, int p2,  void (*cb)(struct S_IDD, double, int)) ;
+EXPORT void f8_V_SDI_IDP(struct S_IDP p0, double p1, int p2,  void (*cb)(struct S_IDP, double, int)) ;
+EXPORT void f8_V_SDI_IPI(struct S_IPI p0, double p1, int p2,  void (*cb)(struct S_IPI, double, int)) ;
+EXPORT void f8_V_SDI_IPF(struct S_IPF p0, double p1, int p2,  void (*cb)(struct S_IPF, double, int)) ;
+EXPORT void f8_V_SDI_IPD(struct S_IPD p0, double p1, int p2,  void (*cb)(struct S_IPD, double, int)) ;
+EXPORT void f8_V_SDI_IPP(struct S_IPP p0, double p1, int p2,  void (*cb)(struct S_IPP, double, int)) ;
+EXPORT void f8_V_SDI_FII(struct S_FII p0, double p1, int p2,  void (*cb)(struct S_FII, double, int)) ;
+EXPORT void f8_V_SDI_FIF(struct S_FIF p0, double p1, int p2,  void (*cb)(struct S_FIF, double, int)) ;
+EXPORT void f8_V_SDI_FID(struct S_FID p0, double p1, int p2,  void (*cb)(struct S_FID, double, int)) ;
+EXPORT void f8_V_SDI_FIP(struct S_FIP p0, double p1, int p2,  void (*cb)(struct S_FIP, double, int)) ;
+EXPORT void f8_V_SDI_FFI(struct S_FFI p0, double p1, int p2,  void (*cb)(struct S_FFI, double, int)) ;
+EXPORT void f8_V_SDI_FFF(struct S_FFF p0, double p1, int p2,  void (*cb)(struct S_FFF, double, int)) ;
+EXPORT void f8_V_SDI_FFD(struct S_FFD p0, double p1, int p2,  void (*cb)(struct S_FFD, double, int)) ;
+EXPORT void f8_V_SDI_FFP(struct S_FFP p0, double p1, int p2,  void (*cb)(struct S_FFP, double, int)) ;
+EXPORT void f8_V_SDI_FDI(struct S_FDI p0, double p1, int p2,  void (*cb)(struct S_FDI, double, int)) ;
+EXPORT void f8_V_SDI_FDF(struct S_FDF p0, double p1, int p2,  void (*cb)(struct S_FDF, double, int)) ;
+EXPORT void f8_V_SDI_FDD(struct S_FDD p0, double p1, int p2,  void (*cb)(struct S_FDD, double, int)) ;
+EXPORT void f8_V_SDI_FDP(struct S_FDP p0, double p1, int p2,  void (*cb)(struct S_FDP, double, int)) ;
+EXPORT void f8_V_SDI_FPI(struct S_FPI p0, double p1, int p2,  void (*cb)(struct S_FPI, double, int)) ;
+EXPORT void f8_V_SDI_FPF(struct S_FPF p0, double p1, int p2,  void (*cb)(struct S_FPF, double, int)) ;
+EXPORT void f8_V_SDI_FPD(struct S_FPD p0, double p1, int p2,  void (*cb)(struct S_FPD, double, int)) ;
+EXPORT void f8_V_SDI_FPP(struct S_FPP p0, double p1, int p2,  void (*cb)(struct S_FPP, double, int)) ;
+EXPORT void f8_V_SDI_DII(struct S_DII p0, double p1, int p2,  void (*cb)(struct S_DII, double, int)) ;
+EXPORT void f8_V_SDI_DIF(struct S_DIF p0, double p1, int p2,  void (*cb)(struct S_DIF, double, int)) ;
+EXPORT void f8_V_SDI_DID(struct S_DID p0, double p1, int p2,  void (*cb)(struct S_DID, double, int)) ;
+EXPORT void f8_V_SDI_DIP(struct S_DIP p0, double p1, int p2,  void (*cb)(struct S_DIP, double, int)) ;
+EXPORT void f8_V_SDI_DFI(struct S_DFI p0, double p1, int p2,  void (*cb)(struct S_DFI, double, int)) ;
+EXPORT void f8_V_SDI_DFF(struct S_DFF p0, double p1, int p2,  void (*cb)(struct S_DFF, double, int)) ;
+EXPORT void f8_V_SDI_DFD(struct S_DFD p0, double p1, int p2,  void (*cb)(struct S_DFD, double, int)) ;
+EXPORT void f8_V_SDI_DFP(struct S_DFP p0, double p1, int p2,  void (*cb)(struct S_DFP, double, int)) ;
+EXPORT void f8_V_SDI_DDI(struct S_DDI p0, double p1, int p2,  void (*cb)(struct S_DDI, double, int)) ;
+EXPORT void f8_V_SDI_DDF(struct S_DDF p0, double p1, int p2,  void (*cb)(struct S_DDF, double, int)) ;
+EXPORT void f8_V_SDI_DDD(struct S_DDD p0, double p1, int p2,  void (*cb)(struct S_DDD, double, int)) ;
+EXPORT void f8_V_SDI_DDP(struct S_DDP p0, double p1, int p2,  void (*cb)(struct S_DDP, double, int)) ;
+EXPORT void f8_V_SDI_DPI(struct S_DPI p0, double p1, int p2,  void (*cb)(struct S_DPI, double, int)) ;
+EXPORT void f8_V_SDI_DPF(struct S_DPF p0, double p1, int p2,  void (*cb)(struct S_DPF, double, int)) ;
+EXPORT void f8_V_SDI_DPD(struct S_DPD p0, double p1, int p2,  void (*cb)(struct S_DPD, double, int)) ;
+EXPORT void f8_V_SDI_DPP(struct S_DPP p0, double p1, int p2,  void (*cb)(struct S_DPP, double, int)) ;
+EXPORT void f8_V_SDI_PII(struct S_PII p0, double p1, int p2,  void (*cb)(struct S_PII, double, int)) ;
+EXPORT void f8_V_SDI_PIF(struct S_PIF p0, double p1, int p2,  void (*cb)(struct S_PIF, double, int)) ;
+EXPORT void f8_V_SDI_PID(struct S_PID p0, double p1, int p2,  void (*cb)(struct S_PID, double, int)) ;
+EXPORT void f8_V_SDI_PIP(struct S_PIP p0, double p1, int p2,  void (*cb)(struct S_PIP, double, int)) ;
+EXPORT void f8_V_SDI_PFI(struct S_PFI p0, double p1, int p2,  void (*cb)(struct S_PFI, double, int)) ;
+EXPORT void f8_V_SDI_PFF(struct S_PFF p0, double p1, int p2,  void (*cb)(struct S_PFF, double, int)) ;
+EXPORT void f8_V_SDI_PFD(struct S_PFD p0, double p1, int p2,  void (*cb)(struct S_PFD, double, int)) ;
+EXPORT void f8_V_SDI_PFP(struct S_PFP p0, double p1, int p2,  void (*cb)(struct S_PFP, double, int)) ;
+EXPORT void f8_V_SDI_PDI(struct S_PDI p0, double p1, int p2,  void (*cb)(struct S_PDI, double, int)) ;
+EXPORT void f8_V_SDI_PDF(struct S_PDF p0, double p1, int p2,  void (*cb)(struct S_PDF, double, int)) ;
+EXPORT void f8_V_SDI_PDD(struct S_PDD p0, double p1, int p2,  void (*cb)(struct S_PDD, double, int)) ;
+EXPORT void f8_V_SDI_PDP(struct S_PDP p0, double p1, int p2,  void (*cb)(struct S_PDP, double, int)) ;
+EXPORT void f8_V_SDI_PPI(struct S_PPI p0, double p1, int p2,  void (*cb)(struct S_PPI, double, int)) ;
+EXPORT void f8_V_SDI_PPF(struct S_PPF p0, double p1, int p2,  void (*cb)(struct S_PPF, double, int)) ;
+EXPORT void f8_V_SDI_PPD(struct S_PPD p0, double p1, int p2,  void (*cb)(struct S_PPD, double, int)) ;
+EXPORT void f8_V_SDI_PPP(struct S_PPP p0, double p1, int p2,  void (*cb)(struct S_PPP, double, int)) ;
+EXPORT void f8_V_SDF_I(struct S_I p0, double p1, float p2,  void (*cb)(struct S_I, double, float)) ;
+EXPORT void f8_V_SDF_F(struct S_F p0, double p1, float p2,  void (*cb)(struct S_F, double, float)) ;
+EXPORT void f8_V_SDF_D(struct S_D p0, double p1, float p2,  void (*cb)(struct S_D, double, float)) ;
+EXPORT void f8_V_SDF_P(struct S_P p0, double p1, float p2,  void (*cb)(struct S_P, double, float)) ;
+EXPORT void f8_V_SDF_II(struct S_II p0, double p1, float p2,  void (*cb)(struct S_II, double, float)) ;
+EXPORT void f8_V_SDF_IF(struct S_IF p0, double p1, float p2,  void (*cb)(struct S_IF, double, float)) ;
+EXPORT void f8_V_SDF_ID(struct S_ID p0, double p1, float p2,  void (*cb)(struct S_ID, double, float)) ;
+EXPORT void f8_V_SDF_IP(struct S_IP p0, double p1, float p2,  void (*cb)(struct S_IP, double, float)) ;
+EXPORT void f8_V_SDF_FI(struct S_FI p0, double p1, float p2,  void (*cb)(struct S_FI, double, float)) ;
+EXPORT void f8_V_SDF_FF(struct S_FF p0, double p1, float p2,  void (*cb)(struct S_FF, double, float)) ;
+EXPORT void f8_V_SDF_FD(struct S_FD p0, double p1, float p2,  void (*cb)(struct S_FD, double, float)) ;
+EXPORT void f8_V_SDF_FP(struct S_FP p0, double p1, float p2,  void (*cb)(struct S_FP, double, float)) ;
+EXPORT void f8_V_SDF_DI(struct S_DI p0, double p1, float p2,  void (*cb)(struct S_DI, double, float)) ;
+EXPORT void f8_V_SDF_DF(struct S_DF p0, double p1, float p2,  void (*cb)(struct S_DF, double, float)) ;
+EXPORT void f8_V_SDF_DD(struct S_DD p0, double p1, float p2,  void (*cb)(struct S_DD, double, float)) ;
+EXPORT void f8_V_SDF_DP(struct S_DP p0, double p1, float p2,  void (*cb)(struct S_DP, double, float)) ;
+EXPORT void f8_V_SDF_PI(struct S_PI p0, double p1, float p2,  void (*cb)(struct S_PI, double, float)) ;
+EXPORT void f8_V_SDF_PF(struct S_PF p0, double p1, float p2,  void (*cb)(struct S_PF, double, float)) ;
+EXPORT void f8_V_SDF_PD(struct S_PD p0, double p1, float p2,  void (*cb)(struct S_PD, double, float)) ;
+EXPORT void f8_V_SDF_PP(struct S_PP p0, double p1, float p2,  void (*cb)(struct S_PP, double, float)) ;
+EXPORT void f8_V_SDF_III(struct S_III p0, double p1, float p2,  void (*cb)(struct S_III, double, float)) ;
+EXPORT void f8_V_SDF_IIF(struct S_IIF p0, double p1, float p2,  void (*cb)(struct S_IIF, double, float)) ;
+EXPORT void f8_V_SDF_IID(struct S_IID p0, double p1, float p2,  void (*cb)(struct S_IID, double, float)) ;
+EXPORT void f8_V_SDF_IIP(struct S_IIP p0, double p1, float p2,  void (*cb)(struct S_IIP, double, float)) ;
+EXPORT void f8_V_SDF_IFI(struct S_IFI p0, double p1, float p2,  void (*cb)(struct S_IFI, double, float)) ;
+EXPORT void f8_V_SDF_IFF(struct S_IFF p0, double p1, float p2,  void (*cb)(struct S_IFF, double, float)) ;
+EXPORT void f8_V_SDF_IFD(struct S_IFD p0, double p1, float p2,  void (*cb)(struct S_IFD, double, float)) ;
+EXPORT void f8_V_SDF_IFP(struct S_IFP p0, double p1, float p2,  void (*cb)(struct S_IFP, double, float)) ;
+EXPORT void f8_V_SDF_IDI(struct S_IDI p0, double p1, float p2,  void (*cb)(struct S_IDI, double, float)) ;
+EXPORT void f8_V_SDF_IDF(struct S_IDF p0, double p1, float p2,  void (*cb)(struct S_IDF, double, float)) ;
+EXPORT void f8_V_SDF_IDD(struct S_IDD p0, double p1, float p2,  void (*cb)(struct S_IDD, double, float)) ;
+EXPORT void f8_V_SDF_IDP(struct S_IDP p0, double p1, float p2,  void (*cb)(struct S_IDP, double, float)) ;
+EXPORT void f8_V_SDF_IPI(struct S_IPI p0, double p1, float p2,  void (*cb)(struct S_IPI, double, float)) ;
+EXPORT void f8_V_SDF_IPF(struct S_IPF p0, double p1, float p2,  void (*cb)(struct S_IPF, double, float)) ;
+EXPORT void f8_V_SDF_IPD(struct S_IPD p0, double p1, float p2,  void (*cb)(struct S_IPD, double, float)) ;
+EXPORT void f8_V_SDF_IPP(struct S_IPP p0, double p1, float p2,  void (*cb)(struct S_IPP, double, float)) ;
+EXPORT void f8_V_SDF_FII(struct S_FII p0, double p1, float p2,  void (*cb)(struct S_FII, double, float)) ;
+EXPORT void f8_V_SDF_FIF(struct S_FIF p0, double p1, float p2,  void (*cb)(struct S_FIF, double, float)) ;
+EXPORT void f8_V_SDF_FID(struct S_FID p0, double p1, float p2,  void (*cb)(struct S_FID, double, float)) ;
+EXPORT void f8_V_SDF_FIP(struct S_FIP p0, double p1, float p2,  void (*cb)(struct S_FIP, double, float)) ;
+EXPORT void f8_V_SDF_FFI(struct S_FFI p0, double p1, float p2,  void (*cb)(struct S_FFI, double, float)) ;
+EXPORT void f8_V_SDF_FFF(struct S_FFF p0, double p1, float p2,  void (*cb)(struct S_FFF, double, float)) ;
+EXPORT void f8_V_SDF_FFD(struct S_FFD p0, double p1, float p2,  void (*cb)(struct S_FFD, double, float)) ;
+EXPORT void f8_V_SDF_FFP(struct S_FFP p0, double p1, float p2,  void (*cb)(struct S_FFP, double, float)) ;
+EXPORT void f8_V_SDF_FDI(struct S_FDI p0, double p1, float p2,  void (*cb)(struct S_FDI, double, float)) ;
+EXPORT void f8_V_SDF_FDF(struct S_FDF p0, double p1, float p2,  void (*cb)(struct S_FDF, double, float)) ;
+EXPORT void f8_V_SDF_FDD(struct S_FDD p0, double p1, float p2,  void (*cb)(struct S_FDD, double, float)) ;
+EXPORT void f8_V_SDF_FDP(struct S_FDP p0, double p1, float p2,  void (*cb)(struct S_FDP, double, float)) ;
+EXPORT void f8_V_SDF_FPI(struct S_FPI p0, double p1, float p2,  void (*cb)(struct S_FPI, double, float)) ;
+EXPORT void f8_V_SDF_FPF(struct S_FPF p0, double p1, float p2,  void (*cb)(struct S_FPF, double, float)) ;
+EXPORT void f8_V_SDF_FPD(struct S_FPD p0, double p1, float p2,  void (*cb)(struct S_FPD, double, float)) ;
+EXPORT void f8_V_SDF_FPP(struct S_FPP p0, double p1, float p2,  void (*cb)(struct S_FPP, double, float)) ;
+EXPORT void f8_V_SDF_DII(struct S_DII p0, double p1, float p2,  void (*cb)(struct S_DII, double, float)) ;
+EXPORT void f8_V_SDF_DIF(struct S_DIF p0, double p1, float p2,  void (*cb)(struct S_DIF, double, float)) ;
+EXPORT void f8_V_SDF_DID(struct S_DID p0, double p1, float p2,  void (*cb)(struct S_DID, double, float)) ;
+EXPORT void f8_V_SDF_DIP(struct S_DIP p0, double p1, float p2,  void (*cb)(struct S_DIP, double, float)) ;
+EXPORT void f8_V_SDF_DFI(struct S_DFI p0, double p1, float p2,  void (*cb)(struct S_DFI, double, float)) ;
+EXPORT void f8_V_SDF_DFF(struct S_DFF p0, double p1, float p2,  void (*cb)(struct S_DFF, double, float)) ;
+EXPORT void f8_V_SDF_DFD(struct S_DFD p0, double p1, float p2,  void (*cb)(struct S_DFD, double, float)) ;
+EXPORT void f8_V_SDF_DFP(struct S_DFP p0, double p1, float p2,  void (*cb)(struct S_DFP, double, float)) ;
+EXPORT void f8_V_SDF_DDI(struct S_DDI p0, double p1, float p2,  void (*cb)(struct S_DDI, double, float)) ;
+EXPORT void f8_V_SDF_DDF(struct S_DDF p0, double p1, float p2,  void (*cb)(struct S_DDF, double, float)) ;
+EXPORT void f8_V_SDF_DDD(struct S_DDD p0, double p1, float p2,  void (*cb)(struct S_DDD, double, float)) ;
+EXPORT void f8_V_SDF_DDP(struct S_DDP p0, double p1, float p2,  void (*cb)(struct S_DDP, double, float)) ;
+EXPORT void f8_V_SDF_DPI(struct S_DPI p0, double p1, float p2,  void (*cb)(struct S_DPI, double, float)) ;
+EXPORT void f8_V_SDF_DPF(struct S_DPF p0, double p1, float p2,  void (*cb)(struct S_DPF, double, float)) ;
+EXPORT void f8_V_SDF_DPD(struct S_DPD p0, double p1, float p2,  void (*cb)(struct S_DPD, double, float)) ;
+EXPORT void f8_V_SDF_DPP(struct S_DPP p0, double p1, float p2,  void (*cb)(struct S_DPP, double, float)) ;
+EXPORT void f8_V_SDF_PII(struct S_PII p0, double p1, float p2,  void (*cb)(struct S_PII, double, float)) ;
+EXPORT void f8_V_SDF_PIF(struct S_PIF p0, double p1, float p2,  void (*cb)(struct S_PIF, double, float)) ;
+EXPORT void f8_V_SDF_PID(struct S_PID p0, double p1, float p2,  void (*cb)(struct S_PID, double, float)) ;
+EXPORT void f8_V_SDF_PIP(struct S_PIP p0, double p1, float p2,  void (*cb)(struct S_PIP, double, float)) ;
+EXPORT void f8_V_SDF_PFI(struct S_PFI p0, double p1, float p2,  void (*cb)(struct S_PFI, double, float)) ;
+EXPORT void f8_V_SDF_PFF(struct S_PFF p0, double p1, float p2,  void (*cb)(struct S_PFF, double, float)) ;
+EXPORT void f8_V_SDF_PFD(struct S_PFD p0, double p1, float p2,  void (*cb)(struct S_PFD, double, float)) ;
+EXPORT void f8_V_SDF_PFP(struct S_PFP p0, double p1, float p2,  void (*cb)(struct S_PFP, double, float)) ;
+EXPORT void f8_V_SDF_PDI(struct S_PDI p0, double p1, float p2,  void (*cb)(struct S_PDI, double, float)) ;
+EXPORT void f8_V_SDF_PDF(struct S_PDF p0, double p1, float p2,  void (*cb)(struct S_PDF, double, float)) ;
+EXPORT void f8_V_SDF_PDD(struct S_PDD p0, double p1, float p2,  void (*cb)(struct S_PDD, double, float)) ;
+EXPORT void f8_V_SDF_PDP(struct S_PDP p0, double p1, float p2,  void (*cb)(struct S_PDP, double, float)) ;
+EXPORT void f8_V_SDF_PPI(struct S_PPI p0, double p1, float p2,  void (*cb)(struct S_PPI, double, float)) ;
+EXPORT void f8_V_SDF_PPF(struct S_PPF p0, double p1, float p2,  void (*cb)(struct S_PPF, double, float)) ;
+EXPORT void f8_V_SDF_PPD(struct S_PPD p0, double p1, float p2,  void (*cb)(struct S_PPD, double, float)) ;
+EXPORT void f8_V_SDF_PPP(struct S_PPP p0, double p1, float p2,  void (*cb)(struct S_PPP, double, float)) ;
+EXPORT void f8_V_SDD_I(struct S_I p0, double p1, double p2,  void (*cb)(struct S_I, double, double)) ;
+EXPORT void f8_V_SDD_F(struct S_F p0, double p1, double p2,  void (*cb)(struct S_F, double, double)) ;
+EXPORT void f8_V_SDD_D(struct S_D p0, double p1, double p2,  void (*cb)(struct S_D, double, double)) ;
+EXPORT void f8_V_SDD_P(struct S_P p0, double p1, double p2,  void (*cb)(struct S_P, double, double)) ;
+EXPORT void f8_V_SDD_II(struct S_II p0, double p1, double p2,  void (*cb)(struct S_II, double, double)) ;
+EXPORT void f8_V_SDD_IF(struct S_IF p0, double p1, double p2,  void (*cb)(struct S_IF, double, double)) ;
+EXPORT void f8_V_SDD_ID(struct S_ID p0, double p1, double p2,  void (*cb)(struct S_ID, double, double)) ;
+EXPORT void f8_V_SDD_IP(struct S_IP p0, double p1, double p2,  void (*cb)(struct S_IP, double, double)) ;
+EXPORT void f8_V_SDD_FI(struct S_FI p0, double p1, double p2,  void (*cb)(struct S_FI, double, double)) ;
+EXPORT void f8_V_SDD_FF(struct S_FF p0, double p1, double p2,  void (*cb)(struct S_FF, double, double)) ;
+EXPORT void f8_V_SDD_FD(struct S_FD p0, double p1, double p2,  void (*cb)(struct S_FD, double, double)) ;
+EXPORT void f8_V_SDD_FP(struct S_FP p0, double p1, double p2,  void (*cb)(struct S_FP, double, double)) ;
+EXPORT void f8_V_SDD_DI(struct S_DI p0, double p1, double p2,  void (*cb)(struct S_DI, double, double)) ;
+EXPORT void f8_V_SDD_DF(struct S_DF p0, double p1, double p2,  void (*cb)(struct S_DF, double, double)) ;
+EXPORT void f8_V_SDD_DD(struct S_DD p0, double p1, double p2,  void (*cb)(struct S_DD, double, double)) ;
+EXPORT void f8_V_SDD_DP(struct S_DP p0, double p1, double p2,  void (*cb)(struct S_DP, double, double)) ;
+EXPORT void f8_V_SDD_PI(struct S_PI p0, double p1, double p2,  void (*cb)(struct S_PI, double, double)) ;
+EXPORT void f8_V_SDD_PF(struct S_PF p0, double p1, double p2,  void (*cb)(struct S_PF, double, double)) ;
+EXPORT void f8_V_SDD_PD(struct S_PD p0, double p1, double p2,  void (*cb)(struct S_PD, double, double)) ;
+EXPORT void f8_V_SDD_PP(struct S_PP p0, double p1, double p2,  void (*cb)(struct S_PP, double, double)) ;
+EXPORT void f8_V_SDD_III(struct S_III p0, double p1, double p2,  void (*cb)(struct S_III, double, double)) ;
+EXPORT void f8_V_SDD_IIF(struct S_IIF p0, double p1, double p2,  void (*cb)(struct S_IIF, double, double)) ;
+EXPORT void f8_V_SDD_IID(struct S_IID p0, double p1, double p2,  void (*cb)(struct S_IID, double, double)) ;
+EXPORT void f8_V_SDD_IIP(struct S_IIP p0, double p1, double p2,  void (*cb)(struct S_IIP, double, double)) ;
+EXPORT void f8_V_SDD_IFI(struct S_IFI p0, double p1, double p2,  void (*cb)(struct S_IFI, double, double)) ;
+EXPORT void f8_V_SDD_IFF(struct S_IFF p0, double p1, double p2,  void (*cb)(struct S_IFF, double, double)) ;
+EXPORT void f8_V_SDD_IFD(struct S_IFD p0, double p1, double p2,  void (*cb)(struct S_IFD, double, double)) ;
+EXPORT void f8_V_SDD_IFP(struct S_IFP p0, double p1, double p2,  void (*cb)(struct S_IFP, double, double)) ;
+EXPORT void f8_V_SDD_IDI(struct S_IDI p0, double p1, double p2,  void (*cb)(struct S_IDI, double, double)) ;
+EXPORT void f8_V_SDD_IDF(struct S_IDF p0, double p1, double p2,  void (*cb)(struct S_IDF, double, double)) ;
+EXPORT void f8_V_SDD_IDD(struct S_IDD p0, double p1, double p2,  void (*cb)(struct S_IDD, double, double)) ;
+EXPORT void f8_V_SDD_IDP(struct S_IDP p0, double p1, double p2,  void (*cb)(struct S_IDP, double, double)) ;
+EXPORT void f8_V_SDD_IPI(struct S_IPI p0, double p1, double p2,  void (*cb)(struct S_IPI, double, double)) ;
+EXPORT void f8_V_SDD_IPF(struct S_IPF p0, double p1, double p2,  void (*cb)(struct S_IPF, double, double)) ;
+EXPORT void f8_V_SDD_IPD(struct S_IPD p0, double p1, double p2,  void (*cb)(struct S_IPD, double, double)) ;
+EXPORT void f8_V_SDD_IPP(struct S_IPP p0, double p1, double p2,  void (*cb)(struct S_IPP, double, double)) ;
+EXPORT void f8_V_SDD_FII(struct S_FII p0, double p1, double p2,  void (*cb)(struct S_FII, double, double)) ;
+EXPORT void f8_V_SDD_FIF(struct S_FIF p0, double p1, double p2,  void (*cb)(struct S_FIF, double, double)) ;
+EXPORT void f8_V_SDD_FID(struct S_FID p0, double p1, double p2,  void (*cb)(struct S_FID, double, double)) ;
+EXPORT void f8_V_SDD_FIP(struct S_FIP p0, double p1, double p2,  void (*cb)(struct S_FIP, double, double)) ;
+EXPORT void f8_V_SDD_FFI(struct S_FFI p0, double p1, double p2,  void (*cb)(struct S_FFI, double, double)) ;
+EXPORT void f8_V_SDD_FFF(struct S_FFF p0, double p1, double p2,  void (*cb)(struct S_FFF, double, double)) ;
+EXPORT void f8_V_SDD_FFD(struct S_FFD p0, double p1, double p2,  void (*cb)(struct S_FFD, double, double)) ;
+EXPORT void f8_V_SDD_FFP(struct S_FFP p0, double p1, double p2,  void (*cb)(struct S_FFP, double, double)) ;
+EXPORT void f8_V_SDD_FDI(struct S_FDI p0, double p1, double p2,  void (*cb)(struct S_FDI, double, double)) ;
+EXPORT void f8_V_SDD_FDF(struct S_FDF p0, double p1, double p2,  void (*cb)(struct S_FDF, double, double)) ;
+EXPORT void f8_V_SDD_FDD(struct S_FDD p0, double p1, double p2,  void (*cb)(struct S_FDD, double, double)) ;
+EXPORT void f8_V_SDD_FDP(struct S_FDP p0, double p1, double p2,  void (*cb)(struct S_FDP, double, double)) ;
+EXPORT void f8_V_SDD_FPI(struct S_FPI p0, double p1, double p2,  void (*cb)(struct S_FPI, double, double)) ;
+EXPORT void f8_V_SDD_FPF(struct S_FPF p0, double p1, double p2,  void (*cb)(struct S_FPF, double, double)) ;
+EXPORT void f8_V_SDD_FPD(struct S_FPD p0, double p1, double p2,  void (*cb)(struct S_FPD, double, double)) ;
+EXPORT void f8_V_SDD_FPP(struct S_FPP p0, double p1, double p2,  void (*cb)(struct S_FPP, double, double)) ;
+EXPORT void f8_V_SDD_DII(struct S_DII p0, double p1, double p2,  void (*cb)(struct S_DII, double, double)) ;
+EXPORT void f8_V_SDD_DIF(struct S_DIF p0, double p1, double p2,  void (*cb)(struct S_DIF, double, double)) ;
+EXPORT void f8_V_SDD_DID(struct S_DID p0, double p1, double p2,  void (*cb)(struct S_DID, double, double)) ;
+EXPORT void f8_V_SDD_DIP(struct S_DIP p0, double p1, double p2,  void (*cb)(struct S_DIP, double, double)) ;
+EXPORT void f8_V_SDD_DFI(struct S_DFI p0, double p1, double p2,  void (*cb)(struct S_DFI, double, double)) ;
+EXPORT void f8_V_SDD_DFF(struct S_DFF p0, double p1, double p2,  void (*cb)(struct S_DFF, double, double)) ;
+EXPORT void f8_V_SDD_DFD(struct S_DFD p0, double p1, double p2,  void (*cb)(struct S_DFD, double, double)) ;
+EXPORT void f8_V_SDD_DFP(struct S_DFP p0, double p1, double p2,  void (*cb)(struct S_DFP, double, double)) ;
+EXPORT void f8_V_SDD_DDI(struct S_DDI p0, double p1, double p2,  void (*cb)(struct S_DDI, double, double)) ;
+EXPORT void f8_V_SDD_DDF(struct S_DDF p0, double p1, double p2,  void (*cb)(struct S_DDF, double, double)) ;
+EXPORT void f8_V_SDD_DDD(struct S_DDD p0, double p1, double p2,  void (*cb)(struct S_DDD, double, double)) ;
+EXPORT void f8_V_SDD_DDP(struct S_DDP p0, double p1, double p2,  void (*cb)(struct S_DDP, double, double)) ;
+EXPORT void f8_V_SDD_DPI(struct S_DPI p0, double p1, double p2,  void (*cb)(struct S_DPI, double, double)) ;
+EXPORT void f8_V_SDD_DPF(struct S_DPF p0, double p1, double p2,  void (*cb)(struct S_DPF, double, double)) ;
+EXPORT void f8_V_SDD_DPD(struct S_DPD p0, double p1, double p2,  void (*cb)(struct S_DPD, double, double)) ;
+EXPORT void f8_V_SDD_DPP(struct S_DPP p0, double p1, double p2,  void (*cb)(struct S_DPP, double, double)) ;
+EXPORT void f8_V_SDD_PII(struct S_PII p0, double p1, double p2,  void (*cb)(struct S_PII, double, double)) ;
+EXPORT void f8_V_SDD_PIF(struct S_PIF p0, double p1, double p2,  void (*cb)(struct S_PIF, double, double)) ;
+EXPORT void f8_V_SDD_PID(struct S_PID p0, double p1, double p2,  void (*cb)(struct S_PID, double, double)) ;
+EXPORT void f8_V_SDD_PIP(struct S_PIP p0, double p1, double p2,  void (*cb)(struct S_PIP, double, double)) ;
+EXPORT void f8_V_SDD_PFI(struct S_PFI p0, double p1, double p2,  void (*cb)(struct S_PFI, double, double)) ;
+EXPORT void f8_V_SDD_PFF(struct S_PFF p0, double p1, double p2,  void (*cb)(struct S_PFF, double, double)) ;
+EXPORT void f8_V_SDD_PFD(struct S_PFD p0, double p1, double p2,  void (*cb)(struct S_PFD, double, double)) ;
+EXPORT void f8_V_SDD_PFP(struct S_PFP p0, double p1, double p2,  void (*cb)(struct S_PFP, double, double)) ;
+EXPORT void f8_V_SDD_PDI(struct S_PDI p0, double p1, double p2,  void (*cb)(struct S_PDI, double, double)) ;
+EXPORT void f8_V_SDD_PDF(struct S_PDF p0, double p1, double p2,  void (*cb)(struct S_PDF, double, double)) ;
+EXPORT void f8_V_SDD_PDD(struct S_PDD p0, double p1, double p2,  void (*cb)(struct S_PDD, double, double)) ;
+EXPORT void f8_V_SDD_PDP(struct S_PDP p0, double p1, double p2,  void (*cb)(struct S_PDP, double, double)) ;
+EXPORT void f8_V_SDD_PPI(struct S_PPI p0, double p1, double p2,  void (*cb)(struct S_PPI, double, double)) ;
+EXPORT void f8_V_SDD_PPF(struct S_PPF p0, double p1, double p2,  void (*cb)(struct S_PPF, double, double)) ;
+EXPORT void f8_V_SDD_PPD(struct S_PPD p0, double p1, double p2,  void (*cb)(struct S_PPD, double, double)) ;
+EXPORT void f8_V_SDD_PPP(struct S_PPP p0, double p1, double p2,  void (*cb)(struct S_PPP, double, double)) ;
+EXPORT void f8_V_SDP_I(struct S_I p0, double p1, void* p2,  void (*cb)(struct S_I, double, void*)) ;
+EXPORT void f8_V_SDP_F(struct S_F p0, double p1, void* p2,  void (*cb)(struct S_F, double, void*)) ;
+EXPORT void f8_V_SDP_D(struct S_D p0, double p1, void* p2,  void (*cb)(struct S_D, double, void*)) ;
+EXPORT void f8_V_SDP_P(struct S_P p0, double p1, void* p2,  void (*cb)(struct S_P, double, void*)) ;
+EXPORT void f8_V_SDP_II(struct S_II p0, double p1, void* p2,  void (*cb)(struct S_II, double, void*)) ;
+EXPORT void f8_V_SDP_IF(struct S_IF p0, double p1, void* p2,  void (*cb)(struct S_IF, double, void*)) ;
+EXPORT void f8_V_SDP_ID(struct S_ID p0, double p1, void* p2,  void (*cb)(struct S_ID, double, void*)) ;
+EXPORT void f8_V_SDP_IP(struct S_IP p0, double p1, void* p2,  void (*cb)(struct S_IP, double, void*)) ;
+EXPORT void f8_V_SDP_FI(struct S_FI p0, double p1, void* p2,  void (*cb)(struct S_FI, double, void*)) ;
+EXPORT void f8_V_SDP_FF(struct S_FF p0, double p1, void* p2,  void (*cb)(struct S_FF, double, void*)) ;
+EXPORT void f8_V_SDP_FD(struct S_FD p0, double p1, void* p2,  void (*cb)(struct S_FD, double, void*)) ;
+EXPORT void f8_V_SDP_FP(struct S_FP p0, double p1, void* p2,  void (*cb)(struct S_FP, double, void*)) ;
+EXPORT void f8_V_SDP_DI(struct S_DI p0, double p1, void* p2,  void (*cb)(struct S_DI, double, void*)) ;
+EXPORT void f8_V_SDP_DF(struct S_DF p0, double p1, void* p2,  void (*cb)(struct S_DF, double, void*)) ;
+EXPORT void f8_V_SDP_DD(struct S_DD p0, double p1, void* p2,  void (*cb)(struct S_DD, double, void*)) ;
+EXPORT void f8_V_SDP_DP(struct S_DP p0, double p1, void* p2,  void (*cb)(struct S_DP, double, void*)) ;
+EXPORT void f8_V_SDP_PI(struct S_PI p0, double p1, void* p2,  void (*cb)(struct S_PI, double, void*)) ;
+EXPORT void f8_V_SDP_PF(struct S_PF p0, double p1, void* p2,  void (*cb)(struct S_PF, double, void*)) ;
+EXPORT void f8_V_SDP_PD(struct S_PD p0, double p1, void* p2,  void (*cb)(struct S_PD, double, void*)) ;
+EXPORT void f8_V_SDP_PP(struct S_PP p0, double p1, void* p2,  void (*cb)(struct S_PP, double, void*)) ;
+EXPORT void f8_V_SDP_III(struct S_III p0, double p1, void* p2,  void (*cb)(struct S_III, double, void*)) ;
+EXPORT void f8_V_SDP_IIF(struct S_IIF p0, double p1, void* p2,  void (*cb)(struct S_IIF, double, void*)) ;
+EXPORT void f8_V_SDP_IID(struct S_IID p0, double p1, void* p2,  void (*cb)(struct S_IID, double, void*)) ;
+EXPORT void f8_V_SDP_IIP(struct S_IIP p0, double p1, void* p2,  void (*cb)(struct S_IIP, double, void*)) ;
+EXPORT void f8_V_SDP_IFI(struct S_IFI p0, double p1, void* p2,  void (*cb)(struct S_IFI, double, void*)) ;
+EXPORT void f8_V_SDP_IFF(struct S_IFF p0, double p1, void* p2,  void (*cb)(struct S_IFF, double, void*)) ;
+EXPORT void f8_V_SDP_IFD(struct S_IFD p0, double p1, void* p2,  void (*cb)(struct S_IFD, double, void*)) ;
+EXPORT void f8_V_SDP_IFP(struct S_IFP p0, double p1, void* p2,  void (*cb)(struct S_IFP, double, void*)) ;
+EXPORT void f8_V_SDP_IDI(struct S_IDI p0, double p1, void* p2,  void (*cb)(struct S_IDI, double, void*)) ;
+EXPORT void f8_V_SDP_IDF(struct S_IDF p0, double p1, void* p2,  void (*cb)(struct S_IDF, double, void*)) ;
+EXPORT void f8_V_SDP_IDD(struct S_IDD p0, double p1, void* p2,  void (*cb)(struct S_IDD, double, void*)) ;
+EXPORT void f8_V_SDP_IDP(struct S_IDP p0, double p1, void* p2,  void (*cb)(struct S_IDP, double, void*)) ;
+EXPORT void f8_V_SDP_IPI(struct S_IPI p0, double p1, void* p2,  void (*cb)(struct S_IPI, double, void*)) ;
+EXPORT void f8_V_SDP_IPF(struct S_IPF p0, double p1, void* p2,  void (*cb)(struct S_IPF, double, void*)) ;
+EXPORT void f8_V_SDP_IPD(struct S_IPD p0, double p1, void* p2,  void (*cb)(struct S_IPD, double, void*)) ;
+EXPORT void f8_V_SDP_IPP(struct S_IPP p0, double p1, void* p2,  void (*cb)(struct S_IPP, double, void*)) ;
+EXPORT void f8_V_SDP_FII(struct S_FII p0, double p1, void* p2,  void (*cb)(struct S_FII, double, void*)) ;
+EXPORT void f8_V_SDP_FIF(struct S_FIF p0, double p1, void* p2,  void (*cb)(struct S_FIF, double, void*)) ;
+EXPORT void f8_V_SDP_FID(struct S_FID p0, double p1, void* p2,  void (*cb)(struct S_FID, double, void*)) ;
+EXPORT void f8_V_SDP_FIP(struct S_FIP p0, double p1, void* p2,  void (*cb)(struct S_FIP, double, void*)) ;
+EXPORT void f8_V_SDP_FFI(struct S_FFI p0, double p1, void* p2,  void (*cb)(struct S_FFI, double, void*)) ;
+EXPORT void f8_V_SDP_FFF(struct S_FFF p0, double p1, void* p2,  void (*cb)(struct S_FFF, double, void*)) ;
+EXPORT void f8_V_SDP_FFD(struct S_FFD p0, double p1, void* p2,  void (*cb)(struct S_FFD, double, void*)) ;
+EXPORT void f8_V_SDP_FFP(struct S_FFP p0, double p1, void* p2,  void (*cb)(struct S_FFP, double, void*)) ;
+EXPORT void f8_V_SDP_FDI(struct S_FDI p0, double p1, void* p2,  void (*cb)(struct S_FDI, double, void*)) ;
+EXPORT void f8_V_SDP_FDF(struct S_FDF p0, double p1, void* p2,  void (*cb)(struct S_FDF, double, void*)) ;
+EXPORT void f8_V_SDP_FDD(struct S_FDD p0, double p1, void* p2,  void (*cb)(struct S_FDD, double, void*)) ;
+EXPORT void f8_V_SDP_FDP(struct S_FDP p0, double p1, void* p2,  void (*cb)(struct S_FDP, double, void*)) ;
+EXPORT void f8_V_SDP_FPI(struct S_FPI p0, double p1, void* p2,  void (*cb)(struct S_FPI, double, void*)) ;
+EXPORT void f8_V_SDP_FPF(struct S_FPF p0, double p1, void* p2,  void (*cb)(struct S_FPF, double, void*)) ;
+EXPORT void f8_V_SDP_FPD(struct S_FPD p0, double p1, void* p2,  void (*cb)(struct S_FPD, double, void*)) ;
+EXPORT void f8_V_SDP_FPP(struct S_FPP p0, double p1, void* p2,  void (*cb)(struct S_FPP, double, void*)) ;
+EXPORT void f8_V_SDP_DII(struct S_DII p0, double p1, void* p2,  void (*cb)(struct S_DII, double, void*)) ;
+EXPORT void f8_V_SDP_DIF(struct S_DIF p0, double p1, void* p2,  void (*cb)(struct S_DIF, double, void*)) ;
+EXPORT void f8_V_SDP_DID(struct S_DID p0, double p1, void* p2,  void (*cb)(struct S_DID, double, void*)) ;
+EXPORT void f8_V_SDP_DIP(struct S_DIP p0, double p1, void* p2,  void (*cb)(struct S_DIP, double, void*)) ;
+EXPORT void f8_V_SDP_DFI(struct S_DFI p0, double p1, void* p2,  void (*cb)(struct S_DFI, double, void*)) ;
+EXPORT void f8_V_SDP_DFF(struct S_DFF p0, double p1, void* p2,  void (*cb)(struct S_DFF, double, void*)) ;
+EXPORT void f8_V_SDP_DFD(struct S_DFD p0, double p1, void* p2,  void (*cb)(struct S_DFD, double, void*)) ;
+EXPORT void f8_V_SDP_DFP(struct S_DFP p0, double p1, void* p2,  void (*cb)(struct S_DFP, double, void*)) ;
+EXPORT void f8_V_SDP_DDI(struct S_DDI p0, double p1, void* p2,  void (*cb)(struct S_DDI, double, void*)) ;
+EXPORT void f8_V_SDP_DDF(struct S_DDF p0, double p1, void* p2,  void (*cb)(struct S_DDF, double, void*)) ;
+EXPORT void f8_V_SDP_DDD(struct S_DDD p0, double p1, void* p2,  void (*cb)(struct S_DDD, double, void*)) ;
+EXPORT void f8_V_SDP_DDP(struct S_DDP p0, double p1, void* p2,  void (*cb)(struct S_DDP, double, void*)) ;
+EXPORT void f8_V_SDP_DPI(struct S_DPI p0, double p1, void* p2,  void (*cb)(struct S_DPI, double, void*)) ;
+EXPORT void f8_V_SDP_DPF(struct S_DPF p0, double p1, void* p2,  void (*cb)(struct S_DPF, double, void*)) ;
+EXPORT void f8_V_SDP_DPD(struct S_DPD p0, double p1, void* p2,  void (*cb)(struct S_DPD, double, void*)) ;
+EXPORT void f8_V_SDP_DPP(struct S_DPP p0, double p1, void* p2,  void (*cb)(struct S_DPP, double, void*)) ;
+EXPORT void f8_V_SDP_PII(struct S_PII p0, double p1, void* p2,  void (*cb)(struct S_PII, double, void*)) ;
+EXPORT void f8_V_SDP_PIF(struct S_PIF p0, double p1, void* p2,  void (*cb)(struct S_PIF, double, void*)) ;
+EXPORT void f8_V_SDP_PID(struct S_PID p0, double p1, void* p2,  void (*cb)(struct S_PID, double, void*)) ;
+EXPORT void f8_V_SDP_PIP(struct S_PIP p0, double p1, void* p2,  void (*cb)(struct S_PIP, double, void*)) ;
+EXPORT void f8_V_SDP_PFI(struct S_PFI p0, double p1, void* p2,  void (*cb)(struct S_PFI, double, void*)) ;
+EXPORT void f8_V_SDP_PFF(struct S_PFF p0, double p1, void* p2,  void (*cb)(struct S_PFF, double, void*)) ;
+EXPORT void f8_V_SDP_PFD(struct S_PFD p0, double p1, void* p2,  void (*cb)(struct S_PFD, double, void*)) ;
+EXPORT void f8_V_SDP_PFP(struct S_PFP p0, double p1, void* p2,  void (*cb)(struct S_PFP, double, void*)) ;
+EXPORT void f8_V_SDP_PDI(struct S_PDI p0, double p1, void* p2,  void (*cb)(struct S_PDI, double, void*)) ;
+EXPORT void f8_V_SDP_PDF(struct S_PDF p0, double p1, void* p2,  void (*cb)(struct S_PDF, double, void*)) ;
+EXPORT void f8_V_SDP_PDD(struct S_PDD p0, double p1, void* p2,  void (*cb)(struct S_PDD, double, void*)) ;
+EXPORT void f8_V_SDP_PDP(struct S_PDP p0, double p1, void* p2,  void (*cb)(struct S_PDP, double, void*)) ;
+EXPORT void f8_V_SDP_PPI(struct S_PPI p0, double p1, void* p2,  void (*cb)(struct S_PPI, double, void*)) ;
+EXPORT void f8_V_SDP_PPF(struct S_PPF p0, double p1, void* p2,  void (*cb)(struct S_PPF, double, void*)) ;
+EXPORT void f8_V_SDP_PPD(struct S_PPD p0, double p1, void* p2,  void (*cb)(struct S_PPD, double, void*)) ;
+EXPORT void f8_V_SDP_PPP(struct S_PPP p0, double p1, void* p2,  void (*cb)(struct S_PPP, double, void*)) ;
+EXPORT void f8_V_SDS_I(struct S_I p0, double p1, struct S_I p2,  void (*cb)(struct S_I, double, struct S_I)) ;
+EXPORT void f8_V_SDS_F(struct S_F p0, double p1, struct S_F p2,  void (*cb)(struct S_F, double, struct S_F)) ;
+EXPORT void f8_V_SDS_D(struct S_D p0, double p1, struct S_D p2,  void (*cb)(struct S_D, double, struct S_D)) ;
+EXPORT void f8_V_SDS_P(struct S_P p0, double p1, struct S_P p2,  void (*cb)(struct S_P, double, struct S_P)) ;
+EXPORT void f8_V_SDS_II(struct S_II p0, double p1, struct S_II p2,  void (*cb)(struct S_II, double, struct S_II)) ;
+EXPORT void f8_V_SDS_IF(struct S_IF p0, double p1, struct S_IF p2,  void (*cb)(struct S_IF, double, struct S_IF)) ;
+EXPORT void f8_V_SDS_ID(struct S_ID p0, double p1, struct S_ID p2,  void (*cb)(struct S_ID, double, struct S_ID)) ;
+EXPORT void f8_V_SDS_IP(struct S_IP p0, double p1, struct S_IP p2,  void (*cb)(struct S_IP, double, struct S_IP)) ;
+EXPORT void f8_V_SDS_FI(struct S_FI p0, double p1, struct S_FI p2,  void (*cb)(struct S_FI, double, struct S_FI)) ;
+EXPORT void f8_V_SDS_FF(struct S_FF p0, double p1, struct S_FF p2,  void (*cb)(struct S_FF, double, struct S_FF)) ;
+EXPORT void f8_V_SDS_FD(struct S_FD p0, double p1, struct S_FD p2,  void (*cb)(struct S_FD, double, struct S_FD)) ;
+EXPORT void f8_V_SDS_FP(struct S_FP p0, double p1, struct S_FP p2,  void (*cb)(struct S_FP, double, struct S_FP)) ;
+EXPORT void f8_V_SDS_DI(struct S_DI p0, double p1, struct S_DI p2,  void (*cb)(struct S_DI, double, struct S_DI)) ;
+EXPORT void f8_V_SDS_DF(struct S_DF p0, double p1, struct S_DF p2,  void (*cb)(struct S_DF, double, struct S_DF)) ;
+EXPORT void f8_V_SDS_DD(struct S_DD p0, double p1, struct S_DD p2,  void (*cb)(struct S_DD, double, struct S_DD)) ;
+EXPORT void f8_V_SDS_DP(struct S_DP p0, double p1, struct S_DP p2,  void (*cb)(struct S_DP, double, struct S_DP)) ;
+EXPORT void f8_V_SDS_PI(struct S_PI p0, double p1, struct S_PI p2,  void (*cb)(struct S_PI, double, struct S_PI)) ;
+EXPORT void f8_V_SDS_PF(struct S_PF p0, double p1, struct S_PF p2,  void (*cb)(struct S_PF, double, struct S_PF)) ;
+EXPORT void f8_V_SDS_PD(struct S_PD p0, double p1, struct S_PD p2,  void (*cb)(struct S_PD, double, struct S_PD)) ;
+EXPORT void f8_V_SDS_PP(struct S_PP p0, double p1, struct S_PP p2,  void (*cb)(struct S_PP, double, struct S_PP)) ;
+EXPORT void f8_V_SDS_III(struct S_III p0, double p1, struct S_III p2,  void (*cb)(struct S_III, double, struct S_III)) ;
+EXPORT void f8_V_SDS_IIF(struct S_IIF p0, double p1, struct S_IIF p2,  void (*cb)(struct S_IIF, double, struct S_IIF)) ;
+EXPORT void f8_V_SDS_IID(struct S_IID p0, double p1, struct S_IID p2,  void (*cb)(struct S_IID, double, struct S_IID)) ;
+EXPORT void f8_V_SDS_IIP(struct S_IIP p0, double p1, struct S_IIP p2,  void (*cb)(struct S_IIP, double, struct S_IIP)) ;
+EXPORT void f8_V_SDS_IFI(struct S_IFI p0, double p1, struct S_IFI p2,  void (*cb)(struct S_IFI, double, struct S_IFI)) ;
+EXPORT void f8_V_SDS_IFF(struct S_IFF p0, double p1, struct S_IFF p2,  void (*cb)(struct S_IFF, double, struct S_IFF)) ;
+EXPORT void f8_V_SDS_IFD(struct S_IFD p0, double p1, struct S_IFD p2,  void (*cb)(struct S_IFD, double, struct S_IFD)) ;
+EXPORT void f8_V_SDS_IFP(struct S_IFP p0, double p1, struct S_IFP p2,  void (*cb)(struct S_IFP, double, struct S_IFP)) ;
+EXPORT void f8_V_SDS_IDI(struct S_IDI p0, double p1, struct S_IDI p2,  void (*cb)(struct S_IDI, double, struct S_IDI)) ;
+EXPORT void f8_V_SDS_IDF(struct S_IDF p0, double p1, struct S_IDF p2,  void (*cb)(struct S_IDF, double, struct S_IDF)) ;
+EXPORT void f8_V_SDS_IDD(struct S_IDD p0, double p1, struct S_IDD p2,  void (*cb)(struct S_IDD, double, struct S_IDD)) ;
+EXPORT void f8_V_SDS_IDP(struct S_IDP p0, double p1, struct S_IDP p2,  void (*cb)(struct S_IDP, double, struct S_IDP)) ;
+EXPORT void f8_V_SDS_IPI(struct S_IPI p0, double p1, struct S_IPI p2,  void (*cb)(struct S_IPI, double, struct S_IPI)) ;
+EXPORT void f8_V_SDS_IPF(struct S_IPF p0, double p1, struct S_IPF p2,  void (*cb)(struct S_IPF, double, struct S_IPF)) ;
+EXPORT void f8_V_SDS_IPD(struct S_IPD p0, double p1, struct S_IPD p2,  void (*cb)(struct S_IPD, double, struct S_IPD)) ;
+EXPORT void f8_V_SDS_IPP(struct S_IPP p0, double p1, struct S_IPP p2,  void (*cb)(struct S_IPP, double, struct S_IPP)) ;
+EXPORT void f8_V_SDS_FII(struct S_FII p0, double p1, struct S_FII p2,  void (*cb)(struct S_FII, double, struct S_FII)) ;
+EXPORT void f8_V_SDS_FIF(struct S_FIF p0, double p1, struct S_FIF p2,  void (*cb)(struct S_FIF, double, struct S_FIF)) ;
+EXPORT void f8_V_SDS_FID(struct S_FID p0, double p1, struct S_FID p2,  void (*cb)(struct S_FID, double, struct S_FID)) ;
+EXPORT void f8_V_SDS_FIP(struct S_FIP p0, double p1, struct S_FIP p2,  void (*cb)(struct S_FIP, double, struct S_FIP)) ;
+EXPORT void f8_V_SDS_FFI(struct S_FFI p0, double p1, struct S_FFI p2,  void (*cb)(struct S_FFI, double, struct S_FFI)) ;
+EXPORT void f8_V_SDS_FFF(struct S_FFF p0, double p1, struct S_FFF p2,  void (*cb)(struct S_FFF, double, struct S_FFF)) ;
+EXPORT void f8_V_SDS_FFD(struct S_FFD p0, double p1, struct S_FFD p2,  void (*cb)(struct S_FFD, double, struct S_FFD)) ;
+EXPORT void f8_V_SDS_FFP(struct S_FFP p0, double p1, struct S_FFP p2,  void (*cb)(struct S_FFP, double, struct S_FFP)) ;
+EXPORT void f8_V_SDS_FDI(struct S_FDI p0, double p1, struct S_FDI p2,  void (*cb)(struct S_FDI, double, struct S_FDI)) ;
+EXPORT void f8_V_SDS_FDF(struct S_FDF p0, double p1, struct S_FDF p2,  void (*cb)(struct S_FDF, double, struct S_FDF)) ;
+EXPORT void f8_V_SDS_FDD(struct S_FDD p0, double p1, struct S_FDD p2,  void (*cb)(struct S_FDD, double, struct S_FDD)) ;
+EXPORT void f8_V_SDS_FDP(struct S_FDP p0, double p1, struct S_FDP p2,  void (*cb)(struct S_FDP, double, struct S_FDP)) ;
+EXPORT void f8_V_SDS_FPI(struct S_FPI p0, double p1, struct S_FPI p2,  void (*cb)(struct S_FPI, double, struct S_FPI)) ;
+EXPORT void f8_V_SDS_FPF(struct S_FPF p0, double p1, struct S_FPF p2,  void (*cb)(struct S_FPF, double, struct S_FPF)) ;
+EXPORT void f8_V_SDS_FPD(struct S_FPD p0, double p1, struct S_FPD p2,  void (*cb)(struct S_FPD, double, struct S_FPD)) ;
+EXPORT void f8_V_SDS_FPP(struct S_FPP p0, double p1, struct S_FPP p2,  void (*cb)(struct S_FPP, double, struct S_FPP)) ;
+EXPORT void f8_V_SDS_DII(struct S_DII p0, double p1, struct S_DII p2,  void (*cb)(struct S_DII, double, struct S_DII)) ;
+EXPORT void f8_V_SDS_DIF(struct S_DIF p0, double p1, struct S_DIF p2,  void (*cb)(struct S_DIF, double, struct S_DIF)) ;
+EXPORT void f8_V_SDS_DID(struct S_DID p0, double p1, struct S_DID p2,  void (*cb)(struct S_DID, double, struct S_DID)) ;
+EXPORT void f8_V_SDS_DIP(struct S_DIP p0, double p1, struct S_DIP p2,  void (*cb)(struct S_DIP, double, struct S_DIP)) ;
+EXPORT void f8_V_SDS_DFI(struct S_DFI p0, double p1, struct S_DFI p2,  void (*cb)(struct S_DFI, double, struct S_DFI)) ;
+EXPORT void f8_V_SDS_DFF(struct S_DFF p0, double p1, struct S_DFF p2,  void (*cb)(struct S_DFF, double, struct S_DFF)) ;
+EXPORT void f8_V_SDS_DFD(struct S_DFD p0, double p1, struct S_DFD p2,  void (*cb)(struct S_DFD, double, struct S_DFD)) ;
+EXPORT void f8_V_SDS_DFP(struct S_DFP p0, double p1, struct S_DFP p2,  void (*cb)(struct S_DFP, double, struct S_DFP)) ;
+EXPORT void f8_V_SDS_DDI(struct S_DDI p0, double p1, struct S_DDI p2,  void (*cb)(struct S_DDI, double, struct S_DDI)) ;
+EXPORT void f8_V_SDS_DDF(struct S_DDF p0, double p1, struct S_DDF p2,  void (*cb)(struct S_DDF, double, struct S_DDF)) ;
+EXPORT void f8_V_SDS_DDD(struct S_DDD p0, double p1, struct S_DDD p2,  void (*cb)(struct S_DDD, double, struct S_DDD)) ;
+EXPORT void f8_V_SDS_DDP(struct S_DDP p0, double p1, struct S_DDP p2,  void (*cb)(struct S_DDP, double, struct S_DDP)) ;
+EXPORT void f8_V_SDS_DPI(struct S_DPI p0, double p1, struct S_DPI p2,  void (*cb)(struct S_DPI, double, struct S_DPI)) ;
+EXPORT void f8_V_SDS_DPF(struct S_DPF p0, double p1, struct S_DPF p2,  void (*cb)(struct S_DPF, double, struct S_DPF)) ;
+EXPORT void f8_V_SDS_DPD(struct S_DPD p0, double p1, struct S_DPD p2,  void (*cb)(struct S_DPD, double, struct S_DPD)) ;
+EXPORT void f8_V_SDS_DPP(struct S_DPP p0, double p1, struct S_DPP p2,  void (*cb)(struct S_DPP, double, struct S_DPP)) ;
+EXPORT void f8_V_SDS_PII(struct S_PII p0, double p1, struct S_PII p2,  void (*cb)(struct S_PII, double, struct S_PII)) ;
+EXPORT void f8_V_SDS_PIF(struct S_PIF p0, double p1, struct S_PIF p2,  void (*cb)(struct S_PIF, double, struct S_PIF)) ;
+EXPORT void f8_V_SDS_PID(struct S_PID p0, double p1, struct S_PID p2,  void (*cb)(struct S_PID, double, struct S_PID)) ;
+EXPORT void f8_V_SDS_PIP(struct S_PIP p0, double p1, struct S_PIP p2,  void (*cb)(struct S_PIP, double, struct S_PIP)) ;
+EXPORT void f8_V_SDS_PFI(struct S_PFI p0, double p1, struct S_PFI p2,  void (*cb)(struct S_PFI, double, struct S_PFI)) ;
+EXPORT void f8_V_SDS_PFF(struct S_PFF p0, double p1, struct S_PFF p2,  void (*cb)(struct S_PFF, double, struct S_PFF)) ;
+EXPORT void f8_V_SDS_PFD(struct S_PFD p0, double p1, struct S_PFD p2,  void (*cb)(struct S_PFD, double, struct S_PFD)) ;
+EXPORT void f8_V_SDS_PFP(struct S_PFP p0, double p1, struct S_PFP p2,  void (*cb)(struct S_PFP, double, struct S_PFP)) ;
+EXPORT void f8_V_SDS_PDI(struct S_PDI p0, double p1, struct S_PDI p2,  void (*cb)(struct S_PDI, double, struct S_PDI)) ;
+EXPORT void f8_V_SDS_PDF(struct S_PDF p0, double p1, struct S_PDF p2,  void (*cb)(struct S_PDF, double, struct S_PDF)) ;
+EXPORT void f8_V_SDS_PDD(struct S_PDD p0, double p1, struct S_PDD p2,  void (*cb)(struct S_PDD, double, struct S_PDD)) ;
+EXPORT void f8_V_SDS_PDP(struct S_PDP p0, double p1, struct S_PDP p2,  void (*cb)(struct S_PDP, double, struct S_PDP)) ;
+EXPORT void f8_V_SDS_PPI(struct S_PPI p0, double p1, struct S_PPI p2,  void (*cb)(struct S_PPI, double, struct S_PPI)) ;
+EXPORT void f8_V_SDS_PPF(struct S_PPF p0, double p1, struct S_PPF p2,  void (*cb)(struct S_PPF, double, struct S_PPF)) ;
+EXPORT void f8_V_SDS_PPD(struct S_PPD p0, double p1, struct S_PPD p2,  void (*cb)(struct S_PPD, double, struct S_PPD)) ;
+EXPORT void f8_V_SDS_PPP(struct S_PPP p0, double p1, struct S_PPP p2,  void (*cb)(struct S_PPP, double, struct S_PPP)) ;
+EXPORT void f8_V_SPI_I(struct S_I p0, void* p1, int p2,  void (*cb)(struct S_I, void*, int)) ;
+EXPORT void f8_V_SPI_F(struct S_F p0, void* p1, int p2,  void (*cb)(struct S_F, void*, int)) ;
+EXPORT void f8_V_SPI_D(struct S_D p0, void* p1, int p2,  void (*cb)(struct S_D, void*, int)) ;
+EXPORT void f8_V_SPI_P(struct S_P p0, void* p1, int p2,  void (*cb)(struct S_P, void*, int)) ;
+EXPORT void f8_V_SPI_II(struct S_II p0, void* p1, int p2,  void (*cb)(struct S_II, void*, int)) ;
+EXPORT void f8_V_SPI_IF(struct S_IF p0, void* p1, int p2,  void (*cb)(struct S_IF, void*, int)) ;
+EXPORT void f8_V_SPI_ID(struct S_ID p0, void* p1, int p2,  void (*cb)(struct S_ID, void*, int)) ;
+EXPORT void f8_V_SPI_IP(struct S_IP p0, void* p1, int p2,  void (*cb)(struct S_IP, void*, int)) ;
+EXPORT void f8_V_SPI_FI(struct S_FI p0, void* p1, int p2,  void (*cb)(struct S_FI, void*, int)) ;
+EXPORT void f8_V_SPI_FF(struct S_FF p0, void* p1, int p2,  void (*cb)(struct S_FF, void*, int)) ;
+EXPORT void f8_V_SPI_FD(struct S_FD p0, void* p1, int p2,  void (*cb)(struct S_FD, void*, int)) ;
+EXPORT void f8_V_SPI_FP(struct S_FP p0, void* p1, int p2,  void (*cb)(struct S_FP, void*, int)) ;
+EXPORT void f8_V_SPI_DI(struct S_DI p0, void* p1, int p2,  void (*cb)(struct S_DI, void*, int)) ;
+EXPORT void f8_V_SPI_DF(struct S_DF p0, void* p1, int p2,  void (*cb)(struct S_DF, void*, int)) ;
+EXPORT void f8_V_SPI_DD(struct S_DD p0, void* p1, int p2,  void (*cb)(struct S_DD, void*, int)) ;
+EXPORT void f8_V_SPI_DP(struct S_DP p0, void* p1, int p2,  void (*cb)(struct S_DP, void*, int)) ;
+EXPORT void f8_V_SPI_PI(struct S_PI p0, void* p1, int p2,  void (*cb)(struct S_PI, void*, int)) ;
+EXPORT void f8_V_SPI_PF(struct S_PF p0, void* p1, int p2,  void (*cb)(struct S_PF, void*, int)) ;
+EXPORT void f8_V_SPI_PD(struct S_PD p0, void* p1, int p2,  void (*cb)(struct S_PD, void*, int)) ;
+EXPORT void f8_V_SPI_PP(struct S_PP p0, void* p1, int p2,  void (*cb)(struct S_PP, void*, int)) ;
+EXPORT void f8_V_SPI_III(struct S_III p0, void* p1, int p2,  void (*cb)(struct S_III, void*, int)) ;
+EXPORT void f8_V_SPI_IIF(struct S_IIF p0, void* p1, int p2,  void (*cb)(struct S_IIF, void*, int)) ;
+EXPORT void f8_V_SPI_IID(struct S_IID p0, void* p1, int p2,  void (*cb)(struct S_IID, void*, int)) ;
+EXPORT void f8_V_SPI_IIP(struct S_IIP p0, void* p1, int p2,  void (*cb)(struct S_IIP, void*, int)) ;
+EXPORT void f8_V_SPI_IFI(struct S_IFI p0, void* p1, int p2,  void (*cb)(struct S_IFI, void*, int)) ;
+EXPORT void f8_V_SPI_IFF(struct S_IFF p0, void* p1, int p2,  void (*cb)(struct S_IFF, void*, int)) ;
+EXPORT void f8_V_SPI_IFD(struct S_IFD p0, void* p1, int p2,  void (*cb)(struct S_IFD, void*, int)) ;
+EXPORT void f8_V_SPI_IFP(struct S_IFP p0, void* p1, int p2,  void (*cb)(struct S_IFP, void*, int)) ;
+EXPORT void f8_V_SPI_IDI(struct S_IDI p0, void* p1, int p2,  void (*cb)(struct S_IDI, void*, int)) ;
+EXPORT void f8_V_SPI_IDF(struct S_IDF p0, void* p1, int p2,  void (*cb)(struct S_IDF, void*, int)) ;
+EXPORT void f8_V_SPI_IDD(struct S_IDD p0, void* p1, int p2,  void (*cb)(struct S_IDD, void*, int)) ;
+EXPORT void f8_V_SPI_IDP(struct S_IDP p0, void* p1, int p2,  void (*cb)(struct S_IDP, void*, int)) ;
+EXPORT void f8_V_SPI_IPI(struct S_IPI p0, void* p1, int p2,  void (*cb)(struct S_IPI, void*, int)) ;
+EXPORT void f8_V_SPI_IPF(struct S_IPF p0, void* p1, int p2,  void (*cb)(struct S_IPF, void*, int)) ;
+EXPORT void f8_V_SPI_IPD(struct S_IPD p0, void* p1, int p2,  void (*cb)(struct S_IPD, void*, int)) ;
+EXPORT void f8_V_SPI_IPP(struct S_IPP p0, void* p1, int p2,  void (*cb)(struct S_IPP, void*, int)) ;
+EXPORT void f8_V_SPI_FII(struct S_FII p0, void* p1, int p2,  void (*cb)(struct S_FII, void*, int)) ;
+EXPORT void f8_V_SPI_FIF(struct S_FIF p0, void* p1, int p2,  void (*cb)(struct S_FIF, void*, int)) ;
+EXPORT void f8_V_SPI_FID(struct S_FID p0, void* p1, int p2,  void (*cb)(struct S_FID, void*, int)) ;
+EXPORT void f8_V_SPI_FIP(struct S_FIP p0, void* p1, int p2,  void (*cb)(struct S_FIP, void*, int)) ;
+EXPORT void f8_V_SPI_FFI(struct S_FFI p0, void* p1, int p2,  void (*cb)(struct S_FFI, void*, int)) ;
+EXPORT void f8_V_SPI_FFF(struct S_FFF p0, void* p1, int p2,  void (*cb)(struct S_FFF, void*, int)) ;
+EXPORT void f8_V_SPI_FFD(struct S_FFD p0, void* p1, int p2,  void (*cb)(struct S_FFD, void*, int)) ;
+EXPORT void f8_V_SPI_FFP(struct S_FFP p0, void* p1, int p2,  void (*cb)(struct S_FFP, void*, int)) ;
+EXPORT void f8_V_SPI_FDI(struct S_FDI p0, void* p1, int p2,  void (*cb)(struct S_FDI, void*, int)) ;
+EXPORT void f8_V_SPI_FDF(struct S_FDF p0, void* p1, int p2,  void (*cb)(struct S_FDF, void*, int)) ;
+EXPORT void f8_V_SPI_FDD(struct S_FDD p0, void* p1, int p2,  void (*cb)(struct S_FDD, void*, int)) ;
+EXPORT void f8_V_SPI_FDP(struct S_FDP p0, void* p1, int p2,  void (*cb)(struct S_FDP, void*, int)) ;
+EXPORT void f8_V_SPI_FPI(struct S_FPI p0, void* p1, int p2,  void (*cb)(struct S_FPI, void*, int)) ;
+EXPORT void f8_V_SPI_FPF(struct S_FPF p0, void* p1, int p2,  void (*cb)(struct S_FPF, void*, int)) ;
+EXPORT void f8_V_SPI_FPD(struct S_FPD p0, void* p1, int p2,  void (*cb)(struct S_FPD, void*, int)) ;
+EXPORT void f8_V_SPI_FPP(struct S_FPP p0, void* p1, int p2,  void (*cb)(struct S_FPP, void*, int)) ;
+EXPORT void f8_V_SPI_DII(struct S_DII p0, void* p1, int p2,  void (*cb)(struct S_DII, void*, int)) ;
+EXPORT void f8_V_SPI_DIF(struct S_DIF p0, void* p1, int p2,  void (*cb)(struct S_DIF, void*, int)) ;
+EXPORT void f8_V_SPI_DID(struct S_DID p0, void* p1, int p2,  void (*cb)(struct S_DID, void*, int)) ;
+EXPORT void f8_V_SPI_DIP(struct S_DIP p0, void* p1, int p2,  void (*cb)(struct S_DIP, void*, int)) ;
+EXPORT void f8_V_SPI_DFI(struct S_DFI p0, void* p1, int p2,  void (*cb)(struct S_DFI, void*, int)) ;
+EXPORT void f8_V_SPI_DFF(struct S_DFF p0, void* p1, int p2,  void (*cb)(struct S_DFF, void*, int)) ;
+EXPORT void f8_V_SPI_DFD(struct S_DFD p0, void* p1, int p2,  void (*cb)(struct S_DFD, void*, int)) ;
+EXPORT void f8_V_SPI_DFP(struct S_DFP p0, void* p1, int p2,  void (*cb)(struct S_DFP, void*, int)) ;
+EXPORT void f8_V_SPI_DDI(struct S_DDI p0, void* p1, int p2,  void (*cb)(struct S_DDI, void*, int)) ;
+EXPORT void f8_V_SPI_DDF(struct S_DDF p0, void* p1, int p2,  void (*cb)(struct S_DDF, void*, int)) ;
+EXPORT void f8_V_SPI_DDD(struct S_DDD p0, void* p1, int p2,  void (*cb)(struct S_DDD, void*, int)) ;
+EXPORT void f8_V_SPI_DDP(struct S_DDP p0, void* p1, int p2,  void (*cb)(struct S_DDP, void*, int)) ;
+EXPORT void f8_V_SPI_DPI(struct S_DPI p0, void* p1, int p2,  void (*cb)(struct S_DPI, void*, int)) ;
+EXPORT void f8_V_SPI_DPF(struct S_DPF p0, void* p1, int p2,  void (*cb)(struct S_DPF, void*, int)) ;
+EXPORT void f8_V_SPI_DPD(struct S_DPD p0, void* p1, int p2,  void (*cb)(struct S_DPD, void*, int)) ;
+EXPORT void f8_V_SPI_DPP(struct S_DPP p0, void* p1, int p2,  void (*cb)(struct S_DPP, void*, int)) ;
+EXPORT void f8_V_SPI_PII(struct S_PII p0, void* p1, int p2,  void (*cb)(struct S_PII, void*, int)) ;
+EXPORT void f8_V_SPI_PIF(struct S_PIF p0, void* p1, int p2,  void (*cb)(struct S_PIF, void*, int)) ;
+EXPORT void f8_V_SPI_PID(struct S_PID p0, void* p1, int p2,  void (*cb)(struct S_PID, void*, int)) ;
+EXPORT void f8_V_SPI_PIP(struct S_PIP p0, void* p1, int p2,  void (*cb)(struct S_PIP, void*, int)) ;
+EXPORT void f8_V_SPI_PFI(struct S_PFI p0, void* p1, int p2,  void (*cb)(struct S_PFI, void*, int)) ;
+EXPORT void f8_V_SPI_PFF(struct S_PFF p0, void* p1, int p2,  void (*cb)(struct S_PFF, void*, int)) ;
+EXPORT void f8_V_SPI_PFD(struct S_PFD p0, void* p1, int p2,  void (*cb)(struct S_PFD, void*, int)) ;
+EXPORT void f8_V_SPI_PFP(struct S_PFP p0, void* p1, int p2,  void (*cb)(struct S_PFP, void*, int)) ;
+EXPORT void f8_V_SPI_PDI(struct S_PDI p0, void* p1, int p2,  void (*cb)(struct S_PDI, void*, int)) ;
+EXPORT void f8_V_SPI_PDF(struct S_PDF p0, void* p1, int p2,  void (*cb)(struct S_PDF, void*, int)) ;
+EXPORT void f8_V_SPI_PDD(struct S_PDD p0, void* p1, int p2,  void (*cb)(struct S_PDD, void*, int)) ;
+EXPORT void f8_V_SPI_PDP(struct S_PDP p0, void* p1, int p2,  void (*cb)(struct S_PDP, void*, int)) ;
+EXPORT void f8_V_SPI_PPI(struct S_PPI p0, void* p1, int p2,  void (*cb)(struct S_PPI, void*, int)) ;
+EXPORT void f8_V_SPI_PPF(struct S_PPF p0, void* p1, int p2,  void (*cb)(struct S_PPF, void*, int)) ;
+EXPORT void f8_V_SPI_PPD(struct S_PPD p0, void* p1, int p2,  void (*cb)(struct S_PPD, void*, int)) ;
+EXPORT void f8_V_SPI_PPP(struct S_PPP p0, void* p1, int p2,  void (*cb)(struct S_PPP, void*, int)) ;
+EXPORT void f8_V_SPF_I(struct S_I p0, void* p1, float p2,  void (*cb)(struct S_I, void*, float)) ;
+EXPORT void f8_V_SPF_F(struct S_F p0, void* p1, float p2,  void (*cb)(struct S_F, void*, float)) ;
+EXPORT void f8_V_SPF_D(struct S_D p0, void* p1, float p2,  void (*cb)(struct S_D, void*, float)) ;
+EXPORT void f8_V_SPF_P(struct S_P p0, void* p1, float p2,  void (*cb)(struct S_P, void*, float)) ;
+EXPORT void f8_V_SPF_II(struct S_II p0, void* p1, float p2,  void (*cb)(struct S_II, void*, float)) ;
+EXPORT void f8_V_SPF_IF(struct S_IF p0, void* p1, float p2,  void (*cb)(struct S_IF, void*, float)) ;
+EXPORT void f8_V_SPF_ID(struct S_ID p0, void* p1, float p2,  void (*cb)(struct S_ID, void*, float)) ;
+EXPORT void f8_V_SPF_IP(struct S_IP p0, void* p1, float p2,  void (*cb)(struct S_IP, void*, float)) ;
+EXPORT void f8_V_SPF_FI(struct S_FI p0, void* p1, float p2,  void (*cb)(struct S_FI, void*, float)) ;
+EXPORT void f8_V_SPF_FF(struct S_FF p0, void* p1, float p2,  void (*cb)(struct S_FF, void*, float)) ;
+EXPORT void f8_V_SPF_FD(struct S_FD p0, void* p1, float p2,  void (*cb)(struct S_FD, void*, float)) ;
+EXPORT void f8_V_SPF_FP(struct S_FP p0, void* p1, float p2,  void (*cb)(struct S_FP, void*, float)) ;
+EXPORT void f8_V_SPF_DI(struct S_DI p0, void* p1, float p2,  void (*cb)(struct S_DI, void*, float)) ;
+EXPORT void f8_V_SPF_DF(struct S_DF p0, void* p1, float p2,  void (*cb)(struct S_DF, void*, float)) ;
+EXPORT void f8_V_SPF_DD(struct S_DD p0, void* p1, float p2,  void (*cb)(struct S_DD, void*, float)) ;
+EXPORT void f8_V_SPF_DP(struct S_DP p0, void* p1, float p2,  void (*cb)(struct S_DP, void*, float)) ;
+EXPORT void f8_V_SPF_PI(struct S_PI p0, void* p1, float p2,  void (*cb)(struct S_PI, void*, float)) ;
+EXPORT void f8_V_SPF_PF(struct S_PF p0, void* p1, float p2,  void (*cb)(struct S_PF, void*, float)) ;
+EXPORT void f8_V_SPF_PD(struct S_PD p0, void* p1, float p2,  void (*cb)(struct S_PD, void*, float)) ;
+EXPORT void f8_V_SPF_PP(struct S_PP p0, void* p1, float p2,  void (*cb)(struct S_PP, void*, float)) ;
+EXPORT void f8_V_SPF_III(struct S_III p0, void* p1, float p2,  void (*cb)(struct S_III, void*, float)) ;
+EXPORT void f8_V_SPF_IIF(struct S_IIF p0, void* p1, float p2,  void (*cb)(struct S_IIF, void*, float)) ;
+EXPORT void f8_V_SPF_IID(struct S_IID p0, void* p1, float p2,  void (*cb)(struct S_IID, void*, float)) ;
+EXPORT void f8_V_SPF_IIP(struct S_IIP p0, void* p1, float p2,  void (*cb)(struct S_IIP, void*, float)) ;
+EXPORT void f8_V_SPF_IFI(struct S_IFI p0, void* p1, float p2,  void (*cb)(struct S_IFI, void*, float)) ;
+EXPORT void f8_V_SPF_IFF(struct S_IFF p0, void* p1, float p2,  void (*cb)(struct S_IFF, void*, float)) ;
+EXPORT void f8_V_SPF_IFD(struct S_IFD p0, void* p1, float p2,  void (*cb)(struct S_IFD, void*, float)) ;
+EXPORT void f8_V_SPF_IFP(struct S_IFP p0, void* p1, float p2,  void (*cb)(struct S_IFP, void*, float)) ;
+EXPORT void f8_V_SPF_IDI(struct S_IDI p0, void* p1, float p2,  void (*cb)(struct S_IDI, void*, float)) ;
+EXPORT void f8_V_SPF_IDF(struct S_IDF p0, void* p1, float p2,  void (*cb)(struct S_IDF, void*, float)) ;
+EXPORT void f8_V_SPF_IDD(struct S_IDD p0, void* p1, float p2,  void (*cb)(struct S_IDD, void*, float)) ;
+EXPORT void f8_V_SPF_IDP(struct S_IDP p0, void* p1, float p2,  void (*cb)(struct S_IDP, void*, float)) ;
+EXPORT void f8_V_SPF_IPI(struct S_IPI p0, void* p1, float p2,  void (*cb)(struct S_IPI, void*, float)) ;
+EXPORT void f8_V_SPF_IPF(struct S_IPF p0, void* p1, float p2,  void (*cb)(struct S_IPF, void*, float)) ;
+EXPORT void f8_V_SPF_IPD(struct S_IPD p0, void* p1, float p2,  void (*cb)(struct S_IPD, void*, float)) ;
+EXPORT void f8_V_SPF_IPP(struct S_IPP p0, void* p1, float p2,  void (*cb)(struct S_IPP, void*, float)) ;
+EXPORT void f8_V_SPF_FII(struct S_FII p0, void* p1, float p2,  void (*cb)(struct S_FII, void*, float)) ;
+EXPORT void f8_V_SPF_FIF(struct S_FIF p0, void* p1, float p2,  void (*cb)(struct S_FIF, void*, float)) ;
+EXPORT void f8_V_SPF_FID(struct S_FID p0, void* p1, float p2,  void (*cb)(struct S_FID, void*, float)) ;
+EXPORT void f8_V_SPF_FIP(struct S_FIP p0, void* p1, float p2,  void (*cb)(struct S_FIP, void*, float)) ;
+EXPORT void f8_V_SPF_FFI(struct S_FFI p0, void* p1, float p2,  void (*cb)(struct S_FFI, void*, float)) ;
+EXPORT void f8_V_SPF_FFF(struct S_FFF p0, void* p1, float p2,  void (*cb)(struct S_FFF, void*, float)) ;
+EXPORT void f8_V_SPF_FFD(struct S_FFD p0, void* p1, float p2,  void (*cb)(struct S_FFD, void*, float)) ;
+EXPORT void f8_V_SPF_FFP(struct S_FFP p0, void* p1, float p2,  void (*cb)(struct S_FFP, void*, float)) ;
+EXPORT void f8_V_SPF_FDI(struct S_FDI p0, void* p1, float p2,  void (*cb)(struct S_FDI, void*, float)) ;
+EXPORT void f8_V_SPF_FDF(struct S_FDF p0, void* p1, float p2,  void (*cb)(struct S_FDF, void*, float)) ;
+EXPORT void f8_V_SPF_FDD(struct S_FDD p0, void* p1, float p2,  void (*cb)(struct S_FDD, void*, float)) ;
+EXPORT void f8_V_SPF_FDP(struct S_FDP p0, void* p1, float p2,  void (*cb)(struct S_FDP, void*, float)) ;
+EXPORT void f8_V_SPF_FPI(struct S_FPI p0, void* p1, float p2,  void (*cb)(struct S_FPI, void*, float)) ;
+EXPORT void f8_V_SPF_FPF(struct S_FPF p0, void* p1, float p2,  void (*cb)(struct S_FPF, void*, float)) ;
+EXPORT void f8_V_SPF_FPD(struct S_FPD p0, void* p1, float p2,  void (*cb)(struct S_FPD, void*, float)) ;
+EXPORT void f8_V_SPF_FPP(struct S_FPP p0, void* p1, float p2,  void (*cb)(struct S_FPP, void*, float)) ;
+EXPORT void f8_V_SPF_DII(struct S_DII p0, void* p1, float p2,  void (*cb)(struct S_DII, void*, float)) ;
+EXPORT void f8_V_SPF_DIF(struct S_DIF p0, void* p1, float p2,  void (*cb)(struct S_DIF, void*, float)) ;
+EXPORT void f8_V_SPF_DID(struct S_DID p0, void* p1, float p2,  void (*cb)(struct S_DID, void*, float)) ;
+EXPORT void f8_V_SPF_DIP(struct S_DIP p0, void* p1, float p2,  void (*cb)(struct S_DIP, void*, float)) ;
+EXPORT void f8_V_SPF_DFI(struct S_DFI p0, void* p1, float p2,  void (*cb)(struct S_DFI, void*, float)) ;
+EXPORT void f8_V_SPF_DFF(struct S_DFF p0, void* p1, float p2,  void (*cb)(struct S_DFF, void*, float)) ;
+EXPORT void f8_V_SPF_DFD(struct S_DFD p0, void* p1, float p2,  void (*cb)(struct S_DFD, void*, float)) ;
+EXPORT void f8_V_SPF_DFP(struct S_DFP p0, void* p1, float p2,  void (*cb)(struct S_DFP, void*, float)) ;
+EXPORT void f8_V_SPF_DDI(struct S_DDI p0, void* p1, float p2,  void (*cb)(struct S_DDI, void*, float)) ;
+EXPORT void f8_V_SPF_DDF(struct S_DDF p0, void* p1, float p2,  void (*cb)(struct S_DDF, void*, float)) ;
+EXPORT void f8_V_SPF_DDD(struct S_DDD p0, void* p1, float p2,  void (*cb)(struct S_DDD, void*, float)) ;
+EXPORT void f8_V_SPF_DDP(struct S_DDP p0, void* p1, float p2,  void (*cb)(struct S_DDP, void*, float)) ;
+EXPORT void f8_V_SPF_DPI(struct S_DPI p0, void* p1, float p2,  void (*cb)(struct S_DPI, void*, float)) ;
+EXPORT void f8_V_SPF_DPF(struct S_DPF p0, void* p1, float p2,  void (*cb)(struct S_DPF, void*, float)) ;
+EXPORT void f8_V_SPF_DPD(struct S_DPD p0, void* p1, float p2,  void (*cb)(struct S_DPD, void*, float)) ;
+EXPORT void f8_V_SPF_DPP(struct S_DPP p0, void* p1, float p2,  void (*cb)(struct S_DPP, void*, float)) ;
+EXPORT void f8_V_SPF_PII(struct S_PII p0, void* p1, float p2,  void (*cb)(struct S_PII, void*, float)) ;
+EXPORT void f8_V_SPF_PIF(struct S_PIF p0, void* p1, float p2,  void (*cb)(struct S_PIF, void*, float)) ;
+EXPORT void f8_V_SPF_PID(struct S_PID p0, void* p1, float p2,  void (*cb)(struct S_PID, void*, float)) ;
+EXPORT void f8_V_SPF_PIP(struct S_PIP p0, void* p1, float p2,  void (*cb)(struct S_PIP, void*, float)) ;
+EXPORT void f8_V_SPF_PFI(struct S_PFI p0, void* p1, float p2,  void (*cb)(struct S_PFI, void*, float)) ;
+EXPORT void f8_V_SPF_PFF(struct S_PFF p0, void* p1, float p2,  void (*cb)(struct S_PFF, void*, float)) ;
+EXPORT void f8_V_SPF_PFD(struct S_PFD p0, void* p1, float p2,  void (*cb)(struct S_PFD, void*, float)) ;
+EXPORT void f8_V_SPF_PFP(struct S_PFP p0, void* p1, float p2,  void (*cb)(struct S_PFP, void*, float)) ;
+EXPORT void f8_V_SPF_PDI(struct S_PDI p0, void* p1, float p2,  void (*cb)(struct S_PDI, void*, float)) ;
+EXPORT void f8_V_SPF_PDF(struct S_PDF p0, void* p1, float p2,  void (*cb)(struct S_PDF, void*, float)) ;
+EXPORT void f8_V_SPF_PDD(struct S_PDD p0, void* p1, float p2,  void (*cb)(struct S_PDD, void*, float)) ;
+EXPORT void f8_V_SPF_PDP(struct S_PDP p0, void* p1, float p2,  void (*cb)(struct S_PDP, void*, float)) ;
+EXPORT void f8_V_SPF_PPI(struct S_PPI p0, void* p1, float p2,  void (*cb)(struct S_PPI, void*, float)) ;
+EXPORT void f8_V_SPF_PPF(struct S_PPF p0, void* p1, float p2,  void (*cb)(struct S_PPF, void*, float)) ;
+EXPORT void f8_V_SPF_PPD(struct S_PPD p0, void* p1, float p2,  void (*cb)(struct S_PPD, void*, float)) ;
+EXPORT void f8_V_SPF_PPP(struct S_PPP p0, void* p1, float p2,  void (*cb)(struct S_PPP, void*, float)) ;
+EXPORT void f8_V_SPD_I(struct S_I p0, void* p1, double p2,  void (*cb)(struct S_I, void*, double)) ;
+EXPORT void f8_V_SPD_F(struct S_F p0, void* p1, double p2,  void (*cb)(struct S_F, void*, double)) ;
+EXPORT void f8_V_SPD_D(struct S_D p0, void* p1, double p2,  void (*cb)(struct S_D, void*, double)) ;
+EXPORT void f8_V_SPD_P(struct S_P p0, void* p1, double p2,  void (*cb)(struct S_P, void*, double)) ;
+EXPORT void f8_V_SPD_II(struct S_II p0, void* p1, double p2,  void (*cb)(struct S_II, void*, double)) ;
+EXPORT void f8_V_SPD_IF(struct S_IF p0, void* p1, double p2,  void (*cb)(struct S_IF, void*, double)) ;
+EXPORT void f8_V_SPD_ID(struct S_ID p0, void* p1, double p2,  void (*cb)(struct S_ID, void*, double)) ;
+EXPORT void f8_V_SPD_IP(struct S_IP p0, void* p1, double p2,  void (*cb)(struct S_IP, void*, double)) ;
+EXPORT void f8_V_SPD_FI(struct S_FI p0, void* p1, double p2,  void (*cb)(struct S_FI, void*, double)) ;
+EXPORT void f8_V_SPD_FF(struct S_FF p0, void* p1, double p2,  void (*cb)(struct S_FF, void*, double)) ;
+EXPORT void f8_V_SPD_FD(struct S_FD p0, void* p1, double p2,  void (*cb)(struct S_FD, void*, double)) ;
+EXPORT void f8_V_SPD_FP(struct S_FP p0, void* p1, double p2,  void (*cb)(struct S_FP, void*, double)) ;
+EXPORT void f8_V_SPD_DI(struct S_DI p0, void* p1, double p2,  void (*cb)(struct S_DI, void*, double)) ;
+EXPORT void f8_V_SPD_DF(struct S_DF p0, void* p1, double p2,  void (*cb)(struct S_DF, void*, double)) ;
+EXPORT void f8_V_SPD_DD(struct S_DD p0, void* p1, double p2,  void (*cb)(struct S_DD, void*, double)) ;
+EXPORT void f8_V_SPD_DP(struct S_DP p0, void* p1, double p2,  void (*cb)(struct S_DP, void*, double)) ;
+EXPORT void f8_V_SPD_PI(struct S_PI p0, void* p1, double p2,  void (*cb)(struct S_PI, void*, double)) ;
+EXPORT void f8_V_SPD_PF(struct S_PF p0, void* p1, double p2,  void (*cb)(struct S_PF, void*, double)) ;
+EXPORT void f8_V_SPD_PD(struct S_PD p0, void* p1, double p2,  void (*cb)(struct S_PD, void*, double)) ;
+EXPORT void f8_V_SPD_PP(struct S_PP p0, void* p1, double p2,  void (*cb)(struct S_PP, void*, double)) ;
+EXPORT void f8_V_SPD_III(struct S_III p0, void* p1, double p2,  void (*cb)(struct S_III, void*, double)) ;
+EXPORT void f8_V_SPD_IIF(struct S_IIF p0, void* p1, double p2,  void (*cb)(struct S_IIF, void*, double)) ;
+EXPORT void f8_V_SPD_IID(struct S_IID p0, void* p1, double p2,  void (*cb)(struct S_IID, void*, double)) ;
+EXPORT void f9_V_SPD_IIP(struct S_IIP p0, void* p1, double p2,  void (*cb)(struct S_IIP, void*, double)) ;
+EXPORT void f9_V_SPD_IFI(struct S_IFI p0, void* p1, double p2,  void (*cb)(struct S_IFI, void*, double)) ;
+EXPORT void f9_V_SPD_IFF(struct S_IFF p0, void* p1, double p2,  void (*cb)(struct S_IFF, void*, double)) ;
+EXPORT void f9_V_SPD_IFD(struct S_IFD p0, void* p1, double p2,  void (*cb)(struct S_IFD, void*, double)) ;
+EXPORT void f9_V_SPD_IFP(struct S_IFP p0, void* p1, double p2,  void (*cb)(struct S_IFP, void*, double)) ;
+EXPORT void f9_V_SPD_IDI(struct S_IDI p0, void* p1, double p2,  void (*cb)(struct S_IDI, void*, double)) ;
+EXPORT void f9_V_SPD_IDF(struct S_IDF p0, void* p1, double p2,  void (*cb)(struct S_IDF, void*, double)) ;
+EXPORT void f9_V_SPD_IDD(struct S_IDD p0, void* p1, double p2,  void (*cb)(struct S_IDD, void*, double)) ;
+EXPORT void f9_V_SPD_IDP(struct S_IDP p0, void* p1, double p2,  void (*cb)(struct S_IDP, void*, double)) ;
+EXPORT void f9_V_SPD_IPI(struct S_IPI p0, void* p1, double p2,  void (*cb)(struct S_IPI, void*, double)) ;
+EXPORT void f9_V_SPD_IPF(struct S_IPF p0, void* p1, double p2,  void (*cb)(struct S_IPF, void*, double)) ;
+EXPORT void f9_V_SPD_IPD(struct S_IPD p0, void* p1, double p2,  void (*cb)(struct S_IPD, void*, double)) ;
+EXPORT void f9_V_SPD_IPP(struct S_IPP p0, void* p1, double p2,  void (*cb)(struct S_IPP, void*, double)) ;
+EXPORT void f9_V_SPD_FII(struct S_FII p0, void* p1, double p2,  void (*cb)(struct S_FII, void*, double)) ;
+EXPORT void f9_V_SPD_FIF(struct S_FIF p0, void* p1, double p2,  void (*cb)(struct S_FIF, void*, double)) ;
+EXPORT void f9_V_SPD_FID(struct S_FID p0, void* p1, double p2,  void (*cb)(struct S_FID, void*, double)) ;
+EXPORT void f9_V_SPD_FIP(struct S_FIP p0, void* p1, double p2,  void (*cb)(struct S_FIP, void*, double)) ;
+EXPORT void f9_V_SPD_FFI(struct S_FFI p0, void* p1, double p2,  void (*cb)(struct S_FFI, void*, double)) ;
+EXPORT void f9_V_SPD_FFF(struct S_FFF p0, void* p1, double p2,  void (*cb)(struct S_FFF, void*, double)) ;
+EXPORT void f9_V_SPD_FFD(struct S_FFD p0, void* p1, double p2,  void (*cb)(struct S_FFD, void*, double)) ;
+EXPORT void f9_V_SPD_FFP(struct S_FFP p0, void* p1, double p2,  void (*cb)(struct S_FFP, void*, double)) ;
+EXPORT void f9_V_SPD_FDI(struct S_FDI p0, void* p1, double p2,  void (*cb)(struct S_FDI, void*, double)) ;
+EXPORT void f9_V_SPD_FDF(struct S_FDF p0, void* p1, double p2,  void (*cb)(struct S_FDF, void*, double)) ;
+EXPORT void f9_V_SPD_FDD(struct S_FDD p0, void* p1, double p2,  void (*cb)(struct S_FDD, void*, double)) ;
+EXPORT void f9_V_SPD_FDP(struct S_FDP p0, void* p1, double p2,  void (*cb)(struct S_FDP, void*, double)) ;
+EXPORT void f9_V_SPD_FPI(struct S_FPI p0, void* p1, double p2,  void (*cb)(struct S_FPI, void*, double)) ;
+EXPORT void f9_V_SPD_FPF(struct S_FPF p0, void* p1, double p2,  void (*cb)(struct S_FPF, void*, double)) ;
+EXPORT void f9_V_SPD_FPD(struct S_FPD p0, void* p1, double p2,  void (*cb)(struct S_FPD, void*, double)) ;
+EXPORT void f9_V_SPD_FPP(struct S_FPP p0, void* p1, double p2,  void (*cb)(struct S_FPP, void*, double)) ;
+EXPORT void f9_V_SPD_DII(struct S_DII p0, void* p1, double p2,  void (*cb)(struct S_DII, void*, double)) ;
+EXPORT void f9_V_SPD_DIF(struct S_DIF p0, void* p1, double p2,  void (*cb)(struct S_DIF, void*, double)) ;
+EXPORT void f9_V_SPD_DID(struct S_DID p0, void* p1, double p2,  void (*cb)(struct S_DID, void*, double)) ;
+EXPORT void f9_V_SPD_DIP(struct S_DIP p0, void* p1, double p2,  void (*cb)(struct S_DIP, void*, double)) ;
+EXPORT void f9_V_SPD_DFI(struct S_DFI p0, void* p1, double p2,  void (*cb)(struct S_DFI, void*, double)) ;
+EXPORT void f9_V_SPD_DFF(struct S_DFF p0, void* p1, double p2,  void (*cb)(struct S_DFF, void*, double)) ;
+EXPORT void f9_V_SPD_DFD(struct S_DFD p0, void* p1, double p2,  void (*cb)(struct S_DFD, void*, double)) ;
+EXPORT void f9_V_SPD_DFP(struct S_DFP p0, void* p1, double p2,  void (*cb)(struct S_DFP, void*, double)) ;
+EXPORT void f9_V_SPD_DDI(struct S_DDI p0, void* p1, double p2,  void (*cb)(struct S_DDI, void*, double)) ;
+EXPORT void f9_V_SPD_DDF(struct S_DDF p0, void* p1, double p2,  void (*cb)(struct S_DDF, void*, double)) ;
+EXPORT void f9_V_SPD_DDD(struct S_DDD p0, void* p1, double p2,  void (*cb)(struct S_DDD, void*, double)) ;
+EXPORT void f9_V_SPD_DDP(struct S_DDP p0, void* p1, double p2,  void (*cb)(struct S_DDP, void*, double)) ;
+EXPORT void f9_V_SPD_DPI(struct S_DPI p0, void* p1, double p2,  void (*cb)(struct S_DPI, void*, double)) ;
+EXPORT void f9_V_SPD_DPF(struct S_DPF p0, void* p1, double p2,  void (*cb)(struct S_DPF, void*, double)) ;
+EXPORT void f9_V_SPD_DPD(struct S_DPD p0, void* p1, double p2,  void (*cb)(struct S_DPD, void*, double)) ;
+EXPORT void f9_V_SPD_DPP(struct S_DPP p0, void* p1, double p2,  void (*cb)(struct S_DPP, void*, double)) ;
+EXPORT void f9_V_SPD_PII(struct S_PII p0, void* p1, double p2,  void (*cb)(struct S_PII, void*, double)) ;
+EXPORT void f9_V_SPD_PIF(struct S_PIF p0, void* p1, double p2,  void (*cb)(struct S_PIF, void*, double)) ;
+EXPORT void f9_V_SPD_PID(struct S_PID p0, void* p1, double p2,  void (*cb)(struct S_PID, void*, double)) ;
+EXPORT void f9_V_SPD_PIP(struct S_PIP p0, void* p1, double p2,  void (*cb)(struct S_PIP, void*, double)) ;
+EXPORT void f9_V_SPD_PFI(struct S_PFI p0, void* p1, double p2,  void (*cb)(struct S_PFI, void*, double)) ;
+EXPORT void f9_V_SPD_PFF(struct S_PFF p0, void* p1, double p2,  void (*cb)(struct S_PFF, void*, double)) ;
+EXPORT void f9_V_SPD_PFD(struct S_PFD p0, void* p1, double p2,  void (*cb)(struct S_PFD, void*, double)) ;
+EXPORT void f9_V_SPD_PFP(struct S_PFP p0, void* p1, double p2,  void (*cb)(struct S_PFP, void*, double)) ;
+EXPORT void f9_V_SPD_PDI(struct S_PDI p0, void* p1, double p2,  void (*cb)(struct S_PDI, void*, double)) ;
+EXPORT void f9_V_SPD_PDF(struct S_PDF p0, void* p1, double p2,  void (*cb)(struct S_PDF, void*, double)) ;
+EXPORT void f9_V_SPD_PDD(struct S_PDD p0, void* p1, double p2,  void (*cb)(struct S_PDD, void*, double)) ;
+EXPORT void f9_V_SPD_PDP(struct S_PDP p0, void* p1, double p2,  void (*cb)(struct S_PDP, void*, double)) ;
+EXPORT void f9_V_SPD_PPI(struct S_PPI p0, void* p1, double p2,  void (*cb)(struct S_PPI, void*, double)) ;
+EXPORT void f9_V_SPD_PPF(struct S_PPF p0, void* p1, double p2,  void (*cb)(struct S_PPF, void*, double)) ;
+EXPORT void f9_V_SPD_PPD(struct S_PPD p0, void* p1, double p2,  void (*cb)(struct S_PPD, void*, double)) ;
+EXPORT void f9_V_SPD_PPP(struct S_PPP p0, void* p1, double p2,  void (*cb)(struct S_PPP, void*, double)) ;
+EXPORT void f9_V_SPP_I(struct S_I p0, void* p1, void* p2,  void (*cb)(struct S_I, void*, void*)) ;
+EXPORT void f9_V_SPP_F(struct S_F p0, void* p1, void* p2,  void (*cb)(struct S_F, void*, void*)) ;
+EXPORT void f9_V_SPP_D(struct S_D p0, void* p1, void* p2,  void (*cb)(struct S_D, void*, void*)) ;
+EXPORT void f9_V_SPP_P(struct S_P p0, void* p1, void* p2,  void (*cb)(struct S_P, void*, void*)) ;
+EXPORT void f9_V_SPP_II(struct S_II p0, void* p1, void* p2,  void (*cb)(struct S_II, void*, void*)) ;
+EXPORT void f9_V_SPP_IF(struct S_IF p0, void* p1, void* p2,  void (*cb)(struct S_IF, void*, void*)) ;
+EXPORT void f9_V_SPP_ID(struct S_ID p0, void* p1, void* p2,  void (*cb)(struct S_ID, void*, void*)) ;
+EXPORT void f9_V_SPP_IP(struct S_IP p0, void* p1, void* p2,  void (*cb)(struct S_IP, void*, void*)) ;
+EXPORT void f9_V_SPP_FI(struct S_FI p0, void* p1, void* p2,  void (*cb)(struct S_FI, void*, void*)) ;
+EXPORT void f9_V_SPP_FF(struct S_FF p0, void* p1, void* p2,  void (*cb)(struct S_FF, void*, void*)) ;
+EXPORT void f9_V_SPP_FD(struct S_FD p0, void* p1, void* p2,  void (*cb)(struct S_FD, void*, void*)) ;
+EXPORT void f9_V_SPP_FP(struct S_FP p0, void* p1, void* p2,  void (*cb)(struct S_FP, void*, void*)) ;
+EXPORT void f9_V_SPP_DI(struct S_DI p0, void* p1, void* p2,  void (*cb)(struct S_DI, void*, void*)) ;
+EXPORT void f9_V_SPP_DF(struct S_DF p0, void* p1, void* p2,  void (*cb)(struct S_DF, void*, void*)) ;
+EXPORT void f9_V_SPP_DD(struct S_DD p0, void* p1, void* p2,  void (*cb)(struct S_DD, void*, void*)) ;
+EXPORT void f9_V_SPP_DP(struct S_DP p0, void* p1, void* p2,  void (*cb)(struct S_DP, void*, void*)) ;
+EXPORT void f9_V_SPP_PI(struct S_PI p0, void* p1, void* p2,  void (*cb)(struct S_PI, void*, void*)) ;
+EXPORT void f9_V_SPP_PF(struct S_PF p0, void* p1, void* p2,  void (*cb)(struct S_PF, void*, void*)) ;
+EXPORT void f9_V_SPP_PD(struct S_PD p0, void* p1, void* p2,  void (*cb)(struct S_PD, void*, void*)) ;
+EXPORT void f9_V_SPP_PP(struct S_PP p0, void* p1, void* p2,  void (*cb)(struct S_PP, void*, void*)) ;
+EXPORT void f9_V_SPP_III(struct S_III p0, void* p1, void* p2,  void (*cb)(struct S_III, void*, void*)) ;
+EXPORT void f9_V_SPP_IIF(struct S_IIF p0, void* p1, void* p2,  void (*cb)(struct S_IIF, void*, void*)) ;
+EXPORT void f9_V_SPP_IID(struct S_IID p0, void* p1, void* p2,  void (*cb)(struct S_IID, void*, void*)) ;
+EXPORT void f9_V_SPP_IIP(struct S_IIP p0, void* p1, void* p2,  void (*cb)(struct S_IIP, void*, void*)) ;
+EXPORT void f9_V_SPP_IFI(struct S_IFI p0, void* p1, void* p2,  void (*cb)(struct S_IFI, void*, void*)) ;
+EXPORT void f9_V_SPP_IFF(struct S_IFF p0, void* p1, void* p2,  void (*cb)(struct S_IFF, void*, void*)) ;
+EXPORT void f9_V_SPP_IFD(struct S_IFD p0, void* p1, void* p2,  void (*cb)(struct S_IFD, void*, void*)) ;
+EXPORT void f9_V_SPP_IFP(struct S_IFP p0, void* p1, void* p2,  void (*cb)(struct S_IFP, void*, void*)) ;
+EXPORT void f9_V_SPP_IDI(struct S_IDI p0, void* p1, void* p2,  void (*cb)(struct S_IDI, void*, void*)) ;
+EXPORT void f9_V_SPP_IDF(struct S_IDF p0, void* p1, void* p2,  void (*cb)(struct S_IDF, void*, void*)) ;
+EXPORT void f9_V_SPP_IDD(struct S_IDD p0, void* p1, void* p2,  void (*cb)(struct S_IDD, void*, void*)) ;
+EXPORT void f9_V_SPP_IDP(struct S_IDP p0, void* p1, void* p2,  void (*cb)(struct S_IDP, void*, void*)) ;
+EXPORT void f9_V_SPP_IPI(struct S_IPI p0, void* p1, void* p2,  void (*cb)(struct S_IPI, void*, void*)) ;
+EXPORT void f9_V_SPP_IPF(struct S_IPF p0, void* p1, void* p2,  void (*cb)(struct S_IPF, void*, void*)) ;
+EXPORT void f9_V_SPP_IPD(struct S_IPD p0, void* p1, void* p2,  void (*cb)(struct S_IPD, void*, void*)) ;
+EXPORT void f9_V_SPP_IPP(struct S_IPP p0, void* p1, void* p2,  void (*cb)(struct S_IPP, void*, void*)) ;
+EXPORT void f9_V_SPP_FII(struct S_FII p0, void* p1, void* p2,  void (*cb)(struct S_FII, void*, void*)) ;
+EXPORT void f9_V_SPP_FIF(struct S_FIF p0, void* p1, void* p2,  void (*cb)(struct S_FIF, void*, void*)) ;
+EXPORT void f9_V_SPP_FID(struct S_FID p0, void* p1, void* p2,  void (*cb)(struct S_FID, void*, void*)) ;
+EXPORT void f9_V_SPP_FIP(struct S_FIP p0, void* p1, void* p2,  void (*cb)(struct S_FIP, void*, void*)) ;
+EXPORT void f9_V_SPP_FFI(struct S_FFI p0, void* p1, void* p2,  void (*cb)(struct S_FFI, void*, void*)) ;
+EXPORT void f9_V_SPP_FFF(struct S_FFF p0, void* p1, void* p2,  void (*cb)(struct S_FFF, void*, void*)) ;
+EXPORT void f9_V_SPP_FFD(struct S_FFD p0, void* p1, void* p2,  void (*cb)(struct S_FFD, void*, void*)) ;
+EXPORT void f9_V_SPP_FFP(struct S_FFP p0, void* p1, void* p2,  void (*cb)(struct S_FFP, void*, void*)) ;
+EXPORT void f9_V_SPP_FDI(struct S_FDI p0, void* p1, void* p2,  void (*cb)(struct S_FDI, void*, void*)) ;
+EXPORT void f9_V_SPP_FDF(struct S_FDF p0, void* p1, void* p2,  void (*cb)(struct S_FDF, void*, void*)) ;
+EXPORT void f9_V_SPP_FDD(struct S_FDD p0, void* p1, void* p2,  void (*cb)(struct S_FDD, void*, void*)) ;
+EXPORT void f9_V_SPP_FDP(struct S_FDP p0, void* p1, void* p2,  void (*cb)(struct S_FDP, void*, void*)) ;
+EXPORT void f9_V_SPP_FPI(struct S_FPI p0, void* p1, void* p2,  void (*cb)(struct S_FPI, void*, void*)) ;
+EXPORT void f9_V_SPP_FPF(struct S_FPF p0, void* p1, void* p2,  void (*cb)(struct S_FPF, void*, void*)) ;
+EXPORT void f9_V_SPP_FPD(struct S_FPD p0, void* p1, void* p2,  void (*cb)(struct S_FPD, void*, void*)) ;
+EXPORT void f9_V_SPP_FPP(struct S_FPP p0, void* p1, void* p2,  void (*cb)(struct S_FPP, void*, void*)) ;
+EXPORT void f9_V_SPP_DII(struct S_DII p0, void* p1, void* p2,  void (*cb)(struct S_DII, void*, void*)) ;
+EXPORT void f9_V_SPP_DIF(struct S_DIF p0, void* p1, void* p2,  void (*cb)(struct S_DIF, void*, void*)) ;
+EXPORT void f9_V_SPP_DID(struct S_DID p0, void* p1, void* p2,  void (*cb)(struct S_DID, void*, void*)) ;
+EXPORT void f9_V_SPP_DIP(struct S_DIP p0, void* p1, void* p2,  void (*cb)(struct S_DIP, void*, void*)) ;
+EXPORT void f9_V_SPP_DFI(struct S_DFI p0, void* p1, void* p2,  void (*cb)(struct S_DFI, void*, void*)) ;
+EXPORT void f9_V_SPP_DFF(struct S_DFF p0, void* p1, void* p2,  void (*cb)(struct S_DFF, void*, void*)) ;
+EXPORT void f9_V_SPP_DFD(struct S_DFD p0, void* p1, void* p2,  void (*cb)(struct S_DFD, void*, void*)) ;
+EXPORT void f9_V_SPP_DFP(struct S_DFP p0, void* p1, void* p2,  void (*cb)(struct S_DFP, void*, void*)) ;
+EXPORT void f9_V_SPP_DDI(struct S_DDI p0, void* p1, void* p2,  void (*cb)(struct S_DDI, void*, void*)) ;
+EXPORT void f9_V_SPP_DDF(struct S_DDF p0, void* p1, void* p2,  void (*cb)(struct S_DDF, void*, void*)) ;
+EXPORT void f9_V_SPP_DDD(struct S_DDD p0, void* p1, void* p2,  void (*cb)(struct S_DDD, void*, void*)) ;
+EXPORT void f9_V_SPP_DDP(struct S_DDP p0, void* p1, void* p2,  void (*cb)(struct S_DDP, void*, void*)) ;
+EXPORT void f9_V_SPP_DPI(struct S_DPI p0, void* p1, void* p2,  void (*cb)(struct S_DPI, void*, void*)) ;
+EXPORT void f9_V_SPP_DPF(struct S_DPF p0, void* p1, void* p2,  void (*cb)(struct S_DPF, void*, void*)) ;
+EXPORT void f9_V_SPP_DPD(struct S_DPD p0, void* p1, void* p2,  void (*cb)(struct S_DPD, void*, void*)) ;
+EXPORT void f9_V_SPP_DPP(struct S_DPP p0, void* p1, void* p2,  void (*cb)(struct S_DPP, void*, void*)) ;
+EXPORT void f9_V_SPP_PII(struct S_PII p0, void* p1, void* p2,  void (*cb)(struct S_PII, void*, void*)) ;
+EXPORT void f9_V_SPP_PIF(struct S_PIF p0, void* p1, void* p2,  void (*cb)(struct S_PIF, void*, void*)) ;
+EXPORT void f9_V_SPP_PID(struct S_PID p0, void* p1, void* p2,  void (*cb)(struct S_PID, void*, void*)) ;
+EXPORT void f9_V_SPP_PIP(struct S_PIP p0, void* p1, void* p2,  void (*cb)(struct S_PIP, void*, void*)) ;
+EXPORT void f9_V_SPP_PFI(struct S_PFI p0, void* p1, void* p2,  void (*cb)(struct S_PFI, void*, void*)) ;
+EXPORT void f9_V_SPP_PFF(struct S_PFF p0, void* p1, void* p2,  void (*cb)(struct S_PFF, void*, void*)) ;
+EXPORT void f9_V_SPP_PFD(struct S_PFD p0, void* p1, void* p2,  void (*cb)(struct S_PFD, void*, void*)) ;
+EXPORT void f9_V_SPP_PFP(struct S_PFP p0, void* p1, void* p2,  void (*cb)(struct S_PFP, void*, void*)) ;
+EXPORT void f9_V_SPP_PDI(struct S_PDI p0, void* p1, void* p2,  void (*cb)(struct S_PDI, void*, void*)) ;
+EXPORT void f9_V_SPP_PDF(struct S_PDF p0, void* p1, void* p2,  void (*cb)(struct S_PDF, void*, void*)) ;
+EXPORT void f9_V_SPP_PDD(struct S_PDD p0, void* p1, void* p2,  void (*cb)(struct S_PDD, void*, void*)) ;
+EXPORT void f9_V_SPP_PDP(struct S_PDP p0, void* p1, void* p2,  void (*cb)(struct S_PDP, void*, void*)) ;
+EXPORT void f9_V_SPP_PPI(struct S_PPI p0, void* p1, void* p2,  void (*cb)(struct S_PPI, void*, void*)) ;
+EXPORT void f9_V_SPP_PPF(struct S_PPF p0, void* p1, void* p2,  void (*cb)(struct S_PPF, void*, void*)) ;
+EXPORT void f9_V_SPP_PPD(struct S_PPD p0, void* p1, void* p2,  void (*cb)(struct S_PPD, void*, void*)) ;
+EXPORT void f9_V_SPP_PPP(struct S_PPP p0, void* p1, void* p2,  void (*cb)(struct S_PPP, void*, void*)) ;
+EXPORT void f9_V_SPS_I(struct S_I p0, void* p1, struct S_I p2,  void (*cb)(struct S_I, void*, struct S_I)) ;
+EXPORT void f9_V_SPS_F(struct S_F p0, void* p1, struct S_F p2,  void (*cb)(struct S_F, void*, struct S_F)) ;
+EXPORT void f9_V_SPS_D(struct S_D p0, void* p1, struct S_D p2,  void (*cb)(struct S_D, void*, struct S_D)) ;
+EXPORT void f9_V_SPS_P(struct S_P p0, void* p1, struct S_P p2,  void (*cb)(struct S_P, void*, struct S_P)) ;
+EXPORT void f9_V_SPS_II(struct S_II p0, void* p1, struct S_II p2,  void (*cb)(struct S_II, void*, struct S_II)) ;
+EXPORT void f9_V_SPS_IF(struct S_IF p0, void* p1, struct S_IF p2,  void (*cb)(struct S_IF, void*, struct S_IF)) ;
+EXPORT void f9_V_SPS_ID(struct S_ID p0, void* p1, struct S_ID p2,  void (*cb)(struct S_ID, void*, struct S_ID)) ;
+EXPORT void f9_V_SPS_IP(struct S_IP p0, void* p1, struct S_IP p2,  void (*cb)(struct S_IP, void*, struct S_IP)) ;
+EXPORT void f9_V_SPS_FI(struct S_FI p0, void* p1, struct S_FI p2,  void (*cb)(struct S_FI, void*, struct S_FI)) ;
+EXPORT void f9_V_SPS_FF(struct S_FF p0, void* p1, struct S_FF p2,  void (*cb)(struct S_FF, void*, struct S_FF)) ;
+EXPORT void f9_V_SPS_FD(struct S_FD p0, void* p1, struct S_FD p2,  void (*cb)(struct S_FD, void*, struct S_FD)) ;
+EXPORT void f9_V_SPS_FP(struct S_FP p0, void* p1, struct S_FP p2,  void (*cb)(struct S_FP, void*, struct S_FP)) ;
+EXPORT void f9_V_SPS_DI(struct S_DI p0, void* p1, struct S_DI p2,  void (*cb)(struct S_DI, void*, struct S_DI)) ;
+EXPORT void f9_V_SPS_DF(struct S_DF p0, void* p1, struct S_DF p2,  void (*cb)(struct S_DF, void*, struct S_DF)) ;
+EXPORT void f9_V_SPS_DD(struct S_DD p0, void* p1, struct S_DD p2,  void (*cb)(struct S_DD, void*, struct S_DD)) ;
+EXPORT void f9_V_SPS_DP(struct S_DP p0, void* p1, struct S_DP p2,  void (*cb)(struct S_DP, void*, struct S_DP)) ;
+EXPORT void f9_V_SPS_PI(struct S_PI p0, void* p1, struct S_PI p2,  void (*cb)(struct S_PI, void*, struct S_PI)) ;
+EXPORT void f9_V_SPS_PF(struct S_PF p0, void* p1, struct S_PF p2,  void (*cb)(struct S_PF, void*, struct S_PF)) ;
+EXPORT void f9_V_SPS_PD(struct S_PD p0, void* p1, struct S_PD p2,  void (*cb)(struct S_PD, void*, struct S_PD)) ;
+EXPORT void f9_V_SPS_PP(struct S_PP p0, void* p1, struct S_PP p2,  void (*cb)(struct S_PP, void*, struct S_PP)) ;
+EXPORT void f9_V_SPS_III(struct S_III p0, void* p1, struct S_III p2,  void (*cb)(struct S_III, void*, struct S_III)) ;
+EXPORT void f9_V_SPS_IIF(struct S_IIF p0, void* p1, struct S_IIF p2,  void (*cb)(struct S_IIF, void*, struct S_IIF)) ;
+EXPORT void f9_V_SPS_IID(struct S_IID p0, void* p1, struct S_IID p2,  void (*cb)(struct S_IID, void*, struct S_IID)) ;
+EXPORT void f9_V_SPS_IIP(struct S_IIP p0, void* p1, struct S_IIP p2,  void (*cb)(struct S_IIP, void*, struct S_IIP)) ;
+EXPORT void f9_V_SPS_IFI(struct S_IFI p0, void* p1, struct S_IFI p2,  void (*cb)(struct S_IFI, void*, struct S_IFI)) ;
+EXPORT void f9_V_SPS_IFF(struct S_IFF p0, void* p1, struct S_IFF p2,  void (*cb)(struct S_IFF, void*, struct S_IFF)) ;
+EXPORT void f9_V_SPS_IFD(struct S_IFD p0, void* p1, struct S_IFD p2,  void (*cb)(struct S_IFD, void*, struct S_IFD)) ;
+EXPORT void f9_V_SPS_IFP(struct S_IFP p0, void* p1, struct S_IFP p2,  void (*cb)(struct S_IFP, void*, struct S_IFP)) ;
+EXPORT void f9_V_SPS_IDI(struct S_IDI p0, void* p1, struct S_IDI p2,  void (*cb)(struct S_IDI, void*, struct S_IDI)) ;
+EXPORT void f9_V_SPS_IDF(struct S_IDF p0, void* p1, struct S_IDF p2,  void (*cb)(struct S_IDF, void*, struct S_IDF)) ;
+EXPORT void f9_V_SPS_IDD(struct S_IDD p0, void* p1, struct S_IDD p2,  void (*cb)(struct S_IDD, void*, struct S_IDD)) ;
+EXPORT void f9_V_SPS_IDP(struct S_IDP p0, void* p1, struct S_IDP p2,  void (*cb)(struct S_IDP, void*, struct S_IDP)) ;
+EXPORT void f9_V_SPS_IPI(struct S_IPI p0, void* p1, struct S_IPI p2,  void (*cb)(struct S_IPI, void*, struct S_IPI)) ;
+EXPORT void f9_V_SPS_IPF(struct S_IPF p0, void* p1, struct S_IPF p2,  void (*cb)(struct S_IPF, void*, struct S_IPF)) ;
+EXPORT void f9_V_SPS_IPD(struct S_IPD p0, void* p1, struct S_IPD p2,  void (*cb)(struct S_IPD, void*, struct S_IPD)) ;
+EXPORT void f9_V_SPS_IPP(struct S_IPP p0, void* p1, struct S_IPP p2,  void (*cb)(struct S_IPP, void*, struct S_IPP)) ;
+EXPORT void f9_V_SPS_FII(struct S_FII p0, void* p1, struct S_FII p2,  void (*cb)(struct S_FII, void*, struct S_FII)) ;
+EXPORT void f9_V_SPS_FIF(struct S_FIF p0, void* p1, struct S_FIF p2,  void (*cb)(struct S_FIF, void*, struct S_FIF)) ;
+EXPORT void f9_V_SPS_FID(struct S_FID p0, void* p1, struct S_FID p2,  void (*cb)(struct S_FID, void*, struct S_FID)) ;
+EXPORT void f9_V_SPS_FIP(struct S_FIP p0, void* p1, struct S_FIP p2,  void (*cb)(struct S_FIP, void*, struct S_FIP)) ;
+EXPORT void f9_V_SPS_FFI(struct S_FFI p0, void* p1, struct S_FFI p2,  void (*cb)(struct S_FFI, void*, struct S_FFI)) ;
+EXPORT void f9_V_SPS_FFF(struct S_FFF p0, void* p1, struct S_FFF p2,  void (*cb)(struct S_FFF, void*, struct S_FFF)) ;
+EXPORT void f9_V_SPS_FFD(struct S_FFD p0, void* p1, struct S_FFD p2,  void (*cb)(struct S_FFD, void*, struct S_FFD)) ;
+EXPORT void f9_V_SPS_FFP(struct S_FFP p0, void* p1, struct S_FFP p2,  void (*cb)(struct S_FFP, void*, struct S_FFP)) ;
+EXPORT void f9_V_SPS_FDI(struct S_FDI p0, void* p1, struct S_FDI p2,  void (*cb)(struct S_FDI, void*, struct S_FDI)) ;
+EXPORT void f9_V_SPS_FDF(struct S_FDF p0, void* p1, struct S_FDF p2,  void (*cb)(struct S_FDF, void*, struct S_FDF)) ;
+EXPORT void f9_V_SPS_FDD(struct S_FDD p0, void* p1, struct S_FDD p2,  void (*cb)(struct S_FDD, void*, struct S_FDD)) ;
+EXPORT void f9_V_SPS_FDP(struct S_FDP p0, void* p1, struct S_FDP p2,  void (*cb)(struct S_FDP, void*, struct S_FDP)) ;
+EXPORT void f9_V_SPS_FPI(struct S_FPI p0, void* p1, struct S_FPI p2,  void (*cb)(struct S_FPI, void*, struct S_FPI)) ;
+EXPORT void f9_V_SPS_FPF(struct S_FPF p0, void* p1, struct S_FPF p2,  void (*cb)(struct S_FPF, void*, struct S_FPF)) ;
+EXPORT void f9_V_SPS_FPD(struct S_FPD p0, void* p1, struct S_FPD p2,  void (*cb)(struct S_FPD, void*, struct S_FPD)) ;
+EXPORT void f9_V_SPS_FPP(struct S_FPP p0, void* p1, struct S_FPP p2,  void (*cb)(struct S_FPP, void*, struct S_FPP)) ;
+EXPORT void f9_V_SPS_DII(struct S_DII p0, void* p1, struct S_DII p2,  void (*cb)(struct S_DII, void*, struct S_DII)) ;
+EXPORT void f9_V_SPS_DIF(struct S_DIF p0, void* p1, struct S_DIF p2,  void (*cb)(struct S_DIF, void*, struct S_DIF)) ;
+EXPORT void f9_V_SPS_DID(struct S_DID p0, void* p1, struct S_DID p2,  void (*cb)(struct S_DID, void*, struct S_DID)) ;
+EXPORT void f9_V_SPS_DIP(struct S_DIP p0, void* p1, struct S_DIP p2,  void (*cb)(struct S_DIP, void*, struct S_DIP)) ;
+EXPORT void f9_V_SPS_DFI(struct S_DFI p0, void* p1, struct S_DFI p2,  void (*cb)(struct S_DFI, void*, struct S_DFI)) ;
+EXPORT void f9_V_SPS_DFF(struct S_DFF p0, void* p1, struct S_DFF p2,  void (*cb)(struct S_DFF, void*, struct S_DFF)) ;
+EXPORT void f9_V_SPS_DFD(struct S_DFD p0, void* p1, struct S_DFD p2,  void (*cb)(struct S_DFD, void*, struct S_DFD)) ;
+EXPORT void f9_V_SPS_DFP(struct S_DFP p0, void* p1, struct S_DFP p2,  void (*cb)(struct S_DFP, void*, struct S_DFP)) ;
+EXPORT void f9_V_SPS_DDI(struct S_DDI p0, void* p1, struct S_DDI p2,  void (*cb)(struct S_DDI, void*, struct S_DDI)) ;
+EXPORT void f9_V_SPS_DDF(struct S_DDF p0, void* p1, struct S_DDF p2,  void (*cb)(struct S_DDF, void*, struct S_DDF)) ;
+EXPORT void f9_V_SPS_DDD(struct S_DDD p0, void* p1, struct S_DDD p2,  void (*cb)(struct S_DDD, void*, struct S_DDD)) ;
+EXPORT void f9_V_SPS_DDP(struct S_DDP p0, void* p1, struct S_DDP p2,  void (*cb)(struct S_DDP, void*, struct S_DDP)) ;
+EXPORT void f9_V_SPS_DPI(struct S_DPI p0, void* p1, struct S_DPI p2,  void (*cb)(struct S_DPI, void*, struct S_DPI)) ;
+EXPORT void f9_V_SPS_DPF(struct S_DPF p0, void* p1, struct S_DPF p2,  void (*cb)(struct S_DPF, void*, struct S_DPF)) ;
+EXPORT void f9_V_SPS_DPD(struct S_DPD p0, void* p1, struct S_DPD p2,  void (*cb)(struct S_DPD, void*, struct S_DPD)) ;
+EXPORT void f9_V_SPS_DPP(struct S_DPP p0, void* p1, struct S_DPP p2,  void (*cb)(struct S_DPP, void*, struct S_DPP)) ;
+EXPORT void f9_V_SPS_PII(struct S_PII p0, void* p1, struct S_PII p2,  void (*cb)(struct S_PII, void*, struct S_PII)) ;
+EXPORT void f9_V_SPS_PIF(struct S_PIF p0, void* p1, struct S_PIF p2,  void (*cb)(struct S_PIF, void*, struct S_PIF)) ;
+EXPORT void f9_V_SPS_PID(struct S_PID p0, void* p1, struct S_PID p2,  void (*cb)(struct S_PID, void*, struct S_PID)) ;
+EXPORT void f9_V_SPS_PIP(struct S_PIP p0, void* p1, struct S_PIP p2,  void (*cb)(struct S_PIP, void*, struct S_PIP)) ;
+EXPORT void f9_V_SPS_PFI(struct S_PFI p0, void* p1, struct S_PFI p2,  void (*cb)(struct S_PFI, void*, struct S_PFI)) ;
+EXPORT void f9_V_SPS_PFF(struct S_PFF p0, void* p1, struct S_PFF p2,  void (*cb)(struct S_PFF, void*, struct S_PFF)) ;
+EXPORT void f9_V_SPS_PFD(struct S_PFD p0, void* p1, struct S_PFD p2,  void (*cb)(struct S_PFD, void*, struct S_PFD)) ;
+EXPORT void f9_V_SPS_PFP(struct S_PFP p0, void* p1, struct S_PFP p2,  void (*cb)(struct S_PFP, void*, struct S_PFP)) ;
+EXPORT void f9_V_SPS_PDI(struct S_PDI p0, void* p1, struct S_PDI p2,  void (*cb)(struct S_PDI, void*, struct S_PDI)) ;
+EXPORT void f9_V_SPS_PDF(struct S_PDF p0, void* p1, struct S_PDF p2,  void (*cb)(struct S_PDF, void*, struct S_PDF)) ;
+EXPORT void f9_V_SPS_PDD(struct S_PDD p0, void* p1, struct S_PDD p2,  void (*cb)(struct S_PDD, void*, struct S_PDD)) ;
+EXPORT void f9_V_SPS_PDP(struct S_PDP p0, void* p1, struct S_PDP p2,  void (*cb)(struct S_PDP, void*, struct S_PDP)) ;
+EXPORT void f9_V_SPS_PPI(struct S_PPI p0, void* p1, struct S_PPI p2,  void (*cb)(struct S_PPI, void*, struct S_PPI)) ;
+EXPORT void f9_V_SPS_PPF(struct S_PPF p0, void* p1, struct S_PPF p2,  void (*cb)(struct S_PPF, void*, struct S_PPF)) ;
+EXPORT void f9_V_SPS_PPD(struct S_PPD p0, void* p1, struct S_PPD p2,  void (*cb)(struct S_PPD, void*, struct S_PPD)) ;
+EXPORT void f9_V_SPS_PPP(struct S_PPP p0, void* p1, struct S_PPP p2,  void (*cb)(struct S_PPP, void*, struct S_PPP)) ;
+EXPORT void f9_V_SSI_I(struct S_I p0, struct S_I p1, int p2,  void (*cb)(struct S_I, struct S_I, int)) ;
+EXPORT void f9_V_SSI_F(struct S_F p0, struct S_F p1, int p2,  void (*cb)(struct S_F, struct S_F, int)) ;
+EXPORT void f9_V_SSI_D(struct S_D p0, struct S_D p1, int p2,  void (*cb)(struct S_D, struct S_D, int)) ;
+EXPORT void f9_V_SSI_P(struct S_P p0, struct S_P p1, int p2,  void (*cb)(struct S_P, struct S_P, int)) ;
+EXPORT void f9_V_SSI_II(struct S_II p0, struct S_II p1, int p2,  void (*cb)(struct S_II, struct S_II, int)) ;
+EXPORT void f9_V_SSI_IF(struct S_IF p0, struct S_IF p1, int p2,  void (*cb)(struct S_IF, struct S_IF, int)) ;
+EXPORT void f9_V_SSI_ID(struct S_ID p0, struct S_ID p1, int p2,  void (*cb)(struct S_ID, struct S_ID, int)) ;
+EXPORT void f9_V_SSI_IP(struct S_IP p0, struct S_IP p1, int p2,  void (*cb)(struct S_IP, struct S_IP, int)) ;
+EXPORT void f9_V_SSI_FI(struct S_FI p0, struct S_FI p1, int p2,  void (*cb)(struct S_FI, struct S_FI, int)) ;
+EXPORT void f9_V_SSI_FF(struct S_FF p0, struct S_FF p1, int p2,  void (*cb)(struct S_FF, struct S_FF, int)) ;
+EXPORT void f9_V_SSI_FD(struct S_FD p0, struct S_FD p1, int p2,  void (*cb)(struct S_FD, struct S_FD, int)) ;
+EXPORT void f9_V_SSI_FP(struct S_FP p0, struct S_FP p1, int p2,  void (*cb)(struct S_FP, struct S_FP, int)) ;
+EXPORT void f9_V_SSI_DI(struct S_DI p0, struct S_DI p1, int p2,  void (*cb)(struct S_DI, struct S_DI, int)) ;
+EXPORT void f9_V_SSI_DF(struct S_DF p0, struct S_DF p1, int p2,  void (*cb)(struct S_DF, struct S_DF, int)) ;
+EXPORT void f9_V_SSI_DD(struct S_DD p0, struct S_DD p1, int p2,  void (*cb)(struct S_DD, struct S_DD, int)) ;
+EXPORT void f9_V_SSI_DP(struct S_DP p0, struct S_DP p1, int p2,  void (*cb)(struct S_DP, struct S_DP, int)) ;
+EXPORT void f9_V_SSI_PI(struct S_PI p0, struct S_PI p1, int p2,  void (*cb)(struct S_PI, struct S_PI, int)) ;
+EXPORT void f9_V_SSI_PF(struct S_PF p0, struct S_PF p1, int p2,  void (*cb)(struct S_PF, struct S_PF, int)) ;
+EXPORT void f9_V_SSI_PD(struct S_PD p0, struct S_PD p1, int p2,  void (*cb)(struct S_PD, struct S_PD, int)) ;
+EXPORT void f9_V_SSI_PP(struct S_PP p0, struct S_PP p1, int p2,  void (*cb)(struct S_PP, struct S_PP, int)) ;
+EXPORT void f9_V_SSI_III(struct S_III p0, struct S_III p1, int p2,  void (*cb)(struct S_III, struct S_III, int)) ;
+EXPORT void f9_V_SSI_IIF(struct S_IIF p0, struct S_IIF p1, int p2,  void (*cb)(struct S_IIF, struct S_IIF, int)) ;
+EXPORT void f9_V_SSI_IID(struct S_IID p0, struct S_IID p1, int p2,  void (*cb)(struct S_IID, struct S_IID, int)) ;
+EXPORT void f9_V_SSI_IIP(struct S_IIP p0, struct S_IIP p1, int p2,  void (*cb)(struct S_IIP, struct S_IIP, int)) ;
+EXPORT void f9_V_SSI_IFI(struct S_IFI p0, struct S_IFI p1, int p2,  void (*cb)(struct S_IFI, struct S_IFI, int)) ;
+EXPORT void f9_V_SSI_IFF(struct S_IFF p0, struct S_IFF p1, int p2,  void (*cb)(struct S_IFF, struct S_IFF, int)) ;
+EXPORT void f9_V_SSI_IFD(struct S_IFD p0, struct S_IFD p1, int p2,  void (*cb)(struct S_IFD, struct S_IFD, int)) ;
+EXPORT void f9_V_SSI_IFP(struct S_IFP p0, struct S_IFP p1, int p2,  void (*cb)(struct S_IFP, struct S_IFP, int)) ;
+EXPORT void f9_V_SSI_IDI(struct S_IDI p0, struct S_IDI p1, int p2,  void (*cb)(struct S_IDI, struct S_IDI, int)) ;
+EXPORT void f9_V_SSI_IDF(struct S_IDF p0, struct S_IDF p1, int p2,  void (*cb)(struct S_IDF, struct S_IDF, int)) ;
+EXPORT void f9_V_SSI_IDD(struct S_IDD p0, struct S_IDD p1, int p2,  void (*cb)(struct S_IDD, struct S_IDD, int)) ;
+EXPORT void f9_V_SSI_IDP(struct S_IDP p0, struct S_IDP p1, int p2,  void (*cb)(struct S_IDP, struct S_IDP, int)) ;
+EXPORT void f9_V_SSI_IPI(struct S_IPI p0, struct S_IPI p1, int p2,  void (*cb)(struct S_IPI, struct S_IPI, int)) ;
+EXPORT void f9_V_SSI_IPF(struct S_IPF p0, struct S_IPF p1, int p2,  void (*cb)(struct S_IPF, struct S_IPF, int)) ;
+EXPORT void f9_V_SSI_IPD(struct S_IPD p0, struct S_IPD p1, int p2,  void (*cb)(struct S_IPD, struct S_IPD, int)) ;
+EXPORT void f9_V_SSI_IPP(struct S_IPP p0, struct S_IPP p1, int p2,  void (*cb)(struct S_IPP, struct S_IPP, int)) ;
+EXPORT void f9_V_SSI_FII(struct S_FII p0, struct S_FII p1, int p2,  void (*cb)(struct S_FII, struct S_FII, int)) ;
+EXPORT void f9_V_SSI_FIF(struct S_FIF p0, struct S_FIF p1, int p2,  void (*cb)(struct S_FIF, struct S_FIF, int)) ;
+EXPORT void f9_V_SSI_FID(struct S_FID p0, struct S_FID p1, int p2,  void (*cb)(struct S_FID, struct S_FID, int)) ;
+EXPORT void f9_V_SSI_FIP(struct S_FIP p0, struct S_FIP p1, int p2,  void (*cb)(struct S_FIP, struct S_FIP, int)) ;
+EXPORT void f9_V_SSI_FFI(struct S_FFI p0, struct S_FFI p1, int p2,  void (*cb)(struct S_FFI, struct S_FFI, int)) ;
+EXPORT void f9_V_SSI_FFF(struct S_FFF p0, struct S_FFF p1, int p2,  void (*cb)(struct S_FFF, struct S_FFF, int)) ;
+EXPORT void f9_V_SSI_FFD(struct S_FFD p0, struct S_FFD p1, int p2,  void (*cb)(struct S_FFD, struct S_FFD, int)) ;
+EXPORT void f9_V_SSI_FFP(struct S_FFP p0, struct S_FFP p1, int p2,  void (*cb)(struct S_FFP, struct S_FFP, int)) ;
+EXPORT void f9_V_SSI_FDI(struct S_FDI p0, struct S_FDI p1, int p2,  void (*cb)(struct S_FDI, struct S_FDI, int)) ;
+EXPORT void f9_V_SSI_FDF(struct S_FDF p0, struct S_FDF p1, int p2,  void (*cb)(struct S_FDF, struct S_FDF, int)) ;
+EXPORT void f9_V_SSI_FDD(struct S_FDD p0, struct S_FDD p1, int p2,  void (*cb)(struct S_FDD, struct S_FDD, int)) ;
+EXPORT void f9_V_SSI_FDP(struct S_FDP p0, struct S_FDP p1, int p2,  void (*cb)(struct S_FDP, struct S_FDP, int)) ;
+EXPORT void f9_V_SSI_FPI(struct S_FPI p0, struct S_FPI p1, int p2,  void (*cb)(struct S_FPI, struct S_FPI, int)) ;
+EXPORT void f9_V_SSI_FPF(struct S_FPF p0, struct S_FPF p1, int p2,  void (*cb)(struct S_FPF, struct S_FPF, int)) ;
+EXPORT void f9_V_SSI_FPD(struct S_FPD p0, struct S_FPD p1, int p2,  void (*cb)(struct S_FPD, struct S_FPD, int)) ;
+EXPORT void f9_V_SSI_FPP(struct S_FPP p0, struct S_FPP p1, int p2,  void (*cb)(struct S_FPP, struct S_FPP, int)) ;
+EXPORT void f9_V_SSI_DII(struct S_DII p0, struct S_DII p1, int p2,  void (*cb)(struct S_DII, struct S_DII, int)) ;
+EXPORT void f9_V_SSI_DIF(struct S_DIF p0, struct S_DIF p1, int p2,  void (*cb)(struct S_DIF, struct S_DIF, int)) ;
+EXPORT void f9_V_SSI_DID(struct S_DID p0, struct S_DID p1, int p2,  void (*cb)(struct S_DID, struct S_DID, int)) ;
+EXPORT void f9_V_SSI_DIP(struct S_DIP p0, struct S_DIP p1, int p2,  void (*cb)(struct S_DIP, struct S_DIP, int)) ;
+EXPORT void f9_V_SSI_DFI(struct S_DFI p0, struct S_DFI p1, int p2,  void (*cb)(struct S_DFI, struct S_DFI, int)) ;
+EXPORT void f9_V_SSI_DFF(struct S_DFF p0, struct S_DFF p1, int p2,  void (*cb)(struct S_DFF, struct S_DFF, int)) ;
+EXPORT void f9_V_SSI_DFD(struct S_DFD p0, struct S_DFD p1, int p2,  void (*cb)(struct S_DFD, struct S_DFD, int)) ;
+EXPORT void f9_V_SSI_DFP(struct S_DFP p0, struct S_DFP p1, int p2,  void (*cb)(struct S_DFP, struct S_DFP, int)) ;
+EXPORT void f9_V_SSI_DDI(struct S_DDI p0, struct S_DDI p1, int p2,  void (*cb)(struct S_DDI, struct S_DDI, int)) ;
+EXPORT void f9_V_SSI_DDF(struct S_DDF p0, struct S_DDF p1, int p2,  void (*cb)(struct S_DDF, struct S_DDF, int)) ;
+EXPORT void f9_V_SSI_DDD(struct S_DDD p0, struct S_DDD p1, int p2,  void (*cb)(struct S_DDD, struct S_DDD, int)) ;
+EXPORT void f9_V_SSI_DDP(struct S_DDP p0, struct S_DDP p1, int p2,  void (*cb)(struct S_DDP, struct S_DDP, int)) ;
+EXPORT void f9_V_SSI_DPI(struct S_DPI p0, struct S_DPI p1, int p2,  void (*cb)(struct S_DPI, struct S_DPI, int)) ;
+EXPORT void f9_V_SSI_DPF(struct S_DPF p0, struct S_DPF p1, int p2,  void (*cb)(struct S_DPF, struct S_DPF, int)) ;
+EXPORT void f9_V_SSI_DPD(struct S_DPD p0, struct S_DPD p1, int p2,  void (*cb)(struct S_DPD, struct S_DPD, int)) ;
+EXPORT void f9_V_SSI_DPP(struct S_DPP p0, struct S_DPP p1, int p2,  void (*cb)(struct S_DPP, struct S_DPP, int)) ;
+EXPORT void f9_V_SSI_PII(struct S_PII p0, struct S_PII p1, int p2,  void (*cb)(struct S_PII, struct S_PII, int)) ;
+EXPORT void f9_V_SSI_PIF(struct S_PIF p0, struct S_PIF p1, int p2,  void (*cb)(struct S_PIF, struct S_PIF, int)) ;
+EXPORT void f9_V_SSI_PID(struct S_PID p0, struct S_PID p1, int p2,  void (*cb)(struct S_PID, struct S_PID, int)) ;
+EXPORT void f9_V_SSI_PIP(struct S_PIP p0, struct S_PIP p1, int p2,  void (*cb)(struct S_PIP, struct S_PIP, int)) ;
+EXPORT void f9_V_SSI_PFI(struct S_PFI p0, struct S_PFI p1, int p2,  void (*cb)(struct S_PFI, struct S_PFI, int)) ;
+EXPORT void f9_V_SSI_PFF(struct S_PFF p0, struct S_PFF p1, int p2,  void (*cb)(struct S_PFF, struct S_PFF, int)) ;
+EXPORT void f9_V_SSI_PFD(struct S_PFD p0, struct S_PFD p1, int p2,  void (*cb)(struct S_PFD, struct S_PFD, int)) ;
+EXPORT void f9_V_SSI_PFP(struct S_PFP p0, struct S_PFP p1, int p2,  void (*cb)(struct S_PFP, struct S_PFP, int)) ;
+EXPORT void f9_V_SSI_PDI(struct S_PDI p0, struct S_PDI p1, int p2,  void (*cb)(struct S_PDI, struct S_PDI, int)) ;
+EXPORT void f9_V_SSI_PDF(struct S_PDF p0, struct S_PDF p1, int p2,  void (*cb)(struct S_PDF, struct S_PDF, int)) ;
+EXPORT void f9_V_SSI_PDD(struct S_PDD p0, struct S_PDD p1, int p2,  void (*cb)(struct S_PDD, struct S_PDD, int)) ;
+EXPORT void f9_V_SSI_PDP(struct S_PDP p0, struct S_PDP p1, int p2,  void (*cb)(struct S_PDP, struct S_PDP, int)) ;
+EXPORT void f9_V_SSI_PPI(struct S_PPI p0, struct S_PPI p1, int p2,  void (*cb)(struct S_PPI, struct S_PPI, int)) ;
+EXPORT void f9_V_SSI_PPF(struct S_PPF p0, struct S_PPF p1, int p2,  void (*cb)(struct S_PPF, struct S_PPF, int)) ;
+EXPORT void f9_V_SSI_PPD(struct S_PPD p0, struct S_PPD p1, int p2,  void (*cb)(struct S_PPD, struct S_PPD, int)) ;
+EXPORT void f9_V_SSI_PPP(struct S_PPP p0, struct S_PPP p1, int p2,  void (*cb)(struct S_PPP, struct S_PPP, int)) ;
+EXPORT void f9_V_SSF_I(struct S_I p0, struct S_I p1, float p2,  void (*cb)(struct S_I, struct S_I, float)) ;
+EXPORT void f9_V_SSF_F(struct S_F p0, struct S_F p1, float p2,  void (*cb)(struct S_F, struct S_F, float)) ;
+EXPORT void f9_V_SSF_D(struct S_D p0, struct S_D p1, float p2,  void (*cb)(struct S_D, struct S_D, float)) ;
+EXPORT void f9_V_SSF_P(struct S_P p0, struct S_P p1, float p2,  void (*cb)(struct S_P, struct S_P, float)) ;
+EXPORT void f9_V_SSF_II(struct S_II p0, struct S_II p1, float p2,  void (*cb)(struct S_II, struct S_II, float)) ;
+EXPORT void f9_V_SSF_IF(struct S_IF p0, struct S_IF p1, float p2,  void (*cb)(struct S_IF, struct S_IF, float)) ;
+EXPORT void f9_V_SSF_ID(struct S_ID p0, struct S_ID p1, float p2,  void (*cb)(struct S_ID, struct S_ID, float)) ;
+EXPORT void f9_V_SSF_IP(struct S_IP p0, struct S_IP p1, float p2,  void (*cb)(struct S_IP, struct S_IP, float)) ;
+EXPORT void f9_V_SSF_FI(struct S_FI p0, struct S_FI p1, float p2,  void (*cb)(struct S_FI, struct S_FI, float)) ;
+EXPORT void f9_V_SSF_FF(struct S_FF p0, struct S_FF p1, float p2,  void (*cb)(struct S_FF, struct S_FF, float)) ;
+EXPORT void f9_V_SSF_FD(struct S_FD p0, struct S_FD p1, float p2,  void (*cb)(struct S_FD, struct S_FD, float)) ;
+EXPORT void f9_V_SSF_FP(struct S_FP p0, struct S_FP p1, float p2,  void (*cb)(struct S_FP, struct S_FP, float)) ;
+EXPORT void f9_V_SSF_DI(struct S_DI p0, struct S_DI p1, float p2,  void (*cb)(struct S_DI, struct S_DI, float)) ;
+EXPORT void f9_V_SSF_DF(struct S_DF p0, struct S_DF p1, float p2,  void (*cb)(struct S_DF, struct S_DF, float)) ;
+EXPORT void f9_V_SSF_DD(struct S_DD p0, struct S_DD p1, float p2,  void (*cb)(struct S_DD, struct S_DD, float)) ;
+EXPORT void f9_V_SSF_DP(struct S_DP p0, struct S_DP p1, float p2,  void (*cb)(struct S_DP, struct S_DP, float)) ;
+EXPORT void f9_V_SSF_PI(struct S_PI p0, struct S_PI p1, float p2,  void (*cb)(struct S_PI, struct S_PI, float)) ;
+EXPORT void f9_V_SSF_PF(struct S_PF p0, struct S_PF p1, float p2,  void (*cb)(struct S_PF, struct S_PF, float)) ;
+EXPORT void f9_V_SSF_PD(struct S_PD p0, struct S_PD p1, float p2,  void (*cb)(struct S_PD, struct S_PD, float)) ;
+EXPORT void f9_V_SSF_PP(struct S_PP p0, struct S_PP p1, float p2,  void (*cb)(struct S_PP, struct S_PP, float)) ;
+EXPORT void f9_V_SSF_III(struct S_III p0, struct S_III p1, float p2,  void (*cb)(struct S_III, struct S_III, float)) ;
+EXPORT void f9_V_SSF_IIF(struct S_IIF p0, struct S_IIF p1, float p2,  void (*cb)(struct S_IIF, struct S_IIF, float)) ;
+EXPORT void f9_V_SSF_IID(struct S_IID p0, struct S_IID p1, float p2,  void (*cb)(struct S_IID, struct S_IID, float)) ;
+EXPORT void f9_V_SSF_IIP(struct S_IIP p0, struct S_IIP p1, float p2,  void (*cb)(struct S_IIP, struct S_IIP, float)) ;
+EXPORT void f9_V_SSF_IFI(struct S_IFI p0, struct S_IFI p1, float p2,  void (*cb)(struct S_IFI, struct S_IFI, float)) ;
+EXPORT void f9_V_SSF_IFF(struct S_IFF p0, struct S_IFF p1, float p2,  void (*cb)(struct S_IFF, struct S_IFF, float)) ;
+EXPORT void f9_V_SSF_IFD(struct S_IFD p0, struct S_IFD p1, float p2,  void (*cb)(struct S_IFD, struct S_IFD, float)) ;
+EXPORT void f9_V_SSF_IFP(struct S_IFP p0, struct S_IFP p1, float p2,  void (*cb)(struct S_IFP, struct S_IFP, float)) ;
+EXPORT void f9_V_SSF_IDI(struct S_IDI p0, struct S_IDI p1, float p2,  void (*cb)(struct S_IDI, struct S_IDI, float)) ;
+EXPORT void f9_V_SSF_IDF(struct S_IDF p0, struct S_IDF p1, float p2,  void (*cb)(struct S_IDF, struct S_IDF, float)) ;
+EXPORT void f9_V_SSF_IDD(struct S_IDD p0, struct S_IDD p1, float p2,  void (*cb)(struct S_IDD, struct S_IDD, float)) ;
+EXPORT void f9_V_SSF_IDP(struct S_IDP p0, struct S_IDP p1, float p2,  void (*cb)(struct S_IDP, struct S_IDP, float)) ;
+EXPORT void f9_V_SSF_IPI(struct S_IPI p0, struct S_IPI p1, float p2,  void (*cb)(struct S_IPI, struct S_IPI, float)) ;
+EXPORT void f9_V_SSF_IPF(struct S_IPF p0, struct S_IPF p1, float p2,  void (*cb)(struct S_IPF, struct S_IPF, float)) ;
+EXPORT void f9_V_SSF_IPD(struct S_IPD p0, struct S_IPD p1, float p2,  void (*cb)(struct S_IPD, struct S_IPD, float)) ;
+EXPORT void f9_V_SSF_IPP(struct S_IPP p0, struct S_IPP p1, float p2,  void (*cb)(struct S_IPP, struct S_IPP, float)) ;
+EXPORT void f9_V_SSF_FII(struct S_FII p0, struct S_FII p1, float p2,  void (*cb)(struct S_FII, struct S_FII, float)) ;
+EXPORT void f9_V_SSF_FIF(struct S_FIF p0, struct S_FIF p1, float p2,  void (*cb)(struct S_FIF, struct S_FIF, float)) ;
+EXPORT void f9_V_SSF_FID(struct S_FID p0, struct S_FID p1, float p2,  void (*cb)(struct S_FID, struct S_FID, float)) ;
+EXPORT void f9_V_SSF_FIP(struct S_FIP p0, struct S_FIP p1, float p2,  void (*cb)(struct S_FIP, struct S_FIP, float)) ;
+EXPORT void f9_V_SSF_FFI(struct S_FFI p0, struct S_FFI p1, float p2,  void (*cb)(struct S_FFI, struct S_FFI, float)) ;
+EXPORT void f9_V_SSF_FFF(struct S_FFF p0, struct S_FFF p1, float p2,  void (*cb)(struct S_FFF, struct S_FFF, float)) ;
+EXPORT void f9_V_SSF_FFD(struct S_FFD p0, struct S_FFD p1, float p2,  void (*cb)(struct S_FFD, struct S_FFD, float)) ;
+EXPORT void f9_V_SSF_FFP(struct S_FFP p0, struct S_FFP p1, float p2,  void (*cb)(struct S_FFP, struct S_FFP, float)) ;
+EXPORT void f9_V_SSF_FDI(struct S_FDI p0, struct S_FDI p1, float p2,  void (*cb)(struct S_FDI, struct S_FDI, float)) ;
+EXPORT void f9_V_SSF_FDF(struct S_FDF p0, struct S_FDF p1, float p2,  void (*cb)(struct S_FDF, struct S_FDF, float)) ;
+EXPORT void f9_V_SSF_FDD(struct S_FDD p0, struct S_FDD p1, float p2,  void (*cb)(struct S_FDD, struct S_FDD, float)) ;
+EXPORT void f9_V_SSF_FDP(struct S_FDP p0, struct S_FDP p1, float p2,  void (*cb)(struct S_FDP, struct S_FDP, float)) ;
+EXPORT void f9_V_SSF_FPI(struct S_FPI p0, struct S_FPI p1, float p2,  void (*cb)(struct S_FPI, struct S_FPI, float)) ;
+EXPORT void f9_V_SSF_FPF(struct S_FPF p0, struct S_FPF p1, float p2,  void (*cb)(struct S_FPF, struct S_FPF, float)) ;
+EXPORT void f9_V_SSF_FPD(struct S_FPD p0, struct S_FPD p1, float p2,  void (*cb)(struct S_FPD, struct S_FPD, float)) ;
+EXPORT void f9_V_SSF_FPP(struct S_FPP p0, struct S_FPP p1, float p2,  void (*cb)(struct S_FPP, struct S_FPP, float)) ;
+EXPORT void f9_V_SSF_DII(struct S_DII p0, struct S_DII p1, float p2,  void (*cb)(struct S_DII, struct S_DII, float)) ;
+EXPORT void f9_V_SSF_DIF(struct S_DIF p0, struct S_DIF p1, float p2,  void (*cb)(struct S_DIF, struct S_DIF, float)) ;
+EXPORT void f9_V_SSF_DID(struct S_DID p0, struct S_DID p1, float p2,  void (*cb)(struct S_DID, struct S_DID, float)) ;
+EXPORT void f9_V_SSF_DIP(struct S_DIP p0, struct S_DIP p1, float p2,  void (*cb)(struct S_DIP, struct S_DIP, float)) ;
+EXPORT void f9_V_SSF_DFI(struct S_DFI p0, struct S_DFI p1, float p2,  void (*cb)(struct S_DFI, struct S_DFI, float)) ;
+EXPORT void f9_V_SSF_DFF(struct S_DFF p0, struct S_DFF p1, float p2,  void (*cb)(struct S_DFF, struct S_DFF, float)) ;
+EXPORT void f9_V_SSF_DFD(struct S_DFD p0, struct S_DFD p1, float p2,  void (*cb)(struct S_DFD, struct S_DFD, float)) ;
+EXPORT void f9_V_SSF_DFP(struct S_DFP p0, struct S_DFP p1, float p2,  void (*cb)(struct S_DFP, struct S_DFP, float)) ;
+EXPORT void f9_V_SSF_DDI(struct S_DDI p0, struct S_DDI p1, float p2,  void (*cb)(struct S_DDI, struct S_DDI, float)) ;
+EXPORT void f9_V_SSF_DDF(struct S_DDF p0, struct S_DDF p1, float p2,  void (*cb)(struct S_DDF, struct S_DDF, float)) ;
+EXPORT void f9_V_SSF_DDD(struct S_DDD p0, struct S_DDD p1, float p2,  void (*cb)(struct S_DDD, struct S_DDD, float)) ;
+EXPORT void f9_V_SSF_DDP(struct S_DDP p0, struct S_DDP p1, float p2,  void (*cb)(struct S_DDP, struct S_DDP, float)) ;
+EXPORT void f9_V_SSF_DPI(struct S_DPI p0, struct S_DPI p1, float p2,  void (*cb)(struct S_DPI, struct S_DPI, float)) ;
+EXPORT void f9_V_SSF_DPF(struct S_DPF p0, struct S_DPF p1, float p2,  void (*cb)(struct S_DPF, struct S_DPF, float)) ;
+EXPORT void f9_V_SSF_DPD(struct S_DPD p0, struct S_DPD p1, float p2,  void (*cb)(struct S_DPD, struct S_DPD, float)) ;
+EXPORT void f9_V_SSF_DPP(struct S_DPP p0, struct S_DPP p1, float p2,  void (*cb)(struct S_DPP, struct S_DPP, float)) ;
+EXPORT void f9_V_SSF_PII(struct S_PII p0, struct S_PII p1, float p2,  void (*cb)(struct S_PII, struct S_PII, float)) ;
+EXPORT void f9_V_SSF_PIF(struct S_PIF p0, struct S_PIF p1, float p2,  void (*cb)(struct S_PIF, struct S_PIF, float)) ;
+EXPORT void f9_V_SSF_PID(struct S_PID p0, struct S_PID p1, float p2,  void (*cb)(struct S_PID, struct S_PID, float)) ;
+EXPORT void f9_V_SSF_PIP(struct S_PIP p0, struct S_PIP p1, float p2,  void (*cb)(struct S_PIP, struct S_PIP, float)) ;
+EXPORT void f9_V_SSF_PFI(struct S_PFI p0, struct S_PFI p1, float p2,  void (*cb)(struct S_PFI, struct S_PFI, float)) ;
+EXPORT void f9_V_SSF_PFF(struct S_PFF p0, struct S_PFF p1, float p2,  void (*cb)(struct S_PFF, struct S_PFF, float)) ;
+EXPORT void f9_V_SSF_PFD(struct S_PFD p0, struct S_PFD p1, float p2,  void (*cb)(struct S_PFD, struct S_PFD, float)) ;
+EXPORT void f9_V_SSF_PFP(struct S_PFP p0, struct S_PFP p1, float p2,  void (*cb)(struct S_PFP, struct S_PFP, float)) ;
+EXPORT void f9_V_SSF_PDI(struct S_PDI p0, struct S_PDI p1, float p2,  void (*cb)(struct S_PDI, struct S_PDI, float)) ;
+EXPORT void f9_V_SSF_PDF(struct S_PDF p0, struct S_PDF p1, float p2,  void (*cb)(struct S_PDF, struct S_PDF, float)) ;
+EXPORT void f9_V_SSF_PDD(struct S_PDD p0, struct S_PDD p1, float p2,  void (*cb)(struct S_PDD, struct S_PDD, float)) ;
+EXPORT void f9_V_SSF_PDP(struct S_PDP p0, struct S_PDP p1, float p2,  void (*cb)(struct S_PDP, struct S_PDP, float)) ;
+EXPORT void f9_V_SSF_PPI(struct S_PPI p0, struct S_PPI p1, float p2,  void (*cb)(struct S_PPI, struct S_PPI, float)) ;
+EXPORT void f9_V_SSF_PPF(struct S_PPF p0, struct S_PPF p1, float p2,  void (*cb)(struct S_PPF, struct S_PPF, float)) ;
+EXPORT void f9_V_SSF_PPD(struct S_PPD p0, struct S_PPD p1, float p2,  void (*cb)(struct S_PPD, struct S_PPD, float)) ;
+EXPORT void f9_V_SSF_PPP(struct S_PPP p0, struct S_PPP p1, float p2,  void (*cb)(struct S_PPP, struct S_PPP, float)) ;
+EXPORT void f9_V_SSD_I(struct S_I p0, struct S_I p1, double p2,  void (*cb)(struct S_I, struct S_I, double)) ;
+EXPORT void f9_V_SSD_F(struct S_F p0, struct S_F p1, double p2,  void (*cb)(struct S_F, struct S_F, double)) ;
+EXPORT void f9_V_SSD_D(struct S_D p0, struct S_D p1, double p2,  void (*cb)(struct S_D, struct S_D, double)) ;
+EXPORT void f9_V_SSD_P(struct S_P p0, struct S_P p1, double p2,  void (*cb)(struct S_P, struct S_P, double)) ;
+EXPORT void f9_V_SSD_II(struct S_II p0, struct S_II p1, double p2,  void (*cb)(struct S_II, struct S_II, double)) ;
+EXPORT void f9_V_SSD_IF(struct S_IF p0, struct S_IF p1, double p2,  void (*cb)(struct S_IF, struct S_IF, double)) ;
+EXPORT void f9_V_SSD_ID(struct S_ID p0, struct S_ID p1, double p2,  void (*cb)(struct S_ID, struct S_ID, double)) ;
+EXPORT void f9_V_SSD_IP(struct S_IP p0, struct S_IP p1, double p2,  void (*cb)(struct S_IP, struct S_IP, double)) ;
+EXPORT void f9_V_SSD_FI(struct S_FI p0, struct S_FI p1, double p2,  void (*cb)(struct S_FI, struct S_FI, double)) ;
+EXPORT void f9_V_SSD_FF(struct S_FF p0, struct S_FF p1, double p2,  void (*cb)(struct S_FF, struct S_FF, double)) ;
+EXPORT void f9_V_SSD_FD(struct S_FD p0, struct S_FD p1, double p2,  void (*cb)(struct S_FD, struct S_FD, double)) ;
+EXPORT void f9_V_SSD_FP(struct S_FP p0, struct S_FP p1, double p2,  void (*cb)(struct S_FP, struct S_FP, double)) ;
+EXPORT void f9_V_SSD_DI(struct S_DI p0, struct S_DI p1, double p2,  void (*cb)(struct S_DI, struct S_DI, double)) ;
+EXPORT void f9_V_SSD_DF(struct S_DF p0, struct S_DF p1, double p2,  void (*cb)(struct S_DF, struct S_DF, double)) ;
+EXPORT void f9_V_SSD_DD(struct S_DD p0, struct S_DD p1, double p2,  void (*cb)(struct S_DD, struct S_DD, double)) ;
+EXPORT void f9_V_SSD_DP(struct S_DP p0, struct S_DP p1, double p2,  void (*cb)(struct S_DP, struct S_DP, double)) ;
+EXPORT void f9_V_SSD_PI(struct S_PI p0, struct S_PI p1, double p2,  void (*cb)(struct S_PI, struct S_PI, double)) ;
+EXPORT void f9_V_SSD_PF(struct S_PF p0, struct S_PF p1, double p2,  void (*cb)(struct S_PF, struct S_PF, double)) ;
+EXPORT void f9_V_SSD_PD(struct S_PD p0, struct S_PD p1, double p2,  void (*cb)(struct S_PD, struct S_PD, double)) ;
+EXPORT void f9_V_SSD_PP(struct S_PP p0, struct S_PP p1, double p2,  void (*cb)(struct S_PP, struct S_PP, double)) ;
+EXPORT void f9_V_SSD_III(struct S_III p0, struct S_III p1, double p2,  void (*cb)(struct S_III, struct S_III, double)) ;
+EXPORT void f9_V_SSD_IIF(struct S_IIF p0, struct S_IIF p1, double p2,  void (*cb)(struct S_IIF, struct S_IIF, double)) ;
+EXPORT void f9_V_SSD_IID(struct S_IID p0, struct S_IID p1, double p2,  void (*cb)(struct S_IID, struct S_IID, double)) ;
+EXPORT void f9_V_SSD_IIP(struct S_IIP p0, struct S_IIP p1, double p2,  void (*cb)(struct S_IIP, struct S_IIP, double)) ;
+EXPORT void f9_V_SSD_IFI(struct S_IFI p0, struct S_IFI p1, double p2,  void (*cb)(struct S_IFI, struct S_IFI, double)) ;
+EXPORT void f9_V_SSD_IFF(struct S_IFF p0, struct S_IFF p1, double p2,  void (*cb)(struct S_IFF, struct S_IFF, double)) ;
+EXPORT void f9_V_SSD_IFD(struct S_IFD p0, struct S_IFD p1, double p2,  void (*cb)(struct S_IFD, struct S_IFD, double)) ;
+EXPORT void f9_V_SSD_IFP(struct S_IFP p0, struct S_IFP p1, double p2,  void (*cb)(struct S_IFP, struct S_IFP, double)) ;
+EXPORT void f9_V_SSD_IDI(struct S_IDI p0, struct S_IDI p1, double p2,  void (*cb)(struct S_IDI, struct S_IDI, double)) ;
+EXPORT void f9_V_SSD_IDF(struct S_IDF p0, struct S_IDF p1, double p2,  void (*cb)(struct S_IDF, struct S_IDF, double)) ;
+EXPORT void f9_V_SSD_IDD(struct S_IDD p0, struct S_IDD p1, double p2,  void (*cb)(struct S_IDD, struct S_IDD, double)) ;
+EXPORT void f9_V_SSD_IDP(struct S_IDP p0, struct S_IDP p1, double p2,  void (*cb)(struct S_IDP, struct S_IDP, double)) ;
+EXPORT void f9_V_SSD_IPI(struct S_IPI p0, struct S_IPI p1, double p2,  void (*cb)(struct S_IPI, struct S_IPI, double)) ;
+EXPORT void f9_V_SSD_IPF(struct S_IPF p0, struct S_IPF p1, double p2,  void (*cb)(struct S_IPF, struct S_IPF, double)) ;
+EXPORT void f9_V_SSD_IPD(struct S_IPD p0, struct S_IPD p1, double p2,  void (*cb)(struct S_IPD, struct S_IPD, double)) ;
+EXPORT void f9_V_SSD_IPP(struct S_IPP p0, struct S_IPP p1, double p2,  void (*cb)(struct S_IPP, struct S_IPP, double)) ;
+EXPORT void f9_V_SSD_FII(struct S_FII p0, struct S_FII p1, double p2,  void (*cb)(struct S_FII, struct S_FII, double)) ;
+EXPORT void f9_V_SSD_FIF(struct S_FIF p0, struct S_FIF p1, double p2,  void (*cb)(struct S_FIF, struct S_FIF, double)) ;
+EXPORT void f9_V_SSD_FID(struct S_FID p0, struct S_FID p1, double p2,  void (*cb)(struct S_FID, struct S_FID, double)) ;
+EXPORT void f9_V_SSD_FIP(struct S_FIP p0, struct S_FIP p1, double p2,  void (*cb)(struct S_FIP, struct S_FIP, double)) ;
+EXPORT void f9_V_SSD_FFI(struct S_FFI p0, struct S_FFI p1, double p2,  void (*cb)(struct S_FFI, struct S_FFI, double)) ;
+EXPORT void f9_V_SSD_FFF(struct S_FFF p0, struct S_FFF p1, double p2,  void (*cb)(struct S_FFF, struct S_FFF, double)) ;
+EXPORT void f9_V_SSD_FFD(struct S_FFD p0, struct S_FFD p1, double p2,  void (*cb)(struct S_FFD, struct S_FFD, double)) ;
+EXPORT void f9_V_SSD_FFP(struct S_FFP p0, struct S_FFP p1, double p2,  void (*cb)(struct S_FFP, struct S_FFP, double)) ;
+EXPORT void f9_V_SSD_FDI(struct S_FDI p0, struct S_FDI p1, double p2,  void (*cb)(struct S_FDI, struct S_FDI, double)) ;
+EXPORT void f9_V_SSD_FDF(struct S_FDF p0, struct S_FDF p1, double p2,  void (*cb)(struct S_FDF, struct S_FDF, double)) ;
+EXPORT void f9_V_SSD_FDD(struct S_FDD p0, struct S_FDD p1, double p2,  void (*cb)(struct S_FDD, struct S_FDD, double)) ;
+EXPORT void f9_V_SSD_FDP(struct S_FDP p0, struct S_FDP p1, double p2,  void (*cb)(struct S_FDP, struct S_FDP, double)) ;
+EXPORT void f9_V_SSD_FPI(struct S_FPI p0, struct S_FPI p1, double p2,  void (*cb)(struct S_FPI, struct S_FPI, double)) ;
+EXPORT void f9_V_SSD_FPF(struct S_FPF p0, struct S_FPF p1, double p2,  void (*cb)(struct S_FPF, struct S_FPF, double)) ;
+EXPORT void f9_V_SSD_FPD(struct S_FPD p0, struct S_FPD p1, double p2,  void (*cb)(struct S_FPD, struct S_FPD, double)) ;
+EXPORT void f9_V_SSD_FPP(struct S_FPP p0, struct S_FPP p1, double p2,  void (*cb)(struct S_FPP, struct S_FPP, double)) ;
+EXPORT void f9_V_SSD_DII(struct S_DII p0, struct S_DII p1, double p2,  void (*cb)(struct S_DII, struct S_DII, double)) ;
+EXPORT void f9_V_SSD_DIF(struct S_DIF p0, struct S_DIF p1, double p2,  void (*cb)(struct S_DIF, struct S_DIF, double)) ;
+EXPORT void f9_V_SSD_DID(struct S_DID p0, struct S_DID p1, double p2,  void (*cb)(struct S_DID, struct S_DID, double)) ;
+EXPORT void f9_V_SSD_DIP(struct S_DIP p0, struct S_DIP p1, double p2,  void (*cb)(struct S_DIP, struct S_DIP, double)) ;
+EXPORT void f9_V_SSD_DFI(struct S_DFI p0, struct S_DFI p1, double p2,  void (*cb)(struct S_DFI, struct S_DFI, double)) ;
+EXPORT void f9_V_SSD_DFF(struct S_DFF p0, struct S_DFF p1, double p2,  void (*cb)(struct S_DFF, struct S_DFF, double)) ;
+EXPORT void f9_V_SSD_DFD(struct S_DFD p0, struct S_DFD p1, double p2,  void (*cb)(struct S_DFD, struct S_DFD, double)) ;
+EXPORT void f9_V_SSD_DFP(struct S_DFP p0, struct S_DFP p1, double p2,  void (*cb)(struct S_DFP, struct S_DFP, double)) ;
+EXPORT void f9_V_SSD_DDI(struct S_DDI p0, struct S_DDI p1, double p2,  void (*cb)(struct S_DDI, struct S_DDI, double)) ;
+EXPORT void f9_V_SSD_DDF(struct S_DDF p0, struct S_DDF p1, double p2,  void (*cb)(struct S_DDF, struct S_DDF, double)) ;
+EXPORT void f9_V_SSD_DDD(struct S_DDD p0, struct S_DDD p1, double p2,  void (*cb)(struct S_DDD, struct S_DDD, double)) ;
+EXPORT void f9_V_SSD_DDP(struct S_DDP p0, struct S_DDP p1, double p2,  void (*cb)(struct S_DDP, struct S_DDP, double)) ;
+EXPORT void f9_V_SSD_DPI(struct S_DPI p0, struct S_DPI p1, double p2,  void (*cb)(struct S_DPI, struct S_DPI, double)) ;
+EXPORT void f9_V_SSD_DPF(struct S_DPF p0, struct S_DPF p1, double p2,  void (*cb)(struct S_DPF, struct S_DPF, double)) ;
+EXPORT void f9_V_SSD_DPD(struct S_DPD p0, struct S_DPD p1, double p2,  void (*cb)(struct S_DPD, struct S_DPD, double)) ;
+EXPORT void f9_V_SSD_DPP(struct S_DPP p0, struct S_DPP p1, double p2,  void (*cb)(struct S_DPP, struct S_DPP, double)) ;
+EXPORT void f9_V_SSD_PII(struct S_PII p0, struct S_PII p1, double p2,  void (*cb)(struct S_PII, struct S_PII, double)) ;
+EXPORT void f9_V_SSD_PIF(struct S_PIF p0, struct S_PIF p1, double p2,  void (*cb)(struct S_PIF, struct S_PIF, double)) ;
+EXPORT void f9_V_SSD_PID(struct S_PID p0, struct S_PID p1, double p2,  void (*cb)(struct S_PID, struct S_PID, double)) ;
+EXPORT void f9_V_SSD_PIP(struct S_PIP p0, struct S_PIP p1, double p2,  void (*cb)(struct S_PIP, struct S_PIP, double)) ;
+EXPORT void f9_V_SSD_PFI(struct S_PFI p0, struct S_PFI p1, double p2,  void (*cb)(struct S_PFI, struct S_PFI, double)) ;
+EXPORT void f9_V_SSD_PFF(struct S_PFF p0, struct S_PFF p1, double p2,  void (*cb)(struct S_PFF, struct S_PFF, double)) ;
+EXPORT void f9_V_SSD_PFD(struct S_PFD p0, struct S_PFD p1, double p2,  void (*cb)(struct S_PFD, struct S_PFD, double)) ;
+EXPORT void f9_V_SSD_PFP(struct S_PFP p0, struct S_PFP p1, double p2,  void (*cb)(struct S_PFP, struct S_PFP, double)) ;
+EXPORT void f9_V_SSD_PDI(struct S_PDI p0, struct S_PDI p1, double p2,  void (*cb)(struct S_PDI, struct S_PDI, double)) ;
+EXPORT void f9_V_SSD_PDF(struct S_PDF p0, struct S_PDF p1, double p2,  void (*cb)(struct S_PDF, struct S_PDF, double)) ;
+EXPORT void f9_V_SSD_PDD(struct S_PDD p0, struct S_PDD p1, double p2,  void (*cb)(struct S_PDD, struct S_PDD, double)) ;
+EXPORT void f9_V_SSD_PDP(struct S_PDP p0, struct S_PDP p1, double p2,  void (*cb)(struct S_PDP, struct S_PDP, double)) ;
+EXPORT void f9_V_SSD_PPI(struct S_PPI p0, struct S_PPI p1, double p2,  void (*cb)(struct S_PPI, struct S_PPI, double)) ;
+EXPORT void f9_V_SSD_PPF(struct S_PPF p0, struct S_PPF p1, double p2,  void (*cb)(struct S_PPF, struct S_PPF, double)) ;
+EXPORT void f9_V_SSD_PPD(struct S_PPD p0, struct S_PPD p1, double p2,  void (*cb)(struct S_PPD, struct S_PPD, double)) ;
+EXPORT void f9_V_SSD_PPP(struct S_PPP p0, struct S_PPP p1, double p2,  void (*cb)(struct S_PPP, struct S_PPP, double)) ;
+EXPORT void f9_V_SSP_I(struct S_I p0, struct S_I p1, void* p2,  void (*cb)(struct S_I, struct S_I, void*)) ;
+EXPORT void f9_V_SSP_F(struct S_F p0, struct S_F p1, void* p2,  void (*cb)(struct S_F, struct S_F, void*)) ;
+EXPORT void f9_V_SSP_D(struct S_D p0, struct S_D p1, void* p2,  void (*cb)(struct S_D, struct S_D, void*)) ;
+EXPORT void f9_V_SSP_P(struct S_P p0, struct S_P p1, void* p2,  void (*cb)(struct S_P, struct S_P, void*)) ;
+EXPORT void f9_V_SSP_II(struct S_II p0, struct S_II p1, void* p2,  void (*cb)(struct S_II, struct S_II, void*)) ;
+EXPORT void f9_V_SSP_IF(struct S_IF p0, struct S_IF p1, void* p2,  void (*cb)(struct S_IF, struct S_IF, void*)) ;
+EXPORT void f9_V_SSP_ID(struct S_ID p0, struct S_ID p1, void* p2,  void (*cb)(struct S_ID, struct S_ID, void*)) ;
+EXPORT void f9_V_SSP_IP(struct S_IP p0, struct S_IP p1, void* p2,  void (*cb)(struct S_IP, struct S_IP, void*)) ;
+EXPORT void f9_V_SSP_FI(struct S_FI p0, struct S_FI p1, void* p2,  void (*cb)(struct S_FI, struct S_FI, void*)) ;
+EXPORT void f9_V_SSP_FF(struct S_FF p0, struct S_FF p1, void* p2,  void (*cb)(struct S_FF, struct S_FF, void*)) ;
+EXPORT void f9_V_SSP_FD(struct S_FD p0, struct S_FD p1, void* p2,  void (*cb)(struct S_FD, struct S_FD, void*)) ;
+EXPORT void f9_V_SSP_FP(struct S_FP p0, struct S_FP p1, void* p2,  void (*cb)(struct S_FP, struct S_FP, void*)) ;
+EXPORT void f9_V_SSP_DI(struct S_DI p0, struct S_DI p1, void* p2,  void (*cb)(struct S_DI, struct S_DI, void*)) ;
+EXPORT void f9_V_SSP_DF(struct S_DF p0, struct S_DF p1, void* p2,  void (*cb)(struct S_DF, struct S_DF, void*)) ;
+EXPORT void f9_V_SSP_DD(struct S_DD p0, struct S_DD p1, void* p2,  void (*cb)(struct S_DD, struct S_DD, void*)) ;
+EXPORT void f9_V_SSP_DP(struct S_DP p0, struct S_DP p1, void* p2,  void (*cb)(struct S_DP, struct S_DP, void*)) ;
+EXPORT void f9_V_SSP_PI(struct S_PI p0, struct S_PI p1, void* p2,  void (*cb)(struct S_PI, struct S_PI, void*)) ;
+EXPORT void f9_V_SSP_PF(struct S_PF p0, struct S_PF p1, void* p2,  void (*cb)(struct S_PF, struct S_PF, void*)) ;
+EXPORT void f9_V_SSP_PD(struct S_PD p0, struct S_PD p1, void* p2,  void (*cb)(struct S_PD, struct S_PD, void*)) ;
+EXPORT void f9_V_SSP_PP(struct S_PP p0, struct S_PP p1, void* p2,  void (*cb)(struct S_PP, struct S_PP, void*)) ;
+EXPORT void f9_V_SSP_III(struct S_III p0, struct S_III p1, void* p2,  void (*cb)(struct S_III, struct S_III, void*)) ;
+EXPORT void f9_V_SSP_IIF(struct S_IIF p0, struct S_IIF p1, void* p2,  void (*cb)(struct S_IIF, struct S_IIF, void*)) ;
+EXPORT void f9_V_SSP_IID(struct S_IID p0, struct S_IID p1, void* p2,  void (*cb)(struct S_IID, struct S_IID, void*)) ;
+EXPORT void f9_V_SSP_IIP(struct S_IIP p0, struct S_IIP p1, void* p2,  void (*cb)(struct S_IIP, struct S_IIP, void*)) ;
+EXPORT void f9_V_SSP_IFI(struct S_IFI p0, struct S_IFI p1, void* p2,  void (*cb)(struct S_IFI, struct S_IFI, void*)) ;
+EXPORT void f9_V_SSP_IFF(struct S_IFF p0, struct S_IFF p1, void* p2,  void (*cb)(struct S_IFF, struct S_IFF, void*)) ;
+EXPORT void f9_V_SSP_IFD(struct S_IFD p0, struct S_IFD p1, void* p2,  void (*cb)(struct S_IFD, struct S_IFD, void*)) ;
+EXPORT void f9_V_SSP_IFP(struct S_IFP p0, struct S_IFP p1, void* p2,  void (*cb)(struct S_IFP, struct S_IFP, void*)) ;
+EXPORT void f9_V_SSP_IDI(struct S_IDI p0, struct S_IDI p1, void* p2,  void (*cb)(struct S_IDI, struct S_IDI, void*)) ;
+EXPORT void f9_V_SSP_IDF(struct S_IDF p0, struct S_IDF p1, void* p2,  void (*cb)(struct S_IDF, struct S_IDF, void*)) ;
+EXPORT void f9_V_SSP_IDD(struct S_IDD p0, struct S_IDD p1, void* p2,  void (*cb)(struct S_IDD, struct S_IDD, void*)) ;
+EXPORT void f9_V_SSP_IDP(struct S_IDP p0, struct S_IDP p1, void* p2,  void (*cb)(struct S_IDP, struct S_IDP, void*)) ;
+EXPORT void f9_V_SSP_IPI(struct S_IPI p0, struct S_IPI p1, void* p2,  void (*cb)(struct S_IPI, struct S_IPI, void*)) ;
+EXPORT void f9_V_SSP_IPF(struct S_IPF p0, struct S_IPF p1, void* p2,  void (*cb)(struct S_IPF, struct S_IPF, void*)) ;
+EXPORT void f9_V_SSP_IPD(struct S_IPD p0, struct S_IPD p1, void* p2,  void (*cb)(struct S_IPD, struct S_IPD, void*)) ;
+EXPORT void f9_V_SSP_IPP(struct S_IPP p0, struct S_IPP p1, void* p2,  void (*cb)(struct S_IPP, struct S_IPP, void*)) ;
+EXPORT void f9_V_SSP_FII(struct S_FII p0, struct S_FII p1, void* p2,  void (*cb)(struct S_FII, struct S_FII, void*)) ;
+EXPORT void f9_V_SSP_FIF(struct S_FIF p0, struct S_FIF p1, void* p2,  void (*cb)(struct S_FIF, struct S_FIF, void*)) ;
+EXPORT void f9_V_SSP_FID(struct S_FID p0, struct S_FID p1, void* p2,  void (*cb)(struct S_FID, struct S_FID, void*)) ;
+EXPORT void f9_V_SSP_FIP(struct S_FIP p0, struct S_FIP p1, void* p2,  void (*cb)(struct S_FIP, struct S_FIP, void*)) ;
+EXPORT void f9_V_SSP_FFI(struct S_FFI p0, struct S_FFI p1, void* p2,  void (*cb)(struct S_FFI, struct S_FFI, void*)) ;
+EXPORT void f9_V_SSP_FFF(struct S_FFF p0, struct S_FFF p1, void* p2,  void (*cb)(struct S_FFF, struct S_FFF, void*)) ;
+EXPORT void f9_V_SSP_FFD(struct S_FFD p0, struct S_FFD p1, void* p2,  void (*cb)(struct S_FFD, struct S_FFD, void*)) ;
+EXPORT void f9_V_SSP_FFP(struct S_FFP p0, struct S_FFP p1, void* p2,  void (*cb)(struct S_FFP, struct S_FFP, void*)) ;
+EXPORT void f9_V_SSP_FDI(struct S_FDI p0, struct S_FDI p1, void* p2,  void (*cb)(struct S_FDI, struct S_FDI, void*)) ;
+EXPORT void f9_V_SSP_FDF(struct S_FDF p0, struct S_FDF p1, void* p2,  void (*cb)(struct S_FDF, struct S_FDF, void*)) ;
+EXPORT void f9_V_SSP_FDD(struct S_FDD p0, struct S_FDD p1, void* p2,  void (*cb)(struct S_FDD, struct S_FDD, void*)) ;
+EXPORT void f9_V_SSP_FDP(struct S_FDP p0, struct S_FDP p1, void* p2,  void (*cb)(struct S_FDP, struct S_FDP, void*)) ;
+EXPORT void f9_V_SSP_FPI(struct S_FPI p0, struct S_FPI p1, void* p2,  void (*cb)(struct S_FPI, struct S_FPI, void*)) ;
+EXPORT void f9_V_SSP_FPF(struct S_FPF p0, struct S_FPF p1, void* p2,  void (*cb)(struct S_FPF, struct S_FPF, void*)) ;
+EXPORT void f9_V_SSP_FPD(struct S_FPD p0, struct S_FPD p1, void* p2,  void (*cb)(struct S_FPD, struct S_FPD, void*)) ;
+EXPORT void f9_V_SSP_FPP(struct S_FPP p0, struct S_FPP p1, void* p2,  void (*cb)(struct S_FPP, struct S_FPP, void*)) ;
+EXPORT void f9_V_SSP_DII(struct S_DII p0, struct S_DII p1, void* p2,  void (*cb)(struct S_DII, struct S_DII, void*)) ;
+EXPORT void f9_V_SSP_DIF(struct S_DIF p0, struct S_DIF p1, void* p2,  void (*cb)(struct S_DIF, struct S_DIF, void*)) ;
+EXPORT void f9_V_SSP_DID(struct S_DID p0, struct S_DID p1, void* p2,  void (*cb)(struct S_DID, struct S_DID, void*)) ;
+EXPORT void f9_V_SSP_DIP(struct S_DIP p0, struct S_DIP p1, void* p2,  void (*cb)(struct S_DIP, struct S_DIP, void*)) ;
+EXPORT void f9_V_SSP_DFI(struct S_DFI p0, struct S_DFI p1, void* p2,  void (*cb)(struct S_DFI, struct S_DFI, void*)) ;
+EXPORT void f9_V_SSP_DFF(struct S_DFF p0, struct S_DFF p1, void* p2,  void (*cb)(struct S_DFF, struct S_DFF, void*)) ;
+EXPORT void f9_V_SSP_DFD(struct S_DFD p0, struct S_DFD p1, void* p2,  void (*cb)(struct S_DFD, struct S_DFD, void*)) ;
+EXPORT void f9_V_SSP_DFP(struct S_DFP p0, struct S_DFP p1, void* p2,  void (*cb)(struct S_DFP, struct S_DFP, void*)) ;
+EXPORT void f9_V_SSP_DDI(struct S_DDI p0, struct S_DDI p1, void* p2,  void (*cb)(struct S_DDI, struct S_DDI, void*)) ;
+EXPORT void f9_V_SSP_DDF(struct S_DDF p0, struct S_DDF p1, void* p2,  void (*cb)(struct S_DDF, struct S_DDF, void*)) ;
+EXPORT void f9_V_SSP_DDD(struct S_DDD p0, struct S_DDD p1, void* p2,  void (*cb)(struct S_DDD, struct S_DDD, void*)) ;
+EXPORT void f9_V_SSP_DDP(struct S_DDP p0, struct S_DDP p1, void* p2,  void (*cb)(struct S_DDP, struct S_DDP, void*)) ;
+EXPORT void f9_V_SSP_DPI(struct S_DPI p0, struct S_DPI p1, void* p2,  void (*cb)(struct S_DPI, struct S_DPI, void*)) ;
+EXPORT void f9_V_SSP_DPF(struct S_DPF p0, struct S_DPF p1, void* p2,  void (*cb)(struct S_DPF, struct S_DPF, void*)) ;
+EXPORT void f9_V_SSP_DPD(struct S_DPD p0, struct S_DPD p1, void* p2,  void (*cb)(struct S_DPD, struct S_DPD, void*)) ;
+EXPORT void f9_V_SSP_DPP(struct S_DPP p0, struct S_DPP p1, void* p2,  void (*cb)(struct S_DPP, struct S_DPP, void*)) ;
+EXPORT void f9_V_SSP_PII(struct S_PII p0, struct S_PII p1, void* p2,  void (*cb)(struct S_PII, struct S_PII, void*)) ;
+EXPORT void f9_V_SSP_PIF(struct S_PIF p0, struct S_PIF p1, void* p2,  void (*cb)(struct S_PIF, struct S_PIF, void*)) ;
+EXPORT void f9_V_SSP_PID(struct S_PID p0, struct S_PID p1, void* p2,  void (*cb)(struct S_PID, struct S_PID, void*)) ;
+EXPORT void f9_V_SSP_PIP(struct S_PIP p0, struct S_PIP p1, void* p2,  void (*cb)(struct S_PIP, struct S_PIP, void*)) ;
+EXPORT void f9_V_SSP_PFI(struct S_PFI p0, struct S_PFI p1, void* p2,  void (*cb)(struct S_PFI, struct S_PFI, void*)) ;
+EXPORT void f9_V_SSP_PFF(struct S_PFF p0, struct S_PFF p1, void* p2,  void (*cb)(struct S_PFF, struct S_PFF, void*)) ;
+EXPORT void f9_V_SSP_PFD(struct S_PFD p0, struct S_PFD p1, void* p2,  void (*cb)(struct S_PFD, struct S_PFD, void*)) ;
+EXPORT void f9_V_SSP_PFP(struct S_PFP p0, struct S_PFP p1, void* p2,  void (*cb)(struct S_PFP, struct S_PFP, void*)) ;
+EXPORT void f9_V_SSP_PDI(struct S_PDI p0, struct S_PDI p1, void* p2,  void (*cb)(struct S_PDI, struct S_PDI, void*)) ;
+EXPORT void f9_V_SSP_PDF(struct S_PDF p0, struct S_PDF p1, void* p2,  void (*cb)(struct S_PDF, struct S_PDF, void*)) ;
+EXPORT void f9_V_SSP_PDD(struct S_PDD p0, struct S_PDD p1, void* p2,  void (*cb)(struct S_PDD, struct S_PDD, void*)) ;
+EXPORT void f9_V_SSP_PDP(struct S_PDP p0, struct S_PDP p1, void* p2,  void (*cb)(struct S_PDP, struct S_PDP, void*)) ;
+EXPORT void f9_V_SSP_PPI(struct S_PPI p0, struct S_PPI p1, void* p2,  void (*cb)(struct S_PPI, struct S_PPI, void*)) ;
+EXPORT void f9_V_SSP_PPF(struct S_PPF p0, struct S_PPF p1, void* p2,  void (*cb)(struct S_PPF, struct S_PPF, void*)) ;
+EXPORT void f9_V_SSP_PPD(struct S_PPD p0, struct S_PPD p1, void* p2,  void (*cb)(struct S_PPD, struct S_PPD, void*)) ;
+EXPORT void f9_V_SSP_PPP(struct S_PPP p0, struct S_PPP p1, void* p2,  void (*cb)(struct S_PPP, struct S_PPP, void*)) ;
+EXPORT void f9_V_SSS_I(struct S_I p0, struct S_I p1, struct S_I p2,  void (*cb)(struct S_I, struct S_I, struct S_I)) ;
+EXPORT void f9_V_SSS_F(struct S_F p0, struct S_F p1, struct S_F p2,  void (*cb)(struct S_F, struct S_F, struct S_F)) ;
+EXPORT void f9_V_SSS_D(struct S_D p0, struct S_D p1, struct S_D p2,  void (*cb)(struct S_D, struct S_D, struct S_D)) ;
+EXPORT void f9_V_SSS_P(struct S_P p0, struct S_P p1, struct S_P p2,  void (*cb)(struct S_P, struct S_P, struct S_P)) ;
+EXPORT void f9_V_SSS_II(struct S_II p0, struct S_II p1, struct S_II p2,  void (*cb)(struct S_II, struct S_II, struct S_II)) ;
+EXPORT void f9_V_SSS_IF(struct S_IF p0, struct S_IF p1, struct S_IF p2,  void (*cb)(struct S_IF, struct S_IF, struct S_IF)) ;
+EXPORT void f9_V_SSS_ID(struct S_ID p0, struct S_ID p1, struct S_ID p2,  void (*cb)(struct S_ID, struct S_ID, struct S_ID)) ;
+EXPORT void f9_V_SSS_IP(struct S_IP p0, struct S_IP p1, struct S_IP p2,  void (*cb)(struct S_IP, struct S_IP, struct S_IP)) ;
+EXPORT void f9_V_SSS_FI(struct S_FI p0, struct S_FI p1, struct S_FI p2,  void (*cb)(struct S_FI, struct S_FI, struct S_FI)) ;
+EXPORT void f9_V_SSS_FF(struct S_FF p0, struct S_FF p1, struct S_FF p2,  void (*cb)(struct S_FF, struct S_FF, struct S_FF)) ;
+EXPORT void f9_V_SSS_FD(struct S_FD p0, struct S_FD p1, struct S_FD p2,  void (*cb)(struct S_FD, struct S_FD, struct S_FD)) ;
+EXPORT void f9_V_SSS_FP(struct S_FP p0, struct S_FP p1, struct S_FP p2,  void (*cb)(struct S_FP, struct S_FP, struct S_FP)) ;
+EXPORT void f9_V_SSS_DI(struct S_DI p0, struct S_DI p1, struct S_DI p2,  void (*cb)(struct S_DI, struct S_DI, struct S_DI)) ;
+EXPORT void f9_V_SSS_DF(struct S_DF p0, struct S_DF p1, struct S_DF p2,  void (*cb)(struct S_DF, struct S_DF, struct S_DF)) ;
+EXPORT void f9_V_SSS_DD(struct S_DD p0, struct S_DD p1, struct S_DD p2,  void (*cb)(struct S_DD, struct S_DD, struct S_DD)) ;
+EXPORT void f9_V_SSS_DP(struct S_DP p0, struct S_DP p1, struct S_DP p2,  void (*cb)(struct S_DP, struct S_DP, struct S_DP)) ;
+EXPORT void f9_V_SSS_PI(struct S_PI p0, struct S_PI p1, struct S_PI p2,  void (*cb)(struct S_PI, struct S_PI, struct S_PI)) ;
+EXPORT void f9_V_SSS_PF(struct S_PF p0, struct S_PF p1, struct S_PF p2,  void (*cb)(struct S_PF, struct S_PF, struct S_PF)) ;
+EXPORT void f9_V_SSS_PD(struct S_PD p0, struct S_PD p1, struct S_PD p2,  void (*cb)(struct S_PD, struct S_PD, struct S_PD)) ;
+EXPORT void f9_V_SSS_PP(struct S_PP p0, struct S_PP p1, struct S_PP p2,  void (*cb)(struct S_PP, struct S_PP, struct S_PP)) ;
+EXPORT void f9_V_SSS_III(struct S_III p0, struct S_III p1, struct S_III p2,  void (*cb)(struct S_III, struct S_III, struct S_III)) ;
+EXPORT void f9_V_SSS_IIF(struct S_IIF p0, struct S_IIF p1, struct S_IIF p2,  void (*cb)(struct S_IIF, struct S_IIF, struct S_IIF)) ;
+EXPORT void f9_V_SSS_IID(struct S_IID p0, struct S_IID p1, struct S_IID p2,  void (*cb)(struct S_IID, struct S_IID, struct S_IID)) ;
+EXPORT void f9_V_SSS_IIP(struct S_IIP p0, struct S_IIP p1, struct S_IIP p2,  void (*cb)(struct S_IIP, struct S_IIP, struct S_IIP)) ;
+EXPORT void f9_V_SSS_IFI(struct S_IFI p0, struct S_IFI p1, struct S_IFI p2,  void (*cb)(struct S_IFI, struct S_IFI, struct S_IFI)) ;
+EXPORT void f9_V_SSS_IFF(struct S_IFF p0, struct S_IFF p1, struct S_IFF p2,  void (*cb)(struct S_IFF, struct S_IFF, struct S_IFF)) ;
+EXPORT void f9_V_SSS_IFD(struct S_IFD p0, struct S_IFD p1, struct S_IFD p2,  void (*cb)(struct S_IFD, struct S_IFD, struct S_IFD)) ;
+EXPORT void f9_V_SSS_IFP(struct S_IFP p0, struct S_IFP p1, struct S_IFP p2,  void (*cb)(struct S_IFP, struct S_IFP, struct S_IFP)) ;
+EXPORT void f9_V_SSS_IDI(struct S_IDI p0, struct S_IDI p1, struct S_IDI p2,  void (*cb)(struct S_IDI, struct S_IDI, struct S_IDI)) ;
+EXPORT void f9_V_SSS_IDF(struct S_IDF p0, struct S_IDF p1, struct S_IDF p2,  void (*cb)(struct S_IDF, struct S_IDF, struct S_IDF)) ;
+EXPORT void f9_V_SSS_IDD(struct S_IDD p0, struct S_IDD p1, struct S_IDD p2,  void (*cb)(struct S_IDD, struct S_IDD, struct S_IDD)) ;
+EXPORT void f9_V_SSS_IDP(struct S_IDP p0, struct S_IDP p1, struct S_IDP p2,  void (*cb)(struct S_IDP, struct S_IDP, struct S_IDP)) ;
+EXPORT void f9_V_SSS_IPI(struct S_IPI p0, struct S_IPI p1, struct S_IPI p2,  void (*cb)(struct S_IPI, struct S_IPI, struct S_IPI)) ;
+EXPORT void f9_V_SSS_IPF(struct S_IPF p0, struct S_IPF p1, struct S_IPF p2,  void (*cb)(struct S_IPF, struct S_IPF, struct S_IPF)) ;
+EXPORT void f9_V_SSS_IPD(struct S_IPD p0, struct S_IPD p1, struct S_IPD p2,  void (*cb)(struct S_IPD, struct S_IPD, struct S_IPD)) ;
+EXPORT void f10_V_SSS_IPP(struct S_IPP p0, struct S_IPP p1, struct S_IPP p2,  void (*cb)(struct S_IPP, struct S_IPP, struct S_IPP)) ;
+EXPORT void f10_V_SSS_FII(struct S_FII p0, struct S_FII p1, struct S_FII p2,  void (*cb)(struct S_FII, struct S_FII, struct S_FII)) ;
+EXPORT void f10_V_SSS_FIF(struct S_FIF p0, struct S_FIF p1, struct S_FIF p2,  void (*cb)(struct S_FIF, struct S_FIF, struct S_FIF)) ;
+EXPORT void f10_V_SSS_FID(struct S_FID p0, struct S_FID p1, struct S_FID p2,  void (*cb)(struct S_FID, struct S_FID, struct S_FID)) ;
+EXPORT void f10_V_SSS_FIP(struct S_FIP p0, struct S_FIP p1, struct S_FIP p2,  void (*cb)(struct S_FIP, struct S_FIP, struct S_FIP)) ;
+EXPORT void f10_V_SSS_FFI(struct S_FFI p0, struct S_FFI p1, struct S_FFI p2,  void (*cb)(struct S_FFI, struct S_FFI, struct S_FFI)) ;
+EXPORT void f10_V_SSS_FFF(struct S_FFF p0, struct S_FFF p1, struct S_FFF p2,  void (*cb)(struct S_FFF, struct S_FFF, struct S_FFF)) ;
+EXPORT void f10_V_SSS_FFD(struct S_FFD p0, struct S_FFD p1, struct S_FFD p2,  void (*cb)(struct S_FFD, struct S_FFD, struct S_FFD)) ;
+EXPORT void f10_V_SSS_FFP(struct S_FFP p0, struct S_FFP p1, struct S_FFP p2,  void (*cb)(struct S_FFP, struct S_FFP, struct S_FFP)) ;
+EXPORT void f10_V_SSS_FDI(struct S_FDI p0, struct S_FDI p1, struct S_FDI p2,  void (*cb)(struct S_FDI, struct S_FDI, struct S_FDI)) ;
+EXPORT void f10_V_SSS_FDF(struct S_FDF p0, struct S_FDF p1, struct S_FDF p2,  void (*cb)(struct S_FDF, struct S_FDF, struct S_FDF)) ;
+EXPORT void f10_V_SSS_FDD(struct S_FDD p0, struct S_FDD p1, struct S_FDD p2,  void (*cb)(struct S_FDD, struct S_FDD, struct S_FDD)) ;
+EXPORT void f10_V_SSS_FDP(struct S_FDP p0, struct S_FDP p1, struct S_FDP p2,  void (*cb)(struct S_FDP, struct S_FDP, struct S_FDP)) ;
+EXPORT void f10_V_SSS_FPI(struct S_FPI p0, struct S_FPI p1, struct S_FPI p2,  void (*cb)(struct S_FPI, struct S_FPI, struct S_FPI)) ;
+EXPORT void f10_V_SSS_FPF(struct S_FPF p0, struct S_FPF p1, struct S_FPF p2,  void (*cb)(struct S_FPF, struct S_FPF, struct S_FPF)) ;
+EXPORT void f10_V_SSS_FPD(struct S_FPD p0, struct S_FPD p1, struct S_FPD p2,  void (*cb)(struct S_FPD, struct S_FPD, struct S_FPD)) ;
+EXPORT void f10_V_SSS_FPP(struct S_FPP p0, struct S_FPP p1, struct S_FPP p2,  void (*cb)(struct S_FPP, struct S_FPP, struct S_FPP)) ;
+EXPORT void f10_V_SSS_DII(struct S_DII p0, struct S_DII p1, struct S_DII p2,  void (*cb)(struct S_DII, struct S_DII, struct S_DII)) ;
+EXPORT void f10_V_SSS_DIF(struct S_DIF p0, struct S_DIF p1, struct S_DIF p2,  void (*cb)(struct S_DIF, struct S_DIF, struct S_DIF)) ;
+EXPORT void f10_V_SSS_DID(struct S_DID p0, struct S_DID p1, struct S_DID p2,  void (*cb)(struct S_DID, struct S_DID, struct S_DID)) ;
+EXPORT void f10_V_SSS_DIP(struct S_DIP p0, struct S_DIP p1, struct S_DIP p2,  void (*cb)(struct S_DIP, struct S_DIP, struct S_DIP)) ;
+EXPORT void f10_V_SSS_DFI(struct S_DFI p0, struct S_DFI p1, struct S_DFI p2,  void (*cb)(struct S_DFI, struct S_DFI, struct S_DFI)) ;
+EXPORT void f10_V_SSS_DFF(struct S_DFF p0, struct S_DFF p1, struct S_DFF p2,  void (*cb)(struct S_DFF, struct S_DFF, struct S_DFF)) ;
+EXPORT void f10_V_SSS_DFD(struct S_DFD p0, struct S_DFD p1, struct S_DFD p2,  void (*cb)(struct S_DFD, struct S_DFD, struct S_DFD)) ;
+EXPORT void f10_V_SSS_DFP(struct S_DFP p0, struct S_DFP p1, struct S_DFP p2,  void (*cb)(struct S_DFP, struct S_DFP, struct S_DFP)) ;
+EXPORT void f10_V_SSS_DDI(struct S_DDI p0, struct S_DDI p1, struct S_DDI p2,  void (*cb)(struct S_DDI, struct S_DDI, struct S_DDI)) ;
+EXPORT void f10_V_SSS_DDF(struct S_DDF p0, struct S_DDF p1, struct S_DDF p2,  void (*cb)(struct S_DDF, struct S_DDF, struct S_DDF)) ;
+EXPORT void f10_V_SSS_DDD(struct S_DDD p0, struct S_DDD p1, struct S_DDD p2,  void (*cb)(struct S_DDD, struct S_DDD, struct S_DDD)) ;
+EXPORT void f10_V_SSS_DDP(struct S_DDP p0, struct S_DDP p1, struct S_DDP p2,  void (*cb)(struct S_DDP, struct S_DDP, struct S_DDP)) ;
+EXPORT void f10_V_SSS_DPI(struct S_DPI p0, struct S_DPI p1, struct S_DPI p2,  void (*cb)(struct S_DPI, struct S_DPI, struct S_DPI)) ;
+EXPORT void f10_V_SSS_DPF(struct S_DPF p0, struct S_DPF p1, struct S_DPF p2,  void (*cb)(struct S_DPF, struct S_DPF, struct S_DPF)) ;
+EXPORT void f10_V_SSS_DPD(struct S_DPD p0, struct S_DPD p1, struct S_DPD p2,  void (*cb)(struct S_DPD, struct S_DPD, struct S_DPD)) ;
+EXPORT void f10_V_SSS_DPP(struct S_DPP p0, struct S_DPP p1, struct S_DPP p2,  void (*cb)(struct S_DPP, struct S_DPP, struct S_DPP)) ;
+EXPORT void f10_V_SSS_PII(struct S_PII p0, struct S_PII p1, struct S_PII p2,  void (*cb)(struct S_PII, struct S_PII, struct S_PII)) ;
+EXPORT void f10_V_SSS_PIF(struct S_PIF p0, struct S_PIF p1, struct S_PIF p2,  void (*cb)(struct S_PIF, struct S_PIF, struct S_PIF)) ;
+EXPORT void f10_V_SSS_PID(struct S_PID p0, struct S_PID p1, struct S_PID p2,  void (*cb)(struct S_PID, struct S_PID, struct S_PID)) ;
+EXPORT void f10_V_SSS_PIP(struct S_PIP p0, struct S_PIP p1, struct S_PIP p2,  void (*cb)(struct S_PIP, struct S_PIP, struct S_PIP)) ;
+EXPORT void f10_V_SSS_PFI(struct S_PFI p0, struct S_PFI p1, struct S_PFI p2,  void (*cb)(struct S_PFI, struct S_PFI, struct S_PFI)) ;
+EXPORT void f10_V_SSS_PFF(struct S_PFF p0, struct S_PFF p1, struct S_PFF p2,  void (*cb)(struct S_PFF, struct S_PFF, struct S_PFF)) ;
+EXPORT void f10_V_SSS_PFD(struct S_PFD p0, struct S_PFD p1, struct S_PFD p2,  void (*cb)(struct S_PFD, struct S_PFD, struct S_PFD)) ;
+EXPORT void f10_V_SSS_PFP(struct S_PFP p0, struct S_PFP p1, struct S_PFP p2,  void (*cb)(struct S_PFP, struct S_PFP, struct S_PFP)) ;
+EXPORT void f10_V_SSS_PDI(struct S_PDI p0, struct S_PDI p1, struct S_PDI p2,  void (*cb)(struct S_PDI, struct S_PDI, struct S_PDI)) ;
+EXPORT void f10_V_SSS_PDF(struct S_PDF p0, struct S_PDF p1, struct S_PDF p2,  void (*cb)(struct S_PDF, struct S_PDF, struct S_PDF)) ;
+EXPORT void f10_V_SSS_PDD(struct S_PDD p0, struct S_PDD p1, struct S_PDD p2,  void (*cb)(struct S_PDD, struct S_PDD, struct S_PDD)) ;
+EXPORT void f10_V_SSS_PDP(struct S_PDP p0, struct S_PDP p1, struct S_PDP p2,  void (*cb)(struct S_PDP, struct S_PDP, struct S_PDP)) ;
+EXPORT void f10_V_SSS_PPI(struct S_PPI p0, struct S_PPI p1, struct S_PPI p2,  void (*cb)(struct S_PPI, struct S_PPI, struct S_PPI)) ;
+EXPORT void f10_V_SSS_PPF(struct S_PPF p0, struct S_PPF p1, struct S_PPF p2,  void (*cb)(struct S_PPF, struct S_PPF, struct S_PPF)) ;
+EXPORT void f10_V_SSS_PPD(struct S_PPD p0, struct S_PPD p1, struct S_PPD p2,  void (*cb)(struct S_PPD, struct S_PPD, struct S_PPD)) ;
+EXPORT void f10_V_SSS_PPP(struct S_PPP p0, struct S_PPP p1, struct S_PPP p2,  void (*cb)(struct S_PPP, struct S_PPP, struct S_PPP)) ;
+EXPORT int f10_I_I_(int p0,  int (*cb)(int)) ;
+EXPORT float f10_F_F_(float p0,  float (*cb)(float)) ;
+EXPORT double f10_D_D_(double p0,  double (*cb)(double)) ;
+EXPORT void* f10_P_P_(void* p0,  void* (*cb)(void*)) ;
+EXPORT struct S_I f10_S_S_I(struct S_I p0,  struct S_I (*cb)(struct S_I)) ;
+EXPORT struct S_F f10_S_S_F(struct S_F p0,  struct S_F (*cb)(struct S_F)) ;
+EXPORT struct S_D f10_S_S_D(struct S_D p0,  struct S_D (*cb)(struct S_D)) ;
+EXPORT struct S_P f10_S_S_P(struct S_P p0,  struct S_P (*cb)(struct S_P)) ;
+EXPORT struct S_II f10_S_S_II(struct S_II p0,  struct S_II (*cb)(struct S_II)) ;
+EXPORT struct S_IF f10_S_S_IF(struct S_IF p0,  struct S_IF (*cb)(struct S_IF)) ;
+EXPORT struct S_ID f10_S_S_ID(struct S_ID p0,  struct S_ID (*cb)(struct S_ID)) ;
+EXPORT struct S_IP f10_S_S_IP(struct S_IP p0,  struct S_IP (*cb)(struct S_IP)) ;
+EXPORT struct S_FI f10_S_S_FI(struct S_FI p0,  struct S_FI (*cb)(struct S_FI)) ;
+EXPORT struct S_FF f10_S_S_FF(struct S_FF p0,  struct S_FF (*cb)(struct S_FF)) ;
+EXPORT struct S_FD f10_S_S_FD(struct S_FD p0,  struct S_FD (*cb)(struct S_FD)) ;
+EXPORT struct S_FP f10_S_S_FP(struct S_FP p0,  struct S_FP (*cb)(struct S_FP)) ;
+EXPORT struct S_DI f10_S_S_DI(struct S_DI p0,  struct S_DI (*cb)(struct S_DI)) ;
+EXPORT struct S_DF f10_S_S_DF(struct S_DF p0,  struct S_DF (*cb)(struct S_DF)) ;
+EXPORT struct S_DD f10_S_S_DD(struct S_DD p0,  struct S_DD (*cb)(struct S_DD)) ;
+EXPORT struct S_DP f10_S_S_DP(struct S_DP p0,  struct S_DP (*cb)(struct S_DP)) ;
+EXPORT struct S_PI f10_S_S_PI(struct S_PI p0,  struct S_PI (*cb)(struct S_PI)) ;
+EXPORT struct S_PF f10_S_S_PF(struct S_PF p0,  struct S_PF (*cb)(struct S_PF)) ;
+EXPORT struct S_PD f10_S_S_PD(struct S_PD p0,  struct S_PD (*cb)(struct S_PD)) ;
+EXPORT struct S_PP f10_S_S_PP(struct S_PP p0,  struct S_PP (*cb)(struct S_PP)) ;
+EXPORT struct S_III f10_S_S_III(struct S_III p0,  struct S_III (*cb)(struct S_III)) ;
+EXPORT struct S_IIF f10_S_S_IIF(struct S_IIF p0,  struct S_IIF (*cb)(struct S_IIF)) ;
+EXPORT struct S_IID f10_S_S_IID(struct S_IID p0,  struct S_IID (*cb)(struct S_IID)) ;
+EXPORT struct S_IIP f10_S_S_IIP(struct S_IIP p0,  struct S_IIP (*cb)(struct S_IIP)) ;
+EXPORT struct S_IFI f10_S_S_IFI(struct S_IFI p0,  struct S_IFI (*cb)(struct S_IFI)) ;
+EXPORT struct S_IFF f10_S_S_IFF(struct S_IFF p0,  struct S_IFF (*cb)(struct S_IFF)) ;
+EXPORT struct S_IFD f10_S_S_IFD(struct S_IFD p0,  struct S_IFD (*cb)(struct S_IFD)) ;
+EXPORT struct S_IFP f10_S_S_IFP(struct S_IFP p0,  struct S_IFP (*cb)(struct S_IFP)) ;
+EXPORT struct S_IDI f10_S_S_IDI(struct S_IDI p0,  struct S_IDI (*cb)(struct S_IDI)) ;
+EXPORT struct S_IDF f10_S_S_IDF(struct S_IDF p0,  struct S_IDF (*cb)(struct S_IDF)) ;
+EXPORT struct S_IDD f10_S_S_IDD(struct S_IDD p0,  struct S_IDD (*cb)(struct S_IDD)) ;
+EXPORT struct S_IDP f10_S_S_IDP(struct S_IDP p0,  struct S_IDP (*cb)(struct S_IDP)) ;
+EXPORT struct S_IPI f10_S_S_IPI(struct S_IPI p0,  struct S_IPI (*cb)(struct S_IPI)) ;
+EXPORT struct S_IPF f10_S_S_IPF(struct S_IPF p0,  struct S_IPF (*cb)(struct S_IPF)) ;
+EXPORT struct S_IPD f10_S_S_IPD(struct S_IPD p0,  struct S_IPD (*cb)(struct S_IPD)) ;
+EXPORT struct S_IPP f10_S_S_IPP(struct S_IPP p0,  struct S_IPP (*cb)(struct S_IPP)) ;
+EXPORT struct S_FII f10_S_S_FII(struct S_FII p0,  struct S_FII (*cb)(struct S_FII)) ;
+EXPORT struct S_FIF f10_S_S_FIF(struct S_FIF p0,  struct S_FIF (*cb)(struct S_FIF)) ;
+EXPORT struct S_FID f10_S_S_FID(struct S_FID p0,  struct S_FID (*cb)(struct S_FID)) ;
+EXPORT struct S_FIP f10_S_S_FIP(struct S_FIP p0,  struct S_FIP (*cb)(struct S_FIP)) ;
+EXPORT struct S_FFI f10_S_S_FFI(struct S_FFI p0,  struct S_FFI (*cb)(struct S_FFI)) ;
+EXPORT struct S_FFF f10_S_S_FFF(struct S_FFF p0,  struct S_FFF (*cb)(struct S_FFF)) ;
+EXPORT struct S_FFD f10_S_S_FFD(struct S_FFD p0,  struct S_FFD (*cb)(struct S_FFD)) ;
+EXPORT struct S_FFP f10_S_S_FFP(struct S_FFP p0,  struct S_FFP (*cb)(struct S_FFP)) ;
+EXPORT struct S_FDI f10_S_S_FDI(struct S_FDI p0,  struct S_FDI (*cb)(struct S_FDI)) ;
+EXPORT struct S_FDF f10_S_S_FDF(struct S_FDF p0,  struct S_FDF (*cb)(struct S_FDF)) ;
+EXPORT struct S_FDD f10_S_S_FDD(struct S_FDD p0,  struct S_FDD (*cb)(struct S_FDD)) ;
+EXPORT struct S_FDP f10_S_S_FDP(struct S_FDP p0,  struct S_FDP (*cb)(struct S_FDP)) ;
+EXPORT struct S_FPI f10_S_S_FPI(struct S_FPI p0,  struct S_FPI (*cb)(struct S_FPI)) ;
+EXPORT struct S_FPF f10_S_S_FPF(struct S_FPF p0,  struct S_FPF (*cb)(struct S_FPF)) ;
+EXPORT struct S_FPD f10_S_S_FPD(struct S_FPD p0,  struct S_FPD (*cb)(struct S_FPD)) ;
+EXPORT struct S_FPP f10_S_S_FPP(struct S_FPP p0,  struct S_FPP (*cb)(struct S_FPP)) ;
+EXPORT struct S_DII f10_S_S_DII(struct S_DII p0,  struct S_DII (*cb)(struct S_DII)) ;
+EXPORT struct S_DIF f10_S_S_DIF(struct S_DIF p0,  struct S_DIF (*cb)(struct S_DIF)) ;
+EXPORT struct S_DID f10_S_S_DID(struct S_DID p0,  struct S_DID (*cb)(struct S_DID)) ;
+EXPORT struct S_DIP f10_S_S_DIP(struct S_DIP p0,  struct S_DIP (*cb)(struct S_DIP)) ;
+EXPORT struct S_DFI f10_S_S_DFI(struct S_DFI p0,  struct S_DFI (*cb)(struct S_DFI)) ;
+EXPORT struct S_DFF f10_S_S_DFF(struct S_DFF p0,  struct S_DFF (*cb)(struct S_DFF)) ;
+EXPORT struct S_DFD f10_S_S_DFD(struct S_DFD p0,  struct S_DFD (*cb)(struct S_DFD)) ;
+EXPORT struct S_DFP f10_S_S_DFP(struct S_DFP p0,  struct S_DFP (*cb)(struct S_DFP)) ;
+EXPORT struct S_DDI f10_S_S_DDI(struct S_DDI p0,  struct S_DDI (*cb)(struct S_DDI)) ;
+EXPORT struct S_DDF f10_S_S_DDF(struct S_DDF p0,  struct S_DDF (*cb)(struct S_DDF)) ;
+EXPORT struct S_DDD f10_S_S_DDD(struct S_DDD p0,  struct S_DDD (*cb)(struct S_DDD)) ;
+EXPORT struct S_DDP f10_S_S_DDP(struct S_DDP p0,  struct S_DDP (*cb)(struct S_DDP)) ;
+EXPORT struct S_DPI f10_S_S_DPI(struct S_DPI p0,  struct S_DPI (*cb)(struct S_DPI)) ;
+EXPORT struct S_DPF f10_S_S_DPF(struct S_DPF p0,  struct S_DPF (*cb)(struct S_DPF)) ;
+EXPORT struct S_DPD f10_S_S_DPD(struct S_DPD p0,  struct S_DPD (*cb)(struct S_DPD)) ;
+EXPORT struct S_DPP f10_S_S_DPP(struct S_DPP p0,  struct S_DPP (*cb)(struct S_DPP)) ;
+EXPORT struct S_PII f10_S_S_PII(struct S_PII p0,  struct S_PII (*cb)(struct S_PII)) ;
+EXPORT struct S_PIF f10_S_S_PIF(struct S_PIF p0,  struct S_PIF (*cb)(struct S_PIF)) ;
+EXPORT struct S_PID f10_S_S_PID(struct S_PID p0,  struct S_PID (*cb)(struct S_PID)) ;
+EXPORT struct S_PIP f10_S_S_PIP(struct S_PIP p0,  struct S_PIP (*cb)(struct S_PIP)) ;
+EXPORT struct S_PFI f10_S_S_PFI(struct S_PFI p0,  struct S_PFI (*cb)(struct S_PFI)) ;
+EXPORT struct S_PFF f10_S_S_PFF(struct S_PFF p0,  struct S_PFF (*cb)(struct S_PFF)) ;
+EXPORT struct S_PFD f10_S_S_PFD(struct S_PFD p0,  struct S_PFD (*cb)(struct S_PFD)) ;
+EXPORT struct S_PFP f10_S_S_PFP(struct S_PFP p0,  struct S_PFP (*cb)(struct S_PFP)) ;
+EXPORT struct S_PDI f10_S_S_PDI(struct S_PDI p0,  struct S_PDI (*cb)(struct S_PDI)) ;
+EXPORT struct S_PDF f10_S_S_PDF(struct S_PDF p0,  struct S_PDF (*cb)(struct S_PDF)) ;
+EXPORT struct S_PDD f10_S_S_PDD(struct S_PDD p0,  struct S_PDD (*cb)(struct S_PDD)) ;
+EXPORT struct S_PDP f10_S_S_PDP(struct S_PDP p0,  struct S_PDP (*cb)(struct S_PDP)) ;
+EXPORT struct S_PPI f10_S_S_PPI(struct S_PPI p0,  struct S_PPI (*cb)(struct S_PPI)) ;
+EXPORT struct S_PPF f10_S_S_PPF(struct S_PPF p0,  struct S_PPF (*cb)(struct S_PPF)) ;
+EXPORT struct S_PPD f10_S_S_PPD(struct S_PPD p0,  struct S_PPD (*cb)(struct S_PPD)) ;
+EXPORT struct S_PPP f10_S_S_PPP(struct S_PPP p0,  struct S_PPP (*cb)(struct S_PPP)) ;
+EXPORT int f10_I_II_(int p0, int p1,  int (*cb)(int, int)) ;
+EXPORT int f10_I_IF_(int p0, float p1,  int (*cb)(int, float)) ;
+EXPORT int f10_I_ID_(int p0, double p1,  int (*cb)(int, double)) ;
+EXPORT int f10_I_IP_(int p0, void* p1,  int (*cb)(int, void*)) ;
+EXPORT int f10_I_IS_I(int p0, struct S_I p1,  int (*cb)(int, struct S_I)) ;
+EXPORT int f10_I_IS_F(int p0, struct S_F p1,  int (*cb)(int, struct S_F)) ;
+EXPORT int f10_I_IS_D(int p0, struct S_D p1,  int (*cb)(int, struct S_D)) ;
+EXPORT int f10_I_IS_P(int p0, struct S_P p1,  int (*cb)(int, struct S_P)) ;
+EXPORT int f10_I_IS_II(int p0, struct S_II p1,  int (*cb)(int, struct S_II)) ;
+EXPORT int f10_I_IS_IF(int p0, struct S_IF p1,  int (*cb)(int, struct S_IF)) ;
+EXPORT int f10_I_IS_ID(int p0, struct S_ID p1,  int (*cb)(int, struct S_ID)) ;
+EXPORT int f10_I_IS_IP(int p0, struct S_IP p1,  int (*cb)(int, struct S_IP)) ;
+EXPORT int f10_I_IS_FI(int p0, struct S_FI p1,  int (*cb)(int, struct S_FI)) ;
+EXPORT int f10_I_IS_FF(int p0, struct S_FF p1,  int (*cb)(int, struct S_FF)) ;
+EXPORT int f10_I_IS_FD(int p0, struct S_FD p1,  int (*cb)(int, struct S_FD)) ;
+EXPORT int f10_I_IS_FP(int p0, struct S_FP p1,  int (*cb)(int, struct S_FP)) ;
+EXPORT int f10_I_IS_DI(int p0, struct S_DI p1,  int (*cb)(int, struct S_DI)) ;
+EXPORT int f10_I_IS_DF(int p0, struct S_DF p1,  int (*cb)(int, struct S_DF)) ;
+EXPORT int f10_I_IS_DD(int p0, struct S_DD p1,  int (*cb)(int, struct S_DD)) ;
+EXPORT int f10_I_IS_DP(int p0, struct S_DP p1,  int (*cb)(int, struct S_DP)) ;
+EXPORT int f10_I_IS_PI(int p0, struct S_PI p1,  int (*cb)(int, struct S_PI)) ;
+EXPORT int f10_I_IS_PF(int p0, struct S_PF p1,  int (*cb)(int, struct S_PF)) ;
+EXPORT int f10_I_IS_PD(int p0, struct S_PD p1,  int (*cb)(int, struct S_PD)) ;
+EXPORT int f10_I_IS_PP(int p0, struct S_PP p1,  int (*cb)(int, struct S_PP)) ;
+EXPORT int f10_I_IS_III(int p0, struct S_III p1,  int (*cb)(int, struct S_III)) ;
+EXPORT int f10_I_IS_IIF(int p0, struct S_IIF p1,  int (*cb)(int, struct S_IIF)) ;
+EXPORT int f10_I_IS_IID(int p0, struct S_IID p1,  int (*cb)(int, struct S_IID)) ;
+EXPORT int f10_I_IS_IIP(int p0, struct S_IIP p1,  int (*cb)(int, struct S_IIP)) ;
+EXPORT int f10_I_IS_IFI(int p0, struct S_IFI p1,  int (*cb)(int, struct S_IFI)) ;
+EXPORT int f10_I_IS_IFF(int p0, struct S_IFF p1,  int (*cb)(int, struct S_IFF)) ;
+EXPORT int f10_I_IS_IFD(int p0, struct S_IFD p1,  int (*cb)(int, struct S_IFD)) ;
+EXPORT int f10_I_IS_IFP(int p0, struct S_IFP p1,  int (*cb)(int, struct S_IFP)) ;
+EXPORT int f10_I_IS_IDI(int p0, struct S_IDI p1,  int (*cb)(int, struct S_IDI)) ;
+EXPORT int f10_I_IS_IDF(int p0, struct S_IDF p1,  int (*cb)(int, struct S_IDF)) ;
+EXPORT int f10_I_IS_IDD(int p0, struct S_IDD p1,  int (*cb)(int, struct S_IDD)) ;
+EXPORT int f10_I_IS_IDP(int p0, struct S_IDP p1,  int (*cb)(int, struct S_IDP)) ;
+EXPORT int f10_I_IS_IPI(int p0, struct S_IPI p1,  int (*cb)(int, struct S_IPI)) ;
+EXPORT int f10_I_IS_IPF(int p0, struct S_IPF p1,  int (*cb)(int, struct S_IPF)) ;
+EXPORT int f10_I_IS_IPD(int p0, struct S_IPD p1,  int (*cb)(int, struct S_IPD)) ;
+EXPORT int f10_I_IS_IPP(int p0, struct S_IPP p1,  int (*cb)(int, struct S_IPP)) ;
+EXPORT int f10_I_IS_FII(int p0, struct S_FII p1,  int (*cb)(int, struct S_FII)) ;
+EXPORT int f10_I_IS_FIF(int p0, struct S_FIF p1,  int (*cb)(int, struct S_FIF)) ;
+EXPORT int f10_I_IS_FID(int p0, struct S_FID p1,  int (*cb)(int, struct S_FID)) ;
+EXPORT int f10_I_IS_FIP(int p0, struct S_FIP p1,  int (*cb)(int, struct S_FIP)) ;
+EXPORT int f10_I_IS_FFI(int p0, struct S_FFI p1,  int (*cb)(int, struct S_FFI)) ;
+EXPORT int f10_I_IS_FFF(int p0, struct S_FFF p1,  int (*cb)(int, struct S_FFF)) ;
+EXPORT int f10_I_IS_FFD(int p0, struct S_FFD p1,  int (*cb)(int, struct S_FFD)) ;
+EXPORT int f10_I_IS_FFP(int p0, struct S_FFP p1,  int (*cb)(int, struct S_FFP)) ;
+EXPORT int f10_I_IS_FDI(int p0, struct S_FDI p1,  int (*cb)(int, struct S_FDI)) ;
+EXPORT int f10_I_IS_FDF(int p0, struct S_FDF p1,  int (*cb)(int, struct S_FDF)) ;
+EXPORT int f10_I_IS_FDD(int p0, struct S_FDD p1,  int (*cb)(int, struct S_FDD)) ;
+EXPORT int f10_I_IS_FDP(int p0, struct S_FDP p1,  int (*cb)(int, struct S_FDP)) ;
+EXPORT int f10_I_IS_FPI(int p0, struct S_FPI p1,  int (*cb)(int, struct S_FPI)) ;
+EXPORT int f10_I_IS_FPF(int p0, struct S_FPF p1,  int (*cb)(int, struct S_FPF)) ;
+EXPORT int f10_I_IS_FPD(int p0, struct S_FPD p1,  int (*cb)(int, struct S_FPD)) ;
+EXPORT int f10_I_IS_FPP(int p0, struct S_FPP p1,  int (*cb)(int, struct S_FPP)) ;
+EXPORT int f10_I_IS_DII(int p0, struct S_DII p1,  int (*cb)(int, struct S_DII)) ;
+EXPORT int f10_I_IS_DIF(int p0, struct S_DIF p1,  int (*cb)(int, struct S_DIF)) ;
+EXPORT int f10_I_IS_DID(int p0, struct S_DID p1,  int (*cb)(int, struct S_DID)) ;
+EXPORT int f10_I_IS_DIP(int p0, struct S_DIP p1,  int (*cb)(int, struct S_DIP)) ;
+EXPORT int f10_I_IS_DFI(int p0, struct S_DFI p1,  int (*cb)(int, struct S_DFI)) ;
+EXPORT int f10_I_IS_DFF(int p0, struct S_DFF p1,  int (*cb)(int, struct S_DFF)) ;
+EXPORT int f10_I_IS_DFD(int p0, struct S_DFD p1,  int (*cb)(int, struct S_DFD)) ;
+EXPORT int f10_I_IS_DFP(int p0, struct S_DFP p1,  int (*cb)(int, struct S_DFP)) ;
+EXPORT int f10_I_IS_DDI(int p0, struct S_DDI p1,  int (*cb)(int, struct S_DDI)) ;
+EXPORT int f10_I_IS_DDF(int p0, struct S_DDF p1,  int (*cb)(int, struct S_DDF)) ;
+EXPORT int f10_I_IS_DDD(int p0, struct S_DDD p1,  int (*cb)(int, struct S_DDD)) ;
+EXPORT int f10_I_IS_DDP(int p0, struct S_DDP p1,  int (*cb)(int, struct S_DDP)) ;
+EXPORT int f10_I_IS_DPI(int p0, struct S_DPI p1,  int (*cb)(int, struct S_DPI)) ;
+EXPORT int f10_I_IS_DPF(int p0, struct S_DPF p1,  int (*cb)(int, struct S_DPF)) ;
+EXPORT int f10_I_IS_DPD(int p0, struct S_DPD p1,  int (*cb)(int, struct S_DPD)) ;
+EXPORT int f10_I_IS_DPP(int p0, struct S_DPP p1,  int (*cb)(int, struct S_DPP)) ;
+EXPORT int f10_I_IS_PII(int p0, struct S_PII p1,  int (*cb)(int, struct S_PII)) ;
+EXPORT int f10_I_IS_PIF(int p0, struct S_PIF p1,  int (*cb)(int, struct S_PIF)) ;
+EXPORT int f10_I_IS_PID(int p0, struct S_PID p1,  int (*cb)(int, struct S_PID)) ;
+EXPORT int f10_I_IS_PIP(int p0, struct S_PIP p1,  int (*cb)(int, struct S_PIP)) ;
+EXPORT int f10_I_IS_PFI(int p0, struct S_PFI p1,  int (*cb)(int, struct S_PFI)) ;
+EXPORT int f10_I_IS_PFF(int p0, struct S_PFF p1,  int (*cb)(int, struct S_PFF)) ;
+EXPORT int f10_I_IS_PFD(int p0, struct S_PFD p1,  int (*cb)(int, struct S_PFD)) ;
+EXPORT int f10_I_IS_PFP(int p0, struct S_PFP p1,  int (*cb)(int, struct S_PFP)) ;
+EXPORT int f10_I_IS_PDI(int p0, struct S_PDI p1,  int (*cb)(int, struct S_PDI)) ;
+EXPORT int f10_I_IS_PDF(int p0, struct S_PDF p1,  int (*cb)(int, struct S_PDF)) ;
+EXPORT int f10_I_IS_PDD(int p0, struct S_PDD p1,  int (*cb)(int, struct S_PDD)) ;
+EXPORT int f10_I_IS_PDP(int p0, struct S_PDP p1,  int (*cb)(int, struct S_PDP)) ;
+EXPORT int f10_I_IS_PPI(int p0, struct S_PPI p1,  int (*cb)(int, struct S_PPI)) ;
+EXPORT int f10_I_IS_PPF(int p0, struct S_PPF p1,  int (*cb)(int, struct S_PPF)) ;
+EXPORT int f10_I_IS_PPD(int p0, struct S_PPD p1,  int (*cb)(int, struct S_PPD)) ;
+EXPORT int f10_I_IS_PPP(int p0, struct S_PPP p1,  int (*cb)(int, struct S_PPP)) ;
+EXPORT float f10_F_FI_(float p0, int p1,  float (*cb)(float, int)) ;
+EXPORT float f10_F_FF_(float p0, float p1,  float (*cb)(float, float)) ;
+EXPORT float f10_F_FD_(float p0, double p1,  float (*cb)(float, double)) ;
+EXPORT float f10_F_FP_(float p0, void* p1,  float (*cb)(float, void*)) ;
+EXPORT float f10_F_FS_I(float p0, struct S_I p1,  float (*cb)(float, struct S_I)) ;
+EXPORT float f10_F_FS_F(float p0, struct S_F p1,  float (*cb)(float, struct S_F)) ;
+EXPORT float f10_F_FS_D(float p0, struct S_D p1,  float (*cb)(float, struct S_D)) ;
+EXPORT float f10_F_FS_P(float p0, struct S_P p1,  float (*cb)(float, struct S_P)) ;
+EXPORT float f10_F_FS_II(float p0, struct S_II p1,  float (*cb)(float, struct S_II)) ;
+EXPORT float f10_F_FS_IF(float p0, struct S_IF p1,  float (*cb)(float, struct S_IF)) ;
+EXPORT float f10_F_FS_ID(float p0, struct S_ID p1,  float (*cb)(float, struct S_ID)) ;
+EXPORT float f10_F_FS_IP(float p0, struct S_IP p1,  float (*cb)(float, struct S_IP)) ;
+EXPORT float f10_F_FS_FI(float p0, struct S_FI p1,  float (*cb)(float, struct S_FI)) ;
+EXPORT float f10_F_FS_FF(float p0, struct S_FF p1,  float (*cb)(float, struct S_FF)) ;
+EXPORT float f10_F_FS_FD(float p0, struct S_FD p1,  float (*cb)(float, struct S_FD)) ;
+EXPORT float f10_F_FS_FP(float p0, struct S_FP p1,  float (*cb)(float, struct S_FP)) ;
+EXPORT float f10_F_FS_DI(float p0, struct S_DI p1,  float (*cb)(float, struct S_DI)) ;
+EXPORT float f10_F_FS_DF(float p0, struct S_DF p1,  float (*cb)(float, struct S_DF)) ;
+EXPORT float f10_F_FS_DD(float p0, struct S_DD p1,  float (*cb)(float, struct S_DD)) ;
+EXPORT float f10_F_FS_DP(float p0, struct S_DP p1,  float (*cb)(float, struct S_DP)) ;
+EXPORT float f10_F_FS_PI(float p0, struct S_PI p1,  float (*cb)(float, struct S_PI)) ;
+EXPORT float f10_F_FS_PF(float p0, struct S_PF p1,  float (*cb)(float, struct S_PF)) ;
+EXPORT float f10_F_FS_PD(float p0, struct S_PD p1,  float (*cb)(float, struct S_PD)) ;
+EXPORT float f10_F_FS_PP(float p0, struct S_PP p1,  float (*cb)(float, struct S_PP)) ;
+EXPORT float f10_F_FS_III(float p0, struct S_III p1,  float (*cb)(float, struct S_III)) ;
+EXPORT float f10_F_FS_IIF(float p0, struct S_IIF p1,  float (*cb)(float, struct S_IIF)) ;
+EXPORT float f10_F_FS_IID(float p0, struct S_IID p1,  float (*cb)(float, struct S_IID)) ;
+EXPORT float f10_F_FS_IIP(float p0, struct S_IIP p1,  float (*cb)(float, struct S_IIP)) ;
+EXPORT float f10_F_FS_IFI(float p0, struct S_IFI p1,  float (*cb)(float, struct S_IFI)) ;
+EXPORT float f10_F_FS_IFF(float p0, struct S_IFF p1,  float (*cb)(float, struct S_IFF)) ;
+EXPORT float f10_F_FS_IFD(float p0, struct S_IFD p1,  float (*cb)(float, struct S_IFD)) ;
+EXPORT float f10_F_FS_IFP(float p0, struct S_IFP p1,  float (*cb)(float, struct S_IFP)) ;
+EXPORT float f10_F_FS_IDI(float p0, struct S_IDI p1,  float (*cb)(float, struct S_IDI)) ;
+EXPORT float f10_F_FS_IDF(float p0, struct S_IDF p1,  float (*cb)(float, struct S_IDF)) ;
+EXPORT float f10_F_FS_IDD(float p0, struct S_IDD p1,  float (*cb)(float, struct S_IDD)) ;
+EXPORT float f10_F_FS_IDP(float p0, struct S_IDP p1,  float (*cb)(float, struct S_IDP)) ;
+EXPORT float f10_F_FS_IPI(float p0, struct S_IPI p1,  float (*cb)(float, struct S_IPI)) ;
+EXPORT float f10_F_FS_IPF(float p0, struct S_IPF p1,  float (*cb)(float, struct S_IPF)) ;
+EXPORT float f10_F_FS_IPD(float p0, struct S_IPD p1,  float (*cb)(float, struct S_IPD)) ;
+EXPORT float f10_F_FS_IPP(float p0, struct S_IPP p1,  float (*cb)(float, struct S_IPP)) ;
+EXPORT float f10_F_FS_FII(float p0, struct S_FII p1,  float (*cb)(float, struct S_FII)) ;
+EXPORT float f10_F_FS_FIF(float p0, struct S_FIF p1,  float (*cb)(float, struct S_FIF)) ;
+EXPORT float f10_F_FS_FID(float p0, struct S_FID p1,  float (*cb)(float, struct S_FID)) ;
+EXPORT float f10_F_FS_FIP(float p0, struct S_FIP p1,  float (*cb)(float, struct S_FIP)) ;
+EXPORT float f10_F_FS_FFI(float p0, struct S_FFI p1,  float (*cb)(float, struct S_FFI)) ;
+EXPORT float f10_F_FS_FFF(float p0, struct S_FFF p1,  float (*cb)(float, struct S_FFF)) ;
+EXPORT float f10_F_FS_FFD(float p0, struct S_FFD p1,  float (*cb)(float, struct S_FFD)) ;
+EXPORT float f10_F_FS_FFP(float p0, struct S_FFP p1,  float (*cb)(float, struct S_FFP)) ;
+EXPORT float f10_F_FS_FDI(float p0, struct S_FDI p1,  float (*cb)(float, struct S_FDI)) ;
+EXPORT float f10_F_FS_FDF(float p0, struct S_FDF p1,  float (*cb)(float, struct S_FDF)) ;
+EXPORT float f10_F_FS_FDD(float p0, struct S_FDD p1,  float (*cb)(float, struct S_FDD)) ;
+EXPORT float f10_F_FS_FDP(float p0, struct S_FDP p1,  float (*cb)(float, struct S_FDP)) ;
+EXPORT float f10_F_FS_FPI(float p0, struct S_FPI p1,  float (*cb)(float, struct S_FPI)) ;
+EXPORT float f10_F_FS_FPF(float p0, struct S_FPF p1,  float (*cb)(float, struct S_FPF)) ;
+EXPORT float f10_F_FS_FPD(float p0, struct S_FPD p1,  float (*cb)(float, struct S_FPD)) ;
+EXPORT float f10_F_FS_FPP(float p0, struct S_FPP p1,  float (*cb)(float, struct S_FPP)) ;
+EXPORT float f10_F_FS_DII(float p0, struct S_DII p1,  float (*cb)(float, struct S_DII)) ;
+EXPORT float f10_F_FS_DIF(float p0, struct S_DIF p1,  float (*cb)(float, struct S_DIF)) ;
+EXPORT float f10_F_FS_DID(float p0, struct S_DID p1,  float (*cb)(float, struct S_DID)) ;
+EXPORT float f10_F_FS_DIP(float p0, struct S_DIP p1,  float (*cb)(float, struct S_DIP)) ;
+EXPORT float f10_F_FS_DFI(float p0, struct S_DFI p1,  float (*cb)(float, struct S_DFI)) ;
+EXPORT float f10_F_FS_DFF(float p0, struct S_DFF p1,  float (*cb)(float, struct S_DFF)) ;
+EXPORT float f10_F_FS_DFD(float p0, struct S_DFD p1,  float (*cb)(float, struct S_DFD)) ;
+EXPORT float f10_F_FS_DFP(float p0, struct S_DFP p1,  float (*cb)(float, struct S_DFP)) ;
+EXPORT float f10_F_FS_DDI(float p0, struct S_DDI p1,  float (*cb)(float, struct S_DDI)) ;
+EXPORT float f10_F_FS_DDF(float p0, struct S_DDF p1,  float (*cb)(float, struct S_DDF)) ;
+EXPORT float f10_F_FS_DDD(float p0, struct S_DDD p1,  float (*cb)(float, struct S_DDD)) ;
+EXPORT float f10_F_FS_DDP(float p0, struct S_DDP p1,  float (*cb)(float, struct S_DDP)) ;
+EXPORT float f10_F_FS_DPI(float p0, struct S_DPI p1,  float (*cb)(float, struct S_DPI)) ;
+EXPORT float f10_F_FS_DPF(float p0, struct S_DPF p1,  float (*cb)(float, struct S_DPF)) ;
+EXPORT float f10_F_FS_DPD(float p0, struct S_DPD p1,  float (*cb)(float, struct S_DPD)) ;
+EXPORT float f10_F_FS_DPP(float p0, struct S_DPP p1,  float (*cb)(float, struct S_DPP)) ;
+EXPORT float f10_F_FS_PII(float p0, struct S_PII p1,  float (*cb)(float, struct S_PII)) ;
+EXPORT float f10_F_FS_PIF(float p0, struct S_PIF p1,  float (*cb)(float, struct S_PIF)) ;
+EXPORT float f10_F_FS_PID(float p0, struct S_PID p1,  float (*cb)(float, struct S_PID)) ;
+EXPORT float f10_F_FS_PIP(float p0, struct S_PIP p1,  float (*cb)(float, struct S_PIP)) ;
+EXPORT float f10_F_FS_PFI(float p0, struct S_PFI p1,  float (*cb)(float, struct S_PFI)) ;
+EXPORT float f10_F_FS_PFF(float p0, struct S_PFF p1,  float (*cb)(float, struct S_PFF)) ;
+EXPORT float f10_F_FS_PFD(float p0, struct S_PFD p1,  float (*cb)(float, struct S_PFD)) ;
+EXPORT float f10_F_FS_PFP(float p0, struct S_PFP p1,  float (*cb)(float, struct S_PFP)) ;
+EXPORT float f10_F_FS_PDI(float p0, struct S_PDI p1,  float (*cb)(float, struct S_PDI)) ;
+EXPORT float f10_F_FS_PDF(float p0, struct S_PDF p1,  float (*cb)(float, struct S_PDF)) ;
+EXPORT float f10_F_FS_PDD(float p0, struct S_PDD p1,  float (*cb)(float, struct S_PDD)) ;
+EXPORT float f10_F_FS_PDP(float p0, struct S_PDP p1,  float (*cb)(float, struct S_PDP)) ;
+EXPORT float f10_F_FS_PPI(float p0, struct S_PPI p1,  float (*cb)(float, struct S_PPI)) ;
+EXPORT float f10_F_FS_PPF(float p0, struct S_PPF p1,  float (*cb)(float, struct S_PPF)) ;
+EXPORT float f10_F_FS_PPD(float p0, struct S_PPD p1,  float (*cb)(float, struct S_PPD)) ;
+EXPORT float f10_F_FS_PPP(float p0, struct S_PPP p1,  float (*cb)(float, struct S_PPP)) ;
+EXPORT double f10_D_DI_(double p0, int p1,  double (*cb)(double, int)) ;
+EXPORT double f10_D_DF_(double p0, float p1,  double (*cb)(double, float)) ;
+EXPORT double f10_D_DD_(double p0, double p1,  double (*cb)(double, double)) ;
+EXPORT double f10_D_DP_(double p0, void* p1,  double (*cb)(double, void*)) ;
+EXPORT double f10_D_DS_I(double p0, struct S_I p1,  double (*cb)(double, struct S_I)) ;
+EXPORT double f10_D_DS_F(double p0, struct S_F p1,  double (*cb)(double, struct S_F)) ;
+EXPORT double f10_D_DS_D(double p0, struct S_D p1,  double (*cb)(double, struct S_D)) ;
+EXPORT double f10_D_DS_P(double p0, struct S_P p1,  double (*cb)(double, struct S_P)) ;
+EXPORT double f10_D_DS_II(double p0, struct S_II p1,  double (*cb)(double, struct S_II)) ;
+EXPORT double f10_D_DS_IF(double p0, struct S_IF p1,  double (*cb)(double, struct S_IF)) ;
+EXPORT double f10_D_DS_ID(double p0, struct S_ID p1,  double (*cb)(double, struct S_ID)) ;
+EXPORT double f10_D_DS_IP(double p0, struct S_IP p1,  double (*cb)(double, struct S_IP)) ;
+EXPORT double f10_D_DS_FI(double p0, struct S_FI p1,  double (*cb)(double, struct S_FI)) ;
+EXPORT double f10_D_DS_FF(double p0, struct S_FF p1,  double (*cb)(double, struct S_FF)) ;
+EXPORT double f10_D_DS_FD(double p0, struct S_FD p1,  double (*cb)(double, struct S_FD)) ;
+EXPORT double f10_D_DS_FP(double p0, struct S_FP p1,  double (*cb)(double, struct S_FP)) ;
+EXPORT double f10_D_DS_DI(double p0, struct S_DI p1,  double (*cb)(double, struct S_DI)) ;
+EXPORT double f10_D_DS_DF(double p0, struct S_DF p1,  double (*cb)(double, struct S_DF)) ;
+EXPORT double f10_D_DS_DD(double p0, struct S_DD p1,  double (*cb)(double, struct S_DD)) ;
+EXPORT double f10_D_DS_DP(double p0, struct S_DP p1,  double (*cb)(double, struct S_DP)) ;
+EXPORT double f10_D_DS_PI(double p0, struct S_PI p1,  double (*cb)(double, struct S_PI)) ;
+EXPORT double f10_D_DS_PF(double p0, struct S_PF p1,  double (*cb)(double, struct S_PF)) ;
+EXPORT double f10_D_DS_PD(double p0, struct S_PD p1,  double (*cb)(double, struct S_PD)) ;
+EXPORT double f10_D_DS_PP(double p0, struct S_PP p1,  double (*cb)(double, struct S_PP)) ;
+EXPORT double f10_D_DS_III(double p0, struct S_III p1,  double (*cb)(double, struct S_III)) ;
+EXPORT double f10_D_DS_IIF(double p0, struct S_IIF p1,  double (*cb)(double, struct S_IIF)) ;
+EXPORT double f10_D_DS_IID(double p0, struct S_IID p1,  double (*cb)(double, struct S_IID)) ;
+EXPORT double f10_D_DS_IIP(double p0, struct S_IIP p1,  double (*cb)(double, struct S_IIP)) ;
+EXPORT double f10_D_DS_IFI(double p0, struct S_IFI p1,  double (*cb)(double, struct S_IFI)) ;
+EXPORT double f10_D_DS_IFF(double p0, struct S_IFF p1,  double (*cb)(double, struct S_IFF)) ;
+EXPORT double f10_D_DS_IFD(double p0, struct S_IFD p1,  double (*cb)(double, struct S_IFD)) ;
+EXPORT double f10_D_DS_IFP(double p0, struct S_IFP p1,  double (*cb)(double, struct S_IFP)) ;
+EXPORT double f10_D_DS_IDI(double p0, struct S_IDI p1,  double (*cb)(double, struct S_IDI)) ;
+EXPORT double f10_D_DS_IDF(double p0, struct S_IDF p1,  double (*cb)(double, struct S_IDF)) ;
+EXPORT double f10_D_DS_IDD(double p0, struct S_IDD p1,  double (*cb)(double, struct S_IDD)) ;
+EXPORT double f10_D_DS_IDP(double p0, struct S_IDP p1,  double (*cb)(double, struct S_IDP)) ;
+EXPORT double f10_D_DS_IPI(double p0, struct S_IPI p1,  double (*cb)(double, struct S_IPI)) ;
+EXPORT double f10_D_DS_IPF(double p0, struct S_IPF p1,  double (*cb)(double, struct S_IPF)) ;
+EXPORT double f10_D_DS_IPD(double p0, struct S_IPD p1,  double (*cb)(double, struct S_IPD)) ;
+EXPORT double f10_D_DS_IPP(double p0, struct S_IPP p1,  double (*cb)(double, struct S_IPP)) ;
+EXPORT double f10_D_DS_FII(double p0, struct S_FII p1,  double (*cb)(double, struct S_FII)) ;
+EXPORT double f10_D_DS_FIF(double p0, struct S_FIF p1,  double (*cb)(double, struct S_FIF)) ;
+EXPORT double f10_D_DS_FID(double p0, struct S_FID p1,  double (*cb)(double, struct S_FID)) ;
+EXPORT double f10_D_DS_FIP(double p0, struct S_FIP p1,  double (*cb)(double, struct S_FIP)) ;
+EXPORT double f10_D_DS_FFI(double p0, struct S_FFI p1,  double (*cb)(double, struct S_FFI)) ;
+EXPORT double f10_D_DS_FFF(double p0, struct S_FFF p1,  double (*cb)(double, struct S_FFF)) ;
+EXPORT double f10_D_DS_FFD(double p0, struct S_FFD p1,  double (*cb)(double, struct S_FFD)) ;
+EXPORT double f10_D_DS_FFP(double p0, struct S_FFP p1,  double (*cb)(double, struct S_FFP)) ;
+EXPORT double f10_D_DS_FDI(double p0, struct S_FDI p1,  double (*cb)(double, struct S_FDI)) ;
+EXPORT double f10_D_DS_FDF(double p0, struct S_FDF p1,  double (*cb)(double, struct S_FDF)) ;
+EXPORT double f10_D_DS_FDD(double p0, struct S_FDD p1,  double (*cb)(double, struct S_FDD)) ;
+EXPORT double f10_D_DS_FDP(double p0, struct S_FDP p1,  double (*cb)(double, struct S_FDP)) ;
+EXPORT double f10_D_DS_FPI(double p0, struct S_FPI p1,  double (*cb)(double, struct S_FPI)) ;
+EXPORT double f10_D_DS_FPF(double p0, struct S_FPF p1,  double (*cb)(double, struct S_FPF)) ;
+EXPORT double f10_D_DS_FPD(double p0, struct S_FPD p1,  double (*cb)(double, struct S_FPD)) ;
+EXPORT double f10_D_DS_FPP(double p0, struct S_FPP p1,  double (*cb)(double, struct S_FPP)) ;
+EXPORT double f10_D_DS_DII(double p0, struct S_DII p1,  double (*cb)(double, struct S_DII)) ;
+EXPORT double f10_D_DS_DIF(double p0, struct S_DIF p1,  double (*cb)(double, struct S_DIF)) ;
+EXPORT double f10_D_DS_DID(double p0, struct S_DID p1,  double (*cb)(double, struct S_DID)) ;
+EXPORT double f10_D_DS_DIP(double p0, struct S_DIP p1,  double (*cb)(double, struct S_DIP)) ;
+EXPORT double f10_D_DS_DFI(double p0, struct S_DFI p1,  double (*cb)(double, struct S_DFI)) ;
+EXPORT double f10_D_DS_DFF(double p0, struct S_DFF p1,  double (*cb)(double, struct S_DFF)) ;
+EXPORT double f10_D_DS_DFD(double p0, struct S_DFD p1,  double (*cb)(double, struct S_DFD)) ;
+EXPORT double f10_D_DS_DFP(double p0, struct S_DFP p1,  double (*cb)(double, struct S_DFP)) ;
+EXPORT double f10_D_DS_DDI(double p0, struct S_DDI p1,  double (*cb)(double, struct S_DDI)) ;
+EXPORT double f10_D_DS_DDF(double p0, struct S_DDF p1,  double (*cb)(double, struct S_DDF)) ;
+EXPORT double f10_D_DS_DDD(double p0, struct S_DDD p1,  double (*cb)(double, struct S_DDD)) ;
+EXPORT double f10_D_DS_DDP(double p0, struct S_DDP p1,  double (*cb)(double, struct S_DDP)) ;
+EXPORT double f10_D_DS_DPI(double p0, struct S_DPI p1,  double (*cb)(double, struct S_DPI)) ;
+EXPORT double f10_D_DS_DPF(double p0, struct S_DPF p1,  double (*cb)(double, struct S_DPF)) ;
+EXPORT double f10_D_DS_DPD(double p0, struct S_DPD p1,  double (*cb)(double, struct S_DPD)) ;
+EXPORT double f10_D_DS_DPP(double p0, struct S_DPP p1,  double (*cb)(double, struct S_DPP)) ;
+EXPORT double f10_D_DS_PII(double p0, struct S_PII p1,  double (*cb)(double, struct S_PII)) ;
+EXPORT double f10_D_DS_PIF(double p0, struct S_PIF p1,  double (*cb)(double, struct S_PIF)) ;
+EXPORT double f10_D_DS_PID(double p0, struct S_PID p1,  double (*cb)(double, struct S_PID)) ;
+EXPORT double f10_D_DS_PIP(double p0, struct S_PIP p1,  double (*cb)(double, struct S_PIP)) ;
+EXPORT double f10_D_DS_PFI(double p0, struct S_PFI p1,  double (*cb)(double, struct S_PFI)) ;
+EXPORT double f10_D_DS_PFF(double p0, struct S_PFF p1,  double (*cb)(double, struct S_PFF)) ;
+EXPORT double f10_D_DS_PFD(double p0, struct S_PFD p1,  double (*cb)(double, struct S_PFD)) ;
+EXPORT double f10_D_DS_PFP(double p0, struct S_PFP p1,  double (*cb)(double, struct S_PFP)) ;
+EXPORT double f10_D_DS_PDI(double p0, struct S_PDI p1,  double (*cb)(double, struct S_PDI)) ;
+EXPORT double f10_D_DS_PDF(double p0, struct S_PDF p1,  double (*cb)(double, struct S_PDF)) ;
+EXPORT double f10_D_DS_PDD(double p0, struct S_PDD p1,  double (*cb)(double, struct S_PDD)) ;
+EXPORT double f10_D_DS_PDP(double p0, struct S_PDP p1,  double (*cb)(double, struct S_PDP)) ;
+EXPORT double f10_D_DS_PPI(double p0, struct S_PPI p1,  double (*cb)(double, struct S_PPI)) ;
+EXPORT double f10_D_DS_PPF(double p0, struct S_PPF p1,  double (*cb)(double, struct S_PPF)) ;
+EXPORT double f10_D_DS_PPD(double p0, struct S_PPD p1,  double (*cb)(double, struct S_PPD)) ;
+EXPORT double f10_D_DS_PPP(double p0, struct S_PPP p1,  double (*cb)(double, struct S_PPP)) ;
+EXPORT void* f10_P_PI_(void* p0, int p1,  void* (*cb)(void*, int)) ;
+EXPORT void* f10_P_PF_(void* p0, float p1,  void* (*cb)(void*, float)) ;
+EXPORT void* f10_P_PD_(void* p0, double p1,  void* (*cb)(void*, double)) ;
+EXPORT void* f10_P_PP_(void* p0, void* p1,  void* (*cb)(void*, void*)) ;
+EXPORT void* f10_P_PS_I(void* p0, struct S_I p1,  void* (*cb)(void*, struct S_I)) ;
+EXPORT void* f10_P_PS_F(void* p0, struct S_F p1,  void* (*cb)(void*, struct S_F)) ;
+EXPORT void* f10_P_PS_D(void* p0, struct S_D p1,  void* (*cb)(void*, struct S_D)) ;
+EXPORT void* f10_P_PS_P(void* p0, struct S_P p1,  void* (*cb)(void*, struct S_P)) ;
+EXPORT void* f10_P_PS_II(void* p0, struct S_II p1,  void* (*cb)(void*, struct S_II)) ;
+EXPORT void* f10_P_PS_IF(void* p0, struct S_IF p1,  void* (*cb)(void*, struct S_IF)) ;
+EXPORT void* f10_P_PS_ID(void* p0, struct S_ID p1,  void* (*cb)(void*, struct S_ID)) ;
+EXPORT void* f10_P_PS_IP(void* p0, struct S_IP p1,  void* (*cb)(void*, struct S_IP)) ;
+EXPORT void* f10_P_PS_FI(void* p0, struct S_FI p1,  void* (*cb)(void*, struct S_FI)) ;
+EXPORT void* f10_P_PS_FF(void* p0, struct S_FF p1,  void* (*cb)(void*, struct S_FF)) ;
+EXPORT void* f10_P_PS_FD(void* p0, struct S_FD p1,  void* (*cb)(void*, struct S_FD)) ;
+EXPORT void* f10_P_PS_FP(void* p0, struct S_FP p1,  void* (*cb)(void*, struct S_FP)) ;
+EXPORT void* f10_P_PS_DI(void* p0, struct S_DI p1,  void* (*cb)(void*, struct S_DI)) ;
+EXPORT void* f10_P_PS_DF(void* p0, struct S_DF p1,  void* (*cb)(void*, struct S_DF)) ;
+EXPORT void* f10_P_PS_DD(void* p0, struct S_DD p1,  void* (*cb)(void*, struct S_DD)) ;
+EXPORT void* f10_P_PS_DP(void* p0, struct S_DP p1,  void* (*cb)(void*, struct S_DP)) ;
+EXPORT void* f10_P_PS_PI(void* p0, struct S_PI p1,  void* (*cb)(void*, struct S_PI)) ;
+EXPORT void* f10_P_PS_PF(void* p0, struct S_PF p1,  void* (*cb)(void*, struct S_PF)) ;
+EXPORT void* f10_P_PS_PD(void* p0, struct S_PD p1,  void* (*cb)(void*, struct S_PD)) ;
+EXPORT void* f10_P_PS_PP(void* p0, struct S_PP p1,  void* (*cb)(void*, struct S_PP)) ;
+EXPORT void* f10_P_PS_III(void* p0, struct S_III p1,  void* (*cb)(void*, struct S_III)) ;
+EXPORT void* f10_P_PS_IIF(void* p0, struct S_IIF p1,  void* (*cb)(void*, struct S_IIF)) ;
+EXPORT void* f10_P_PS_IID(void* p0, struct S_IID p1,  void* (*cb)(void*, struct S_IID)) ;
+EXPORT void* f10_P_PS_IIP(void* p0, struct S_IIP p1,  void* (*cb)(void*, struct S_IIP)) ;
+EXPORT void* f10_P_PS_IFI(void* p0, struct S_IFI p1,  void* (*cb)(void*, struct S_IFI)) ;
+EXPORT void* f10_P_PS_IFF(void* p0, struct S_IFF p1,  void* (*cb)(void*, struct S_IFF)) ;
+EXPORT void* f10_P_PS_IFD(void* p0, struct S_IFD p1,  void* (*cb)(void*, struct S_IFD)) ;
+EXPORT void* f10_P_PS_IFP(void* p0, struct S_IFP p1,  void* (*cb)(void*, struct S_IFP)) ;
+EXPORT void* f10_P_PS_IDI(void* p0, struct S_IDI p1,  void* (*cb)(void*, struct S_IDI)) ;
+EXPORT void* f10_P_PS_IDF(void* p0, struct S_IDF p1,  void* (*cb)(void*, struct S_IDF)) ;
+EXPORT void* f10_P_PS_IDD(void* p0, struct S_IDD p1,  void* (*cb)(void*, struct S_IDD)) ;
+EXPORT void* f10_P_PS_IDP(void* p0, struct S_IDP p1,  void* (*cb)(void*, struct S_IDP)) ;
+EXPORT void* f10_P_PS_IPI(void* p0, struct S_IPI p1,  void* (*cb)(void*, struct S_IPI)) ;
+EXPORT void* f10_P_PS_IPF(void* p0, struct S_IPF p1,  void* (*cb)(void*, struct S_IPF)) ;
+EXPORT void* f10_P_PS_IPD(void* p0, struct S_IPD p1,  void* (*cb)(void*, struct S_IPD)) ;
+EXPORT void* f10_P_PS_IPP(void* p0, struct S_IPP p1,  void* (*cb)(void*, struct S_IPP)) ;
+EXPORT void* f10_P_PS_FII(void* p0, struct S_FII p1,  void* (*cb)(void*, struct S_FII)) ;
+EXPORT void* f10_P_PS_FIF(void* p0, struct S_FIF p1,  void* (*cb)(void*, struct S_FIF)) ;
+EXPORT void* f10_P_PS_FID(void* p0, struct S_FID p1,  void* (*cb)(void*, struct S_FID)) ;
+EXPORT void* f10_P_PS_FIP(void* p0, struct S_FIP p1,  void* (*cb)(void*, struct S_FIP)) ;
+EXPORT void* f10_P_PS_FFI(void* p0, struct S_FFI p1,  void* (*cb)(void*, struct S_FFI)) ;
+EXPORT void* f10_P_PS_FFF(void* p0, struct S_FFF p1,  void* (*cb)(void*, struct S_FFF)) ;
+EXPORT void* f10_P_PS_FFD(void* p0, struct S_FFD p1,  void* (*cb)(void*, struct S_FFD)) ;
+EXPORT void* f10_P_PS_FFP(void* p0, struct S_FFP p1,  void* (*cb)(void*, struct S_FFP)) ;
+EXPORT void* f10_P_PS_FDI(void* p0, struct S_FDI p1,  void* (*cb)(void*, struct S_FDI)) ;
+EXPORT void* f10_P_PS_FDF(void* p0, struct S_FDF p1,  void* (*cb)(void*, struct S_FDF)) ;
+EXPORT void* f10_P_PS_FDD(void* p0, struct S_FDD p1,  void* (*cb)(void*, struct S_FDD)) ;
+EXPORT void* f10_P_PS_FDP(void* p0, struct S_FDP p1,  void* (*cb)(void*, struct S_FDP)) ;
+EXPORT void* f10_P_PS_FPI(void* p0, struct S_FPI p1,  void* (*cb)(void*, struct S_FPI)) ;
+EXPORT void* f10_P_PS_FPF(void* p0, struct S_FPF p1,  void* (*cb)(void*, struct S_FPF)) ;
+EXPORT void* f10_P_PS_FPD(void* p0, struct S_FPD p1,  void* (*cb)(void*, struct S_FPD)) ;
+EXPORT void* f10_P_PS_FPP(void* p0, struct S_FPP p1,  void* (*cb)(void*, struct S_FPP)) ;
+EXPORT void* f10_P_PS_DII(void* p0, struct S_DII p1,  void* (*cb)(void*, struct S_DII)) ;
+EXPORT void* f10_P_PS_DIF(void* p0, struct S_DIF p1,  void* (*cb)(void*, struct S_DIF)) ;
+EXPORT void* f10_P_PS_DID(void* p0, struct S_DID p1,  void* (*cb)(void*, struct S_DID)) ;
+EXPORT void* f10_P_PS_DIP(void* p0, struct S_DIP p1,  void* (*cb)(void*, struct S_DIP)) ;
+EXPORT void* f10_P_PS_DFI(void* p0, struct S_DFI p1,  void* (*cb)(void*, struct S_DFI)) ;
+EXPORT void* f10_P_PS_DFF(void* p0, struct S_DFF p1,  void* (*cb)(void*, struct S_DFF)) ;
+EXPORT void* f10_P_PS_DFD(void* p0, struct S_DFD p1,  void* (*cb)(void*, struct S_DFD)) ;
+EXPORT void* f10_P_PS_DFP(void* p0, struct S_DFP p1,  void* (*cb)(void*, struct S_DFP)) ;
+EXPORT void* f10_P_PS_DDI(void* p0, struct S_DDI p1,  void* (*cb)(void*, struct S_DDI)) ;
+EXPORT void* f10_P_PS_DDF(void* p0, struct S_DDF p1,  void* (*cb)(void*, struct S_DDF)) ;
+EXPORT void* f10_P_PS_DDD(void* p0, struct S_DDD p1,  void* (*cb)(void*, struct S_DDD)) ;
+EXPORT void* f10_P_PS_DDP(void* p0, struct S_DDP p1,  void* (*cb)(void*, struct S_DDP)) ;
+EXPORT void* f10_P_PS_DPI(void* p0, struct S_DPI p1,  void* (*cb)(void*, struct S_DPI)) ;
+EXPORT void* f10_P_PS_DPF(void* p0, struct S_DPF p1,  void* (*cb)(void*, struct S_DPF)) ;
+EXPORT void* f10_P_PS_DPD(void* p0, struct S_DPD p1,  void* (*cb)(void*, struct S_DPD)) ;
+EXPORT void* f10_P_PS_DPP(void* p0, struct S_DPP p1,  void* (*cb)(void*, struct S_DPP)) ;
+EXPORT void* f10_P_PS_PII(void* p0, struct S_PII p1,  void* (*cb)(void*, struct S_PII)) ;
+EXPORT void* f10_P_PS_PIF(void* p0, struct S_PIF p1,  void* (*cb)(void*, struct S_PIF)) ;
+EXPORT void* f10_P_PS_PID(void* p0, struct S_PID p1,  void* (*cb)(void*, struct S_PID)) ;
+EXPORT void* f10_P_PS_PIP(void* p0, struct S_PIP p1,  void* (*cb)(void*, struct S_PIP)) ;
+EXPORT void* f10_P_PS_PFI(void* p0, struct S_PFI p1,  void* (*cb)(void*, struct S_PFI)) ;
+EXPORT void* f10_P_PS_PFF(void* p0, struct S_PFF p1,  void* (*cb)(void*, struct S_PFF)) ;
+EXPORT void* f10_P_PS_PFD(void* p0, struct S_PFD p1,  void* (*cb)(void*, struct S_PFD)) ;
+EXPORT void* f10_P_PS_PFP(void* p0, struct S_PFP p1,  void* (*cb)(void*, struct S_PFP)) ;
+EXPORT void* f10_P_PS_PDI(void* p0, struct S_PDI p1,  void* (*cb)(void*, struct S_PDI)) ;
+EXPORT void* f10_P_PS_PDF(void* p0, struct S_PDF p1,  void* (*cb)(void*, struct S_PDF)) ;
+EXPORT void* f10_P_PS_PDD(void* p0, struct S_PDD p1,  void* (*cb)(void*, struct S_PDD)) ;
+EXPORT void* f10_P_PS_PDP(void* p0, struct S_PDP p1,  void* (*cb)(void*, struct S_PDP)) ;
+EXPORT void* f10_P_PS_PPI(void* p0, struct S_PPI p1,  void* (*cb)(void*, struct S_PPI)) ;
+EXPORT void* f10_P_PS_PPF(void* p0, struct S_PPF p1,  void* (*cb)(void*, struct S_PPF)) ;
+EXPORT void* f10_P_PS_PPD(void* p0, struct S_PPD p1,  void* (*cb)(void*, struct S_PPD)) ;
+EXPORT void* f10_P_PS_PPP(void* p0, struct S_PPP p1,  void* (*cb)(void*, struct S_PPP)) ;
+EXPORT struct S_I f10_S_SI_I(struct S_I p0, int p1,  struct S_I (*cb)(struct S_I, int)) ;
+EXPORT struct S_F f10_S_SI_F(struct S_F p0, int p1,  struct S_F (*cb)(struct S_F, int)) ;
+EXPORT struct S_D f10_S_SI_D(struct S_D p0, int p1,  struct S_D (*cb)(struct S_D, int)) ;
+EXPORT struct S_P f10_S_SI_P(struct S_P p0, int p1,  struct S_P (*cb)(struct S_P, int)) ;
+EXPORT struct S_II f10_S_SI_II(struct S_II p0, int p1,  struct S_II (*cb)(struct S_II, int)) ;
+EXPORT struct S_IF f10_S_SI_IF(struct S_IF p0, int p1,  struct S_IF (*cb)(struct S_IF, int)) ;
+EXPORT struct S_ID f10_S_SI_ID(struct S_ID p0, int p1,  struct S_ID (*cb)(struct S_ID, int)) ;
+EXPORT struct S_IP f10_S_SI_IP(struct S_IP p0, int p1,  struct S_IP (*cb)(struct S_IP, int)) ;
+EXPORT struct S_FI f10_S_SI_FI(struct S_FI p0, int p1,  struct S_FI (*cb)(struct S_FI, int)) ;
+EXPORT struct S_FF f10_S_SI_FF(struct S_FF p0, int p1,  struct S_FF (*cb)(struct S_FF, int)) ;
+EXPORT struct S_FD f10_S_SI_FD(struct S_FD p0, int p1,  struct S_FD (*cb)(struct S_FD, int)) ;
+EXPORT struct S_FP f10_S_SI_FP(struct S_FP p0, int p1,  struct S_FP (*cb)(struct S_FP, int)) ;
+EXPORT struct S_DI f10_S_SI_DI(struct S_DI p0, int p1,  struct S_DI (*cb)(struct S_DI, int)) ;
+EXPORT struct S_DF f10_S_SI_DF(struct S_DF p0, int p1,  struct S_DF (*cb)(struct S_DF, int)) ;
+EXPORT struct S_DD f10_S_SI_DD(struct S_DD p0, int p1,  struct S_DD (*cb)(struct S_DD, int)) ;
+EXPORT struct S_DP f10_S_SI_DP(struct S_DP p0, int p1,  struct S_DP (*cb)(struct S_DP, int)) ;
+EXPORT struct S_PI f10_S_SI_PI(struct S_PI p0, int p1,  struct S_PI (*cb)(struct S_PI, int)) ;
+EXPORT struct S_PF f10_S_SI_PF(struct S_PF p0, int p1,  struct S_PF (*cb)(struct S_PF, int)) ;
+EXPORT struct S_PD f10_S_SI_PD(struct S_PD p0, int p1,  struct S_PD (*cb)(struct S_PD, int)) ;
+EXPORT struct S_PP f10_S_SI_PP(struct S_PP p0, int p1,  struct S_PP (*cb)(struct S_PP, int)) ;
+EXPORT struct S_III f10_S_SI_III(struct S_III p0, int p1,  struct S_III (*cb)(struct S_III, int)) ;
+EXPORT struct S_IIF f10_S_SI_IIF(struct S_IIF p0, int p1,  struct S_IIF (*cb)(struct S_IIF, int)) ;
+EXPORT struct S_IID f10_S_SI_IID(struct S_IID p0, int p1,  struct S_IID (*cb)(struct S_IID, int)) ;
+EXPORT struct S_IIP f10_S_SI_IIP(struct S_IIP p0, int p1,  struct S_IIP (*cb)(struct S_IIP, int)) ;
+EXPORT struct S_IFI f10_S_SI_IFI(struct S_IFI p0, int p1,  struct S_IFI (*cb)(struct S_IFI, int)) ;
+EXPORT struct S_IFF f10_S_SI_IFF(struct S_IFF p0, int p1,  struct S_IFF (*cb)(struct S_IFF, int)) ;
+EXPORT struct S_IFD f10_S_SI_IFD(struct S_IFD p0, int p1,  struct S_IFD (*cb)(struct S_IFD, int)) ;
+EXPORT struct S_IFP f10_S_SI_IFP(struct S_IFP p0, int p1,  struct S_IFP (*cb)(struct S_IFP, int)) ;
+EXPORT struct S_IDI f10_S_SI_IDI(struct S_IDI p0, int p1,  struct S_IDI (*cb)(struct S_IDI, int)) ;
+EXPORT struct S_IDF f10_S_SI_IDF(struct S_IDF p0, int p1,  struct S_IDF (*cb)(struct S_IDF, int)) ;
+EXPORT struct S_IDD f10_S_SI_IDD(struct S_IDD p0, int p1,  struct S_IDD (*cb)(struct S_IDD, int)) ;
+EXPORT struct S_IDP f10_S_SI_IDP(struct S_IDP p0, int p1,  struct S_IDP (*cb)(struct S_IDP, int)) ;
+EXPORT struct S_IPI f10_S_SI_IPI(struct S_IPI p0, int p1,  struct S_IPI (*cb)(struct S_IPI, int)) ;
+EXPORT struct S_IPF f10_S_SI_IPF(struct S_IPF p0, int p1,  struct S_IPF (*cb)(struct S_IPF, int)) ;
+EXPORT struct S_IPD f10_S_SI_IPD(struct S_IPD p0, int p1,  struct S_IPD (*cb)(struct S_IPD, int)) ;
+EXPORT struct S_IPP f10_S_SI_IPP(struct S_IPP p0, int p1,  struct S_IPP (*cb)(struct S_IPP, int)) ;
+EXPORT struct S_FII f10_S_SI_FII(struct S_FII p0, int p1,  struct S_FII (*cb)(struct S_FII, int)) ;
+EXPORT struct S_FIF f10_S_SI_FIF(struct S_FIF p0, int p1,  struct S_FIF (*cb)(struct S_FIF, int)) ;
+EXPORT struct S_FID f10_S_SI_FID(struct S_FID p0, int p1,  struct S_FID (*cb)(struct S_FID, int)) ;
+EXPORT struct S_FIP f10_S_SI_FIP(struct S_FIP p0, int p1,  struct S_FIP (*cb)(struct S_FIP, int)) ;
+EXPORT struct S_FFI f10_S_SI_FFI(struct S_FFI p0, int p1,  struct S_FFI (*cb)(struct S_FFI, int)) ;
+EXPORT struct S_FFF f10_S_SI_FFF(struct S_FFF p0, int p1,  struct S_FFF (*cb)(struct S_FFF, int)) ;
+EXPORT struct S_FFD f10_S_SI_FFD(struct S_FFD p0, int p1,  struct S_FFD (*cb)(struct S_FFD, int)) ;
+EXPORT struct S_FFP f10_S_SI_FFP(struct S_FFP p0, int p1,  struct S_FFP (*cb)(struct S_FFP, int)) ;
+EXPORT struct S_FDI f10_S_SI_FDI(struct S_FDI p0, int p1,  struct S_FDI (*cb)(struct S_FDI, int)) ;
+EXPORT struct S_FDF f10_S_SI_FDF(struct S_FDF p0, int p1,  struct S_FDF (*cb)(struct S_FDF, int)) ;
+EXPORT struct S_FDD f10_S_SI_FDD(struct S_FDD p0, int p1,  struct S_FDD (*cb)(struct S_FDD, int)) ;
+EXPORT struct S_FDP f10_S_SI_FDP(struct S_FDP p0, int p1,  struct S_FDP (*cb)(struct S_FDP, int)) ;
+EXPORT struct S_FPI f10_S_SI_FPI(struct S_FPI p0, int p1,  struct S_FPI (*cb)(struct S_FPI, int)) ;
+EXPORT struct S_FPF f10_S_SI_FPF(struct S_FPF p0, int p1,  struct S_FPF (*cb)(struct S_FPF, int)) ;
+EXPORT struct S_FPD f10_S_SI_FPD(struct S_FPD p0, int p1,  struct S_FPD (*cb)(struct S_FPD, int)) ;
+EXPORT struct S_FPP f10_S_SI_FPP(struct S_FPP p0, int p1,  struct S_FPP (*cb)(struct S_FPP, int)) ;
+EXPORT struct S_DII f10_S_SI_DII(struct S_DII p0, int p1,  struct S_DII (*cb)(struct S_DII, int)) ;
+EXPORT struct S_DIF f10_S_SI_DIF(struct S_DIF p0, int p1,  struct S_DIF (*cb)(struct S_DIF, int)) ;
+EXPORT struct S_DID f10_S_SI_DID(struct S_DID p0, int p1,  struct S_DID (*cb)(struct S_DID, int)) ;
+EXPORT struct S_DIP f10_S_SI_DIP(struct S_DIP p0, int p1,  struct S_DIP (*cb)(struct S_DIP, int)) ;
+EXPORT struct S_DFI f10_S_SI_DFI(struct S_DFI p0, int p1,  struct S_DFI (*cb)(struct S_DFI, int)) ;
+EXPORT struct S_DFF f10_S_SI_DFF(struct S_DFF p0, int p1,  struct S_DFF (*cb)(struct S_DFF, int)) ;
+EXPORT struct S_DFD f10_S_SI_DFD(struct S_DFD p0, int p1,  struct S_DFD (*cb)(struct S_DFD, int)) ;
+EXPORT struct S_DFP f10_S_SI_DFP(struct S_DFP p0, int p1,  struct S_DFP (*cb)(struct S_DFP, int)) ;
+EXPORT struct S_DDI f10_S_SI_DDI(struct S_DDI p0, int p1,  struct S_DDI (*cb)(struct S_DDI, int)) ;
+EXPORT struct S_DDF f10_S_SI_DDF(struct S_DDF p0, int p1,  struct S_DDF (*cb)(struct S_DDF, int)) ;
+EXPORT struct S_DDD f10_S_SI_DDD(struct S_DDD p0, int p1,  struct S_DDD (*cb)(struct S_DDD, int)) ;
+EXPORT struct S_DDP f10_S_SI_DDP(struct S_DDP p0, int p1,  struct S_DDP (*cb)(struct S_DDP, int)) ;
+EXPORT struct S_DPI f10_S_SI_DPI(struct S_DPI p0, int p1,  struct S_DPI (*cb)(struct S_DPI, int)) ;
+EXPORT struct S_DPF f10_S_SI_DPF(struct S_DPF p0, int p1,  struct S_DPF (*cb)(struct S_DPF, int)) ;
+EXPORT struct S_DPD f10_S_SI_DPD(struct S_DPD p0, int p1,  struct S_DPD (*cb)(struct S_DPD, int)) ;
+EXPORT struct S_DPP f10_S_SI_DPP(struct S_DPP p0, int p1,  struct S_DPP (*cb)(struct S_DPP, int)) ;
+EXPORT struct S_PII f10_S_SI_PII(struct S_PII p0, int p1,  struct S_PII (*cb)(struct S_PII, int)) ;
+EXPORT struct S_PIF f10_S_SI_PIF(struct S_PIF p0, int p1,  struct S_PIF (*cb)(struct S_PIF, int)) ;
+EXPORT struct S_PID f10_S_SI_PID(struct S_PID p0, int p1,  struct S_PID (*cb)(struct S_PID, int)) ;
+EXPORT struct S_PIP f10_S_SI_PIP(struct S_PIP p0, int p1,  struct S_PIP (*cb)(struct S_PIP, int)) ;
+EXPORT struct S_PFI f10_S_SI_PFI(struct S_PFI p0, int p1,  struct S_PFI (*cb)(struct S_PFI, int)) ;
+EXPORT struct S_PFF f10_S_SI_PFF(struct S_PFF p0, int p1,  struct S_PFF (*cb)(struct S_PFF, int)) ;
+EXPORT struct S_PFD f10_S_SI_PFD(struct S_PFD p0, int p1,  struct S_PFD (*cb)(struct S_PFD, int)) ;
+EXPORT struct S_PFP f10_S_SI_PFP(struct S_PFP p0, int p1,  struct S_PFP (*cb)(struct S_PFP, int)) ;
+EXPORT struct S_PDI f10_S_SI_PDI(struct S_PDI p0, int p1,  struct S_PDI (*cb)(struct S_PDI, int)) ;
+EXPORT struct S_PDF f10_S_SI_PDF(struct S_PDF p0, int p1,  struct S_PDF (*cb)(struct S_PDF, int)) ;
+EXPORT struct S_PDD f10_S_SI_PDD(struct S_PDD p0, int p1,  struct S_PDD (*cb)(struct S_PDD, int)) ;
+EXPORT struct S_PDP f10_S_SI_PDP(struct S_PDP p0, int p1,  struct S_PDP (*cb)(struct S_PDP, int)) ;
+EXPORT struct S_PPI f10_S_SI_PPI(struct S_PPI p0, int p1,  struct S_PPI (*cb)(struct S_PPI, int)) ;
+EXPORT struct S_PPF f10_S_SI_PPF(struct S_PPF p0, int p1,  struct S_PPF (*cb)(struct S_PPF, int)) ;
+EXPORT struct S_PPD f10_S_SI_PPD(struct S_PPD p0, int p1,  struct S_PPD (*cb)(struct S_PPD, int)) ;
+EXPORT struct S_PPP f10_S_SI_PPP(struct S_PPP p0, int p1,  struct S_PPP (*cb)(struct S_PPP, int)) ;
+EXPORT struct S_I f10_S_SF_I(struct S_I p0, float p1,  struct S_I (*cb)(struct S_I, float)) ;
+EXPORT struct S_F f10_S_SF_F(struct S_F p0, float p1,  struct S_F (*cb)(struct S_F, float)) ;
+EXPORT struct S_D f10_S_SF_D(struct S_D p0, float p1,  struct S_D (*cb)(struct S_D, float)) ;
+EXPORT struct S_P f10_S_SF_P(struct S_P p0, float p1,  struct S_P (*cb)(struct S_P, float)) ;
+EXPORT struct S_II f10_S_SF_II(struct S_II p0, float p1,  struct S_II (*cb)(struct S_II, float)) ;
+EXPORT struct S_IF f10_S_SF_IF(struct S_IF p0, float p1,  struct S_IF (*cb)(struct S_IF, float)) ;
+EXPORT struct S_ID f10_S_SF_ID(struct S_ID p0, float p1,  struct S_ID (*cb)(struct S_ID, float)) ;
+EXPORT struct S_IP f10_S_SF_IP(struct S_IP p0, float p1,  struct S_IP (*cb)(struct S_IP, float)) ;
+EXPORT struct S_FI f10_S_SF_FI(struct S_FI p0, float p1,  struct S_FI (*cb)(struct S_FI, float)) ;
+EXPORT struct S_FF f10_S_SF_FF(struct S_FF p0, float p1,  struct S_FF (*cb)(struct S_FF, float)) ;
+EXPORT struct S_FD f10_S_SF_FD(struct S_FD p0, float p1,  struct S_FD (*cb)(struct S_FD, float)) ;
+EXPORT struct S_FP f10_S_SF_FP(struct S_FP p0, float p1,  struct S_FP (*cb)(struct S_FP, float)) ;
+EXPORT struct S_DI f10_S_SF_DI(struct S_DI p0, float p1,  struct S_DI (*cb)(struct S_DI, float)) ;
+EXPORT struct S_DF f10_S_SF_DF(struct S_DF p0, float p1,  struct S_DF (*cb)(struct S_DF, float)) ;
+EXPORT struct S_DD f10_S_SF_DD(struct S_DD p0, float p1,  struct S_DD (*cb)(struct S_DD, float)) ;
+EXPORT struct S_DP f10_S_SF_DP(struct S_DP p0, float p1,  struct S_DP (*cb)(struct S_DP, float)) ;
+EXPORT struct S_PI f10_S_SF_PI(struct S_PI p0, float p1,  struct S_PI (*cb)(struct S_PI, float)) ;
+EXPORT struct S_PF f10_S_SF_PF(struct S_PF p0, float p1,  struct S_PF (*cb)(struct S_PF, float)) ;
+EXPORT struct S_PD f10_S_SF_PD(struct S_PD p0, float p1,  struct S_PD (*cb)(struct S_PD, float)) ;
+EXPORT struct S_PP f10_S_SF_PP(struct S_PP p0, float p1,  struct S_PP (*cb)(struct S_PP, float)) ;
+EXPORT struct S_III f10_S_SF_III(struct S_III p0, float p1,  struct S_III (*cb)(struct S_III, float)) ;
+EXPORT struct S_IIF f10_S_SF_IIF(struct S_IIF p0, float p1,  struct S_IIF (*cb)(struct S_IIF, float)) ;
+EXPORT struct S_IID f10_S_SF_IID(struct S_IID p0, float p1,  struct S_IID (*cb)(struct S_IID, float)) ;
+EXPORT struct S_IIP f10_S_SF_IIP(struct S_IIP p0, float p1,  struct S_IIP (*cb)(struct S_IIP, float)) ;
+EXPORT struct S_IFI f10_S_SF_IFI(struct S_IFI p0, float p1,  struct S_IFI (*cb)(struct S_IFI, float)) ;
+EXPORT struct S_IFF f10_S_SF_IFF(struct S_IFF p0, float p1,  struct S_IFF (*cb)(struct S_IFF, float)) ;
+EXPORT struct S_IFD f10_S_SF_IFD(struct S_IFD p0, float p1,  struct S_IFD (*cb)(struct S_IFD, float)) ;
+EXPORT struct S_IFP f11_S_SF_IFP(struct S_IFP p0, float p1,  struct S_IFP (*cb)(struct S_IFP, float)) ;
+EXPORT struct S_IDI f11_S_SF_IDI(struct S_IDI p0, float p1,  struct S_IDI (*cb)(struct S_IDI, float)) ;
+EXPORT struct S_IDF f11_S_SF_IDF(struct S_IDF p0, float p1,  struct S_IDF (*cb)(struct S_IDF, float)) ;
+EXPORT struct S_IDD f11_S_SF_IDD(struct S_IDD p0, float p1,  struct S_IDD (*cb)(struct S_IDD, float)) ;
+EXPORT struct S_IDP f11_S_SF_IDP(struct S_IDP p0, float p1,  struct S_IDP (*cb)(struct S_IDP, float)) ;
+EXPORT struct S_IPI f11_S_SF_IPI(struct S_IPI p0, float p1,  struct S_IPI (*cb)(struct S_IPI, float)) ;
+EXPORT struct S_IPF f11_S_SF_IPF(struct S_IPF p0, float p1,  struct S_IPF (*cb)(struct S_IPF, float)) ;
+EXPORT struct S_IPD f11_S_SF_IPD(struct S_IPD p0, float p1,  struct S_IPD (*cb)(struct S_IPD, float)) ;
+EXPORT struct S_IPP f11_S_SF_IPP(struct S_IPP p0, float p1,  struct S_IPP (*cb)(struct S_IPP, float)) ;
+EXPORT struct S_FII f11_S_SF_FII(struct S_FII p0, float p1,  struct S_FII (*cb)(struct S_FII, float)) ;
+EXPORT struct S_FIF f11_S_SF_FIF(struct S_FIF p0, float p1,  struct S_FIF (*cb)(struct S_FIF, float)) ;
+EXPORT struct S_FID f11_S_SF_FID(struct S_FID p0, float p1,  struct S_FID (*cb)(struct S_FID, float)) ;
+EXPORT struct S_FIP f11_S_SF_FIP(struct S_FIP p0, float p1,  struct S_FIP (*cb)(struct S_FIP, float)) ;
+EXPORT struct S_FFI f11_S_SF_FFI(struct S_FFI p0, float p1,  struct S_FFI (*cb)(struct S_FFI, float)) ;
+EXPORT struct S_FFF f11_S_SF_FFF(struct S_FFF p0, float p1,  struct S_FFF (*cb)(struct S_FFF, float)) ;
+EXPORT struct S_FFD f11_S_SF_FFD(struct S_FFD p0, float p1,  struct S_FFD (*cb)(struct S_FFD, float)) ;
+EXPORT struct S_FFP f11_S_SF_FFP(struct S_FFP p0, float p1,  struct S_FFP (*cb)(struct S_FFP, float)) ;
+EXPORT struct S_FDI f11_S_SF_FDI(struct S_FDI p0, float p1,  struct S_FDI (*cb)(struct S_FDI, float)) ;
+EXPORT struct S_FDF f11_S_SF_FDF(struct S_FDF p0, float p1,  struct S_FDF (*cb)(struct S_FDF, float)) ;
+EXPORT struct S_FDD f11_S_SF_FDD(struct S_FDD p0, float p1,  struct S_FDD (*cb)(struct S_FDD, float)) ;
+EXPORT struct S_FDP f11_S_SF_FDP(struct S_FDP p0, float p1,  struct S_FDP (*cb)(struct S_FDP, float)) ;
+EXPORT struct S_FPI f11_S_SF_FPI(struct S_FPI p0, float p1,  struct S_FPI (*cb)(struct S_FPI, float)) ;
+EXPORT struct S_FPF f11_S_SF_FPF(struct S_FPF p0, float p1,  struct S_FPF (*cb)(struct S_FPF, float)) ;
+EXPORT struct S_FPD f11_S_SF_FPD(struct S_FPD p0, float p1,  struct S_FPD (*cb)(struct S_FPD, float)) ;
+EXPORT struct S_FPP f11_S_SF_FPP(struct S_FPP p0, float p1,  struct S_FPP (*cb)(struct S_FPP, float)) ;
+EXPORT struct S_DII f11_S_SF_DII(struct S_DII p0, float p1,  struct S_DII (*cb)(struct S_DII, float)) ;
+EXPORT struct S_DIF f11_S_SF_DIF(struct S_DIF p0, float p1,  struct S_DIF (*cb)(struct S_DIF, float)) ;
+EXPORT struct S_DID f11_S_SF_DID(struct S_DID p0, float p1,  struct S_DID (*cb)(struct S_DID, float)) ;
+EXPORT struct S_DIP f11_S_SF_DIP(struct S_DIP p0, float p1,  struct S_DIP (*cb)(struct S_DIP, float)) ;
+EXPORT struct S_DFI f11_S_SF_DFI(struct S_DFI p0, float p1,  struct S_DFI (*cb)(struct S_DFI, float)) ;
+EXPORT struct S_DFF f11_S_SF_DFF(struct S_DFF p0, float p1,  struct S_DFF (*cb)(struct S_DFF, float)) ;
+EXPORT struct S_DFD f11_S_SF_DFD(struct S_DFD p0, float p1,  struct S_DFD (*cb)(struct S_DFD, float)) ;
+EXPORT struct S_DFP f11_S_SF_DFP(struct S_DFP p0, float p1,  struct S_DFP (*cb)(struct S_DFP, float)) ;
+EXPORT struct S_DDI f11_S_SF_DDI(struct S_DDI p0, float p1,  struct S_DDI (*cb)(struct S_DDI, float)) ;
+EXPORT struct S_DDF f11_S_SF_DDF(struct S_DDF p0, float p1,  struct S_DDF (*cb)(struct S_DDF, float)) ;
+EXPORT struct S_DDD f11_S_SF_DDD(struct S_DDD p0, float p1,  struct S_DDD (*cb)(struct S_DDD, float)) ;
+EXPORT struct S_DDP f11_S_SF_DDP(struct S_DDP p0, float p1,  struct S_DDP (*cb)(struct S_DDP, float)) ;
+EXPORT struct S_DPI f11_S_SF_DPI(struct S_DPI p0, float p1,  struct S_DPI (*cb)(struct S_DPI, float)) ;
+EXPORT struct S_DPF f11_S_SF_DPF(struct S_DPF p0, float p1,  struct S_DPF (*cb)(struct S_DPF, float)) ;
+EXPORT struct S_DPD f11_S_SF_DPD(struct S_DPD p0, float p1,  struct S_DPD (*cb)(struct S_DPD, float)) ;
+EXPORT struct S_DPP f11_S_SF_DPP(struct S_DPP p0, float p1,  struct S_DPP (*cb)(struct S_DPP, float)) ;
+EXPORT struct S_PII f11_S_SF_PII(struct S_PII p0, float p1,  struct S_PII (*cb)(struct S_PII, float)) ;
+EXPORT struct S_PIF f11_S_SF_PIF(struct S_PIF p0, float p1,  struct S_PIF (*cb)(struct S_PIF, float)) ;
+EXPORT struct S_PID f11_S_SF_PID(struct S_PID p0, float p1,  struct S_PID (*cb)(struct S_PID, float)) ;
+EXPORT struct S_PIP f11_S_SF_PIP(struct S_PIP p0, float p1,  struct S_PIP (*cb)(struct S_PIP, float)) ;
+EXPORT struct S_PFI f11_S_SF_PFI(struct S_PFI p0, float p1,  struct S_PFI (*cb)(struct S_PFI, float)) ;
+EXPORT struct S_PFF f11_S_SF_PFF(struct S_PFF p0, float p1,  struct S_PFF (*cb)(struct S_PFF, float)) ;
+EXPORT struct S_PFD f11_S_SF_PFD(struct S_PFD p0, float p1,  struct S_PFD (*cb)(struct S_PFD, float)) ;
+EXPORT struct S_PFP f11_S_SF_PFP(struct S_PFP p0, float p1,  struct S_PFP (*cb)(struct S_PFP, float)) ;
+EXPORT struct S_PDI f11_S_SF_PDI(struct S_PDI p0, float p1,  struct S_PDI (*cb)(struct S_PDI, float)) ;
+EXPORT struct S_PDF f11_S_SF_PDF(struct S_PDF p0, float p1,  struct S_PDF (*cb)(struct S_PDF, float)) ;
+EXPORT struct S_PDD f11_S_SF_PDD(struct S_PDD p0, float p1,  struct S_PDD (*cb)(struct S_PDD, float)) ;
+EXPORT struct S_PDP f11_S_SF_PDP(struct S_PDP p0, float p1,  struct S_PDP (*cb)(struct S_PDP, float)) ;
+EXPORT struct S_PPI f11_S_SF_PPI(struct S_PPI p0, float p1,  struct S_PPI (*cb)(struct S_PPI, float)) ;
+EXPORT struct S_PPF f11_S_SF_PPF(struct S_PPF p0, float p1,  struct S_PPF (*cb)(struct S_PPF, float)) ;
+EXPORT struct S_PPD f11_S_SF_PPD(struct S_PPD p0, float p1,  struct S_PPD (*cb)(struct S_PPD, float)) ;
+EXPORT struct S_PPP f11_S_SF_PPP(struct S_PPP p0, float p1,  struct S_PPP (*cb)(struct S_PPP, float)) ;
+EXPORT struct S_I f11_S_SD_I(struct S_I p0, double p1,  struct S_I (*cb)(struct S_I, double)) ;
+EXPORT struct S_F f11_S_SD_F(struct S_F p0, double p1,  struct S_F (*cb)(struct S_F, double)) ;
+EXPORT struct S_D f11_S_SD_D(struct S_D p0, double p1,  struct S_D (*cb)(struct S_D, double)) ;
+EXPORT struct S_P f11_S_SD_P(struct S_P p0, double p1,  struct S_P (*cb)(struct S_P, double)) ;
+EXPORT struct S_II f11_S_SD_II(struct S_II p0, double p1,  struct S_II (*cb)(struct S_II, double)) ;
+EXPORT struct S_IF f11_S_SD_IF(struct S_IF p0, double p1,  struct S_IF (*cb)(struct S_IF, double)) ;
+EXPORT struct S_ID f11_S_SD_ID(struct S_ID p0, double p1,  struct S_ID (*cb)(struct S_ID, double)) ;
+EXPORT struct S_IP f11_S_SD_IP(struct S_IP p0, double p1,  struct S_IP (*cb)(struct S_IP, double)) ;
+EXPORT struct S_FI f11_S_SD_FI(struct S_FI p0, double p1,  struct S_FI (*cb)(struct S_FI, double)) ;
+EXPORT struct S_FF f11_S_SD_FF(struct S_FF p0, double p1,  struct S_FF (*cb)(struct S_FF, double)) ;
+EXPORT struct S_FD f11_S_SD_FD(struct S_FD p0, double p1,  struct S_FD (*cb)(struct S_FD, double)) ;
+EXPORT struct S_FP f11_S_SD_FP(struct S_FP p0, double p1,  struct S_FP (*cb)(struct S_FP, double)) ;
+EXPORT struct S_DI f11_S_SD_DI(struct S_DI p0, double p1,  struct S_DI (*cb)(struct S_DI, double)) ;
+EXPORT struct S_DF f11_S_SD_DF(struct S_DF p0, double p1,  struct S_DF (*cb)(struct S_DF, double)) ;
+EXPORT struct S_DD f11_S_SD_DD(struct S_DD p0, double p1,  struct S_DD (*cb)(struct S_DD, double)) ;
+EXPORT struct S_DP f11_S_SD_DP(struct S_DP p0, double p1,  struct S_DP (*cb)(struct S_DP, double)) ;
+EXPORT struct S_PI f11_S_SD_PI(struct S_PI p0, double p1,  struct S_PI (*cb)(struct S_PI, double)) ;
+EXPORT struct S_PF f11_S_SD_PF(struct S_PF p0, double p1,  struct S_PF (*cb)(struct S_PF, double)) ;
+EXPORT struct S_PD f11_S_SD_PD(struct S_PD p0, double p1,  struct S_PD (*cb)(struct S_PD, double)) ;
+EXPORT struct S_PP f11_S_SD_PP(struct S_PP p0, double p1,  struct S_PP (*cb)(struct S_PP, double)) ;
+EXPORT struct S_III f11_S_SD_III(struct S_III p0, double p1,  struct S_III (*cb)(struct S_III, double)) ;
+EXPORT struct S_IIF f11_S_SD_IIF(struct S_IIF p0, double p1,  struct S_IIF (*cb)(struct S_IIF, double)) ;
+EXPORT struct S_IID f11_S_SD_IID(struct S_IID p0, double p1,  struct S_IID (*cb)(struct S_IID, double)) ;
+EXPORT struct S_IIP f11_S_SD_IIP(struct S_IIP p0, double p1,  struct S_IIP (*cb)(struct S_IIP, double)) ;
+EXPORT struct S_IFI f11_S_SD_IFI(struct S_IFI p0, double p1,  struct S_IFI (*cb)(struct S_IFI, double)) ;
+EXPORT struct S_IFF f11_S_SD_IFF(struct S_IFF p0, double p1,  struct S_IFF (*cb)(struct S_IFF, double)) ;
+EXPORT struct S_IFD f11_S_SD_IFD(struct S_IFD p0, double p1,  struct S_IFD (*cb)(struct S_IFD, double)) ;
+EXPORT struct S_IFP f11_S_SD_IFP(struct S_IFP p0, double p1,  struct S_IFP (*cb)(struct S_IFP, double)) ;
+EXPORT struct S_IDI f11_S_SD_IDI(struct S_IDI p0, double p1,  struct S_IDI (*cb)(struct S_IDI, double)) ;
+EXPORT struct S_IDF f11_S_SD_IDF(struct S_IDF p0, double p1,  struct S_IDF (*cb)(struct S_IDF, double)) ;
+EXPORT struct S_IDD f11_S_SD_IDD(struct S_IDD p0, double p1,  struct S_IDD (*cb)(struct S_IDD, double)) ;
+EXPORT struct S_IDP f11_S_SD_IDP(struct S_IDP p0, double p1,  struct S_IDP (*cb)(struct S_IDP, double)) ;
+EXPORT struct S_IPI f11_S_SD_IPI(struct S_IPI p0, double p1,  struct S_IPI (*cb)(struct S_IPI, double)) ;
+EXPORT struct S_IPF f11_S_SD_IPF(struct S_IPF p0, double p1,  struct S_IPF (*cb)(struct S_IPF, double)) ;
+EXPORT struct S_IPD f11_S_SD_IPD(struct S_IPD p0, double p1,  struct S_IPD (*cb)(struct S_IPD, double)) ;
+EXPORT struct S_IPP f11_S_SD_IPP(struct S_IPP p0, double p1,  struct S_IPP (*cb)(struct S_IPP, double)) ;
+EXPORT struct S_FII f11_S_SD_FII(struct S_FII p0, double p1,  struct S_FII (*cb)(struct S_FII, double)) ;
+EXPORT struct S_FIF f11_S_SD_FIF(struct S_FIF p0, double p1,  struct S_FIF (*cb)(struct S_FIF, double)) ;
+EXPORT struct S_FID f11_S_SD_FID(struct S_FID p0, double p1,  struct S_FID (*cb)(struct S_FID, double)) ;
+EXPORT struct S_FIP f11_S_SD_FIP(struct S_FIP p0, double p1,  struct S_FIP (*cb)(struct S_FIP, double)) ;
+EXPORT struct S_FFI f11_S_SD_FFI(struct S_FFI p0, double p1,  struct S_FFI (*cb)(struct S_FFI, double)) ;
+EXPORT struct S_FFF f11_S_SD_FFF(struct S_FFF p0, double p1,  struct S_FFF (*cb)(struct S_FFF, double)) ;
+EXPORT struct S_FFD f11_S_SD_FFD(struct S_FFD p0, double p1,  struct S_FFD (*cb)(struct S_FFD, double)) ;
+EXPORT struct S_FFP f11_S_SD_FFP(struct S_FFP p0, double p1,  struct S_FFP (*cb)(struct S_FFP, double)) ;
+EXPORT struct S_FDI f11_S_SD_FDI(struct S_FDI p0, double p1,  struct S_FDI (*cb)(struct S_FDI, double)) ;
+EXPORT struct S_FDF f11_S_SD_FDF(struct S_FDF p0, double p1,  struct S_FDF (*cb)(struct S_FDF, double)) ;
+EXPORT struct S_FDD f11_S_SD_FDD(struct S_FDD p0, double p1,  struct S_FDD (*cb)(struct S_FDD, double)) ;
+EXPORT struct S_FDP f11_S_SD_FDP(struct S_FDP p0, double p1,  struct S_FDP (*cb)(struct S_FDP, double)) ;
+EXPORT struct S_FPI f11_S_SD_FPI(struct S_FPI p0, double p1,  struct S_FPI (*cb)(struct S_FPI, double)) ;
+EXPORT struct S_FPF f11_S_SD_FPF(struct S_FPF p0, double p1,  struct S_FPF (*cb)(struct S_FPF, double)) ;
+EXPORT struct S_FPD f11_S_SD_FPD(struct S_FPD p0, double p1,  struct S_FPD (*cb)(struct S_FPD, double)) ;
+EXPORT struct S_FPP f11_S_SD_FPP(struct S_FPP p0, double p1,  struct S_FPP (*cb)(struct S_FPP, double)) ;
+EXPORT struct S_DII f11_S_SD_DII(struct S_DII p0, double p1,  struct S_DII (*cb)(struct S_DII, double)) ;
+EXPORT struct S_DIF f11_S_SD_DIF(struct S_DIF p0, double p1,  struct S_DIF (*cb)(struct S_DIF, double)) ;
+EXPORT struct S_DID f11_S_SD_DID(struct S_DID p0, double p1,  struct S_DID (*cb)(struct S_DID, double)) ;
+EXPORT struct S_DIP f11_S_SD_DIP(struct S_DIP p0, double p1,  struct S_DIP (*cb)(struct S_DIP, double)) ;
+EXPORT struct S_DFI f11_S_SD_DFI(struct S_DFI p0, double p1,  struct S_DFI (*cb)(struct S_DFI, double)) ;
+EXPORT struct S_DFF f11_S_SD_DFF(struct S_DFF p0, double p1,  struct S_DFF (*cb)(struct S_DFF, double)) ;
+EXPORT struct S_DFD f11_S_SD_DFD(struct S_DFD p0, double p1,  struct S_DFD (*cb)(struct S_DFD, double)) ;
+EXPORT struct S_DFP f11_S_SD_DFP(struct S_DFP p0, double p1,  struct S_DFP (*cb)(struct S_DFP, double)) ;
+EXPORT struct S_DDI f11_S_SD_DDI(struct S_DDI p0, double p1,  struct S_DDI (*cb)(struct S_DDI, double)) ;
+EXPORT struct S_DDF f11_S_SD_DDF(struct S_DDF p0, double p1,  struct S_DDF (*cb)(struct S_DDF, double)) ;
+EXPORT struct S_DDD f11_S_SD_DDD(struct S_DDD p0, double p1,  struct S_DDD (*cb)(struct S_DDD, double)) ;
+EXPORT struct S_DDP f11_S_SD_DDP(struct S_DDP p0, double p1,  struct S_DDP (*cb)(struct S_DDP, double)) ;
+EXPORT struct S_DPI f11_S_SD_DPI(struct S_DPI p0, double p1,  struct S_DPI (*cb)(struct S_DPI, double)) ;
+EXPORT struct S_DPF f11_S_SD_DPF(struct S_DPF p0, double p1,  struct S_DPF (*cb)(struct S_DPF, double)) ;
+EXPORT struct S_DPD f11_S_SD_DPD(struct S_DPD p0, double p1,  struct S_DPD (*cb)(struct S_DPD, double)) ;
+EXPORT struct S_DPP f11_S_SD_DPP(struct S_DPP p0, double p1,  struct S_DPP (*cb)(struct S_DPP, double)) ;
+EXPORT struct S_PII f11_S_SD_PII(struct S_PII p0, double p1,  struct S_PII (*cb)(struct S_PII, double)) ;
+EXPORT struct S_PIF f11_S_SD_PIF(struct S_PIF p0, double p1,  struct S_PIF (*cb)(struct S_PIF, double)) ;
+EXPORT struct S_PID f11_S_SD_PID(struct S_PID p0, double p1,  struct S_PID (*cb)(struct S_PID, double)) ;
+EXPORT struct S_PIP f11_S_SD_PIP(struct S_PIP p0, double p1,  struct S_PIP (*cb)(struct S_PIP, double)) ;
+EXPORT struct S_PFI f11_S_SD_PFI(struct S_PFI p0, double p1,  struct S_PFI (*cb)(struct S_PFI, double)) ;
+EXPORT struct S_PFF f11_S_SD_PFF(struct S_PFF p0, double p1,  struct S_PFF (*cb)(struct S_PFF, double)) ;
+EXPORT struct S_PFD f11_S_SD_PFD(struct S_PFD p0, double p1,  struct S_PFD (*cb)(struct S_PFD, double)) ;
+EXPORT struct S_PFP f11_S_SD_PFP(struct S_PFP p0, double p1,  struct S_PFP (*cb)(struct S_PFP, double)) ;
+EXPORT struct S_PDI f11_S_SD_PDI(struct S_PDI p0, double p1,  struct S_PDI (*cb)(struct S_PDI, double)) ;
+EXPORT struct S_PDF f11_S_SD_PDF(struct S_PDF p0, double p1,  struct S_PDF (*cb)(struct S_PDF, double)) ;
+EXPORT struct S_PDD f11_S_SD_PDD(struct S_PDD p0, double p1,  struct S_PDD (*cb)(struct S_PDD, double)) ;
+EXPORT struct S_PDP f11_S_SD_PDP(struct S_PDP p0, double p1,  struct S_PDP (*cb)(struct S_PDP, double)) ;
+EXPORT struct S_PPI f11_S_SD_PPI(struct S_PPI p0, double p1,  struct S_PPI (*cb)(struct S_PPI, double)) ;
+EXPORT struct S_PPF f11_S_SD_PPF(struct S_PPF p0, double p1,  struct S_PPF (*cb)(struct S_PPF, double)) ;
+EXPORT struct S_PPD f11_S_SD_PPD(struct S_PPD p0, double p1,  struct S_PPD (*cb)(struct S_PPD, double)) ;
+EXPORT struct S_PPP f11_S_SD_PPP(struct S_PPP p0, double p1,  struct S_PPP (*cb)(struct S_PPP, double)) ;
+EXPORT struct S_I f11_S_SP_I(struct S_I p0, void* p1,  struct S_I (*cb)(struct S_I, void*)) ;
+EXPORT struct S_F f11_S_SP_F(struct S_F p0, void* p1,  struct S_F (*cb)(struct S_F, void*)) ;
+EXPORT struct S_D f11_S_SP_D(struct S_D p0, void* p1,  struct S_D (*cb)(struct S_D, void*)) ;
+EXPORT struct S_P f11_S_SP_P(struct S_P p0, void* p1,  struct S_P (*cb)(struct S_P, void*)) ;
+EXPORT struct S_II f11_S_SP_II(struct S_II p0, void* p1,  struct S_II (*cb)(struct S_II, void*)) ;
+EXPORT struct S_IF f11_S_SP_IF(struct S_IF p0, void* p1,  struct S_IF (*cb)(struct S_IF, void*)) ;
+EXPORT struct S_ID f11_S_SP_ID(struct S_ID p0, void* p1,  struct S_ID (*cb)(struct S_ID, void*)) ;
+EXPORT struct S_IP f11_S_SP_IP(struct S_IP p0, void* p1,  struct S_IP (*cb)(struct S_IP, void*)) ;
+EXPORT struct S_FI f11_S_SP_FI(struct S_FI p0, void* p1,  struct S_FI (*cb)(struct S_FI, void*)) ;
+EXPORT struct S_FF f11_S_SP_FF(struct S_FF p0, void* p1,  struct S_FF (*cb)(struct S_FF, void*)) ;
+EXPORT struct S_FD f11_S_SP_FD(struct S_FD p0, void* p1,  struct S_FD (*cb)(struct S_FD, void*)) ;
+EXPORT struct S_FP f11_S_SP_FP(struct S_FP p0, void* p1,  struct S_FP (*cb)(struct S_FP, void*)) ;
+EXPORT struct S_DI f11_S_SP_DI(struct S_DI p0, void* p1,  struct S_DI (*cb)(struct S_DI, void*)) ;
+EXPORT struct S_DF f11_S_SP_DF(struct S_DF p0, void* p1,  struct S_DF (*cb)(struct S_DF, void*)) ;
+EXPORT struct S_DD f11_S_SP_DD(struct S_DD p0, void* p1,  struct S_DD (*cb)(struct S_DD, void*)) ;
+EXPORT struct S_DP f11_S_SP_DP(struct S_DP p0, void* p1,  struct S_DP (*cb)(struct S_DP, void*)) ;
+EXPORT struct S_PI f11_S_SP_PI(struct S_PI p0, void* p1,  struct S_PI (*cb)(struct S_PI, void*)) ;
+EXPORT struct S_PF f11_S_SP_PF(struct S_PF p0, void* p1,  struct S_PF (*cb)(struct S_PF, void*)) ;
+EXPORT struct S_PD f11_S_SP_PD(struct S_PD p0, void* p1,  struct S_PD (*cb)(struct S_PD, void*)) ;
+EXPORT struct S_PP f11_S_SP_PP(struct S_PP p0, void* p1,  struct S_PP (*cb)(struct S_PP, void*)) ;
+EXPORT struct S_III f11_S_SP_III(struct S_III p0, void* p1,  struct S_III (*cb)(struct S_III, void*)) ;
+EXPORT struct S_IIF f11_S_SP_IIF(struct S_IIF p0, void* p1,  struct S_IIF (*cb)(struct S_IIF, void*)) ;
+EXPORT struct S_IID f11_S_SP_IID(struct S_IID p0, void* p1,  struct S_IID (*cb)(struct S_IID, void*)) ;
+EXPORT struct S_IIP f11_S_SP_IIP(struct S_IIP p0, void* p1,  struct S_IIP (*cb)(struct S_IIP, void*)) ;
+EXPORT struct S_IFI f11_S_SP_IFI(struct S_IFI p0, void* p1,  struct S_IFI (*cb)(struct S_IFI, void*)) ;
+EXPORT struct S_IFF f11_S_SP_IFF(struct S_IFF p0, void* p1,  struct S_IFF (*cb)(struct S_IFF, void*)) ;
+EXPORT struct S_IFD f11_S_SP_IFD(struct S_IFD p0, void* p1,  struct S_IFD (*cb)(struct S_IFD, void*)) ;
+EXPORT struct S_IFP f11_S_SP_IFP(struct S_IFP p0, void* p1,  struct S_IFP (*cb)(struct S_IFP, void*)) ;
+EXPORT struct S_IDI f11_S_SP_IDI(struct S_IDI p0, void* p1,  struct S_IDI (*cb)(struct S_IDI, void*)) ;
+EXPORT struct S_IDF f11_S_SP_IDF(struct S_IDF p0, void* p1,  struct S_IDF (*cb)(struct S_IDF, void*)) ;
+EXPORT struct S_IDD f11_S_SP_IDD(struct S_IDD p0, void* p1,  struct S_IDD (*cb)(struct S_IDD, void*)) ;
+EXPORT struct S_IDP f11_S_SP_IDP(struct S_IDP p0, void* p1,  struct S_IDP (*cb)(struct S_IDP, void*)) ;
+EXPORT struct S_IPI f11_S_SP_IPI(struct S_IPI p0, void* p1,  struct S_IPI (*cb)(struct S_IPI, void*)) ;
+EXPORT struct S_IPF f11_S_SP_IPF(struct S_IPF p0, void* p1,  struct S_IPF (*cb)(struct S_IPF, void*)) ;
+EXPORT struct S_IPD f11_S_SP_IPD(struct S_IPD p0, void* p1,  struct S_IPD (*cb)(struct S_IPD, void*)) ;
+EXPORT struct S_IPP f11_S_SP_IPP(struct S_IPP p0, void* p1,  struct S_IPP (*cb)(struct S_IPP, void*)) ;
+EXPORT struct S_FII f11_S_SP_FII(struct S_FII p0, void* p1,  struct S_FII (*cb)(struct S_FII, void*)) ;
+EXPORT struct S_FIF f11_S_SP_FIF(struct S_FIF p0, void* p1,  struct S_FIF (*cb)(struct S_FIF, void*)) ;
+EXPORT struct S_FID f11_S_SP_FID(struct S_FID p0, void* p1,  struct S_FID (*cb)(struct S_FID, void*)) ;
+EXPORT struct S_FIP f11_S_SP_FIP(struct S_FIP p0, void* p1,  struct S_FIP (*cb)(struct S_FIP, void*)) ;
+EXPORT struct S_FFI f11_S_SP_FFI(struct S_FFI p0, void* p1,  struct S_FFI (*cb)(struct S_FFI, void*)) ;
+EXPORT struct S_FFF f11_S_SP_FFF(struct S_FFF p0, void* p1,  struct S_FFF (*cb)(struct S_FFF, void*)) ;
+EXPORT struct S_FFD f11_S_SP_FFD(struct S_FFD p0, void* p1,  struct S_FFD (*cb)(struct S_FFD, void*)) ;
+EXPORT struct S_FFP f11_S_SP_FFP(struct S_FFP p0, void* p1,  struct S_FFP (*cb)(struct S_FFP, void*)) ;
+EXPORT struct S_FDI f11_S_SP_FDI(struct S_FDI p0, void* p1,  struct S_FDI (*cb)(struct S_FDI, void*)) ;
+EXPORT struct S_FDF f11_S_SP_FDF(struct S_FDF p0, void* p1,  struct S_FDF (*cb)(struct S_FDF, void*)) ;
+EXPORT struct S_FDD f11_S_SP_FDD(struct S_FDD p0, void* p1,  struct S_FDD (*cb)(struct S_FDD, void*)) ;
+EXPORT struct S_FDP f11_S_SP_FDP(struct S_FDP p0, void* p1,  struct S_FDP (*cb)(struct S_FDP, void*)) ;
+EXPORT struct S_FPI f11_S_SP_FPI(struct S_FPI p0, void* p1,  struct S_FPI (*cb)(struct S_FPI, void*)) ;
+EXPORT struct S_FPF f11_S_SP_FPF(struct S_FPF p0, void* p1,  struct S_FPF (*cb)(struct S_FPF, void*)) ;
+EXPORT struct S_FPD f11_S_SP_FPD(struct S_FPD p0, void* p1,  struct S_FPD (*cb)(struct S_FPD, void*)) ;
+EXPORT struct S_FPP f11_S_SP_FPP(struct S_FPP p0, void* p1,  struct S_FPP (*cb)(struct S_FPP, void*)) ;
+EXPORT struct S_DII f11_S_SP_DII(struct S_DII p0, void* p1,  struct S_DII (*cb)(struct S_DII, void*)) ;
+EXPORT struct S_DIF f11_S_SP_DIF(struct S_DIF p0, void* p1,  struct S_DIF (*cb)(struct S_DIF, void*)) ;
+EXPORT struct S_DID f11_S_SP_DID(struct S_DID p0, void* p1,  struct S_DID (*cb)(struct S_DID, void*)) ;
+EXPORT struct S_DIP f11_S_SP_DIP(struct S_DIP p0, void* p1,  struct S_DIP (*cb)(struct S_DIP, void*)) ;
+EXPORT struct S_DFI f11_S_SP_DFI(struct S_DFI p0, void* p1,  struct S_DFI (*cb)(struct S_DFI, void*)) ;
+EXPORT struct S_DFF f11_S_SP_DFF(struct S_DFF p0, void* p1,  struct S_DFF (*cb)(struct S_DFF, void*)) ;
+EXPORT struct S_DFD f11_S_SP_DFD(struct S_DFD p0, void* p1,  struct S_DFD (*cb)(struct S_DFD, void*)) ;
+EXPORT struct S_DFP f11_S_SP_DFP(struct S_DFP p0, void* p1,  struct S_DFP (*cb)(struct S_DFP, void*)) ;
+EXPORT struct S_DDI f11_S_SP_DDI(struct S_DDI p0, void* p1,  struct S_DDI (*cb)(struct S_DDI, void*)) ;
+EXPORT struct S_DDF f11_S_SP_DDF(struct S_DDF p0, void* p1,  struct S_DDF (*cb)(struct S_DDF, void*)) ;
+EXPORT struct S_DDD f11_S_SP_DDD(struct S_DDD p0, void* p1,  struct S_DDD (*cb)(struct S_DDD, void*)) ;
+EXPORT struct S_DDP f11_S_SP_DDP(struct S_DDP p0, void* p1,  struct S_DDP (*cb)(struct S_DDP, void*)) ;
+EXPORT struct S_DPI f11_S_SP_DPI(struct S_DPI p0, void* p1,  struct S_DPI (*cb)(struct S_DPI, void*)) ;
+EXPORT struct S_DPF f11_S_SP_DPF(struct S_DPF p0, void* p1,  struct S_DPF (*cb)(struct S_DPF, void*)) ;
+EXPORT struct S_DPD f11_S_SP_DPD(struct S_DPD p0, void* p1,  struct S_DPD (*cb)(struct S_DPD, void*)) ;
+EXPORT struct S_DPP f11_S_SP_DPP(struct S_DPP p0, void* p1,  struct S_DPP (*cb)(struct S_DPP, void*)) ;
+EXPORT struct S_PII f11_S_SP_PII(struct S_PII p0, void* p1,  struct S_PII (*cb)(struct S_PII, void*)) ;
+EXPORT struct S_PIF f11_S_SP_PIF(struct S_PIF p0, void* p1,  struct S_PIF (*cb)(struct S_PIF, void*)) ;
+EXPORT struct S_PID f11_S_SP_PID(struct S_PID p0, void* p1,  struct S_PID (*cb)(struct S_PID, void*)) ;
+EXPORT struct S_PIP f11_S_SP_PIP(struct S_PIP p0, void* p1,  struct S_PIP (*cb)(struct S_PIP, void*)) ;
+EXPORT struct S_PFI f11_S_SP_PFI(struct S_PFI p0, void* p1,  struct S_PFI (*cb)(struct S_PFI, void*)) ;
+EXPORT struct S_PFF f11_S_SP_PFF(struct S_PFF p0, void* p1,  struct S_PFF (*cb)(struct S_PFF, void*)) ;
+EXPORT struct S_PFD f11_S_SP_PFD(struct S_PFD p0, void* p1,  struct S_PFD (*cb)(struct S_PFD, void*)) ;
+EXPORT struct S_PFP f11_S_SP_PFP(struct S_PFP p0, void* p1,  struct S_PFP (*cb)(struct S_PFP, void*)) ;
+EXPORT struct S_PDI f11_S_SP_PDI(struct S_PDI p0, void* p1,  struct S_PDI (*cb)(struct S_PDI, void*)) ;
+EXPORT struct S_PDF f11_S_SP_PDF(struct S_PDF p0, void* p1,  struct S_PDF (*cb)(struct S_PDF, void*)) ;
+EXPORT struct S_PDD f11_S_SP_PDD(struct S_PDD p0, void* p1,  struct S_PDD (*cb)(struct S_PDD, void*)) ;
+EXPORT struct S_PDP f11_S_SP_PDP(struct S_PDP p0, void* p1,  struct S_PDP (*cb)(struct S_PDP, void*)) ;
+EXPORT struct S_PPI f11_S_SP_PPI(struct S_PPI p0, void* p1,  struct S_PPI (*cb)(struct S_PPI, void*)) ;
+EXPORT struct S_PPF f11_S_SP_PPF(struct S_PPF p0, void* p1,  struct S_PPF (*cb)(struct S_PPF, void*)) ;
+EXPORT struct S_PPD f11_S_SP_PPD(struct S_PPD p0, void* p1,  struct S_PPD (*cb)(struct S_PPD, void*)) ;
+EXPORT struct S_PPP f11_S_SP_PPP(struct S_PPP p0, void* p1,  struct S_PPP (*cb)(struct S_PPP, void*)) ;
+EXPORT struct S_I f11_S_SS_I(struct S_I p0, struct S_I p1,  struct S_I (*cb)(struct S_I, struct S_I)) ;
+EXPORT struct S_F f11_S_SS_F(struct S_F p0, struct S_F p1,  struct S_F (*cb)(struct S_F, struct S_F)) ;
+EXPORT struct S_D f11_S_SS_D(struct S_D p0, struct S_D p1,  struct S_D (*cb)(struct S_D, struct S_D)) ;
+EXPORT struct S_P f11_S_SS_P(struct S_P p0, struct S_P p1,  struct S_P (*cb)(struct S_P, struct S_P)) ;
+EXPORT struct S_II f11_S_SS_II(struct S_II p0, struct S_II p1,  struct S_II (*cb)(struct S_II, struct S_II)) ;
+EXPORT struct S_IF f11_S_SS_IF(struct S_IF p0, struct S_IF p1,  struct S_IF (*cb)(struct S_IF, struct S_IF)) ;
+EXPORT struct S_ID f11_S_SS_ID(struct S_ID p0, struct S_ID p1,  struct S_ID (*cb)(struct S_ID, struct S_ID)) ;
+EXPORT struct S_IP f11_S_SS_IP(struct S_IP p0, struct S_IP p1,  struct S_IP (*cb)(struct S_IP, struct S_IP)) ;
+EXPORT struct S_FI f11_S_SS_FI(struct S_FI p0, struct S_FI p1,  struct S_FI (*cb)(struct S_FI, struct S_FI)) ;
+EXPORT struct S_FF f11_S_SS_FF(struct S_FF p0, struct S_FF p1,  struct S_FF (*cb)(struct S_FF, struct S_FF)) ;
+EXPORT struct S_FD f11_S_SS_FD(struct S_FD p0, struct S_FD p1,  struct S_FD (*cb)(struct S_FD, struct S_FD)) ;
+EXPORT struct S_FP f11_S_SS_FP(struct S_FP p0, struct S_FP p1,  struct S_FP (*cb)(struct S_FP, struct S_FP)) ;
+EXPORT struct S_DI f11_S_SS_DI(struct S_DI p0, struct S_DI p1,  struct S_DI (*cb)(struct S_DI, struct S_DI)) ;
+EXPORT struct S_DF f11_S_SS_DF(struct S_DF p0, struct S_DF p1,  struct S_DF (*cb)(struct S_DF, struct S_DF)) ;
+EXPORT struct S_DD f11_S_SS_DD(struct S_DD p0, struct S_DD p1,  struct S_DD (*cb)(struct S_DD, struct S_DD)) ;
+EXPORT struct S_DP f11_S_SS_DP(struct S_DP p0, struct S_DP p1,  struct S_DP (*cb)(struct S_DP, struct S_DP)) ;
+EXPORT struct S_PI f11_S_SS_PI(struct S_PI p0, struct S_PI p1,  struct S_PI (*cb)(struct S_PI, struct S_PI)) ;
+EXPORT struct S_PF f11_S_SS_PF(struct S_PF p0, struct S_PF p1,  struct S_PF (*cb)(struct S_PF, struct S_PF)) ;
+EXPORT struct S_PD f11_S_SS_PD(struct S_PD p0, struct S_PD p1,  struct S_PD (*cb)(struct S_PD, struct S_PD)) ;
+EXPORT struct S_PP f11_S_SS_PP(struct S_PP p0, struct S_PP p1,  struct S_PP (*cb)(struct S_PP, struct S_PP)) ;
+EXPORT struct S_III f11_S_SS_III(struct S_III p0, struct S_III p1,  struct S_III (*cb)(struct S_III, struct S_III)) ;
+EXPORT struct S_IIF f11_S_SS_IIF(struct S_IIF p0, struct S_IIF p1,  struct S_IIF (*cb)(struct S_IIF, struct S_IIF)) ;
+EXPORT struct S_IID f11_S_SS_IID(struct S_IID p0, struct S_IID p1,  struct S_IID (*cb)(struct S_IID, struct S_IID)) ;
+EXPORT struct S_IIP f11_S_SS_IIP(struct S_IIP p0, struct S_IIP p1,  struct S_IIP (*cb)(struct S_IIP, struct S_IIP)) ;
+EXPORT struct S_IFI f11_S_SS_IFI(struct S_IFI p0, struct S_IFI p1,  struct S_IFI (*cb)(struct S_IFI, struct S_IFI)) ;
+EXPORT struct S_IFF f11_S_SS_IFF(struct S_IFF p0, struct S_IFF p1,  struct S_IFF (*cb)(struct S_IFF, struct S_IFF)) ;
+EXPORT struct S_IFD f11_S_SS_IFD(struct S_IFD p0, struct S_IFD p1,  struct S_IFD (*cb)(struct S_IFD, struct S_IFD)) ;
+EXPORT struct S_IFP f11_S_SS_IFP(struct S_IFP p0, struct S_IFP p1,  struct S_IFP (*cb)(struct S_IFP, struct S_IFP)) ;
+EXPORT struct S_IDI f11_S_SS_IDI(struct S_IDI p0, struct S_IDI p1,  struct S_IDI (*cb)(struct S_IDI, struct S_IDI)) ;
+EXPORT struct S_IDF f11_S_SS_IDF(struct S_IDF p0, struct S_IDF p1,  struct S_IDF (*cb)(struct S_IDF, struct S_IDF)) ;
+EXPORT struct S_IDD f11_S_SS_IDD(struct S_IDD p0, struct S_IDD p1,  struct S_IDD (*cb)(struct S_IDD, struct S_IDD)) ;
+EXPORT struct S_IDP f11_S_SS_IDP(struct S_IDP p0, struct S_IDP p1,  struct S_IDP (*cb)(struct S_IDP, struct S_IDP)) ;
+EXPORT struct S_IPI f11_S_SS_IPI(struct S_IPI p0, struct S_IPI p1,  struct S_IPI (*cb)(struct S_IPI, struct S_IPI)) ;
+EXPORT struct S_IPF f11_S_SS_IPF(struct S_IPF p0, struct S_IPF p1,  struct S_IPF (*cb)(struct S_IPF, struct S_IPF)) ;
+EXPORT struct S_IPD f11_S_SS_IPD(struct S_IPD p0, struct S_IPD p1,  struct S_IPD (*cb)(struct S_IPD, struct S_IPD)) ;
+EXPORT struct S_IPP f11_S_SS_IPP(struct S_IPP p0, struct S_IPP p1,  struct S_IPP (*cb)(struct S_IPP, struct S_IPP)) ;
+EXPORT struct S_FII f11_S_SS_FII(struct S_FII p0, struct S_FII p1,  struct S_FII (*cb)(struct S_FII, struct S_FII)) ;
+EXPORT struct S_FIF f11_S_SS_FIF(struct S_FIF p0, struct S_FIF p1,  struct S_FIF (*cb)(struct S_FIF, struct S_FIF)) ;
+EXPORT struct S_FID f11_S_SS_FID(struct S_FID p0, struct S_FID p1,  struct S_FID (*cb)(struct S_FID, struct S_FID)) ;
+EXPORT struct S_FIP f11_S_SS_FIP(struct S_FIP p0, struct S_FIP p1,  struct S_FIP (*cb)(struct S_FIP, struct S_FIP)) ;
+EXPORT struct S_FFI f11_S_SS_FFI(struct S_FFI p0, struct S_FFI p1,  struct S_FFI (*cb)(struct S_FFI, struct S_FFI)) ;
+EXPORT struct S_FFF f11_S_SS_FFF(struct S_FFF p0, struct S_FFF p1,  struct S_FFF (*cb)(struct S_FFF, struct S_FFF)) ;
+EXPORT struct S_FFD f11_S_SS_FFD(struct S_FFD p0, struct S_FFD p1,  struct S_FFD (*cb)(struct S_FFD, struct S_FFD)) ;
+EXPORT struct S_FFP f11_S_SS_FFP(struct S_FFP p0, struct S_FFP p1,  struct S_FFP (*cb)(struct S_FFP, struct S_FFP)) ;
+EXPORT struct S_FDI f11_S_SS_FDI(struct S_FDI p0, struct S_FDI p1,  struct S_FDI (*cb)(struct S_FDI, struct S_FDI)) ;
+EXPORT struct S_FDF f11_S_SS_FDF(struct S_FDF p0, struct S_FDF p1,  struct S_FDF (*cb)(struct S_FDF, struct S_FDF)) ;
+EXPORT struct S_FDD f11_S_SS_FDD(struct S_FDD p0, struct S_FDD p1,  struct S_FDD (*cb)(struct S_FDD, struct S_FDD)) ;
+EXPORT struct S_FDP f11_S_SS_FDP(struct S_FDP p0, struct S_FDP p1,  struct S_FDP (*cb)(struct S_FDP, struct S_FDP)) ;
+EXPORT struct S_FPI f11_S_SS_FPI(struct S_FPI p0, struct S_FPI p1,  struct S_FPI (*cb)(struct S_FPI, struct S_FPI)) ;
+EXPORT struct S_FPF f11_S_SS_FPF(struct S_FPF p0, struct S_FPF p1,  struct S_FPF (*cb)(struct S_FPF, struct S_FPF)) ;
+EXPORT struct S_FPD f11_S_SS_FPD(struct S_FPD p0, struct S_FPD p1,  struct S_FPD (*cb)(struct S_FPD, struct S_FPD)) ;
+EXPORT struct S_FPP f11_S_SS_FPP(struct S_FPP p0, struct S_FPP p1,  struct S_FPP (*cb)(struct S_FPP, struct S_FPP)) ;
+EXPORT struct S_DII f11_S_SS_DII(struct S_DII p0, struct S_DII p1,  struct S_DII (*cb)(struct S_DII, struct S_DII)) ;
+EXPORT struct S_DIF f11_S_SS_DIF(struct S_DIF p0, struct S_DIF p1,  struct S_DIF (*cb)(struct S_DIF, struct S_DIF)) ;
+EXPORT struct S_DID f11_S_SS_DID(struct S_DID p0, struct S_DID p1,  struct S_DID (*cb)(struct S_DID, struct S_DID)) ;
+EXPORT struct S_DIP f11_S_SS_DIP(struct S_DIP p0, struct S_DIP p1,  struct S_DIP (*cb)(struct S_DIP, struct S_DIP)) ;
+EXPORT struct S_DFI f11_S_SS_DFI(struct S_DFI p0, struct S_DFI p1,  struct S_DFI (*cb)(struct S_DFI, struct S_DFI)) ;
+EXPORT struct S_DFF f11_S_SS_DFF(struct S_DFF p0, struct S_DFF p1,  struct S_DFF (*cb)(struct S_DFF, struct S_DFF)) ;
+EXPORT struct S_DFD f11_S_SS_DFD(struct S_DFD p0, struct S_DFD p1,  struct S_DFD (*cb)(struct S_DFD, struct S_DFD)) ;
+EXPORT struct S_DFP f11_S_SS_DFP(struct S_DFP p0, struct S_DFP p1,  struct S_DFP (*cb)(struct S_DFP, struct S_DFP)) ;
+EXPORT struct S_DDI f11_S_SS_DDI(struct S_DDI p0, struct S_DDI p1,  struct S_DDI (*cb)(struct S_DDI, struct S_DDI)) ;
+EXPORT struct S_DDF f11_S_SS_DDF(struct S_DDF p0, struct S_DDF p1,  struct S_DDF (*cb)(struct S_DDF, struct S_DDF)) ;
+EXPORT struct S_DDD f11_S_SS_DDD(struct S_DDD p0, struct S_DDD p1,  struct S_DDD (*cb)(struct S_DDD, struct S_DDD)) ;
+EXPORT struct S_DDP f11_S_SS_DDP(struct S_DDP p0, struct S_DDP p1,  struct S_DDP (*cb)(struct S_DDP, struct S_DDP)) ;
+EXPORT struct S_DPI f11_S_SS_DPI(struct S_DPI p0, struct S_DPI p1,  struct S_DPI (*cb)(struct S_DPI, struct S_DPI)) ;
+EXPORT struct S_DPF f11_S_SS_DPF(struct S_DPF p0, struct S_DPF p1,  struct S_DPF (*cb)(struct S_DPF, struct S_DPF)) ;
+EXPORT struct S_DPD f11_S_SS_DPD(struct S_DPD p0, struct S_DPD p1,  struct S_DPD (*cb)(struct S_DPD, struct S_DPD)) ;
+EXPORT struct S_DPP f11_S_SS_DPP(struct S_DPP p0, struct S_DPP p1,  struct S_DPP (*cb)(struct S_DPP, struct S_DPP)) ;
+EXPORT struct S_PII f11_S_SS_PII(struct S_PII p0, struct S_PII p1,  struct S_PII (*cb)(struct S_PII, struct S_PII)) ;
+EXPORT struct S_PIF f11_S_SS_PIF(struct S_PIF p0, struct S_PIF p1,  struct S_PIF (*cb)(struct S_PIF, struct S_PIF)) ;
+EXPORT struct S_PID f11_S_SS_PID(struct S_PID p0, struct S_PID p1,  struct S_PID (*cb)(struct S_PID, struct S_PID)) ;
+EXPORT struct S_PIP f11_S_SS_PIP(struct S_PIP p0, struct S_PIP p1,  struct S_PIP (*cb)(struct S_PIP, struct S_PIP)) ;
+EXPORT struct S_PFI f11_S_SS_PFI(struct S_PFI p0, struct S_PFI p1,  struct S_PFI (*cb)(struct S_PFI, struct S_PFI)) ;
+EXPORT struct S_PFF f11_S_SS_PFF(struct S_PFF p0, struct S_PFF p1,  struct S_PFF (*cb)(struct S_PFF, struct S_PFF)) ;
+EXPORT struct S_PFD f11_S_SS_PFD(struct S_PFD p0, struct S_PFD p1,  struct S_PFD (*cb)(struct S_PFD, struct S_PFD)) ;
+EXPORT struct S_PFP f11_S_SS_PFP(struct S_PFP p0, struct S_PFP p1,  struct S_PFP (*cb)(struct S_PFP, struct S_PFP)) ;
+EXPORT struct S_PDI f11_S_SS_PDI(struct S_PDI p0, struct S_PDI p1,  struct S_PDI (*cb)(struct S_PDI, struct S_PDI)) ;
+EXPORT struct S_PDF f11_S_SS_PDF(struct S_PDF p0, struct S_PDF p1,  struct S_PDF (*cb)(struct S_PDF, struct S_PDF)) ;
+EXPORT struct S_PDD f11_S_SS_PDD(struct S_PDD p0, struct S_PDD p1,  struct S_PDD (*cb)(struct S_PDD, struct S_PDD)) ;
+EXPORT struct S_PDP f11_S_SS_PDP(struct S_PDP p0, struct S_PDP p1,  struct S_PDP (*cb)(struct S_PDP, struct S_PDP)) ;
+EXPORT struct S_PPI f11_S_SS_PPI(struct S_PPI p0, struct S_PPI p1,  struct S_PPI (*cb)(struct S_PPI, struct S_PPI)) ;
+EXPORT struct S_PPF f11_S_SS_PPF(struct S_PPF p0, struct S_PPF p1,  struct S_PPF (*cb)(struct S_PPF, struct S_PPF)) ;
+EXPORT struct S_PPD f11_S_SS_PPD(struct S_PPD p0, struct S_PPD p1,  struct S_PPD (*cb)(struct S_PPD, struct S_PPD)) ;
+EXPORT struct S_PPP f11_S_SS_PPP(struct S_PPP p0, struct S_PPP p1,  struct S_PPP (*cb)(struct S_PPP, struct S_PPP)) ;
+EXPORT int f11_I_III_(int p0, int p1, int p2,  int (*cb)(int, int, int)) ;
+EXPORT int f11_I_IIF_(int p0, int p1, float p2,  int (*cb)(int, int, float)) ;
+EXPORT int f11_I_IID_(int p0, int p1, double p2,  int (*cb)(int, int, double)) ;
+EXPORT int f11_I_IIP_(int p0, int p1, void* p2,  int (*cb)(int, int, void*)) ;
+EXPORT int f11_I_IIS_I(int p0, int p1, struct S_I p2,  int (*cb)(int, int, struct S_I)) ;
+EXPORT int f11_I_IIS_F(int p0, int p1, struct S_F p2,  int (*cb)(int, int, struct S_F)) ;
+EXPORT int f11_I_IIS_D(int p0, int p1, struct S_D p2,  int (*cb)(int, int, struct S_D)) ;
+EXPORT int f11_I_IIS_P(int p0, int p1, struct S_P p2,  int (*cb)(int, int, struct S_P)) ;
+EXPORT int f11_I_IIS_II(int p0, int p1, struct S_II p2,  int (*cb)(int, int, struct S_II)) ;
+EXPORT int f11_I_IIS_IF(int p0, int p1, struct S_IF p2,  int (*cb)(int, int, struct S_IF)) ;
+EXPORT int f11_I_IIS_ID(int p0, int p1, struct S_ID p2,  int (*cb)(int, int, struct S_ID)) ;
+EXPORT int f11_I_IIS_IP(int p0, int p1, struct S_IP p2,  int (*cb)(int, int, struct S_IP)) ;
+EXPORT int f11_I_IIS_FI(int p0, int p1, struct S_FI p2,  int (*cb)(int, int, struct S_FI)) ;
+EXPORT int f11_I_IIS_FF(int p0, int p1, struct S_FF p2,  int (*cb)(int, int, struct S_FF)) ;
+EXPORT int f11_I_IIS_FD(int p0, int p1, struct S_FD p2,  int (*cb)(int, int, struct S_FD)) ;
+EXPORT int f11_I_IIS_FP(int p0, int p1, struct S_FP p2,  int (*cb)(int, int, struct S_FP)) ;
+EXPORT int f11_I_IIS_DI(int p0, int p1, struct S_DI p2,  int (*cb)(int, int, struct S_DI)) ;
+EXPORT int f11_I_IIS_DF(int p0, int p1, struct S_DF p2,  int (*cb)(int, int, struct S_DF)) ;
+EXPORT int f11_I_IIS_DD(int p0, int p1, struct S_DD p2,  int (*cb)(int, int, struct S_DD)) ;
+EXPORT int f11_I_IIS_DP(int p0, int p1, struct S_DP p2,  int (*cb)(int, int, struct S_DP)) ;
+EXPORT int f11_I_IIS_PI(int p0, int p1, struct S_PI p2,  int (*cb)(int, int, struct S_PI)) ;
+EXPORT int f11_I_IIS_PF(int p0, int p1, struct S_PF p2,  int (*cb)(int, int, struct S_PF)) ;
+EXPORT int f11_I_IIS_PD(int p0, int p1, struct S_PD p2,  int (*cb)(int, int, struct S_PD)) ;
+EXPORT int f11_I_IIS_PP(int p0, int p1, struct S_PP p2,  int (*cb)(int, int, struct S_PP)) ;
+EXPORT int f11_I_IIS_III(int p0, int p1, struct S_III p2,  int (*cb)(int, int, struct S_III)) ;
+EXPORT int f11_I_IIS_IIF(int p0, int p1, struct S_IIF p2,  int (*cb)(int, int, struct S_IIF)) ;
+EXPORT int f11_I_IIS_IID(int p0, int p1, struct S_IID p2,  int (*cb)(int, int, struct S_IID)) ;
+EXPORT int f11_I_IIS_IIP(int p0, int p1, struct S_IIP p2,  int (*cb)(int, int, struct S_IIP)) ;
+EXPORT int f11_I_IIS_IFI(int p0, int p1, struct S_IFI p2,  int (*cb)(int, int, struct S_IFI)) ;
+EXPORT int f11_I_IIS_IFF(int p0, int p1, struct S_IFF p2,  int (*cb)(int, int, struct S_IFF)) ;
+EXPORT int f11_I_IIS_IFD(int p0, int p1, struct S_IFD p2,  int (*cb)(int, int, struct S_IFD)) ;
+EXPORT int f11_I_IIS_IFP(int p0, int p1, struct S_IFP p2,  int (*cb)(int, int, struct S_IFP)) ;
+EXPORT int f11_I_IIS_IDI(int p0, int p1, struct S_IDI p2,  int (*cb)(int, int, struct S_IDI)) ;
+EXPORT int f11_I_IIS_IDF(int p0, int p1, struct S_IDF p2,  int (*cb)(int, int, struct S_IDF)) ;
+EXPORT int f11_I_IIS_IDD(int p0, int p1, struct S_IDD p2,  int (*cb)(int, int, struct S_IDD)) ;
+EXPORT int f11_I_IIS_IDP(int p0, int p1, struct S_IDP p2,  int (*cb)(int, int, struct S_IDP)) ;
+EXPORT int f11_I_IIS_IPI(int p0, int p1, struct S_IPI p2,  int (*cb)(int, int, struct S_IPI)) ;
+EXPORT int f11_I_IIS_IPF(int p0, int p1, struct S_IPF p2,  int (*cb)(int, int, struct S_IPF)) ;
+EXPORT int f11_I_IIS_IPD(int p0, int p1, struct S_IPD p2,  int (*cb)(int, int, struct S_IPD)) ;
+EXPORT int f11_I_IIS_IPP(int p0, int p1, struct S_IPP p2,  int (*cb)(int, int, struct S_IPP)) ;
+EXPORT int f11_I_IIS_FII(int p0, int p1, struct S_FII p2,  int (*cb)(int, int, struct S_FII)) ;
+EXPORT int f11_I_IIS_FIF(int p0, int p1, struct S_FIF p2,  int (*cb)(int, int, struct S_FIF)) ;
+EXPORT int f11_I_IIS_FID(int p0, int p1, struct S_FID p2,  int (*cb)(int, int, struct S_FID)) ;
+EXPORT int f11_I_IIS_FIP(int p0, int p1, struct S_FIP p2,  int (*cb)(int, int, struct S_FIP)) ;
+EXPORT int f11_I_IIS_FFI(int p0, int p1, struct S_FFI p2,  int (*cb)(int, int, struct S_FFI)) ;
+EXPORT int f11_I_IIS_FFF(int p0, int p1, struct S_FFF p2,  int (*cb)(int, int, struct S_FFF)) ;
+EXPORT int f11_I_IIS_FFD(int p0, int p1, struct S_FFD p2,  int (*cb)(int, int, struct S_FFD)) ;
+EXPORT int f11_I_IIS_FFP(int p0, int p1, struct S_FFP p2,  int (*cb)(int, int, struct S_FFP)) ;
+EXPORT int f11_I_IIS_FDI(int p0, int p1, struct S_FDI p2,  int (*cb)(int, int, struct S_FDI)) ;
+EXPORT int f11_I_IIS_FDF(int p0, int p1, struct S_FDF p2,  int (*cb)(int, int, struct S_FDF)) ;
+EXPORT int f11_I_IIS_FDD(int p0, int p1, struct S_FDD p2,  int (*cb)(int, int, struct S_FDD)) ;
+EXPORT int f11_I_IIS_FDP(int p0, int p1, struct S_FDP p2,  int (*cb)(int, int, struct S_FDP)) ;
+EXPORT int f11_I_IIS_FPI(int p0, int p1, struct S_FPI p2,  int (*cb)(int, int, struct S_FPI)) ;
+EXPORT int f11_I_IIS_FPF(int p0, int p1, struct S_FPF p2,  int (*cb)(int, int, struct S_FPF)) ;
+EXPORT int f11_I_IIS_FPD(int p0, int p1, struct S_FPD p2,  int (*cb)(int, int, struct S_FPD)) ;
+EXPORT int f11_I_IIS_FPP(int p0, int p1, struct S_FPP p2,  int (*cb)(int, int, struct S_FPP)) ;
+EXPORT int f11_I_IIS_DII(int p0, int p1, struct S_DII p2,  int (*cb)(int, int, struct S_DII)) ;
+EXPORT int f11_I_IIS_DIF(int p0, int p1, struct S_DIF p2,  int (*cb)(int, int, struct S_DIF)) ;
+EXPORT int f11_I_IIS_DID(int p0, int p1, struct S_DID p2,  int (*cb)(int, int, struct S_DID)) ;
+EXPORT int f11_I_IIS_DIP(int p0, int p1, struct S_DIP p2,  int (*cb)(int, int, struct S_DIP)) ;
+EXPORT int f11_I_IIS_DFI(int p0, int p1, struct S_DFI p2,  int (*cb)(int, int, struct S_DFI)) ;
+EXPORT int f11_I_IIS_DFF(int p0, int p1, struct S_DFF p2,  int (*cb)(int, int, struct S_DFF)) ;
+EXPORT int f11_I_IIS_DFD(int p0, int p1, struct S_DFD p2,  int (*cb)(int, int, struct S_DFD)) ;
+EXPORT int f11_I_IIS_DFP(int p0, int p1, struct S_DFP p2,  int (*cb)(int, int, struct S_DFP)) ;
+EXPORT int f11_I_IIS_DDI(int p0, int p1, struct S_DDI p2,  int (*cb)(int, int, struct S_DDI)) ;
+EXPORT int f11_I_IIS_DDF(int p0, int p1, struct S_DDF p2,  int (*cb)(int, int, struct S_DDF)) ;
+EXPORT int f11_I_IIS_DDD(int p0, int p1, struct S_DDD p2,  int (*cb)(int, int, struct S_DDD)) ;
+EXPORT int f11_I_IIS_DDP(int p0, int p1, struct S_DDP p2,  int (*cb)(int, int, struct S_DDP)) ;
+EXPORT int f11_I_IIS_DPI(int p0, int p1, struct S_DPI p2,  int (*cb)(int, int, struct S_DPI)) ;
+EXPORT int f11_I_IIS_DPF(int p0, int p1, struct S_DPF p2,  int (*cb)(int, int, struct S_DPF)) ;
+EXPORT int f11_I_IIS_DPD(int p0, int p1, struct S_DPD p2,  int (*cb)(int, int, struct S_DPD)) ;
+EXPORT int f11_I_IIS_DPP(int p0, int p1, struct S_DPP p2,  int (*cb)(int, int, struct S_DPP)) ;
+EXPORT int f11_I_IIS_PII(int p0, int p1, struct S_PII p2,  int (*cb)(int, int, struct S_PII)) ;
+EXPORT int f11_I_IIS_PIF(int p0, int p1, struct S_PIF p2,  int (*cb)(int, int, struct S_PIF)) ;
+EXPORT int f11_I_IIS_PID(int p0, int p1, struct S_PID p2,  int (*cb)(int, int, struct S_PID)) ;
+EXPORT int f11_I_IIS_PIP(int p0, int p1, struct S_PIP p2,  int (*cb)(int, int, struct S_PIP)) ;
+EXPORT int f11_I_IIS_PFI(int p0, int p1, struct S_PFI p2,  int (*cb)(int, int, struct S_PFI)) ;
+EXPORT int f11_I_IIS_PFF(int p0, int p1, struct S_PFF p2,  int (*cb)(int, int, struct S_PFF)) ;
+EXPORT int f11_I_IIS_PFD(int p0, int p1, struct S_PFD p2,  int (*cb)(int, int, struct S_PFD)) ;
+EXPORT int f11_I_IIS_PFP(int p0, int p1, struct S_PFP p2,  int (*cb)(int, int, struct S_PFP)) ;
+EXPORT int f11_I_IIS_PDI(int p0, int p1, struct S_PDI p2,  int (*cb)(int, int, struct S_PDI)) ;
+EXPORT int f11_I_IIS_PDF(int p0, int p1, struct S_PDF p2,  int (*cb)(int, int, struct S_PDF)) ;
+EXPORT int f11_I_IIS_PDD(int p0, int p1, struct S_PDD p2,  int (*cb)(int, int, struct S_PDD)) ;
+EXPORT int f11_I_IIS_PDP(int p0, int p1, struct S_PDP p2,  int (*cb)(int, int, struct S_PDP)) ;
+EXPORT int f11_I_IIS_PPI(int p0, int p1, struct S_PPI p2,  int (*cb)(int, int, struct S_PPI)) ;
+EXPORT int f11_I_IIS_PPF(int p0, int p1, struct S_PPF p2,  int (*cb)(int, int, struct S_PPF)) ;
+EXPORT int f11_I_IIS_PPD(int p0, int p1, struct S_PPD p2,  int (*cb)(int, int, struct S_PPD)) ;
+EXPORT int f11_I_IIS_PPP(int p0, int p1, struct S_PPP p2,  int (*cb)(int, int, struct S_PPP)) ;
+EXPORT int f11_I_IFI_(int p0, float p1, int p2,  int (*cb)(int, float, int)) ;
+EXPORT int f11_I_IFF_(int p0, float p1, float p2,  int (*cb)(int, float, float)) ;
+EXPORT int f11_I_IFD_(int p0, float p1, double p2,  int (*cb)(int, float, double)) ;
+EXPORT int f11_I_IFP_(int p0, float p1, void* p2,  int (*cb)(int, float, void*)) ;
+EXPORT int f11_I_IFS_I(int p0, float p1, struct S_I p2,  int (*cb)(int, float, struct S_I)) ;
+EXPORT int f11_I_IFS_F(int p0, float p1, struct S_F p2,  int (*cb)(int, float, struct S_F)) ;
+EXPORT int f11_I_IFS_D(int p0, float p1, struct S_D p2,  int (*cb)(int, float, struct S_D)) ;
+EXPORT int f11_I_IFS_P(int p0, float p1, struct S_P p2,  int (*cb)(int, float, struct S_P)) ;
+EXPORT int f11_I_IFS_II(int p0, float p1, struct S_II p2,  int (*cb)(int, float, struct S_II)) ;
+EXPORT int f11_I_IFS_IF(int p0, float p1, struct S_IF p2,  int (*cb)(int, float, struct S_IF)) ;
+EXPORT int f11_I_IFS_ID(int p0, float p1, struct S_ID p2,  int (*cb)(int, float, struct S_ID)) ;
+EXPORT int f11_I_IFS_IP(int p0, float p1, struct S_IP p2,  int (*cb)(int, float, struct S_IP)) ;
+EXPORT int f11_I_IFS_FI(int p0, float p1, struct S_FI p2,  int (*cb)(int, float, struct S_FI)) ;
+EXPORT int f11_I_IFS_FF(int p0, float p1, struct S_FF p2,  int (*cb)(int, float, struct S_FF)) ;
+EXPORT int f11_I_IFS_FD(int p0, float p1, struct S_FD p2,  int (*cb)(int, float, struct S_FD)) ;
+EXPORT int f11_I_IFS_FP(int p0, float p1, struct S_FP p2,  int (*cb)(int, float, struct S_FP)) ;
+EXPORT int f11_I_IFS_DI(int p0, float p1, struct S_DI p2,  int (*cb)(int, float, struct S_DI)) ;
+EXPORT int f11_I_IFS_DF(int p0, float p1, struct S_DF p2,  int (*cb)(int, float, struct S_DF)) ;
+EXPORT int f11_I_IFS_DD(int p0, float p1, struct S_DD p2,  int (*cb)(int, float, struct S_DD)) ;
+EXPORT int f11_I_IFS_DP(int p0, float p1, struct S_DP p2,  int (*cb)(int, float, struct S_DP)) ;
+EXPORT int f11_I_IFS_PI(int p0, float p1, struct S_PI p2,  int (*cb)(int, float, struct S_PI)) ;
+EXPORT int f11_I_IFS_PF(int p0, float p1, struct S_PF p2,  int (*cb)(int, float, struct S_PF)) ;
+EXPORT int f11_I_IFS_PD(int p0, float p1, struct S_PD p2,  int (*cb)(int, float, struct S_PD)) ;
+EXPORT int f11_I_IFS_PP(int p0, float p1, struct S_PP p2,  int (*cb)(int, float, struct S_PP)) ;
+EXPORT int f11_I_IFS_III(int p0, float p1, struct S_III p2,  int (*cb)(int, float, struct S_III)) ;
+EXPORT int f11_I_IFS_IIF(int p0, float p1, struct S_IIF p2,  int (*cb)(int, float, struct S_IIF)) ;
+EXPORT int f11_I_IFS_IID(int p0, float p1, struct S_IID p2,  int (*cb)(int, float, struct S_IID)) ;
+EXPORT int f11_I_IFS_IIP(int p0, float p1, struct S_IIP p2,  int (*cb)(int, float, struct S_IIP)) ;
+EXPORT int f11_I_IFS_IFI(int p0, float p1, struct S_IFI p2,  int (*cb)(int, float, struct S_IFI)) ;
+EXPORT int f11_I_IFS_IFF(int p0, float p1, struct S_IFF p2,  int (*cb)(int, float, struct S_IFF)) ;
+EXPORT int f11_I_IFS_IFD(int p0, float p1, struct S_IFD p2,  int (*cb)(int, float, struct S_IFD)) ;
+EXPORT int f11_I_IFS_IFP(int p0, float p1, struct S_IFP p2,  int (*cb)(int, float, struct S_IFP)) ;
+EXPORT int f11_I_IFS_IDI(int p0, float p1, struct S_IDI p2,  int (*cb)(int, float, struct S_IDI)) ;
+EXPORT int f11_I_IFS_IDF(int p0, float p1, struct S_IDF p2,  int (*cb)(int, float, struct S_IDF)) ;
+EXPORT int f11_I_IFS_IDD(int p0, float p1, struct S_IDD p2,  int (*cb)(int, float, struct S_IDD)) ;
+EXPORT int f11_I_IFS_IDP(int p0, float p1, struct S_IDP p2,  int (*cb)(int, float, struct S_IDP)) ;
+EXPORT int f11_I_IFS_IPI(int p0, float p1, struct S_IPI p2,  int (*cb)(int, float, struct S_IPI)) ;
+EXPORT int f11_I_IFS_IPF(int p0, float p1, struct S_IPF p2,  int (*cb)(int, float, struct S_IPF)) ;
+EXPORT int f11_I_IFS_IPD(int p0, float p1, struct S_IPD p2,  int (*cb)(int, float, struct S_IPD)) ;
+EXPORT int f11_I_IFS_IPP(int p0, float p1, struct S_IPP p2,  int (*cb)(int, float, struct S_IPP)) ;
+EXPORT int f11_I_IFS_FII(int p0, float p1, struct S_FII p2,  int (*cb)(int, float, struct S_FII)) ;
+EXPORT int f11_I_IFS_FIF(int p0, float p1, struct S_FIF p2,  int (*cb)(int, float, struct S_FIF)) ;
+EXPORT int f11_I_IFS_FID(int p0, float p1, struct S_FID p2,  int (*cb)(int, float, struct S_FID)) ;
+EXPORT int f11_I_IFS_FIP(int p0, float p1, struct S_FIP p2,  int (*cb)(int, float, struct S_FIP)) ;
+EXPORT int f11_I_IFS_FFI(int p0, float p1, struct S_FFI p2,  int (*cb)(int, float, struct S_FFI)) ;
+EXPORT int f11_I_IFS_FFF(int p0, float p1, struct S_FFF p2,  int (*cb)(int, float, struct S_FFF)) ;
+EXPORT int f11_I_IFS_FFD(int p0, float p1, struct S_FFD p2,  int (*cb)(int, float, struct S_FFD)) ;
+EXPORT int f11_I_IFS_FFP(int p0, float p1, struct S_FFP p2,  int (*cb)(int, float, struct S_FFP)) ;
+EXPORT int f11_I_IFS_FDI(int p0, float p1, struct S_FDI p2,  int (*cb)(int, float, struct S_FDI)) ;
+EXPORT int f11_I_IFS_FDF(int p0, float p1, struct S_FDF p2,  int (*cb)(int, float, struct S_FDF)) ;
+EXPORT int f11_I_IFS_FDD(int p0, float p1, struct S_FDD p2,  int (*cb)(int, float, struct S_FDD)) ;
+EXPORT int f11_I_IFS_FDP(int p0, float p1, struct S_FDP p2,  int (*cb)(int, float, struct S_FDP)) ;
+EXPORT int f11_I_IFS_FPI(int p0, float p1, struct S_FPI p2,  int (*cb)(int, float, struct S_FPI)) ;
+EXPORT int f11_I_IFS_FPF(int p0, float p1, struct S_FPF p2,  int (*cb)(int, float, struct S_FPF)) ;
+EXPORT int f11_I_IFS_FPD(int p0, float p1, struct S_FPD p2,  int (*cb)(int, float, struct S_FPD)) ;
+EXPORT int f11_I_IFS_FPP(int p0, float p1, struct S_FPP p2,  int (*cb)(int, float, struct S_FPP)) ;
+EXPORT int f11_I_IFS_DII(int p0, float p1, struct S_DII p2,  int (*cb)(int, float, struct S_DII)) ;
+EXPORT int f11_I_IFS_DIF(int p0, float p1, struct S_DIF p2,  int (*cb)(int, float, struct S_DIF)) ;
+EXPORT int f11_I_IFS_DID(int p0, float p1, struct S_DID p2,  int (*cb)(int, float, struct S_DID)) ;
+EXPORT int f11_I_IFS_DIP(int p0, float p1, struct S_DIP p2,  int (*cb)(int, float, struct S_DIP)) ;
+EXPORT int f11_I_IFS_DFI(int p0, float p1, struct S_DFI p2,  int (*cb)(int, float, struct S_DFI)) ;
+EXPORT int f11_I_IFS_DFF(int p0, float p1, struct S_DFF p2,  int (*cb)(int, float, struct S_DFF)) ;
+EXPORT int f11_I_IFS_DFD(int p0, float p1, struct S_DFD p2,  int (*cb)(int, float, struct S_DFD)) ;
+EXPORT int f11_I_IFS_DFP(int p0, float p1, struct S_DFP p2,  int (*cb)(int, float, struct S_DFP)) ;
+EXPORT int f11_I_IFS_DDI(int p0, float p1, struct S_DDI p2,  int (*cb)(int, float, struct S_DDI)) ;
+EXPORT int f11_I_IFS_DDF(int p0, float p1, struct S_DDF p2,  int (*cb)(int, float, struct S_DDF)) ;
+EXPORT int f11_I_IFS_DDD(int p0, float p1, struct S_DDD p2,  int (*cb)(int, float, struct S_DDD)) ;
+EXPORT int f11_I_IFS_DDP(int p0, float p1, struct S_DDP p2,  int (*cb)(int, float, struct S_DDP)) ;
+EXPORT int f11_I_IFS_DPI(int p0, float p1, struct S_DPI p2,  int (*cb)(int, float, struct S_DPI)) ;
+EXPORT int f11_I_IFS_DPF(int p0, float p1, struct S_DPF p2,  int (*cb)(int, float, struct S_DPF)) ;
+EXPORT int f11_I_IFS_DPD(int p0, float p1, struct S_DPD p2,  int (*cb)(int, float, struct S_DPD)) ;
+EXPORT int f11_I_IFS_DPP(int p0, float p1, struct S_DPP p2,  int (*cb)(int, float, struct S_DPP)) ;
+EXPORT int f11_I_IFS_PII(int p0, float p1, struct S_PII p2,  int (*cb)(int, float, struct S_PII)) ;
+EXPORT int f11_I_IFS_PIF(int p0, float p1, struct S_PIF p2,  int (*cb)(int, float, struct S_PIF)) ;
+EXPORT int f11_I_IFS_PID(int p0, float p1, struct S_PID p2,  int (*cb)(int, float, struct S_PID)) ;
+EXPORT int f11_I_IFS_PIP(int p0, float p1, struct S_PIP p2,  int (*cb)(int, float, struct S_PIP)) ;
+EXPORT int f11_I_IFS_PFI(int p0, float p1, struct S_PFI p2,  int (*cb)(int, float, struct S_PFI)) ;
+EXPORT int f11_I_IFS_PFF(int p0, float p1, struct S_PFF p2,  int (*cb)(int, float, struct S_PFF)) ;
+EXPORT int f11_I_IFS_PFD(int p0, float p1, struct S_PFD p2,  int (*cb)(int, float, struct S_PFD)) ;
+EXPORT int f11_I_IFS_PFP(int p0, float p1, struct S_PFP p2,  int (*cb)(int, float, struct S_PFP)) ;
+EXPORT int f11_I_IFS_PDI(int p0, float p1, struct S_PDI p2,  int (*cb)(int, float, struct S_PDI)) ;
+EXPORT int f11_I_IFS_PDF(int p0, float p1, struct S_PDF p2,  int (*cb)(int, float, struct S_PDF)) ;
+EXPORT int f11_I_IFS_PDD(int p0, float p1, struct S_PDD p2,  int (*cb)(int, float, struct S_PDD)) ;
+EXPORT int f11_I_IFS_PDP(int p0, float p1, struct S_PDP p2,  int (*cb)(int, float, struct S_PDP)) ;
+EXPORT int f11_I_IFS_PPI(int p0, float p1, struct S_PPI p2,  int (*cb)(int, float, struct S_PPI)) ;
+EXPORT int f11_I_IFS_PPF(int p0, float p1, struct S_PPF p2,  int (*cb)(int, float, struct S_PPF)) ;
+EXPORT int f11_I_IFS_PPD(int p0, float p1, struct S_PPD p2,  int (*cb)(int, float, struct S_PPD)) ;
+EXPORT int f11_I_IFS_PPP(int p0, float p1, struct S_PPP p2,  int (*cb)(int, float, struct S_PPP)) ;
+EXPORT int f11_I_IDI_(int p0, double p1, int p2,  int (*cb)(int, double, int)) ;
+EXPORT int f11_I_IDF_(int p0, double p1, float p2,  int (*cb)(int, double, float)) ;
+EXPORT int f11_I_IDD_(int p0, double p1, double p2,  int (*cb)(int, double, double)) ;
+EXPORT int f11_I_IDP_(int p0, double p1, void* p2,  int (*cb)(int, double, void*)) ;
+EXPORT int f11_I_IDS_I(int p0, double p1, struct S_I p2,  int (*cb)(int, double, struct S_I)) ;
+EXPORT int f11_I_IDS_F(int p0, double p1, struct S_F p2,  int (*cb)(int, double, struct S_F)) ;
+EXPORT int f11_I_IDS_D(int p0, double p1, struct S_D p2,  int (*cb)(int, double, struct S_D)) ;
+EXPORT int f11_I_IDS_P(int p0, double p1, struct S_P p2,  int (*cb)(int, double, struct S_P)) ;
+EXPORT int f11_I_IDS_II(int p0, double p1, struct S_II p2,  int (*cb)(int, double, struct S_II)) ;
+EXPORT int f11_I_IDS_IF(int p0, double p1, struct S_IF p2,  int (*cb)(int, double, struct S_IF)) ;
+EXPORT int f11_I_IDS_ID(int p0, double p1, struct S_ID p2,  int (*cb)(int, double, struct S_ID)) ;
+EXPORT int f11_I_IDS_IP(int p0, double p1, struct S_IP p2,  int (*cb)(int, double, struct S_IP)) ;
+EXPORT int f11_I_IDS_FI(int p0, double p1, struct S_FI p2,  int (*cb)(int, double, struct S_FI)) ;
+EXPORT int f11_I_IDS_FF(int p0, double p1, struct S_FF p2,  int (*cb)(int, double, struct S_FF)) ;
+EXPORT int f11_I_IDS_FD(int p0, double p1, struct S_FD p2,  int (*cb)(int, double, struct S_FD)) ;
+EXPORT int f11_I_IDS_FP(int p0, double p1, struct S_FP p2,  int (*cb)(int, double, struct S_FP)) ;
+EXPORT int f11_I_IDS_DI(int p0, double p1, struct S_DI p2,  int (*cb)(int, double, struct S_DI)) ;
+EXPORT int f11_I_IDS_DF(int p0, double p1, struct S_DF p2,  int (*cb)(int, double, struct S_DF)) ;
+EXPORT int f11_I_IDS_DD(int p0, double p1, struct S_DD p2,  int (*cb)(int, double, struct S_DD)) ;
+EXPORT int f11_I_IDS_DP(int p0, double p1, struct S_DP p2,  int (*cb)(int, double, struct S_DP)) ;
+EXPORT int f11_I_IDS_PI(int p0, double p1, struct S_PI p2,  int (*cb)(int, double, struct S_PI)) ;
+EXPORT int f11_I_IDS_PF(int p0, double p1, struct S_PF p2,  int (*cb)(int, double, struct S_PF)) ;
+EXPORT int f11_I_IDS_PD(int p0, double p1, struct S_PD p2,  int (*cb)(int, double, struct S_PD)) ;
+EXPORT int f11_I_IDS_PP(int p0, double p1, struct S_PP p2,  int (*cb)(int, double, struct S_PP)) ;
+EXPORT int f11_I_IDS_III(int p0, double p1, struct S_III p2,  int (*cb)(int, double, struct S_III)) ;
+EXPORT int f11_I_IDS_IIF(int p0, double p1, struct S_IIF p2,  int (*cb)(int, double, struct S_IIF)) ;
+EXPORT int f11_I_IDS_IID(int p0, double p1, struct S_IID p2,  int (*cb)(int, double, struct S_IID)) ;
+EXPORT int f11_I_IDS_IIP(int p0, double p1, struct S_IIP p2,  int (*cb)(int, double, struct S_IIP)) ;
+EXPORT int f11_I_IDS_IFI(int p0, double p1, struct S_IFI p2,  int (*cb)(int, double, struct S_IFI)) ;
+EXPORT int f11_I_IDS_IFF(int p0, double p1, struct S_IFF p2,  int (*cb)(int, double, struct S_IFF)) ;
+EXPORT int f11_I_IDS_IFD(int p0, double p1, struct S_IFD p2,  int (*cb)(int, double, struct S_IFD)) ;
+EXPORT int f11_I_IDS_IFP(int p0, double p1, struct S_IFP p2,  int (*cb)(int, double, struct S_IFP)) ;
+EXPORT int f11_I_IDS_IDI(int p0, double p1, struct S_IDI p2,  int (*cb)(int, double, struct S_IDI)) ;
+EXPORT int f11_I_IDS_IDF(int p0, double p1, struct S_IDF p2,  int (*cb)(int, double, struct S_IDF)) ;
+EXPORT int f11_I_IDS_IDD(int p0, double p1, struct S_IDD p2,  int (*cb)(int, double, struct S_IDD)) ;
+EXPORT int f11_I_IDS_IDP(int p0, double p1, struct S_IDP p2,  int (*cb)(int, double, struct S_IDP)) ;
+EXPORT int f11_I_IDS_IPI(int p0, double p1, struct S_IPI p2,  int (*cb)(int, double, struct S_IPI)) ;
+EXPORT int f11_I_IDS_IPF(int p0, double p1, struct S_IPF p2,  int (*cb)(int, double, struct S_IPF)) ;
+EXPORT int f11_I_IDS_IPD(int p0, double p1, struct S_IPD p2,  int (*cb)(int, double, struct S_IPD)) ;
+EXPORT int f11_I_IDS_IPP(int p0, double p1, struct S_IPP p2,  int (*cb)(int, double, struct S_IPP)) ;
+EXPORT int f11_I_IDS_FII(int p0, double p1, struct S_FII p2,  int (*cb)(int, double, struct S_FII)) ;
+EXPORT int f11_I_IDS_FIF(int p0, double p1, struct S_FIF p2,  int (*cb)(int, double, struct S_FIF)) ;
+EXPORT int f11_I_IDS_FID(int p0, double p1, struct S_FID p2,  int (*cb)(int, double, struct S_FID)) ;
+EXPORT int f11_I_IDS_FIP(int p0, double p1, struct S_FIP p2,  int (*cb)(int, double, struct S_FIP)) ;
+EXPORT int f11_I_IDS_FFI(int p0, double p1, struct S_FFI p2,  int (*cb)(int, double, struct S_FFI)) ;
+EXPORT int f11_I_IDS_FFF(int p0, double p1, struct S_FFF p2,  int (*cb)(int, double, struct S_FFF)) ;
+EXPORT int f11_I_IDS_FFD(int p0, double p1, struct S_FFD p2,  int (*cb)(int, double, struct S_FFD)) ;
+EXPORT int f11_I_IDS_FFP(int p0, double p1, struct S_FFP p2,  int (*cb)(int, double, struct S_FFP)) ;
+EXPORT int f11_I_IDS_FDI(int p0, double p1, struct S_FDI p2,  int (*cb)(int, double, struct S_FDI)) ;
+EXPORT int f11_I_IDS_FDF(int p0, double p1, struct S_FDF p2,  int (*cb)(int, double, struct S_FDF)) ;
+EXPORT int f11_I_IDS_FDD(int p0, double p1, struct S_FDD p2,  int (*cb)(int, double, struct S_FDD)) ;
+EXPORT int f11_I_IDS_FDP(int p0, double p1, struct S_FDP p2,  int (*cb)(int, double, struct S_FDP)) ;
+EXPORT int f11_I_IDS_FPI(int p0, double p1, struct S_FPI p2,  int (*cb)(int, double, struct S_FPI)) ;
+EXPORT int f11_I_IDS_FPF(int p0, double p1, struct S_FPF p2,  int (*cb)(int, double, struct S_FPF)) ;
+EXPORT int f11_I_IDS_FPD(int p0, double p1, struct S_FPD p2,  int (*cb)(int, double, struct S_FPD)) ;
+EXPORT int f11_I_IDS_FPP(int p0, double p1, struct S_FPP p2,  int (*cb)(int, double, struct S_FPP)) ;
+EXPORT int f11_I_IDS_DII(int p0, double p1, struct S_DII p2,  int (*cb)(int, double, struct S_DII)) ;
+EXPORT int f11_I_IDS_DIF(int p0, double p1, struct S_DIF p2,  int (*cb)(int, double, struct S_DIF)) ;
+EXPORT int f11_I_IDS_DID(int p0, double p1, struct S_DID p2,  int (*cb)(int, double, struct S_DID)) ;
+EXPORT int f11_I_IDS_DIP(int p0, double p1, struct S_DIP p2,  int (*cb)(int, double, struct S_DIP)) ;
+EXPORT int f11_I_IDS_DFI(int p0, double p1, struct S_DFI p2,  int (*cb)(int, double, struct S_DFI)) ;
+EXPORT int f11_I_IDS_DFF(int p0, double p1, struct S_DFF p2,  int (*cb)(int, double, struct S_DFF)) ;
+EXPORT int f11_I_IDS_DFD(int p0, double p1, struct S_DFD p2,  int (*cb)(int, double, struct S_DFD)) ;
+EXPORT int f11_I_IDS_DFP(int p0, double p1, struct S_DFP p2,  int (*cb)(int, double, struct S_DFP)) ;
+EXPORT int f11_I_IDS_DDI(int p0, double p1, struct S_DDI p2,  int (*cb)(int, double, struct S_DDI)) ;
+EXPORT int f11_I_IDS_DDF(int p0, double p1, struct S_DDF p2,  int (*cb)(int, double, struct S_DDF)) ;
+EXPORT int f11_I_IDS_DDD(int p0, double p1, struct S_DDD p2,  int (*cb)(int, double, struct S_DDD)) ;
+EXPORT int f11_I_IDS_DDP(int p0, double p1, struct S_DDP p2,  int (*cb)(int, double, struct S_DDP)) ;
+EXPORT int f11_I_IDS_DPI(int p0, double p1, struct S_DPI p2,  int (*cb)(int, double, struct S_DPI)) ;
+EXPORT int f11_I_IDS_DPF(int p0, double p1, struct S_DPF p2,  int (*cb)(int, double, struct S_DPF)) ;
+EXPORT int f11_I_IDS_DPD(int p0, double p1, struct S_DPD p2,  int (*cb)(int, double, struct S_DPD)) ;
+EXPORT int f11_I_IDS_DPP(int p0, double p1, struct S_DPP p2,  int (*cb)(int, double, struct S_DPP)) ;
+EXPORT int f11_I_IDS_PII(int p0, double p1, struct S_PII p2,  int (*cb)(int, double, struct S_PII)) ;
+EXPORT int f11_I_IDS_PIF(int p0, double p1, struct S_PIF p2,  int (*cb)(int, double, struct S_PIF)) ;
+EXPORT int f11_I_IDS_PID(int p0, double p1, struct S_PID p2,  int (*cb)(int, double, struct S_PID)) ;
+EXPORT int f11_I_IDS_PIP(int p0, double p1, struct S_PIP p2,  int (*cb)(int, double, struct S_PIP)) ;
+EXPORT int f11_I_IDS_PFI(int p0, double p1, struct S_PFI p2,  int (*cb)(int, double, struct S_PFI)) ;
+EXPORT int f11_I_IDS_PFF(int p0, double p1, struct S_PFF p2,  int (*cb)(int, double, struct S_PFF)) ;
+EXPORT int f11_I_IDS_PFD(int p0, double p1, struct S_PFD p2,  int (*cb)(int, double, struct S_PFD)) ;
+EXPORT int f11_I_IDS_PFP(int p0, double p1, struct S_PFP p2,  int (*cb)(int, double, struct S_PFP)) ;
+EXPORT int f11_I_IDS_PDI(int p0, double p1, struct S_PDI p2,  int (*cb)(int, double, struct S_PDI)) ;
+EXPORT int f11_I_IDS_PDF(int p0, double p1, struct S_PDF p2,  int (*cb)(int, double, struct S_PDF)) ;
+EXPORT int f11_I_IDS_PDD(int p0, double p1, struct S_PDD p2,  int (*cb)(int, double, struct S_PDD)) ;
+EXPORT int f11_I_IDS_PDP(int p0, double p1, struct S_PDP p2,  int (*cb)(int, double, struct S_PDP)) ;
+EXPORT int f11_I_IDS_PPI(int p0, double p1, struct S_PPI p2,  int (*cb)(int, double, struct S_PPI)) ;
+EXPORT int f11_I_IDS_PPF(int p0, double p1, struct S_PPF p2,  int (*cb)(int, double, struct S_PPF)) ;
+EXPORT int f11_I_IDS_PPD(int p0, double p1, struct S_PPD p2,  int (*cb)(int, double, struct S_PPD)) ;
+EXPORT int f11_I_IDS_PPP(int p0, double p1, struct S_PPP p2,  int (*cb)(int, double, struct S_PPP)) ;
+EXPORT int f11_I_IPI_(int p0, void* p1, int p2,  int (*cb)(int, void*, int)) ;
+EXPORT int f11_I_IPF_(int p0, void* p1, float p2,  int (*cb)(int, void*, float)) ;
+EXPORT int f11_I_IPD_(int p0, void* p1, double p2,  int (*cb)(int, void*, double)) ;
+EXPORT int f11_I_IPP_(int p0, void* p1, void* p2,  int (*cb)(int, void*, void*)) ;
+EXPORT int f11_I_IPS_I(int p0, void* p1, struct S_I p2,  int (*cb)(int, void*, struct S_I)) ;
+EXPORT int f11_I_IPS_F(int p0, void* p1, struct S_F p2,  int (*cb)(int, void*, struct S_F)) ;
+EXPORT int f11_I_IPS_D(int p0, void* p1, struct S_D p2,  int (*cb)(int, void*, struct S_D)) ;
+EXPORT int f11_I_IPS_P(int p0, void* p1, struct S_P p2,  int (*cb)(int, void*, struct S_P)) ;
+EXPORT int f11_I_IPS_II(int p0, void* p1, struct S_II p2,  int (*cb)(int, void*, struct S_II)) ;
+EXPORT int f11_I_IPS_IF(int p0, void* p1, struct S_IF p2,  int (*cb)(int, void*, struct S_IF)) ;
+EXPORT int f11_I_IPS_ID(int p0, void* p1, struct S_ID p2,  int (*cb)(int, void*, struct S_ID)) ;
+EXPORT int f11_I_IPS_IP(int p0, void* p1, struct S_IP p2,  int (*cb)(int, void*, struct S_IP)) ;
+EXPORT int f11_I_IPS_FI(int p0, void* p1, struct S_FI p2,  int (*cb)(int, void*, struct S_FI)) ;
+EXPORT int f11_I_IPS_FF(int p0, void* p1, struct S_FF p2,  int (*cb)(int, void*, struct S_FF)) ;
+EXPORT int f11_I_IPS_FD(int p0, void* p1, struct S_FD p2,  int (*cb)(int, void*, struct S_FD)) ;
+EXPORT int f11_I_IPS_FP(int p0, void* p1, struct S_FP p2,  int (*cb)(int, void*, struct S_FP)) ;
+EXPORT int f11_I_IPS_DI(int p0, void* p1, struct S_DI p2,  int (*cb)(int, void*, struct S_DI)) ;
+EXPORT int f11_I_IPS_DF(int p0, void* p1, struct S_DF p2,  int (*cb)(int, void*, struct S_DF)) ;
+EXPORT int f11_I_IPS_DD(int p0, void* p1, struct S_DD p2,  int (*cb)(int, void*, struct S_DD)) ;
+EXPORT int f11_I_IPS_DP(int p0, void* p1, struct S_DP p2,  int (*cb)(int, void*, struct S_DP)) ;
+EXPORT int f11_I_IPS_PI(int p0, void* p1, struct S_PI p2,  int (*cb)(int, void*, struct S_PI)) ;
+EXPORT int f11_I_IPS_PF(int p0, void* p1, struct S_PF p2,  int (*cb)(int, void*, struct S_PF)) ;
+EXPORT int f11_I_IPS_PD(int p0, void* p1, struct S_PD p2,  int (*cb)(int, void*, struct S_PD)) ;
+EXPORT int f11_I_IPS_PP(int p0, void* p1, struct S_PP p2,  int (*cb)(int, void*, struct S_PP)) ;
+EXPORT int f11_I_IPS_III(int p0, void* p1, struct S_III p2,  int (*cb)(int, void*, struct S_III)) ;
+EXPORT int f11_I_IPS_IIF(int p0, void* p1, struct S_IIF p2,  int (*cb)(int, void*, struct S_IIF)) ;
+EXPORT int f11_I_IPS_IID(int p0, void* p1, struct S_IID p2,  int (*cb)(int, void*, struct S_IID)) ;
+EXPORT int f12_I_IPS_IIP(int p0, void* p1, struct S_IIP p2,  int (*cb)(int, void*, struct S_IIP)) ;
+EXPORT int f12_I_IPS_IFI(int p0, void* p1, struct S_IFI p2,  int (*cb)(int, void*, struct S_IFI)) ;
+EXPORT int f12_I_IPS_IFF(int p0, void* p1, struct S_IFF p2,  int (*cb)(int, void*, struct S_IFF)) ;
+EXPORT int f12_I_IPS_IFD(int p0, void* p1, struct S_IFD p2,  int (*cb)(int, void*, struct S_IFD)) ;
+EXPORT int f12_I_IPS_IFP(int p0, void* p1, struct S_IFP p2,  int (*cb)(int, void*, struct S_IFP)) ;
+EXPORT int f12_I_IPS_IDI(int p0, void* p1, struct S_IDI p2,  int (*cb)(int, void*, struct S_IDI)) ;
+EXPORT int f12_I_IPS_IDF(int p0, void* p1, struct S_IDF p2,  int (*cb)(int, void*, struct S_IDF)) ;
+EXPORT int f12_I_IPS_IDD(int p0, void* p1, struct S_IDD p2,  int (*cb)(int, void*, struct S_IDD)) ;
+EXPORT int f12_I_IPS_IDP(int p0, void* p1, struct S_IDP p2,  int (*cb)(int, void*, struct S_IDP)) ;
+EXPORT int f12_I_IPS_IPI(int p0, void* p1, struct S_IPI p2,  int (*cb)(int, void*, struct S_IPI)) ;
+EXPORT int f12_I_IPS_IPF(int p0, void* p1, struct S_IPF p2,  int (*cb)(int, void*, struct S_IPF)) ;
+EXPORT int f12_I_IPS_IPD(int p0, void* p1, struct S_IPD p2,  int (*cb)(int, void*, struct S_IPD)) ;
+EXPORT int f12_I_IPS_IPP(int p0, void* p1, struct S_IPP p2,  int (*cb)(int, void*, struct S_IPP)) ;
+EXPORT int f12_I_IPS_FII(int p0, void* p1, struct S_FII p2,  int (*cb)(int, void*, struct S_FII)) ;
+EXPORT int f12_I_IPS_FIF(int p0, void* p1, struct S_FIF p2,  int (*cb)(int, void*, struct S_FIF)) ;
+EXPORT int f12_I_IPS_FID(int p0, void* p1, struct S_FID p2,  int (*cb)(int, void*, struct S_FID)) ;
+EXPORT int f12_I_IPS_FIP(int p0, void* p1, struct S_FIP p2,  int (*cb)(int, void*, struct S_FIP)) ;
+EXPORT int f12_I_IPS_FFI(int p0, void* p1, struct S_FFI p2,  int (*cb)(int, void*, struct S_FFI)) ;
+EXPORT int f12_I_IPS_FFF(int p0, void* p1, struct S_FFF p2,  int (*cb)(int, void*, struct S_FFF)) ;
+EXPORT int f12_I_IPS_FFD(int p0, void* p1, struct S_FFD p2,  int (*cb)(int, void*, struct S_FFD)) ;
+EXPORT int f12_I_IPS_FFP(int p0, void* p1, struct S_FFP p2,  int (*cb)(int, void*, struct S_FFP)) ;
+EXPORT int f12_I_IPS_FDI(int p0, void* p1, struct S_FDI p2,  int (*cb)(int, void*, struct S_FDI)) ;
+EXPORT int f12_I_IPS_FDF(int p0, void* p1, struct S_FDF p2,  int (*cb)(int, void*, struct S_FDF)) ;
+EXPORT int f12_I_IPS_FDD(int p0, void* p1, struct S_FDD p2,  int (*cb)(int, void*, struct S_FDD)) ;
+EXPORT int f12_I_IPS_FDP(int p0, void* p1, struct S_FDP p2,  int (*cb)(int, void*, struct S_FDP)) ;
+EXPORT int f12_I_IPS_FPI(int p0, void* p1, struct S_FPI p2,  int (*cb)(int, void*, struct S_FPI)) ;
+EXPORT int f12_I_IPS_FPF(int p0, void* p1, struct S_FPF p2,  int (*cb)(int, void*, struct S_FPF)) ;
+EXPORT int f12_I_IPS_FPD(int p0, void* p1, struct S_FPD p2,  int (*cb)(int, void*, struct S_FPD)) ;
+EXPORT int f12_I_IPS_FPP(int p0, void* p1, struct S_FPP p2,  int (*cb)(int, void*, struct S_FPP)) ;
+EXPORT int f12_I_IPS_DII(int p0, void* p1, struct S_DII p2,  int (*cb)(int, void*, struct S_DII)) ;
+EXPORT int f12_I_IPS_DIF(int p0, void* p1, struct S_DIF p2,  int (*cb)(int, void*, struct S_DIF)) ;
+EXPORT int f12_I_IPS_DID(int p0, void* p1, struct S_DID p2,  int (*cb)(int, void*, struct S_DID)) ;
+EXPORT int f12_I_IPS_DIP(int p0, void* p1, struct S_DIP p2,  int (*cb)(int, void*, struct S_DIP)) ;
+EXPORT int f12_I_IPS_DFI(int p0, void* p1, struct S_DFI p2,  int (*cb)(int, void*, struct S_DFI)) ;
+EXPORT int f12_I_IPS_DFF(int p0, void* p1, struct S_DFF p2,  int (*cb)(int, void*, struct S_DFF)) ;
+EXPORT int f12_I_IPS_DFD(int p0, void* p1, struct S_DFD p2,  int (*cb)(int, void*, struct S_DFD)) ;
+EXPORT int f12_I_IPS_DFP(int p0, void* p1, struct S_DFP p2,  int (*cb)(int, void*, struct S_DFP)) ;
+EXPORT int f12_I_IPS_DDI(int p0, void* p1, struct S_DDI p2,  int (*cb)(int, void*, struct S_DDI)) ;
+EXPORT int f12_I_IPS_DDF(int p0, void* p1, struct S_DDF p2,  int (*cb)(int, void*, struct S_DDF)) ;
+EXPORT int f12_I_IPS_DDD(int p0, void* p1, struct S_DDD p2,  int (*cb)(int, void*, struct S_DDD)) ;
+EXPORT int f12_I_IPS_DDP(int p0, void* p1, struct S_DDP p2,  int (*cb)(int, void*, struct S_DDP)) ;
+EXPORT int f12_I_IPS_DPI(int p0, void* p1, struct S_DPI p2,  int (*cb)(int, void*, struct S_DPI)) ;
+EXPORT int f12_I_IPS_DPF(int p0, void* p1, struct S_DPF p2,  int (*cb)(int, void*, struct S_DPF)) ;
+EXPORT int f12_I_IPS_DPD(int p0, void* p1, struct S_DPD p2,  int (*cb)(int, void*, struct S_DPD)) ;
+EXPORT int f12_I_IPS_DPP(int p0, void* p1, struct S_DPP p2,  int (*cb)(int, void*, struct S_DPP)) ;
+EXPORT int f12_I_IPS_PII(int p0, void* p1, struct S_PII p2,  int (*cb)(int, void*, struct S_PII)) ;
+EXPORT int f12_I_IPS_PIF(int p0, void* p1, struct S_PIF p2,  int (*cb)(int, void*, struct S_PIF)) ;
+EXPORT int f12_I_IPS_PID(int p0, void* p1, struct S_PID p2,  int (*cb)(int, void*, struct S_PID)) ;
+EXPORT int f12_I_IPS_PIP(int p0, void* p1, struct S_PIP p2,  int (*cb)(int, void*, struct S_PIP)) ;
+EXPORT int f12_I_IPS_PFI(int p0, void* p1, struct S_PFI p2,  int (*cb)(int, void*, struct S_PFI)) ;
+EXPORT int f12_I_IPS_PFF(int p0, void* p1, struct S_PFF p2,  int (*cb)(int, void*, struct S_PFF)) ;
+EXPORT int f12_I_IPS_PFD(int p0, void* p1, struct S_PFD p2,  int (*cb)(int, void*, struct S_PFD)) ;
+EXPORT int f12_I_IPS_PFP(int p0, void* p1, struct S_PFP p2,  int (*cb)(int, void*, struct S_PFP)) ;
+EXPORT int f12_I_IPS_PDI(int p0, void* p1, struct S_PDI p2,  int (*cb)(int, void*, struct S_PDI)) ;
+EXPORT int f12_I_IPS_PDF(int p0, void* p1, struct S_PDF p2,  int (*cb)(int, void*, struct S_PDF)) ;
+EXPORT int f12_I_IPS_PDD(int p0, void* p1, struct S_PDD p2,  int (*cb)(int, void*, struct S_PDD)) ;
+EXPORT int f12_I_IPS_PDP(int p0, void* p1, struct S_PDP p2,  int (*cb)(int, void*, struct S_PDP)) ;
+EXPORT int f12_I_IPS_PPI(int p0, void* p1, struct S_PPI p2,  int (*cb)(int, void*, struct S_PPI)) ;
+EXPORT int f12_I_IPS_PPF(int p0, void* p1, struct S_PPF p2,  int (*cb)(int, void*, struct S_PPF)) ;
+EXPORT int f12_I_IPS_PPD(int p0, void* p1, struct S_PPD p2,  int (*cb)(int, void*, struct S_PPD)) ;
+EXPORT int f12_I_IPS_PPP(int p0, void* p1, struct S_PPP p2,  int (*cb)(int, void*, struct S_PPP)) ;
+EXPORT int f12_I_ISI_I(int p0, struct S_I p1, int p2,  int (*cb)(int, struct S_I, int)) ;
+EXPORT int f12_I_ISI_F(int p0, struct S_F p1, int p2,  int (*cb)(int, struct S_F, int)) ;
+EXPORT int f12_I_ISI_D(int p0, struct S_D p1, int p2,  int (*cb)(int, struct S_D, int)) ;
+EXPORT int f12_I_ISI_P(int p0, struct S_P p1, int p2,  int (*cb)(int, struct S_P, int)) ;
+EXPORT int f12_I_ISI_II(int p0, struct S_II p1, int p2,  int (*cb)(int, struct S_II, int)) ;
+EXPORT int f12_I_ISI_IF(int p0, struct S_IF p1, int p2,  int (*cb)(int, struct S_IF, int)) ;
+EXPORT int f12_I_ISI_ID(int p0, struct S_ID p1, int p2,  int (*cb)(int, struct S_ID, int)) ;
+EXPORT int f12_I_ISI_IP(int p0, struct S_IP p1, int p2,  int (*cb)(int, struct S_IP, int)) ;
+EXPORT int f12_I_ISI_FI(int p0, struct S_FI p1, int p2,  int (*cb)(int, struct S_FI, int)) ;
+EXPORT int f12_I_ISI_FF(int p0, struct S_FF p1, int p2,  int (*cb)(int, struct S_FF, int)) ;
+EXPORT int f12_I_ISI_FD(int p0, struct S_FD p1, int p2,  int (*cb)(int, struct S_FD, int)) ;
+EXPORT int f12_I_ISI_FP(int p0, struct S_FP p1, int p2,  int (*cb)(int, struct S_FP, int)) ;
+EXPORT int f12_I_ISI_DI(int p0, struct S_DI p1, int p2,  int (*cb)(int, struct S_DI, int)) ;
+EXPORT int f12_I_ISI_DF(int p0, struct S_DF p1, int p2,  int (*cb)(int, struct S_DF, int)) ;
+EXPORT int f12_I_ISI_DD(int p0, struct S_DD p1, int p2,  int (*cb)(int, struct S_DD, int)) ;
+EXPORT int f12_I_ISI_DP(int p0, struct S_DP p1, int p2,  int (*cb)(int, struct S_DP, int)) ;
+EXPORT int f12_I_ISI_PI(int p0, struct S_PI p1, int p2,  int (*cb)(int, struct S_PI, int)) ;
+EXPORT int f12_I_ISI_PF(int p0, struct S_PF p1, int p2,  int (*cb)(int, struct S_PF, int)) ;
+EXPORT int f12_I_ISI_PD(int p0, struct S_PD p1, int p2,  int (*cb)(int, struct S_PD, int)) ;
+EXPORT int f12_I_ISI_PP(int p0, struct S_PP p1, int p2,  int (*cb)(int, struct S_PP, int)) ;
+EXPORT int f12_I_ISI_III(int p0, struct S_III p1, int p2,  int (*cb)(int, struct S_III, int)) ;
+EXPORT int f12_I_ISI_IIF(int p0, struct S_IIF p1, int p2,  int (*cb)(int, struct S_IIF, int)) ;
+EXPORT int f12_I_ISI_IID(int p0, struct S_IID p1, int p2,  int (*cb)(int, struct S_IID, int)) ;
+EXPORT int f12_I_ISI_IIP(int p0, struct S_IIP p1, int p2,  int (*cb)(int, struct S_IIP, int)) ;
+EXPORT int f12_I_ISI_IFI(int p0, struct S_IFI p1, int p2,  int (*cb)(int, struct S_IFI, int)) ;
+EXPORT int f12_I_ISI_IFF(int p0, struct S_IFF p1, int p2,  int (*cb)(int, struct S_IFF, int)) ;
+EXPORT int f12_I_ISI_IFD(int p0, struct S_IFD p1, int p2,  int (*cb)(int, struct S_IFD, int)) ;
+EXPORT int f12_I_ISI_IFP(int p0, struct S_IFP p1, int p2,  int (*cb)(int, struct S_IFP, int)) ;
+EXPORT int f12_I_ISI_IDI(int p0, struct S_IDI p1, int p2,  int (*cb)(int, struct S_IDI, int)) ;
+EXPORT int f12_I_ISI_IDF(int p0, struct S_IDF p1, int p2,  int (*cb)(int, struct S_IDF, int)) ;
+EXPORT int f12_I_ISI_IDD(int p0, struct S_IDD p1, int p2,  int (*cb)(int, struct S_IDD, int)) ;
+EXPORT int f12_I_ISI_IDP(int p0, struct S_IDP p1, int p2,  int (*cb)(int, struct S_IDP, int)) ;
+EXPORT int f12_I_ISI_IPI(int p0, struct S_IPI p1, int p2,  int (*cb)(int, struct S_IPI, int)) ;
+EXPORT int f12_I_ISI_IPF(int p0, struct S_IPF p1, int p2,  int (*cb)(int, struct S_IPF, int)) ;
+EXPORT int f12_I_ISI_IPD(int p0, struct S_IPD p1, int p2,  int (*cb)(int, struct S_IPD, int)) ;
+EXPORT int f12_I_ISI_IPP(int p0, struct S_IPP p1, int p2,  int (*cb)(int, struct S_IPP, int)) ;
+EXPORT int f12_I_ISI_FII(int p0, struct S_FII p1, int p2,  int (*cb)(int, struct S_FII, int)) ;
+EXPORT int f12_I_ISI_FIF(int p0, struct S_FIF p1, int p2,  int (*cb)(int, struct S_FIF, int)) ;
+EXPORT int f12_I_ISI_FID(int p0, struct S_FID p1, int p2,  int (*cb)(int, struct S_FID, int)) ;
+EXPORT int f12_I_ISI_FIP(int p0, struct S_FIP p1, int p2,  int (*cb)(int, struct S_FIP, int)) ;
+EXPORT int f12_I_ISI_FFI(int p0, struct S_FFI p1, int p2,  int (*cb)(int, struct S_FFI, int)) ;
+EXPORT int f12_I_ISI_FFF(int p0, struct S_FFF p1, int p2,  int (*cb)(int, struct S_FFF, int)) ;
+EXPORT int f12_I_ISI_FFD(int p0, struct S_FFD p1, int p2,  int (*cb)(int, struct S_FFD, int)) ;
+EXPORT int f12_I_ISI_FFP(int p0, struct S_FFP p1, int p2,  int (*cb)(int, struct S_FFP, int)) ;
+EXPORT int f12_I_ISI_FDI(int p0, struct S_FDI p1, int p2,  int (*cb)(int, struct S_FDI, int)) ;
+EXPORT int f12_I_ISI_FDF(int p0, struct S_FDF p1, int p2,  int (*cb)(int, struct S_FDF, int)) ;
+EXPORT int f12_I_ISI_FDD(int p0, struct S_FDD p1, int p2,  int (*cb)(int, struct S_FDD, int)) ;
+EXPORT int f12_I_ISI_FDP(int p0, struct S_FDP p1, int p2,  int (*cb)(int, struct S_FDP, int)) ;
+EXPORT int f12_I_ISI_FPI(int p0, struct S_FPI p1, int p2,  int (*cb)(int, struct S_FPI, int)) ;
+EXPORT int f12_I_ISI_FPF(int p0, struct S_FPF p1, int p2,  int (*cb)(int, struct S_FPF, int)) ;
+EXPORT int f12_I_ISI_FPD(int p0, struct S_FPD p1, int p2,  int (*cb)(int, struct S_FPD, int)) ;
+EXPORT int f12_I_ISI_FPP(int p0, struct S_FPP p1, int p2,  int (*cb)(int, struct S_FPP, int)) ;
+EXPORT int f12_I_ISI_DII(int p0, struct S_DII p1, int p2,  int (*cb)(int, struct S_DII, int)) ;
+EXPORT int f12_I_ISI_DIF(int p0, struct S_DIF p1, int p2,  int (*cb)(int, struct S_DIF, int)) ;
+EXPORT int f12_I_ISI_DID(int p0, struct S_DID p1, int p2,  int (*cb)(int, struct S_DID, int)) ;
+EXPORT int f12_I_ISI_DIP(int p0, struct S_DIP p1, int p2,  int (*cb)(int, struct S_DIP, int)) ;
+EXPORT int f12_I_ISI_DFI(int p0, struct S_DFI p1, int p2,  int (*cb)(int, struct S_DFI, int)) ;
+EXPORT int f12_I_ISI_DFF(int p0, struct S_DFF p1, int p2,  int (*cb)(int, struct S_DFF, int)) ;
+EXPORT int f12_I_ISI_DFD(int p0, struct S_DFD p1, int p2,  int (*cb)(int, struct S_DFD, int)) ;
+EXPORT int f12_I_ISI_DFP(int p0, struct S_DFP p1, int p2,  int (*cb)(int, struct S_DFP, int)) ;
+EXPORT int f12_I_ISI_DDI(int p0, struct S_DDI p1, int p2,  int (*cb)(int, struct S_DDI, int)) ;
+EXPORT int f12_I_ISI_DDF(int p0, struct S_DDF p1, int p2,  int (*cb)(int, struct S_DDF, int)) ;
+EXPORT int f12_I_ISI_DDD(int p0, struct S_DDD p1, int p2,  int (*cb)(int, struct S_DDD, int)) ;
+EXPORT int f12_I_ISI_DDP(int p0, struct S_DDP p1, int p2,  int (*cb)(int, struct S_DDP, int)) ;
+EXPORT int f12_I_ISI_DPI(int p0, struct S_DPI p1, int p2,  int (*cb)(int, struct S_DPI, int)) ;
+EXPORT int f12_I_ISI_DPF(int p0, struct S_DPF p1, int p2,  int (*cb)(int, struct S_DPF, int)) ;
+EXPORT int f12_I_ISI_DPD(int p0, struct S_DPD p1, int p2,  int (*cb)(int, struct S_DPD, int)) ;
+EXPORT int f12_I_ISI_DPP(int p0, struct S_DPP p1, int p2,  int (*cb)(int, struct S_DPP, int)) ;
+EXPORT int f12_I_ISI_PII(int p0, struct S_PII p1, int p2,  int (*cb)(int, struct S_PII, int)) ;
+EXPORT int f12_I_ISI_PIF(int p0, struct S_PIF p1, int p2,  int (*cb)(int, struct S_PIF, int)) ;
+EXPORT int f12_I_ISI_PID(int p0, struct S_PID p1, int p2,  int (*cb)(int, struct S_PID, int)) ;
+EXPORT int f12_I_ISI_PIP(int p0, struct S_PIP p1, int p2,  int (*cb)(int, struct S_PIP, int)) ;
+EXPORT int f12_I_ISI_PFI(int p0, struct S_PFI p1, int p2,  int (*cb)(int, struct S_PFI, int)) ;
+EXPORT int f12_I_ISI_PFF(int p0, struct S_PFF p1, int p2,  int (*cb)(int, struct S_PFF, int)) ;
+EXPORT int f12_I_ISI_PFD(int p0, struct S_PFD p1, int p2,  int (*cb)(int, struct S_PFD, int)) ;
+EXPORT int f12_I_ISI_PFP(int p0, struct S_PFP p1, int p2,  int (*cb)(int, struct S_PFP, int)) ;
+EXPORT int f12_I_ISI_PDI(int p0, struct S_PDI p1, int p2,  int (*cb)(int, struct S_PDI, int)) ;
+EXPORT int f12_I_ISI_PDF(int p0, struct S_PDF p1, int p2,  int (*cb)(int, struct S_PDF, int)) ;
+EXPORT int f12_I_ISI_PDD(int p0, struct S_PDD p1, int p2,  int (*cb)(int, struct S_PDD, int)) ;
+EXPORT int f12_I_ISI_PDP(int p0, struct S_PDP p1, int p2,  int (*cb)(int, struct S_PDP, int)) ;
+EXPORT int f12_I_ISI_PPI(int p0, struct S_PPI p1, int p2,  int (*cb)(int, struct S_PPI, int)) ;
+EXPORT int f12_I_ISI_PPF(int p0, struct S_PPF p1, int p2,  int (*cb)(int, struct S_PPF, int)) ;
+EXPORT int f12_I_ISI_PPD(int p0, struct S_PPD p1, int p2,  int (*cb)(int, struct S_PPD, int)) ;
+EXPORT int f12_I_ISI_PPP(int p0, struct S_PPP p1, int p2,  int (*cb)(int, struct S_PPP, int)) ;
+EXPORT int f12_I_ISF_I(int p0, struct S_I p1, float p2,  int (*cb)(int, struct S_I, float)) ;
+EXPORT int f12_I_ISF_F(int p0, struct S_F p1, float p2,  int (*cb)(int, struct S_F, float)) ;
+EXPORT int f12_I_ISF_D(int p0, struct S_D p1, float p2,  int (*cb)(int, struct S_D, float)) ;
+EXPORT int f12_I_ISF_P(int p0, struct S_P p1, float p2,  int (*cb)(int, struct S_P, float)) ;
+EXPORT int f12_I_ISF_II(int p0, struct S_II p1, float p2,  int (*cb)(int, struct S_II, float)) ;
+EXPORT int f12_I_ISF_IF(int p0, struct S_IF p1, float p2,  int (*cb)(int, struct S_IF, float)) ;
+EXPORT int f12_I_ISF_ID(int p0, struct S_ID p1, float p2,  int (*cb)(int, struct S_ID, float)) ;
+EXPORT int f12_I_ISF_IP(int p0, struct S_IP p1, float p2,  int (*cb)(int, struct S_IP, float)) ;
+EXPORT int f12_I_ISF_FI(int p0, struct S_FI p1, float p2,  int (*cb)(int, struct S_FI, float)) ;
+EXPORT int f12_I_ISF_FF(int p0, struct S_FF p1, float p2,  int (*cb)(int, struct S_FF, float)) ;
+EXPORT int f12_I_ISF_FD(int p0, struct S_FD p1, float p2,  int (*cb)(int, struct S_FD, float)) ;
+EXPORT int f12_I_ISF_FP(int p0, struct S_FP p1, float p2,  int (*cb)(int, struct S_FP, float)) ;
+EXPORT int f12_I_ISF_DI(int p0, struct S_DI p1, float p2,  int (*cb)(int, struct S_DI, float)) ;
+EXPORT int f12_I_ISF_DF(int p0, struct S_DF p1, float p2,  int (*cb)(int, struct S_DF, float)) ;
+EXPORT int f12_I_ISF_DD(int p0, struct S_DD p1, float p2,  int (*cb)(int, struct S_DD, float)) ;
+EXPORT int f12_I_ISF_DP(int p0, struct S_DP p1, float p2,  int (*cb)(int, struct S_DP, float)) ;
+EXPORT int f12_I_ISF_PI(int p0, struct S_PI p1, float p2,  int (*cb)(int, struct S_PI, float)) ;
+EXPORT int f12_I_ISF_PF(int p0, struct S_PF p1, float p2,  int (*cb)(int, struct S_PF, float)) ;
+EXPORT int f12_I_ISF_PD(int p0, struct S_PD p1, float p2,  int (*cb)(int, struct S_PD, float)) ;
+EXPORT int f12_I_ISF_PP(int p0, struct S_PP p1, float p2,  int (*cb)(int, struct S_PP, float)) ;
+EXPORT int f12_I_ISF_III(int p0, struct S_III p1, float p2,  int (*cb)(int, struct S_III, float)) ;
+EXPORT int f12_I_ISF_IIF(int p0, struct S_IIF p1, float p2,  int (*cb)(int, struct S_IIF, float)) ;
+EXPORT int f12_I_ISF_IID(int p0, struct S_IID p1, float p2,  int (*cb)(int, struct S_IID, float)) ;
+EXPORT int f12_I_ISF_IIP(int p0, struct S_IIP p1, float p2,  int (*cb)(int, struct S_IIP, float)) ;
+EXPORT int f12_I_ISF_IFI(int p0, struct S_IFI p1, float p2,  int (*cb)(int, struct S_IFI, float)) ;
+EXPORT int f12_I_ISF_IFF(int p0, struct S_IFF p1, float p2,  int (*cb)(int, struct S_IFF, float)) ;
+EXPORT int f12_I_ISF_IFD(int p0, struct S_IFD p1, float p2,  int (*cb)(int, struct S_IFD, float)) ;
+EXPORT int f12_I_ISF_IFP(int p0, struct S_IFP p1, float p2,  int (*cb)(int, struct S_IFP, float)) ;
+EXPORT int f12_I_ISF_IDI(int p0, struct S_IDI p1, float p2,  int (*cb)(int, struct S_IDI, float)) ;
+EXPORT int f12_I_ISF_IDF(int p0, struct S_IDF p1, float p2,  int (*cb)(int, struct S_IDF, float)) ;
+EXPORT int f12_I_ISF_IDD(int p0, struct S_IDD p1, float p2,  int (*cb)(int, struct S_IDD, float)) ;
+EXPORT int f12_I_ISF_IDP(int p0, struct S_IDP p1, float p2,  int (*cb)(int, struct S_IDP, float)) ;
+EXPORT int f12_I_ISF_IPI(int p0, struct S_IPI p1, float p2,  int (*cb)(int, struct S_IPI, float)) ;
+EXPORT int f12_I_ISF_IPF(int p0, struct S_IPF p1, float p2,  int (*cb)(int, struct S_IPF, float)) ;
+EXPORT int f12_I_ISF_IPD(int p0, struct S_IPD p1, float p2,  int (*cb)(int, struct S_IPD, float)) ;
+EXPORT int f12_I_ISF_IPP(int p0, struct S_IPP p1, float p2,  int (*cb)(int, struct S_IPP, float)) ;
+EXPORT int f12_I_ISF_FII(int p0, struct S_FII p1, float p2,  int (*cb)(int, struct S_FII, float)) ;
+EXPORT int f12_I_ISF_FIF(int p0, struct S_FIF p1, float p2,  int (*cb)(int, struct S_FIF, float)) ;
+EXPORT int f12_I_ISF_FID(int p0, struct S_FID p1, float p2,  int (*cb)(int, struct S_FID, float)) ;
+EXPORT int f12_I_ISF_FIP(int p0, struct S_FIP p1, float p2,  int (*cb)(int, struct S_FIP, float)) ;
+EXPORT int f12_I_ISF_FFI(int p0, struct S_FFI p1, float p2,  int (*cb)(int, struct S_FFI, float)) ;
+EXPORT int f12_I_ISF_FFF(int p0, struct S_FFF p1, float p2,  int (*cb)(int, struct S_FFF, float)) ;
+EXPORT int f12_I_ISF_FFD(int p0, struct S_FFD p1, float p2,  int (*cb)(int, struct S_FFD, float)) ;
+EXPORT int f12_I_ISF_FFP(int p0, struct S_FFP p1, float p2,  int (*cb)(int, struct S_FFP, float)) ;
+EXPORT int f12_I_ISF_FDI(int p0, struct S_FDI p1, float p2,  int (*cb)(int, struct S_FDI, float)) ;
+EXPORT int f12_I_ISF_FDF(int p0, struct S_FDF p1, float p2,  int (*cb)(int, struct S_FDF, float)) ;
+EXPORT int f12_I_ISF_FDD(int p0, struct S_FDD p1, float p2,  int (*cb)(int, struct S_FDD, float)) ;
+EXPORT int f12_I_ISF_FDP(int p0, struct S_FDP p1, float p2,  int (*cb)(int, struct S_FDP, float)) ;
+EXPORT int f12_I_ISF_FPI(int p0, struct S_FPI p1, float p2,  int (*cb)(int, struct S_FPI, float)) ;
+EXPORT int f12_I_ISF_FPF(int p0, struct S_FPF p1, float p2,  int (*cb)(int, struct S_FPF, float)) ;
+EXPORT int f12_I_ISF_FPD(int p0, struct S_FPD p1, float p2,  int (*cb)(int, struct S_FPD, float)) ;
+EXPORT int f12_I_ISF_FPP(int p0, struct S_FPP p1, float p2,  int (*cb)(int, struct S_FPP, float)) ;
+EXPORT int f12_I_ISF_DII(int p0, struct S_DII p1, float p2,  int (*cb)(int, struct S_DII, float)) ;
+EXPORT int f12_I_ISF_DIF(int p0, struct S_DIF p1, float p2,  int (*cb)(int, struct S_DIF, float)) ;
+EXPORT int f12_I_ISF_DID(int p0, struct S_DID p1, float p2,  int (*cb)(int, struct S_DID, float)) ;
+EXPORT int f12_I_ISF_DIP(int p0, struct S_DIP p1, float p2,  int (*cb)(int, struct S_DIP, float)) ;
+EXPORT int f12_I_ISF_DFI(int p0, struct S_DFI p1, float p2,  int (*cb)(int, struct S_DFI, float)) ;
+EXPORT int f12_I_ISF_DFF(int p0, struct S_DFF p1, float p2,  int (*cb)(int, struct S_DFF, float)) ;
+EXPORT int f12_I_ISF_DFD(int p0, struct S_DFD p1, float p2,  int (*cb)(int, struct S_DFD, float)) ;
+EXPORT int f12_I_ISF_DFP(int p0, struct S_DFP p1, float p2,  int (*cb)(int, struct S_DFP, float)) ;
+EXPORT int f12_I_ISF_DDI(int p0, struct S_DDI p1, float p2,  int (*cb)(int, struct S_DDI, float)) ;
+EXPORT int f12_I_ISF_DDF(int p0, struct S_DDF p1, float p2,  int (*cb)(int, struct S_DDF, float)) ;
+EXPORT int f12_I_ISF_DDD(int p0, struct S_DDD p1, float p2,  int (*cb)(int, struct S_DDD, float)) ;
+EXPORT int f12_I_ISF_DDP(int p0, struct S_DDP p1, float p2,  int (*cb)(int, struct S_DDP, float)) ;
+EXPORT int f12_I_ISF_DPI(int p0, struct S_DPI p1, float p2,  int (*cb)(int, struct S_DPI, float)) ;
+EXPORT int f12_I_ISF_DPF(int p0, struct S_DPF p1, float p2,  int (*cb)(int, struct S_DPF, float)) ;
+EXPORT int f12_I_ISF_DPD(int p0, struct S_DPD p1, float p2,  int (*cb)(int, struct S_DPD, float)) ;
+EXPORT int f12_I_ISF_DPP(int p0, struct S_DPP p1, float p2,  int (*cb)(int, struct S_DPP, float)) ;
+EXPORT int f12_I_ISF_PII(int p0, struct S_PII p1, float p2,  int (*cb)(int, struct S_PII, float)) ;
+EXPORT int f12_I_ISF_PIF(int p0, struct S_PIF p1, float p2,  int (*cb)(int, struct S_PIF, float)) ;
+EXPORT int f12_I_ISF_PID(int p0, struct S_PID p1, float p2,  int (*cb)(int, struct S_PID, float)) ;
+EXPORT int f12_I_ISF_PIP(int p0, struct S_PIP p1, float p2,  int (*cb)(int, struct S_PIP, float)) ;
+EXPORT int f12_I_ISF_PFI(int p0, struct S_PFI p1, float p2,  int (*cb)(int, struct S_PFI, float)) ;
+EXPORT int f12_I_ISF_PFF(int p0, struct S_PFF p1, float p2,  int (*cb)(int, struct S_PFF, float)) ;
+EXPORT int f12_I_ISF_PFD(int p0, struct S_PFD p1, float p2,  int (*cb)(int, struct S_PFD, float)) ;
+EXPORT int f12_I_ISF_PFP(int p0, struct S_PFP p1, float p2,  int (*cb)(int, struct S_PFP, float)) ;
+EXPORT int f12_I_ISF_PDI(int p0, struct S_PDI p1, float p2,  int (*cb)(int, struct S_PDI, float)) ;
+EXPORT int f12_I_ISF_PDF(int p0, struct S_PDF p1, float p2,  int (*cb)(int, struct S_PDF, float)) ;
+EXPORT int f12_I_ISF_PDD(int p0, struct S_PDD p1, float p2,  int (*cb)(int, struct S_PDD, float)) ;
+EXPORT int f12_I_ISF_PDP(int p0, struct S_PDP p1, float p2,  int (*cb)(int, struct S_PDP, float)) ;
+EXPORT int f12_I_ISF_PPI(int p0, struct S_PPI p1, float p2,  int (*cb)(int, struct S_PPI, float)) ;
+EXPORT int f12_I_ISF_PPF(int p0, struct S_PPF p1, float p2,  int (*cb)(int, struct S_PPF, float)) ;
+EXPORT int f12_I_ISF_PPD(int p0, struct S_PPD p1, float p2,  int (*cb)(int, struct S_PPD, float)) ;
+EXPORT int f12_I_ISF_PPP(int p0, struct S_PPP p1, float p2,  int (*cb)(int, struct S_PPP, float)) ;
+EXPORT int f12_I_ISD_I(int p0, struct S_I p1, double p2,  int (*cb)(int, struct S_I, double)) ;
+EXPORT int f12_I_ISD_F(int p0, struct S_F p1, double p2,  int (*cb)(int, struct S_F, double)) ;
+EXPORT int f12_I_ISD_D(int p0, struct S_D p1, double p2,  int (*cb)(int, struct S_D, double)) ;
+EXPORT int f12_I_ISD_P(int p0, struct S_P p1, double p2,  int (*cb)(int, struct S_P, double)) ;
+EXPORT int f12_I_ISD_II(int p0, struct S_II p1, double p2,  int (*cb)(int, struct S_II, double)) ;
+EXPORT int f12_I_ISD_IF(int p0, struct S_IF p1, double p2,  int (*cb)(int, struct S_IF, double)) ;
+EXPORT int f12_I_ISD_ID(int p0, struct S_ID p1, double p2,  int (*cb)(int, struct S_ID, double)) ;
+EXPORT int f12_I_ISD_IP(int p0, struct S_IP p1, double p2,  int (*cb)(int, struct S_IP, double)) ;
+EXPORT int f12_I_ISD_FI(int p0, struct S_FI p1, double p2,  int (*cb)(int, struct S_FI, double)) ;
+EXPORT int f12_I_ISD_FF(int p0, struct S_FF p1, double p2,  int (*cb)(int, struct S_FF, double)) ;
+EXPORT int f12_I_ISD_FD(int p0, struct S_FD p1, double p2,  int (*cb)(int, struct S_FD, double)) ;
+EXPORT int f12_I_ISD_FP(int p0, struct S_FP p1, double p2,  int (*cb)(int, struct S_FP, double)) ;
+EXPORT int f12_I_ISD_DI(int p0, struct S_DI p1, double p2,  int (*cb)(int, struct S_DI, double)) ;
+EXPORT int f12_I_ISD_DF(int p0, struct S_DF p1, double p2,  int (*cb)(int, struct S_DF, double)) ;
+EXPORT int f12_I_ISD_DD(int p0, struct S_DD p1, double p2,  int (*cb)(int, struct S_DD, double)) ;
+EXPORT int f12_I_ISD_DP(int p0, struct S_DP p1, double p2,  int (*cb)(int, struct S_DP, double)) ;
+EXPORT int f12_I_ISD_PI(int p0, struct S_PI p1, double p2,  int (*cb)(int, struct S_PI, double)) ;
+EXPORT int f12_I_ISD_PF(int p0, struct S_PF p1, double p2,  int (*cb)(int, struct S_PF, double)) ;
+EXPORT int f12_I_ISD_PD(int p0, struct S_PD p1, double p2,  int (*cb)(int, struct S_PD, double)) ;
+EXPORT int f12_I_ISD_PP(int p0, struct S_PP p1, double p2,  int (*cb)(int, struct S_PP, double)) ;
+EXPORT int f12_I_ISD_III(int p0, struct S_III p1, double p2,  int (*cb)(int, struct S_III, double)) ;
+EXPORT int f12_I_ISD_IIF(int p0, struct S_IIF p1, double p2,  int (*cb)(int, struct S_IIF, double)) ;
+EXPORT int f12_I_ISD_IID(int p0, struct S_IID p1, double p2,  int (*cb)(int, struct S_IID, double)) ;
+EXPORT int f12_I_ISD_IIP(int p0, struct S_IIP p1, double p2,  int (*cb)(int, struct S_IIP, double)) ;
+EXPORT int f12_I_ISD_IFI(int p0, struct S_IFI p1, double p2,  int (*cb)(int, struct S_IFI, double)) ;
+EXPORT int f12_I_ISD_IFF(int p0, struct S_IFF p1, double p2,  int (*cb)(int, struct S_IFF, double)) ;
+EXPORT int f12_I_ISD_IFD(int p0, struct S_IFD p1, double p2,  int (*cb)(int, struct S_IFD, double)) ;
+EXPORT int f12_I_ISD_IFP(int p0, struct S_IFP p1, double p2,  int (*cb)(int, struct S_IFP, double)) ;
+EXPORT int f12_I_ISD_IDI(int p0, struct S_IDI p1, double p2,  int (*cb)(int, struct S_IDI, double)) ;
+EXPORT int f12_I_ISD_IDF(int p0, struct S_IDF p1, double p2,  int (*cb)(int, struct S_IDF, double)) ;
+EXPORT int f12_I_ISD_IDD(int p0, struct S_IDD p1, double p2,  int (*cb)(int, struct S_IDD, double)) ;
+EXPORT int f12_I_ISD_IDP(int p0, struct S_IDP p1, double p2,  int (*cb)(int, struct S_IDP, double)) ;
+EXPORT int f12_I_ISD_IPI(int p0, struct S_IPI p1, double p2,  int (*cb)(int, struct S_IPI, double)) ;
+EXPORT int f12_I_ISD_IPF(int p0, struct S_IPF p1, double p2,  int (*cb)(int, struct S_IPF, double)) ;
+EXPORT int f12_I_ISD_IPD(int p0, struct S_IPD p1, double p2,  int (*cb)(int, struct S_IPD, double)) ;
+EXPORT int f12_I_ISD_IPP(int p0, struct S_IPP p1, double p2,  int (*cb)(int, struct S_IPP, double)) ;
+EXPORT int f12_I_ISD_FII(int p0, struct S_FII p1, double p2,  int (*cb)(int, struct S_FII, double)) ;
+EXPORT int f12_I_ISD_FIF(int p0, struct S_FIF p1, double p2,  int (*cb)(int, struct S_FIF, double)) ;
+EXPORT int f12_I_ISD_FID(int p0, struct S_FID p1, double p2,  int (*cb)(int, struct S_FID, double)) ;
+EXPORT int f12_I_ISD_FIP(int p0, struct S_FIP p1, double p2,  int (*cb)(int, struct S_FIP, double)) ;
+EXPORT int f12_I_ISD_FFI(int p0, struct S_FFI p1, double p2,  int (*cb)(int, struct S_FFI, double)) ;
+EXPORT int f12_I_ISD_FFF(int p0, struct S_FFF p1, double p2,  int (*cb)(int, struct S_FFF, double)) ;
+EXPORT int f12_I_ISD_FFD(int p0, struct S_FFD p1, double p2,  int (*cb)(int, struct S_FFD, double)) ;
+EXPORT int f12_I_ISD_FFP(int p0, struct S_FFP p1, double p2,  int (*cb)(int, struct S_FFP, double)) ;
+EXPORT int f12_I_ISD_FDI(int p0, struct S_FDI p1, double p2,  int (*cb)(int, struct S_FDI, double)) ;
+EXPORT int f12_I_ISD_FDF(int p0, struct S_FDF p1, double p2,  int (*cb)(int, struct S_FDF, double)) ;
+EXPORT int f12_I_ISD_FDD(int p0, struct S_FDD p1, double p2,  int (*cb)(int, struct S_FDD, double)) ;
+EXPORT int f12_I_ISD_FDP(int p0, struct S_FDP p1, double p2,  int (*cb)(int, struct S_FDP, double)) ;
+EXPORT int f12_I_ISD_FPI(int p0, struct S_FPI p1, double p2,  int (*cb)(int, struct S_FPI, double)) ;
+EXPORT int f12_I_ISD_FPF(int p0, struct S_FPF p1, double p2,  int (*cb)(int, struct S_FPF, double)) ;
+EXPORT int f12_I_ISD_FPD(int p0, struct S_FPD p1, double p2,  int (*cb)(int, struct S_FPD, double)) ;
+EXPORT int f12_I_ISD_FPP(int p0, struct S_FPP p1, double p2,  int (*cb)(int, struct S_FPP, double)) ;
+EXPORT int f12_I_ISD_DII(int p0, struct S_DII p1, double p2,  int (*cb)(int, struct S_DII, double)) ;
+EXPORT int f12_I_ISD_DIF(int p0, struct S_DIF p1, double p2,  int (*cb)(int, struct S_DIF, double)) ;
+EXPORT int f12_I_ISD_DID(int p0, struct S_DID p1, double p2,  int (*cb)(int, struct S_DID, double)) ;
+EXPORT int f12_I_ISD_DIP(int p0, struct S_DIP p1, double p2,  int (*cb)(int, struct S_DIP, double)) ;
+EXPORT int f12_I_ISD_DFI(int p0, struct S_DFI p1, double p2,  int (*cb)(int, struct S_DFI, double)) ;
+EXPORT int f12_I_ISD_DFF(int p0, struct S_DFF p1, double p2,  int (*cb)(int, struct S_DFF, double)) ;
+EXPORT int f12_I_ISD_DFD(int p0, struct S_DFD p1, double p2,  int (*cb)(int, struct S_DFD, double)) ;
+EXPORT int f12_I_ISD_DFP(int p0, struct S_DFP p1, double p2,  int (*cb)(int, struct S_DFP, double)) ;
+EXPORT int f12_I_ISD_DDI(int p0, struct S_DDI p1, double p2,  int (*cb)(int, struct S_DDI, double)) ;
+EXPORT int f12_I_ISD_DDF(int p0, struct S_DDF p1, double p2,  int (*cb)(int, struct S_DDF, double)) ;
+EXPORT int f12_I_ISD_DDD(int p0, struct S_DDD p1, double p2,  int (*cb)(int, struct S_DDD, double)) ;
+EXPORT int f12_I_ISD_DDP(int p0, struct S_DDP p1, double p2,  int (*cb)(int, struct S_DDP, double)) ;
+EXPORT int f12_I_ISD_DPI(int p0, struct S_DPI p1, double p2,  int (*cb)(int, struct S_DPI, double)) ;
+EXPORT int f12_I_ISD_DPF(int p0, struct S_DPF p1, double p2,  int (*cb)(int, struct S_DPF, double)) ;
+EXPORT int f12_I_ISD_DPD(int p0, struct S_DPD p1, double p2,  int (*cb)(int, struct S_DPD, double)) ;
+EXPORT int f12_I_ISD_DPP(int p0, struct S_DPP p1, double p2,  int (*cb)(int, struct S_DPP, double)) ;
+EXPORT int f12_I_ISD_PII(int p0, struct S_PII p1, double p2,  int (*cb)(int, struct S_PII, double)) ;
+EXPORT int f12_I_ISD_PIF(int p0, struct S_PIF p1, double p2,  int (*cb)(int, struct S_PIF, double)) ;
+EXPORT int f12_I_ISD_PID(int p0, struct S_PID p1, double p2,  int (*cb)(int, struct S_PID, double)) ;
+EXPORT int f12_I_ISD_PIP(int p0, struct S_PIP p1, double p2,  int (*cb)(int, struct S_PIP, double)) ;
+EXPORT int f12_I_ISD_PFI(int p0, struct S_PFI p1, double p2,  int (*cb)(int, struct S_PFI, double)) ;
+EXPORT int f12_I_ISD_PFF(int p0, struct S_PFF p1, double p2,  int (*cb)(int, struct S_PFF, double)) ;
+EXPORT int f12_I_ISD_PFD(int p0, struct S_PFD p1, double p2,  int (*cb)(int, struct S_PFD, double)) ;
+EXPORT int f12_I_ISD_PFP(int p0, struct S_PFP p1, double p2,  int (*cb)(int, struct S_PFP, double)) ;
+EXPORT int f12_I_ISD_PDI(int p0, struct S_PDI p1, double p2,  int (*cb)(int, struct S_PDI, double)) ;
+EXPORT int f12_I_ISD_PDF(int p0, struct S_PDF p1, double p2,  int (*cb)(int, struct S_PDF, double)) ;
+EXPORT int f12_I_ISD_PDD(int p0, struct S_PDD p1, double p2,  int (*cb)(int, struct S_PDD, double)) ;
+EXPORT int f12_I_ISD_PDP(int p0, struct S_PDP p1, double p2,  int (*cb)(int, struct S_PDP, double)) ;
+EXPORT int f12_I_ISD_PPI(int p0, struct S_PPI p1, double p2,  int (*cb)(int, struct S_PPI, double)) ;
+EXPORT int f12_I_ISD_PPF(int p0, struct S_PPF p1, double p2,  int (*cb)(int, struct S_PPF, double)) ;
+EXPORT int f12_I_ISD_PPD(int p0, struct S_PPD p1, double p2,  int (*cb)(int, struct S_PPD, double)) ;
+EXPORT int f12_I_ISD_PPP(int p0, struct S_PPP p1, double p2,  int (*cb)(int, struct S_PPP, double)) ;
+EXPORT int f12_I_ISP_I(int p0, struct S_I p1, void* p2,  int (*cb)(int, struct S_I, void*)) ;
+EXPORT int f12_I_ISP_F(int p0, struct S_F p1, void* p2,  int (*cb)(int, struct S_F, void*)) ;
+EXPORT int f12_I_ISP_D(int p0, struct S_D p1, void* p2,  int (*cb)(int, struct S_D, void*)) ;
+EXPORT int f12_I_ISP_P(int p0, struct S_P p1, void* p2,  int (*cb)(int, struct S_P, void*)) ;
+EXPORT int f12_I_ISP_II(int p0, struct S_II p1, void* p2,  int (*cb)(int, struct S_II, void*)) ;
+EXPORT int f12_I_ISP_IF(int p0, struct S_IF p1, void* p2,  int (*cb)(int, struct S_IF, void*)) ;
+EXPORT int f12_I_ISP_ID(int p0, struct S_ID p1, void* p2,  int (*cb)(int, struct S_ID, void*)) ;
+EXPORT int f12_I_ISP_IP(int p0, struct S_IP p1, void* p2,  int (*cb)(int, struct S_IP, void*)) ;
+EXPORT int f12_I_ISP_FI(int p0, struct S_FI p1, void* p2,  int (*cb)(int, struct S_FI, void*)) ;
+EXPORT int f12_I_ISP_FF(int p0, struct S_FF p1, void* p2,  int (*cb)(int, struct S_FF, void*)) ;
+EXPORT int f12_I_ISP_FD(int p0, struct S_FD p1, void* p2,  int (*cb)(int, struct S_FD, void*)) ;
+EXPORT int f12_I_ISP_FP(int p0, struct S_FP p1, void* p2,  int (*cb)(int, struct S_FP, void*)) ;
+EXPORT int f12_I_ISP_DI(int p0, struct S_DI p1, void* p2,  int (*cb)(int, struct S_DI, void*)) ;
+EXPORT int f12_I_ISP_DF(int p0, struct S_DF p1, void* p2,  int (*cb)(int, struct S_DF, void*)) ;
+EXPORT int f12_I_ISP_DD(int p0, struct S_DD p1, void* p2,  int (*cb)(int, struct S_DD, void*)) ;
+EXPORT int f12_I_ISP_DP(int p0, struct S_DP p1, void* p2,  int (*cb)(int, struct S_DP, void*)) ;
+EXPORT int f12_I_ISP_PI(int p0, struct S_PI p1, void* p2,  int (*cb)(int, struct S_PI, void*)) ;
+EXPORT int f12_I_ISP_PF(int p0, struct S_PF p1, void* p2,  int (*cb)(int, struct S_PF, void*)) ;
+EXPORT int f12_I_ISP_PD(int p0, struct S_PD p1, void* p2,  int (*cb)(int, struct S_PD, void*)) ;
+EXPORT int f12_I_ISP_PP(int p0, struct S_PP p1, void* p2,  int (*cb)(int, struct S_PP, void*)) ;
+EXPORT int f12_I_ISP_III(int p0, struct S_III p1, void* p2,  int (*cb)(int, struct S_III, void*)) ;
+EXPORT int f12_I_ISP_IIF(int p0, struct S_IIF p1, void* p2,  int (*cb)(int, struct S_IIF, void*)) ;
+EXPORT int f12_I_ISP_IID(int p0, struct S_IID p1, void* p2,  int (*cb)(int, struct S_IID, void*)) ;
+EXPORT int f12_I_ISP_IIP(int p0, struct S_IIP p1, void* p2,  int (*cb)(int, struct S_IIP, void*)) ;
+EXPORT int f12_I_ISP_IFI(int p0, struct S_IFI p1, void* p2,  int (*cb)(int, struct S_IFI, void*)) ;
+EXPORT int f12_I_ISP_IFF(int p0, struct S_IFF p1, void* p2,  int (*cb)(int, struct S_IFF, void*)) ;
+EXPORT int f12_I_ISP_IFD(int p0, struct S_IFD p1, void* p2,  int (*cb)(int, struct S_IFD, void*)) ;
+EXPORT int f12_I_ISP_IFP(int p0, struct S_IFP p1, void* p2,  int (*cb)(int, struct S_IFP, void*)) ;
+EXPORT int f12_I_ISP_IDI(int p0, struct S_IDI p1, void* p2,  int (*cb)(int, struct S_IDI, void*)) ;
+EXPORT int f12_I_ISP_IDF(int p0, struct S_IDF p1, void* p2,  int (*cb)(int, struct S_IDF, void*)) ;
+EXPORT int f12_I_ISP_IDD(int p0, struct S_IDD p1, void* p2,  int (*cb)(int, struct S_IDD, void*)) ;
+EXPORT int f12_I_ISP_IDP(int p0, struct S_IDP p1, void* p2,  int (*cb)(int, struct S_IDP, void*)) ;
+EXPORT int f12_I_ISP_IPI(int p0, struct S_IPI p1, void* p2,  int (*cb)(int, struct S_IPI, void*)) ;
+EXPORT int f12_I_ISP_IPF(int p0, struct S_IPF p1, void* p2,  int (*cb)(int, struct S_IPF, void*)) ;
+EXPORT int f12_I_ISP_IPD(int p0, struct S_IPD p1, void* p2,  int (*cb)(int, struct S_IPD, void*)) ;
+EXPORT int f12_I_ISP_IPP(int p0, struct S_IPP p1, void* p2,  int (*cb)(int, struct S_IPP, void*)) ;
+EXPORT int f12_I_ISP_FII(int p0, struct S_FII p1, void* p2,  int (*cb)(int, struct S_FII, void*)) ;
+EXPORT int f12_I_ISP_FIF(int p0, struct S_FIF p1, void* p2,  int (*cb)(int, struct S_FIF, void*)) ;
+EXPORT int f12_I_ISP_FID(int p0, struct S_FID p1, void* p2,  int (*cb)(int, struct S_FID, void*)) ;
+EXPORT int f12_I_ISP_FIP(int p0, struct S_FIP p1, void* p2,  int (*cb)(int, struct S_FIP, void*)) ;
+EXPORT int f12_I_ISP_FFI(int p0, struct S_FFI p1, void* p2,  int (*cb)(int, struct S_FFI, void*)) ;
+EXPORT int f12_I_ISP_FFF(int p0, struct S_FFF p1, void* p2,  int (*cb)(int, struct S_FFF, void*)) ;
+EXPORT int f12_I_ISP_FFD(int p0, struct S_FFD p1, void* p2,  int (*cb)(int, struct S_FFD, void*)) ;
+EXPORT int f12_I_ISP_FFP(int p0, struct S_FFP p1, void* p2,  int (*cb)(int, struct S_FFP, void*)) ;
+EXPORT int f12_I_ISP_FDI(int p0, struct S_FDI p1, void* p2,  int (*cb)(int, struct S_FDI, void*)) ;
+EXPORT int f12_I_ISP_FDF(int p0, struct S_FDF p1, void* p2,  int (*cb)(int, struct S_FDF, void*)) ;
+EXPORT int f12_I_ISP_FDD(int p0, struct S_FDD p1, void* p2,  int (*cb)(int, struct S_FDD, void*)) ;
+EXPORT int f12_I_ISP_FDP(int p0, struct S_FDP p1, void* p2,  int (*cb)(int, struct S_FDP, void*)) ;
+EXPORT int f12_I_ISP_FPI(int p0, struct S_FPI p1, void* p2,  int (*cb)(int, struct S_FPI, void*)) ;
+EXPORT int f12_I_ISP_FPF(int p0, struct S_FPF p1, void* p2,  int (*cb)(int, struct S_FPF, void*)) ;
+EXPORT int f12_I_ISP_FPD(int p0, struct S_FPD p1, void* p2,  int (*cb)(int, struct S_FPD, void*)) ;
+EXPORT int f12_I_ISP_FPP(int p0, struct S_FPP p1, void* p2,  int (*cb)(int, struct S_FPP, void*)) ;
+EXPORT int f12_I_ISP_DII(int p0, struct S_DII p1, void* p2,  int (*cb)(int, struct S_DII, void*)) ;
+EXPORT int f12_I_ISP_DIF(int p0, struct S_DIF p1, void* p2,  int (*cb)(int, struct S_DIF, void*)) ;
+EXPORT int f12_I_ISP_DID(int p0, struct S_DID p1, void* p2,  int (*cb)(int, struct S_DID, void*)) ;
+EXPORT int f12_I_ISP_DIP(int p0, struct S_DIP p1, void* p2,  int (*cb)(int, struct S_DIP, void*)) ;
+EXPORT int f12_I_ISP_DFI(int p0, struct S_DFI p1, void* p2,  int (*cb)(int, struct S_DFI, void*)) ;
+EXPORT int f12_I_ISP_DFF(int p0, struct S_DFF p1, void* p2,  int (*cb)(int, struct S_DFF, void*)) ;
+EXPORT int f12_I_ISP_DFD(int p0, struct S_DFD p1, void* p2,  int (*cb)(int, struct S_DFD, void*)) ;
+EXPORT int f12_I_ISP_DFP(int p0, struct S_DFP p1, void* p2,  int (*cb)(int, struct S_DFP, void*)) ;
+EXPORT int f12_I_ISP_DDI(int p0, struct S_DDI p1, void* p2,  int (*cb)(int, struct S_DDI, void*)) ;
+EXPORT int f12_I_ISP_DDF(int p0, struct S_DDF p1, void* p2,  int (*cb)(int, struct S_DDF, void*)) ;
+EXPORT int f12_I_ISP_DDD(int p0, struct S_DDD p1, void* p2,  int (*cb)(int, struct S_DDD, void*)) ;
+EXPORT int f12_I_ISP_DDP(int p0, struct S_DDP p1, void* p2,  int (*cb)(int, struct S_DDP, void*)) ;
+EXPORT int f12_I_ISP_DPI(int p0, struct S_DPI p1, void* p2,  int (*cb)(int, struct S_DPI, void*)) ;
+EXPORT int f12_I_ISP_DPF(int p0, struct S_DPF p1, void* p2,  int (*cb)(int, struct S_DPF, void*)) ;
+EXPORT int f12_I_ISP_DPD(int p0, struct S_DPD p1, void* p2,  int (*cb)(int, struct S_DPD, void*)) ;
+EXPORT int f12_I_ISP_DPP(int p0, struct S_DPP p1, void* p2,  int (*cb)(int, struct S_DPP, void*)) ;
+EXPORT int f12_I_ISP_PII(int p0, struct S_PII p1, void* p2,  int (*cb)(int, struct S_PII, void*)) ;
+EXPORT int f12_I_ISP_PIF(int p0, struct S_PIF p1, void* p2,  int (*cb)(int, struct S_PIF, void*)) ;
+EXPORT int f12_I_ISP_PID(int p0, struct S_PID p1, void* p2,  int (*cb)(int, struct S_PID, void*)) ;
+EXPORT int f12_I_ISP_PIP(int p0, struct S_PIP p1, void* p2,  int (*cb)(int, struct S_PIP, void*)) ;
+EXPORT int f12_I_ISP_PFI(int p0, struct S_PFI p1, void* p2,  int (*cb)(int, struct S_PFI, void*)) ;
+EXPORT int f12_I_ISP_PFF(int p0, struct S_PFF p1, void* p2,  int (*cb)(int, struct S_PFF, void*)) ;
+EXPORT int f12_I_ISP_PFD(int p0, struct S_PFD p1, void* p2,  int (*cb)(int, struct S_PFD, void*)) ;
+EXPORT int f12_I_ISP_PFP(int p0, struct S_PFP p1, void* p2,  int (*cb)(int, struct S_PFP, void*)) ;
+EXPORT int f12_I_ISP_PDI(int p0, struct S_PDI p1, void* p2,  int (*cb)(int, struct S_PDI, void*)) ;
+EXPORT int f12_I_ISP_PDF(int p0, struct S_PDF p1, void* p2,  int (*cb)(int, struct S_PDF, void*)) ;
+EXPORT int f12_I_ISP_PDD(int p0, struct S_PDD p1, void* p2,  int (*cb)(int, struct S_PDD, void*)) ;
+EXPORT int f12_I_ISP_PDP(int p0, struct S_PDP p1, void* p2,  int (*cb)(int, struct S_PDP, void*)) ;
+EXPORT int f12_I_ISP_PPI(int p0, struct S_PPI p1, void* p2,  int (*cb)(int, struct S_PPI, void*)) ;
+EXPORT int f12_I_ISP_PPF(int p0, struct S_PPF p1, void* p2,  int (*cb)(int, struct S_PPF, void*)) ;
+EXPORT int f12_I_ISP_PPD(int p0, struct S_PPD p1, void* p2,  int (*cb)(int, struct S_PPD, void*)) ;
+EXPORT int f12_I_ISP_PPP(int p0, struct S_PPP p1, void* p2,  int (*cb)(int, struct S_PPP, void*)) ;
+EXPORT int f12_I_ISS_I(int p0, struct S_I p1, struct S_I p2,  int (*cb)(int, struct S_I, struct S_I)) ;
+EXPORT int f12_I_ISS_F(int p0, struct S_F p1, struct S_F p2,  int (*cb)(int, struct S_F, struct S_F)) ;
+EXPORT int f12_I_ISS_D(int p0, struct S_D p1, struct S_D p2,  int (*cb)(int, struct S_D, struct S_D)) ;
+EXPORT int f12_I_ISS_P(int p0, struct S_P p1, struct S_P p2,  int (*cb)(int, struct S_P, struct S_P)) ;
+EXPORT int f12_I_ISS_II(int p0, struct S_II p1, struct S_II p2,  int (*cb)(int, struct S_II, struct S_II)) ;
+EXPORT int f12_I_ISS_IF(int p0, struct S_IF p1, struct S_IF p2,  int (*cb)(int, struct S_IF, struct S_IF)) ;
+EXPORT int f12_I_ISS_ID(int p0, struct S_ID p1, struct S_ID p2,  int (*cb)(int, struct S_ID, struct S_ID)) ;
+EXPORT int f12_I_ISS_IP(int p0, struct S_IP p1, struct S_IP p2,  int (*cb)(int, struct S_IP, struct S_IP)) ;
+EXPORT int f12_I_ISS_FI(int p0, struct S_FI p1, struct S_FI p2,  int (*cb)(int, struct S_FI, struct S_FI)) ;
+EXPORT int f12_I_ISS_FF(int p0, struct S_FF p1, struct S_FF p2,  int (*cb)(int, struct S_FF, struct S_FF)) ;
+EXPORT int f12_I_ISS_FD(int p0, struct S_FD p1, struct S_FD p2,  int (*cb)(int, struct S_FD, struct S_FD)) ;
+EXPORT int f12_I_ISS_FP(int p0, struct S_FP p1, struct S_FP p2,  int (*cb)(int, struct S_FP, struct S_FP)) ;
+EXPORT int f12_I_ISS_DI(int p0, struct S_DI p1, struct S_DI p2,  int (*cb)(int, struct S_DI, struct S_DI)) ;
+EXPORT int f12_I_ISS_DF(int p0, struct S_DF p1, struct S_DF p2,  int (*cb)(int, struct S_DF, struct S_DF)) ;
+EXPORT int f12_I_ISS_DD(int p0, struct S_DD p1, struct S_DD p2,  int (*cb)(int, struct S_DD, struct S_DD)) ;
+EXPORT int f12_I_ISS_DP(int p0, struct S_DP p1, struct S_DP p2,  int (*cb)(int, struct S_DP, struct S_DP)) ;
+EXPORT int f12_I_ISS_PI(int p0, struct S_PI p1, struct S_PI p2,  int (*cb)(int, struct S_PI, struct S_PI)) ;
+EXPORT int f12_I_ISS_PF(int p0, struct S_PF p1, struct S_PF p2,  int (*cb)(int, struct S_PF, struct S_PF)) ;
+EXPORT int f12_I_ISS_PD(int p0, struct S_PD p1, struct S_PD p2,  int (*cb)(int, struct S_PD, struct S_PD)) ;
+EXPORT int f12_I_ISS_PP(int p0, struct S_PP p1, struct S_PP p2,  int (*cb)(int, struct S_PP, struct S_PP)) ;
+EXPORT int f12_I_ISS_III(int p0, struct S_III p1, struct S_III p2,  int (*cb)(int, struct S_III, struct S_III)) ;
+EXPORT int f12_I_ISS_IIF(int p0, struct S_IIF p1, struct S_IIF p2,  int (*cb)(int, struct S_IIF, struct S_IIF)) ;
+EXPORT int f12_I_ISS_IID(int p0, struct S_IID p1, struct S_IID p2,  int (*cb)(int, struct S_IID, struct S_IID)) ;
+EXPORT int f12_I_ISS_IIP(int p0, struct S_IIP p1, struct S_IIP p2,  int (*cb)(int, struct S_IIP, struct S_IIP)) ;
+EXPORT int f12_I_ISS_IFI(int p0, struct S_IFI p1, struct S_IFI p2,  int (*cb)(int, struct S_IFI, struct S_IFI)) ;
+EXPORT int f12_I_ISS_IFF(int p0, struct S_IFF p1, struct S_IFF p2,  int (*cb)(int, struct S_IFF, struct S_IFF)) ;
+EXPORT int f12_I_ISS_IFD(int p0, struct S_IFD p1, struct S_IFD p2,  int (*cb)(int, struct S_IFD, struct S_IFD)) ;
+EXPORT int f12_I_ISS_IFP(int p0, struct S_IFP p1, struct S_IFP p2,  int (*cb)(int, struct S_IFP, struct S_IFP)) ;
+EXPORT int f12_I_ISS_IDI(int p0, struct S_IDI p1, struct S_IDI p2,  int (*cb)(int, struct S_IDI, struct S_IDI)) ;
+EXPORT int f12_I_ISS_IDF(int p0, struct S_IDF p1, struct S_IDF p2,  int (*cb)(int, struct S_IDF, struct S_IDF)) ;
+EXPORT int f12_I_ISS_IDD(int p0, struct S_IDD p1, struct S_IDD p2,  int (*cb)(int, struct S_IDD, struct S_IDD)) ;
+EXPORT int f12_I_ISS_IDP(int p0, struct S_IDP p1, struct S_IDP p2,  int (*cb)(int, struct S_IDP, struct S_IDP)) ;
+EXPORT int f12_I_ISS_IPI(int p0, struct S_IPI p1, struct S_IPI p2,  int (*cb)(int, struct S_IPI, struct S_IPI)) ;
+EXPORT int f12_I_ISS_IPF(int p0, struct S_IPF p1, struct S_IPF p2,  int (*cb)(int, struct S_IPF, struct S_IPF)) ;
+EXPORT int f12_I_ISS_IPD(int p0, struct S_IPD p1, struct S_IPD p2,  int (*cb)(int, struct S_IPD, struct S_IPD)) ;
+EXPORT int f12_I_ISS_IPP(int p0, struct S_IPP p1, struct S_IPP p2,  int (*cb)(int, struct S_IPP, struct S_IPP)) ;
+EXPORT int f12_I_ISS_FII(int p0, struct S_FII p1, struct S_FII p2,  int (*cb)(int, struct S_FII, struct S_FII)) ;
+EXPORT int f12_I_ISS_FIF(int p0, struct S_FIF p1, struct S_FIF p2,  int (*cb)(int, struct S_FIF, struct S_FIF)) ;
+EXPORT int f12_I_ISS_FID(int p0, struct S_FID p1, struct S_FID p2,  int (*cb)(int, struct S_FID, struct S_FID)) ;
+EXPORT int f12_I_ISS_FIP(int p0, struct S_FIP p1, struct S_FIP p2,  int (*cb)(int, struct S_FIP, struct S_FIP)) ;
+EXPORT int f12_I_ISS_FFI(int p0, struct S_FFI p1, struct S_FFI p2,  int (*cb)(int, struct S_FFI, struct S_FFI)) ;
+EXPORT int f12_I_ISS_FFF(int p0, struct S_FFF p1, struct S_FFF p2,  int (*cb)(int, struct S_FFF, struct S_FFF)) ;
+EXPORT int f12_I_ISS_FFD(int p0, struct S_FFD p1, struct S_FFD p2,  int (*cb)(int, struct S_FFD, struct S_FFD)) ;
+EXPORT int f12_I_ISS_FFP(int p0, struct S_FFP p1, struct S_FFP p2,  int (*cb)(int, struct S_FFP, struct S_FFP)) ;
+EXPORT int f12_I_ISS_FDI(int p0, struct S_FDI p1, struct S_FDI p2,  int (*cb)(int, struct S_FDI, struct S_FDI)) ;
+EXPORT int f12_I_ISS_FDF(int p0, struct S_FDF p1, struct S_FDF p2,  int (*cb)(int, struct S_FDF, struct S_FDF)) ;
+EXPORT int f12_I_ISS_FDD(int p0, struct S_FDD p1, struct S_FDD p2,  int (*cb)(int, struct S_FDD, struct S_FDD)) ;
+EXPORT int f12_I_ISS_FDP(int p0, struct S_FDP p1, struct S_FDP p2,  int (*cb)(int, struct S_FDP, struct S_FDP)) ;
+EXPORT int f12_I_ISS_FPI(int p0, struct S_FPI p1, struct S_FPI p2,  int (*cb)(int, struct S_FPI, struct S_FPI)) ;
+EXPORT int f12_I_ISS_FPF(int p0, struct S_FPF p1, struct S_FPF p2,  int (*cb)(int, struct S_FPF, struct S_FPF)) ;
+EXPORT int f12_I_ISS_FPD(int p0, struct S_FPD p1, struct S_FPD p2,  int (*cb)(int, struct S_FPD, struct S_FPD)) ;
+EXPORT int f12_I_ISS_FPP(int p0, struct S_FPP p1, struct S_FPP p2,  int (*cb)(int, struct S_FPP, struct S_FPP)) ;
+EXPORT int f12_I_ISS_DII(int p0, struct S_DII p1, struct S_DII p2,  int (*cb)(int, struct S_DII, struct S_DII)) ;
+EXPORT int f12_I_ISS_DIF(int p0, struct S_DIF p1, struct S_DIF p2,  int (*cb)(int, struct S_DIF, struct S_DIF)) ;
+EXPORT int f12_I_ISS_DID(int p0, struct S_DID p1, struct S_DID p2,  int (*cb)(int, struct S_DID, struct S_DID)) ;
+EXPORT int f12_I_ISS_DIP(int p0, struct S_DIP p1, struct S_DIP p2,  int (*cb)(int, struct S_DIP, struct S_DIP)) ;
+EXPORT int f12_I_ISS_DFI(int p0, struct S_DFI p1, struct S_DFI p2,  int (*cb)(int, struct S_DFI, struct S_DFI)) ;
+EXPORT int f12_I_ISS_DFF(int p0, struct S_DFF p1, struct S_DFF p2,  int (*cb)(int, struct S_DFF, struct S_DFF)) ;
+EXPORT int f12_I_ISS_DFD(int p0, struct S_DFD p1, struct S_DFD p2,  int (*cb)(int, struct S_DFD, struct S_DFD)) ;
+EXPORT int f12_I_ISS_DFP(int p0, struct S_DFP p1, struct S_DFP p2,  int (*cb)(int, struct S_DFP, struct S_DFP)) ;
+EXPORT int f12_I_ISS_DDI(int p0, struct S_DDI p1, struct S_DDI p2,  int (*cb)(int, struct S_DDI, struct S_DDI)) ;
+EXPORT int f12_I_ISS_DDF(int p0, struct S_DDF p1, struct S_DDF p2,  int (*cb)(int, struct S_DDF, struct S_DDF)) ;
+EXPORT int f12_I_ISS_DDD(int p0, struct S_DDD p1, struct S_DDD p2,  int (*cb)(int, struct S_DDD, struct S_DDD)) ;
+EXPORT int f12_I_ISS_DDP(int p0, struct S_DDP p1, struct S_DDP p2,  int (*cb)(int, struct S_DDP, struct S_DDP)) ;
+EXPORT int f12_I_ISS_DPI(int p0, struct S_DPI p1, struct S_DPI p2,  int (*cb)(int, struct S_DPI, struct S_DPI)) ;
+EXPORT int f12_I_ISS_DPF(int p0, struct S_DPF p1, struct S_DPF p2,  int (*cb)(int, struct S_DPF, struct S_DPF)) ;
+EXPORT int f12_I_ISS_DPD(int p0, struct S_DPD p1, struct S_DPD p2,  int (*cb)(int, struct S_DPD, struct S_DPD)) ;
+EXPORT int f12_I_ISS_DPP(int p0, struct S_DPP p1, struct S_DPP p2,  int (*cb)(int, struct S_DPP, struct S_DPP)) ;
+EXPORT int f12_I_ISS_PII(int p0, struct S_PII p1, struct S_PII p2,  int (*cb)(int, struct S_PII, struct S_PII)) ;
+EXPORT int f12_I_ISS_PIF(int p0, struct S_PIF p1, struct S_PIF p2,  int (*cb)(int, struct S_PIF, struct S_PIF)) ;
+EXPORT int f12_I_ISS_PID(int p0, struct S_PID p1, struct S_PID p2,  int (*cb)(int, struct S_PID, struct S_PID)) ;
+EXPORT int f12_I_ISS_PIP(int p0, struct S_PIP p1, struct S_PIP p2,  int (*cb)(int, struct S_PIP, struct S_PIP)) ;
+EXPORT int f12_I_ISS_PFI(int p0, struct S_PFI p1, struct S_PFI p2,  int (*cb)(int, struct S_PFI, struct S_PFI)) ;
+EXPORT int f12_I_ISS_PFF(int p0, struct S_PFF p1, struct S_PFF p2,  int (*cb)(int, struct S_PFF, struct S_PFF)) ;
+EXPORT int f12_I_ISS_PFD(int p0, struct S_PFD p1, struct S_PFD p2,  int (*cb)(int, struct S_PFD, struct S_PFD)) ;
+EXPORT int f12_I_ISS_PFP(int p0, struct S_PFP p1, struct S_PFP p2,  int (*cb)(int, struct S_PFP, struct S_PFP)) ;
+EXPORT int f12_I_ISS_PDI(int p0, struct S_PDI p1, struct S_PDI p2,  int (*cb)(int, struct S_PDI, struct S_PDI)) ;
+EXPORT int f12_I_ISS_PDF(int p0, struct S_PDF p1, struct S_PDF p2,  int (*cb)(int, struct S_PDF, struct S_PDF)) ;
+EXPORT int f12_I_ISS_PDD(int p0, struct S_PDD p1, struct S_PDD p2,  int (*cb)(int, struct S_PDD, struct S_PDD)) ;
+EXPORT int f12_I_ISS_PDP(int p0, struct S_PDP p1, struct S_PDP p2,  int (*cb)(int, struct S_PDP, struct S_PDP)) ;
+EXPORT int f12_I_ISS_PPI(int p0, struct S_PPI p1, struct S_PPI p2,  int (*cb)(int, struct S_PPI, struct S_PPI)) ;
+EXPORT int f12_I_ISS_PPF(int p0, struct S_PPF p1, struct S_PPF p2,  int (*cb)(int, struct S_PPF, struct S_PPF)) ;
+EXPORT int f12_I_ISS_PPD(int p0, struct S_PPD p1, struct S_PPD p2,  int (*cb)(int, struct S_PPD, struct S_PPD)) ;
+EXPORT int f12_I_ISS_PPP(int p0, struct S_PPP p1, struct S_PPP p2,  int (*cb)(int, struct S_PPP, struct S_PPP)) ;
+EXPORT float f12_F_FII_(float p0, int p1, int p2,  float (*cb)(float, int, int)) ;
+EXPORT float f12_F_FIF_(float p0, int p1, float p2,  float (*cb)(float, int, float)) ;
+EXPORT float f12_F_FID_(float p0, int p1, double p2,  float (*cb)(float, int, double)) ;
+EXPORT float f12_F_FIP_(float p0, int p1, void* p2,  float (*cb)(float, int, void*)) ;
+EXPORT float f12_F_FIS_I(float p0, int p1, struct S_I p2,  float (*cb)(float, int, struct S_I)) ;
+EXPORT float f12_F_FIS_F(float p0, int p1, struct S_F p2,  float (*cb)(float, int, struct S_F)) ;
+EXPORT float f12_F_FIS_D(float p0, int p1, struct S_D p2,  float (*cb)(float, int, struct S_D)) ;
+EXPORT float f12_F_FIS_P(float p0, int p1, struct S_P p2,  float (*cb)(float, int, struct S_P)) ;
+EXPORT float f12_F_FIS_II(float p0, int p1, struct S_II p2,  float (*cb)(float, int, struct S_II)) ;
+EXPORT float f12_F_FIS_IF(float p0, int p1, struct S_IF p2,  float (*cb)(float, int, struct S_IF)) ;
+EXPORT float f12_F_FIS_ID(float p0, int p1, struct S_ID p2,  float (*cb)(float, int, struct S_ID)) ;
+EXPORT float f12_F_FIS_IP(float p0, int p1, struct S_IP p2,  float (*cb)(float, int, struct S_IP)) ;
+EXPORT float f12_F_FIS_FI(float p0, int p1, struct S_FI p2,  float (*cb)(float, int, struct S_FI)) ;
+EXPORT float f12_F_FIS_FF(float p0, int p1, struct S_FF p2,  float (*cb)(float, int, struct S_FF)) ;
+EXPORT float f12_F_FIS_FD(float p0, int p1, struct S_FD p2,  float (*cb)(float, int, struct S_FD)) ;
+EXPORT float f12_F_FIS_FP(float p0, int p1, struct S_FP p2,  float (*cb)(float, int, struct S_FP)) ;
+EXPORT float f12_F_FIS_DI(float p0, int p1, struct S_DI p2,  float (*cb)(float, int, struct S_DI)) ;
+EXPORT float f12_F_FIS_DF(float p0, int p1, struct S_DF p2,  float (*cb)(float, int, struct S_DF)) ;
+EXPORT float f12_F_FIS_DD(float p0, int p1, struct S_DD p2,  float (*cb)(float, int, struct S_DD)) ;
+EXPORT float f12_F_FIS_DP(float p0, int p1, struct S_DP p2,  float (*cb)(float, int, struct S_DP)) ;
+EXPORT float f12_F_FIS_PI(float p0, int p1, struct S_PI p2,  float (*cb)(float, int, struct S_PI)) ;
+EXPORT float f12_F_FIS_PF(float p0, int p1, struct S_PF p2,  float (*cb)(float, int, struct S_PF)) ;
+EXPORT float f12_F_FIS_PD(float p0, int p1, struct S_PD p2,  float (*cb)(float, int, struct S_PD)) ;
+EXPORT float f12_F_FIS_PP(float p0, int p1, struct S_PP p2,  float (*cb)(float, int, struct S_PP)) ;
+EXPORT float f12_F_FIS_III(float p0, int p1, struct S_III p2,  float (*cb)(float, int, struct S_III)) ;
+EXPORT float f12_F_FIS_IIF(float p0, int p1, struct S_IIF p2,  float (*cb)(float, int, struct S_IIF)) ;
+EXPORT float f12_F_FIS_IID(float p0, int p1, struct S_IID p2,  float (*cb)(float, int, struct S_IID)) ;
+EXPORT float f12_F_FIS_IIP(float p0, int p1, struct S_IIP p2,  float (*cb)(float, int, struct S_IIP)) ;
+EXPORT float f12_F_FIS_IFI(float p0, int p1, struct S_IFI p2,  float (*cb)(float, int, struct S_IFI)) ;
+EXPORT float f12_F_FIS_IFF(float p0, int p1, struct S_IFF p2,  float (*cb)(float, int, struct S_IFF)) ;
+EXPORT float f12_F_FIS_IFD(float p0, int p1, struct S_IFD p2,  float (*cb)(float, int, struct S_IFD)) ;
+EXPORT float f12_F_FIS_IFP(float p0, int p1, struct S_IFP p2,  float (*cb)(float, int, struct S_IFP)) ;
+EXPORT float f12_F_FIS_IDI(float p0, int p1, struct S_IDI p2,  float (*cb)(float, int, struct S_IDI)) ;
+EXPORT float f12_F_FIS_IDF(float p0, int p1, struct S_IDF p2,  float (*cb)(float, int, struct S_IDF)) ;
+EXPORT float f12_F_FIS_IDD(float p0, int p1, struct S_IDD p2,  float (*cb)(float, int, struct S_IDD)) ;
+EXPORT float f12_F_FIS_IDP(float p0, int p1, struct S_IDP p2,  float (*cb)(float, int, struct S_IDP)) ;
+EXPORT float f12_F_FIS_IPI(float p0, int p1, struct S_IPI p2,  float (*cb)(float, int, struct S_IPI)) ;
+EXPORT float f12_F_FIS_IPF(float p0, int p1, struct S_IPF p2,  float (*cb)(float, int, struct S_IPF)) ;
+EXPORT float f12_F_FIS_IPD(float p0, int p1, struct S_IPD p2,  float (*cb)(float, int, struct S_IPD)) ;
+EXPORT float f12_F_FIS_IPP(float p0, int p1, struct S_IPP p2,  float (*cb)(float, int, struct S_IPP)) ;
+EXPORT float f12_F_FIS_FII(float p0, int p1, struct S_FII p2,  float (*cb)(float, int, struct S_FII)) ;
+EXPORT float f12_F_FIS_FIF(float p0, int p1, struct S_FIF p2,  float (*cb)(float, int, struct S_FIF)) ;
+EXPORT float f12_F_FIS_FID(float p0, int p1, struct S_FID p2,  float (*cb)(float, int, struct S_FID)) ;
+EXPORT float f12_F_FIS_FIP(float p0, int p1, struct S_FIP p2,  float (*cb)(float, int, struct S_FIP)) ;
+EXPORT float f12_F_FIS_FFI(float p0, int p1, struct S_FFI p2,  float (*cb)(float, int, struct S_FFI)) ;
+EXPORT float f12_F_FIS_FFF(float p0, int p1, struct S_FFF p2,  float (*cb)(float, int, struct S_FFF)) ;
+EXPORT float f12_F_FIS_FFD(float p0, int p1, struct S_FFD p2,  float (*cb)(float, int, struct S_FFD)) ;
+EXPORT float f12_F_FIS_FFP(float p0, int p1, struct S_FFP p2,  float (*cb)(float, int, struct S_FFP)) ;
+EXPORT float f12_F_FIS_FDI(float p0, int p1, struct S_FDI p2,  float (*cb)(float, int, struct S_FDI)) ;
+EXPORT float f12_F_FIS_FDF(float p0, int p1, struct S_FDF p2,  float (*cb)(float, int, struct S_FDF)) ;
+EXPORT float f12_F_FIS_FDD(float p0, int p1, struct S_FDD p2,  float (*cb)(float, int, struct S_FDD)) ;
+EXPORT float f12_F_FIS_FDP(float p0, int p1, struct S_FDP p2,  float (*cb)(float, int, struct S_FDP)) ;
+EXPORT float f12_F_FIS_FPI(float p0, int p1, struct S_FPI p2,  float (*cb)(float, int, struct S_FPI)) ;
+EXPORT float f12_F_FIS_FPF(float p0, int p1, struct S_FPF p2,  float (*cb)(float, int, struct S_FPF)) ;
+EXPORT float f12_F_FIS_FPD(float p0, int p1, struct S_FPD p2,  float (*cb)(float, int, struct S_FPD)) ;
+EXPORT float f12_F_FIS_FPP(float p0, int p1, struct S_FPP p2,  float (*cb)(float, int, struct S_FPP)) ;
+EXPORT float f12_F_FIS_DII(float p0, int p1, struct S_DII p2,  float (*cb)(float, int, struct S_DII)) ;
+EXPORT float f12_F_FIS_DIF(float p0, int p1, struct S_DIF p2,  float (*cb)(float, int, struct S_DIF)) ;
+EXPORT float f12_F_FIS_DID(float p0, int p1, struct S_DID p2,  float (*cb)(float, int, struct S_DID)) ;
+EXPORT float f12_F_FIS_DIP(float p0, int p1, struct S_DIP p2,  float (*cb)(float, int, struct S_DIP)) ;
+EXPORT float f12_F_FIS_DFI(float p0, int p1, struct S_DFI p2,  float (*cb)(float, int, struct S_DFI)) ;
+EXPORT float f12_F_FIS_DFF(float p0, int p1, struct S_DFF p2,  float (*cb)(float, int, struct S_DFF)) ;
+EXPORT float f12_F_FIS_DFD(float p0, int p1, struct S_DFD p2,  float (*cb)(float, int, struct S_DFD)) ;
+EXPORT float f12_F_FIS_DFP(float p0, int p1, struct S_DFP p2,  float (*cb)(float, int, struct S_DFP)) ;
+EXPORT float f12_F_FIS_DDI(float p0, int p1, struct S_DDI p2,  float (*cb)(float, int, struct S_DDI)) ;
+EXPORT float f12_F_FIS_DDF(float p0, int p1, struct S_DDF p2,  float (*cb)(float, int, struct S_DDF)) ;
+EXPORT float f12_F_FIS_DDD(float p0, int p1, struct S_DDD p2,  float (*cb)(float, int, struct S_DDD)) ;
+EXPORT float f12_F_FIS_DDP(float p0, int p1, struct S_DDP p2,  float (*cb)(float, int, struct S_DDP)) ;
+EXPORT float f12_F_FIS_DPI(float p0, int p1, struct S_DPI p2,  float (*cb)(float, int, struct S_DPI)) ;
+EXPORT float f12_F_FIS_DPF(float p0, int p1, struct S_DPF p2,  float (*cb)(float, int, struct S_DPF)) ;
+EXPORT float f12_F_FIS_DPD(float p0, int p1, struct S_DPD p2,  float (*cb)(float, int, struct S_DPD)) ;
+EXPORT float f12_F_FIS_DPP(float p0, int p1, struct S_DPP p2,  float (*cb)(float, int, struct S_DPP)) ;
+EXPORT float f12_F_FIS_PII(float p0, int p1, struct S_PII p2,  float (*cb)(float, int, struct S_PII)) ;
+EXPORT float f12_F_FIS_PIF(float p0, int p1, struct S_PIF p2,  float (*cb)(float, int, struct S_PIF)) ;
+EXPORT float f12_F_FIS_PID(float p0, int p1, struct S_PID p2,  float (*cb)(float, int, struct S_PID)) ;
+EXPORT float f12_F_FIS_PIP(float p0, int p1, struct S_PIP p2,  float (*cb)(float, int, struct S_PIP)) ;
+EXPORT float f12_F_FIS_PFI(float p0, int p1, struct S_PFI p2,  float (*cb)(float, int, struct S_PFI)) ;
+EXPORT float f12_F_FIS_PFF(float p0, int p1, struct S_PFF p2,  float (*cb)(float, int, struct S_PFF)) ;
+EXPORT float f12_F_FIS_PFD(float p0, int p1, struct S_PFD p2,  float (*cb)(float, int, struct S_PFD)) ;
+EXPORT float f12_F_FIS_PFP(float p0, int p1, struct S_PFP p2,  float (*cb)(float, int, struct S_PFP)) ;
+EXPORT float f12_F_FIS_PDI(float p0, int p1, struct S_PDI p2,  float (*cb)(float, int, struct S_PDI)) ;
+EXPORT float f12_F_FIS_PDF(float p0, int p1, struct S_PDF p2,  float (*cb)(float, int, struct S_PDF)) ;
+EXPORT float f12_F_FIS_PDD(float p0, int p1, struct S_PDD p2,  float (*cb)(float, int, struct S_PDD)) ;
+EXPORT float f12_F_FIS_PDP(float p0, int p1, struct S_PDP p2,  float (*cb)(float, int, struct S_PDP)) ;
+EXPORT float f12_F_FIS_PPI(float p0, int p1, struct S_PPI p2,  float (*cb)(float, int, struct S_PPI)) ;
+EXPORT float f12_F_FIS_PPF(float p0, int p1, struct S_PPF p2,  float (*cb)(float, int, struct S_PPF)) ;
+EXPORT float f12_F_FIS_PPD(float p0, int p1, struct S_PPD p2,  float (*cb)(float, int, struct S_PPD)) ;
+EXPORT float f12_F_FIS_PPP(float p0, int p1, struct S_PPP p2,  float (*cb)(float, int, struct S_PPP)) ;
+EXPORT float f12_F_FFI_(float p0, float p1, int p2,  float (*cb)(float, float, int)) ;
+EXPORT float f12_F_FFF_(float p0, float p1, float p2,  float (*cb)(float, float, float)) ;
+EXPORT float f12_F_FFD_(float p0, float p1, double p2,  float (*cb)(float, float, double)) ;
+EXPORT float f12_F_FFP_(float p0, float p1, void* p2,  float (*cb)(float, float, void*)) ;
+EXPORT float f12_F_FFS_I(float p0, float p1, struct S_I p2,  float (*cb)(float, float, struct S_I)) ;
+EXPORT float f12_F_FFS_F(float p0, float p1, struct S_F p2,  float (*cb)(float, float, struct S_F)) ;
+EXPORT float f12_F_FFS_D(float p0, float p1, struct S_D p2,  float (*cb)(float, float, struct S_D)) ;
+EXPORT float f12_F_FFS_P(float p0, float p1, struct S_P p2,  float (*cb)(float, float, struct S_P)) ;
+EXPORT float f12_F_FFS_II(float p0, float p1, struct S_II p2,  float (*cb)(float, float, struct S_II)) ;
+EXPORT float f12_F_FFS_IF(float p0, float p1, struct S_IF p2,  float (*cb)(float, float, struct S_IF)) ;
+EXPORT float f12_F_FFS_ID(float p0, float p1, struct S_ID p2,  float (*cb)(float, float, struct S_ID)) ;
+EXPORT float f12_F_FFS_IP(float p0, float p1, struct S_IP p2,  float (*cb)(float, float, struct S_IP)) ;
+EXPORT float f12_F_FFS_FI(float p0, float p1, struct S_FI p2,  float (*cb)(float, float, struct S_FI)) ;
+EXPORT float f12_F_FFS_FF(float p0, float p1, struct S_FF p2,  float (*cb)(float, float, struct S_FF)) ;
+EXPORT float f12_F_FFS_FD(float p0, float p1, struct S_FD p2,  float (*cb)(float, float, struct S_FD)) ;
+EXPORT float f12_F_FFS_FP(float p0, float p1, struct S_FP p2,  float (*cb)(float, float, struct S_FP)) ;
+EXPORT float f12_F_FFS_DI(float p0, float p1, struct S_DI p2,  float (*cb)(float, float, struct S_DI)) ;
+EXPORT float f12_F_FFS_DF(float p0, float p1, struct S_DF p2,  float (*cb)(float, float, struct S_DF)) ;
+EXPORT float f12_F_FFS_DD(float p0, float p1, struct S_DD p2,  float (*cb)(float, float, struct S_DD)) ;
+EXPORT float f12_F_FFS_DP(float p0, float p1, struct S_DP p2,  float (*cb)(float, float, struct S_DP)) ;
+EXPORT float f12_F_FFS_PI(float p0, float p1, struct S_PI p2,  float (*cb)(float, float, struct S_PI)) ;
+EXPORT float f12_F_FFS_PF(float p0, float p1, struct S_PF p2,  float (*cb)(float, float, struct S_PF)) ;
+EXPORT float f12_F_FFS_PD(float p0, float p1, struct S_PD p2,  float (*cb)(float, float, struct S_PD)) ;
+EXPORT float f12_F_FFS_PP(float p0, float p1, struct S_PP p2,  float (*cb)(float, float, struct S_PP)) ;
+EXPORT float f12_F_FFS_III(float p0, float p1, struct S_III p2,  float (*cb)(float, float, struct S_III)) ;
+EXPORT float f12_F_FFS_IIF(float p0, float p1, struct S_IIF p2,  float (*cb)(float, float, struct S_IIF)) ;
+EXPORT float f12_F_FFS_IID(float p0, float p1, struct S_IID p2,  float (*cb)(float, float, struct S_IID)) ;
+EXPORT float f12_F_FFS_IIP(float p0, float p1, struct S_IIP p2,  float (*cb)(float, float, struct S_IIP)) ;
+EXPORT float f12_F_FFS_IFI(float p0, float p1, struct S_IFI p2,  float (*cb)(float, float, struct S_IFI)) ;
+EXPORT float f12_F_FFS_IFF(float p0, float p1, struct S_IFF p2,  float (*cb)(float, float, struct S_IFF)) ;
+EXPORT float f12_F_FFS_IFD(float p0, float p1, struct S_IFD p2,  float (*cb)(float, float, struct S_IFD)) ;
+EXPORT float f13_F_FFS_IFP(float p0, float p1, struct S_IFP p2,  float (*cb)(float, float, struct S_IFP)) ;
+EXPORT float f13_F_FFS_IDI(float p0, float p1, struct S_IDI p2,  float (*cb)(float, float, struct S_IDI)) ;
+EXPORT float f13_F_FFS_IDF(float p0, float p1, struct S_IDF p2,  float (*cb)(float, float, struct S_IDF)) ;
+EXPORT float f13_F_FFS_IDD(float p0, float p1, struct S_IDD p2,  float (*cb)(float, float, struct S_IDD)) ;
+EXPORT float f13_F_FFS_IDP(float p0, float p1, struct S_IDP p2,  float (*cb)(float, float, struct S_IDP)) ;
+EXPORT float f13_F_FFS_IPI(float p0, float p1, struct S_IPI p2,  float (*cb)(float, float, struct S_IPI)) ;
+EXPORT float f13_F_FFS_IPF(float p0, float p1, struct S_IPF p2,  float (*cb)(float, float, struct S_IPF)) ;
+EXPORT float f13_F_FFS_IPD(float p0, float p1, struct S_IPD p2,  float (*cb)(float, float, struct S_IPD)) ;
+EXPORT float f13_F_FFS_IPP(float p0, float p1, struct S_IPP p2,  float (*cb)(float, float, struct S_IPP)) ;
+EXPORT float f13_F_FFS_FII(float p0, float p1, struct S_FII p2,  float (*cb)(float, float, struct S_FII)) ;
+EXPORT float f13_F_FFS_FIF(float p0, float p1, struct S_FIF p2,  float (*cb)(float, float, struct S_FIF)) ;
+EXPORT float f13_F_FFS_FID(float p0, float p1, struct S_FID p2,  float (*cb)(float, float, struct S_FID)) ;
+EXPORT float f13_F_FFS_FIP(float p0, float p1, struct S_FIP p2,  float (*cb)(float, float, struct S_FIP)) ;
+EXPORT float f13_F_FFS_FFI(float p0, float p1, struct S_FFI p2,  float (*cb)(float, float, struct S_FFI)) ;
+EXPORT float f13_F_FFS_FFF(float p0, float p1, struct S_FFF p2,  float (*cb)(float, float, struct S_FFF)) ;
+EXPORT float f13_F_FFS_FFD(float p0, float p1, struct S_FFD p2,  float (*cb)(float, float, struct S_FFD)) ;
+EXPORT float f13_F_FFS_FFP(float p0, float p1, struct S_FFP p2,  float (*cb)(float, float, struct S_FFP)) ;
+EXPORT float f13_F_FFS_FDI(float p0, float p1, struct S_FDI p2,  float (*cb)(float, float, struct S_FDI)) ;
+EXPORT float f13_F_FFS_FDF(float p0, float p1, struct S_FDF p2,  float (*cb)(float, float, struct S_FDF)) ;
+EXPORT float f13_F_FFS_FDD(float p0, float p1, struct S_FDD p2,  float (*cb)(float, float, struct S_FDD)) ;
+EXPORT float f13_F_FFS_FDP(float p0, float p1, struct S_FDP p2,  float (*cb)(float, float, struct S_FDP)) ;
+EXPORT float f13_F_FFS_FPI(float p0, float p1, struct S_FPI p2,  float (*cb)(float, float, struct S_FPI)) ;
+EXPORT float f13_F_FFS_FPF(float p0, float p1, struct S_FPF p2,  float (*cb)(float, float, struct S_FPF)) ;
+EXPORT float f13_F_FFS_FPD(float p0, float p1, struct S_FPD p2,  float (*cb)(float, float, struct S_FPD)) ;
+EXPORT float f13_F_FFS_FPP(float p0, float p1, struct S_FPP p2,  float (*cb)(float, float, struct S_FPP)) ;
+EXPORT float f13_F_FFS_DII(float p0, float p1, struct S_DII p2,  float (*cb)(float, float, struct S_DII)) ;
+EXPORT float f13_F_FFS_DIF(float p0, float p1, struct S_DIF p2,  float (*cb)(float, float, struct S_DIF)) ;
+EXPORT float f13_F_FFS_DID(float p0, float p1, struct S_DID p2,  float (*cb)(float, float, struct S_DID)) ;
+EXPORT float f13_F_FFS_DIP(float p0, float p1, struct S_DIP p2,  float (*cb)(float, float, struct S_DIP)) ;
+EXPORT float f13_F_FFS_DFI(float p0, float p1, struct S_DFI p2,  float (*cb)(float, float, struct S_DFI)) ;
+EXPORT float f13_F_FFS_DFF(float p0, float p1, struct S_DFF p2,  float (*cb)(float, float, struct S_DFF)) ;
+EXPORT float f13_F_FFS_DFD(float p0, float p1, struct S_DFD p2,  float (*cb)(float, float, struct S_DFD)) ;
+EXPORT float f13_F_FFS_DFP(float p0, float p1, struct S_DFP p2,  float (*cb)(float, float, struct S_DFP)) ;
+EXPORT float f13_F_FFS_DDI(float p0, float p1, struct S_DDI p2,  float (*cb)(float, float, struct S_DDI)) ;
+EXPORT float f13_F_FFS_DDF(float p0, float p1, struct S_DDF p2,  float (*cb)(float, float, struct S_DDF)) ;
+EXPORT float f13_F_FFS_DDD(float p0, float p1, struct S_DDD p2,  float (*cb)(float, float, struct S_DDD)) ;
+EXPORT float f13_F_FFS_DDP(float p0, float p1, struct S_DDP p2,  float (*cb)(float, float, struct S_DDP)) ;
+EXPORT float f13_F_FFS_DPI(float p0, float p1, struct S_DPI p2,  float (*cb)(float, float, struct S_DPI)) ;
+EXPORT float f13_F_FFS_DPF(float p0, float p1, struct S_DPF p2,  float (*cb)(float, float, struct S_DPF)) ;
+EXPORT float f13_F_FFS_DPD(float p0, float p1, struct S_DPD p2,  float (*cb)(float, float, struct S_DPD)) ;
+EXPORT float f13_F_FFS_DPP(float p0, float p1, struct S_DPP p2,  float (*cb)(float, float, struct S_DPP)) ;
+EXPORT float f13_F_FFS_PII(float p0, float p1, struct S_PII p2,  float (*cb)(float, float, struct S_PII)) ;
+EXPORT float f13_F_FFS_PIF(float p0, float p1, struct S_PIF p2,  float (*cb)(float, float, struct S_PIF)) ;
+EXPORT float f13_F_FFS_PID(float p0, float p1, struct S_PID p2,  float (*cb)(float, float, struct S_PID)) ;
+EXPORT float f13_F_FFS_PIP(float p0, float p1, struct S_PIP p2,  float (*cb)(float, float, struct S_PIP)) ;
+EXPORT float f13_F_FFS_PFI(float p0, float p1, struct S_PFI p2,  float (*cb)(float, float, struct S_PFI)) ;
+EXPORT float f13_F_FFS_PFF(float p0, float p1, struct S_PFF p2,  float (*cb)(float, float, struct S_PFF)) ;
+EXPORT float f13_F_FFS_PFD(float p0, float p1, struct S_PFD p2,  float (*cb)(float, float, struct S_PFD)) ;
+EXPORT float f13_F_FFS_PFP(float p0, float p1, struct S_PFP p2,  float (*cb)(float, float, struct S_PFP)) ;
+EXPORT float f13_F_FFS_PDI(float p0, float p1, struct S_PDI p2,  float (*cb)(float, float, struct S_PDI)) ;
+EXPORT float f13_F_FFS_PDF(float p0, float p1, struct S_PDF p2,  float (*cb)(float, float, struct S_PDF)) ;
+EXPORT float f13_F_FFS_PDD(float p0, float p1, struct S_PDD p2,  float (*cb)(float, float, struct S_PDD)) ;
+EXPORT float f13_F_FFS_PDP(float p0, float p1, struct S_PDP p2,  float (*cb)(float, float, struct S_PDP)) ;
+EXPORT float f13_F_FFS_PPI(float p0, float p1, struct S_PPI p2,  float (*cb)(float, float, struct S_PPI)) ;
+EXPORT float f13_F_FFS_PPF(float p0, float p1, struct S_PPF p2,  float (*cb)(float, float, struct S_PPF)) ;
+EXPORT float f13_F_FFS_PPD(float p0, float p1, struct S_PPD p2,  float (*cb)(float, float, struct S_PPD)) ;
+EXPORT float f13_F_FFS_PPP(float p0, float p1, struct S_PPP p2,  float (*cb)(float, float, struct S_PPP)) ;
+EXPORT float f13_F_FDI_(float p0, double p1, int p2,  float (*cb)(float, double, int)) ;
+EXPORT float f13_F_FDF_(float p0, double p1, float p2,  float (*cb)(float, double, float)) ;
+EXPORT float f13_F_FDD_(float p0, double p1, double p2,  float (*cb)(float, double, double)) ;
+EXPORT float f13_F_FDP_(float p0, double p1, void* p2,  float (*cb)(float, double, void*)) ;
+EXPORT float f13_F_FDS_I(float p0, double p1, struct S_I p2,  float (*cb)(float, double, struct S_I)) ;
+EXPORT float f13_F_FDS_F(float p0, double p1, struct S_F p2,  float (*cb)(float, double, struct S_F)) ;
+EXPORT float f13_F_FDS_D(float p0, double p1, struct S_D p2,  float (*cb)(float, double, struct S_D)) ;
+EXPORT float f13_F_FDS_P(float p0, double p1, struct S_P p2,  float (*cb)(float, double, struct S_P)) ;
+EXPORT float f13_F_FDS_II(float p0, double p1, struct S_II p2,  float (*cb)(float, double, struct S_II)) ;
+EXPORT float f13_F_FDS_IF(float p0, double p1, struct S_IF p2,  float (*cb)(float, double, struct S_IF)) ;
+EXPORT float f13_F_FDS_ID(float p0, double p1, struct S_ID p2,  float (*cb)(float, double, struct S_ID)) ;
+EXPORT float f13_F_FDS_IP(float p0, double p1, struct S_IP p2,  float (*cb)(float, double, struct S_IP)) ;
+EXPORT float f13_F_FDS_FI(float p0, double p1, struct S_FI p2,  float (*cb)(float, double, struct S_FI)) ;
+EXPORT float f13_F_FDS_FF(float p0, double p1, struct S_FF p2,  float (*cb)(float, double, struct S_FF)) ;
+EXPORT float f13_F_FDS_FD(float p0, double p1, struct S_FD p2,  float (*cb)(float, double, struct S_FD)) ;
+EXPORT float f13_F_FDS_FP(float p0, double p1, struct S_FP p2,  float (*cb)(float, double, struct S_FP)) ;
+EXPORT float f13_F_FDS_DI(float p0, double p1, struct S_DI p2,  float (*cb)(float, double, struct S_DI)) ;
+EXPORT float f13_F_FDS_DF(float p0, double p1, struct S_DF p2,  float (*cb)(float, double, struct S_DF)) ;
+EXPORT float f13_F_FDS_DD(float p0, double p1, struct S_DD p2,  float (*cb)(float, double, struct S_DD)) ;
+EXPORT float f13_F_FDS_DP(float p0, double p1, struct S_DP p2,  float (*cb)(float, double, struct S_DP)) ;
+EXPORT float f13_F_FDS_PI(float p0, double p1, struct S_PI p2,  float (*cb)(float, double, struct S_PI)) ;
+EXPORT float f13_F_FDS_PF(float p0, double p1, struct S_PF p2,  float (*cb)(float, double, struct S_PF)) ;
+EXPORT float f13_F_FDS_PD(float p0, double p1, struct S_PD p2,  float (*cb)(float, double, struct S_PD)) ;
+EXPORT float f13_F_FDS_PP(float p0, double p1, struct S_PP p2,  float (*cb)(float, double, struct S_PP)) ;
+EXPORT float f13_F_FDS_III(float p0, double p1, struct S_III p2,  float (*cb)(float, double, struct S_III)) ;
+EXPORT float f13_F_FDS_IIF(float p0, double p1, struct S_IIF p2,  float (*cb)(float, double, struct S_IIF)) ;
+EXPORT float f13_F_FDS_IID(float p0, double p1, struct S_IID p2,  float (*cb)(float, double, struct S_IID)) ;
+EXPORT float f13_F_FDS_IIP(float p0, double p1, struct S_IIP p2,  float (*cb)(float, double, struct S_IIP)) ;
+EXPORT float f13_F_FDS_IFI(float p0, double p1, struct S_IFI p2,  float (*cb)(float, double, struct S_IFI)) ;
+EXPORT float f13_F_FDS_IFF(float p0, double p1, struct S_IFF p2,  float (*cb)(float, double, struct S_IFF)) ;
+EXPORT float f13_F_FDS_IFD(float p0, double p1, struct S_IFD p2,  float (*cb)(float, double, struct S_IFD)) ;
+EXPORT float f13_F_FDS_IFP(float p0, double p1, struct S_IFP p2,  float (*cb)(float, double, struct S_IFP)) ;
+EXPORT float f13_F_FDS_IDI(float p0, double p1, struct S_IDI p2,  float (*cb)(float, double, struct S_IDI)) ;
+EXPORT float f13_F_FDS_IDF(float p0, double p1, struct S_IDF p2,  float (*cb)(float, double, struct S_IDF)) ;
+EXPORT float f13_F_FDS_IDD(float p0, double p1, struct S_IDD p2,  float (*cb)(float, double, struct S_IDD)) ;
+EXPORT float f13_F_FDS_IDP(float p0, double p1, struct S_IDP p2,  float (*cb)(float, double, struct S_IDP)) ;
+EXPORT float f13_F_FDS_IPI(float p0, double p1, struct S_IPI p2,  float (*cb)(float, double, struct S_IPI)) ;
+EXPORT float f13_F_FDS_IPF(float p0, double p1, struct S_IPF p2,  float (*cb)(float, double, struct S_IPF)) ;
+EXPORT float f13_F_FDS_IPD(float p0, double p1, struct S_IPD p2,  float (*cb)(float, double, struct S_IPD)) ;
+EXPORT float f13_F_FDS_IPP(float p0, double p1, struct S_IPP p2,  float (*cb)(float, double, struct S_IPP)) ;
+EXPORT float f13_F_FDS_FII(float p0, double p1, struct S_FII p2,  float (*cb)(float, double, struct S_FII)) ;
+EXPORT float f13_F_FDS_FIF(float p0, double p1, struct S_FIF p2,  float (*cb)(float, double, struct S_FIF)) ;
+EXPORT float f13_F_FDS_FID(float p0, double p1, struct S_FID p2,  float (*cb)(float, double, struct S_FID)) ;
+EXPORT float f13_F_FDS_FIP(float p0, double p1, struct S_FIP p2,  float (*cb)(float, double, struct S_FIP)) ;
+EXPORT float f13_F_FDS_FFI(float p0, double p1, struct S_FFI p2,  float (*cb)(float, double, struct S_FFI)) ;
+EXPORT float f13_F_FDS_FFF(float p0, double p1, struct S_FFF p2,  float (*cb)(float, double, struct S_FFF)) ;
+EXPORT float f13_F_FDS_FFD(float p0, double p1, struct S_FFD p2,  float (*cb)(float, double, struct S_FFD)) ;
+EXPORT float f13_F_FDS_FFP(float p0, double p1, struct S_FFP p2,  float (*cb)(float, double, struct S_FFP)) ;
+EXPORT float f13_F_FDS_FDI(float p0, double p1, struct S_FDI p2,  float (*cb)(float, double, struct S_FDI)) ;
+EXPORT float f13_F_FDS_FDF(float p0, double p1, struct S_FDF p2,  float (*cb)(float, double, struct S_FDF)) ;
+EXPORT float f13_F_FDS_FDD(float p0, double p1, struct S_FDD p2,  float (*cb)(float, double, struct S_FDD)) ;
+EXPORT float f13_F_FDS_FDP(float p0, double p1, struct S_FDP p2,  float (*cb)(float, double, struct S_FDP)) ;
+EXPORT float f13_F_FDS_FPI(float p0, double p1, struct S_FPI p2,  float (*cb)(float, double, struct S_FPI)) ;
+EXPORT float f13_F_FDS_FPF(float p0, double p1, struct S_FPF p2,  float (*cb)(float, double, struct S_FPF)) ;
+EXPORT float f13_F_FDS_FPD(float p0, double p1, struct S_FPD p2,  float (*cb)(float, double, struct S_FPD)) ;
+EXPORT float f13_F_FDS_FPP(float p0, double p1, struct S_FPP p2,  float (*cb)(float, double, struct S_FPP)) ;
+EXPORT float f13_F_FDS_DII(float p0, double p1, struct S_DII p2,  float (*cb)(float, double, struct S_DII)) ;
+EXPORT float f13_F_FDS_DIF(float p0, double p1, struct S_DIF p2,  float (*cb)(float, double, struct S_DIF)) ;
+EXPORT float f13_F_FDS_DID(float p0, double p1, struct S_DID p2,  float (*cb)(float, double, struct S_DID)) ;
+EXPORT float f13_F_FDS_DIP(float p0, double p1, struct S_DIP p2,  float (*cb)(float, double, struct S_DIP)) ;
+EXPORT float f13_F_FDS_DFI(float p0, double p1, struct S_DFI p2,  float (*cb)(float, double, struct S_DFI)) ;
+EXPORT float f13_F_FDS_DFF(float p0, double p1, struct S_DFF p2,  float (*cb)(float, double, struct S_DFF)) ;
+EXPORT float f13_F_FDS_DFD(float p0, double p1, struct S_DFD p2,  float (*cb)(float, double, struct S_DFD)) ;
+EXPORT float f13_F_FDS_DFP(float p0, double p1, struct S_DFP p2,  float (*cb)(float, double, struct S_DFP)) ;
+EXPORT float f13_F_FDS_DDI(float p0, double p1, struct S_DDI p2,  float (*cb)(float, double, struct S_DDI)) ;
+EXPORT float f13_F_FDS_DDF(float p0, double p1, struct S_DDF p2,  float (*cb)(float, double, struct S_DDF)) ;
+EXPORT float f13_F_FDS_DDD(float p0, double p1, struct S_DDD p2,  float (*cb)(float, double, struct S_DDD)) ;
+EXPORT float f13_F_FDS_DDP(float p0, double p1, struct S_DDP p2,  float (*cb)(float, double, struct S_DDP)) ;
+EXPORT float f13_F_FDS_DPI(float p0, double p1, struct S_DPI p2,  float (*cb)(float, double, struct S_DPI)) ;
+EXPORT float f13_F_FDS_DPF(float p0, double p1, struct S_DPF p2,  float (*cb)(float, double, struct S_DPF)) ;
+EXPORT float f13_F_FDS_DPD(float p0, double p1, struct S_DPD p2,  float (*cb)(float, double, struct S_DPD)) ;
+EXPORT float f13_F_FDS_DPP(float p0, double p1, struct S_DPP p2,  float (*cb)(float, double, struct S_DPP)) ;
+EXPORT float f13_F_FDS_PII(float p0, double p1, struct S_PII p2,  float (*cb)(float, double, struct S_PII)) ;
+EXPORT float f13_F_FDS_PIF(float p0, double p1, struct S_PIF p2,  float (*cb)(float, double, struct S_PIF)) ;
+EXPORT float f13_F_FDS_PID(float p0, double p1, struct S_PID p2,  float (*cb)(float, double, struct S_PID)) ;
+EXPORT float f13_F_FDS_PIP(float p0, double p1, struct S_PIP p2,  float (*cb)(float, double, struct S_PIP)) ;
+EXPORT float f13_F_FDS_PFI(float p0, double p1, struct S_PFI p2,  float (*cb)(float, double, struct S_PFI)) ;
+EXPORT float f13_F_FDS_PFF(float p0, double p1, struct S_PFF p2,  float (*cb)(float, double, struct S_PFF)) ;
+EXPORT float f13_F_FDS_PFD(float p0, double p1, struct S_PFD p2,  float (*cb)(float, double, struct S_PFD)) ;
+EXPORT float f13_F_FDS_PFP(float p0, double p1, struct S_PFP p2,  float (*cb)(float, double, struct S_PFP)) ;
+EXPORT float f13_F_FDS_PDI(float p0, double p1, struct S_PDI p2,  float (*cb)(float, double, struct S_PDI)) ;
+EXPORT float f13_F_FDS_PDF(float p0, double p1, struct S_PDF p2,  float (*cb)(float, double, struct S_PDF)) ;
+EXPORT float f13_F_FDS_PDD(float p0, double p1, struct S_PDD p2,  float (*cb)(float, double, struct S_PDD)) ;
+EXPORT float f13_F_FDS_PDP(float p0, double p1, struct S_PDP p2,  float (*cb)(float, double, struct S_PDP)) ;
+EXPORT float f13_F_FDS_PPI(float p0, double p1, struct S_PPI p2,  float (*cb)(float, double, struct S_PPI)) ;
+EXPORT float f13_F_FDS_PPF(float p0, double p1, struct S_PPF p2,  float (*cb)(float, double, struct S_PPF)) ;
+EXPORT float f13_F_FDS_PPD(float p0, double p1, struct S_PPD p2,  float (*cb)(float, double, struct S_PPD)) ;
+EXPORT float f13_F_FDS_PPP(float p0, double p1, struct S_PPP p2,  float (*cb)(float, double, struct S_PPP)) ;
+EXPORT float f13_F_FPI_(float p0, void* p1, int p2,  float (*cb)(float, void*, int)) ;
+EXPORT float f13_F_FPF_(float p0, void* p1, float p2,  float (*cb)(float, void*, float)) ;
+EXPORT float f13_F_FPD_(float p0, void* p1, double p2,  float (*cb)(float, void*, double)) ;
+EXPORT float f13_F_FPP_(float p0, void* p1, void* p2,  float (*cb)(float, void*, void*)) ;
+EXPORT float f13_F_FPS_I(float p0, void* p1, struct S_I p2,  float (*cb)(float, void*, struct S_I)) ;
+EXPORT float f13_F_FPS_F(float p0, void* p1, struct S_F p2,  float (*cb)(float, void*, struct S_F)) ;
+EXPORT float f13_F_FPS_D(float p0, void* p1, struct S_D p2,  float (*cb)(float, void*, struct S_D)) ;
+EXPORT float f13_F_FPS_P(float p0, void* p1, struct S_P p2,  float (*cb)(float, void*, struct S_P)) ;
+EXPORT float f13_F_FPS_II(float p0, void* p1, struct S_II p2,  float (*cb)(float, void*, struct S_II)) ;
+EXPORT float f13_F_FPS_IF(float p0, void* p1, struct S_IF p2,  float (*cb)(float, void*, struct S_IF)) ;
+EXPORT float f13_F_FPS_ID(float p0, void* p1, struct S_ID p2,  float (*cb)(float, void*, struct S_ID)) ;
+EXPORT float f13_F_FPS_IP(float p0, void* p1, struct S_IP p2,  float (*cb)(float, void*, struct S_IP)) ;
+EXPORT float f13_F_FPS_FI(float p0, void* p1, struct S_FI p2,  float (*cb)(float, void*, struct S_FI)) ;
+EXPORT float f13_F_FPS_FF(float p0, void* p1, struct S_FF p2,  float (*cb)(float, void*, struct S_FF)) ;
+EXPORT float f13_F_FPS_FD(float p0, void* p1, struct S_FD p2,  float (*cb)(float, void*, struct S_FD)) ;
+EXPORT float f13_F_FPS_FP(float p0, void* p1, struct S_FP p2,  float (*cb)(float, void*, struct S_FP)) ;
+EXPORT float f13_F_FPS_DI(float p0, void* p1, struct S_DI p2,  float (*cb)(float, void*, struct S_DI)) ;
+EXPORT float f13_F_FPS_DF(float p0, void* p1, struct S_DF p2,  float (*cb)(float, void*, struct S_DF)) ;
+EXPORT float f13_F_FPS_DD(float p0, void* p1, struct S_DD p2,  float (*cb)(float, void*, struct S_DD)) ;
+EXPORT float f13_F_FPS_DP(float p0, void* p1, struct S_DP p2,  float (*cb)(float, void*, struct S_DP)) ;
+EXPORT float f13_F_FPS_PI(float p0, void* p1, struct S_PI p2,  float (*cb)(float, void*, struct S_PI)) ;
+EXPORT float f13_F_FPS_PF(float p0, void* p1, struct S_PF p2,  float (*cb)(float, void*, struct S_PF)) ;
+EXPORT float f13_F_FPS_PD(float p0, void* p1, struct S_PD p2,  float (*cb)(float, void*, struct S_PD)) ;
+EXPORT float f13_F_FPS_PP(float p0, void* p1, struct S_PP p2,  float (*cb)(float, void*, struct S_PP)) ;
+EXPORT float f13_F_FPS_III(float p0, void* p1, struct S_III p2,  float (*cb)(float, void*, struct S_III)) ;
+EXPORT float f13_F_FPS_IIF(float p0, void* p1, struct S_IIF p2,  float (*cb)(float, void*, struct S_IIF)) ;
+EXPORT float f13_F_FPS_IID(float p0, void* p1, struct S_IID p2,  float (*cb)(float, void*, struct S_IID)) ;
+EXPORT float f13_F_FPS_IIP(float p0, void* p1, struct S_IIP p2,  float (*cb)(float, void*, struct S_IIP)) ;
+EXPORT float f13_F_FPS_IFI(float p0, void* p1, struct S_IFI p2,  float (*cb)(float, void*, struct S_IFI)) ;
+EXPORT float f13_F_FPS_IFF(float p0, void* p1, struct S_IFF p2,  float (*cb)(float, void*, struct S_IFF)) ;
+EXPORT float f13_F_FPS_IFD(float p0, void* p1, struct S_IFD p2,  float (*cb)(float, void*, struct S_IFD)) ;
+EXPORT float f13_F_FPS_IFP(float p0, void* p1, struct S_IFP p2,  float (*cb)(float, void*, struct S_IFP)) ;
+EXPORT float f13_F_FPS_IDI(float p0, void* p1, struct S_IDI p2,  float (*cb)(float, void*, struct S_IDI)) ;
+EXPORT float f13_F_FPS_IDF(float p0, void* p1, struct S_IDF p2,  float (*cb)(float, void*, struct S_IDF)) ;
+EXPORT float f13_F_FPS_IDD(float p0, void* p1, struct S_IDD p2,  float (*cb)(float, void*, struct S_IDD)) ;
+EXPORT float f13_F_FPS_IDP(float p0, void* p1, struct S_IDP p2,  float (*cb)(float, void*, struct S_IDP)) ;
+EXPORT float f13_F_FPS_IPI(float p0, void* p1, struct S_IPI p2,  float (*cb)(float, void*, struct S_IPI)) ;
+EXPORT float f13_F_FPS_IPF(float p0, void* p1, struct S_IPF p2,  float (*cb)(float, void*, struct S_IPF)) ;
+EXPORT float f13_F_FPS_IPD(float p0, void* p1, struct S_IPD p2,  float (*cb)(float, void*, struct S_IPD)) ;
+EXPORT float f13_F_FPS_IPP(float p0, void* p1, struct S_IPP p2,  float (*cb)(float, void*, struct S_IPP)) ;
+EXPORT float f13_F_FPS_FII(float p0, void* p1, struct S_FII p2,  float (*cb)(float, void*, struct S_FII)) ;
+EXPORT float f13_F_FPS_FIF(float p0, void* p1, struct S_FIF p2,  float (*cb)(float, void*, struct S_FIF)) ;
+EXPORT float f13_F_FPS_FID(float p0, void* p1, struct S_FID p2,  float (*cb)(float, void*, struct S_FID)) ;
+EXPORT float f13_F_FPS_FIP(float p0, void* p1, struct S_FIP p2,  float (*cb)(float, void*, struct S_FIP)) ;
+EXPORT float f13_F_FPS_FFI(float p0, void* p1, struct S_FFI p2,  float (*cb)(float, void*, struct S_FFI)) ;
+EXPORT float f13_F_FPS_FFF(float p0, void* p1, struct S_FFF p2,  float (*cb)(float, void*, struct S_FFF)) ;
+EXPORT float f13_F_FPS_FFD(float p0, void* p1, struct S_FFD p2,  float (*cb)(float, void*, struct S_FFD)) ;
+EXPORT float f13_F_FPS_FFP(float p0, void* p1, struct S_FFP p2,  float (*cb)(float, void*, struct S_FFP)) ;
+EXPORT float f13_F_FPS_FDI(float p0, void* p1, struct S_FDI p2,  float (*cb)(float, void*, struct S_FDI)) ;
+EXPORT float f13_F_FPS_FDF(float p0, void* p1, struct S_FDF p2,  float (*cb)(float, void*, struct S_FDF)) ;
+EXPORT float f13_F_FPS_FDD(float p0, void* p1, struct S_FDD p2,  float (*cb)(float, void*, struct S_FDD)) ;
+EXPORT float f13_F_FPS_FDP(float p0, void* p1, struct S_FDP p2,  float (*cb)(float, void*, struct S_FDP)) ;
+EXPORT float f13_F_FPS_FPI(float p0, void* p1, struct S_FPI p2,  float (*cb)(float, void*, struct S_FPI)) ;
+EXPORT float f13_F_FPS_FPF(float p0, void* p1, struct S_FPF p2,  float (*cb)(float, void*, struct S_FPF)) ;
+EXPORT float f13_F_FPS_FPD(float p0, void* p1, struct S_FPD p2,  float (*cb)(float, void*, struct S_FPD)) ;
+EXPORT float f13_F_FPS_FPP(float p0, void* p1, struct S_FPP p2,  float (*cb)(float, void*, struct S_FPP)) ;
+EXPORT float f13_F_FPS_DII(float p0, void* p1, struct S_DII p2,  float (*cb)(float, void*, struct S_DII)) ;
+EXPORT float f13_F_FPS_DIF(float p0, void* p1, struct S_DIF p2,  float (*cb)(float, void*, struct S_DIF)) ;
+EXPORT float f13_F_FPS_DID(float p0, void* p1, struct S_DID p2,  float (*cb)(float, void*, struct S_DID)) ;
+EXPORT float f13_F_FPS_DIP(float p0, void* p1, struct S_DIP p2,  float (*cb)(float, void*, struct S_DIP)) ;
+EXPORT float f13_F_FPS_DFI(float p0, void* p1, struct S_DFI p2,  float (*cb)(float, void*, struct S_DFI)) ;
+EXPORT float f13_F_FPS_DFF(float p0, void* p1, struct S_DFF p2,  float (*cb)(float, void*, struct S_DFF)) ;
+EXPORT float f13_F_FPS_DFD(float p0, void* p1, struct S_DFD p2,  float (*cb)(float, void*, struct S_DFD)) ;
+EXPORT float f13_F_FPS_DFP(float p0, void* p1, struct S_DFP p2,  float (*cb)(float, void*, struct S_DFP)) ;
+EXPORT float f13_F_FPS_DDI(float p0, void* p1, struct S_DDI p2,  float (*cb)(float, void*, struct S_DDI)) ;
+EXPORT float f13_F_FPS_DDF(float p0, void* p1, struct S_DDF p2,  float (*cb)(float, void*, struct S_DDF)) ;
+EXPORT float f13_F_FPS_DDD(float p0, void* p1, struct S_DDD p2,  float (*cb)(float, void*, struct S_DDD)) ;
+EXPORT float f13_F_FPS_DDP(float p0, void* p1, struct S_DDP p2,  float (*cb)(float, void*, struct S_DDP)) ;
+EXPORT float f13_F_FPS_DPI(float p0, void* p1, struct S_DPI p2,  float (*cb)(float, void*, struct S_DPI)) ;
+EXPORT float f13_F_FPS_DPF(float p0, void* p1, struct S_DPF p2,  float (*cb)(float, void*, struct S_DPF)) ;
+EXPORT float f13_F_FPS_DPD(float p0, void* p1, struct S_DPD p2,  float (*cb)(float, void*, struct S_DPD)) ;
+EXPORT float f13_F_FPS_DPP(float p0, void* p1, struct S_DPP p2,  float (*cb)(float, void*, struct S_DPP)) ;
+EXPORT float f13_F_FPS_PII(float p0, void* p1, struct S_PII p2,  float (*cb)(float, void*, struct S_PII)) ;
+EXPORT float f13_F_FPS_PIF(float p0, void* p1, struct S_PIF p2,  float (*cb)(float, void*, struct S_PIF)) ;
+EXPORT float f13_F_FPS_PID(float p0, void* p1, struct S_PID p2,  float (*cb)(float, void*, struct S_PID)) ;
+EXPORT float f13_F_FPS_PIP(float p0, void* p1, struct S_PIP p2,  float (*cb)(float, void*, struct S_PIP)) ;
+EXPORT float f13_F_FPS_PFI(float p0, void* p1, struct S_PFI p2,  float (*cb)(float, void*, struct S_PFI)) ;
+EXPORT float f13_F_FPS_PFF(float p0, void* p1, struct S_PFF p2,  float (*cb)(float, void*, struct S_PFF)) ;
+EXPORT float f13_F_FPS_PFD(float p0, void* p1, struct S_PFD p2,  float (*cb)(float, void*, struct S_PFD)) ;
+EXPORT float f13_F_FPS_PFP(float p0, void* p1, struct S_PFP p2,  float (*cb)(float, void*, struct S_PFP)) ;
+EXPORT float f13_F_FPS_PDI(float p0, void* p1, struct S_PDI p2,  float (*cb)(float, void*, struct S_PDI)) ;
+EXPORT float f13_F_FPS_PDF(float p0, void* p1, struct S_PDF p2,  float (*cb)(float, void*, struct S_PDF)) ;
+EXPORT float f13_F_FPS_PDD(float p0, void* p1, struct S_PDD p2,  float (*cb)(float, void*, struct S_PDD)) ;
+EXPORT float f13_F_FPS_PDP(float p0, void* p1, struct S_PDP p2,  float (*cb)(float, void*, struct S_PDP)) ;
+EXPORT float f13_F_FPS_PPI(float p0, void* p1, struct S_PPI p2,  float (*cb)(float, void*, struct S_PPI)) ;
+EXPORT float f13_F_FPS_PPF(float p0, void* p1, struct S_PPF p2,  float (*cb)(float, void*, struct S_PPF)) ;
+EXPORT float f13_F_FPS_PPD(float p0, void* p1, struct S_PPD p2,  float (*cb)(float, void*, struct S_PPD)) ;
+EXPORT float f13_F_FPS_PPP(float p0, void* p1, struct S_PPP p2,  float (*cb)(float, void*, struct S_PPP)) ;
+EXPORT float f13_F_FSI_I(float p0, struct S_I p1, int p2,  float (*cb)(float, struct S_I, int)) ;
+EXPORT float f13_F_FSI_F(float p0, struct S_F p1, int p2,  float (*cb)(float, struct S_F, int)) ;
+EXPORT float f13_F_FSI_D(float p0, struct S_D p1, int p2,  float (*cb)(float, struct S_D, int)) ;
+EXPORT float f13_F_FSI_P(float p0, struct S_P p1, int p2,  float (*cb)(float, struct S_P, int)) ;
+EXPORT float f13_F_FSI_II(float p0, struct S_II p1, int p2,  float (*cb)(float, struct S_II, int)) ;
+EXPORT float f13_F_FSI_IF(float p0, struct S_IF p1, int p2,  float (*cb)(float, struct S_IF, int)) ;
+EXPORT float f13_F_FSI_ID(float p0, struct S_ID p1, int p2,  float (*cb)(float, struct S_ID, int)) ;
+EXPORT float f13_F_FSI_IP(float p0, struct S_IP p1, int p2,  float (*cb)(float, struct S_IP, int)) ;
+EXPORT float f13_F_FSI_FI(float p0, struct S_FI p1, int p2,  float (*cb)(float, struct S_FI, int)) ;
+EXPORT float f13_F_FSI_FF(float p0, struct S_FF p1, int p2,  float (*cb)(float, struct S_FF, int)) ;
+EXPORT float f13_F_FSI_FD(float p0, struct S_FD p1, int p2,  float (*cb)(float, struct S_FD, int)) ;
+EXPORT float f13_F_FSI_FP(float p0, struct S_FP p1, int p2,  float (*cb)(float, struct S_FP, int)) ;
+EXPORT float f13_F_FSI_DI(float p0, struct S_DI p1, int p2,  float (*cb)(float, struct S_DI, int)) ;
+EXPORT float f13_F_FSI_DF(float p0, struct S_DF p1, int p2,  float (*cb)(float, struct S_DF, int)) ;
+EXPORT float f13_F_FSI_DD(float p0, struct S_DD p1, int p2,  float (*cb)(float, struct S_DD, int)) ;
+EXPORT float f13_F_FSI_DP(float p0, struct S_DP p1, int p2,  float (*cb)(float, struct S_DP, int)) ;
+EXPORT float f13_F_FSI_PI(float p0, struct S_PI p1, int p2,  float (*cb)(float, struct S_PI, int)) ;
+EXPORT float f13_F_FSI_PF(float p0, struct S_PF p1, int p2,  float (*cb)(float, struct S_PF, int)) ;
+EXPORT float f13_F_FSI_PD(float p0, struct S_PD p1, int p2,  float (*cb)(float, struct S_PD, int)) ;
+EXPORT float f13_F_FSI_PP(float p0, struct S_PP p1, int p2,  float (*cb)(float, struct S_PP, int)) ;
+EXPORT float f13_F_FSI_III(float p0, struct S_III p1, int p2,  float (*cb)(float, struct S_III, int)) ;
+EXPORT float f13_F_FSI_IIF(float p0, struct S_IIF p1, int p2,  float (*cb)(float, struct S_IIF, int)) ;
+EXPORT float f13_F_FSI_IID(float p0, struct S_IID p1, int p2,  float (*cb)(float, struct S_IID, int)) ;
+EXPORT float f13_F_FSI_IIP(float p0, struct S_IIP p1, int p2,  float (*cb)(float, struct S_IIP, int)) ;
+EXPORT float f13_F_FSI_IFI(float p0, struct S_IFI p1, int p2,  float (*cb)(float, struct S_IFI, int)) ;
+EXPORT float f13_F_FSI_IFF(float p0, struct S_IFF p1, int p2,  float (*cb)(float, struct S_IFF, int)) ;
+EXPORT float f13_F_FSI_IFD(float p0, struct S_IFD p1, int p2,  float (*cb)(float, struct S_IFD, int)) ;
+EXPORT float f13_F_FSI_IFP(float p0, struct S_IFP p1, int p2,  float (*cb)(float, struct S_IFP, int)) ;
+EXPORT float f13_F_FSI_IDI(float p0, struct S_IDI p1, int p2,  float (*cb)(float, struct S_IDI, int)) ;
+EXPORT float f13_F_FSI_IDF(float p0, struct S_IDF p1, int p2,  float (*cb)(float, struct S_IDF, int)) ;
+EXPORT float f13_F_FSI_IDD(float p0, struct S_IDD p1, int p2,  float (*cb)(float, struct S_IDD, int)) ;
+EXPORT float f13_F_FSI_IDP(float p0, struct S_IDP p1, int p2,  float (*cb)(float, struct S_IDP, int)) ;
+EXPORT float f13_F_FSI_IPI(float p0, struct S_IPI p1, int p2,  float (*cb)(float, struct S_IPI, int)) ;
+EXPORT float f13_F_FSI_IPF(float p0, struct S_IPF p1, int p2,  float (*cb)(float, struct S_IPF, int)) ;
+EXPORT float f13_F_FSI_IPD(float p0, struct S_IPD p1, int p2,  float (*cb)(float, struct S_IPD, int)) ;
+EXPORT float f13_F_FSI_IPP(float p0, struct S_IPP p1, int p2,  float (*cb)(float, struct S_IPP, int)) ;
+EXPORT float f13_F_FSI_FII(float p0, struct S_FII p1, int p2,  float (*cb)(float, struct S_FII, int)) ;
+EXPORT float f13_F_FSI_FIF(float p0, struct S_FIF p1, int p2,  float (*cb)(float, struct S_FIF, int)) ;
+EXPORT float f13_F_FSI_FID(float p0, struct S_FID p1, int p2,  float (*cb)(float, struct S_FID, int)) ;
+EXPORT float f13_F_FSI_FIP(float p0, struct S_FIP p1, int p2,  float (*cb)(float, struct S_FIP, int)) ;
+EXPORT float f13_F_FSI_FFI(float p0, struct S_FFI p1, int p2,  float (*cb)(float, struct S_FFI, int)) ;
+EXPORT float f13_F_FSI_FFF(float p0, struct S_FFF p1, int p2,  float (*cb)(float, struct S_FFF, int)) ;
+EXPORT float f13_F_FSI_FFD(float p0, struct S_FFD p1, int p2,  float (*cb)(float, struct S_FFD, int)) ;
+EXPORT float f13_F_FSI_FFP(float p0, struct S_FFP p1, int p2,  float (*cb)(float, struct S_FFP, int)) ;
+EXPORT float f13_F_FSI_FDI(float p0, struct S_FDI p1, int p2,  float (*cb)(float, struct S_FDI, int)) ;
+EXPORT float f13_F_FSI_FDF(float p0, struct S_FDF p1, int p2,  float (*cb)(float, struct S_FDF, int)) ;
+EXPORT float f13_F_FSI_FDD(float p0, struct S_FDD p1, int p2,  float (*cb)(float, struct S_FDD, int)) ;
+EXPORT float f13_F_FSI_FDP(float p0, struct S_FDP p1, int p2,  float (*cb)(float, struct S_FDP, int)) ;
+EXPORT float f13_F_FSI_FPI(float p0, struct S_FPI p1, int p2,  float (*cb)(float, struct S_FPI, int)) ;
+EXPORT float f13_F_FSI_FPF(float p0, struct S_FPF p1, int p2,  float (*cb)(float, struct S_FPF, int)) ;
+EXPORT float f13_F_FSI_FPD(float p0, struct S_FPD p1, int p2,  float (*cb)(float, struct S_FPD, int)) ;
+EXPORT float f13_F_FSI_FPP(float p0, struct S_FPP p1, int p2,  float (*cb)(float, struct S_FPP, int)) ;
+EXPORT float f13_F_FSI_DII(float p0, struct S_DII p1, int p2,  float (*cb)(float, struct S_DII, int)) ;
+EXPORT float f13_F_FSI_DIF(float p0, struct S_DIF p1, int p2,  float (*cb)(float, struct S_DIF, int)) ;
+EXPORT float f13_F_FSI_DID(float p0, struct S_DID p1, int p2,  float (*cb)(float, struct S_DID, int)) ;
+EXPORT float f13_F_FSI_DIP(float p0, struct S_DIP p1, int p2,  float (*cb)(float, struct S_DIP, int)) ;
+EXPORT float f13_F_FSI_DFI(float p0, struct S_DFI p1, int p2,  float (*cb)(float, struct S_DFI, int)) ;
+EXPORT float f13_F_FSI_DFF(float p0, struct S_DFF p1, int p2,  float (*cb)(float, struct S_DFF, int)) ;
+EXPORT float f13_F_FSI_DFD(float p0, struct S_DFD p1, int p2,  float (*cb)(float, struct S_DFD, int)) ;
+EXPORT float f13_F_FSI_DFP(float p0, struct S_DFP p1, int p2,  float (*cb)(float, struct S_DFP, int)) ;
+EXPORT float f13_F_FSI_DDI(float p0, struct S_DDI p1, int p2,  float (*cb)(float, struct S_DDI, int)) ;
+EXPORT float f13_F_FSI_DDF(float p0, struct S_DDF p1, int p2,  float (*cb)(float, struct S_DDF, int)) ;
+EXPORT float f13_F_FSI_DDD(float p0, struct S_DDD p1, int p2,  float (*cb)(float, struct S_DDD, int)) ;
+EXPORT float f13_F_FSI_DDP(float p0, struct S_DDP p1, int p2,  float (*cb)(float, struct S_DDP, int)) ;
+EXPORT float f13_F_FSI_DPI(float p0, struct S_DPI p1, int p2,  float (*cb)(float, struct S_DPI, int)) ;
+EXPORT float f13_F_FSI_DPF(float p0, struct S_DPF p1, int p2,  float (*cb)(float, struct S_DPF, int)) ;
+EXPORT float f13_F_FSI_DPD(float p0, struct S_DPD p1, int p2,  float (*cb)(float, struct S_DPD, int)) ;
+EXPORT float f13_F_FSI_DPP(float p0, struct S_DPP p1, int p2,  float (*cb)(float, struct S_DPP, int)) ;
+EXPORT float f13_F_FSI_PII(float p0, struct S_PII p1, int p2,  float (*cb)(float, struct S_PII, int)) ;
+EXPORT float f13_F_FSI_PIF(float p0, struct S_PIF p1, int p2,  float (*cb)(float, struct S_PIF, int)) ;
+EXPORT float f13_F_FSI_PID(float p0, struct S_PID p1, int p2,  float (*cb)(float, struct S_PID, int)) ;
+EXPORT float f13_F_FSI_PIP(float p0, struct S_PIP p1, int p2,  float (*cb)(float, struct S_PIP, int)) ;
+EXPORT float f13_F_FSI_PFI(float p0, struct S_PFI p1, int p2,  float (*cb)(float, struct S_PFI, int)) ;
+EXPORT float f13_F_FSI_PFF(float p0, struct S_PFF p1, int p2,  float (*cb)(float, struct S_PFF, int)) ;
+EXPORT float f13_F_FSI_PFD(float p0, struct S_PFD p1, int p2,  float (*cb)(float, struct S_PFD, int)) ;
+EXPORT float f13_F_FSI_PFP(float p0, struct S_PFP p1, int p2,  float (*cb)(float, struct S_PFP, int)) ;
+EXPORT float f13_F_FSI_PDI(float p0, struct S_PDI p1, int p2,  float (*cb)(float, struct S_PDI, int)) ;
+EXPORT float f13_F_FSI_PDF(float p0, struct S_PDF p1, int p2,  float (*cb)(float, struct S_PDF, int)) ;
+EXPORT float f13_F_FSI_PDD(float p0, struct S_PDD p1, int p2,  float (*cb)(float, struct S_PDD, int)) ;
+EXPORT float f13_F_FSI_PDP(float p0, struct S_PDP p1, int p2,  float (*cb)(float, struct S_PDP, int)) ;
+EXPORT float f13_F_FSI_PPI(float p0, struct S_PPI p1, int p2,  float (*cb)(float, struct S_PPI, int)) ;
+EXPORT float f13_F_FSI_PPF(float p0, struct S_PPF p1, int p2,  float (*cb)(float, struct S_PPF, int)) ;
+EXPORT float f13_F_FSI_PPD(float p0, struct S_PPD p1, int p2,  float (*cb)(float, struct S_PPD, int)) ;
+EXPORT float f13_F_FSI_PPP(float p0, struct S_PPP p1, int p2,  float (*cb)(float, struct S_PPP, int)) ;
+EXPORT float f13_F_FSF_I(float p0, struct S_I p1, float p2,  float (*cb)(float, struct S_I, float)) ;
+EXPORT float f13_F_FSF_F(float p0, struct S_F p1, float p2,  float (*cb)(float, struct S_F, float)) ;
+EXPORT float f13_F_FSF_D(float p0, struct S_D p1, float p2,  float (*cb)(float, struct S_D, float)) ;
+EXPORT float f13_F_FSF_P(float p0, struct S_P p1, float p2,  float (*cb)(float, struct S_P, float)) ;
+EXPORT float f13_F_FSF_II(float p0, struct S_II p1, float p2,  float (*cb)(float, struct S_II, float)) ;
+EXPORT float f13_F_FSF_IF(float p0, struct S_IF p1, float p2,  float (*cb)(float, struct S_IF, float)) ;
+EXPORT float f13_F_FSF_ID(float p0, struct S_ID p1, float p2,  float (*cb)(float, struct S_ID, float)) ;
+EXPORT float f13_F_FSF_IP(float p0, struct S_IP p1, float p2,  float (*cb)(float, struct S_IP, float)) ;
+EXPORT float f13_F_FSF_FI(float p0, struct S_FI p1, float p2,  float (*cb)(float, struct S_FI, float)) ;
+EXPORT float f13_F_FSF_FF(float p0, struct S_FF p1, float p2,  float (*cb)(float, struct S_FF, float)) ;
+EXPORT float f13_F_FSF_FD(float p0, struct S_FD p1, float p2,  float (*cb)(float, struct S_FD, float)) ;
+EXPORT float f13_F_FSF_FP(float p0, struct S_FP p1, float p2,  float (*cb)(float, struct S_FP, float)) ;
+EXPORT float f13_F_FSF_DI(float p0, struct S_DI p1, float p2,  float (*cb)(float, struct S_DI, float)) ;
+EXPORT float f13_F_FSF_DF(float p0, struct S_DF p1, float p2,  float (*cb)(float, struct S_DF, float)) ;
+EXPORT float f13_F_FSF_DD(float p0, struct S_DD p1, float p2,  float (*cb)(float, struct S_DD, float)) ;
+EXPORT float f13_F_FSF_DP(float p0, struct S_DP p1, float p2,  float (*cb)(float, struct S_DP, float)) ;
+EXPORT float f13_F_FSF_PI(float p0, struct S_PI p1, float p2,  float (*cb)(float, struct S_PI, float)) ;
+EXPORT float f13_F_FSF_PF(float p0, struct S_PF p1, float p2,  float (*cb)(float, struct S_PF, float)) ;
+EXPORT float f13_F_FSF_PD(float p0, struct S_PD p1, float p2,  float (*cb)(float, struct S_PD, float)) ;
+EXPORT float f13_F_FSF_PP(float p0, struct S_PP p1, float p2,  float (*cb)(float, struct S_PP, float)) ;
+EXPORT float f13_F_FSF_III(float p0, struct S_III p1, float p2,  float (*cb)(float, struct S_III, float)) ;
+EXPORT float f13_F_FSF_IIF(float p0, struct S_IIF p1, float p2,  float (*cb)(float, struct S_IIF, float)) ;
+EXPORT float f13_F_FSF_IID(float p0, struct S_IID p1, float p2,  float (*cb)(float, struct S_IID, float)) ;
+EXPORT float f13_F_FSF_IIP(float p0, struct S_IIP p1, float p2,  float (*cb)(float, struct S_IIP, float)) ;
+EXPORT float f13_F_FSF_IFI(float p0, struct S_IFI p1, float p2,  float (*cb)(float, struct S_IFI, float)) ;
+EXPORT float f13_F_FSF_IFF(float p0, struct S_IFF p1, float p2,  float (*cb)(float, struct S_IFF, float)) ;
+EXPORT float f13_F_FSF_IFD(float p0, struct S_IFD p1, float p2,  float (*cb)(float, struct S_IFD, float)) ;
+EXPORT float f13_F_FSF_IFP(float p0, struct S_IFP p1, float p2,  float (*cb)(float, struct S_IFP, float)) ;
+EXPORT float f13_F_FSF_IDI(float p0, struct S_IDI p1, float p2,  float (*cb)(float, struct S_IDI, float)) ;
+EXPORT float f13_F_FSF_IDF(float p0, struct S_IDF p1, float p2,  float (*cb)(float, struct S_IDF, float)) ;
+EXPORT float f13_F_FSF_IDD(float p0, struct S_IDD p1, float p2,  float (*cb)(float, struct S_IDD, float)) ;
+EXPORT float f13_F_FSF_IDP(float p0, struct S_IDP p1, float p2,  float (*cb)(float, struct S_IDP, float)) ;
+EXPORT float f13_F_FSF_IPI(float p0, struct S_IPI p1, float p2,  float (*cb)(float, struct S_IPI, float)) ;
+EXPORT float f13_F_FSF_IPF(float p0, struct S_IPF p1, float p2,  float (*cb)(float, struct S_IPF, float)) ;
+EXPORT float f13_F_FSF_IPD(float p0, struct S_IPD p1, float p2,  float (*cb)(float, struct S_IPD, float)) ;
+EXPORT float f13_F_FSF_IPP(float p0, struct S_IPP p1, float p2,  float (*cb)(float, struct S_IPP, float)) ;
+EXPORT float f13_F_FSF_FII(float p0, struct S_FII p1, float p2,  float (*cb)(float, struct S_FII, float)) ;
+EXPORT float f13_F_FSF_FIF(float p0, struct S_FIF p1, float p2,  float (*cb)(float, struct S_FIF, float)) ;
+EXPORT float f13_F_FSF_FID(float p0, struct S_FID p1, float p2,  float (*cb)(float, struct S_FID, float)) ;
+EXPORT float f13_F_FSF_FIP(float p0, struct S_FIP p1, float p2,  float (*cb)(float, struct S_FIP, float)) ;
+EXPORT float f13_F_FSF_FFI(float p0, struct S_FFI p1, float p2,  float (*cb)(float, struct S_FFI, float)) ;
+EXPORT float f13_F_FSF_FFF(float p0, struct S_FFF p1, float p2,  float (*cb)(float, struct S_FFF, float)) ;
+EXPORT float f13_F_FSF_FFD(float p0, struct S_FFD p1, float p2,  float (*cb)(float, struct S_FFD, float)) ;
+EXPORT float f13_F_FSF_FFP(float p0, struct S_FFP p1, float p2,  float (*cb)(float, struct S_FFP, float)) ;
+EXPORT float f13_F_FSF_FDI(float p0, struct S_FDI p1, float p2,  float (*cb)(float, struct S_FDI, float)) ;
+EXPORT float f13_F_FSF_FDF(float p0, struct S_FDF p1, float p2,  float (*cb)(float, struct S_FDF, float)) ;
+EXPORT float f13_F_FSF_FDD(float p0, struct S_FDD p1, float p2,  float (*cb)(float, struct S_FDD, float)) ;
+EXPORT float f13_F_FSF_FDP(float p0, struct S_FDP p1, float p2,  float (*cb)(float, struct S_FDP, float)) ;
+EXPORT float f13_F_FSF_FPI(float p0, struct S_FPI p1, float p2,  float (*cb)(float, struct S_FPI, float)) ;
+EXPORT float f13_F_FSF_FPF(float p0, struct S_FPF p1, float p2,  float (*cb)(float, struct S_FPF, float)) ;
+EXPORT float f13_F_FSF_FPD(float p0, struct S_FPD p1, float p2,  float (*cb)(float, struct S_FPD, float)) ;
+EXPORT float f13_F_FSF_FPP(float p0, struct S_FPP p1, float p2,  float (*cb)(float, struct S_FPP, float)) ;
+EXPORT float f13_F_FSF_DII(float p0, struct S_DII p1, float p2,  float (*cb)(float, struct S_DII, float)) ;
+EXPORT float f13_F_FSF_DIF(float p0, struct S_DIF p1, float p2,  float (*cb)(float, struct S_DIF, float)) ;
+EXPORT float f13_F_FSF_DID(float p0, struct S_DID p1, float p2,  float (*cb)(float, struct S_DID, float)) ;
+EXPORT float f13_F_FSF_DIP(float p0, struct S_DIP p1, float p2,  float (*cb)(float, struct S_DIP, float)) ;
+EXPORT float f13_F_FSF_DFI(float p0, struct S_DFI p1, float p2,  float (*cb)(float, struct S_DFI, float)) ;
+EXPORT float f13_F_FSF_DFF(float p0, struct S_DFF p1, float p2,  float (*cb)(float, struct S_DFF, float)) ;
+EXPORT float f13_F_FSF_DFD(float p0, struct S_DFD p1, float p2,  float (*cb)(float, struct S_DFD, float)) ;
+EXPORT float f13_F_FSF_DFP(float p0, struct S_DFP p1, float p2,  float (*cb)(float, struct S_DFP, float)) ;
+EXPORT float f13_F_FSF_DDI(float p0, struct S_DDI p1, float p2,  float (*cb)(float, struct S_DDI, float)) ;
+EXPORT float f13_F_FSF_DDF(float p0, struct S_DDF p1, float p2,  float (*cb)(float, struct S_DDF, float)) ;
+EXPORT float f13_F_FSF_DDD(float p0, struct S_DDD p1, float p2,  float (*cb)(float, struct S_DDD, float)) ;
+EXPORT float f13_F_FSF_DDP(float p0, struct S_DDP p1, float p2,  float (*cb)(float, struct S_DDP, float)) ;
+EXPORT float f13_F_FSF_DPI(float p0, struct S_DPI p1, float p2,  float (*cb)(float, struct S_DPI, float)) ;
+EXPORT float f13_F_FSF_DPF(float p0, struct S_DPF p1, float p2,  float (*cb)(float, struct S_DPF, float)) ;
+EXPORT float f13_F_FSF_DPD(float p0, struct S_DPD p1, float p2,  float (*cb)(float, struct S_DPD, float)) ;
+EXPORT float f13_F_FSF_DPP(float p0, struct S_DPP p1, float p2,  float (*cb)(float, struct S_DPP, float)) ;
+EXPORT float f13_F_FSF_PII(float p0, struct S_PII p1, float p2,  float (*cb)(float, struct S_PII, float)) ;
+EXPORT float f13_F_FSF_PIF(float p0, struct S_PIF p1, float p2,  float (*cb)(float, struct S_PIF, float)) ;
+EXPORT float f13_F_FSF_PID(float p0, struct S_PID p1, float p2,  float (*cb)(float, struct S_PID, float)) ;
+EXPORT float f13_F_FSF_PIP(float p0, struct S_PIP p1, float p2,  float (*cb)(float, struct S_PIP, float)) ;
+EXPORT float f13_F_FSF_PFI(float p0, struct S_PFI p1, float p2,  float (*cb)(float, struct S_PFI, float)) ;
+EXPORT float f13_F_FSF_PFF(float p0, struct S_PFF p1, float p2,  float (*cb)(float, struct S_PFF, float)) ;
+EXPORT float f13_F_FSF_PFD(float p0, struct S_PFD p1, float p2,  float (*cb)(float, struct S_PFD, float)) ;
+EXPORT float f13_F_FSF_PFP(float p0, struct S_PFP p1, float p2,  float (*cb)(float, struct S_PFP, float)) ;
+EXPORT float f13_F_FSF_PDI(float p0, struct S_PDI p1, float p2,  float (*cb)(float, struct S_PDI, float)) ;
+EXPORT float f13_F_FSF_PDF(float p0, struct S_PDF p1, float p2,  float (*cb)(float, struct S_PDF, float)) ;
+EXPORT float f13_F_FSF_PDD(float p0, struct S_PDD p1, float p2,  float (*cb)(float, struct S_PDD, float)) ;
+EXPORT float f13_F_FSF_PDP(float p0, struct S_PDP p1, float p2,  float (*cb)(float, struct S_PDP, float)) ;
+EXPORT float f13_F_FSF_PPI(float p0, struct S_PPI p1, float p2,  float (*cb)(float, struct S_PPI, float)) ;
+EXPORT float f13_F_FSF_PPF(float p0, struct S_PPF p1, float p2,  float (*cb)(float, struct S_PPF, float)) ;
+EXPORT float f13_F_FSF_PPD(float p0, struct S_PPD p1, float p2,  float (*cb)(float, struct S_PPD, float)) ;
+EXPORT float f13_F_FSF_PPP(float p0, struct S_PPP p1, float p2,  float (*cb)(float, struct S_PPP, float)) ;
+EXPORT float f13_F_FSD_I(float p0, struct S_I p1, double p2,  float (*cb)(float, struct S_I, double)) ;
+EXPORT float f13_F_FSD_F(float p0, struct S_F p1, double p2,  float (*cb)(float, struct S_F, double)) ;
+EXPORT float f13_F_FSD_D(float p0, struct S_D p1, double p2,  float (*cb)(float, struct S_D, double)) ;
+EXPORT float f13_F_FSD_P(float p0, struct S_P p1, double p2,  float (*cb)(float, struct S_P, double)) ;
+EXPORT float f13_F_FSD_II(float p0, struct S_II p1, double p2,  float (*cb)(float, struct S_II, double)) ;
+EXPORT float f13_F_FSD_IF(float p0, struct S_IF p1, double p2,  float (*cb)(float, struct S_IF, double)) ;
+EXPORT float f13_F_FSD_ID(float p0, struct S_ID p1, double p2,  float (*cb)(float, struct S_ID, double)) ;
+EXPORT float f13_F_FSD_IP(float p0, struct S_IP p1, double p2,  float (*cb)(float, struct S_IP, double)) ;
+EXPORT float f13_F_FSD_FI(float p0, struct S_FI p1, double p2,  float (*cb)(float, struct S_FI, double)) ;
+EXPORT float f13_F_FSD_FF(float p0, struct S_FF p1, double p2,  float (*cb)(float, struct S_FF, double)) ;
+EXPORT float f13_F_FSD_FD(float p0, struct S_FD p1, double p2,  float (*cb)(float, struct S_FD, double)) ;
+EXPORT float f13_F_FSD_FP(float p0, struct S_FP p1, double p2,  float (*cb)(float, struct S_FP, double)) ;
+EXPORT float f13_F_FSD_DI(float p0, struct S_DI p1, double p2,  float (*cb)(float, struct S_DI, double)) ;
+EXPORT float f13_F_FSD_DF(float p0, struct S_DF p1, double p2,  float (*cb)(float, struct S_DF, double)) ;
+EXPORT float f13_F_FSD_DD(float p0, struct S_DD p1, double p2,  float (*cb)(float, struct S_DD, double)) ;
+EXPORT float f13_F_FSD_DP(float p0, struct S_DP p1, double p2,  float (*cb)(float, struct S_DP, double)) ;
+EXPORT float f13_F_FSD_PI(float p0, struct S_PI p1, double p2,  float (*cb)(float, struct S_PI, double)) ;
+EXPORT float f13_F_FSD_PF(float p0, struct S_PF p1, double p2,  float (*cb)(float, struct S_PF, double)) ;
+EXPORT float f13_F_FSD_PD(float p0, struct S_PD p1, double p2,  float (*cb)(float, struct S_PD, double)) ;
+EXPORT float f13_F_FSD_PP(float p0, struct S_PP p1, double p2,  float (*cb)(float, struct S_PP, double)) ;
+EXPORT float f13_F_FSD_III(float p0, struct S_III p1, double p2,  float (*cb)(float, struct S_III, double)) ;
+EXPORT float f13_F_FSD_IIF(float p0, struct S_IIF p1, double p2,  float (*cb)(float, struct S_IIF, double)) ;
+EXPORT float f13_F_FSD_IID(float p0, struct S_IID p1, double p2,  float (*cb)(float, struct S_IID, double)) ;
+EXPORT float f13_F_FSD_IIP(float p0, struct S_IIP p1, double p2,  float (*cb)(float, struct S_IIP, double)) ;
+EXPORT float f13_F_FSD_IFI(float p0, struct S_IFI p1, double p2,  float (*cb)(float, struct S_IFI, double)) ;
+EXPORT float f13_F_FSD_IFF(float p0, struct S_IFF p1, double p2,  float (*cb)(float, struct S_IFF, double)) ;
+EXPORT float f13_F_FSD_IFD(float p0, struct S_IFD p1, double p2,  float (*cb)(float, struct S_IFD, double)) ;
+EXPORT float f13_F_FSD_IFP(float p0, struct S_IFP p1, double p2,  float (*cb)(float, struct S_IFP, double)) ;
+EXPORT float f13_F_FSD_IDI(float p0, struct S_IDI p1, double p2,  float (*cb)(float, struct S_IDI, double)) ;
+EXPORT float f13_F_FSD_IDF(float p0, struct S_IDF p1, double p2,  float (*cb)(float, struct S_IDF, double)) ;
+EXPORT float f13_F_FSD_IDD(float p0, struct S_IDD p1, double p2,  float (*cb)(float, struct S_IDD, double)) ;
+EXPORT float f13_F_FSD_IDP(float p0, struct S_IDP p1, double p2,  float (*cb)(float, struct S_IDP, double)) ;
+EXPORT float f13_F_FSD_IPI(float p0, struct S_IPI p1, double p2,  float (*cb)(float, struct S_IPI, double)) ;
+EXPORT float f13_F_FSD_IPF(float p0, struct S_IPF p1, double p2,  float (*cb)(float, struct S_IPF, double)) ;
+EXPORT float f13_F_FSD_IPD(float p0, struct S_IPD p1, double p2,  float (*cb)(float, struct S_IPD, double)) ;
+EXPORT float f13_F_FSD_IPP(float p0, struct S_IPP p1, double p2,  float (*cb)(float, struct S_IPP, double)) ;
+EXPORT float f13_F_FSD_FII(float p0, struct S_FII p1, double p2,  float (*cb)(float, struct S_FII, double)) ;
+EXPORT float f13_F_FSD_FIF(float p0, struct S_FIF p1, double p2,  float (*cb)(float, struct S_FIF, double)) ;
+EXPORT float f13_F_FSD_FID(float p0, struct S_FID p1, double p2,  float (*cb)(float, struct S_FID, double)) ;
+EXPORT float f13_F_FSD_FIP(float p0, struct S_FIP p1, double p2,  float (*cb)(float, struct S_FIP, double)) ;
+EXPORT float f13_F_FSD_FFI(float p0, struct S_FFI p1, double p2,  float (*cb)(float, struct S_FFI, double)) ;
+EXPORT float f13_F_FSD_FFF(float p0, struct S_FFF p1, double p2,  float (*cb)(float, struct S_FFF, double)) ;
+EXPORT float f13_F_FSD_FFD(float p0, struct S_FFD p1, double p2,  float (*cb)(float, struct S_FFD, double)) ;
+EXPORT float f13_F_FSD_FFP(float p0, struct S_FFP p1, double p2,  float (*cb)(float, struct S_FFP, double)) ;
+EXPORT float f13_F_FSD_FDI(float p0, struct S_FDI p1, double p2,  float (*cb)(float, struct S_FDI, double)) ;
+EXPORT float f13_F_FSD_FDF(float p0, struct S_FDF p1, double p2,  float (*cb)(float, struct S_FDF, double)) ;
+EXPORT float f13_F_FSD_FDD(float p0, struct S_FDD p1, double p2,  float (*cb)(float, struct S_FDD, double)) ;
+EXPORT float f13_F_FSD_FDP(float p0, struct S_FDP p1, double p2,  float (*cb)(float, struct S_FDP, double)) ;
+EXPORT float f13_F_FSD_FPI(float p0, struct S_FPI p1, double p2,  float (*cb)(float, struct S_FPI, double)) ;
+EXPORT float f13_F_FSD_FPF(float p0, struct S_FPF p1, double p2,  float (*cb)(float, struct S_FPF, double)) ;
+EXPORT float f13_F_FSD_FPD(float p0, struct S_FPD p1, double p2,  float (*cb)(float, struct S_FPD, double)) ;
+EXPORT float f13_F_FSD_FPP(float p0, struct S_FPP p1, double p2,  float (*cb)(float, struct S_FPP, double)) ;
+EXPORT float f13_F_FSD_DII(float p0, struct S_DII p1, double p2,  float (*cb)(float, struct S_DII, double)) ;
+EXPORT float f13_F_FSD_DIF(float p0, struct S_DIF p1, double p2,  float (*cb)(float, struct S_DIF, double)) ;
+EXPORT float f13_F_FSD_DID(float p0, struct S_DID p1, double p2,  float (*cb)(float, struct S_DID, double)) ;
+EXPORT float f13_F_FSD_DIP(float p0, struct S_DIP p1, double p2,  float (*cb)(float, struct S_DIP, double)) ;
+EXPORT float f13_F_FSD_DFI(float p0, struct S_DFI p1, double p2,  float (*cb)(float, struct S_DFI, double)) ;
+EXPORT float f13_F_FSD_DFF(float p0, struct S_DFF p1, double p2,  float (*cb)(float, struct S_DFF, double)) ;
+EXPORT float f13_F_FSD_DFD(float p0, struct S_DFD p1, double p2,  float (*cb)(float, struct S_DFD, double)) ;
+EXPORT float f13_F_FSD_DFP(float p0, struct S_DFP p1, double p2,  float (*cb)(float, struct S_DFP, double)) ;
+EXPORT float f13_F_FSD_DDI(float p0, struct S_DDI p1, double p2,  float (*cb)(float, struct S_DDI, double)) ;
+EXPORT float f13_F_FSD_DDF(float p0, struct S_DDF p1, double p2,  float (*cb)(float, struct S_DDF, double)) ;
+EXPORT float f13_F_FSD_DDD(float p0, struct S_DDD p1, double p2,  float (*cb)(float, struct S_DDD, double)) ;
+EXPORT float f13_F_FSD_DDP(float p0, struct S_DDP p1, double p2,  float (*cb)(float, struct S_DDP, double)) ;
+EXPORT float f13_F_FSD_DPI(float p0, struct S_DPI p1, double p2,  float (*cb)(float, struct S_DPI, double)) ;
+EXPORT float f13_F_FSD_DPF(float p0, struct S_DPF p1, double p2,  float (*cb)(float, struct S_DPF, double)) ;
+EXPORT float f13_F_FSD_DPD(float p0, struct S_DPD p1, double p2,  float (*cb)(float, struct S_DPD, double)) ;
+EXPORT float f13_F_FSD_DPP(float p0, struct S_DPP p1, double p2,  float (*cb)(float, struct S_DPP, double)) ;
+EXPORT float f13_F_FSD_PII(float p0, struct S_PII p1, double p2,  float (*cb)(float, struct S_PII, double)) ;
+EXPORT float f13_F_FSD_PIF(float p0, struct S_PIF p1, double p2,  float (*cb)(float, struct S_PIF, double)) ;
+EXPORT float f13_F_FSD_PID(float p0, struct S_PID p1, double p2,  float (*cb)(float, struct S_PID, double)) ;
+EXPORT float f13_F_FSD_PIP(float p0, struct S_PIP p1, double p2,  float (*cb)(float, struct S_PIP, double)) ;
+EXPORT float f13_F_FSD_PFI(float p0, struct S_PFI p1, double p2,  float (*cb)(float, struct S_PFI, double)) ;
+EXPORT float f13_F_FSD_PFF(float p0, struct S_PFF p1, double p2,  float (*cb)(float, struct S_PFF, double)) ;
+EXPORT float f13_F_FSD_PFD(float p0, struct S_PFD p1, double p2,  float (*cb)(float, struct S_PFD, double)) ;
+EXPORT float f13_F_FSD_PFP(float p0, struct S_PFP p1, double p2,  float (*cb)(float, struct S_PFP, double)) ;
+EXPORT float f13_F_FSD_PDI(float p0, struct S_PDI p1, double p2,  float (*cb)(float, struct S_PDI, double)) ;
+EXPORT float f13_F_FSD_PDF(float p0, struct S_PDF p1, double p2,  float (*cb)(float, struct S_PDF, double)) ;
+EXPORT float f13_F_FSD_PDD(float p0, struct S_PDD p1, double p2,  float (*cb)(float, struct S_PDD, double)) ;
+EXPORT float f13_F_FSD_PDP(float p0, struct S_PDP p1, double p2,  float (*cb)(float, struct S_PDP, double)) ;
+EXPORT float f13_F_FSD_PPI(float p0, struct S_PPI p1, double p2,  float (*cb)(float, struct S_PPI, double)) ;
+EXPORT float f13_F_FSD_PPF(float p0, struct S_PPF p1, double p2,  float (*cb)(float, struct S_PPF, double)) ;
+EXPORT float f13_F_FSD_PPD(float p0, struct S_PPD p1, double p2,  float (*cb)(float, struct S_PPD, double)) ;
+EXPORT float f13_F_FSD_PPP(float p0, struct S_PPP p1, double p2,  float (*cb)(float, struct S_PPP, double)) ;
+EXPORT float f13_F_FSP_I(float p0, struct S_I p1, void* p2,  float (*cb)(float, struct S_I, void*)) ;
+EXPORT float f13_F_FSP_F(float p0, struct S_F p1, void* p2,  float (*cb)(float, struct S_F, void*)) ;
+EXPORT float f13_F_FSP_D(float p0, struct S_D p1, void* p2,  float (*cb)(float, struct S_D, void*)) ;
+EXPORT float f13_F_FSP_P(float p0, struct S_P p1, void* p2,  float (*cb)(float, struct S_P, void*)) ;
+EXPORT float f13_F_FSP_II(float p0, struct S_II p1, void* p2,  float (*cb)(float, struct S_II, void*)) ;
+EXPORT float f13_F_FSP_IF(float p0, struct S_IF p1, void* p2,  float (*cb)(float, struct S_IF, void*)) ;
+EXPORT float f13_F_FSP_ID(float p0, struct S_ID p1, void* p2,  float (*cb)(float, struct S_ID, void*)) ;
+EXPORT float f13_F_FSP_IP(float p0, struct S_IP p1, void* p2,  float (*cb)(float, struct S_IP, void*)) ;
+EXPORT float f13_F_FSP_FI(float p0, struct S_FI p1, void* p2,  float (*cb)(float, struct S_FI, void*)) ;
+EXPORT float f13_F_FSP_FF(float p0, struct S_FF p1, void* p2,  float (*cb)(float, struct S_FF, void*)) ;
+EXPORT float f13_F_FSP_FD(float p0, struct S_FD p1, void* p2,  float (*cb)(float, struct S_FD, void*)) ;
+EXPORT float f13_F_FSP_FP(float p0, struct S_FP p1, void* p2,  float (*cb)(float, struct S_FP, void*)) ;
+EXPORT float f13_F_FSP_DI(float p0, struct S_DI p1, void* p2,  float (*cb)(float, struct S_DI, void*)) ;
+EXPORT float f13_F_FSP_DF(float p0, struct S_DF p1, void* p2,  float (*cb)(float, struct S_DF, void*)) ;
+EXPORT float f13_F_FSP_DD(float p0, struct S_DD p1, void* p2,  float (*cb)(float, struct S_DD, void*)) ;
+EXPORT float f13_F_FSP_DP(float p0, struct S_DP p1, void* p2,  float (*cb)(float, struct S_DP, void*)) ;
+EXPORT float f13_F_FSP_PI(float p0, struct S_PI p1, void* p2,  float (*cb)(float, struct S_PI, void*)) ;
+EXPORT float f13_F_FSP_PF(float p0, struct S_PF p1, void* p2,  float (*cb)(float, struct S_PF, void*)) ;
+EXPORT float f13_F_FSP_PD(float p0, struct S_PD p1, void* p2,  float (*cb)(float, struct S_PD, void*)) ;
+EXPORT float f13_F_FSP_PP(float p0, struct S_PP p1, void* p2,  float (*cb)(float, struct S_PP, void*)) ;
+EXPORT float f13_F_FSP_III(float p0, struct S_III p1, void* p2,  float (*cb)(float, struct S_III, void*)) ;
+EXPORT float f13_F_FSP_IIF(float p0, struct S_IIF p1, void* p2,  float (*cb)(float, struct S_IIF, void*)) ;
+EXPORT float f13_F_FSP_IID(float p0, struct S_IID p1, void* p2,  float (*cb)(float, struct S_IID, void*)) ;
+EXPORT float f13_F_FSP_IIP(float p0, struct S_IIP p1, void* p2,  float (*cb)(float, struct S_IIP, void*)) ;
+EXPORT float f13_F_FSP_IFI(float p0, struct S_IFI p1, void* p2,  float (*cb)(float, struct S_IFI, void*)) ;
+EXPORT float f13_F_FSP_IFF(float p0, struct S_IFF p1, void* p2,  float (*cb)(float, struct S_IFF, void*)) ;
+EXPORT float f13_F_FSP_IFD(float p0, struct S_IFD p1, void* p2,  float (*cb)(float, struct S_IFD, void*)) ;
+EXPORT float f13_F_FSP_IFP(float p0, struct S_IFP p1, void* p2,  float (*cb)(float, struct S_IFP, void*)) ;
+EXPORT float f13_F_FSP_IDI(float p0, struct S_IDI p1, void* p2,  float (*cb)(float, struct S_IDI, void*)) ;
+EXPORT float f13_F_FSP_IDF(float p0, struct S_IDF p1, void* p2,  float (*cb)(float, struct S_IDF, void*)) ;
+EXPORT float f13_F_FSP_IDD(float p0, struct S_IDD p1, void* p2,  float (*cb)(float, struct S_IDD, void*)) ;
+EXPORT float f13_F_FSP_IDP(float p0, struct S_IDP p1, void* p2,  float (*cb)(float, struct S_IDP, void*)) ;
+EXPORT float f13_F_FSP_IPI(float p0, struct S_IPI p1, void* p2,  float (*cb)(float, struct S_IPI, void*)) ;
+EXPORT float f13_F_FSP_IPF(float p0, struct S_IPF p1, void* p2,  float (*cb)(float, struct S_IPF, void*)) ;
+EXPORT float f13_F_FSP_IPD(float p0, struct S_IPD p1, void* p2,  float (*cb)(float, struct S_IPD, void*)) ;
+EXPORT float f13_F_FSP_IPP(float p0, struct S_IPP p1, void* p2,  float (*cb)(float, struct S_IPP, void*)) ;
+EXPORT float f13_F_FSP_FII(float p0, struct S_FII p1, void* p2,  float (*cb)(float, struct S_FII, void*)) ;
+EXPORT float f13_F_FSP_FIF(float p0, struct S_FIF p1, void* p2,  float (*cb)(float, struct S_FIF, void*)) ;
+EXPORT float f13_F_FSP_FID(float p0, struct S_FID p1, void* p2,  float (*cb)(float, struct S_FID, void*)) ;
+EXPORT float f13_F_FSP_FIP(float p0, struct S_FIP p1, void* p2,  float (*cb)(float, struct S_FIP, void*)) ;
+EXPORT float f13_F_FSP_FFI(float p0, struct S_FFI p1, void* p2,  float (*cb)(float, struct S_FFI, void*)) ;
+EXPORT float f13_F_FSP_FFF(float p0, struct S_FFF p1, void* p2,  float (*cb)(float, struct S_FFF, void*)) ;
+EXPORT float f13_F_FSP_FFD(float p0, struct S_FFD p1, void* p2,  float (*cb)(float, struct S_FFD, void*)) ;
+EXPORT float f13_F_FSP_FFP(float p0, struct S_FFP p1, void* p2,  float (*cb)(float, struct S_FFP, void*)) ;
+EXPORT float f13_F_FSP_FDI(float p0, struct S_FDI p1, void* p2,  float (*cb)(float, struct S_FDI, void*)) ;
+EXPORT float f13_F_FSP_FDF(float p0, struct S_FDF p1, void* p2,  float (*cb)(float, struct S_FDF, void*)) ;
+EXPORT float f13_F_FSP_FDD(float p0, struct S_FDD p1, void* p2,  float (*cb)(float, struct S_FDD, void*)) ;
+EXPORT float f13_F_FSP_FDP(float p0, struct S_FDP p1, void* p2,  float (*cb)(float, struct S_FDP, void*)) ;
+EXPORT float f13_F_FSP_FPI(float p0, struct S_FPI p1, void* p2,  float (*cb)(float, struct S_FPI, void*)) ;
+EXPORT float f13_F_FSP_FPF(float p0, struct S_FPF p1, void* p2,  float (*cb)(float, struct S_FPF, void*)) ;
+EXPORT float f13_F_FSP_FPD(float p0, struct S_FPD p1, void* p2,  float (*cb)(float, struct S_FPD, void*)) ;
+EXPORT float f13_F_FSP_FPP(float p0, struct S_FPP p1, void* p2,  float (*cb)(float, struct S_FPP, void*)) ;
+EXPORT float f13_F_FSP_DII(float p0, struct S_DII p1, void* p2,  float (*cb)(float, struct S_DII, void*)) ;
+EXPORT float f13_F_FSP_DIF(float p0, struct S_DIF p1, void* p2,  float (*cb)(float, struct S_DIF, void*)) ;
+EXPORT float f13_F_FSP_DID(float p0, struct S_DID p1, void* p2,  float (*cb)(float, struct S_DID, void*)) ;
+EXPORT float f13_F_FSP_DIP(float p0, struct S_DIP p1, void* p2,  float (*cb)(float, struct S_DIP, void*)) ;
+EXPORT float f13_F_FSP_DFI(float p0, struct S_DFI p1, void* p2,  float (*cb)(float, struct S_DFI, void*)) ;
+EXPORT float f13_F_FSP_DFF(float p0, struct S_DFF p1, void* p2,  float (*cb)(float, struct S_DFF, void*)) ;
+EXPORT float f13_F_FSP_DFD(float p0, struct S_DFD p1, void* p2,  float (*cb)(float, struct S_DFD, void*)) ;
+EXPORT float f13_F_FSP_DFP(float p0, struct S_DFP p1, void* p2,  float (*cb)(float, struct S_DFP, void*)) ;
+EXPORT float f13_F_FSP_DDI(float p0, struct S_DDI p1, void* p2,  float (*cb)(float, struct S_DDI, void*)) ;
+EXPORT float f13_F_FSP_DDF(float p0, struct S_DDF p1, void* p2,  float (*cb)(float, struct S_DDF, void*)) ;
+EXPORT float f13_F_FSP_DDD(float p0, struct S_DDD p1, void* p2,  float (*cb)(float, struct S_DDD, void*)) ;
+EXPORT float f13_F_FSP_DDP(float p0, struct S_DDP p1, void* p2,  float (*cb)(float, struct S_DDP, void*)) ;
+EXPORT float f13_F_FSP_DPI(float p0, struct S_DPI p1, void* p2,  float (*cb)(float, struct S_DPI, void*)) ;
+EXPORT float f13_F_FSP_DPF(float p0, struct S_DPF p1, void* p2,  float (*cb)(float, struct S_DPF, void*)) ;
+EXPORT float f13_F_FSP_DPD(float p0, struct S_DPD p1, void* p2,  float (*cb)(float, struct S_DPD, void*)) ;
+EXPORT float f13_F_FSP_DPP(float p0, struct S_DPP p1, void* p2,  float (*cb)(float, struct S_DPP, void*)) ;
+EXPORT float f13_F_FSP_PII(float p0, struct S_PII p1, void* p2,  float (*cb)(float, struct S_PII, void*)) ;
+EXPORT float f13_F_FSP_PIF(float p0, struct S_PIF p1, void* p2,  float (*cb)(float, struct S_PIF, void*)) ;
+EXPORT float f13_F_FSP_PID(float p0, struct S_PID p1, void* p2,  float (*cb)(float, struct S_PID, void*)) ;
+EXPORT float f13_F_FSP_PIP(float p0, struct S_PIP p1, void* p2,  float (*cb)(float, struct S_PIP, void*)) ;
+EXPORT float f13_F_FSP_PFI(float p0, struct S_PFI p1, void* p2,  float (*cb)(float, struct S_PFI, void*)) ;
+EXPORT float f13_F_FSP_PFF(float p0, struct S_PFF p1, void* p2,  float (*cb)(float, struct S_PFF, void*)) ;
+EXPORT float f13_F_FSP_PFD(float p0, struct S_PFD p1, void* p2,  float (*cb)(float, struct S_PFD, void*)) ;
+EXPORT float f13_F_FSP_PFP(float p0, struct S_PFP p1, void* p2,  float (*cb)(float, struct S_PFP, void*)) ;
+EXPORT float f13_F_FSP_PDI(float p0, struct S_PDI p1, void* p2,  float (*cb)(float, struct S_PDI, void*)) ;
+EXPORT float f13_F_FSP_PDF(float p0, struct S_PDF p1, void* p2,  float (*cb)(float, struct S_PDF, void*)) ;
+EXPORT float f13_F_FSP_PDD(float p0, struct S_PDD p1, void* p2,  float (*cb)(float, struct S_PDD, void*)) ;
+EXPORT float f13_F_FSP_PDP(float p0, struct S_PDP p1, void* p2,  float (*cb)(float, struct S_PDP, void*)) ;
+EXPORT float f13_F_FSP_PPI(float p0, struct S_PPI p1, void* p2,  float (*cb)(float, struct S_PPI, void*)) ;
+EXPORT float f13_F_FSP_PPF(float p0, struct S_PPF p1, void* p2,  float (*cb)(float, struct S_PPF, void*)) ;
+EXPORT float f13_F_FSP_PPD(float p0, struct S_PPD p1, void* p2,  float (*cb)(float, struct S_PPD, void*)) ;
+EXPORT float f13_F_FSP_PPP(float p0, struct S_PPP p1, void* p2,  float (*cb)(float, struct S_PPP, void*)) ;
+EXPORT float f13_F_FSS_I(float p0, struct S_I p1, struct S_I p2,  float (*cb)(float, struct S_I, struct S_I)) ;
+EXPORT float f13_F_FSS_F(float p0, struct S_F p1, struct S_F p2,  float (*cb)(float, struct S_F, struct S_F)) ;
+EXPORT float f13_F_FSS_D(float p0, struct S_D p1, struct S_D p2,  float (*cb)(float, struct S_D, struct S_D)) ;
+EXPORT float f13_F_FSS_P(float p0, struct S_P p1, struct S_P p2,  float (*cb)(float, struct S_P, struct S_P)) ;
+EXPORT float f13_F_FSS_II(float p0, struct S_II p1, struct S_II p2,  float (*cb)(float, struct S_II, struct S_II)) ;
+EXPORT float f13_F_FSS_IF(float p0, struct S_IF p1, struct S_IF p2,  float (*cb)(float, struct S_IF, struct S_IF)) ;
+EXPORT float f13_F_FSS_ID(float p0, struct S_ID p1, struct S_ID p2,  float (*cb)(float, struct S_ID, struct S_ID)) ;
+EXPORT float f13_F_FSS_IP(float p0, struct S_IP p1, struct S_IP p2,  float (*cb)(float, struct S_IP, struct S_IP)) ;
+EXPORT float f13_F_FSS_FI(float p0, struct S_FI p1, struct S_FI p2,  float (*cb)(float, struct S_FI, struct S_FI)) ;
+EXPORT float f13_F_FSS_FF(float p0, struct S_FF p1, struct S_FF p2,  float (*cb)(float, struct S_FF, struct S_FF)) ;
+EXPORT float f13_F_FSS_FD(float p0, struct S_FD p1, struct S_FD p2,  float (*cb)(float, struct S_FD, struct S_FD)) ;
+EXPORT float f13_F_FSS_FP(float p0, struct S_FP p1, struct S_FP p2,  float (*cb)(float, struct S_FP, struct S_FP)) ;
+EXPORT float f13_F_FSS_DI(float p0, struct S_DI p1, struct S_DI p2,  float (*cb)(float, struct S_DI, struct S_DI)) ;
+EXPORT float f13_F_FSS_DF(float p0, struct S_DF p1, struct S_DF p2,  float (*cb)(float, struct S_DF, struct S_DF)) ;
+EXPORT float f13_F_FSS_DD(float p0, struct S_DD p1, struct S_DD p2,  float (*cb)(float, struct S_DD, struct S_DD)) ;
+EXPORT float f13_F_FSS_DP(float p0, struct S_DP p1, struct S_DP p2,  float (*cb)(float, struct S_DP, struct S_DP)) ;
+EXPORT float f13_F_FSS_PI(float p0, struct S_PI p1, struct S_PI p2,  float (*cb)(float, struct S_PI, struct S_PI)) ;
+EXPORT float f13_F_FSS_PF(float p0, struct S_PF p1, struct S_PF p2,  float (*cb)(float, struct S_PF, struct S_PF)) ;
+EXPORT float f13_F_FSS_PD(float p0, struct S_PD p1, struct S_PD p2,  float (*cb)(float, struct S_PD, struct S_PD)) ;
+EXPORT float f13_F_FSS_PP(float p0, struct S_PP p1, struct S_PP p2,  float (*cb)(float, struct S_PP, struct S_PP)) ;
+EXPORT float f13_F_FSS_III(float p0, struct S_III p1, struct S_III p2,  float (*cb)(float, struct S_III, struct S_III)) ;
+EXPORT float f13_F_FSS_IIF(float p0, struct S_IIF p1, struct S_IIF p2,  float (*cb)(float, struct S_IIF, struct S_IIF)) ;
+EXPORT float f13_F_FSS_IID(float p0, struct S_IID p1, struct S_IID p2,  float (*cb)(float, struct S_IID, struct S_IID)) ;
+EXPORT float f13_F_FSS_IIP(float p0, struct S_IIP p1, struct S_IIP p2,  float (*cb)(float, struct S_IIP, struct S_IIP)) ;
+EXPORT float f13_F_FSS_IFI(float p0, struct S_IFI p1, struct S_IFI p2,  float (*cb)(float, struct S_IFI, struct S_IFI)) ;
+EXPORT float f13_F_FSS_IFF(float p0, struct S_IFF p1, struct S_IFF p2,  float (*cb)(float, struct S_IFF, struct S_IFF)) ;
+EXPORT float f13_F_FSS_IFD(float p0, struct S_IFD p1, struct S_IFD p2,  float (*cb)(float, struct S_IFD, struct S_IFD)) ;
+EXPORT float f13_F_FSS_IFP(float p0, struct S_IFP p1, struct S_IFP p2,  float (*cb)(float, struct S_IFP, struct S_IFP)) ;
+EXPORT float f13_F_FSS_IDI(float p0, struct S_IDI p1, struct S_IDI p2,  float (*cb)(float, struct S_IDI, struct S_IDI)) ;
+EXPORT float f13_F_FSS_IDF(float p0, struct S_IDF p1, struct S_IDF p2,  float (*cb)(float, struct S_IDF, struct S_IDF)) ;
+EXPORT float f13_F_FSS_IDD(float p0, struct S_IDD p1, struct S_IDD p2,  float (*cb)(float, struct S_IDD, struct S_IDD)) ;
+EXPORT float f14_F_FSS_IDP(float p0, struct S_IDP p1, struct S_IDP p2,  float (*cb)(float, struct S_IDP, struct S_IDP)) ;
+EXPORT float f14_F_FSS_IPI(float p0, struct S_IPI p1, struct S_IPI p2,  float (*cb)(float, struct S_IPI, struct S_IPI)) ;
+EXPORT float f14_F_FSS_IPF(float p0, struct S_IPF p1, struct S_IPF p2,  float (*cb)(float, struct S_IPF, struct S_IPF)) ;
+EXPORT float f14_F_FSS_IPD(float p0, struct S_IPD p1, struct S_IPD p2,  float (*cb)(float, struct S_IPD, struct S_IPD)) ;
+EXPORT float f14_F_FSS_IPP(float p0, struct S_IPP p1, struct S_IPP p2,  float (*cb)(float, struct S_IPP, struct S_IPP)) ;
+EXPORT float f14_F_FSS_FII(float p0, struct S_FII p1, struct S_FII p2,  float (*cb)(float, struct S_FII, struct S_FII)) ;
+EXPORT float f14_F_FSS_FIF(float p0, struct S_FIF p1, struct S_FIF p2,  float (*cb)(float, struct S_FIF, struct S_FIF)) ;
+EXPORT float f14_F_FSS_FID(float p0, struct S_FID p1, struct S_FID p2,  float (*cb)(float, struct S_FID, struct S_FID)) ;
+EXPORT float f14_F_FSS_FIP(float p0, struct S_FIP p1, struct S_FIP p2,  float (*cb)(float, struct S_FIP, struct S_FIP)) ;
+EXPORT float f14_F_FSS_FFI(float p0, struct S_FFI p1, struct S_FFI p2,  float (*cb)(float, struct S_FFI, struct S_FFI)) ;
+EXPORT float f14_F_FSS_FFF(float p0, struct S_FFF p1, struct S_FFF p2,  float (*cb)(float, struct S_FFF, struct S_FFF)) ;
+EXPORT float f14_F_FSS_FFD(float p0, struct S_FFD p1, struct S_FFD p2,  float (*cb)(float, struct S_FFD, struct S_FFD)) ;
+EXPORT float f14_F_FSS_FFP(float p0, struct S_FFP p1, struct S_FFP p2,  float (*cb)(float, struct S_FFP, struct S_FFP)) ;
+EXPORT float f14_F_FSS_FDI(float p0, struct S_FDI p1, struct S_FDI p2,  float (*cb)(float, struct S_FDI, struct S_FDI)) ;
+EXPORT float f14_F_FSS_FDF(float p0, struct S_FDF p1, struct S_FDF p2,  float (*cb)(float, struct S_FDF, struct S_FDF)) ;
+EXPORT float f14_F_FSS_FDD(float p0, struct S_FDD p1, struct S_FDD p2,  float (*cb)(float, struct S_FDD, struct S_FDD)) ;
+EXPORT float f14_F_FSS_FDP(float p0, struct S_FDP p1, struct S_FDP p2,  float (*cb)(float, struct S_FDP, struct S_FDP)) ;
+EXPORT float f14_F_FSS_FPI(float p0, struct S_FPI p1, struct S_FPI p2,  float (*cb)(float, struct S_FPI, struct S_FPI)) ;
+EXPORT float f14_F_FSS_FPF(float p0, struct S_FPF p1, struct S_FPF p2,  float (*cb)(float, struct S_FPF, struct S_FPF)) ;
+EXPORT float f14_F_FSS_FPD(float p0, struct S_FPD p1, struct S_FPD p2,  float (*cb)(float, struct S_FPD, struct S_FPD)) ;
+EXPORT float f14_F_FSS_FPP(float p0, struct S_FPP p1, struct S_FPP p2,  float (*cb)(float, struct S_FPP, struct S_FPP)) ;
+EXPORT float f14_F_FSS_DII(float p0, struct S_DII p1, struct S_DII p2,  float (*cb)(float, struct S_DII, struct S_DII)) ;
+EXPORT float f14_F_FSS_DIF(float p0, struct S_DIF p1, struct S_DIF p2,  float (*cb)(float, struct S_DIF, struct S_DIF)) ;
+EXPORT float f14_F_FSS_DID(float p0, struct S_DID p1, struct S_DID p2,  float (*cb)(float, struct S_DID, struct S_DID)) ;
+EXPORT float f14_F_FSS_DIP(float p0, struct S_DIP p1, struct S_DIP p2,  float (*cb)(float, struct S_DIP, struct S_DIP)) ;
+EXPORT float f14_F_FSS_DFI(float p0, struct S_DFI p1, struct S_DFI p2,  float (*cb)(float, struct S_DFI, struct S_DFI)) ;
+EXPORT float f14_F_FSS_DFF(float p0, struct S_DFF p1, struct S_DFF p2,  float (*cb)(float, struct S_DFF, struct S_DFF)) ;
+EXPORT float f14_F_FSS_DFD(float p0, struct S_DFD p1, struct S_DFD p2,  float (*cb)(float, struct S_DFD, struct S_DFD)) ;
+EXPORT float f14_F_FSS_DFP(float p0, struct S_DFP p1, struct S_DFP p2,  float (*cb)(float, struct S_DFP, struct S_DFP)) ;
+EXPORT float f14_F_FSS_DDI(float p0, struct S_DDI p1, struct S_DDI p2,  float (*cb)(float, struct S_DDI, struct S_DDI)) ;
+EXPORT float f14_F_FSS_DDF(float p0, struct S_DDF p1, struct S_DDF p2,  float (*cb)(float, struct S_DDF, struct S_DDF)) ;
+EXPORT float f14_F_FSS_DDD(float p0, struct S_DDD p1, struct S_DDD p2,  float (*cb)(float, struct S_DDD, struct S_DDD)) ;
+EXPORT float f14_F_FSS_DDP(float p0, struct S_DDP p1, struct S_DDP p2,  float (*cb)(float, struct S_DDP, struct S_DDP)) ;
+EXPORT float f14_F_FSS_DPI(float p0, struct S_DPI p1, struct S_DPI p2,  float (*cb)(float, struct S_DPI, struct S_DPI)) ;
+EXPORT float f14_F_FSS_DPF(float p0, struct S_DPF p1, struct S_DPF p2,  float (*cb)(float, struct S_DPF, struct S_DPF)) ;
+EXPORT float f14_F_FSS_DPD(float p0, struct S_DPD p1, struct S_DPD p2,  float (*cb)(float, struct S_DPD, struct S_DPD)) ;
+EXPORT float f14_F_FSS_DPP(float p0, struct S_DPP p1, struct S_DPP p2,  float (*cb)(float, struct S_DPP, struct S_DPP)) ;
+EXPORT float f14_F_FSS_PII(float p0, struct S_PII p1, struct S_PII p2,  float (*cb)(float, struct S_PII, struct S_PII)) ;
+EXPORT float f14_F_FSS_PIF(float p0, struct S_PIF p1, struct S_PIF p2,  float (*cb)(float, struct S_PIF, struct S_PIF)) ;
+EXPORT float f14_F_FSS_PID(float p0, struct S_PID p1, struct S_PID p2,  float (*cb)(float, struct S_PID, struct S_PID)) ;
+EXPORT float f14_F_FSS_PIP(float p0, struct S_PIP p1, struct S_PIP p2,  float (*cb)(float, struct S_PIP, struct S_PIP)) ;
+EXPORT float f14_F_FSS_PFI(float p0, struct S_PFI p1, struct S_PFI p2,  float (*cb)(float, struct S_PFI, struct S_PFI)) ;
+EXPORT float f14_F_FSS_PFF(float p0, struct S_PFF p1, struct S_PFF p2,  float (*cb)(float, struct S_PFF, struct S_PFF)) ;
+EXPORT float f14_F_FSS_PFD(float p0, struct S_PFD p1, struct S_PFD p2,  float (*cb)(float, struct S_PFD, struct S_PFD)) ;
+EXPORT float f14_F_FSS_PFP(float p0, struct S_PFP p1, struct S_PFP p2,  float (*cb)(float, struct S_PFP, struct S_PFP)) ;
+EXPORT float f14_F_FSS_PDI(float p0, struct S_PDI p1, struct S_PDI p2,  float (*cb)(float, struct S_PDI, struct S_PDI)) ;
+EXPORT float f14_F_FSS_PDF(float p0, struct S_PDF p1, struct S_PDF p2,  float (*cb)(float, struct S_PDF, struct S_PDF)) ;
+EXPORT float f14_F_FSS_PDD(float p0, struct S_PDD p1, struct S_PDD p2,  float (*cb)(float, struct S_PDD, struct S_PDD)) ;
+EXPORT float f14_F_FSS_PDP(float p0, struct S_PDP p1, struct S_PDP p2,  float (*cb)(float, struct S_PDP, struct S_PDP)) ;
+EXPORT float f14_F_FSS_PPI(float p0, struct S_PPI p1, struct S_PPI p2,  float (*cb)(float, struct S_PPI, struct S_PPI)) ;
+EXPORT float f14_F_FSS_PPF(float p0, struct S_PPF p1, struct S_PPF p2,  float (*cb)(float, struct S_PPF, struct S_PPF)) ;
+EXPORT float f14_F_FSS_PPD(float p0, struct S_PPD p1, struct S_PPD p2,  float (*cb)(float, struct S_PPD, struct S_PPD)) ;
+EXPORT float f14_F_FSS_PPP(float p0, struct S_PPP p1, struct S_PPP p2,  float (*cb)(float, struct S_PPP, struct S_PPP)) ;
+EXPORT double f14_D_DII_(double p0, int p1, int p2,  double (*cb)(double, int, int)) ;
+EXPORT double f14_D_DIF_(double p0, int p1, float p2,  double (*cb)(double, int, float)) ;
+EXPORT double f14_D_DID_(double p0, int p1, double p2,  double (*cb)(double, int, double)) ;
+EXPORT double f14_D_DIP_(double p0, int p1, void* p2,  double (*cb)(double, int, void*)) ;
+EXPORT double f14_D_DIS_I(double p0, int p1, struct S_I p2,  double (*cb)(double, int, struct S_I)) ;
+EXPORT double f14_D_DIS_F(double p0, int p1, struct S_F p2,  double (*cb)(double, int, struct S_F)) ;
+EXPORT double f14_D_DIS_D(double p0, int p1, struct S_D p2,  double (*cb)(double, int, struct S_D)) ;
+EXPORT double f14_D_DIS_P(double p0, int p1, struct S_P p2,  double (*cb)(double, int, struct S_P)) ;
+EXPORT double f14_D_DIS_II(double p0, int p1, struct S_II p2,  double (*cb)(double, int, struct S_II)) ;
+EXPORT double f14_D_DIS_IF(double p0, int p1, struct S_IF p2,  double (*cb)(double, int, struct S_IF)) ;
+EXPORT double f14_D_DIS_ID(double p0, int p1, struct S_ID p2,  double (*cb)(double, int, struct S_ID)) ;
+EXPORT double f14_D_DIS_IP(double p0, int p1, struct S_IP p2,  double (*cb)(double, int, struct S_IP)) ;
+EXPORT double f14_D_DIS_FI(double p0, int p1, struct S_FI p2,  double (*cb)(double, int, struct S_FI)) ;
+EXPORT double f14_D_DIS_FF(double p0, int p1, struct S_FF p2,  double (*cb)(double, int, struct S_FF)) ;
+EXPORT double f14_D_DIS_FD(double p0, int p1, struct S_FD p2,  double (*cb)(double, int, struct S_FD)) ;
+EXPORT double f14_D_DIS_FP(double p0, int p1, struct S_FP p2,  double (*cb)(double, int, struct S_FP)) ;
+EXPORT double f14_D_DIS_DI(double p0, int p1, struct S_DI p2,  double (*cb)(double, int, struct S_DI)) ;
+EXPORT double f14_D_DIS_DF(double p0, int p1, struct S_DF p2,  double (*cb)(double, int, struct S_DF)) ;
+EXPORT double f14_D_DIS_DD(double p0, int p1, struct S_DD p2,  double (*cb)(double, int, struct S_DD)) ;
+EXPORT double f14_D_DIS_DP(double p0, int p1, struct S_DP p2,  double (*cb)(double, int, struct S_DP)) ;
+EXPORT double f14_D_DIS_PI(double p0, int p1, struct S_PI p2,  double (*cb)(double, int, struct S_PI)) ;
+EXPORT double f14_D_DIS_PF(double p0, int p1, struct S_PF p2,  double (*cb)(double, int, struct S_PF)) ;
+EXPORT double f14_D_DIS_PD(double p0, int p1, struct S_PD p2,  double (*cb)(double, int, struct S_PD)) ;
+EXPORT double f14_D_DIS_PP(double p0, int p1, struct S_PP p2,  double (*cb)(double, int, struct S_PP)) ;
+EXPORT double f14_D_DIS_III(double p0, int p1, struct S_III p2,  double (*cb)(double, int, struct S_III)) ;
+EXPORT double f14_D_DIS_IIF(double p0, int p1, struct S_IIF p2,  double (*cb)(double, int, struct S_IIF)) ;
+EXPORT double f14_D_DIS_IID(double p0, int p1, struct S_IID p2,  double (*cb)(double, int, struct S_IID)) ;
+EXPORT double f14_D_DIS_IIP(double p0, int p1, struct S_IIP p2,  double (*cb)(double, int, struct S_IIP)) ;
+EXPORT double f14_D_DIS_IFI(double p0, int p1, struct S_IFI p2,  double (*cb)(double, int, struct S_IFI)) ;
+EXPORT double f14_D_DIS_IFF(double p0, int p1, struct S_IFF p2,  double (*cb)(double, int, struct S_IFF)) ;
+EXPORT double f14_D_DIS_IFD(double p0, int p1, struct S_IFD p2,  double (*cb)(double, int, struct S_IFD)) ;
+EXPORT double f14_D_DIS_IFP(double p0, int p1, struct S_IFP p2,  double (*cb)(double, int, struct S_IFP)) ;
+EXPORT double f14_D_DIS_IDI(double p0, int p1, struct S_IDI p2,  double (*cb)(double, int, struct S_IDI)) ;
+EXPORT double f14_D_DIS_IDF(double p0, int p1, struct S_IDF p2,  double (*cb)(double, int, struct S_IDF)) ;
+EXPORT double f14_D_DIS_IDD(double p0, int p1, struct S_IDD p2,  double (*cb)(double, int, struct S_IDD)) ;
+EXPORT double f14_D_DIS_IDP(double p0, int p1, struct S_IDP p2,  double (*cb)(double, int, struct S_IDP)) ;
+EXPORT double f14_D_DIS_IPI(double p0, int p1, struct S_IPI p2,  double (*cb)(double, int, struct S_IPI)) ;
+EXPORT double f14_D_DIS_IPF(double p0, int p1, struct S_IPF p2,  double (*cb)(double, int, struct S_IPF)) ;
+EXPORT double f14_D_DIS_IPD(double p0, int p1, struct S_IPD p2,  double (*cb)(double, int, struct S_IPD)) ;
+EXPORT double f14_D_DIS_IPP(double p0, int p1, struct S_IPP p2,  double (*cb)(double, int, struct S_IPP)) ;
+EXPORT double f14_D_DIS_FII(double p0, int p1, struct S_FII p2,  double (*cb)(double, int, struct S_FII)) ;
+EXPORT double f14_D_DIS_FIF(double p0, int p1, struct S_FIF p2,  double (*cb)(double, int, struct S_FIF)) ;
+EXPORT double f14_D_DIS_FID(double p0, int p1, struct S_FID p2,  double (*cb)(double, int, struct S_FID)) ;
+EXPORT double f14_D_DIS_FIP(double p0, int p1, struct S_FIP p2,  double (*cb)(double, int, struct S_FIP)) ;
+EXPORT double f14_D_DIS_FFI(double p0, int p1, struct S_FFI p2,  double (*cb)(double, int, struct S_FFI)) ;
+EXPORT double f14_D_DIS_FFF(double p0, int p1, struct S_FFF p2,  double (*cb)(double, int, struct S_FFF)) ;
+EXPORT double f14_D_DIS_FFD(double p0, int p1, struct S_FFD p2,  double (*cb)(double, int, struct S_FFD)) ;
+EXPORT double f14_D_DIS_FFP(double p0, int p1, struct S_FFP p2,  double (*cb)(double, int, struct S_FFP)) ;
+EXPORT double f14_D_DIS_FDI(double p0, int p1, struct S_FDI p2,  double (*cb)(double, int, struct S_FDI)) ;
+EXPORT double f14_D_DIS_FDF(double p0, int p1, struct S_FDF p2,  double (*cb)(double, int, struct S_FDF)) ;
+EXPORT double f14_D_DIS_FDD(double p0, int p1, struct S_FDD p2,  double (*cb)(double, int, struct S_FDD)) ;
+EXPORT double f14_D_DIS_FDP(double p0, int p1, struct S_FDP p2,  double (*cb)(double, int, struct S_FDP)) ;
+EXPORT double f14_D_DIS_FPI(double p0, int p1, struct S_FPI p2,  double (*cb)(double, int, struct S_FPI)) ;
+EXPORT double f14_D_DIS_FPF(double p0, int p1, struct S_FPF p2,  double (*cb)(double, int, struct S_FPF)) ;
+EXPORT double f14_D_DIS_FPD(double p0, int p1, struct S_FPD p2,  double (*cb)(double, int, struct S_FPD)) ;
+EXPORT double f14_D_DIS_FPP(double p0, int p1, struct S_FPP p2,  double (*cb)(double, int, struct S_FPP)) ;
+EXPORT double f14_D_DIS_DII(double p0, int p1, struct S_DII p2,  double (*cb)(double, int, struct S_DII)) ;
+EXPORT double f14_D_DIS_DIF(double p0, int p1, struct S_DIF p2,  double (*cb)(double, int, struct S_DIF)) ;
+EXPORT double f14_D_DIS_DID(double p0, int p1, struct S_DID p2,  double (*cb)(double, int, struct S_DID)) ;
+EXPORT double f14_D_DIS_DIP(double p0, int p1, struct S_DIP p2,  double (*cb)(double, int, struct S_DIP)) ;
+EXPORT double f14_D_DIS_DFI(double p0, int p1, struct S_DFI p2,  double (*cb)(double, int, struct S_DFI)) ;
+EXPORT double f14_D_DIS_DFF(double p0, int p1, struct S_DFF p2,  double (*cb)(double, int, struct S_DFF)) ;
+EXPORT double f14_D_DIS_DFD(double p0, int p1, struct S_DFD p2,  double (*cb)(double, int, struct S_DFD)) ;
+EXPORT double f14_D_DIS_DFP(double p0, int p1, struct S_DFP p2,  double (*cb)(double, int, struct S_DFP)) ;
+EXPORT double f14_D_DIS_DDI(double p0, int p1, struct S_DDI p2,  double (*cb)(double, int, struct S_DDI)) ;
+EXPORT double f14_D_DIS_DDF(double p0, int p1, struct S_DDF p2,  double (*cb)(double, int, struct S_DDF)) ;
+EXPORT double f14_D_DIS_DDD(double p0, int p1, struct S_DDD p2,  double (*cb)(double, int, struct S_DDD)) ;
+EXPORT double f14_D_DIS_DDP(double p0, int p1, struct S_DDP p2,  double (*cb)(double, int, struct S_DDP)) ;
+EXPORT double f14_D_DIS_DPI(double p0, int p1, struct S_DPI p2,  double (*cb)(double, int, struct S_DPI)) ;
+EXPORT double f14_D_DIS_DPF(double p0, int p1, struct S_DPF p2,  double (*cb)(double, int, struct S_DPF)) ;
+EXPORT double f14_D_DIS_DPD(double p0, int p1, struct S_DPD p2,  double (*cb)(double, int, struct S_DPD)) ;
+EXPORT double f14_D_DIS_DPP(double p0, int p1, struct S_DPP p2,  double (*cb)(double, int, struct S_DPP)) ;
+EXPORT double f14_D_DIS_PII(double p0, int p1, struct S_PII p2,  double (*cb)(double, int, struct S_PII)) ;
+EXPORT double f14_D_DIS_PIF(double p0, int p1, struct S_PIF p2,  double (*cb)(double, int, struct S_PIF)) ;
+EXPORT double f14_D_DIS_PID(double p0, int p1, struct S_PID p2,  double (*cb)(double, int, struct S_PID)) ;
+EXPORT double f14_D_DIS_PIP(double p0, int p1, struct S_PIP p2,  double (*cb)(double, int, struct S_PIP)) ;
+EXPORT double f14_D_DIS_PFI(double p0, int p1, struct S_PFI p2,  double (*cb)(double, int, struct S_PFI)) ;
+EXPORT double f14_D_DIS_PFF(double p0, int p1, struct S_PFF p2,  double (*cb)(double, int, struct S_PFF)) ;
+EXPORT double f14_D_DIS_PFD(double p0, int p1, struct S_PFD p2,  double (*cb)(double, int, struct S_PFD)) ;
+EXPORT double f14_D_DIS_PFP(double p0, int p1, struct S_PFP p2,  double (*cb)(double, int, struct S_PFP)) ;
+EXPORT double f14_D_DIS_PDI(double p0, int p1, struct S_PDI p2,  double (*cb)(double, int, struct S_PDI)) ;
+EXPORT double f14_D_DIS_PDF(double p0, int p1, struct S_PDF p2,  double (*cb)(double, int, struct S_PDF)) ;
+EXPORT double f14_D_DIS_PDD(double p0, int p1, struct S_PDD p2,  double (*cb)(double, int, struct S_PDD)) ;
+EXPORT double f14_D_DIS_PDP(double p0, int p1, struct S_PDP p2,  double (*cb)(double, int, struct S_PDP)) ;
+EXPORT double f14_D_DIS_PPI(double p0, int p1, struct S_PPI p2,  double (*cb)(double, int, struct S_PPI)) ;
+EXPORT double f14_D_DIS_PPF(double p0, int p1, struct S_PPF p2,  double (*cb)(double, int, struct S_PPF)) ;
+EXPORT double f14_D_DIS_PPD(double p0, int p1, struct S_PPD p2,  double (*cb)(double, int, struct S_PPD)) ;
+EXPORT double f14_D_DIS_PPP(double p0, int p1, struct S_PPP p2,  double (*cb)(double, int, struct S_PPP)) ;
+EXPORT double f14_D_DFI_(double p0, float p1, int p2,  double (*cb)(double, float, int)) ;
+EXPORT double f14_D_DFF_(double p0, float p1, float p2,  double (*cb)(double, float, float)) ;
+EXPORT double f14_D_DFD_(double p0, float p1, double p2,  double (*cb)(double, float, double)) ;
+EXPORT double f14_D_DFP_(double p0, float p1, void* p2,  double (*cb)(double, float, void*)) ;
+EXPORT double f14_D_DFS_I(double p0, float p1, struct S_I p2,  double (*cb)(double, float, struct S_I)) ;
+EXPORT double f14_D_DFS_F(double p0, float p1, struct S_F p2,  double (*cb)(double, float, struct S_F)) ;
+EXPORT double f14_D_DFS_D(double p0, float p1, struct S_D p2,  double (*cb)(double, float, struct S_D)) ;
+EXPORT double f14_D_DFS_P(double p0, float p1, struct S_P p2,  double (*cb)(double, float, struct S_P)) ;
+EXPORT double f14_D_DFS_II(double p0, float p1, struct S_II p2,  double (*cb)(double, float, struct S_II)) ;
+EXPORT double f14_D_DFS_IF(double p0, float p1, struct S_IF p2,  double (*cb)(double, float, struct S_IF)) ;
+EXPORT double f14_D_DFS_ID(double p0, float p1, struct S_ID p2,  double (*cb)(double, float, struct S_ID)) ;
+EXPORT double f14_D_DFS_IP(double p0, float p1, struct S_IP p2,  double (*cb)(double, float, struct S_IP)) ;
+EXPORT double f14_D_DFS_FI(double p0, float p1, struct S_FI p2,  double (*cb)(double, float, struct S_FI)) ;
+EXPORT double f14_D_DFS_FF(double p0, float p1, struct S_FF p2,  double (*cb)(double, float, struct S_FF)) ;
+EXPORT double f14_D_DFS_FD(double p0, float p1, struct S_FD p2,  double (*cb)(double, float, struct S_FD)) ;
+EXPORT double f14_D_DFS_FP(double p0, float p1, struct S_FP p2,  double (*cb)(double, float, struct S_FP)) ;
+EXPORT double f14_D_DFS_DI(double p0, float p1, struct S_DI p2,  double (*cb)(double, float, struct S_DI)) ;
+EXPORT double f14_D_DFS_DF(double p0, float p1, struct S_DF p2,  double (*cb)(double, float, struct S_DF)) ;
+EXPORT double f14_D_DFS_DD(double p0, float p1, struct S_DD p2,  double (*cb)(double, float, struct S_DD)) ;
+EXPORT double f14_D_DFS_DP(double p0, float p1, struct S_DP p2,  double (*cb)(double, float, struct S_DP)) ;
+EXPORT double f14_D_DFS_PI(double p0, float p1, struct S_PI p2,  double (*cb)(double, float, struct S_PI)) ;
+EXPORT double f14_D_DFS_PF(double p0, float p1, struct S_PF p2,  double (*cb)(double, float, struct S_PF)) ;
+EXPORT double f14_D_DFS_PD(double p0, float p1, struct S_PD p2,  double (*cb)(double, float, struct S_PD)) ;
+EXPORT double f14_D_DFS_PP(double p0, float p1, struct S_PP p2,  double (*cb)(double, float, struct S_PP)) ;
+EXPORT double f14_D_DFS_III(double p0, float p1, struct S_III p2,  double (*cb)(double, float, struct S_III)) ;
+EXPORT double f14_D_DFS_IIF(double p0, float p1, struct S_IIF p2,  double (*cb)(double, float, struct S_IIF)) ;
+EXPORT double f14_D_DFS_IID(double p0, float p1, struct S_IID p2,  double (*cb)(double, float, struct S_IID)) ;
+EXPORT double f14_D_DFS_IIP(double p0, float p1, struct S_IIP p2,  double (*cb)(double, float, struct S_IIP)) ;
+EXPORT double f14_D_DFS_IFI(double p0, float p1, struct S_IFI p2,  double (*cb)(double, float, struct S_IFI)) ;
+EXPORT double f14_D_DFS_IFF(double p0, float p1, struct S_IFF p2,  double (*cb)(double, float, struct S_IFF)) ;
+EXPORT double f14_D_DFS_IFD(double p0, float p1, struct S_IFD p2,  double (*cb)(double, float, struct S_IFD)) ;
+EXPORT double f14_D_DFS_IFP(double p0, float p1, struct S_IFP p2,  double (*cb)(double, float, struct S_IFP)) ;
+EXPORT double f14_D_DFS_IDI(double p0, float p1, struct S_IDI p2,  double (*cb)(double, float, struct S_IDI)) ;
+EXPORT double f14_D_DFS_IDF(double p0, float p1, struct S_IDF p2,  double (*cb)(double, float, struct S_IDF)) ;
+EXPORT double f14_D_DFS_IDD(double p0, float p1, struct S_IDD p2,  double (*cb)(double, float, struct S_IDD)) ;
+EXPORT double f14_D_DFS_IDP(double p0, float p1, struct S_IDP p2,  double (*cb)(double, float, struct S_IDP)) ;
+EXPORT double f14_D_DFS_IPI(double p0, float p1, struct S_IPI p2,  double (*cb)(double, float, struct S_IPI)) ;
+EXPORT double f14_D_DFS_IPF(double p0, float p1, struct S_IPF p2,  double (*cb)(double, float, struct S_IPF)) ;
+EXPORT double f14_D_DFS_IPD(double p0, float p1, struct S_IPD p2,  double (*cb)(double, float, struct S_IPD)) ;
+EXPORT double f14_D_DFS_IPP(double p0, float p1, struct S_IPP p2,  double (*cb)(double, float, struct S_IPP)) ;
+EXPORT double f14_D_DFS_FII(double p0, float p1, struct S_FII p2,  double (*cb)(double, float, struct S_FII)) ;
+EXPORT double f14_D_DFS_FIF(double p0, float p1, struct S_FIF p2,  double (*cb)(double, float, struct S_FIF)) ;
+EXPORT double f14_D_DFS_FID(double p0, float p1, struct S_FID p2,  double (*cb)(double, float, struct S_FID)) ;
+EXPORT double f14_D_DFS_FIP(double p0, float p1, struct S_FIP p2,  double (*cb)(double, float, struct S_FIP)) ;
+EXPORT double f14_D_DFS_FFI(double p0, float p1, struct S_FFI p2,  double (*cb)(double, float, struct S_FFI)) ;
+EXPORT double f14_D_DFS_FFF(double p0, float p1, struct S_FFF p2,  double (*cb)(double, float, struct S_FFF)) ;
+EXPORT double f14_D_DFS_FFD(double p0, float p1, struct S_FFD p2,  double (*cb)(double, float, struct S_FFD)) ;
+EXPORT double f14_D_DFS_FFP(double p0, float p1, struct S_FFP p2,  double (*cb)(double, float, struct S_FFP)) ;
+EXPORT double f14_D_DFS_FDI(double p0, float p1, struct S_FDI p2,  double (*cb)(double, float, struct S_FDI)) ;
+EXPORT double f14_D_DFS_FDF(double p0, float p1, struct S_FDF p2,  double (*cb)(double, float, struct S_FDF)) ;
+EXPORT double f14_D_DFS_FDD(double p0, float p1, struct S_FDD p2,  double (*cb)(double, float, struct S_FDD)) ;
+EXPORT double f14_D_DFS_FDP(double p0, float p1, struct S_FDP p2,  double (*cb)(double, float, struct S_FDP)) ;
+EXPORT double f14_D_DFS_FPI(double p0, float p1, struct S_FPI p2,  double (*cb)(double, float, struct S_FPI)) ;
+EXPORT double f14_D_DFS_FPF(double p0, float p1, struct S_FPF p2,  double (*cb)(double, float, struct S_FPF)) ;
+EXPORT double f14_D_DFS_FPD(double p0, float p1, struct S_FPD p2,  double (*cb)(double, float, struct S_FPD)) ;
+EXPORT double f14_D_DFS_FPP(double p0, float p1, struct S_FPP p2,  double (*cb)(double, float, struct S_FPP)) ;
+EXPORT double f14_D_DFS_DII(double p0, float p1, struct S_DII p2,  double (*cb)(double, float, struct S_DII)) ;
+EXPORT double f14_D_DFS_DIF(double p0, float p1, struct S_DIF p2,  double (*cb)(double, float, struct S_DIF)) ;
+EXPORT double f14_D_DFS_DID(double p0, float p1, struct S_DID p2,  double (*cb)(double, float, struct S_DID)) ;
+EXPORT double f14_D_DFS_DIP(double p0, float p1, struct S_DIP p2,  double (*cb)(double, float, struct S_DIP)) ;
+EXPORT double f14_D_DFS_DFI(double p0, float p1, struct S_DFI p2,  double (*cb)(double, float, struct S_DFI)) ;
+EXPORT double f14_D_DFS_DFF(double p0, float p1, struct S_DFF p2,  double (*cb)(double, float, struct S_DFF)) ;
+EXPORT double f14_D_DFS_DFD(double p0, float p1, struct S_DFD p2,  double (*cb)(double, float, struct S_DFD)) ;
+EXPORT double f14_D_DFS_DFP(double p0, float p1, struct S_DFP p2,  double (*cb)(double, float, struct S_DFP)) ;
+EXPORT double f14_D_DFS_DDI(double p0, float p1, struct S_DDI p2,  double (*cb)(double, float, struct S_DDI)) ;
+EXPORT double f14_D_DFS_DDF(double p0, float p1, struct S_DDF p2,  double (*cb)(double, float, struct S_DDF)) ;
+EXPORT double f14_D_DFS_DDD(double p0, float p1, struct S_DDD p2,  double (*cb)(double, float, struct S_DDD)) ;
+EXPORT double f14_D_DFS_DDP(double p0, float p1, struct S_DDP p2,  double (*cb)(double, float, struct S_DDP)) ;
+EXPORT double f14_D_DFS_DPI(double p0, float p1, struct S_DPI p2,  double (*cb)(double, float, struct S_DPI)) ;
+EXPORT double f14_D_DFS_DPF(double p0, float p1, struct S_DPF p2,  double (*cb)(double, float, struct S_DPF)) ;
+EXPORT double f14_D_DFS_DPD(double p0, float p1, struct S_DPD p2,  double (*cb)(double, float, struct S_DPD)) ;
+EXPORT double f14_D_DFS_DPP(double p0, float p1, struct S_DPP p2,  double (*cb)(double, float, struct S_DPP)) ;
+EXPORT double f14_D_DFS_PII(double p0, float p1, struct S_PII p2,  double (*cb)(double, float, struct S_PII)) ;
+EXPORT double f14_D_DFS_PIF(double p0, float p1, struct S_PIF p2,  double (*cb)(double, float, struct S_PIF)) ;
+EXPORT double f14_D_DFS_PID(double p0, float p1, struct S_PID p2,  double (*cb)(double, float, struct S_PID)) ;
+EXPORT double f14_D_DFS_PIP(double p0, float p1, struct S_PIP p2,  double (*cb)(double, float, struct S_PIP)) ;
+EXPORT double f14_D_DFS_PFI(double p0, float p1, struct S_PFI p2,  double (*cb)(double, float, struct S_PFI)) ;
+EXPORT double f14_D_DFS_PFF(double p0, float p1, struct S_PFF p2,  double (*cb)(double, float, struct S_PFF)) ;
+EXPORT double f14_D_DFS_PFD(double p0, float p1, struct S_PFD p2,  double (*cb)(double, float, struct S_PFD)) ;
+EXPORT double f14_D_DFS_PFP(double p0, float p1, struct S_PFP p2,  double (*cb)(double, float, struct S_PFP)) ;
+EXPORT double f14_D_DFS_PDI(double p0, float p1, struct S_PDI p2,  double (*cb)(double, float, struct S_PDI)) ;
+EXPORT double f14_D_DFS_PDF(double p0, float p1, struct S_PDF p2,  double (*cb)(double, float, struct S_PDF)) ;
+EXPORT double f14_D_DFS_PDD(double p0, float p1, struct S_PDD p2,  double (*cb)(double, float, struct S_PDD)) ;
+EXPORT double f14_D_DFS_PDP(double p0, float p1, struct S_PDP p2,  double (*cb)(double, float, struct S_PDP)) ;
+EXPORT double f14_D_DFS_PPI(double p0, float p1, struct S_PPI p2,  double (*cb)(double, float, struct S_PPI)) ;
+EXPORT double f14_D_DFS_PPF(double p0, float p1, struct S_PPF p2,  double (*cb)(double, float, struct S_PPF)) ;
+EXPORT double f14_D_DFS_PPD(double p0, float p1, struct S_PPD p2,  double (*cb)(double, float, struct S_PPD)) ;
+EXPORT double f14_D_DFS_PPP(double p0, float p1, struct S_PPP p2,  double (*cb)(double, float, struct S_PPP)) ;
+EXPORT double f14_D_DDI_(double p0, double p1, int p2,  double (*cb)(double, double, int)) ;
+EXPORT double f14_D_DDF_(double p0, double p1, float p2,  double (*cb)(double, double, float)) ;
+EXPORT double f14_D_DDD_(double p0, double p1, double p2,  double (*cb)(double, double, double)) ;
+EXPORT double f14_D_DDP_(double p0, double p1, void* p2,  double (*cb)(double, double, void*)) ;
+EXPORT double f14_D_DDS_I(double p0, double p1, struct S_I p2,  double (*cb)(double, double, struct S_I)) ;
+EXPORT double f14_D_DDS_F(double p0, double p1, struct S_F p2,  double (*cb)(double, double, struct S_F)) ;
+EXPORT double f14_D_DDS_D(double p0, double p1, struct S_D p2,  double (*cb)(double, double, struct S_D)) ;
+EXPORT double f14_D_DDS_P(double p0, double p1, struct S_P p2,  double (*cb)(double, double, struct S_P)) ;
+EXPORT double f14_D_DDS_II(double p0, double p1, struct S_II p2,  double (*cb)(double, double, struct S_II)) ;
+EXPORT double f14_D_DDS_IF(double p0, double p1, struct S_IF p2,  double (*cb)(double, double, struct S_IF)) ;
+EXPORT double f14_D_DDS_ID(double p0, double p1, struct S_ID p2,  double (*cb)(double, double, struct S_ID)) ;
+EXPORT double f14_D_DDS_IP(double p0, double p1, struct S_IP p2,  double (*cb)(double, double, struct S_IP)) ;
+EXPORT double f14_D_DDS_FI(double p0, double p1, struct S_FI p2,  double (*cb)(double, double, struct S_FI)) ;
+EXPORT double f14_D_DDS_FF(double p0, double p1, struct S_FF p2,  double (*cb)(double, double, struct S_FF)) ;
+EXPORT double f14_D_DDS_FD(double p0, double p1, struct S_FD p2,  double (*cb)(double, double, struct S_FD)) ;
+EXPORT double f14_D_DDS_FP(double p0, double p1, struct S_FP p2,  double (*cb)(double, double, struct S_FP)) ;
+EXPORT double f14_D_DDS_DI(double p0, double p1, struct S_DI p2,  double (*cb)(double, double, struct S_DI)) ;
+EXPORT double f14_D_DDS_DF(double p0, double p1, struct S_DF p2,  double (*cb)(double, double, struct S_DF)) ;
+EXPORT double f14_D_DDS_DD(double p0, double p1, struct S_DD p2,  double (*cb)(double, double, struct S_DD)) ;
+EXPORT double f14_D_DDS_DP(double p0, double p1, struct S_DP p2,  double (*cb)(double, double, struct S_DP)) ;
+EXPORT double f14_D_DDS_PI(double p0, double p1, struct S_PI p2,  double (*cb)(double, double, struct S_PI)) ;
+EXPORT double f14_D_DDS_PF(double p0, double p1, struct S_PF p2,  double (*cb)(double, double, struct S_PF)) ;
+EXPORT double f14_D_DDS_PD(double p0, double p1, struct S_PD p2,  double (*cb)(double, double, struct S_PD)) ;
+EXPORT double f14_D_DDS_PP(double p0, double p1, struct S_PP p2,  double (*cb)(double, double, struct S_PP)) ;
+EXPORT double f14_D_DDS_III(double p0, double p1, struct S_III p2,  double (*cb)(double, double, struct S_III)) ;
+EXPORT double f14_D_DDS_IIF(double p0, double p1, struct S_IIF p2,  double (*cb)(double, double, struct S_IIF)) ;
+EXPORT double f14_D_DDS_IID(double p0, double p1, struct S_IID p2,  double (*cb)(double, double, struct S_IID)) ;
+EXPORT double f14_D_DDS_IIP(double p0, double p1, struct S_IIP p2,  double (*cb)(double, double, struct S_IIP)) ;
+EXPORT double f14_D_DDS_IFI(double p0, double p1, struct S_IFI p2,  double (*cb)(double, double, struct S_IFI)) ;
+EXPORT double f14_D_DDS_IFF(double p0, double p1, struct S_IFF p2,  double (*cb)(double, double, struct S_IFF)) ;
+EXPORT double f14_D_DDS_IFD(double p0, double p1, struct S_IFD p2,  double (*cb)(double, double, struct S_IFD)) ;
+EXPORT double f14_D_DDS_IFP(double p0, double p1, struct S_IFP p2,  double (*cb)(double, double, struct S_IFP)) ;
+EXPORT double f14_D_DDS_IDI(double p0, double p1, struct S_IDI p2,  double (*cb)(double, double, struct S_IDI)) ;
+EXPORT double f14_D_DDS_IDF(double p0, double p1, struct S_IDF p2,  double (*cb)(double, double, struct S_IDF)) ;
+EXPORT double f14_D_DDS_IDD(double p0, double p1, struct S_IDD p2,  double (*cb)(double, double, struct S_IDD)) ;
+EXPORT double f14_D_DDS_IDP(double p0, double p1, struct S_IDP p2,  double (*cb)(double, double, struct S_IDP)) ;
+EXPORT double f14_D_DDS_IPI(double p0, double p1, struct S_IPI p2,  double (*cb)(double, double, struct S_IPI)) ;
+EXPORT double f14_D_DDS_IPF(double p0, double p1, struct S_IPF p2,  double (*cb)(double, double, struct S_IPF)) ;
+EXPORT double f14_D_DDS_IPD(double p0, double p1, struct S_IPD p2,  double (*cb)(double, double, struct S_IPD)) ;
+EXPORT double f14_D_DDS_IPP(double p0, double p1, struct S_IPP p2,  double (*cb)(double, double, struct S_IPP)) ;
+EXPORT double f14_D_DDS_FII(double p0, double p1, struct S_FII p2,  double (*cb)(double, double, struct S_FII)) ;
+EXPORT double f14_D_DDS_FIF(double p0, double p1, struct S_FIF p2,  double (*cb)(double, double, struct S_FIF)) ;
+EXPORT double f14_D_DDS_FID(double p0, double p1, struct S_FID p2,  double (*cb)(double, double, struct S_FID)) ;
+EXPORT double f14_D_DDS_FIP(double p0, double p1, struct S_FIP p2,  double (*cb)(double, double, struct S_FIP)) ;
+EXPORT double f14_D_DDS_FFI(double p0, double p1, struct S_FFI p2,  double (*cb)(double, double, struct S_FFI)) ;
+EXPORT double f14_D_DDS_FFF(double p0, double p1, struct S_FFF p2,  double (*cb)(double, double, struct S_FFF)) ;
+EXPORT double f14_D_DDS_FFD(double p0, double p1, struct S_FFD p2,  double (*cb)(double, double, struct S_FFD)) ;
+EXPORT double f14_D_DDS_FFP(double p0, double p1, struct S_FFP p2,  double (*cb)(double, double, struct S_FFP)) ;
+EXPORT double f14_D_DDS_FDI(double p0, double p1, struct S_FDI p2,  double (*cb)(double, double, struct S_FDI)) ;
+EXPORT double f14_D_DDS_FDF(double p0, double p1, struct S_FDF p2,  double (*cb)(double, double, struct S_FDF)) ;
+EXPORT double f14_D_DDS_FDD(double p0, double p1, struct S_FDD p2,  double (*cb)(double, double, struct S_FDD)) ;
+EXPORT double f14_D_DDS_FDP(double p0, double p1, struct S_FDP p2,  double (*cb)(double, double, struct S_FDP)) ;
+EXPORT double f14_D_DDS_FPI(double p0, double p1, struct S_FPI p2,  double (*cb)(double, double, struct S_FPI)) ;
+EXPORT double f14_D_DDS_FPF(double p0, double p1, struct S_FPF p2,  double (*cb)(double, double, struct S_FPF)) ;
+EXPORT double f14_D_DDS_FPD(double p0, double p1, struct S_FPD p2,  double (*cb)(double, double, struct S_FPD)) ;
+EXPORT double f14_D_DDS_FPP(double p0, double p1, struct S_FPP p2,  double (*cb)(double, double, struct S_FPP)) ;
+EXPORT double f14_D_DDS_DII(double p0, double p1, struct S_DII p2,  double (*cb)(double, double, struct S_DII)) ;
+EXPORT double f14_D_DDS_DIF(double p0, double p1, struct S_DIF p2,  double (*cb)(double, double, struct S_DIF)) ;
+EXPORT double f14_D_DDS_DID(double p0, double p1, struct S_DID p2,  double (*cb)(double, double, struct S_DID)) ;
+EXPORT double f14_D_DDS_DIP(double p0, double p1, struct S_DIP p2,  double (*cb)(double, double, struct S_DIP)) ;
+EXPORT double f14_D_DDS_DFI(double p0, double p1, struct S_DFI p2,  double (*cb)(double, double, struct S_DFI)) ;
+EXPORT double f14_D_DDS_DFF(double p0, double p1, struct S_DFF p2,  double (*cb)(double, double, struct S_DFF)) ;
+EXPORT double f14_D_DDS_DFD(double p0, double p1, struct S_DFD p2,  double (*cb)(double, double, struct S_DFD)) ;
+EXPORT double f14_D_DDS_DFP(double p0, double p1, struct S_DFP p2,  double (*cb)(double, double, struct S_DFP)) ;
+EXPORT double f14_D_DDS_DDI(double p0, double p1, struct S_DDI p2,  double (*cb)(double, double, struct S_DDI)) ;
+EXPORT double f14_D_DDS_DDF(double p0, double p1, struct S_DDF p2,  double (*cb)(double, double, struct S_DDF)) ;
+EXPORT double f14_D_DDS_DDD(double p0, double p1, struct S_DDD p2,  double (*cb)(double, double, struct S_DDD)) ;
+EXPORT double f14_D_DDS_DDP(double p0, double p1, struct S_DDP p2,  double (*cb)(double, double, struct S_DDP)) ;
+EXPORT double f14_D_DDS_DPI(double p0, double p1, struct S_DPI p2,  double (*cb)(double, double, struct S_DPI)) ;
+EXPORT double f14_D_DDS_DPF(double p0, double p1, struct S_DPF p2,  double (*cb)(double, double, struct S_DPF)) ;
+EXPORT double f14_D_DDS_DPD(double p0, double p1, struct S_DPD p2,  double (*cb)(double, double, struct S_DPD)) ;
+EXPORT double f14_D_DDS_DPP(double p0, double p1, struct S_DPP p2,  double (*cb)(double, double, struct S_DPP)) ;
+EXPORT double f14_D_DDS_PII(double p0, double p1, struct S_PII p2,  double (*cb)(double, double, struct S_PII)) ;
+EXPORT double f14_D_DDS_PIF(double p0, double p1, struct S_PIF p2,  double (*cb)(double, double, struct S_PIF)) ;
+EXPORT double f14_D_DDS_PID(double p0, double p1, struct S_PID p2,  double (*cb)(double, double, struct S_PID)) ;
+EXPORT double f14_D_DDS_PIP(double p0, double p1, struct S_PIP p2,  double (*cb)(double, double, struct S_PIP)) ;
+EXPORT double f14_D_DDS_PFI(double p0, double p1, struct S_PFI p2,  double (*cb)(double, double, struct S_PFI)) ;
+EXPORT double f14_D_DDS_PFF(double p0, double p1, struct S_PFF p2,  double (*cb)(double, double, struct S_PFF)) ;
+EXPORT double f14_D_DDS_PFD(double p0, double p1, struct S_PFD p2,  double (*cb)(double, double, struct S_PFD)) ;
+EXPORT double f14_D_DDS_PFP(double p0, double p1, struct S_PFP p2,  double (*cb)(double, double, struct S_PFP)) ;
+EXPORT double f14_D_DDS_PDI(double p0, double p1, struct S_PDI p2,  double (*cb)(double, double, struct S_PDI)) ;
+EXPORT double f14_D_DDS_PDF(double p0, double p1, struct S_PDF p2,  double (*cb)(double, double, struct S_PDF)) ;
+EXPORT double f14_D_DDS_PDD(double p0, double p1, struct S_PDD p2,  double (*cb)(double, double, struct S_PDD)) ;
+EXPORT double f14_D_DDS_PDP(double p0, double p1, struct S_PDP p2,  double (*cb)(double, double, struct S_PDP)) ;
+EXPORT double f14_D_DDS_PPI(double p0, double p1, struct S_PPI p2,  double (*cb)(double, double, struct S_PPI)) ;
+EXPORT double f14_D_DDS_PPF(double p0, double p1, struct S_PPF p2,  double (*cb)(double, double, struct S_PPF)) ;
+EXPORT double f14_D_DDS_PPD(double p0, double p1, struct S_PPD p2,  double (*cb)(double, double, struct S_PPD)) ;
+EXPORT double f14_D_DDS_PPP(double p0, double p1, struct S_PPP p2,  double (*cb)(double, double, struct S_PPP)) ;
+EXPORT double f14_D_DPI_(double p0, void* p1, int p2,  double (*cb)(double, void*, int)) ;
+EXPORT double f14_D_DPF_(double p0, void* p1, float p2,  double (*cb)(double, void*, float)) ;
+EXPORT double f14_D_DPD_(double p0, void* p1, double p2,  double (*cb)(double, void*, double)) ;
+EXPORT double f14_D_DPP_(double p0, void* p1, void* p2,  double (*cb)(double, void*, void*)) ;
+EXPORT double f14_D_DPS_I(double p0, void* p1, struct S_I p2,  double (*cb)(double, void*, struct S_I)) ;
+EXPORT double f14_D_DPS_F(double p0, void* p1, struct S_F p2,  double (*cb)(double, void*, struct S_F)) ;
+EXPORT double f14_D_DPS_D(double p0, void* p1, struct S_D p2,  double (*cb)(double, void*, struct S_D)) ;
+EXPORT double f14_D_DPS_P(double p0, void* p1, struct S_P p2,  double (*cb)(double, void*, struct S_P)) ;
+EXPORT double f14_D_DPS_II(double p0, void* p1, struct S_II p2,  double (*cb)(double, void*, struct S_II)) ;
+EXPORT double f14_D_DPS_IF(double p0, void* p1, struct S_IF p2,  double (*cb)(double, void*, struct S_IF)) ;
+EXPORT double f14_D_DPS_ID(double p0, void* p1, struct S_ID p2,  double (*cb)(double, void*, struct S_ID)) ;
+EXPORT double f14_D_DPS_IP(double p0, void* p1, struct S_IP p2,  double (*cb)(double, void*, struct S_IP)) ;
+EXPORT double f14_D_DPS_FI(double p0, void* p1, struct S_FI p2,  double (*cb)(double, void*, struct S_FI)) ;
+EXPORT double f14_D_DPS_FF(double p0, void* p1, struct S_FF p2,  double (*cb)(double, void*, struct S_FF)) ;
+EXPORT double f14_D_DPS_FD(double p0, void* p1, struct S_FD p2,  double (*cb)(double, void*, struct S_FD)) ;
+EXPORT double f14_D_DPS_FP(double p0, void* p1, struct S_FP p2,  double (*cb)(double, void*, struct S_FP)) ;
+EXPORT double f14_D_DPS_DI(double p0, void* p1, struct S_DI p2,  double (*cb)(double, void*, struct S_DI)) ;
+EXPORT double f14_D_DPS_DF(double p0, void* p1, struct S_DF p2,  double (*cb)(double, void*, struct S_DF)) ;
+EXPORT double f14_D_DPS_DD(double p0, void* p1, struct S_DD p2,  double (*cb)(double, void*, struct S_DD)) ;
+EXPORT double f14_D_DPS_DP(double p0, void* p1, struct S_DP p2,  double (*cb)(double, void*, struct S_DP)) ;
+EXPORT double f14_D_DPS_PI(double p0, void* p1, struct S_PI p2,  double (*cb)(double, void*, struct S_PI)) ;
+EXPORT double f14_D_DPS_PF(double p0, void* p1, struct S_PF p2,  double (*cb)(double, void*, struct S_PF)) ;
+EXPORT double f14_D_DPS_PD(double p0, void* p1, struct S_PD p2,  double (*cb)(double, void*, struct S_PD)) ;
+EXPORT double f14_D_DPS_PP(double p0, void* p1, struct S_PP p2,  double (*cb)(double, void*, struct S_PP)) ;
+EXPORT double f14_D_DPS_III(double p0, void* p1, struct S_III p2,  double (*cb)(double, void*, struct S_III)) ;
+EXPORT double f14_D_DPS_IIF(double p0, void* p1, struct S_IIF p2,  double (*cb)(double, void*, struct S_IIF)) ;
+EXPORT double f14_D_DPS_IID(double p0, void* p1, struct S_IID p2,  double (*cb)(double, void*, struct S_IID)) ;
+EXPORT double f14_D_DPS_IIP(double p0, void* p1, struct S_IIP p2,  double (*cb)(double, void*, struct S_IIP)) ;
+EXPORT double f14_D_DPS_IFI(double p0, void* p1, struct S_IFI p2,  double (*cb)(double, void*, struct S_IFI)) ;
+EXPORT double f14_D_DPS_IFF(double p0, void* p1, struct S_IFF p2,  double (*cb)(double, void*, struct S_IFF)) ;
+EXPORT double f14_D_DPS_IFD(double p0, void* p1, struct S_IFD p2,  double (*cb)(double, void*, struct S_IFD)) ;
+EXPORT double f14_D_DPS_IFP(double p0, void* p1, struct S_IFP p2,  double (*cb)(double, void*, struct S_IFP)) ;
+EXPORT double f14_D_DPS_IDI(double p0, void* p1, struct S_IDI p2,  double (*cb)(double, void*, struct S_IDI)) ;
+EXPORT double f14_D_DPS_IDF(double p0, void* p1, struct S_IDF p2,  double (*cb)(double, void*, struct S_IDF)) ;
+EXPORT double f14_D_DPS_IDD(double p0, void* p1, struct S_IDD p2,  double (*cb)(double, void*, struct S_IDD)) ;
+EXPORT double f14_D_DPS_IDP(double p0, void* p1, struct S_IDP p2,  double (*cb)(double, void*, struct S_IDP)) ;
+EXPORT double f14_D_DPS_IPI(double p0, void* p1, struct S_IPI p2,  double (*cb)(double, void*, struct S_IPI)) ;
+EXPORT double f14_D_DPS_IPF(double p0, void* p1, struct S_IPF p2,  double (*cb)(double, void*, struct S_IPF)) ;
+EXPORT double f14_D_DPS_IPD(double p0, void* p1, struct S_IPD p2,  double (*cb)(double, void*, struct S_IPD)) ;
+EXPORT double f14_D_DPS_IPP(double p0, void* p1, struct S_IPP p2,  double (*cb)(double, void*, struct S_IPP)) ;
+EXPORT double f14_D_DPS_FII(double p0, void* p1, struct S_FII p2,  double (*cb)(double, void*, struct S_FII)) ;
+EXPORT double f14_D_DPS_FIF(double p0, void* p1, struct S_FIF p2,  double (*cb)(double, void*, struct S_FIF)) ;
+EXPORT double f14_D_DPS_FID(double p0, void* p1, struct S_FID p2,  double (*cb)(double, void*, struct S_FID)) ;
+EXPORT double f14_D_DPS_FIP(double p0, void* p1, struct S_FIP p2,  double (*cb)(double, void*, struct S_FIP)) ;
+EXPORT double f14_D_DPS_FFI(double p0, void* p1, struct S_FFI p2,  double (*cb)(double, void*, struct S_FFI)) ;
+EXPORT double f14_D_DPS_FFF(double p0, void* p1, struct S_FFF p2,  double (*cb)(double, void*, struct S_FFF)) ;
+EXPORT double f14_D_DPS_FFD(double p0, void* p1, struct S_FFD p2,  double (*cb)(double, void*, struct S_FFD)) ;
+EXPORT double f14_D_DPS_FFP(double p0, void* p1, struct S_FFP p2,  double (*cb)(double, void*, struct S_FFP)) ;
+EXPORT double f14_D_DPS_FDI(double p0, void* p1, struct S_FDI p2,  double (*cb)(double, void*, struct S_FDI)) ;
+EXPORT double f14_D_DPS_FDF(double p0, void* p1, struct S_FDF p2,  double (*cb)(double, void*, struct S_FDF)) ;
+EXPORT double f14_D_DPS_FDD(double p0, void* p1, struct S_FDD p2,  double (*cb)(double, void*, struct S_FDD)) ;
+EXPORT double f14_D_DPS_FDP(double p0, void* p1, struct S_FDP p2,  double (*cb)(double, void*, struct S_FDP)) ;
+EXPORT double f14_D_DPS_FPI(double p0, void* p1, struct S_FPI p2,  double (*cb)(double, void*, struct S_FPI)) ;
+EXPORT double f14_D_DPS_FPF(double p0, void* p1, struct S_FPF p2,  double (*cb)(double, void*, struct S_FPF)) ;
+EXPORT double f14_D_DPS_FPD(double p0, void* p1, struct S_FPD p2,  double (*cb)(double, void*, struct S_FPD)) ;
+EXPORT double f14_D_DPS_FPP(double p0, void* p1, struct S_FPP p2,  double (*cb)(double, void*, struct S_FPP)) ;
+EXPORT double f14_D_DPS_DII(double p0, void* p1, struct S_DII p2,  double (*cb)(double, void*, struct S_DII)) ;
+EXPORT double f14_D_DPS_DIF(double p0, void* p1, struct S_DIF p2,  double (*cb)(double, void*, struct S_DIF)) ;
+EXPORT double f14_D_DPS_DID(double p0, void* p1, struct S_DID p2,  double (*cb)(double, void*, struct S_DID)) ;
+EXPORT double f14_D_DPS_DIP(double p0, void* p1, struct S_DIP p2,  double (*cb)(double, void*, struct S_DIP)) ;
+EXPORT double f14_D_DPS_DFI(double p0, void* p1, struct S_DFI p2,  double (*cb)(double, void*, struct S_DFI)) ;
+EXPORT double f14_D_DPS_DFF(double p0, void* p1, struct S_DFF p2,  double (*cb)(double, void*, struct S_DFF)) ;
+EXPORT double f14_D_DPS_DFD(double p0, void* p1, struct S_DFD p2,  double (*cb)(double, void*, struct S_DFD)) ;
+EXPORT double f14_D_DPS_DFP(double p0, void* p1, struct S_DFP p2,  double (*cb)(double, void*, struct S_DFP)) ;
+EXPORT double f14_D_DPS_DDI(double p0, void* p1, struct S_DDI p2,  double (*cb)(double, void*, struct S_DDI)) ;
+EXPORT double f14_D_DPS_DDF(double p0, void* p1, struct S_DDF p2,  double (*cb)(double, void*, struct S_DDF)) ;
+EXPORT double f14_D_DPS_DDD(double p0, void* p1, struct S_DDD p2,  double (*cb)(double, void*, struct S_DDD)) ;
+EXPORT double f14_D_DPS_DDP(double p0, void* p1, struct S_DDP p2,  double (*cb)(double, void*, struct S_DDP)) ;
+EXPORT double f14_D_DPS_DPI(double p0, void* p1, struct S_DPI p2,  double (*cb)(double, void*, struct S_DPI)) ;
+EXPORT double f14_D_DPS_DPF(double p0, void* p1, struct S_DPF p2,  double (*cb)(double, void*, struct S_DPF)) ;
+EXPORT double f14_D_DPS_DPD(double p0, void* p1, struct S_DPD p2,  double (*cb)(double, void*, struct S_DPD)) ;
+EXPORT double f14_D_DPS_DPP(double p0, void* p1, struct S_DPP p2,  double (*cb)(double, void*, struct S_DPP)) ;
+EXPORT double f14_D_DPS_PII(double p0, void* p1, struct S_PII p2,  double (*cb)(double, void*, struct S_PII)) ;
+EXPORT double f14_D_DPS_PIF(double p0, void* p1, struct S_PIF p2,  double (*cb)(double, void*, struct S_PIF)) ;
+EXPORT double f14_D_DPS_PID(double p0, void* p1, struct S_PID p2,  double (*cb)(double, void*, struct S_PID)) ;
+EXPORT double f14_D_DPS_PIP(double p0, void* p1, struct S_PIP p2,  double (*cb)(double, void*, struct S_PIP)) ;
+EXPORT double f14_D_DPS_PFI(double p0, void* p1, struct S_PFI p2,  double (*cb)(double, void*, struct S_PFI)) ;
+EXPORT double f14_D_DPS_PFF(double p0, void* p1, struct S_PFF p2,  double (*cb)(double, void*, struct S_PFF)) ;
+EXPORT double f14_D_DPS_PFD(double p0, void* p1, struct S_PFD p2,  double (*cb)(double, void*, struct S_PFD)) ;
+EXPORT double f14_D_DPS_PFP(double p0, void* p1, struct S_PFP p2,  double (*cb)(double, void*, struct S_PFP)) ;
+EXPORT double f14_D_DPS_PDI(double p0, void* p1, struct S_PDI p2,  double (*cb)(double, void*, struct S_PDI)) ;
+EXPORT double f14_D_DPS_PDF(double p0, void* p1, struct S_PDF p2,  double (*cb)(double, void*, struct S_PDF)) ;
+EXPORT double f14_D_DPS_PDD(double p0, void* p1, struct S_PDD p2,  double (*cb)(double, void*, struct S_PDD)) ;
+EXPORT double f14_D_DPS_PDP(double p0, void* p1, struct S_PDP p2,  double (*cb)(double, void*, struct S_PDP)) ;
+EXPORT double f14_D_DPS_PPI(double p0, void* p1, struct S_PPI p2,  double (*cb)(double, void*, struct S_PPI)) ;
+EXPORT double f14_D_DPS_PPF(double p0, void* p1, struct S_PPF p2,  double (*cb)(double, void*, struct S_PPF)) ;
+EXPORT double f14_D_DPS_PPD(double p0, void* p1, struct S_PPD p2,  double (*cb)(double, void*, struct S_PPD)) ;
+EXPORT double f14_D_DPS_PPP(double p0, void* p1, struct S_PPP p2,  double (*cb)(double, void*, struct S_PPP)) ;
+EXPORT double f14_D_DSI_I(double p0, struct S_I p1, int p2,  double (*cb)(double, struct S_I, int)) ;
+EXPORT double f14_D_DSI_F(double p0, struct S_F p1, int p2,  double (*cb)(double, struct S_F, int)) ;
+EXPORT double f14_D_DSI_D(double p0, struct S_D p1, int p2,  double (*cb)(double, struct S_D, int)) ;
+EXPORT double f14_D_DSI_P(double p0, struct S_P p1, int p2,  double (*cb)(double, struct S_P, int)) ;
+EXPORT double f14_D_DSI_II(double p0, struct S_II p1, int p2,  double (*cb)(double, struct S_II, int)) ;
+EXPORT double f14_D_DSI_IF(double p0, struct S_IF p1, int p2,  double (*cb)(double, struct S_IF, int)) ;
+EXPORT double f14_D_DSI_ID(double p0, struct S_ID p1, int p2,  double (*cb)(double, struct S_ID, int)) ;
+EXPORT double f14_D_DSI_IP(double p0, struct S_IP p1, int p2,  double (*cb)(double, struct S_IP, int)) ;
+EXPORT double f14_D_DSI_FI(double p0, struct S_FI p1, int p2,  double (*cb)(double, struct S_FI, int)) ;
+EXPORT double f14_D_DSI_FF(double p0, struct S_FF p1, int p2,  double (*cb)(double, struct S_FF, int)) ;
+EXPORT double f14_D_DSI_FD(double p0, struct S_FD p1, int p2,  double (*cb)(double, struct S_FD, int)) ;
+EXPORT double f14_D_DSI_FP(double p0, struct S_FP p1, int p2,  double (*cb)(double, struct S_FP, int)) ;
+EXPORT double f14_D_DSI_DI(double p0, struct S_DI p1, int p2,  double (*cb)(double, struct S_DI, int)) ;
+EXPORT double f14_D_DSI_DF(double p0, struct S_DF p1, int p2,  double (*cb)(double, struct S_DF, int)) ;
+EXPORT double f14_D_DSI_DD(double p0, struct S_DD p1, int p2,  double (*cb)(double, struct S_DD, int)) ;
+EXPORT double f14_D_DSI_DP(double p0, struct S_DP p1, int p2,  double (*cb)(double, struct S_DP, int)) ;
+EXPORT double f14_D_DSI_PI(double p0, struct S_PI p1, int p2,  double (*cb)(double, struct S_PI, int)) ;
+EXPORT double f14_D_DSI_PF(double p0, struct S_PF p1, int p2,  double (*cb)(double, struct S_PF, int)) ;
+EXPORT double f14_D_DSI_PD(double p0, struct S_PD p1, int p2,  double (*cb)(double, struct S_PD, int)) ;
+EXPORT double f14_D_DSI_PP(double p0, struct S_PP p1, int p2,  double (*cb)(double, struct S_PP, int)) ;
+EXPORT double f14_D_DSI_III(double p0, struct S_III p1, int p2,  double (*cb)(double, struct S_III, int)) ;
+EXPORT double f14_D_DSI_IIF(double p0, struct S_IIF p1, int p2,  double (*cb)(double, struct S_IIF, int)) ;
+EXPORT double f14_D_DSI_IID(double p0, struct S_IID p1, int p2,  double (*cb)(double, struct S_IID, int)) ;
+EXPORT double f14_D_DSI_IIP(double p0, struct S_IIP p1, int p2,  double (*cb)(double, struct S_IIP, int)) ;
+EXPORT double f14_D_DSI_IFI(double p0, struct S_IFI p1, int p2,  double (*cb)(double, struct S_IFI, int)) ;
+EXPORT double f14_D_DSI_IFF(double p0, struct S_IFF p1, int p2,  double (*cb)(double, struct S_IFF, int)) ;
+EXPORT double f14_D_DSI_IFD(double p0, struct S_IFD p1, int p2,  double (*cb)(double, struct S_IFD, int)) ;
+EXPORT double f14_D_DSI_IFP(double p0, struct S_IFP p1, int p2,  double (*cb)(double, struct S_IFP, int)) ;
+EXPORT double f14_D_DSI_IDI(double p0, struct S_IDI p1, int p2,  double (*cb)(double, struct S_IDI, int)) ;
+EXPORT double f14_D_DSI_IDF(double p0, struct S_IDF p1, int p2,  double (*cb)(double, struct S_IDF, int)) ;
+EXPORT double f14_D_DSI_IDD(double p0, struct S_IDD p1, int p2,  double (*cb)(double, struct S_IDD, int)) ;
+EXPORT double f14_D_DSI_IDP(double p0, struct S_IDP p1, int p2,  double (*cb)(double, struct S_IDP, int)) ;
+EXPORT double f14_D_DSI_IPI(double p0, struct S_IPI p1, int p2,  double (*cb)(double, struct S_IPI, int)) ;
+EXPORT double f14_D_DSI_IPF(double p0, struct S_IPF p1, int p2,  double (*cb)(double, struct S_IPF, int)) ;
+EXPORT double f14_D_DSI_IPD(double p0, struct S_IPD p1, int p2,  double (*cb)(double, struct S_IPD, int)) ;
+EXPORT double f14_D_DSI_IPP(double p0, struct S_IPP p1, int p2,  double (*cb)(double, struct S_IPP, int)) ;
+EXPORT double f14_D_DSI_FII(double p0, struct S_FII p1, int p2,  double (*cb)(double, struct S_FII, int)) ;
+EXPORT double f14_D_DSI_FIF(double p0, struct S_FIF p1, int p2,  double (*cb)(double, struct S_FIF, int)) ;
+EXPORT double f14_D_DSI_FID(double p0, struct S_FID p1, int p2,  double (*cb)(double, struct S_FID, int)) ;
+EXPORT double f14_D_DSI_FIP(double p0, struct S_FIP p1, int p2,  double (*cb)(double, struct S_FIP, int)) ;
+EXPORT double f14_D_DSI_FFI(double p0, struct S_FFI p1, int p2,  double (*cb)(double, struct S_FFI, int)) ;
+EXPORT double f14_D_DSI_FFF(double p0, struct S_FFF p1, int p2,  double (*cb)(double, struct S_FFF, int)) ;
+EXPORT double f14_D_DSI_FFD(double p0, struct S_FFD p1, int p2,  double (*cb)(double, struct S_FFD, int)) ;
+EXPORT double f14_D_DSI_FFP(double p0, struct S_FFP p1, int p2,  double (*cb)(double, struct S_FFP, int)) ;
+EXPORT double f14_D_DSI_FDI(double p0, struct S_FDI p1, int p2,  double (*cb)(double, struct S_FDI, int)) ;
+EXPORT double f14_D_DSI_FDF(double p0, struct S_FDF p1, int p2,  double (*cb)(double, struct S_FDF, int)) ;
+EXPORT double f14_D_DSI_FDD(double p0, struct S_FDD p1, int p2,  double (*cb)(double, struct S_FDD, int)) ;
+EXPORT double f14_D_DSI_FDP(double p0, struct S_FDP p1, int p2,  double (*cb)(double, struct S_FDP, int)) ;
+EXPORT double f14_D_DSI_FPI(double p0, struct S_FPI p1, int p2,  double (*cb)(double, struct S_FPI, int)) ;
+EXPORT double f14_D_DSI_FPF(double p0, struct S_FPF p1, int p2,  double (*cb)(double, struct S_FPF, int)) ;
+EXPORT double f14_D_DSI_FPD(double p0, struct S_FPD p1, int p2,  double (*cb)(double, struct S_FPD, int)) ;
+EXPORT double f14_D_DSI_FPP(double p0, struct S_FPP p1, int p2,  double (*cb)(double, struct S_FPP, int)) ;
+EXPORT double f14_D_DSI_DII(double p0, struct S_DII p1, int p2,  double (*cb)(double, struct S_DII, int)) ;
+EXPORT double f14_D_DSI_DIF(double p0, struct S_DIF p1, int p2,  double (*cb)(double, struct S_DIF, int)) ;
+EXPORT double f14_D_DSI_DID(double p0, struct S_DID p1, int p2,  double (*cb)(double, struct S_DID, int)) ;
+EXPORT double f14_D_DSI_DIP(double p0, struct S_DIP p1, int p2,  double (*cb)(double, struct S_DIP, int)) ;
+EXPORT double f14_D_DSI_DFI(double p0, struct S_DFI p1, int p2,  double (*cb)(double, struct S_DFI, int)) ;
+EXPORT double f14_D_DSI_DFF(double p0, struct S_DFF p1, int p2,  double (*cb)(double, struct S_DFF, int)) ;
+EXPORT double f14_D_DSI_DFD(double p0, struct S_DFD p1, int p2,  double (*cb)(double, struct S_DFD, int)) ;
+EXPORT double f14_D_DSI_DFP(double p0, struct S_DFP p1, int p2,  double (*cb)(double, struct S_DFP, int)) ;
+EXPORT double f14_D_DSI_DDI(double p0, struct S_DDI p1, int p2,  double (*cb)(double, struct S_DDI, int)) ;
+EXPORT double f14_D_DSI_DDF(double p0, struct S_DDF p1, int p2,  double (*cb)(double, struct S_DDF, int)) ;
+EXPORT double f14_D_DSI_DDD(double p0, struct S_DDD p1, int p2,  double (*cb)(double, struct S_DDD, int)) ;
+EXPORT double f14_D_DSI_DDP(double p0, struct S_DDP p1, int p2,  double (*cb)(double, struct S_DDP, int)) ;
+EXPORT double f14_D_DSI_DPI(double p0, struct S_DPI p1, int p2,  double (*cb)(double, struct S_DPI, int)) ;
+EXPORT double f14_D_DSI_DPF(double p0, struct S_DPF p1, int p2,  double (*cb)(double, struct S_DPF, int)) ;
+EXPORT double f14_D_DSI_DPD(double p0, struct S_DPD p1, int p2,  double (*cb)(double, struct S_DPD, int)) ;
+EXPORT double f14_D_DSI_DPP(double p0, struct S_DPP p1, int p2,  double (*cb)(double, struct S_DPP, int)) ;
+EXPORT double f14_D_DSI_PII(double p0, struct S_PII p1, int p2,  double (*cb)(double, struct S_PII, int)) ;
+EXPORT double f14_D_DSI_PIF(double p0, struct S_PIF p1, int p2,  double (*cb)(double, struct S_PIF, int)) ;
+EXPORT double f14_D_DSI_PID(double p0, struct S_PID p1, int p2,  double (*cb)(double, struct S_PID, int)) ;
+EXPORT double f14_D_DSI_PIP(double p0, struct S_PIP p1, int p2,  double (*cb)(double, struct S_PIP, int)) ;
+EXPORT double f14_D_DSI_PFI(double p0, struct S_PFI p1, int p2,  double (*cb)(double, struct S_PFI, int)) ;
+EXPORT double f14_D_DSI_PFF(double p0, struct S_PFF p1, int p2,  double (*cb)(double, struct S_PFF, int)) ;
+EXPORT double f14_D_DSI_PFD(double p0, struct S_PFD p1, int p2,  double (*cb)(double, struct S_PFD, int)) ;
+EXPORT double f14_D_DSI_PFP(double p0, struct S_PFP p1, int p2,  double (*cb)(double, struct S_PFP, int)) ;
+EXPORT double f14_D_DSI_PDI(double p0, struct S_PDI p1, int p2,  double (*cb)(double, struct S_PDI, int)) ;
+EXPORT double f14_D_DSI_PDF(double p0, struct S_PDF p1, int p2,  double (*cb)(double, struct S_PDF, int)) ;
+EXPORT double f14_D_DSI_PDD(double p0, struct S_PDD p1, int p2,  double (*cb)(double, struct S_PDD, int)) ;
+EXPORT double f14_D_DSI_PDP(double p0, struct S_PDP p1, int p2,  double (*cb)(double, struct S_PDP, int)) ;
+EXPORT double f14_D_DSI_PPI(double p0, struct S_PPI p1, int p2,  double (*cb)(double, struct S_PPI, int)) ;
+EXPORT double f14_D_DSI_PPF(double p0, struct S_PPF p1, int p2,  double (*cb)(double, struct S_PPF, int)) ;
+EXPORT double f14_D_DSI_PPD(double p0, struct S_PPD p1, int p2,  double (*cb)(double, struct S_PPD, int)) ;
+EXPORT double f14_D_DSI_PPP(double p0, struct S_PPP p1, int p2,  double (*cb)(double, struct S_PPP, int)) ;
+EXPORT double f14_D_DSF_I(double p0, struct S_I p1, float p2,  double (*cb)(double, struct S_I, float)) ;
+EXPORT double f14_D_DSF_F(double p0, struct S_F p1, float p2,  double (*cb)(double, struct S_F, float)) ;
+EXPORT double f14_D_DSF_D(double p0, struct S_D p1, float p2,  double (*cb)(double, struct S_D, float)) ;
+EXPORT double f14_D_DSF_P(double p0, struct S_P p1, float p2,  double (*cb)(double, struct S_P, float)) ;
+EXPORT double f14_D_DSF_II(double p0, struct S_II p1, float p2,  double (*cb)(double, struct S_II, float)) ;
+EXPORT double f14_D_DSF_IF(double p0, struct S_IF p1, float p2,  double (*cb)(double, struct S_IF, float)) ;
+EXPORT double f14_D_DSF_ID(double p0, struct S_ID p1, float p2,  double (*cb)(double, struct S_ID, float)) ;
+EXPORT double f14_D_DSF_IP(double p0, struct S_IP p1, float p2,  double (*cb)(double, struct S_IP, float)) ;
+EXPORT double f14_D_DSF_FI(double p0, struct S_FI p1, float p2,  double (*cb)(double, struct S_FI, float)) ;
+EXPORT double f14_D_DSF_FF(double p0, struct S_FF p1, float p2,  double (*cb)(double, struct S_FF, float)) ;
+EXPORT double f14_D_DSF_FD(double p0, struct S_FD p1, float p2,  double (*cb)(double, struct S_FD, float)) ;
+EXPORT double f14_D_DSF_FP(double p0, struct S_FP p1, float p2,  double (*cb)(double, struct S_FP, float)) ;
+EXPORT double f14_D_DSF_DI(double p0, struct S_DI p1, float p2,  double (*cb)(double, struct S_DI, float)) ;
+EXPORT double f14_D_DSF_DF(double p0, struct S_DF p1, float p2,  double (*cb)(double, struct S_DF, float)) ;
+EXPORT double f14_D_DSF_DD(double p0, struct S_DD p1, float p2,  double (*cb)(double, struct S_DD, float)) ;
+EXPORT double f14_D_DSF_DP(double p0, struct S_DP p1, float p2,  double (*cb)(double, struct S_DP, float)) ;
+EXPORT double f14_D_DSF_PI(double p0, struct S_PI p1, float p2,  double (*cb)(double, struct S_PI, float)) ;
+EXPORT double f14_D_DSF_PF(double p0, struct S_PF p1, float p2,  double (*cb)(double, struct S_PF, float)) ;
+EXPORT double f14_D_DSF_PD(double p0, struct S_PD p1, float p2,  double (*cb)(double, struct S_PD, float)) ;
+EXPORT double f14_D_DSF_PP(double p0, struct S_PP p1, float p2,  double (*cb)(double, struct S_PP, float)) ;
+EXPORT double f14_D_DSF_III(double p0, struct S_III p1, float p2,  double (*cb)(double, struct S_III, float)) ;
+EXPORT double f14_D_DSF_IIF(double p0, struct S_IIF p1, float p2,  double (*cb)(double, struct S_IIF, float)) ;
+EXPORT double f14_D_DSF_IID(double p0, struct S_IID p1, float p2,  double (*cb)(double, struct S_IID, float)) ;
+EXPORT double f14_D_DSF_IIP(double p0, struct S_IIP p1, float p2,  double (*cb)(double, struct S_IIP, float)) ;
+EXPORT double f14_D_DSF_IFI(double p0, struct S_IFI p1, float p2,  double (*cb)(double, struct S_IFI, float)) ;
+EXPORT double f14_D_DSF_IFF(double p0, struct S_IFF p1, float p2,  double (*cb)(double, struct S_IFF, float)) ;
+EXPORT double f14_D_DSF_IFD(double p0, struct S_IFD p1, float p2,  double (*cb)(double, struct S_IFD, float)) ;
+EXPORT double f14_D_DSF_IFP(double p0, struct S_IFP p1, float p2,  double (*cb)(double, struct S_IFP, float)) ;
+EXPORT double f14_D_DSF_IDI(double p0, struct S_IDI p1, float p2,  double (*cb)(double, struct S_IDI, float)) ;
+EXPORT double f14_D_DSF_IDF(double p0, struct S_IDF p1, float p2,  double (*cb)(double, struct S_IDF, float)) ;
+EXPORT double f14_D_DSF_IDD(double p0, struct S_IDD p1, float p2,  double (*cb)(double, struct S_IDD, float)) ;
+EXPORT double f14_D_DSF_IDP(double p0, struct S_IDP p1, float p2,  double (*cb)(double, struct S_IDP, float)) ;
+EXPORT double f14_D_DSF_IPI(double p0, struct S_IPI p1, float p2,  double (*cb)(double, struct S_IPI, float)) ;
+EXPORT double f14_D_DSF_IPF(double p0, struct S_IPF p1, float p2,  double (*cb)(double, struct S_IPF, float)) ;
+EXPORT double f14_D_DSF_IPD(double p0, struct S_IPD p1, float p2,  double (*cb)(double, struct S_IPD, float)) ;
+EXPORT double f14_D_DSF_IPP(double p0, struct S_IPP p1, float p2,  double (*cb)(double, struct S_IPP, float)) ;
+EXPORT double f14_D_DSF_FII(double p0, struct S_FII p1, float p2,  double (*cb)(double, struct S_FII, float)) ;
+EXPORT double f14_D_DSF_FIF(double p0, struct S_FIF p1, float p2,  double (*cb)(double, struct S_FIF, float)) ;
+EXPORT double f14_D_DSF_FID(double p0, struct S_FID p1, float p2,  double (*cb)(double, struct S_FID, float)) ;
+EXPORT double f14_D_DSF_FIP(double p0, struct S_FIP p1, float p2,  double (*cb)(double, struct S_FIP, float)) ;
+EXPORT double f14_D_DSF_FFI(double p0, struct S_FFI p1, float p2,  double (*cb)(double, struct S_FFI, float)) ;
+EXPORT double f14_D_DSF_FFF(double p0, struct S_FFF p1, float p2,  double (*cb)(double, struct S_FFF, float)) ;
+EXPORT double f14_D_DSF_FFD(double p0, struct S_FFD p1, float p2,  double (*cb)(double, struct S_FFD, float)) ;
+EXPORT double f14_D_DSF_FFP(double p0, struct S_FFP p1, float p2,  double (*cb)(double, struct S_FFP, float)) ;
+EXPORT double f14_D_DSF_FDI(double p0, struct S_FDI p1, float p2,  double (*cb)(double, struct S_FDI, float)) ;
+EXPORT double f14_D_DSF_FDF(double p0, struct S_FDF p1, float p2,  double (*cb)(double, struct S_FDF, float)) ;
+EXPORT double f14_D_DSF_FDD(double p0, struct S_FDD p1, float p2,  double (*cb)(double, struct S_FDD, float)) ;
+EXPORT double f14_D_DSF_FDP(double p0, struct S_FDP p1, float p2,  double (*cb)(double, struct S_FDP, float)) ;
+EXPORT double f14_D_DSF_FPI(double p0, struct S_FPI p1, float p2,  double (*cb)(double, struct S_FPI, float)) ;
+EXPORT double f14_D_DSF_FPF(double p0, struct S_FPF p1, float p2,  double (*cb)(double, struct S_FPF, float)) ;
+EXPORT double f14_D_DSF_FPD(double p0, struct S_FPD p1, float p2,  double (*cb)(double, struct S_FPD, float)) ;
+EXPORT double f14_D_DSF_FPP(double p0, struct S_FPP p1, float p2,  double (*cb)(double, struct S_FPP, float)) ;
+EXPORT double f14_D_DSF_DII(double p0, struct S_DII p1, float p2,  double (*cb)(double, struct S_DII, float)) ;
+EXPORT double f14_D_DSF_DIF(double p0, struct S_DIF p1, float p2,  double (*cb)(double, struct S_DIF, float)) ;
+EXPORT double f14_D_DSF_DID(double p0, struct S_DID p1, float p2,  double (*cb)(double, struct S_DID, float)) ;
+EXPORT double f14_D_DSF_DIP(double p0, struct S_DIP p1, float p2,  double (*cb)(double, struct S_DIP, float)) ;
+EXPORT double f14_D_DSF_DFI(double p0, struct S_DFI p1, float p2,  double (*cb)(double, struct S_DFI, float)) ;
+EXPORT double f14_D_DSF_DFF(double p0, struct S_DFF p1, float p2,  double (*cb)(double, struct S_DFF, float)) ;
+EXPORT double f14_D_DSF_DFD(double p0, struct S_DFD p1, float p2,  double (*cb)(double, struct S_DFD, float)) ;
+EXPORT double f14_D_DSF_DFP(double p0, struct S_DFP p1, float p2,  double (*cb)(double, struct S_DFP, float)) ;
+EXPORT double f14_D_DSF_DDI(double p0, struct S_DDI p1, float p2,  double (*cb)(double, struct S_DDI, float)) ;
+EXPORT double f14_D_DSF_DDF(double p0, struct S_DDF p1, float p2,  double (*cb)(double, struct S_DDF, float)) ;
+EXPORT double f14_D_DSF_DDD(double p0, struct S_DDD p1, float p2,  double (*cb)(double, struct S_DDD, float)) ;
+EXPORT double f14_D_DSF_DDP(double p0, struct S_DDP p1, float p2,  double (*cb)(double, struct S_DDP, float)) ;
+EXPORT double f14_D_DSF_DPI(double p0, struct S_DPI p1, float p2,  double (*cb)(double, struct S_DPI, float)) ;
+EXPORT double f14_D_DSF_DPF(double p0, struct S_DPF p1, float p2,  double (*cb)(double, struct S_DPF, float)) ;
+EXPORT double f14_D_DSF_DPD(double p0, struct S_DPD p1, float p2,  double (*cb)(double, struct S_DPD, float)) ;
+EXPORT double f14_D_DSF_DPP(double p0, struct S_DPP p1, float p2,  double (*cb)(double, struct S_DPP, float)) ;
+EXPORT double f14_D_DSF_PII(double p0, struct S_PII p1, float p2,  double (*cb)(double, struct S_PII, float)) ;
+EXPORT double f14_D_DSF_PIF(double p0, struct S_PIF p1, float p2,  double (*cb)(double, struct S_PIF, float)) ;
+EXPORT double f14_D_DSF_PID(double p0, struct S_PID p1, float p2,  double (*cb)(double, struct S_PID, float)) ;
+EXPORT double f14_D_DSF_PIP(double p0, struct S_PIP p1, float p2,  double (*cb)(double, struct S_PIP, float)) ;
+EXPORT double f14_D_DSF_PFI(double p0, struct S_PFI p1, float p2,  double (*cb)(double, struct S_PFI, float)) ;
+EXPORT double f14_D_DSF_PFF(double p0, struct S_PFF p1, float p2,  double (*cb)(double, struct S_PFF, float)) ;
+EXPORT double f14_D_DSF_PFD(double p0, struct S_PFD p1, float p2,  double (*cb)(double, struct S_PFD, float)) ;
+EXPORT double f14_D_DSF_PFP(double p0, struct S_PFP p1, float p2,  double (*cb)(double, struct S_PFP, float)) ;
+EXPORT double f14_D_DSF_PDI(double p0, struct S_PDI p1, float p2,  double (*cb)(double, struct S_PDI, float)) ;
+EXPORT double f14_D_DSF_PDF(double p0, struct S_PDF p1, float p2,  double (*cb)(double, struct S_PDF, float)) ;
+EXPORT double f14_D_DSF_PDD(double p0, struct S_PDD p1, float p2,  double (*cb)(double, struct S_PDD, float)) ;
+EXPORT double f14_D_DSF_PDP(double p0, struct S_PDP p1, float p2,  double (*cb)(double, struct S_PDP, float)) ;
+EXPORT double f14_D_DSF_PPI(double p0, struct S_PPI p1, float p2,  double (*cb)(double, struct S_PPI, float)) ;
+EXPORT double f14_D_DSF_PPF(double p0, struct S_PPF p1, float p2,  double (*cb)(double, struct S_PPF, float)) ;
+EXPORT double f14_D_DSF_PPD(double p0, struct S_PPD p1, float p2,  double (*cb)(double, struct S_PPD, float)) ;
+EXPORT double f14_D_DSF_PPP(double p0, struct S_PPP p1, float p2,  double (*cb)(double, struct S_PPP, float)) ;
+EXPORT double f14_D_DSD_I(double p0, struct S_I p1, double p2,  double (*cb)(double, struct S_I, double)) ;
+EXPORT double f14_D_DSD_F(double p0, struct S_F p1, double p2,  double (*cb)(double, struct S_F, double)) ;
+EXPORT double f14_D_DSD_D(double p0, struct S_D p1, double p2,  double (*cb)(double, struct S_D, double)) ;
+EXPORT double f14_D_DSD_P(double p0, struct S_P p1, double p2,  double (*cb)(double, struct S_P, double)) ;
+EXPORT double f14_D_DSD_II(double p0, struct S_II p1, double p2,  double (*cb)(double, struct S_II, double)) ;
+EXPORT double f14_D_DSD_IF(double p0, struct S_IF p1, double p2,  double (*cb)(double, struct S_IF, double)) ;
+EXPORT double f14_D_DSD_ID(double p0, struct S_ID p1, double p2,  double (*cb)(double, struct S_ID, double)) ;
+EXPORT double f14_D_DSD_IP(double p0, struct S_IP p1, double p2,  double (*cb)(double, struct S_IP, double)) ;
+EXPORT double f14_D_DSD_FI(double p0, struct S_FI p1, double p2,  double (*cb)(double, struct S_FI, double)) ;
+EXPORT double f14_D_DSD_FF(double p0, struct S_FF p1, double p2,  double (*cb)(double, struct S_FF, double)) ;
+EXPORT double f14_D_DSD_FD(double p0, struct S_FD p1, double p2,  double (*cb)(double, struct S_FD, double)) ;
+EXPORT double f14_D_DSD_FP(double p0, struct S_FP p1, double p2,  double (*cb)(double, struct S_FP, double)) ;
+EXPORT double f14_D_DSD_DI(double p0, struct S_DI p1, double p2,  double (*cb)(double, struct S_DI, double)) ;
+EXPORT double f14_D_DSD_DF(double p0, struct S_DF p1, double p2,  double (*cb)(double, struct S_DF, double)) ;
+EXPORT double f14_D_DSD_DD(double p0, struct S_DD p1, double p2,  double (*cb)(double, struct S_DD, double)) ;
+EXPORT double f14_D_DSD_DP(double p0, struct S_DP p1, double p2,  double (*cb)(double, struct S_DP, double)) ;
+EXPORT double f14_D_DSD_PI(double p0, struct S_PI p1, double p2,  double (*cb)(double, struct S_PI, double)) ;
+EXPORT double f14_D_DSD_PF(double p0, struct S_PF p1, double p2,  double (*cb)(double, struct S_PF, double)) ;
+EXPORT double f14_D_DSD_PD(double p0, struct S_PD p1, double p2,  double (*cb)(double, struct S_PD, double)) ;
+EXPORT double f14_D_DSD_PP(double p0, struct S_PP p1, double p2,  double (*cb)(double, struct S_PP, double)) ;
+EXPORT double f14_D_DSD_III(double p0, struct S_III p1, double p2,  double (*cb)(double, struct S_III, double)) ;
+EXPORT double f14_D_DSD_IIF(double p0, struct S_IIF p1, double p2,  double (*cb)(double, struct S_IIF, double)) ;
+EXPORT double f14_D_DSD_IID(double p0, struct S_IID p1, double p2,  double (*cb)(double, struct S_IID, double)) ;
+EXPORT double f14_D_DSD_IIP(double p0, struct S_IIP p1, double p2,  double (*cb)(double, struct S_IIP, double)) ;
+EXPORT double f14_D_DSD_IFI(double p0, struct S_IFI p1, double p2,  double (*cb)(double, struct S_IFI, double)) ;
+EXPORT double f14_D_DSD_IFF(double p0, struct S_IFF p1, double p2,  double (*cb)(double, struct S_IFF, double)) ;
+EXPORT double f14_D_DSD_IFD(double p0, struct S_IFD p1, double p2,  double (*cb)(double, struct S_IFD, double)) ;
+EXPORT double f15_D_DSD_IFP(double p0, struct S_IFP p1, double p2,  double (*cb)(double, struct S_IFP, double)) ;
+EXPORT double f15_D_DSD_IDI(double p0, struct S_IDI p1, double p2,  double (*cb)(double, struct S_IDI, double)) ;
+EXPORT double f15_D_DSD_IDF(double p0, struct S_IDF p1, double p2,  double (*cb)(double, struct S_IDF, double)) ;
+EXPORT double f15_D_DSD_IDD(double p0, struct S_IDD p1, double p2,  double (*cb)(double, struct S_IDD, double)) ;
+EXPORT double f15_D_DSD_IDP(double p0, struct S_IDP p1, double p2,  double (*cb)(double, struct S_IDP, double)) ;
+EXPORT double f15_D_DSD_IPI(double p0, struct S_IPI p1, double p2,  double (*cb)(double, struct S_IPI, double)) ;
+EXPORT double f15_D_DSD_IPF(double p0, struct S_IPF p1, double p2,  double (*cb)(double, struct S_IPF, double)) ;
+EXPORT double f15_D_DSD_IPD(double p0, struct S_IPD p1, double p2,  double (*cb)(double, struct S_IPD, double)) ;
+EXPORT double f15_D_DSD_IPP(double p0, struct S_IPP p1, double p2,  double (*cb)(double, struct S_IPP, double)) ;
+EXPORT double f15_D_DSD_FII(double p0, struct S_FII p1, double p2,  double (*cb)(double, struct S_FII, double)) ;
+EXPORT double f15_D_DSD_FIF(double p0, struct S_FIF p1, double p2,  double (*cb)(double, struct S_FIF, double)) ;
+EXPORT double f15_D_DSD_FID(double p0, struct S_FID p1, double p2,  double (*cb)(double, struct S_FID, double)) ;
+EXPORT double f15_D_DSD_FIP(double p0, struct S_FIP p1, double p2,  double (*cb)(double, struct S_FIP, double)) ;
+EXPORT double f15_D_DSD_FFI(double p0, struct S_FFI p1, double p2,  double (*cb)(double, struct S_FFI, double)) ;
+EXPORT double f15_D_DSD_FFF(double p0, struct S_FFF p1, double p2,  double (*cb)(double, struct S_FFF, double)) ;
+EXPORT double f15_D_DSD_FFD(double p0, struct S_FFD p1, double p2,  double (*cb)(double, struct S_FFD, double)) ;
+EXPORT double f15_D_DSD_FFP(double p0, struct S_FFP p1, double p2,  double (*cb)(double, struct S_FFP, double)) ;
+EXPORT double f15_D_DSD_FDI(double p0, struct S_FDI p1, double p2,  double (*cb)(double, struct S_FDI, double)) ;
+EXPORT double f15_D_DSD_FDF(double p0, struct S_FDF p1, double p2,  double (*cb)(double, struct S_FDF, double)) ;
+EXPORT double f15_D_DSD_FDD(double p0, struct S_FDD p1, double p2,  double (*cb)(double, struct S_FDD, double)) ;
+EXPORT double f15_D_DSD_FDP(double p0, struct S_FDP p1, double p2,  double (*cb)(double, struct S_FDP, double)) ;
+EXPORT double f15_D_DSD_FPI(double p0, struct S_FPI p1, double p2,  double (*cb)(double, struct S_FPI, double)) ;
+EXPORT double f15_D_DSD_FPF(double p0, struct S_FPF p1, double p2,  double (*cb)(double, struct S_FPF, double)) ;
+EXPORT double f15_D_DSD_FPD(double p0, struct S_FPD p1, double p2,  double (*cb)(double, struct S_FPD, double)) ;
+EXPORT double f15_D_DSD_FPP(double p0, struct S_FPP p1, double p2,  double (*cb)(double, struct S_FPP, double)) ;
+EXPORT double f15_D_DSD_DII(double p0, struct S_DII p1, double p2,  double (*cb)(double, struct S_DII, double)) ;
+EXPORT double f15_D_DSD_DIF(double p0, struct S_DIF p1, double p2,  double (*cb)(double, struct S_DIF, double)) ;
+EXPORT double f15_D_DSD_DID(double p0, struct S_DID p1, double p2,  double (*cb)(double, struct S_DID, double)) ;
+EXPORT double f15_D_DSD_DIP(double p0, struct S_DIP p1, double p2,  double (*cb)(double, struct S_DIP, double)) ;
+EXPORT double f15_D_DSD_DFI(double p0, struct S_DFI p1, double p2,  double (*cb)(double, struct S_DFI, double)) ;
+EXPORT double f15_D_DSD_DFF(double p0, struct S_DFF p1, double p2,  double (*cb)(double, struct S_DFF, double)) ;
+EXPORT double f15_D_DSD_DFD(double p0, struct S_DFD p1, double p2,  double (*cb)(double, struct S_DFD, double)) ;
+EXPORT double f15_D_DSD_DFP(double p0, struct S_DFP p1, double p2,  double (*cb)(double, struct S_DFP, double)) ;
+EXPORT double f15_D_DSD_DDI(double p0, struct S_DDI p1, double p2,  double (*cb)(double, struct S_DDI, double)) ;
+EXPORT double f15_D_DSD_DDF(double p0, struct S_DDF p1, double p2,  double (*cb)(double, struct S_DDF, double)) ;
+EXPORT double f15_D_DSD_DDD(double p0, struct S_DDD p1, double p2,  double (*cb)(double, struct S_DDD, double)) ;
+EXPORT double f15_D_DSD_DDP(double p0, struct S_DDP p1, double p2,  double (*cb)(double, struct S_DDP, double)) ;
+EXPORT double f15_D_DSD_DPI(double p0, struct S_DPI p1, double p2,  double (*cb)(double, struct S_DPI, double)) ;
+EXPORT double f15_D_DSD_DPF(double p0, struct S_DPF p1, double p2,  double (*cb)(double, struct S_DPF, double)) ;
+EXPORT double f15_D_DSD_DPD(double p0, struct S_DPD p1, double p2,  double (*cb)(double, struct S_DPD, double)) ;
+EXPORT double f15_D_DSD_DPP(double p0, struct S_DPP p1, double p2,  double (*cb)(double, struct S_DPP, double)) ;
+EXPORT double f15_D_DSD_PII(double p0, struct S_PII p1, double p2,  double (*cb)(double, struct S_PII, double)) ;
+EXPORT double f15_D_DSD_PIF(double p0, struct S_PIF p1, double p2,  double (*cb)(double, struct S_PIF, double)) ;
+EXPORT double f15_D_DSD_PID(double p0, struct S_PID p1, double p2,  double (*cb)(double, struct S_PID, double)) ;
+EXPORT double f15_D_DSD_PIP(double p0, struct S_PIP p1, double p2,  double (*cb)(double, struct S_PIP, double)) ;
+EXPORT double f15_D_DSD_PFI(double p0, struct S_PFI p1, double p2,  double (*cb)(double, struct S_PFI, double)) ;
+EXPORT double f15_D_DSD_PFF(double p0, struct S_PFF p1, double p2,  double (*cb)(double, struct S_PFF, double)) ;
+EXPORT double f15_D_DSD_PFD(double p0, struct S_PFD p1, double p2,  double (*cb)(double, struct S_PFD, double)) ;
+EXPORT double f15_D_DSD_PFP(double p0, struct S_PFP p1, double p2,  double (*cb)(double, struct S_PFP, double)) ;
+EXPORT double f15_D_DSD_PDI(double p0, struct S_PDI p1, double p2,  double (*cb)(double, struct S_PDI, double)) ;
+EXPORT double f15_D_DSD_PDF(double p0, struct S_PDF p1, double p2,  double (*cb)(double, struct S_PDF, double)) ;
+EXPORT double f15_D_DSD_PDD(double p0, struct S_PDD p1, double p2,  double (*cb)(double, struct S_PDD, double)) ;
+EXPORT double f15_D_DSD_PDP(double p0, struct S_PDP p1, double p2,  double (*cb)(double, struct S_PDP, double)) ;
+EXPORT double f15_D_DSD_PPI(double p0, struct S_PPI p1, double p2,  double (*cb)(double, struct S_PPI, double)) ;
+EXPORT double f15_D_DSD_PPF(double p0, struct S_PPF p1, double p2,  double (*cb)(double, struct S_PPF, double)) ;
+EXPORT double f15_D_DSD_PPD(double p0, struct S_PPD p1, double p2,  double (*cb)(double, struct S_PPD, double)) ;
+EXPORT double f15_D_DSD_PPP(double p0, struct S_PPP p1, double p2,  double (*cb)(double, struct S_PPP, double)) ;
+EXPORT double f15_D_DSP_I(double p0, struct S_I p1, void* p2,  double (*cb)(double, struct S_I, void*)) ;
+EXPORT double f15_D_DSP_F(double p0, struct S_F p1, void* p2,  double (*cb)(double, struct S_F, void*)) ;
+EXPORT double f15_D_DSP_D(double p0, struct S_D p1, void* p2,  double (*cb)(double, struct S_D, void*)) ;
+EXPORT double f15_D_DSP_P(double p0, struct S_P p1, void* p2,  double (*cb)(double, struct S_P, void*)) ;
+EXPORT double f15_D_DSP_II(double p0, struct S_II p1, void* p2,  double (*cb)(double, struct S_II, void*)) ;
+EXPORT double f15_D_DSP_IF(double p0, struct S_IF p1, void* p2,  double (*cb)(double, struct S_IF, void*)) ;
+EXPORT double f15_D_DSP_ID(double p0, struct S_ID p1, void* p2,  double (*cb)(double, struct S_ID, void*)) ;
+EXPORT double f15_D_DSP_IP(double p0, struct S_IP p1, void* p2,  double (*cb)(double, struct S_IP, void*)) ;
+EXPORT double f15_D_DSP_FI(double p0, struct S_FI p1, void* p2,  double (*cb)(double, struct S_FI, void*)) ;
+EXPORT double f15_D_DSP_FF(double p0, struct S_FF p1, void* p2,  double (*cb)(double, struct S_FF, void*)) ;
+EXPORT double f15_D_DSP_FD(double p0, struct S_FD p1, void* p2,  double (*cb)(double, struct S_FD, void*)) ;
+EXPORT double f15_D_DSP_FP(double p0, struct S_FP p1, void* p2,  double (*cb)(double, struct S_FP, void*)) ;
+EXPORT double f15_D_DSP_DI(double p0, struct S_DI p1, void* p2,  double (*cb)(double, struct S_DI, void*)) ;
+EXPORT double f15_D_DSP_DF(double p0, struct S_DF p1, void* p2,  double (*cb)(double, struct S_DF, void*)) ;
+EXPORT double f15_D_DSP_DD(double p0, struct S_DD p1, void* p2,  double (*cb)(double, struct S_DD, void*)) ;
+EXPORT double f15_D_DSP_DP(double p0, struct S_DP p1, void* p2,  double (*cb)(double, struct S_DP, void*)) ;
+EXPORT double f15_D_DSP_PI(double p0, struct S_PI p1, void* p2,  double (*cb)(double, struct S_PI, void*)) ;
+EXPORT double f15_D_DSP_PF(double p0, struct S_PF p1, void* p2,  double (*cb)(double, struct S_PF, void*)) ;
+EXPORT double f15_D_DSP_PD(double p0, struct S_PD p1, void* p2,  double (*cb)(double, struct S_PD, void*)) ;
+EXPORT double f15_D_DSP_PP(double p0, struct S_PP p1, void* p2,  double (*cb)(double, struct S_PP, void*)) ;
+EXPORT double f15_D_DSP_III(double p0, struct S_III p1, void* p2,  double (*cb)(double, struct S_III, void*)) ;
+EXPORT double f15_D_DSP_IIF(double p0, struct S_IIF p1, void* p2,  double (*cb)(double, struct S_IIF, void*)) ;
+EXPORT double f15_D_DSP_IID(double p0, struct S_IID p1, void* p2,  double (*cb)(double, struct S_IID, void*)) ;
+EXPORT double f15_D_DSP_IIP(double p0, struct S_IIP p1, void* p2,  double (*cb)(double, struct S_IIP, void*)) ;
+EXPORT double f15_D_DSP_IFI(double p0, struct S_IFI p1, void* p2,  double (*cb)(double, struct S_IFI, void*)) ;
+EXPORT double f15_D_DSP_IFF(double p0, struct S_IFF p1, void* p2,  double (*cb)(double, struct S_IFF, void*)) ;
+EXPORT double f15_D_DSP_IFD(double p0, struct S_IFD p1, void* p2,  double (*cb)(double, struct S_IFD, void*)) ;
+EXPORT double f15_D_DSP_IFP(double p0, struct S_IFP p1, void* p2,  double (*cb)(double, struct S_IFP, void*)) ;
+EXPORT double f15_D_DSP_IDI(double p0, struct S_IDI p1, void* p2,  double (*cb)(double, struct S_IDI, void*)) ;
+EXPORT double f15_D_DSP_IDF(double p0, struct S_IDF p1, void* p2,  double (*cb)(double, struct S_IDF, void*)) ;
+EXPORT double f15_D_DSP_IDD(double p0, struct S_IDD p1, void* p2,  double (*cb)(double, struct S_IDD, void*)) ;
+EXPORT double f15_D_DSP_IDP(double p0, struct S_IDP p1, void* p2,  double (*cb)(double, struct S_IDP, void*)) ;
+EXPORT double f15_D_DSP_IPI(double p0, struct S_IPI p1, void* p2,  double (*cb)(double, struct S_IPI, void*)) ;
+EXPORT double f15_D_DSP_IPF(double p0, struct S_IPF p1, void* p2,  double (*cb)(double, struct S_IPF, void*)) ;
+EXPORT double f15_D_DSP_IPD(double p0, struct S_IPD p1, void* p2,  double (*cb)(double, struct S_IPD, void*)) ;
+EXPORT double f15_D_DSP_IPP(double p0, struct S_IPP p1, void* p2,  double (*cb)(double, struct S_IPP, void*)) ;
+EXPORT double f15_D_DSP_FII(double p0, struct S_FII p1, void* p2,  double (*cb)(double, struct S_FII, void*)) ;
+EXPORT double f15_D_DSP_FIF(double p0, struct S_FIF p1, void* p2,  double (*cb)(double, struct S_FIF, void*)) ;
+EXPORT double f15_D_DSP_FID(double p0, struct S_FID p1, void* p2,  double (*cb)(double, struct S_FID, void*)) ;
+EXPORT double f15_D_DSP_FIP(double p0, struct S_FIP p1, void* p2,  double (*cb)(double, struct S_FIP, void*)) ;
+EXPORT double f15_D_DSP_FFI(double p0, struct S_FFI p1, void* p2,  double (*cb)(double, struct S_FFI, void*)) ;
+EXPORT double f15_D_DSP_FFF(double p0, struct S_FFF p1, void* p2,  double (*cb)(double, struct S_FFF, void*)) ;
+EXPORT double f15_D_DSP_FFD(double p0, struct S_FFD p1, void* p2,  double (*cb)(double, struct S_FFD, void*)) ;
+EXPORT double f15_D_DSP_FFP(double p0, struct S_FFP p1, void* p2,  double (*cb)(double, struct S_FFP, void*)) ;
+EXPORT double f15_D_DSP_FDI(double p0, struct S_FDI p1, void* p2,  double (*cb)(double, struct S_FDI, void*)) ;
+EXPORT double f15_D_DSP_FDF(double p0, struct S_FDF p1, void* p2,  double (*cb)(double, struct S_FDF, void*)) ;
+EXPORT double f15_D_DSP_FDD(double p0, struct S_FDD p1, void* p2,  double (*cb)(double, struct S_FDD, void*)) ;
+EXPORT double f15_D_DSP_FDP(double p0, struct S_FDP p1, void* p2,  double (*cb)(double, struct S_FDP, void*)) ;
+EXPORT double f15_D_DSP_FPI(double p0, struct S_FPI p1, void* p2,  double (*cb)(double, struct S_FPI, void*)) ;
+EXPORT double f15_D_DSP_FPF(double p0, struct S_FPF p1, void* p2,  double (*cb)(double, struct S_FPF, void*)) ;
+EXPORT double f15_D_DSP_FPD(double p0, struct S_FPD p1, void* p2,  double (*cb)(double, struct S_FPD, void*)) ;
+EXPORT double f15_D_DSP_FPP(double p0, struct S_FPP p1, void* p2,  double (*cb)(double, struct S_FPP, void*)) ;
+EXPORT double f15_D_DSP_DII(double p0, struct S_DII p1, void* p2,  double (*cb)(double, struct S_DII, void*)) ;
+EXPORT double f15_D_DSP_DIF(double p0, struct S_DIF p1, void* p2,  double (*cb)(double, struct S_DIF, void*)) ;
+EXPORT double f15_D_DSP_DID(double p0, struct S_DID p1, void* p2,  double (*cb)(double, struct S_DID, void*)) ;
+EXPORT double f15_D_DSP_DIP(double p0, struct S_DIP p1, void* p2,  double (*cb)(double, struct S_DIP, void*)) ;
+EXPORT double f15_D_DSP_DFI(double p0, struct S_DFI p1, void* p2,  double (*cb)(double, struct S_DFI, void*)) ;
+EXPORT double f15_D_DSP_DFF(double p0, struct S_DFF p1, void* p2,  double (*cb)(double, struct S_DFF, void*)) ;
+EXPORT double f15_D_DSP_DFD(double p0, struct S_DFD p1, void* p2,  double (*cb)(double, struct S_DFD, void*)) ;
+EXPORT double f15_D_DSP_DFP(double p0, struct S_DFP p1, void* p2,  double (*cb)(double, struct S_DFP, void*)) ;
+EXPORT double f15_D_DSP_DDI(double p0, struct S_DDI p1, void* p2,  double (*cb)(double, struct S_DDI, void*)) ;
+EXPORT double f15_D_DSP_DDF(double p0, struct S_DDF p1, void* p2,  double (*cb)(double, struct S_DDF, void*)) ;
+EXPORT double f15_D_DSP_DDD(double p0, struct S_DDD p1, void* p2,  double (*cb)(double, struct S_DDD, void*)) ;
+EXPORT double f15_D_DSP_DDP(double p0, struct S_DDP p1, void* p2,  double (*cb)(double, struct S_DDP, void*)) ;
+EXPORT double f15_D_DSP_DPI(double p0, struct S_DPI p1, void* p2,  double (*cb)(double, struct S_DPI, void*)) ;
+EXPORT double f15_D_DSP_DPF(double p0, struct S_DPF p1, void* p2,  double (*cb)(double, struct S_DPF, void*)) ;
+EXPORT double f15_D_DSP_DPD(double p0, struct S_DPD p1, void* p2,  double (*cb)(double, struct S_DPD, void*)) ;
+EXPORT double f15_D_DSP_DPP(double p0, struct S_DPP p1, void* p2,  double (*cb)(double, struct S_DPP, void*)) ;
+EXPORT double f15_D_DSP_PII(double p0, struct S_PII p1, void* p2,  double (*cb)(double, struct S_PII, void*)) ;
+EXPORT double f15_D_DSP_PIF(double p0, struct S_PIF p1, void* p2,  double (*cb)(double, struct S_PIF, void*)) ;
+EXPORT double f15_D_DSP_PID(double p0, struct S_PID p1, void* p2,  double (*cb)(double, struct S_PID, void*)) ;
+EXPORT double f15_D_DSP_PIP(double p0, struct S_PIP p1, void* p2,  double (*cb)(double, struct S_PIP, void*)) ;
+EXPORT double f15_D_DSP_PFI(double p0, struct S_PFI p1, void* p2,  double (*cb)(double, struct S_PFI, void*)) ;
+EXPORT double f15_D_DSP_PFF(double p0, struct S_PFF p1, void* p2,  double (*cb)(double, struct S_PFF, void*)) ;
+EXPORT double f15_D_DSP_PFD(double p0, struct S_PFD p1, void* p2,  double (*cb)(double, struct S_PFD, void*)) ;
+EXPORT double f15_D_DSP_PFP(double p0, struct S_PFP p1, void* p2,  double (*cb)(double, struct S_PFP, void*)) ;
+EXPORT double f15_D_DSP_PDI(double p0, struct S_PDI p1, void* p2,  double (*cb)(double, struct S_PDI, void*)) ;
+EXPORT double f15_D_DSP_PDF(double p0, struct S_PDF p1, void* p2,  double (*cb)(double, struct S_PDF, void*)) ;
+EXPORT double f15_D_DSP_PDD(double p0, struct S_PDD p1, void* p2,  double (*cb)(double, struct S_PDD, void*)) ;
+EXPORT double f15_D_DSP_PDP(double p0, struct S_PDP p1, void* p2,  double (*cb)(double, struct S_PDP, void*)) ;
+EXPORT double f15_D_DSP_PPI(double p0, struct S_PPI p1, void* p2,  double (*cb)(double, struct S_PPI, void*)) ;
+EXPORT double f15_D_DSP_PPF(double p0, struct S_PPF p1, void* p2,  double (*cb)(double, struct S_PPF, void*)) ;
+EXPORT double f15_D_DSP_PPD(double p0, struct S_PPD p1, void* p2,  double (*cb)(double, struct S_PPD, void*)) ;
+EXPORT double f15_D_DSP_PPP(double p0, struct S_PPP p1, void* p2,  double (*cb)(double, struct S_PPP, void*)) ;
+EXPORT double f15_D_DSS_I(double p0, struct S_I p1, struct S_I p2,  double (*cb)(double, struct S_I, struct S_I)) ;
+EXPORT double f15_D_DSS_F(double p0, struct S_F p1, struct S_F p2,  double (*cb)(double, struct S_F, struct S_F)) ;
+EXPORT double f15_D_DSS_D(double p0, struct S_D p1, struct S_D p2,  double (*cb)(double, struct S_D, struct S_D)) ;
+EXPORT double f15_D_DSS_P(double p0, struct S_P p1, struct S_P p2,  double (*cb)(double, struct S_P, struct S_P)) ;
+EXPORT double f15_D_DSS_II(double p0, struct S_II p1, struct S_II p2,  double (*cb)(double, struct S_II, struct S_II)) ;
+EXPORT double f15_D_DSS_IF(double p0, struct S_IF p1, struct S_IF p2,  double (*cb)(double, struct S_IF, struct S_IF)) ;
+EXPORT double f15_D_DSS_ID(double p0, struct S_ID p1, struct S_ID p2,  double (*cb)(double, struct S_ID, struct S_ID)) ;
+EXPORT double f15_D_DSS_IP(double p0, struct S_IP p1, struct S_IP p2,  double (*cb)(double, struct S_IP, struct S_IP)) ;
+EXPORT double f15_D_DSS_FI(double p0, struct S_FI p1, struct S_FI p2,  double (*cb)(double, struct S_FI, struct S_FI)) ;
+EXPORT double f15_D_DSS_FF(double p0, struct S_FF p1, struct S_FF p2,  double (*cb)(double, struct S_FF, struct S_FF)) ;
+EXPORT double f15_D_DSS_FD(double p0, struct S_FD p1, struct S_FD p2,  double (*cb)(double, struct S_FD, struct S_FD)) ;
+EXPORT double f15_D_DSS_FP(double p0, struct S_FP p1, struct S_FP p2,  double (*cb)(double, struct S_FP, struct S_FP)) ;
+EXPORT double f15_D_DSS_DI(double p0, struct S_DI p1, struct S_DI p2,  double (*cb)(double, struct S_DI, struct S_DI)) ;
+EXPORT double f15_D_DSS_DF(double p0, struct S_DF p1, struct S_DF p2,  double (*cb)(double, struct S_DF, struct S_DF)) ;
+EXPORT double f15_D_DSS_DD(double p0, struct S_DD p1, struct S_DD p2,  double (*cb)(double, struct S_DD, struct S_DD)) ;
+EXPORT double f15_D_DSS_DP(double p0, struct S_DP p1, struct S_DP p2,  double (*cb)(double, struct S_DP, struct S_DP)) ;
+EXPORT double f15_D_DSS_PI(double p0, struct S_PI p1, struct S_PI p2,  double (*cb)(double, struct S_PI, struct S_PI)) ;
+EXPORT double f15_D_DSS_PF(double p0, struct S_PF p1, struct S_PF p2,  double (*cb)(double, struct S_PF, struct S_PF)) ;
+EXPORT double f15_D_DSS_PD(double p0, struct S_PD p1, struct S_PD p2,  double (*cb)(double, struct S_PD, struct S_PD)) ;
+EXPORT double f15_D_DSS_PP(double p0, struct S_PP p1, struct S_PP p2,  double (*cb)(double, struct S_PP, struct S_PP)) ;
+EXPORT double f15_D_DSS_III(double p0, struct S_III p1, struct S_III p2,  double (*cb)(double, struct S_III, struct S_III)) ;
+EXPORT double f15_D_DSS_IIF(double p0, struct S_IIF p1, struct S_IIF p2,  double (*cb)(double, struct S_IIF, struct S_IIF)) ;
+EXPORT double f15_D_DSS_IID(double p0, struct S_IID p1, struct S_IID p2,  double (*cb)(double, struct S_IID, struct S_IID)) ;
+EXPORT double f15_D_DSS_IIP(double p0, struct S_IIP p1, struct S_IIP p2,  double (*cb)(double, struct S_IIP, struct S_IIP)) ;
+EXPORT double f15_D_DSS_IFI(double p0, struct S_IFI p1, struct S_IFI p2,  double (*cb)(double, struct S_IFI, struct S_IFI)) ;
+EXPORT double f15_D_DSS_IFF(double p0, struct S_IFF p1, struct S_IFF p2,  double (*cb)(double, struct S_IFF, struct S_IFF)) ;
+EXPORT double f15_D_DSS_IFD(double p0, struct S_IFD p1, struct S_IFD p2,  double (*cb)(double, struct S_IFD, struct S_IFD)) ;
+EXPORT double f15_D_DSS_IFP(double p0, struct S_IFP p1, struct S_IFP p2,  double (*cb)(double, struct S_IFP, struct S_IFP)) ;
+EXPORT double f15_D_DSS_IDI(double p0, struct S_IDI p1, struct S_IDI p2,  double (*cb)(double, struct S_IDI, struct S_IDI)) ;
+EXPORT double f15_D_DSS_IDF(double p0, struct S_IDF p1, struct S_IDF p2,  double (*cb)(double, struct S_IDF, struct S_IDF)) ;
+EXPORT double f15_D_DSS_IDD(double p0, struct S_IDD p1, struct S_IDD p2,  double (*cb)(double, struct S_IDD, struct S_IDD)) ;
+EXPORT double f15_D_DSS_IDP(double p0, struct S_IDP p1, struct S_IDP p2,  double (*cb)(double, struct S_IDP, struct S_IDP)) ;
+EXPORT double f15_D_DSS_IPI(double p0, struct S_IPI p1, struct S_IPI p2,  double (*cb)(double, struct S_IPI, struct S_IPI)) ;
+EXPORT double f15_D_DSS_IPF(double p0, struct S_IPF p1, struct S_IPF p2,  double (*cb)(double, struct S_IPF, struct S_IPF)) ;
+EXPORT double f15_D_DSS_IPD(double p0, struct S_IPD p1, struct S_IPD p2,  double (*cb)(double, struct S_IPD, struct S_IPD)) ;
+EXPORT double f15_D_DSS_IPP(double p0, struct S_IPP p1, struct S_IPP p2,  double (*cb)(double, struct S_IPP, struct S_IPP)) ;
+EXPORT double f15_D_DSS_FII(double p0, struct S_FII p1, struct S_FII p2,  double (*cb)(double, struct S_FII, struct S_FII)) ;
+EXPORT double f15_D_DSS_FIF(double p0, struct S_FIF p1, struct S_FIF p2,  double (*cb)(double, struct S_FIF, struct S_FIF)) ;
+EXPORT double f15_D_DSS_FID(double p0, struct S_FID p1, struct S_FID p2,  double (*cb)(double, struct S_FID, struct S_FID)) ;
+EXPORT double f15_D_DSS_FIP(double p0, struct S_FIP p1, struct S_FIP p2,  double (*cb)(double, struct S_FIP, struct S_FIP)) ;
+EXPORT double f15_D_DSS_FFI(double p0, struct S_FFI p1, struct S_FFI p2,  double (*cb)(double, struct S_FFI, struct S_FFI)) ;
+EXPORT double f15_D_DSS_FFF(double p0, struct S_FFF p1, struct S_FFF p2,  double (*cb)(double, struct S_FFF, struct S_FFF)) ;
+EXPORT double f15_D_DSS_FFD(double p0, struct S_FFD p1, struct S_FFD p2,  double (*cb)(double, struct S_FFD, struct S_FFD)) ;
+EXPORT double f15_D_DSS_FFP(double p0, struct S_FFP p1, struct S_FFP p2,  double (*cb)(double, struct S_FFP, struct S_FFP)) ;
+EXPORT double f15_D_DSS_FDI(double p0, struct S_FDI p1, struct S_FDI p2,  double (*cb)(double, struct S_FDI, struct S_FDI)) ;
+EXPORT double f15_D_DSS_FDF(double p0, struct S_FDF p1, struct S_FDF p2,  double (*cb)(double, struct S_FDF, struct S_FDF)) ;
+EXPORT double f15_D_DSS_FDD(double p0, struct S_FDD p1, struct S_FDD p2,  double (*cb)(double, struct S_FDD, struct S_FDD)) ;
+EXPORT double f15_D_DSS_FDP(double p0, struct S_FDP p1, struct S_FDP p2,  double (*cb)(double, struct S_FDP, struct S_FDP)) ;
+EXPORT double f15_D_DSS_FPI(double p0, struct S_FPI p1, struct S_FPI p2,  double (*cb)(double, struct S_FPI, struct S_FPI)) ;
+EXPORT double f15_D_DSS_FPF(double p0, struct S_FPF p1, struct S_FPF p2,  double (*cb)(double, struct S_FPF, struct S_FPF)) ;
+EXPORT double f15_D_DSS_FPD(double p0, struct S_FPD p1, struct S_FPD p2,  double (*cb)(double, struct S_FPD, struct S_FPD)) ;
+EXPORT double f15_D_DSS_FPP(double p0, struct S_FPP p1, struct S_FPP p2,  double (*cb)(double, struct S_FPP, struct S_FPP)) ;
+EXPORT double f15_D_DSS_DII(double p0, struct S_DII p1, struct S_DII p2,  double (*cb)(double, struct S_DII, struct S_DII)) ;
+EXPORT double f15_D_DSS_DIF(double p0, struct S_DIF p1, struct S_DIF p2,  double (*cb)(double, struct S_DIF, struct S_DIF)) ;
+EXPORT double f15_D_DSS_DID(double p0, struct S_DID p1, struct S_DID p2,  double (*cb)(double, struct S_DID, struct S_DID)) ;
+EXPORT double f15_D_DSS_DIP(double p0, struct S_DIP p1, struct S_DIP p2,  double (*cb)(double, struct S_DIP, struct S_DIP)) ;
+EXPORT double f15_D_DSS_DFI(double p0, struct S_DFI p1, struct S_DFI p2,  double (*cb)(double, struct S_DFI, struct S_DFI)) ;
+EXPORT double f15_D_DSS_DFF(double p0, struct S_DFF p1, struct S_DFF p2,  double (*cb)(double, struct S_DFF, struct S_DFF)) ;
+EXPORT double f15_D_DSS_DFD(double p0, struct S_DFD p1, struct S_DFD p2,  double (*cb)(double, struct S_DFD, struct S_DFD)) ;
+EXPORT double f15_D_DSS_DFP(double p0, struct S_DFP p1, struct S_DFP p2,  double (*cb)(double, struct S_DFP, struct S_DFP)) ;
+EXPORT double f15_D_DSS_DDI(double p0, struct S_DDI p1, struct S_DDI p2,  double (*cb)(double, struct S_DDI, struct S_DDI)) ;
+EXPORT double f15_D_DSS_DDF(double p0, struct S_DDF p1, struct S_DDF p2,  double (*cb)(double, struct S_DDF, struct S_DDF)) ;
+EXPORT double f15_D_DSS_DDD(double p0, struct S_DDD p1, struct S_DDD p2,  double (*cb)(double, struct S_DDD, struct S_DDD)) ;
+EXPORT double f15_D_DSS_DDP(double p0, struct S_DDP p1, struct S_DDP p2,  double (*cb)(double, struct S_DDP, struct S_DDP)) ;
+EXPORT double f15_D_DSS_DPI(double p0, struct S_DPI p1, struct S_DPI p2,  double (*cb)(double, struct S_DPI, struct S_DPI)) ;
+EXPORT double f15_D_DSS_DPF(double p0, struct S_DPF p1, struct S_DPF p2,  double (*cb)(double, struct S_DPF, struct S_DPF)) ;
+EXPORT double f15_D_DSS_DPD(double p0, struct S_DPD p1, struct S_DPD p2,  double (*cb)(double, struct S_DPD, struct S_DPD)) ;
+EXPORT double f15_D_DSS_DPP(double p0, struct S_DPP p1, struct S_DPP p2,  double (*cb)(double, struct S_DPP, struct S_DPP)) ;
+EXPORT double f15_D_DSS_PII(double p0, struct S_PII p1, struct S_PII p2,  double (*cb)(double, struct S_PII, struct S_PII)) ;
+EXPORT double f15_D_DSS_PIF(double p0, struct S_PIF p1, struct S_PIF p2,  double (*cb)(double, struct S_PIF, struct S_PIF)) ;
+EXPORT double f15_D_DSS_PID(double p0, struct S_PID p1, struct S_PID p2,  double (*cb)(double, struct S_PID, struct S_PID)) ;
+EXPORT double f15_D_DSS_PIP(double p0, struct S_PIP p1, struct S_PIP p2,  double (*cb)(double, struct S_PIP, struct S_PIP)) ;
+EXPORT double f15_D_DSS_PFI(double p0, struct S_PFI p1, struct S_PFI p2,  double (*cb)(double, struct S_PFI, struct S_PFI)) ;
+EXPORT double f15_D_DSS_PFF(double p0, struct S_PFF p1, struct S_PFF p2,  double (*cb)(double, struct S_PFF, struct S_PFF)) ;
+EXPORT double f15_D_DSS_PFD(double p0, struct S_PFD p1, struct S_PFD p2,  double (*cb)(double, struct S_PFD, struct S_PFD)) ;
+EXPORT double f15_D_DSS_PFP(double p0, struct S_PFP p1, struct S_PFP p2,  double (*cb)(double, struct S_PFP, struct S_PFP)) ;
+EXPORT double f15_D_DSS_PDI(double p0, struct S_PDI p1, struct S_PDI p2,  double (*cb)(double, struct S_PDI, struct S_PDI)) ;
+EXPORT double f15_D_DSS_PDF(double p0, struct S_PDF p1, struct S_PDF p2,  double (*cb)(double, struct S_PDF, struct S_PDF)) ;
+EXPORT double f15_D_DSS_PDD(double p0, struct S_PDD p1, struct S_PDD p2,  double (*cb)(double, struct S_PDD, struct S_PDD)) ;
+EXPORT double f15_D_DSS_PDP(double p0, struct S_PDP p1, struct S_PDP p2,  double (*cb)(double, struct S_PDP, struct S_PDP)) ;
+EXPORT double f15_D_DSS_PPI(double p0, struct S_PPI p1, struct S_PPI p2,  double (*cb)(double, struct S_PPI, struct S_PPI)) ;
+EXPORT double f15_D_DSS_PPF(double p0, struct S_PPF p1, struct S_PPF p2,  double (*cb)(double, struct S_PPF, struct S_PPF)) ;
+EXPORT double f15_D_DSS_PPD(double p0, struct S_PPD p1, struct S_PPD p2,  double (*cb)(double, struct S_PPD, struct S_PPD)) ;
+EXPORT double f15_D_DSS_PPP(double p0, struct S_PPP p1, struct S_PPP p2,  double (*cb)(double, struct S_PPP, struct S_PPP)) ;
+EXPORT void* f15_P_PII_(void* p0, int p1, int p2,  void* (*cb)(void*, int, int)) ;
+EXPORT void* f15_P_PIF_(void* p0, int p1, float p2,  void* (*cb)(void*, int, float)) ;
+EXPORT void* f15_P_PID_(void* p0, int p1, double p2,  void* (*cb)(void*, int, double)) ;
+EXPORT void* f15_P_PIP_(void* p0, int p1, void* p2,  void* (*cb)(void*, int, void*)) ;
+EXPORT void* f15_P_PIS_I(void* p0, int p1, struct S_I p2,  void* (*cb)(void*, int, struct S_I)) ;
+EXPORT void* f15_P_PIS_F(void* p0, int p1, struct S_F p2,  void* (*cb)(void*, int, struct S_F)) ;
+EXPORT void* f15_P_PIS_D(void* p0, int p1, struct S_D p2,  void* (*cb)(void*, int, struct S_D)) ;
+EXPORT void* f15_P_PIS_P(void* p0, int p1, struct S_P p2,  void* (*cb)(void*, int, struct S_P)) ;
+EXPORT void* f15_P_PIS_II(void* p0, int p1, struct S_II p2,  void* (*cb)(void*, int, struct S_II)) ;
+EXPORT void* f15_P_PIS_IF(void* p0, int p1, struct S_IF p2,  void* (*cb)(void*, int, struct S_IF)) ;
+EXPORT void* f15_P_PIS_ID(void* p0, int p1, struct S_ID p2,  void* (*cb)(void*, int, struct S_ID)) ;
+EXPORT void* f15_P_PIS_IP(void* p0, int p1, struct S_IP p2,  void* (*cb)(void*, int, struct S_IP)) ;
+EXPORT void* f15_P_PIS_FI(void* p0, int p1, struct S_FI p2,  void* (*cb)(void*, int, struct S_FI)) ;
+EXPORT void* f15_P_PIS_FF(void* p0, int p1, struct S_FF p2,  void* (*cb)(void*, int, struct S_FF)) ;
+EXPORT void* f15_P_PIS_FD(void* p0, int p1, struct S_FD p2,  void* (*cb)(void*, int, struct S_FD)) ;
+EXPORT void* f15_P_PIS_FP(void* p0, int p1, struct S_FP p2,  void* (*cb)(void*, int, struct S_FP)) ;
+EXPORT void* f15_P_PIS_DI(void* p0, int p1, struct S_DI p2,  void* (*cb)(void*, int, struct S_DI)) ;
+EXPORT void* f15_P_PIS_DF(void* p0, int p1, struct S_DF p2,  void* (*cb)(void*, int, struct S_DF)) ;
+EXPORT void* f15_P_PIS_DD(void* p0, int p1, struct S_DD p2,  void* (*cb)(void*, int, struct S_DD)) ;
+EXPORT void* f15_P_PIS_DP(void* p0, int p1, struct S_DP p2,  void* (*cb)(void*, int, struct S_DP)) ;
+EXPORT void* f15_P_PIS_PI(void* p0, int p1, struct S_PI p2,  void* (*cb)(void*, int, struct S_PI)) ;
+EXPORT void* f15_P_PIS_PF(void* p0, int p1, struct S_PF p2,  void* (*cb)(void*, int, struct S_PF)) ;
+EXPORT void* f15_P_PIS_PD(void* p0, int p1, struct S_PD p2,  void* (*cb)(void*, int, struct S_PD)) ;
+EXPORT void* f15_P_PIS_PP(void* p0, int p1, struct S_PP p2,  void* (*cb)(void*, int, struct S_PP)) ;
+EXPORT void* f15_P_PIS_III(void* p0, int p1, struct S_III p2,  void* (*cb)(void*, int, struct S_III)) ;
+EXPORT void* f15_P_PIS_IIF(void* p0, int p1, struct S_IIF p2,  void* (*cb)(void*, int, struct S_IIF)) ;
+EXPORT void* f15_P_PIS_IID(void* p0, int p1, struct S_IID p2,  void* (*cb)(void*, int, struct S_IID)) ;
+EXPORT void* f15_P_PIS_IIP(void* p0, int p1, struct S_IIP p2,  void* (*cb)(void*, int, struct S_IIP)) ;
+EXPORT void* f15_P_PIS_IFI(void* p0, int p1, struct S_IFI p2,  void* (*cb)(void*, int, struct S_IFI)) ;
+EXPORT void* f15_P_PIS_IFF(void* p0, int p1, struct S_IFF p2,  void* (*cb)(void*, int, struct S_IFF)) ;
+EXPORT void* f15_P_PIS_IFD(void* p0, int p1, struct S_IFD p2,  void* (*cb)(void*, int, struct S_IFD)) ;
+EXPORT void* f15_P_PIS_IFP(void* p0, int p1, struct S_IFP p2,  void* (*cb)(void*, int, struct S_IFP)) ;
+EXPORT void* f15_P_PIS_IDI(void* p0, int p1, struct S_IDI p2,  void* (*cb)(void*, int, struct S_IDI)) ;
+EXPORT void* f15_P_PIS_IDF(void* p0, int p1, struct S_IDF p2,  void* (*cb)(void*, int, struct S_IDF)) ;
+EXPORT void* f15_P_PIS_IDD(void* p0, int p1, struct S_IDD p2,  void* (*cb)(void*, int, struct S_IDD)) ;
+EXPORT void* f15_P_PIS_IDP(void* p0, int p1, struct S_IDP p2,  void* (*cb)(void*, int, struct S_IDP)) ;
+EXPORT void* f15_P_PIS_IPI(void* p0, int p1, struct S_IPI p2,  void* (*cb)(void*, int, struct S_IPI)) ;
+EXPORT void* f15_P_PIS_IPF(void* p0, int p1, struct S_IPF p2,  void* (*cb)(void*, int, struct S_IPF)) ;
+EXPORT void* f15_P_PIS_IPD(void* p0, int p1, struct S_IPD p2,  void* (*cb)(void*, int, struct S_IPD)) ;
+EXPORT void* f15_P_PIS_IPP(void* p0, int p1, struct S_IPP p2,  void* (*cb)(void*, int, struct S_IPP)) ;
+EXPORT void* f15_P_PIS_FII(void* p0, int p1, struct S_FII p2,  void* (*cb)(void*, int, struct S_FII)) ;
+EXPORT void* f15_P_PIS_FIF(void* p0, int p1, struct S_FIF p2,  void* (*cb)(void*, int, struct S_FIF)) ;
+EXPORT void* f15_P_PIS_FID(void* p0, int p1, struct S_FID p2,  void* (*cb)(void*, int, struct S_FID)) ;
+EXPORT void* f15_P_PIS_FIP(void* p0, int p1, struct S_FIP p2,  void* (*cb)(void*, int, struct S_FIP)) ;
+EXPORT void* f15_P_PIS_FFI(void* p0, int p1, struct S_FFI p2,  void* (*cb)(void*, int, struct S_FFI)) ;
+EXPORT void* f15_P_PIS_FFF(void* p0, int p1, struct S_FFF p2,  void* (*cb)(void*, int, struct S_FFF)) ;
+EXPORT void* f15_P_PIS_FFD(void* p0, int p1, struct S_FFD p2,  void* (*cb)(void*, int, struct S_FFD)) ;
+EXPORT void* f15_P_PIS_FFP(void* p0, int p1, struct S_FFP p2,  void* (*cb)(void*, int, struct S_FFP)) ;
+EXPORT void* f15_P_PIS_FDI(void* p0, int p1, struct S_FDI p2,  void* (*cb)(void*, int, struct S_FDI)) ;
+EXPORT void* f15_P_PIS_FDF(void* p0, int p1, struct S_FDF p2,  void* (*cb)(void*, int, struct S_FDF)) ;
+EXPORT void* f15_P_PIS_FDD(void* p0, int p1, struct S_FDD p2,  void* (*cb)(void*, int, struct S_FDD)) ;
+EXPORT void* f15_P_PIS_FDP(void* p0, int p1, struct S_FDP p2,  void* (*cb)(void*, int, struct S_FDP)) ;
+EXPORT void* f15_P_PIS_FPI(void* p0, int p1, struct S_FPI p2,  void* (*cb)(void*, int, struct S_FPI)) ;
+EXPORT void* f15_P_PIS_FPF(void* p0, int p1, struct S_FPF p2,  void* (*cb)(void*, int, struct S_FPF)) ;
+EXPORT void* f15_P_PIS_FPD(void* p0, int p1, struct S_FPD p2,  void* (*cb)(void*, int, struct S_FPD)) ;
+EXPORT void* f15_P_PIS_FPP(void* p0, int p1, struct S_FPP p2,  void* (*cb)(void*, int, struct S_FPP)) ;
+EXPORT void* f15_P_PIS_DII(void* p0, int p1, struct S_DII p2,  void* (*cb)(void*, int, struct S_DII)) ;
+EXPORT void* f15_P_PIS_DIF(void* p0, int p1, struct S_DIF p2,  void* (*cb)(void*, int, struct S_DIF)) ;
+EXPORT void* f15_P_PIS_DID(void* p0, int p1, struct S_DID p2,  void* (*cb)(void*, int, struct S_DID)) ;
+EXPORT void* f15_P_PIS_DIP(void* p0, int p1, struct S_DIP p2,  void* (*cb)(void*, int, struct S_DIP)) ;
+EXPORT void* f15_P_PIS_DFI(void* p0, int p1, struct S_DFI p2,  void* (*cb)(void*, int, struct S_DFI)) ;
+EXPORT void* f15_P_PIS_DFF(void* p0, int p1, struct S_DFF p2,  void* (*cb)(void*, int, struct S_DFF)) ;
+EXPORT void* f15_P_PIS_DFD(void* p0, int p1, struct S_DFD p2,  void* (*cb)(void*, int, struct S_DFD)) ;
+EXPORT void* f15_P_PIS_DFP(void* p0, int p1, struct S_DFP p2,  void* (*cb)(void*, int, struct S_DFP)) ;
+EXPORT void* f15_P_PIS_DDI(void* p0, int p1, struct S_DDI p2,  void* (*cb)(void*, int, struct S_DDI)) ;
+EXPORT void* f15_P_PIS_DDF(void* p0, int p1, struct S_DDF p2,  void* (*cb)(void*, int, struct S_DDF)) ;
+EXPORT void* f15_P_PIS_DDD(void* p0, int p1, struct S_DDD p2,  void* (*cb)(void*, int, struct S_DDD)) ;
+EXPORT void* f15_P_PIS_DDP(void* p0, int p1, struct S_DDP p2,  void* (*cb)(void*, int, struct S_DDP)) ;
+EXPORT void* f15_P_PIS_DPI(void* p0, int p1, struct S_DPI p2,  void* (*cb)(void*, int, struct S_DPI)) ;
+EXPORT void* f15_P_PIS_DPF(void* p0, int p1, struct S_DPF p2,  void* (*cb)(void*, int, struct S_DPF)) ;
+EXPORT void* f15_P_PIS_DPD(void* p0, int p1, struct S_DPD p2,  void* (*cb)(void*, int, struct S_DPD)) ;
+EXPORT void* f15_P_PIS_DPP(void* p0, int p1, struct S_DPP p2,  void* (*cb)(void*, int, struct S_DPP)) ;
+EXPORT void* f15_P_PIS_PII(void* p0, int p1, struct S_PII p2,  void* (*cb)(void*, int, struct S_PII)) ;
+EXPORT void* f15_P_PIS_PIF(void* p0, int p1, struct S_PIF p2,  void* (*cb)(void*, int, struct S_PIF)) ;
+EXPORT void* f15_P_PIS_PID(void* p0, int p1, struct S_PID p2,  void* (*cb)(void*, int, struct S_PID)) ;
+EXPORT void* f15_P_PIS_PIP(void* p0, int p1, struct S_PIP p2,  void* (*cb)(void*, int, struct S_PIP)) ;
+EXPORT void* f15_P_PIS_PFI(void* p0, int p1, struct S_PFI p2,  void* (*cb)(void*, int, struct S_PFI)) ;
+EXPORT void* f15_P_PIS_PFF(void* p0, int p1, struct S_PFF p2,  void* (*cb)(void*, int, struct S_PFF)) ;
+EXPORT void* f15_P_PIS_PFD(void* p0, int p1, struct S_PFD p2,  void* (*cb)(void*, int, struct S_PFD)) ;
+EXPORT void* f15_P_PIS_PFP(void* p0, int p1, struct S_PFP p2,  void* (*cb)(void*, int, struct S_PFP)) ;
+EXPORT void* f15_P_PIS_PDI(void* p0, int p1, struct S_PDI p2,  void* (*cb)(void*, int, struct S_PDI)) ;
+EXPORT void* f15_P_PIS_PDF(void* p0, int p1, struct S_PDF p2,  void* (*cb)(void*, int, struct S_PDF)) ;
+EXPORT void* f15_P_PIS_PDD(void* p0, int p1, struct S_PDD p2,  void* (*cb)(void*, int, struct S_PDD)) ;
+EXPORT void* f15_P_PIS_PDP(void* p0, int p1, struct S_PDP p2,  void* (*cb)(void*, int, struct S_PDP)) ;
+EXPORT void* f15_P_PIS_PPI(void* p0, int p1, struct S_PPI p2,  void* (*cb)(void*, int, struct S_PPI)) ;
+EXPORT void* f15_P_PIS_PPF(void* p0, int p1, struct S_PPF p2,  void* (*cb)(void*, int, struct S_PPF)) ;
+EXPORT void* f15_P_PIS_PPD(void* p0, int p1, struct S_PPD p2,  void* (*cb)(void*, int, struct S_PPD)) ;
+EXPORT void* f15_P_PIS_PPP(void* p0, int p1, struct S_PPP p2,  void* (*cb)(void*, int, struct S_PPP)) ;
+EXPORT void* f15_P_PFI_(void* p0, float p1, int p2,  void* (*cb)(void*, float, int)) ;
+EXPORT void* f15_P_PFF_(void* p0, float p1, float p2,  void* (*cb)(void*, float, float)) ;
+EXPORT void* f15_P_PFD_(void* p0, float p1, double p2,  void* (*cb)(void*, float, double)) ;
+EXPORT void* f15_P_PFP_(void* p0, float p1, void* p2,  void* (*cb)(void*, float, void*)) ;
+EXPORT void* f15_P_PFS_I(void* p0, float p1, struct S_I p2,  void* (*cb)(void*, float, struct S_I)) ;
+EXPORT void* f15_P_PFS_F(void* p0, float p1, struct S_F p2,  void* (*cb)(void*, float, struct S_F)) ;
+EXPORT void* f15_P_PFS_D(void* p0, float p1, struct S_D p2,  void* (*cb)(void*, float, struct S_D)) ;
+EXPORT void* f15_P_PFS_P(void* p0, float p1, struct S_P p2,  void* (*cb)(void*, float, struct S_P)) ;
+EXPORT void* f15_P_PFS_II(void* p0, float p1, struct S_II p2,  void* (*cb)(void*, float, struct S_II)) ;
+EXPORT void* f15_P_PFS_IF(void* p0, float p1, struct S_IF p2,  void* (*cb)(void*, float, struct S_IF)) ;
+EXPORT void* f15_P_PFS_ID(void* p0, float p1, struct S_ID p2,  void* (*cb)(void*, float, struct S_ID)) ;
+EXPORT void* f15_P_PFS_IP(void* p0, float p1, struct S_IP p2,  void* (*cb)(void*, float, struct S_IP)) ;
+EXPORT void* f15_P_PFS_FI(void* p0, float p1, struct S_FI p2,  void* (*cb)(void*, float, struct S_FI)) ;
+EXPORT void* f15_P_PFS_FF(void* p0, float p1, struct S_FF p2,  void* (*cb)(void*, float, struct S_FF)) ;
+EXPORT void* f15_P_PFS_FD(void* p0, float p1, struct S_FD p2,  void* (*cb)(void*, float, struct S_FD)) ;
+EXPORT void* f15_P_PFS_FP(void* p0, float p1, struct S_FP p2,  void* (*cb)(void*, float, struct S_FP)) ;
+EXPORT void* f15_P_PFS_DI(void* p0, float p1, struct S_DI p2,  void* (*cb)(void*, float, struct S_DI)) ;
+EXPORT void* f15_P_PFS_DF(void* p0, float p1, struct S_DF p2,  void* (*cb)(void*, float, struct S_DF)) ;
+EXPORT void* f15_P_PFS_DD(void* p0, float p1, struct S_DD p2,  void* (*cb)(void*, float, struct S_DD)) ;
+EXPORT void* f15_P_PFS_DP(void* p0, float p1, struct S_DP p2,  void* (*cb)(void*, float, struct S_DP)) ;
+EXPORT void* f15_P_PFS_PI(void* p0, float p1, struct S_PI p2,  void* (*cb)(void*, float, struct S_PI)) ;
+EXPORT void* f15_P_PFS_PF(void* p0, float p1, struct S_PF p2,  void* (*cb)(void*, float, struct S_PF)) ;
+EXPORT void* f15_P_PFS_PD(void* p0, float p1, struct S_PD p2,  void* (*cb)(void*, float, struct S_PD)) ;
+EXPORT void* f15_P_PFS_PP(void* p0, float p1, struct S_PP p2,  void* (*cb)(void*, float, struct S_PP)) ;
+EXPORT void* f15_P_PFS_III(void* p0, float p1, struct S_III p2,  void* (*cb)(void*, float, struct S_III)) ;
+EXPORT void* f15_P_PFS_IIF(void* p0, float p1, struct S_IIF p2,  void* (*cb)(void*, float, struct S_IIF)) ;
+EXPORT void* f15_P_PFS_IID(void* p0, float p1, struct S_IID p2,  void* (*cb)(void*, float, struct S_IID)) ;
+EXPORT void* f15_P_PFS_IIP(void* p0, float p1, struct S_IIP p2,  void* (*cb)(void*, float, struct S_IIP)) ;
+EXPORT void* f15_P_PFS_IFI(void* p0, float p1, struct S_IFI p2,  void* (*cb)(void*, float, struct S_IFI)) ;
+EXPORT void* f15_P_PFS_IFF(void* p0, float p1, struct S_IFF p2,  void* (*cb)(void*, float, struct S_IFF)) ;
+EXPORT void* f15_P_PFS_IFD(void* p0, float p1, struct S_IFD p2,  void* (*cb)(void*, float, struct S_IFD)) ;
+EXPORT void* f15_P_PFS_IFP(void* p0, float p1, struct S_IFP p2,  void* (*cb)(void*, float, struct S_IFP)) ;
+EXPORT void* f15_P_PFS_IDI(void* p0, float p1, struct S_IDI p2,  void* (*cb)(void*, float, struct S_IDI)) ;
+EXPORT void* f15_P_PFS_IDF(void* p0, float p1, struct S_IDF p2,  void* (*cb)(void*, float, struct S_IDF)) ;
+EXPORT void* f15_P_PFS_IDD(void* p0, float p1, struct S_IDD p2,  void* (*cb)(void*, float, struct S_IDD)) ;
+EXPORT void* f15_P_PFS_IDP(void* p0, float p1, struct S_IDP p2,  void* (*cb)(void*, float, struct S_IDP)) ;
+EXPORT void* f15_P_PFS_IPI(void* p0, float p1, struct S_IPI p2,  void* (*cb)(void*, float, struct S_IPI)) ;
+EXPORT void* f15_P_PFS_IPF(void* p0, float p1, struct S_IPF p2,  void* (*cb)(void*, float, struct S_IPF)) ;
+EXPORT void* f15_P_PFS_IPD(void* p0, float p1, struct S_IPD p2,  void* (*cb)(void*, float, struct S_IPD)) ;
+EXPORT void* f15_P_PFS_IPP(void* p0, float p1, struct S_IPP p2,  void* (*cb)(void*, float, struct S_IPP)) ;
+EXPORT void* f15_P_PFS_FII(void* p0, float p1, struct S_FII p2,  void* (*cb)(void*, float, struct S_FII)) ;
+EXPORT void* f15_P_PFS_FIF(void* p0, float p1, struct S_FIF p2,  void* (*cb)(void*, float, struct S_FIF)) ;
+EXPORT void* f15_P_PFS_FID(void* p0, float p1, struct S_FID p2,  void* (*cb)(void*, float, struct S_FID)) ;
+EXPORT void* f15_P_PFS_FIP(void* p0, float p1, struct S_FIP p2,  void* (*cb)(void*, float, struct S_FIP)) ;
+EXPORT void* f15_P_PFS_FFI(void* p0, float p1, struct S_FFI p2,  void* (*cb)(void*, float, struct S_FFI)) ;
+EXPORT void* f15_P_PFS_FFF(void* p0, float p1, struct S_FFF p2,  void* (*cb)(void*, float, struct S_FFF)) ;
+EXPORT void* f15_P_PFS_FFD(void* p0, float p1, struct S_FFD p2,  void* (*cb)(void*, float, struct S_FFD)) ;
+EXPORT void* f15_P_PFS_FFP(void* p0, float p1, struct S_FFP p2,  void* (*cb)(void*, float, struct S_FFP)) ;
+EXPORT void* f15_P_PFS_FDI(void* p0, float p1, struct S_FDI p2,  void* (*cb)(void*, float, struct S_FDI)) ;
+EXPORT void* f15_P_PFS_FDF(void* p0, float p1, struct S_FDF p2,  void* (*cb)(void*, float, struct S_FDF)) ;
+EXPORT void* f15_P_PFS_FDD(void* p0, float p1, struct S_FDD p2,  void* (*cb)(void*, float, struct S_FDD)) ;
+EXPORT void* f15_P_PFS_FDP(void* p0, float p1, struct S_FDP p2,  void* (*cb)(void*, float, struct S_FDP)) ;
+EXPORT void* f15_P_PFS_FPI(void* p0, float p1, struct S_FPI p2,  void* (*cb)(void*, float, struct S_FPI)) ;
+EXPORT void* f15_P_PFS_FPF(void* p0, float p1, struct S_FPF p2,  void* (*cb)(void*, float, struct S_FPF)) ;
+EXPORT void* f15_P_PFS_FPD(void* p0, float p1, struct S_FPD p2,  void* (*cb)(void*, float, struct S_FPD)) ;
+EXPORT void* f15_P_PFS_FPP(void* p0, float p1, struct S_FPP p2,  void* (*cb)(void*, float, struct S_FPP)) ;
+EXPORT void* f15_P_PFS_DII(void* p0, float p1, struct S_DII p2,  void* (*cb)(void*, float, struct S_DII)) ;
+EXPORT void* f15_P_PFS_DIF(void* p0, float p1, struct S_DIF p2,  void* (*cb)(void*, float, struct S_DIF)) ;
+EXPORT void* f15_P_PFS_DID(void* p0, float p1, struct S_DID p2,  void* (*cb)(void*, float, struct S_DID)) ;
+EXPORT void* f15_P_PFS_DIP(void* p0, float p1, struct S_DIP p2,  void* (*cb)(void*, float, struct S_DIP)) ;
+EXPORT void* f15_P_PFS_DFI(void* p0, float p1, struct S_DFI p2,  void* (*cb)(void*, float, struct S_DFI)) ;
+EXPORT void* f15_P_PFS_DFF(void* p0, float p1, struct S_DFF p2,  void* (*cb)(void*, float, struct S_DFF)) ;
+EXPORT void* f15_P_PFS_DFD(void* p0, float p1, struct S_DFD p2,  void* (*cb)(void*, float, struct S_DFD)) ;
+EXPORT void* f15_P_PFS_DFP(void* p0, float p1, struct S_DFP p2,  void* (*cb)(void*, float, struct S_DFP)) ;
+EXPORT void* f15_P_PFS_DDI(void* p0, float p1, struct S_DDI p2,  void* (*cb)(void*, float, struct S_DDI)) ;
+EXPORT void* f15_P_PFS_DDF(void* p0, float p1, struct S_DDF p2,  void* (*cb)(void*, float, struct S_DDF)) ;
+EXPORT void* f15_P_PFS_DDD(void* p0, float p1, struct S_DDD p2,  void* (*cb)(void*, float, struct S_DDD)) ;
+EXPORT void* f15_P_PFS_DDP(void* p0, float p1, struct S_DDP p2,  void* (*cb)(void*, float, struct S_DDP)) ;
+EXPORT void* f15_P_PFS_DPI(void* p0, float p1, struct S_DPI p2,  void* (*cb)(void*, float, struct S_DPI)) ;
+EXPORT void* f15_P_PFS_DPF(void* p0, float p1, struct S_DPF p2,  void* (*cb)(void*, float, struct S_DPF)) ;
+EXPORT void* f15_P_PFS_DPD(void* p0, float p1, struct S_DPD p2,  void* (*cb)(void*, float, struct S_DPD)) ;
+EXPORT void* f15_P_PFS_DPP(void* p0, float p1, struct S_DPP p2,  void* (*cb)(void*, float, struct S_DPP)) ;
+EXPORT void* f15_P_PFS_PII(void* p0, float p1, struct S_PII p2,  void* (*cb)(void*, float, struct S_PII)) ;
+EXPORT void* f15_P_PFS_PIF(void* p0, float p1, struct S_PIF p2,  void* (*cb)(void*, float, struct S_PIF)) ;
+EXPORT void* f15_P_PFS_PID(void* p0, float p1, struct S_PID p2,  void* (*cb)(void*, float, struct S_PID)) ;
+EXPORT void* f15_P_PFS_PIP(void* p0, float p1, struct S_PIP p2,  void* (*cb)(void*, float, struct S_PIP)) ;
+EXPORT void* f15_P_PFS_PFI(void* p0, float p1, struct S_PFI p2,  void* (*cb)(void*, float, struct S_PFI)) ;
+EXPORT void* f15_P_PFS_PFF(void* p0, float p1, struct S_PFF p2,  void* (*cb)(void*, float, struct S_PFF)) ;
+EXPORT void* f15_P_PFS_PFD(void* p0, float p1, struct S_PFD p2,  void* (*cb)(void*, float, struct S_PFD)) ;
+EXPORT void* f15_P_PFS_PFP(void* p0, float p1, struct S_PFP p2,  void* (*cb)(void*, float, struct S_PFP)) ;
+EXPORT void* f15_P_PFS_PDI(void* p0, float p1, struct S_PDI p2,  void* (*cb)(void*, float, struct S_PDI)) ;
+EXPORT void* f15_P_PFS_PDF(void* p0, float p1, struct S_PDF p2,  void* (*cb)(void*, float, struct S_PDF)) ;
+EXPORT void* f15_P_PFS_PDD(void* p0, float p1, struct S_PDD p2,  void* (*cb)(void*, float, struct S_PDD)) ;
+EXPORT void* f15_P_PFS_PDP(void* p0, float p1, struct S_PDP p2,  void* (*cb)(void*, float, struct S_PDP)) ;
+EXPORT void* f15_P_PFS_PPI(void* p0, float p1, struct S_PPI p2,  void* (*cb)(void*, float, struct S_PPI)) ;
+EXPORT void* f15_P_PFS_PPF(void* p0, float p1, struct S_PPF p2,  void* (*cb)(void*, float, struct S_PPF)) ;
+EXPORT void* f15_P_PFS_PPD(void* p0, float p1, struct S_PPD p2,  void* (*cb)(void*, float, struct S_PPD)) ;
+EXPORT void* f15_P_PFS_PPP(void* p0, float p1, struct S_PPP p2,  void* (*cb)(void*, float, struct S_PPP)) ;
+EXPORT void* f15_P_PDI_(void* p0, double p1, int p2,  void* (*cb)(void*, double, int)) ;
+EXPORT void* f15_P_PDF_(void* p0, double p1, float p2,  void* (*cb)(void*, double, float)) ;
+EXPORT void* f15_P_PDD_(void* p0, double p1, double p2,  void* (*cb)(void*, double, double)) ;
+EXPORT void* f15_P_PDP_(void* p0, double p1, void* p2,  void* (*cb)(void*, double, void*)) ;
+EXPORT void* f15_P_PDS_I(void* p0, double p1, struct S_I p2,  void* (*cb)(void*, double, struct S_I)) ;
+EXPORT void* f15_P_PDS_F(void* p0, double p1, struct S_F p2,  void* (*cb)(void*, double, struct S_F)) ;
+EXPORT void* f15_P_PDS_D(void* p0, double p1, struct S_D p2,  void* (*cb)(void*, double, struct S_D)) ;
+EXPORT void* f15_P_PDS_P(void* p0, double p1, struct S_P p2,  void* (*cb)(void*, double, struct S_P)) ;
+EXPORT void* f15_P_PDS_II(void* p0, double p1, struct S_II p2,  void* (*cb)(void*, double, struct S_II)) ;
+EXPORT void* f15_P_PDS_IF(void* p0, double p1, struct S_IF p2,  void* (*cb)(void*, double, struct S_IF)) ;
+EXPORT void* f15_P_PDS_ID(void* p0, double p1, struct S_ID p2,  void* (*cb)(void*, double, struct S_ID)) ;
+EXPORT void* f15_P_PDS_IP(void* p0, double p1, struct S_IP p2,  void* (*cb)(void*, double, struct S_IP)) ;
+EXPORT void* f15_P_PDS_FI(void* p0, double p1, struct S_FI p2,  void* (*cb)(void*, double, struct S_FI)) ;
+EXPORT void* f15_P_PDS_FF(void* p0, double p1, struct S_FF p2,  void* (*cb)(void*, double, struct S_FF)) ;
+EXPORT void* f15_P_PDS_FD(void* p0, double p1, struct S_FD p2,  void* (*cb)(void*, double, struct S_FD)) ;
+EXPORT void* f15_P_PDS_FP(void* p0, double p1, struct S_FP p2,  void* (*cb)(void*, double, struct S_FP)) ;
+EXPORT void* f15_P_PDS_DI(void* p0, double p1, struct S_DI p2,  void* (*cb)(void*, double, struct S_DI)) ;
+EXPORT void* f15_P_PDS_DF(void* p0, double p1, struct S_DF p2,  void* (*cb)(void*, double, struct S_DF)) ;
+EXPORT void* f15_P_PDS_DD(void* p0, double p1, struct S_DD p2,  void* (*cb)(void*, double, struct S_DD)) ;
+EXPORT void* f15_P_PDS_DP(void* p0, double p1, struct S_DP p2,  void* (*cb)(void*, double, struct S_DP)) ;
+EXPORT void* f15_P_PDS_PI(void* p0, double p1, struct S_PI p2,  void* (*cb)(void*, double, struct S_PI)) ;
+EXPORT void* f15_P_PDS_PF(void* p0, double p1, struct S_PF p2,  void* (*cb)(void*, double, struct S_PF)) ;
+EXPORT void* f15_P_PDS_PD(void* p0, double p1, struct S_PD p2,  void* (*cb)(void*, double, struct S_PD)) ;
+EXPORT void* f15_P_PDS_PP(void* p0, double p1, struct S_PP p2,  void* (*cb)(void*, double, struct S_PP)) ;
+EXPORT void* f15_P_PDS_III(void* p0, double p1, struct S_III p2,  void* (*cb)(void*, double, struct S_III)) ;
+EXPORT void* f15_P_PDS_IIF(void* p0, double p1, struct S_IIF p2,  void* (*cb)(void*, double, struct S_IIF)) ;
+EXPORT void* f15_P_PDS_IID(void* p0, double p1, struct S_IID p2,  void* (*cb)(void*, double, struct S_IID)) ;
+EXPORT void* f15_P_PDS_IIP(void* p0, double p1, struct S_IIP p2,  void* (*cb)(void*, double, struct S_IIP)) ;
+EXPORT void* f15_P_PDS_IFI(void* p0, double p1, struct S_IFI p2,  void* (*cb)(void*, double, struct S_IFI)) ;
+EXPORT void* f15_P_PDS_IFF(void* p0, double p1, struct S_IFF p2,  void* (*cb)(void*, double, struct S_IFF)) ;
+EXPORT void* f15_P_PDS_IFD(void* p0, double p1, struct S_IFD p2,  void* (*cb)(void*, double, struct S_IFD)) ;
+EXPORT void* f15_P_PDS_IFP(void* p0, double p1, struct S_IFP p2,  void* (*cb)(void*, double, struct S_IFP)) ;
+EXPORT void* f15_P_PDS_IDI(void* p0, double p1, struct S_IDI p2,  void* (*cb)(void*, double, struct S_IDI)) ;
+EXPORT void* f15_P_PDS_IDF(void* p0, double p1, struct S_IDF p2,  void* (*cb)(void*, double, struct S_IDF)) ;
+EXPORT void* f15_P_PDS_IDD(void* p0, double p1, struct S_IDD p2,  void* (*cb)(void*, double, struct S_IDD)) ;
+EXPORT void* f15_P_PDS_IDP(void* p0, double p1, struct S_IDP p2,  void* (*cb)(void*, double, struct S_IDP)) ;
+EXPORT void* f15_P_PDS_IPI(void* p0, double p1, struct S_IPI p2,  void* (*cb)(void*, double, struct S_IPI)) ;
+EXPORT void* f15_P_PDS_IPF(void* p0, double p1, struct S_IPF p2,  void* (*cb)(void*, double, struct S_IPF)) ;
+EXPORT void* f15_P_PDS_IPD(void* p0, double p1, struct S_IPD p2,  void* (*cb)(void*, double, struct S_IPD)) ;
+EXPORT void* f15_P_PDS_IPP(void* p0, double p1, struct S_IPP p2,  void* (*cb)(void*, double, struct S_IPP)) ;
+EXPORT void* f15_P_PDS_FII(void* p0, double p1, struct S_FII p2,  void* (*cb)(void*, double, struct S_FII)) ;
+EXPORT void* f15_P_PDS_FIF(void* p0, double p1, struct S_FIF p2,  void* (*cb)(void*, double, struct S_FIF)) ;
+EXPORT void* f15_P_PDS_FID(void* p0, double p1, struct S_FID p2,  void* (*cb)(void*, double, struct S_FID)) ;
+EXPORT void* f15_P_PDS_FIP(void* p0, double p1, struct S_FIP p2,  void* (*cb)(void*, double, struct S_FIP)) ;
+EXPORT void* f15_P_PDS_FFI(void* p0, double p1, struct S_FFI p2,  void* (*cb)(void*, double, struct S_FFI)) ;
+EXPORT void* f15_P_PDS_FFF(void* p0, double p1, struct S_FFF p2,  void* (*cb)(void*, double, struct S_FFF)) ;
+EXPORT void* f15_P_PDS_FFD(void* p0, double p1, struct S_FFD p2,  void* (*cb)(void*, double, struct S_FFD)) ;
+EXPORT void* f15_P_PDS_FFP(void* p0, double p1, struct S_FFP p2,  void* (*cb)(void*, double, struct S_FFP)) ;
+EXPORT void* f15_P_PDS_FDI(void* p0, double p1, struct S_FDI p2,  void* (*cb)(void*, double, struct S_FDI)) ;
+EXPORT void* f15_P_PDS_FDF(void* p0, double p1, struct S_FDF p2,  void* (*cb)(void*, double, struct S_FDF)) ;
+EXPORT void* f15_P_PDS_FDD(void* p0, double p1, struct S_FDD p2,  void* (*cb)(void*, double, struct S_FDD)) ;
+EXPORT void* f15_P_PDS_FDP(void* p0, double p1, struct S_FDP p2,  void* (*cb)(void*, double, struct S_FDP)) ;
+EXPORT void* f15_P_PDS_FPI(void* p0, double p1, struct S_FPI p2,  void* (*cb)(void*, double, struct S_FPI)) ;
+EXPORT void* f15_P_PDS_FPF(void* p0, double p1, struct S_FPF p2,  void* (*cb)(void*, double, struct S_FPF)) ;
+EXPORT void* f15_P_PDS_FPD(void* p0, double p1, struct S_FPD p2,  void* (*cb)(void*, double, struct S_FPD)) ;
+EXPORT void* f15_P_PDS_FPP(void* p0, double p1, struct S_FPP p2,  void* (*cb)(void*, double, struct S_FPP)) ;
+EXPORT void* f15_P_PDS_DII(void* p0, double p1, struct S_DII p2,  void* (*cb)(void*, double, struct S_DII)) ;
+EXPORT void* f15_P_PDS_DIF(void* p0, double p1, struct S_DIF p2,  void* (*cb)(void*, double, struct S_DIF)) ;
+EXPORT void* f15_P_PDS_DID(void* p0, double p1, struct S_DID p2,  void* (*cb)(void*, double, struct S_DID)) ;
+EXPORT void* f15_P_PDS_DIP(void* p0, double p1, struct S_DIP p2,  void* (*cb)(void*, double, struct S_DIP)) ;
+EXPORT void* f15_P_PDS_DFI(void* p0, double p1, struct S_DFI p2,  void* (*cb)(void*, double, struct S_DFI)) ;
+EXPORT void* f15_P_PDS_DFF(void* p0, double p1, struct S_DFF p2,  void* (*cb)(void*, double, struct S_DFF)) ;
+EXPORT void* f15_P_PDS_DFD(void* p0, double p1, struct S_DFD p2,  void* (*cb)(void*, double, struct S_DFD)) ;
+EXPORT void* f15_P_PDS_DFP(void* p0, double p1, struct S_DFP p2,  void* (*cb)(void*, double, struct S_DFP)) ;
+EXPORT void* f15_P_PDS_DDI(void* p0, double p1, struct S_DDI p2,  void* (*cb)(void*, double, struct S_DDI)) ;
+EXPORT void* f15_P_PDS_DDF(void* p0, double p1, struct S_DDF p2,  void* (*cb)(void*, double, struct S_DDF)) ;
+EXPORT void* f15_P_PDS_DDD(void* p0, double p1, struct S_DDD p2,  void* (*cb)(void*, double, struct S_DDD)) ;
+EXPORT void* f15_P_PDS_DDP(void* p0, double p1, struct S_DDP p2,  void* (*cb)(void*, double, struct S_DDP)) ;
+EXPORT void* f15_P_PDS_DPI(void* p0, double p1, struct S_DPI p2,  void* (*cb)(void*, double, struct S_DPI)) ;
+EXPORT void* f15_P_PDS_DPF(void* p0, double p1, struct S_DPF p2,  void* (*cb)(void*, double, struct S_DPF)) ;
+EXPORT void* f15_P_PDS_DPD(void* p0, double p1, struct S_DPD p2,  void* (*cb)(void*, double, struct S_DPD)) ;
+EXPORT void* f15_P_PDS_DPP(void* p0, double p1, struct S_DPP p2,  void* (*cb)(void*, double, struct S_DPP)) ;
+EXPORT void* f15_P_PDS_PII(void* p0, double p1, struct S_PII p2,  void* (*cb)(void*, double, struct S_PII)) ;
+EXPORT void* f15_P_PDS_PIF(void* p0, double p1, struct S_PIF p2,  void* (*cb)(void*, double, struct S_PIF)) ;
+EXPORT void* f15_P_PDS_PID(void* p0, double p1, struct S_PID p2,  void* (*cb)(void*, double, struct S_PID)) ;
+EXPORT void* f15_P_PDS_PIP(void* p0, double p1, struct S_PIP p2,  void* (*cb)(void*, double, struct S_PIP)) ;
+EXPORT void* f15_P_PDS_PFI(void* p0, double p1, struct S_PFI p2,  void* (*cb)(void*, double, struct S_PFI)) ;
+EXPORT void* f15_P_PDS_PFF(void* p0, double p1, struct S_PFF p2,  void* (*cb)(void*, double, struct S_PFF)) ;
+EXPORT void* f15_P_PDS_PFD(void* p0, double p1, struct S_PFD p2,  void* (*cb)(void*, double, struct S_PFD)) ;
+EXPORT void* f15_P_PDS_PFP(void* p0, double p1, struct S_PFP p2,  void* (*cb)(void*, double, struct S_PFP)) ;
+EXPORT void* f15_P_PDS_PDI(void* p0, double p1, struct S_PDI p2,  void* (*cb)(void*, double, struct S_PDI)) ;
+EXPORT void* f15_P_PDS_PDF(void* p0, double p1, struct S_PDF p2,  void* (*cb)(void*, double, struct S_PDF)) ;
+EXPORT void* f15_P_PDS_PDD(void* p0, double p1, struct S_PDD p2,  void* (*cb)(void*, double, struct S_PDD)) ;
+EXPORT void* f15_P_PDS_PDP(void* p0, double p1, struct S_PDP p2,  void* (*cb)(void*, double, struct S_PDP)) ;
+EXPORT void* f15_P_PDS_PPI(void* p0, double p1, struct S_PPI p2,  void* (*cb)(void*, double, struct S_PPI)) ;
+EXPORT void* f15_P_PDS_PPF(void* p0, double p1, struct S_PPF p2,  void* (*cb)(void*, double, struct S_PPF)) ;
+EXPORT void* f15_P_PDS_PPD(void* p0, double p1, struct S_PPD p2,  void* (*cb)(void*, double, struct S_PPD)) ;
+EXPORT void* f15_P_PDS_PPP(void* p0, double p1, struct S_PPP p2,  void* (*cb)(void*, double, struct S_PPP)) ;
+EXPORT void* f15_P_PPI_(void* p0, void* p1, int p2,  void* (*cb)(void*, void*, int)) ;
+EXPORT void* f15_P_PPF_(void* p0, void* p1, float p2,  void* (*cb)(void*, void*, float)) ;
+EXPORT void* f15_P_PPD_(void* p0, void* p1, double p2,  void* (*cb)(void*, void*, double)) ;
+EXPORT void* f15_P_PPP_(void* p0, void* p1, void* p2,  void* (*cb)(void*, void*, void*)) ;
+EXPORT void* f15_P_PPS_I(void* p0, void* p1, struct S_I p2,  void* (*cb)(void*, void*, struct S_I)) ;
+EXPORT void* f15_P_PPS_F(void* p0, void* p1, struct S_F p2,  void* (*cb)(void*, void*, struct S_F)) ;
+EXPORT void* f15_P_PPS_D(void* p0, void* p1, struct S_D p2,  void* (*cb)(void*, void*, struct S_D)) ;
+EXPORT void* f15_P_PPS_P(void* p0, void* p1, struct S_P p2,  void* (*cb)(void*, void*, struct S_P)) ;
+EXPORT void* f15_P_PPS_II(void* p0, void* p1, struct S_II p2,  void* (*cb)(void*, void*, struct S_II)) ;
+EXPORT void* f15_P_PPS_IF(void* p0, void* p1, struct S_IF p2,  void* (*cb)(void*, void*, struct S_IF)) ;
+EXPORT void* f15_P_PPS_ID(void* p0, void* p1, struct S_ID p2,  void* (*cb)(void*, void*, struct S_ID)) ;
+EXPORT void* f15_P_PPS_IP(void* p0, void* p1, struct S_IP p2,  void* (*cb)(void*, void*, struct S_IP)) ;
+EXPORT void* f15_P_PPS_FI(void* p0, void* p1, struct S_FI p2,  void* (*cb)(void*, void*, struct S_FI)) ;
+EXPORT void* f15_P_PPS_FF(void* p0, void* p1, struct S_FF p2,  void* (*cb)(void*, void*, struct S_FF)) ;
+EXPORT void* f15_P_PPS_FD(void* p0, void* p1, struct S_FD p2,  void* (*cb)(void*, void*, struct S_FD)) ;
+EXPORT void* f15_P_PPS_FP(void* p0, void* p1, struct S_FP p2,  void* (*cb)(void*, void*, struct S_FP)) ;
+EXPORT void* f15_P_PPS_DI(void* p0, void* p1, struct S_DI p2,  void* (*cb)(void*, void*, struct S_DI)) ;
+EXPORT void* f15_P_PPS_DF(void* p0, void* p1, struct S_DF p2,  void* (*cb)(void*, void*, struct S_DF)) ;
+EXPORT void* f15_P_PPS_DD(void* p0, void* p1, struct S_DD p2,  void* (*cb)(void*, void*, struct S_DD)) ;
+EXPORT void* f15_P_PPS_DP(void* p0, void* p1, struct S_DP p2,  void* (*cb)(void*, void*, struct S_DP)) ;
+EXPORT void* f15_P_PPS_PI(void* p0, void* p1, struct S_PI p2,  void* (*cb)(void*, void*, struct S_PI)) ;
+EXPORT void* f15_P_PPS_PF(void* p0, void* p1, struct S_PF p2,  void* (*cb)(void*, void*, struct S_PF)) ;
+EXPORT void* f15_P_PPS_PD(void* p0, void* p1, struct S_PD p2,  void* (*cb)(void*, void*, struct S_PD)) ;
+EXPORT void* f15_P_PPS_PP(void* p0, void* p1, struct S_PP p2,  void* (*cb)(void*, void*, struct S_PP)) ;
+EXPORT void* f15_P_PPS_III(void* p0, void* p1, struct S_III p2,  void* (*cb)(void*, void*, struct S_III)) ;
+EXPORT void* f15_P_PPS_IIF(void* p0, void* p1, struct S_IIF p2,  void* (*cb)(void*, void*, struct S_IIF)) ;
+EXPORT void* f15_P_PPS_IID(void* p0, void* p1, struct S_IID p2,  void* (*cb)(void*, void*, struct S_IID)) ;
+EXPORT void* f15_P_PPS_IIP(void* p0, void* p1, struct S_IIP p2,  void* (*cb)(void*, void*, struct S_IIP)) ;
+EXPORT void* f15_P_PPS_IFI(void* p0, void* p1, struct S_IFI p2,  void* (*cb)(void*, void*, struct S_IFI)) ;
+EXPORT void* f15_P_PPS_IFF(void* p0, void* p1, struct S_IFF p2,  void* (*cb)(void*, void*, struct S_IFF)) ;
+EXPORT void* f15_P_PPS_IFD(void* p0, void* p1, struct S_IFD p2,  void* (*cb)(void*, void*, struct S_IFD)) ;
+EXPORT void* f15_P_PPS_IFP(void* p0, void* p1, struct S_IFP p2,  void* (*cb)(void*, void*, struct S_IFP)) ;
+EXPORT void* f15_P_PPS_IDI(void* p0, void* p1, struct S_IDI p2,  void* (*cb)(void*, void*, struct S_IDI)) ;
+EXPORT void* f15_P_PPS_IDF(void* p0, void* p1, struct S_IDF p2,  void* (*cb)(void*, void*, struct S_IDF)) ;
+EXPORT void* f15_P_PPS_IDD(void* p0, void* p1, struct S_IDD p2,  void* (*cb)(void*, void*, struct S_IDD)) ;
+EXPORT void* f15_P_PPS_IDP(void* p0, void* p1, struct S_IDP p2,  void* (*cb)(void*, void*, struct S_IDP)) ;
+EXPORT void* f15_P_PPS_IPI(void* p0, void* p1, struct S_IPI p2,  void* (*cb)(void*, void*, struct S_IPI)) ;
+EXPORT void* f15_P_PPS_IPF(void* p0, void* p1, struct S_IPF p2,  void* (*cb)(void*, void*, struct S_IPF)) ;
+EXPORT void* f15_P_PPS_IPD(void* p0, void* p1, struct S_IPD p2,  void* (*cb)(void*, void*, struct S_IPD)) ;
+EXPORT void* f15_P_PPS_IPP(void* p0, void* p1, struct S_IPP p2,  void* (*cb)(void*, void*, struct S_IPP)) ;
+EXPORT void* f15_P_PPS_FII(void* p0, void* p1, struct S_FII p2,  void* (*cb)(void*, void*, struct S_FII)) ;
+EXPORT void* f15_P_PPS_FIF(void* p0, void* p1, struct S_FIF p2,  void* (*cb)(void*, void*, struct S_FIF)) ;
+EXPORT void* f15_P_PPS_FID(void* p0, void* p1, struct S_FID p2,  void* (*cb)(void*, void*, struct S_FID)) ;
+EXPORT void* f15_P_PPS_FIP(void* p0, void* p1, struct S_FIP p2,  void* (*cb)(void*, void*, struct S_FIP)) ;
+EXPORT void* f15_P_PPS_FFI(void* p0, void* p1, struct S_FFI p2,  void* (*cb)(void*, void*, struct S_FFI)) ;
+EXPORT void* f15_P_PPS_FFF(void* p0, void* p1, struct S_FFF p2,  void* (*cb)(void*, void*, struct S_FFF)) ;
+EXPORT void* f15_P_PPS_FFD(void* p0, void* p1, struct S_FFD p2,  void* (*cb)(void*, void*, struct S_FFD)) ;
+EXPORT void* f15_P_PPS_FFP(void* p0, void* p1, struct S_FFP p2,  void* (*cb)(void*, void*, struct S_FFP)) ;
+EXPORT void* f15_P_PPS_FDI(void* p0, void* p1, struct S_FDI p2,  void* (*cb)(void*, void*, struct S_FDI)) ;
+EXPORT void* f15_P_PPS_FDF(void* p0, void* p1, struct S_FDF p2,  void* (*cb)(void*, void*, struct S_FDF)) ;
+EXPORT void* f15_P_PPS_FDD(void* p0, void* p1, struct S_FDD p2,  void* (*cb)(void*, void*, struct S_FDD)) ;
+EXPORT void* f15_P_PPS_FDP(void* p0, void* p1, struct S_FDP p2,  void* (*cb)(void*, void*, struct S_FDP)) ;
+EXPORT void* f15_P_PPS_FPI(void* p0, void* p1, struct S_FPI p2,  void* (*cb)(void*, void*, struct S_FPI)) ;
+EXPORT void* f15_P_PPS_FPF(void* p0, void* p1, struct S_FPF p2,  void* (*cb)(void*, void*, struct S_FPF)) ;
+EXPORT void* f15_P_PPS_FPD(void* p0, void* p1, struct S_FPD p2,  void* (*cb)(void*, void*, struct S_FPD)) ;
+EXPORT void* f15_P_PPS_FPP(void* p0, void* p1, struct S_FPP p2,  void* (*cb)(void*, void*, struct S_FPP)) ;
+EXPORT void* f15_P_PPS_DII(void* p0, void* p1, struct S_DII p2,  void* (*cb)(void*, void*, struct S_DII)) ;
+EXPORT void* f15_P_PPS_DIF(void* p0, void* p1, struct S_DIF p2,  void* (*cb)(void*, void*, struct S_DIF)) ;
+EXPORT void* f15_P_PPS_DID(void* p0, void* p1, struct S_DID p2,  void* (*cb)(void*, void*, struct S_DID)) ;
+EXPORT void* f15_P_PPS_DIP(void* p0, void* p1, struct S_DIP p2,  void* (*cb)(void*, void*, struct S_DIP)) ;
+EXPORT void* f15_P_PPS_DFI(void* p0, void* p1, struct S_DFI p2,  void* (*cb)(void*, void*, struct S_DFI)) ;
+EXPORT void* f15_P_PPS_DFF(void* p0, void* p1, struct S_DFF p2,  void* (*cb)(void*, void*, struct S_DFF)) ;
+EXPORT void* f15_P_PPS_DFD(void* p0, void* p1, struct S_DFD p2,  void* (*cb)(void*, void*, struct S_DFD)) ;
+EXPORT void* f15_P_PPS_DFP(void* p0, void* p1, struct S_DFP p2,  void* (*cb)(void*, void*, struct S_DFP)) ;
+EXPORT void* f15_P_PPS_DDI(void* p0, void* p1, struct S_DDI p2,  void* (*cb)(void*, void*, struct S_DDI)) ;
+EXPORT void* f15_P_PPS_DDF(void* p0, void* p1, struct S_DDF p2,  void* (*cb)(void*, void*, struct S_DDF)) ;
+EXPORT void* f15_P_PPS_DDD(void* p0, void* p1, struct S_DDD p2,  void* (*cb)(void*, void*, struct S_DDD)) ;
+EXPORT void* f15_P_PPS_DDP(void* p0, void* p1, struct S_DDP p2,  void* (*cb)(void*, void*, struct S_DDP)) ;
+EXPORT void* f15_P_PPS_DPI(void* p0, void* p1, struct S_DPI p2,  void* (*cb)(void*, void*, struct S_DPI)) ;
+EXPORT void* f15_P_PPS_DPF(void* p0, void* p1, struct S_DPF p2,  void* (*cb)(void*, void*, struct S_DPF)) ;
+EXPORT void* f15_P_PPS_DPD(void* p0, void* p1, struct S_DPD p2,  void* (*cb)(void*, void*, struct S_DPD)) ;
+EXPORT void* f15_P_PPS_DPP(void* p0, void* p1, struct S_DPP p2,  void* (*cb)(void*, void*, struct S_DPP)) ;
+EXPORT void* f15_P_PPS_PII(void* p0, void* p1, struct S_PII p2,  void* (*cb)(void*, void*, struct S_PII)) ;
+EXPORT void* f15_P_PPS_PIF(void* p0, void* p1, struct S_PIF p2,  void* (*cb)(void*, void*, struct S_PIF)) ;
+EXPORT void* f15_P_PPS_PID(void* p0, void* p1, struct S_PID p2,  void* (*cb)(void*, void*, struct S_PID)) ;
+EXPORT void* f15_P_PPS_PIP(void* p0, void* p1, struct S_PIP p2,  void* (*cb)(void*, void*, struct S_PIP)) ;
+EXPORT void* f15_P_PPS_PFI(void* p0, void* p1, struct S_PFI p2,  void* (*cb)(void*, void*, struct S_PFI)) ;
+EXPORT void* f15_P_PPS_PFF(void* p0, void* p1, struct S_PFF p2,  void* (*cb)(void*, void*, struct S_PFF)) ;
+EXPORT void* f15_P_PPS_PFD(void* p0, void* p1, struct S_PFD p2,  void* (*cb)(void*, void*, struct S_PFD)) ;
+EXPORT void* f15_P_PPS_PFP(void* p0, void* p1, struct S_PFP p2,  void* (*cb)(void*, void*, struct S_PFP)) ;
+EXPORT void* f15_P_PPS_PDI(void* p0, void* p1, struct S_PDI p2,  void* (*cb)(void*, void*, struct S_PDI)) ;
+EXPORT void* f15_P_PPS_PDF(void* p0, void* p1, struct S_PDF p2,  void* (*cb)(void*, void*, struct S_PDF)) ;
+EXPORT void* f15_P_PPS_PDD(void* p0, void* p1, struct S_PDD p2,  void* (*cb)(void*, void*, struct S_PDD)) ;
+EXPORT void* f15_P_PPS_PDP(void* p0, void* p1, struct S_PDP p2,  void* (*cb)(void*, void*, struct S_PDP)) ;
+EXPORT void* f15_P_PPS_PPI(void* p0, void* p1, struct S_PPI p2,  void* (*cb)(void*, void*, struct S_PPI)) ;
+EXPORT void* f15_P_PPS_PPF(void* p0, void* p1, struct S_PPF p2,  void* (*cb)(void*, void*, struct S_PPF)) ;
+EXPORT void* f15_P_PPS_PPD(void* p0, void* p1, struct S_PPD p2,  void* (*cb)(void*, void*, struct S_PPD)) ;
+EXPORT void* f15_P_PPS_PPP(void* p0, void* p1, struct S_PPP p2,  void* (*cb)(void*, void*, struct S_PPP)) ;
+EXPORT void* f15_P_PSI_I(void* p0, struct S_I p1, int p2,  void* (*cb)(void*, struct S_I, int)) ;
+EXPORT void* f15_P_PSI_F(void* p0, struct S_F p1, int p2,  void* (*cb)(void*, struct S_F, int)) ;
+EXPORT void* f15_P_PSI_D(void* p0, struct S_D p1, int p2,  void* (*cb)(void*, struct S_D, int)) ;
+EXPORT void* f15_P_PSI_P(void* p0, struct S_P p1, int p2,  void* (*cb)(void*, struct S_P, int)) ;
+EXPORT void* f15_P_PSI_II(void* p0, struct S_II p1, int p2,  void* (*cb)(void*, struct S_II, int)) ;
+EXPORT void* f15_P_PSI_IF(void* p0, struct S_IF p1, int p2,  void* (*cb)(void*, struct S_IF, int)) ;
+EXPORT void* f15_P_PSI_ID(void* p0, struct S_ID p1, int p2,  void* (*cb)(void*, struct S_ID, int)) ;
+EXPORT void* f15_P_PSI_IP(void* p0, struct S_IP p1, int p2,  void* (*cb)(void*, struct S_IP, int)) ;
+EXPORT void* f15_P_PSI_FI(void* p0, struct S_FI p1, int p2,  void* (*cb)(void*, struct S_FI, int)) ;
+EXPORT void* f15_P_PSI_FF(void* p0, struct S_FF p1, int p2,  void* (*cb)(void*, struct S_FF, int)) ;
+EXPORT void* f15_P_PSI_FD(void* p0, struct S_FD p1, int p2,  void* (*cb)(void*, struct S_FD, int)) ;
+EXPORT void* f15_P_PSI_FP(void* p0, struct S_FP p1, int p2,  void* (*cb)(void*, struct S_FP, int)) ;
+EXPORT void* f15_P_PSI_DI(void* p0, struct S_DI p1, int p2,  void* (*cb)(void*, struct S_DI, int)) ;
+EXPORT void* f15_P_PSI_DF(void* p0, struct S_DF p1, int p2,  void* (*cb)(void*, struct S_DF, int)) ;
+EXPORT void* f15_P_PSI_DD(void* p0, struct S_DD p1, int p2,  void* (*cb)(void*, struct S_DD, int)) ;
+EXPORT void* f15_P_PSI_DP(void* p0, struct S_DP p1, int p2,  void* (*cb)(void*, struct S_DP, int)) ;
+EXPORT void* f15_P_PSI_PI(void* p0, struct S_PI p1, int p2,  void* (*cb)(void*, struct S_PI, int)) ;
+EXPORT void* f15_P_PSI_PF(void* p0, struct S_PF p1, int p2,  void* (*cb)(void*, struct S_PF, int)) ;
+EXPORT void* f15_P_PSI_PD(void* p0, struct S_PD p1, int p2,  void* (*cb)(void*, struct S_PD, int)) ;
+EXPORT void* f15_P_PSI_PP(void* p0, struct S_PP p1, int p2,  void* (*cb)(void*, struct S_PP, int)) ;
+EXPORT void* f15_P_PSI_III(void* p0, struct S_III p1, int p2,  void* (*cb)(void*, struct S_III, int)) ;
+EXPORT void* f15_P_PSI_IIF(void* p0, struct S_IIF p1, int p2,  void* (*cb)(void*, struct S_IIF, int)) ;
+EXPORT void* f15_P_PSI_IID(void* p0, struct S_IID p1, int p2,  void* (*cb)(void*, struct S_IID, int)) ;
+EXPORT void* f16_P_PSI_IIP(void* p0, struct S_IIP p1, int p2,  void* (*cb)(void*, struct S_IIP, int)) ;
+EXPORT void* f16_P_PSI_IFI(void* p0, struct S_IFI p1, int p2,  void* (*cb)(void*, struct S_IFI, int)) ;
+EXPORT void* f16_P_PSI_IFF(void* p0, struct S_IFF p1, int p2,  void* (*cb)(void*, struct S_IFF, int)) ;
+EXPORT void* f16_P_PSI_IFD(void* p0, struct S_IFD p1, int p2,  void* (*cb)(void*, struct S_IFD, int)) ;
+EXPORT void* f16_P_PSI_IFP(void* p0, struct S_IFP p1, int p2,  void* (*cb)(void*, struct S_IFP, int)) ;
+EXPORT void* f16_P_PSI_IDI(void* p0, struct S_IDI p1, int p2,  void* (*cb)(void*, struct S_IDI, int)) ;
+EXPORT void* f16_P_PSI_IDF(void* p0, struct S_IDF p1, int p2,  void* (*cb)(void*, struct S_IDF, int)) ;
+EXPORT void* f16_P_PSI_IDD(void* p0, struct S_IDD p1, int p2,  void* (*cb)(void*, struct S_IDD, int)) ;
+EXPORT void* f16_P_PSI_IDP(void* p0, struct S_IDP p1, int p2,  void* (*cb)(void*, struct S_IDP, int)) ;
+EXPORT void* f16_P_PSI_IPI(void* p0, struct S_IPI p1, int p2,  void* (*cb)(void*, struct S_IPI, int)) ;
+EXPORT void* f16_P_PSI_IPF(void* p0, struct S_IPF p1, int p2,  void* (*cb)(void*, struct S_IPF, int)) ;
+EXPORT void* f16_P_PSI_IPD(void* p0, struct S_IPD p1, int p2,  void* (*cb)(void*, struct S_IPD, int)) ;
+EXPORT void* f16_P_PSI_IPP(void* p0, struct S_IPP p1, int p2,  void* (*cb)(void*, struct S_IPP, int)) ;
+EXPORT void* f16_P_PSI_FII(void* p0, struct S_FII p1, int p2,  void* (*cb)(void*, struct S_FII, int)) ;
+EXPORT void* f16_P_PSI_FIF(void* p0, struct S_FIF p1, int p2,  void* (*cb)(void*, struct S_FIF, int)) ;
+EXPORT void* f16_P_PSI_FID(void* p0, struct S_FID p1, int p2,  void* (*cb)(void*, struct S_FID, int)) ;
+EXPORT void* f16_P_PSI_FIP(void* p0, struct S_FIP p1, int p2,  void* (*cb)(void*, struct S_FIP, int)) ;
+EXPORT void* f16_P_PSI_FFI(void* p0, struct S_FFI p1, int p2,  void* (*cb)(void*, struct S_FFI, int)) ;
+EXPORT void* f16_P_PSI_FFF(void* p0, struct S_FFF p1, int p2,  void* (*cb)(void*, struct S_FFF, int)) ;
+EXPORT void* f16_P_PSI_FFD(void* p0, struct S_FFD p1, int p2,  void* (*cb)(void*, struct S_FFD, int)) ;
+EXPORT void* f16_P_PSI_FFP(void* p0, struct S_FFP p1, int p2,  void* (*cb)(void*, struct S_FFP, int)) ;
+EXPORT void* f16_P_PSI_FDI(void* p0, struct S_FDI p1, int p2,  void* (*cb)(void*, struct S_FDI, int)) ;
+EXPORT void* f16_P_PSI_FDF(void* p0, struct S_FDF p1, int p2,  void* (*cb)(void*, struct S_FDF, int)) ;
+EXPORT void* f16_P_PSI_FDD(void* p0, struct S_FDD p1, int p2,  void* (*cb)(void*, struct S_FDD, int)) ;
+EXPORT void* f16_P_PSI_FDP(void* p0, struct S_FDP p1, int p2,  void* (*cb)(void*, struct S_FDP, int)) ;
+EXPORT void* f16_P_PSI_FPI(void* p0, struct S_FPI p1, int p2,  void* (*cb)(void*, struct S_FPI, int)) ;
+EXPORT void* f16_P_PSI_FPF(void* p0, struct S_FPF p1, int p2,  void* (*cb)(void*, struct S_FPF, int)) ;
+EXPORT void* f16_P_PSI_FPD(void* p0, struct S_FPD p1, int p2,  void* (*cb)(void*, struct S_FPD, int)) ;
+EXPORT void* f16_P_PSI_FPP(void* p0, struct S_FPP p1, int p2,  void* (*cb)(void*, struct S_FPP, int)) ;
+EXPORT void* f16_P_PSI_DII(void* p0, struct S_DII p1, int p2,  void* (*cb)(void*, struct S_DII, int)) ;
+EXPORT void* f16_P_PSI_DIF(void* p0, struct S_DIF p1, int p2,  void* (*cb)(void*, struct S_DIF, int)) ;
+EXPORT void* f16_P_PSI_DID(void* p0, struct S_DID p1, int p2,  void* (*cb)(void*, struct S_DID, int)) ;
+EXPORT void* f16_P_PSI_DIP(void* p0, struct S_DIP p1, int p2,  void* (*cb)(void*, struct S_DIP, int)) ;
+EXPORT void* f16_P_PSI_DFI(void* p0, struct S_DFI p1, int p2,  void* (*cb)(void*, struct S_DFI, int)) ;
+EXPORT void* f16_P_PSI_DFF(void* p0, struct S_DFF p1, int p2,  void* (*cb)(void*, struct S_DFF, int)) ;
+EXPORT void* f16_P_PSI_DFD(void* p0, struct S_DFD p1, int p2,  void* (*cb)(void*, struct S_DFD, int)) ;
+EXPORT void* f16_P_PSI_DFP(void* p0, struct S_DFP p1, int p2,  void* (*cb)(void*, struct S_DFP, int)) ;
+EXPORT void* f16_P_PSI_DDI(void* p0, struct S_DDI p1, int p2,  void* (*cb)(void*, struct S_DDI, int)) ;
+EXPORT void* f16_P_PSI_DDF(void* p0, struct S_DDF p1, int p2,  void* (*cb)(void*, struct S_DDF, int)) ;
+EXPORT void* f16_P_PSI_DDD(void* p0, struct S_DDD p1, int p2,  void* (*cb)(void*, struct S_DDD, int)) ;
+EXPORT void* f16_P_PSI_DDP(void* p0, struct S_DDP p1, int p2,  void* (*cb)(void*, struct S_DDP, int)) ;
+EXPORT void* f16_P_PSI_DPI(void* p0, struct S_DPI p1, int p2,  void* (*cb)(void*, struct S_DPI, int)) ;
+EXPORT void* f16_P_PSI_DPF(void* p0, struct S_DPF p1, int p2,  void* (*cb)(void*, struct S_DPF, int)) ;
+EXPORT void* f16_P_PSI_DPD(void* p0, struct S_DPD p1, int p2,  void* (*cb)(void*, struct S_DPD, int)) ;
+EXPORT void* f16_P_PSI_DPP(void* p0, struct S_DPP p1, int p2,  void* (*cb)(void*, struct S_DPP, int)) ;
+EXPORT void* f16_P_PSI_PII(void* p0, struct S_PII p1, int p2,  void* (*cb)(void*, struct S_PII, int)) ;
+EXPORT void* f16_P_PSI_PIF(void* p0, struct S_PIF p1, int p2,  void* (*cb)(void*, struct S_PIF, int)) ;
+EXPORT void* f16_P_PSI_PID(void* p0, struct S_PID p1, int p2,  void* (*cb)(void*, struct S_PID, int)) ;
+EXPORT void* f16_P_PSI_PIP(void* p0, struct S_PIP p1, int p2,  void* (*cb)(void*, struct S_PIP, int)) ;
+EXPORT void* f16_P_PSI_PFI(void* p0, struct S_PFI p1, int p2,  void* (*cb)(void*, struct S_PFI, int)) ;
+EXPORT void* f16_P_PSI_PFF(void* p0, struct S_PFF p1, int p2,  void* (*cb)(void*, struct S_PFF, int)) ;
+EXPORT void* f16_P_PSI_PFD(void* p0, struct S_PFD p1, int p2,  void* (*cb)(void*, struct S_PFD, int)) ;
+EXPORT void* f16_P_PSI_PFP(void* p0, struct S_PFP p1, int p2,  void* (*cb)(void*, struct S_PFP, int)) ;
+EXPORT void* f16_P_PSI_PDI(void* p0, struct S_PDI p1, int p2,  void* (*cb)(void*, struct S_PDI, int)) ;
+EXPORT void* f16_P_PSI_PDF(void* p0, struct S_PDF p1, int p2,  void* (*cb)(void*, struct S_PDF, int)) ;
+EXPORT void* f16_P_PSI_PDD(void* p0, struct S_PDD p1, int p2,  void* (*cb)(void*, struct S_PDD, int)) ;
+EXPORT void* f16_P_PSI_PDP(void* p0, struct S_PDP p1, int p2,  void* (*cb)(void*, struct S_PDP, int)) ;
+EXPORT void* f16_P_PSI_PPI(void* p0, struct S_PPI p1, int p2,  void* (*cb)(void*, struct S_PPI, int)) ;
+EXPORT void* f16_P_PSI_PPF(void* p0, struct S_PPF p1, int p2,  void* (*cb)(void*, struct S_PPF, int)) ;
+EXPORT void* f16_P_PSI_PPD(void* p0, struct S_PPD p1, int p2,  void* (*cb)(void*, struct S_PPD, int)) ;
+EXPORT void* f16_P_PSI_PPP(void* p0, struct S_PPP p1, int p2,  void* (*cb)(void*, struct S_PPP, int)) ;
+EXPORT void* f16_P_PSF_I(void* p0, struct S_I p1, float p2,  void* (*cb)(void*, struct S_I, float)) ;
+EXPORT void* f16_P_PSF_F(void* p0, struct S_F p1, float p2,  void* (*cb)(void*, struct S_F, float)) ;
+EXPORT void* f16_P_PSF_D(void* p0, struct S_D p1, float p2,  void* (*cb)(void*, struct S_D, float)) ;
+EXPORT void* f16_P_PSF_P(void* p0, struct S_P p1, float p2,  void* (*cb)(void*, struct S_P, float)) ;
+EXPORT void* f16_P_PSF_II(void* p0, struct S_II p1, float p2,  void* (*cb)(void*, struct S_II, float)) ;
+EXPORT void* f16_P_PSF_IF(void* p0, struct S_IF p1, float p2,  void* (*cb)(void*, struct S_IF, float)) ;
+EXPORT void* f16_P_PSF_ID(void* p0, struct S_ID p1, float p2,  void* (*cb)(void*, struct S_ID, float)) ;
+EXPORT void* f16_P_PSF_IP(void* p0, struct S_IP p1, float p2,  void* (*cb)(void*, struct S_IP, float)) ;
+EXPORT void* f16_P_PSF_FI(void* p0, struct S_FI p1, float p2,  void* (*cb)(void*, struct S_FI, float)) ;
+EXPORT void* f16_P_PSF_FF(void* p0, struct S_FF p1, float p2,  void* (*cb)(void*, struct S_FF, float)) ;
+EXPORT void* f16_P_PSF_FD(void* p0, struct S_FD p1, float p2,  void* (*cb)(void*, struct S_FD, float)) ;
+EXPORT void* f16_P_PSF_FP(void* p0, struct S_FP p1, float p2,  void* (*cb)(void*, struct S_FP, float)) ;
+EXPORT void* f16_P_PSF_DI(void* p0, struct S_DI p1, float p2,  void* (*cb)(void*, struct S_DI, float)) ;
+EXPORT void* f16_P_PSF_DF(void* p0, struct S_DF p1, float p2,  void* (*cb)(void*, struct S_DF, float)) ;
+EXPORT void* f16_P_PSF_DD(void* p0, struct S_DD p1, float p2,  void* (*cb)(void*, struct S_DD, float)) ;
+EXPORT void* f16_P_PSF_DP(void* p0, struct S_DP p1, float p2,  void* (*cb)(void*, struct S_DP, float)) ;
+EXPORT void* f16_P_PSF_PI(void* p0, struct S_PI p1, float p2,  void* (*cb)(void*, struct S_PI, float)) ;
+EXPORT void* f16_P_PSF_PF(void* p0, struct S_PF p1, float p2,  void* (*cb)(void*, struct S_PF, float)) ;
+EXPORT void* f16_P_PSF_PD(void* p0, struct S_PD p1, float p2,  void* (*cb)(void*, struct S_PD, float)) ;
+EXPORT void* f16_P_PSF_PP(void* p0, struct S_PP p1, float p2,  void* (*cb)(void*, struct S_PP, float)) ;
+EXPORT void* f16_P_PSF_III(void* p0, struct S_III p1, float p2,  void* (*cb)(void*, struct S_III, float)) ;
+EXPORT void* f16_P_PSF_IIF(void* p0, struct S_IIF p1, float p2,  void* (*cb)(void*, struct S_IIF, float)) ;
+EXPORT void* f16_P_PSF_IID(void* p0, struct S_IID p1, float p2,  void* (*cb)(void*, struct S_IID, float)) ;
+EXPORT void* f16_P_PSF_IIP(void* p0, struct S_IIP p1, float p2,  void* (*cb)(void*, struct S_IIP, float)) ;
+EXPORT void* f16_P_PSF_IFI(void* p0, struct S_IFI p1, float p2,  void* (*cb)(void*, struct S_IFI, float)) ;
+EXPORT void* f16_P_PSF_IFF(void* p0, struct S_IFF p1, float p2,  void* (*cb)(void*, struct S_IFF, float)) ;
+EXPORT void* f16_P_PSF_IFD(void* p0, struct S_IFD p1, float p2,  void* (*cb)(void*, struct S_IFD, float)) ;
+EXPORT void* f16_P_PSF_IFP(void* p0, struct S_IFP p1, float p2,  void* (*cb)(void*, struct S_IFP, float)) ;
+EXPORT void* f16_P_PSF_IDI(void* p0, struct S_IDI p1, float p2,  void* (*cb)(void*, struct S_IDI, float)) ;
+EXPORT void* f16_P_PSF_IDF(void* p0, struct S_IDF p1, float p2,  void* (*cb)(void*, struct S_IDF, float)) ;
+EXPORT void* f16_P_PSF_IDD(void* p0, struct S_IDD p1, float p2,  void* (*cb)(void*, struct S_IDD, float)) ;
+EXPORT void* f16_P_PSF_IDP(void* p0, struct S_IDP p1, float p2,  void* (*cb)(void*, struct S_IDP, float)) ;
+EXPORT void* f16_P_PSF_IPI(void* p0, struct S_IPI p1, float p2,  void* (*cb)(void*, struct S_IPI, float)) ;
+EXPORT void* f16_P_PSF_IPF(void* p0, struct S_IPF p1, float p2,  void* (*cb)(void*, struct S_IPF, float)) ;
+EXPORT void* f16_P_PSF_IPD(void* p0, struct S_IPD p1, float p2,  void* (*cb)(void*, struct S_IPD, float)) ;
+EXPORT void* f16_P_PSF_IPP(void* p0, struct S_IPP p1, float p2,  void* (*cb)(void*, struct S_IPP, float)) ;
+EXPORT void* f16_P_PSF_FII(void* p0, struct S_FII p1, float p2,  void* (*cb)(void*, struct S_FII, float)) ;
+EXPORT void* f16_P_PSF_FIF(void* p0, struct S_FIF p1, float p2,  void* (*cb)(void*, struct S_FIF, float)) ;
+EXPORT void* f16_P_PSF_FID(void* p0, struct S_FID p1, float p2,  void* (*cb)(void*, struct S_FID, float)) ;
+EXPORT void* f16_P_PSF_FIP(void* p0, struct S_FIP p1, float p2,  void* (*cb)(void*, struct S_FIP, float)) ;
+EXPORT void* f16_P_PSF_FFI(void* p0, struct S_FFI p1, float p2,  void* (*cb)(void*, struct S_FFI, float)) ;
+EXPORT void* f16_P_PSF_FFF(void* p0, struct S_FFF p1, float p2,  void* (*cb)(void*, struct S_FFF, float)) ;
+EXPORT void* f16_P_PSF_FFD(void* p0, struct S_FFD p1, float p2,  void* (*cb)(void*, struct S_FFD, float)) ;
+EXPORT void* f16_P_PSF_FFP(void* p0, struct S_FFP p1, float p2,  void* (*cb)(void*, struct S_FFP, float)) ;
+EXPORT void* f16_P_PSF_FDI(void* p0, struct S_FDI p1, float p2,  void* (*cb)(void*, struct S_FDI, float)) ;
+EXPORT void* f16_P_PSF_FDF(void* p0, struct S_FDF p1, float p2,  void* (*cb)(void*, struct S_FDF, float)) ;
+EXPORT void* f16_P_PSF_FDD(void* p0, struct S_FDD p1, float p2,  void* (*cb)(void*, struct S_FDD, float)) ;
+EXPORT void* f16_P_PSF_FDP(void* p0, struct S_FDP p1, float p2,  void* (*cb)(void*, struct S_FDP, float)) ;
+EXPORT void* f16_P_PSF_FPI(void* p0, struct S_FPI p1, float p2,  void* (*cb)(void*, struct S_FPI, float)) ;
+EXPORT void* f16_P_PSF_FPF(void* p0, struct S_FPF p1, float p2,  void* (*cb)(void*, struct S_FPF, float)) ;
+EXPORT void* f16_P_PSF_FPD(void* p0, struct S_FPD p1, float p2,  void* (*cb)(void*, struct S_FPD, float)) ;
+EXPORT void* f16_P_PSF_FPP(void* p0, struct S_FPP p1, float p2,  void* (*cb)(void*, struct S_FPP, float)) ;
+EXPORT void* f16_P_PSF_DII(void* p0, struct S_DII p1, float p2,  void* (*cb)(void*, struct S_DII, float)) ;
+EXPORT void* f16_P_PSF_DIF(void* p0, struct S_DIF p1, float p2,  void* (*cb)(void*, struct S_DIF, float)) ;
+EXPORT void* f16_P_PSF_DID(void* p0, struct S_DID p1, float p2,  void* (*cb)(void*, struct S_DID, float)) ;
+EXPORT void* f16_P_PSF_DIP(void* p0, struct S_DIP p1, float p2,  void* (*cb)(void*, struct S_DIP, float)) ;
+EXPORT void* f16_P_PSF_DFI(void* p0, struct S_DFI p1, float p2,  void* (*cb)(void*, struct S_DFI, float)) ;
+EXPORT void* f16_P_PSF_DFF(void* p0, struct S_DFF p1, float p2,  void* (*cb)(void*, struct S_DFF, float)) ;
+EXPORT void* f16_P_PSF_DFD(void* p0, struct S_DFD p1, float p2,  void* (*cb)(void*, struct S_DFD, float)) ;
+EXPORT void* f16_P_PSF_DFP(void* p0, struct S_DFP p1, float p2,  void* (*cb)(void*, struct S_DFP, float)) ;
+EXPORT void* f16_P_PSF_DDI(void* p0, struct S_DDI p1, float p2,  void* (*cb)(void*, struct S_DDI, float)) ;
+EXPORT void* f16_P_PSF_DDF(void* p0, struct S_DDF p1, float p2,  void* (*cb)(void*, struct S_DDF, float)) ;
+EXPORT void* f16_P_PSF_DDD(void* p0, struct S_DDD p1, float p2,  void* (*cb)(void*, struct S_DDD, float)) ;
+EXPORT void* f16_P_PSF_DDP(void* p0, struct S_DDP p1, float p2,  void* (*cb)(void*, struct S_DDP, float)) ;
+EXPORT void* f16_P_PSF_DPI(void* p0, struct S_DPI p1, float p2,  void* (*cb)(void*, struct S_DPI, float)) ;
+EXPORT void* f16_P_PSF_DPF(void* p0, struct S_DPF p1, float p2,  void* (*cb)(void*, struct S_DPF, float)) ;
+EXPORT void* f16_P_PSF_DPD(void* p0, struct S_DPD p1, float p2,  void* (*cb)(void*, struct S_DPD, float)) ;
+EXPORT void* f16_P_PSF_DPP(void* p0, struct S_DPP p1, float p2,  void* (*cb)(void*, struct S_DPP, float)) ;
+EXPORT void* f16_P_PSF_PII(void* p0, struct S_PII p1, float p2,  void* (*cb)(void*, struct S_PII, float)) ;
+EXPORT void* f16_P_PSF_PIF(void* p0, struct S_PIF p1, float p2,  void* (*cb)(void*, struct S_PIF, float)) ;
+EXPORT void* f16_P_PSF_PID(void* p0, struct S_PID p1, float p2,  void* (*cb)(void*, struct S_PID, float)) ;
+EXPORT void* f16_P_PSF_PIP(void* p0, struct S_PIP p1, float p2,  void* (*cb)(void*, struct S_PIP, float)) ;
+EXPORT void* f16_P_PSF_PFI(void* p0, struct S_PFI p1, float p2,  void* (*cb)(void*, struct S_PFI, float)) ;
+EXPORT void* f16_P_PSF_PFF(void* p0, struct S_PFF p1, float p2,  void* (*cb)(void*, struct S_PFF, float)) ;
+EXPORT void* f16_P_PSF_PFD(void* p0, struct S_PFD p1, float p2,  void* (*cb)(void*, struct S_PFD, float)) ;
+EXPORT void* f16_P_PSF_PFP(void* p0, struct S_PFP p1, float p2,  void* (*cb)(void*, struct S_PFP, float)) ;
+EXPORT void* f16_P_PSF_PDI(void* p0, struct S_PDI p1, float p2,  void* (*cb)(void*, struct S_PDI, float)) ;
+EXPORT void* f16_P_PSF_PDF(void* p0, struct S_PDF p1, float p2,  void* (*cb)(void*, struct S_PDF, float)) ;
+EXPORT void* f16_P_PSF_PDD(void* p0, struct S_PDD p1, float p2,  void* (*cb)(void*, struct S_PDD, float)) ;
+EXPORT void* f16_P_PSF_PDP(void* p0, struct S_PDP p1, float p2,  void* (*cb)(void*, struct S_PDP, float)) ;
+EXPORT void* f16_P_PSF_PPI(void* p0, struct S_PPI p1, float p2,  void* (*cb)(void*, struct S_PPI, float)) ;
+EXPORT void* f16_P_PSF_PPF(void* p0, struct S_PPF p1, float p2,  void* (*cb)(void*, struct S_PPF, float)) ;
+EXPORT void* f16_P_PSF_PPD(void* p0, struct S_PPD p1, float p2,  void* (*cb)(void*, struct S_PPD, float)) ;
+EXPORT void* f16_P_PSF_PPP(void* p0, struct S_PPP p1, float p2,  void* (*cb)(void*, struct S_PPP, float)) ;
+EXPORT void* f16_P_PSD_I(void* p0, struct S_I p1, double p2,  void* (*cb)(void*, struct S_I, double)) ;
+EXPORT void* f16_P_PSD_F(void* p0, struct S_F p1, double p2,  void* (*cb)(void*, struct S_F, double)) ;
+EXPORT void* f16_P_PSD_D(void* p0, struct S_D p1, double p2,  void* (*cb)(void*, struct S_D, double)) ;
+EXPORT void* f16_P_PSD_P(void* p0, struct S_P p1, double p2,  void* (*cb)(void*, struct S_P, double)) ;
+EXPORT void* f16_P_PSD_II(void* p0, struct S_II p1, double p2,  void* (*cb)(void*, struct S_II, double)) ;
+EXPORT void* f16_P_PSD_IF(void* p0, struct S_IF p1, double p2,  void* (*cb)(void*, struct S_IF, double)) ;
+EXPORT void* f16_P_PSD_ID(void* p0, struct S_ID p1, double p2,  void* (*cb)(void*, struct S_ID, double)) ;
+EXPORT void* f16_P_PSD_IP(void* p0, struct S_IP p1, double p2,  void* (*cb)(void*, struct S_IP, double)) ;
+EXPORT void* f16_P_PSD_FI(void* p0, struct S_FI p1, double p2,  void* (*cb)(void*, struct S_FI, double)) ;
+EXPORT void* f16_P_PSD_FF(void* p0, struct S_FF p1, double p2,  void* (*cb)(void*, struct S_FF, double)) ;
+EXPORT void* f16_P_PSD_FD(void* p0, struct S_FD p1, double p2,  void* (*cb)(void*, struct S_FD, double)) ;
+EXPORT void* f16_P_PSD_FP(void* p0, struct S_FP p1, double p2,  void* (*cb)(void*, struct S_FP, double)) ;
+EXPORT void* f16_P_PSD_DI(void* p0, struct S_DI p1, double p2,  void* (*cb)(void*, struct S_DI, double)) ;
+EXPORT void* f16_P_PSD_DF(void* p0, struct S_DF p1, double p2,  void* (*cb)(void*, struct S_DF, double)) ;
+EXPORT void* f16_P_PSD_DD(void* p0, struct S_DD p1, double p2,  void* (*cb)(void*, struct S_DD, double)) ;
+EXPORT void* f16_P_PSD_DP(void* p0, struct S_DP p1, double p2,  void* (*cb)(void*, struct S_DP, double)) ;
+EXPORT void* f16_P_PSD_PI(void* p0, struct S_PI p1, double p2,  void* (*cb)(void*, struct S_PI, double)) ;
+EXPORT void* f16_P_PSD_PF(void* p0, struct S_PF p1, double p2,  void* (*cb)(void*, struct S_PF, double)) ;
+EXPORT void* f16_P_PSD_PD(void* p0, struct S_PD p1, double p2,  void* (*cb)(void*, struct S_PD, double)) ;
+EXPORT void* f16_P_PSD_PP(void* p0, struct S_PP p1, double p2,  void* (*cb)(void*, struct S_PP, double)) ;
+EXPORT void* f16_P_PSD_III(void* p0, struct S_III p1, double p2,  void* (*cb)(void*, struct S_III, double)) ;
+EXPORT void* f16_P_PSD_IIF(void* p0, struct S_IIF p1, double p2,  void* (*cb)(void*, struct S_IIF, double)) ;
+EXPORT void* f16_P_PSD_IID(void* p0, struct S_IID p1, double p2,  void* (*cb)(void*, struct S_IID, double)) ;
+EXPORT void* f16_P_PSD_IIP(void* p0, struct S_IIP p1, double p2,  void* (*cb)(void*, struct S_IIP, double)) ;
+EXPORT void* f16_P_PSD_IFI(void* p0, struct S_IFI p1, double p2,  void* (*cb)(void*, struct S_IFI, double)) ;
+EXPORT void* f16_P_PSD_IFF(void* p0, struct S_IFF p1, double p2,  void* (*cb)(void*, struct S_IFF, double)) ;
+EXPORT void* f16_P_PSD_IFD(void* p0, struct S_IFD p1, double p2,  void* (*cb)(void*, struct S_IFD, double)) ;
+EXPORT void* f16_P_PSD_IFP(void* p0, struct S_IFP p1, double p2,  void* (*cb)(void*, struct S_IFP, double)) ;
+EXPORT void* f16_P_PSD_IDI(void* p0, struct S_IDI p1, double p2,  void* (*cb)(void*, struct S_IDI, double)) ;
+EXPORT void* f16_P_PSD_IDF(void* p0, struct S_IDF p1, double p2,  void* (*cb)(void*, struct S_IDF, double)) ;
+EXPORT void* f16_P_PSD_IDD(void* p0, struct S_IDD p1, double p2,  void* (*cb)(void*, struct S_IDD, double)) ;
+EXPORT void* f16_P_PSD_IDP(void* p0, struct S_IDP p1, double p2,  void* (*cb)(void*, struct S_IDP, double)) ;
+EXPORT void* f16_P_PSD_IPI(void* p0, struct S_IPI p1, double p2,  void* (*cb)(void*, struct S_IPI, double)) ;
+EXPORT void* f16_P_PSD_IPF(void* p0, struct S_IPF p1, double p2,  void* (*cb)(void*, struct S_IPF, double)) ;
+EXPORT void* f16_P_PSD_IPD(void* p0, struct S_IPD p1, double p2,  void* (*cb)(void*, struct S_IPD, double)) ;
+EXPORT void* f16_P_PSD_IPP(void* p0, struct S_IPP p1, double p2,  void* (*cb)(void*, struct S_IPP, double)) ;
+EXPORT void* f16_P_PSD_FII(void* p0, struct S_FII p1, double p2,  void* (*cb)(void*, struct S_FII, double)) ;
+EXPORT void* f16_P_PSD_FIF(void* p0, struct S_FIF p1, double p2,  void* (*cb)(void*, struct S_FIF, double)) ;
+EXPORT void* f16_P_PSD_FID(void* p0, struct S_FID p1, double p2,  void* (*cb)(void*, struct S_FID, double)) ;
+EXPORT void* f16_P_PSD_FIP(void* p0, struct S_FIP p1, double p2,  void* (*cb)(void*, struct S_FIP, double)) ;
+EXPORT void* f16_P_PSD_FFI(void* p0, struct S_FFI p1, double p2,  void* (*cb)(void*, struct S_FFI, double)) ;
+EXPORT void* f16_P_PSD_FFF(void* p0, struct S_FFF p1, double p2,  void* (*cb)(void*, struct S_FFF, double)) ;
+EXPORT void* f16_P_PSD_FFD(void* p0, struct S_FFD p1, double p2,  void* (*cb)(void*, struct S_FFD, double)) ;
+EXPORT void* f16_P_PSD_FFP(void* p0, struct S_FFP p1, double p2,  void* (*cb)(void*, struct S_FFP, double)) ;
+EXPORT void* f16_P_PSD_FDI(void* p0, struct S_FDI p1, double p2,  void* (*cb)(void*, struct S_FDI, double)) ;
+EXPORT void* f16_P_PSD_FDF(void* p0, struct S_FDF p1, double p2,  void* (*cb)(void*, struct S_FDF, double)) ;
+EXPORT void* f16_P_PSD_FDD(void* p0, struct S_FDD p1, double p2,  void* (*cb)(void*, struct S_FDD, double)) ;
+EXPORT void* f16_P_PSD_FDP(void* p0, struct S_FDP p1, double p2,  void* (*cb)(void*, struct S_FDP, double)) ;
+EXPORT void* f16_P_PSD_FPI(void* p0, struct S_FPI p1, double p2,  void* (*cb)(void*, struct S_FPI, double)) ;
+EXPORT void* f16_P_PSD_FPF(void* p0, struct S_FPF p1, double p2,  void* (*cb)(void*, struct S_FPF, double)) ;
+EXPORT void* f16_P_PSD_FPD(void* p0, struct S_FPD p1, double p2,  void* (*cb)(void*, struct S_FPD, double)) ;
+EXPORT void* f16_P_PSD_FPP(void* p0, struct S_FPP p1, double p2,  void* (*cb)(void*, struct S_FPP, double)) ;
+EXPORT void* f16_P_PSD_DII(void* p0, struct S_DII p1, double p2,  void* (*cb)(void*, struct S_DII, double)) ;
+EXPORT void* f16_P_PSD_DIF(void* p0, struct S_DIF p1, double p2,  void* (*cb)(void*, struct S_DIF, double)) ;
+EXPORT void* f16_P_PSD_DID(void* p0, struct S_DID p1, double p2,  void* (*cb)(void*, struct S_DID, double)) ;
+EXPORT void* f16_P_PSD_DIP(void* p0, struct S_DIP p1, double p2,  void* (*cb)(void*, struct S_DIP, double)) ;
+EXPORT void* f16_P_PSD_DFI(void* p0, struct S_DFI p1, double p2,  void* (*cb)(void*, struct S_DFI, double)) ;
+EXPORT void* f16_P_PSD_DFF(void* p0, struct S_DFF p1, double p2,  void* (*cb)(void*, struct S_DFF, double)) ;
+EXPORT void* f16_P_PSD_DFD(void* p0, struct S_DFD p1, double p2,  void* (*cb)(void*, struct S_DFD, double)) ;
+EXPORT void* f16_P_PSD_DFP(void* p0, struct S_DFP p1, double p2,  void* (*cb)(void*, struct S_DFP, double)) ;
+EXPORT void* f16_P_PSD_DDI(void* p0, struct S_DDI p1, double p2,  void* (*cb)(void*, struct S_DDI, double)) ;
+EXPORT void* f16_P_PSD_DDF(void* p0, struct S_DDF p1, double p2,  void* (*cb)(void*, struct S_DDF, double)) ;
+EXPORT void* f16_P_PSD_DDD(void* p0, struct S_DDD p1, double p2,  void* (*cb)(void*, struct S_DDD, double)) ;
+EXPORT void* f16_P_PSD_DDP(void* p0, struct S_DDP p1, double p2,  void* (*cb)(void*, struct S_DDP, double)) ;
+EXPORT void* f16_P_PSD_DPI(void* p0, struct S_DPI p1, double p2,  void* (*cb)(void*, struct S_DPI, double)) ;
+EXPORT void* f16_P_PSD_DPF(void* p0, struct S_DPF p1, double p2,  void* (*cb)(void*, struct S_DPF, double)) ;
+EXPORT void* f16_P_PSD_DPD(void* p0, struct S_DPD p1, double p2,  void* (*cb)(void*, struct S_DPD, double)) ;
+EXPORT void* f16_P_PSD_DPP(void* p0, struct S_DPP p1, double p2,  void* (*cb)(void*, struct S_DPP, double)) ;
+EXPORT void* f16_P_PSD_PII(void* p0, struct S_PII p1, double p2,  void* (*cb)(void*, struct S_PII, double)) ;
+EXPORT void* f16_P_PSD_PIF(void* p0, struct S_PIF p1, double p2,  void* (*cb)(void*, struct S_PIF, double)) ;
+EXPORT void* f16_P_PSD_PID(void* p0, struct S_PID p1, double p2,  void* (*cb)(void*, struct S_PID, double)) ;
+EXPORT void* f16_P_PSD_PIP(void* p0, struct S_PIP p1, double p2,  void* (*cb)(void*, struct S_PIP, double)) ;
+EXPORT void* f16_P_PSD_PFI(void* p0, struct S_PFI p1, double p2,  void* (*cb)(void*, struct S_PFI, double)) ;
+EXPORT void* f16_P_PSD_PFF(void* p0, struct S_PFF p1, double p2,  void* (*cb)(void*, struct S_PFF, double)) ;
+EXPORT void* f16_P_PSD_PFD(void* p0, struct S_PFD p1, double p2,  void* (*cb)(void*, struct S_PFD, double)) ;
+EXPORT void* f16_P_PSD_PFP(void* p0, struct S_PFP p1, double p2,  void* (*cb)(void*, struct S_PFP, double)) ;
+EXPORT void* f16_P_PSD_PDI(void* p0, struct S_PDI p1, double p2,  void* (*cb)(void*, struct S_PDI, double)) ;
+EXPORT void* f16_P_PSD_PDF(void* p0, struct S_PDF p1, double p2,  void* (*cb)(void*, struct S_PDF, double)) ;
+EXPORT void* f16_P_PSD_PDD(void* p0, struct S_PDD p1, double p2,  void* (*cb)(void*, struct S_PDD, double)) ;
+EXPORT void* f16_P_PSD_PDP(void* p0, struct S_PDP p1, double p2,  void* (*cb)(void*, struct S_PDP, double)) ;
+EXPORT void* f16_P_PSD_PPI(void* p0, struct S_PPI p1, double p2,  void* (*cb)(void*, struct S_PPI, double)) ;
+EXPORT void* f16_P_PSD_PPF(void* p0, struct S_PPF p1, double p2,  void* (*cb)(void*, struct S_PPF, double)) ;
+EXPORT void* f16_P_PSD_PPD(void* p0, struct S_PPD p1, double p2,  void* (*cb)(void*, struct S_PPD, double)) ;
+EXPORT void* f16_P_PSD_PPP(void* p0, struct S_PPP p1, double p2,  void* (*cb)(void*, struct S_PPP, double)) ;
+EXPORT void* f16_P_PSP_I(void* p0, struct S_I p1, void* p2,  void* (*cb)(void*, struct S_I, void*)) ;
+EXPORT void* f16_P_PSP_F(void* p0, struct S_F p1, void* p2,  void* (*cb)(void*, struct S_F, void*)) ;
+EXPORT void* f16_P_PSP_D(void* p0, struct S_D p1, void* p2,  void* (*cb)(void*, struct S_D, void*)) ;
+EXPORT void* f16_P_PSP_P(void* p0, struct S_P p1, void* p2,  void* (*cb)(void*, struct S_P, void*)) ;
+EXPORT void* f16_P_PSP_II(void* p0, struct S_II p1, void* p2,  void* (*cb)(void*, struct S_II, void*)) ;
+EXPORT void* f16_P_PSP_IF(void* p0, struct S_IF p1, void* p2,  void* (*cb)(void*, struct S_IF, void*)) ;
+EXPORT void* f16_P_PSP_ID(void* p0, struct S_ID p1, void* p2,  void* (*cb)(void*, struct S_ID, void*)) ;
+EXPORT void* f16_P_PSP_IP(void* p0, struct S_IP p1, void* p2,  void* (*cb)(void*, struct S_IP, void*)) ;
+EXPORT void* f16_P_PSP_FI(void* p0, struct S_FI p1, void* p2,  void* (*cb)(void*, struct S_FI, void*)) ;
+EXPORT void* f16_P_PSP_FF(void* p0, struct S_FF p1, void* p2,  void* (*cb)(void*, struct S_FF, void*)) ;
+EXPORT void* f16_P_PSP_FD(void* p0, struct S_FD p1, void* p2,  void* (*cb)(void*, struct S_FD, void*)) ;
+EXPORT void* f16_P_PSP_FP(void* p0, struct S_FP p1, void* p2,  void* (*cb)(void*, struct S_FP, void*)) ;
+EXPORT void* f16_P_PSP_DI(void* p0, struct S_DI p1, void* p2,  void* (*cb)(void*, struct S_DI, void*)) ;
+EXPORT void* f16_P_PSP_DF(void* p0, struct S_DF p1, void* p2,  void* (*cb)(void*, struct S_DF, void*)) ;
+EXPORT void* f16_P_PSP_DD(void* p0, struct S_DD p1, void* p2,  void* (*cb)(void*, struct S_DD, void*)) ;
+EXPORT void* f16_P_PSP_DP(void* p0, struct S_DP p1, void* p2,  void* (*cb)(void*, struct S_DP, void*)) ;
+EXPORT void* f16_P_PSP_PI(void* p0, struct S_PI p1, void* p2,  void* (*cb)(void*, struct S_PI, void*)) ;
+EXPORT void* f16_P_PSP_PF(void* p0, struct S_PF p1, void* p2,  void* (*cb)(void*, struct S_PF, void*)) ;
+EXPORT void* f16_P_PSP_PD(void* p0, struct S_PD p1, void* p2,  void* (*cb)(void*, struct S_PD, void*)) ;
+EXPORT void* f16_P_PSP_PP(void* p0, struct S_PP p1, void* p2,  void* (*cb)(void*, struct S_PP, void*)) ;
+EXPORT void* f16_P_PSP_III(void* p0, struct S_III p1, void* p2,  void* (*cb)(void*, struct S_III, void*)) ;
+EXPORT void* f16_P_PSP_IIF(void* p0, struct S_IIF p1, void* p2,  void* (*cb)(void*, struct S_IIF, void*)) ;
+EXPORT void* f16_P_PSP_IID(void* p0, struct S_IID p1, void* p2,  void* (*cb)(void*, struct S_IID, void*)) ;
+EXPORT void* f16_P_PSP_IIP(void* p0, struct S_IIP p1, void* p2,  void* (*cb)(void*, struct S_IIP, void*)) ;
+EXPORT void* f16_P_PSP_IFI(void* p0, struct S_IFI p1, void* p2,  void* (*cb)(void*, struct S_IFI, void*)) ;
+EXPORT void* f16_P_PSP_IFF(void* p0, struct S_IFF p1, void* p2,  void* (*cb)(void*, struct S_IFF, void*)) ;
+EXPORT void* f16_P_PSP_IFD(void* p0, struct S_IFD p1, void* p2,  void* (*cb)(void*, struct S_IFD, void*)) ;
+EXPORT void* f16_P_PSP_IFP(void* p0, struct S_IFP p1, void* p2,  void* (*cb)(void*, struct S_IFP, void*)) ;
+EXPORT void* f16_P_PSP_IDI(void* p0, struct S_IDI p1, void* p2,  void* (*cb)(void*, struct S_IDI, void*)) ;
+EXPORT void* f16_P_PSP_IDF(void* p0, struct S_IDF p1, void* p2,  void* (*cb)(void*, struct S_IDF, void*)) ;
+EXPORT void* f16_P_PSP_IDD(void* p0, struct S_IDD p1, void* p2,  void* (*cb)(void*, struct S_IDD, void*)) ;
+EXPORT void* f16_P_PSP_IDP(void* p0, struct S_IDP p1, void* p2,  void* (*cb)(void*, struct S_IDP, void*)) ;
+EXPORT void* f16_P_PSP_IPI(void* p0, struct S_IPI p1, void* p2,  void* (*cb)(void*, struct S_IPI, void*)) ;
+EXPORT void* f16_P_PSP_IPF(void* p0, struct S_IPF p1, void* p2,  void* (*cb)(void*, struct S_IPF, void*)) ;
+EXPORT void* f16_P_PSP_IPD(void* p0, struct S_IPD p1, void* p2,  void* (*cb)(void*, struct S_IPD, void*)) ;
+EXPORT void* f16_P_PSP_IPP(void* p0, struct S_IPP p1, void* p2,  void* (*cb)(void*, struct S_IPP, void*)) ;
+EXPORT void* f16_P_PSP_FII(void* p0, struct S_FII p1, void* p2,  void* (*cb)(void*, struct S_FII, void*)) ;
+EXPORT void* f16_P_PSP_FIF(void* p0, struct S_FIF p1, void* p2,  void* (*cb)(void*, struct S_FIF, void*)) ;
+EXPORT void* f16_P_PSP_FID(void* p0, struct S_FID p1, void* p2,  void* (*cb)(void*, struct S_FID, void*)) ;
+EXPORT void* f16_P_PSP_FIP(void* p0, struct S_FIP p1, void* p2,  void* (*cb)(void*, struct S_FIP, void*)) ;
+EXPORT void* f16_P_PSP_FFI(void* p0, struct S_FFI p1, void* p2,  void* (*cb)(void*, struct S_FFI, void*)) ;
+EXPORT void* f16_P_PSP_FFF(void* p0, struct S_FFF p1, void* p2,  void* (*cb)(void*, struct S_FFF, void*)) ;
+EXPORT void* f16_P_PSP_FFD(void* p0, struct S_FFD p1, void* p2,  void* (*cb)(void*, struct S_FFD, void*)) ;
+EXPORT void* f16_P_PSP_FFP(void* p0, struct S_FFP p1, void* p2,  void* (*cb)(void*, struct S_FFP, void*)) ;
+EXPORT void* f16_P_PSP_FDI(void* p0, struct S_FDI p1, void* p2,  void* (*cb)(void*, struct S_FDI, void*)) ;
+EXPORT void* f16_P_PSP_FDF(void* p0, struct S_FDF p1, void* p2,  void* (*cb)(void*, struct S_FDF, void*)) ;
+EXPORT void* f16_P_PSP_FDD(void* p0, struct S_FDD p1, void* p2,  void* (*cb)(void*, struct S_FDD, void*)) ;
+EXPORT void* f16_P_PSP_FDP(void* p0, struct S_FDP p1, void* p2,  void* (*cb)(void*, struct S_FDP, void*)) ;
+EXPORT void* f16_P_PSP_FPI(void* p0, struct S_FPI p1, void* p2,  void* (*cb)(void*, struct S_FPI, void*)) ;
+EXPORT void* f16_P_PSP_FPF(void* p0, struct S_FPF p1, void* p2,  void* (*cb)(void*, struct S_FPF, void*)) ;
+EXPORT void* f16_P_PSP_FPD(void* p0, struct S_FPD p1, void* p2,  void* (*cb)(void*, struct S_FPD, void*)) ;
+EXPORT void* f16_P_PSP_FPP(void* p0, struct S_FPP p1, void* p2,  void* (*cb)(void*, struct S_FPP, void*)) ;
+EXPORT void* f16_P_PSP_DII(void* p0, struct S_DII p1, void* p2,  void* (*cb)(void*, struct S_DII, void*)) ;
+EXPORT void* f16_P_PSP_DIF(void* p0, struct S_DIF p1, void* p2,  void* (*cb)(void*, struct S_DIF, void*)) ;
+EXPORT void* f16_P_PSP_DID(void* p0, struct S_DID p1, void* p2,  void* (*cb)(void*, struct S_DID, void*)) ;
+EXPORT void* f16_P_PSP_DIP(void* p0, struct S_DIP p1, void* p2,  void* (*cb)(void*, struct S_DIP, void*)) ;
+EXPORT void* f16_P_PSP_DFI(void* p0, struct S_DFI p1, void* p2,  void* (*cb)(void*, struct S_DFI, void*)) ;
+EXPORT void* f16_P_PSP_DFF(void* p0, struct S_DFF p1, void* p2,  void* (*cb)(void*, struct S_DFF, void*)) ;
+EXPORT void* f16_P_PSP_DFD(void* p0, struct S_DFD p1, void* p2,  void* (*cb)(void*, struct S_DFD, void*)) ;
+EXPORT void* f16_P_PSP_DFP(void* p0, struct S_DFP p1, void* p2,  void* (*cb)(void*, struct S_DFP, void*)) ;
+EXPORT void* f16_P_PSP_DDI(void* p0, struct S_DDI p1, void* p2,  void* (*cb)(void*, struct S_DDI, void*)) ;
+EXPORT void* f16_P_PSP_DDF(void* p0, struct S_DDF p1, void* p2,  void* (*cb)(void*, struct S_DDF, void*)) ;
+EXPORT void* f16_P_PSP_DDD(void* p0, struct S_DDD p1, void* p2,  void* (*cb)(void*, struct S_DDD, void*)) ;
+EXPORT void* f16_P_PSP_DDP(void* p0, struct S_DDP p1, void* p2,  void* (*cb)(void*, struct S_DDP, void*)) ;
+EXPORT void* f16_P_PSP_DPI(void* p0, struct S_DPI p1, void* p2,  void* (*cb)(void*, struct S_DPI, void*)) ;
+EXPORT void* f16_P_PSP_DPF(void* p0, struct S_DPF p1, void* p2,  void* (*cb)(void*, struct S_DPF, void*)) ;
+EXPORT void* f16_P_PSP_DPD(void* p0, struct S_DPD p1, void* p2,  void* (*cb)(void*, struct S_DPD, void*)) ;
+EXPORT void* f16_P_PSP_DPP(void* p0, struct S_DPP p1, void* p2,  void* (*cb)(void*, struct S_DPP, void*)) ;
+EXPORT void* f16_P_PSP_PII(void* p0, struct S_PII p1, void* p2,  void* (*cb)(void*, struct S_PII, void*)) ;
+EXPORT void* f16_P_PSP_PIF(void* p0, struct S_PIF p1, void* p2,  void* (*cb)(void*, struct S_PIF, void*)) ;
+EXPORT void* f16_P_PSP_PID(void* p0, struct S_PID p1, void* p2,  void* (*cb)(void*, struct S_PID, void*)) ;
+EXPORT void* f16_P_PSP_PIP(void* p0, struct S_PIP p1, void* p2,  void* (*cb)(void*, struct S_PIP, void*)) ;
+EXPORT void* f16_P_PSP_PFI(void* p0, struct S_PFI p1, void* p2,  void* (*cb)(void*, struct S_PFI, void*)) ;
+EXPORT void* f16_P_PSP_PFF(void* p0, struct S_PFF p1, void* p2,  void* (*cb)(void*, struct S_PFF, void*)) ;
+EXPORT void* f16_P_PSP_PFD(void* p0, struct S_PFD p1, void* p2,  void* (*cb)(void*, struct S_PFD, void*)) ;
+EXPORT void* f16_P_PSP_PFP(void* p0, struct S_PFP p1, void* p2,  void* (*cb)(void*, struct S_PFP, void*)) ;
+EXPORT void* f16_P_PSP_PDI(void* p0, struct S_PDI p1, void* p2,  void* (*cb)(void*, struct S_PDI, void*)) ;
+EXPORT void* f16_P_PSP_PDF(void* p0, struct S_PDF p1, void* p2,  void* (*cb)(void*, struct S_PDF, void*)) ;
+EXPORT void* f16_P_PSP_PDD(void* p0, struct S_PDD p1, void* p2,  void* (*cb)(void*, struct S_PDD, void*)) ;
+EXPORT void* f16_P_PSP_PDP(void* p0, struct S_PDP p1, void* p2,  void* (*cb)(void*, struct S_PDP, void*)) ;
+EXPORT void* f16_P_PSP_PPI(void* p0, struct S_PPI p1, void* p2,  void* (*cb)(void*, struct S_PPI, void*)) ;
+EXPORT void* f16_P_PSP_PPF(void* p0, struct S_PPF p1, void* p2,  void* (*cb)(void*, struct S_PPF, void*)) ;
+EXPORT void* f16_P_PSP_PPD(void* p0, struct S_PPD p1, void* p2,  void* (*cb)(void*, struct S_PPD, void*)) ;
+EXPORT void* f16_P_PSP_PPP(void* p0, struct S_PPP p1, void* p2,  void* (*cb)(void*, struct S_PPP, void*)) ;
+EXPORT void* f16_P_PSS_I(void* p0, struct S_I p1, struct S_I p2,  void* (*cb)(void*, struct S_I, struct S_I)) ;
+EXPORT void* f16_P_PSS_F(void* p0, struct S_F p1, struct S_F p2,  void* (*cb)(void*, struct S_F, struct S_F)) ;
+EXPORT void* f16_P_PSS_D(void* p0, struct S_D p1, struct S_D p2,  void* (*cb)(void*, struct S_D, struct S_D)) ;
+EXPORT void* f16_P_PSS_P(void* p0, struct S_P p1, struct S_P p2,  void* (*cb)(void*, struct S_P, struct S_P)) ;
+EXPORT void* f16_P_PSS_II(void* p0, struct S_II p1, struct S_II p2,  void* (*cb)(void*, struct S_II, struct S_II)) ;
+EXPORT void* f16_P_PSS_IF(void* p0, struct S_IF p1, struct S_IF p2,  void* (*cb)(void*, struct S_IF, struct S_IF)) ;
+EXPORT void* f16_P_PSS_ID(void* p0, struct S_ID p1, struct S_ID p2,  void* (*cb)(void*, struct S_ID, struct S_ID)) ;
+EXPORT void* f16_P_PSS_IP(void* p0, struct S_IP p1, struct S_IP p2,  void* (*cb)(void*, struct S_IP, struct S_IP)) ;
+EXPORT void* f16_P_PSS_FI(void* p0, struct S_FI p1, struct S_FI p2,  void* (*cb)(void*, struct S_FI, struct S_FI)) ;
+EXPORT void* f16_P_PSS_FF(void* p0, struct S_FF p1, struct S_FF p2,  void* (*cb)(void*, struct S_FF, struct S_FF)) ;
+EXPORT void* f16_P_PSS_FD(void* p0, struct S_FD p1, struct S_FD p2,  void* (*cb)(void*, struct S_FD, struct S_FD)) ;
+EXPORT void* f16_P_PSS_FP(void* p0, struct S_FP p1, struct S_FP p2,  void* (*cb)(void*, struct S_FP, struct S_FP)) ;
+EXPORT void* f16_P_PSS_DI(void* p0, struct S_DI p1, struct S_DI p2,  void* (*cb)(void*, struct S_DI, struct S_DI)) ;
+EXPORT void* f16_P_PSS_DF(void* p0, struct S_DF p1, struct S_DF p2,  void* (*cb)(void*, struct S_DF, struct S_DF)) ;
+EXPORT void* f16_P_PSS_DD(void* p0, struct S_DD p1, struct S_DD p2,  void* (*cb)(void*, struct S_DD, struct S_DD)) ;
+EXPORT void* f16_P_PSS_DP(void* p0, struct S_DP p1, struct S_DP p2,  void* (*cb)(void*, struct S_DP, struct S_DP)) ;
+EXPORT void* f16_P_PSS_PI(void* p0, struct S_PI p1, struct S_PI p2,  void* (*cb)(void*, struct S_PI, struct S_PI)) ;
+EXPORT void* f16_P_PSS_PF(void* p0, struct S_PF p1, struct S_PF p2,  void* (*cb)(void*, struct S_PF, struct S_PF)) ;
+EXPORT void* f16_P_PSS_PD(void* p0, struct S_PD p1, struct S_PD p2,  void* (*cb)(void*, struct S_PD, struct S_PD)) ;
+EXPORT void* f16_P_PSS_PP(void* p0, struct S_PP p1, struct S_PP p2,  void* (*cb)(void*, struct S_PP, struct S_PP)) ;
+EXPORT void* f16_P_PSS_III(void* p0, struct S_III p1, struct S_III p2,  void* (*cb)(void*, struct S_III, struct S_III)) ;
+EXPORT void* f16_P_PSS_IIF(void* p0, struct S_IIF p1, struct S_IIF p2,  void* (*cb)(void*, struct S_IIF, struct S_IIF)) ;
+EXPORT void* f16_P_PSS_IID(void* p0, struct S_IID p1, struct S_IID p2,  void* (*cb)(void*, struct S_IID, struct S_IID)) ;
+EXPORT void* f16_P_PSS_IIP(void* p0, struct S_IIP p1, struct S_IIP p2,  void* (*cb)(void*, struct S_IIP, struct S_IIP)) ;
+EXPORT void* f16_P_PSS_IFI(void* p0, struct S_IFI p1, struct S_IFI p2,  void* (*cb)(void*, struct S_IFI, struct S_IFI)) ;
+EXPORT void* f16_P_PSS_IFF(void* p0, struct S_IFF p1, struct S_IFF p2,  void* (*cb)(void*, struct S_IFF, struct S_IFF)) ;
+EXPORT void* f16_P_PSS_IFD(void* p0, struct S_IFD p1, struct S_IFD p2,  void* (*cb)(void*, struct S_IFD, struct S_IFD)) ;
+EXPORT void* f16_P_PSS_IFP(void* p0, struct S_IFP p1, struct S_IFP p2,  void* (*cb)(void*, struct S_IFP, struct S_IFP)) ;
+EXPORT void* f16_P_PSS_IDI(void* p0, struct S_IDI p1, struct S_IDI p2,  void* (*cb)(void*, struct S_IDI, struct S_IDI)) ;
+EXPORT void* f16_P_PSS_IDF(void* p0, struct S_IDF p1, struct S_IDF p2,  void* (*cb)(void*, struct S_IDF, struct S_IDF)) ;
+EXPORT void* f16_P_PSS_IDD(void* p0, struct S_IDD p1, struct S_IDD p2,  void* (*cb)(void*, struct S_IDD, struct S_IDD)) ;
+EXPORT void* f16_P_PSS_IDP(void* p0, struct S_IDP p1, struct S_IDP p2,  void* (*cb)(void*, struct S_IDP, struct S_IDP)) ;
+EXPORT void* f16_P_PSS_IPI(void* p0, struct S_IPI p1, struct S_IPI p2,  void* (*cb)(void*, struct S_IPI, struct S_IPI)) ;
+EXPORT void* f16_P_PSS_IPF(void* p0, struct S_IPF p1, struct S_IPF p2,  void* (*cb)(void*, struct S_IPF, struct S_IPF)) ;
+EXPORT void* f16_P_PSS_IPD(void* p0, struct S_IPD p1, struct S_IPD p2,  void* (*cb)(void*, struct S_IPD, struct S_IPD)) ;
+EXPORT void* f16_P_PSS_IPP(void* p0, struct S_IPP p1, struct S_IPP p2,  void* (*cb)(void*, struct S_IPP, struct S_IPP)) ;
+EXPORT void* f16_P_PSS_FII(void* p0, struct S_FII p1, struct S_FII p2,  void* (*cb)(void*, struct S_FII, struct S_FII)) ;
+EXPORT void* f16_P_PSS_FIF(void* p0, struct S_FIF p1, struct S_FIF p2,  void* (*cb)(void*, struct S_FIF, struct S_FIF)) ;
+EXPORT void* f16_P_PSS_FID(void* p0, struct S_FID p1, struct S_FID p2,  void* (*cb)(void*, struct S_FID, struct S_FID)) ;
+EXPORT void* f16_P_PSS_FIP(void* p0, struct S_FIP p1, struct S_FIP p2,  void* (*cb)(void*, struct S_FIP, struct S_FIP)) ;
+EXPORT void* f16_P_PSS_FFI(void* p0, struct S_FFI p1, struct S_FFI p2,  void* (*cb)(void*, struct S_FFI, struct S_FFI)) ;
+EXPORT void* f16_P_PSS_FFF(void* p0, struct S_FFF p1, struct S_FFF p2,  void* (*cb)(void*, struct S_FFF, struct S_FFF)) ;
+EXPORT void* f16_P_PSS_FFD(void* p0, struct S_FFD p1, struct S_FFD p2,  void* (*cb)(void*, struct S_FFD, struct S_FFD)) ;
+EXPORT void* f16_P_PSS_FFP(void* p0, struct S_FFP p1, struct S_FFP p2,  void* (*cb)(void*, struct S_FFP, struct S_FFP)) ;
+EXPORT void* f16_P_PSS_FDI(void* p0, struct S_FDI p1, struct S_FDI p2,  void* (*cb)(void*, struct S_FDI, struct S_FDI)) ;
+EXPORT void* f16_P_PSS_FDF(void* p0, struct S_FDF p1, struct S_FDF p2,  void* (*cb)(void*, struct S_FDF, struct S_FDF)) ;
+EXPORT void* f16_P_PSS_FDD(void* p0, struct S_FDD p1, struct S_FDD p2,  void* (*cb)(void*, struct S_FDD, struct S_FDD)) ;
+EXPORT void* f16_P_PSS_FDP(void* p0, struct S_FDP p1, struct S_FDP p2,  void* (*cb)(void*, struct S_FDP, struct S_FDP)) ;
+EXPORT void* f16_P_PSS_FPI(void* p0, struct S_FPI p1, struct S_FPI p2,  void* (*cb)(void*, struct S_FPI, struct S_FPI)) ;
+EXPORT void* f16_P_PSS_FPF(void* p0, struct S_FPF p1, struct S_FPF p2,  void* (*cb)(void*, struct S_FPF, struct S_FPF)) ;
+EXPORT void* f16_P_PSS_FPD(void* p0, struct S_FPD p1, struct S_FPD p2,  void* (*cb)(void*, struct S_FPD, struct S_FPD)) ;
+EXPORT void* f16_P_PSS_FPP(void* p0, struct S_FPP p1, struct S_FPP p2,  void* (*cb)(void*, struct S_FPP, struct S_FPP)) ;
+EXPORT void* f16_P_PSS_DII(void* p0, struct S_DII p1, struct S_DII p2,  void* (*cb)(void*, struct S_DII, struct S_DII)) ;
+EXPORT void* f16_P_PSS_DIF(void* p0, struct S_DIF p1, struct S_DIF p2,  void* (*cb)(void*, struct S_DIF, struct S_DIF)) ;
+EXPORT void* f16_P_PSS_DID(void* p0, struct S_DID p1, struct S_DID p2,  void* (*cb)(void*, struct S_DID, struct S_DID)) ;
+EXPORT void* f16_P_PSS_DIP(void* p0, struct S_DIP p1, struct S_DIP p2,  void* (*cb)(void*, struct S_DIP, struct S_DIP)) ;
+EXPORT void* f16_P_PSS_DFI(void* p0, struct S_DFI p1, struct S_DFI p2,  void* (*cb)(void*, struct S_DFI, struct S_DFI)) ;
+EXPORT void* f16_P_PSS_DFF(void* p0, struct S_DFF p1, struct S_DFF p2,  void* (*cb)(void*, struct S_DFF, struct S_DFF)) ;
+EXPORT void* f16_P_PSS_DFD(void* p0, struct S_DFD p1, struct S_DFD p2,  void* (*cb)(void*, struct S_DFD, struct S_DFD)) ;
+EXPORT void* f16_P_PSS_DFP(void* p0, struct S_DFP p1, struct S_DFP p2,  void* (*cb)(void*, struct S_DFP, struct S_DFP)) ;
+EXPORT void* f16_P_PSS_DDI(void* p0, struct S_DDI p1, struct S_DDI p2,  void* (*cb)(void*, struct S_DDI, struct S_DDI)) ;
+EXPORT void* f16_P_PSS_DDF(void* p0, struct S_DDF p1, struct S_DDF p2,  void* (*cb)(void*, struct S_DDF, struct S_DDF)) ;
+EXPORT void* f16_P_PSS_DDD(void* p0, struct S_DDD p1, struct S_DDD p2,  void* (*cb)(void*, struct S_DDD, struct S_DDD)) ;
+EXPORT void* f16_P_PSS_DDP(void* p0, struct S_DDP p1, struct S_DDP p2,  void* (*cb)(void*, struct S_DDP, struct S_DDP)) ;
+EXPORT void* f16_P_PSS_DPI(void* p0, struct S_DPI p1, struct S_DPI p2,  void* (*cb)(void*, struct S_DPI, struct S_DPI)) ;
+EXPORT void* f16_P_PSS_DPF(void* p0, struct S_DPF p1, struct S_DPF p2,  void* (*cb)(void*, struct S_DPF, struct S_DPF)) ;
+EXPORT void* f16_P_PSS_DPD(void* p0, struct S_DPD p1, struct S_DPD p2,  void* (*cb)(void*, struct S_DPD, struct S_DPD)) ;
+EXPORT void* f16_P_PSS_DPP(void* p0, struct S_DPP p1, struct S_DPP p2,  void* (*cb)(void*, struct S_DPP, struct S_DPP)) ;
+EXPORT void* f16_P_PSS_PII(void* p0, struct S_PII p1, struct S_PII p2,  void* (*cb)(void*, struct S_PII, struct S_PII)) ;
+EXPORT void* f16_P_PSS_PIF(void* p0, struct S_PIF p1, struct S_PIF p2,  void* (*cb)(void*, struct S_PIF, struct S_PIF)) ;
+EXPORT void* f16_P_PSS_PID(void* p0, struct S_PID p1, struct S_PID p2,  void* (*cb)(void*, struct S_PID, struct S_PID)) ;
+EXPORT void* f16_P_PSS_PIP(void* p0, struct S_PIP p1, struct S_PIP p2,  void* (*cb)(void*, struct S_PIP, struct S_PIP)) ;
+EXPORT void* f16_P_PSS_PFI(void* p0, struct S_PFI p1, struct S_PFI p2,  void* (*cb)(void*, struct S_PFI, struct S_PFI)) ;
+EXPORT void* f16_P_PSS_PFF(void* p0, struct S_PFF p1, struct S_PFF p2,  void* (*cb)(void*, struct S_PFF, struct S_PFF)) ;
+EXPORT void* f16_P_PSS_PFD(void* p0, struct S_PFD p1, struct S_PFD p2,  void* (*cb)(void*, struct S_PFD, struct S_PFD)) ;
+EXPORT void* f16_P_PSS_PFP(void* p0, struct S_PFP p1, struct S_PFP p2,  void* (*cb)(void*, struct S_PFP, struct S_PFP)) ;
+EXPORT void* f16_P_PSS_PDI(void* p0, struct S_PDI p1, struct S_PDI p2,  void* (*cb)(void*, struct S_PDI, struct S_PDI)) ;
+EXPORT void* f16_P_PSS_PDF(void* p0, struct S_PDF p1, struct S_PDF p2,  void* (*cb)(void*, struct S_PDF, struct S_PDF)) ;
+EXPORT void* f16_P_PSS_PDD(void* p0, struct S_PDD p1, struct S_PDD p2,  void* (*cb)(void*, struct S_PDD, struct S_PDD)) ;
+EXPORT void* f16_P_PSS_PDP(void* p0, struct S_PDP p1, struct S_PDP p2,  void* (*cb)(void*, struct S_PDP, struct S_PDP)) ;
+EXPORT void* f16_P_PSS_PPI(void* p0, struct S_PPI p1, struct S_PPI p2,  void* (*cb)(void*, struct S_PPI, struct S_PPI)) ;
+EXPORT void* f16_P_PSS_PPF(void* p0, struct S_PPF p1, struct S_PPF p2,  void* (*cb)(void*, struct S_PPF, struct S_PPF)) ;
+EXPORT void* f16_P_PSS_PPD(void* p0, struct S_PPD p1, struct S_PPD p2,  void* (*cb)(void*, struct S_PPD, struct S_PPD)) ;
+EXPORT void* f16_P_PSS_PPP(void* p0, struct S_PPP p1, struct S_PPP p2,  void* (*cb)(void*, struct S_PPP, struct S_PPP)) ;
+EXPORT struct S_I f16_S_SII_I(struct S_I p0, int p1, int p2,  struct S_I (*cb)(struct S_I, int, int)) ;
+EXPORT struct S_F f16_S_SII_F(struct S_F p0, int p1, int p2,  struct S_F (*cb)(struct S_F, int, int)) ;
+EXPORT struct S_D f16_S_SII_D(struct S_D p0, int p1, int p2,  struct S_D (*cb)(struct S_D, int, int)) ;
+EXPORT struct S_P f16_S_SII_P(struct S_P p0, int p1, int p2,  struct S_P (*cb)(struct S_P, int, int)) ;
+EXPORT struct S_II f16_S_SII_II(struct S_II p0, int p1, int p2,  struct S_II (*cb)(struct S_II, int, int)) ;
+EXPORT struct S_IF f16_S_SII_IF(struct S_IF p0, int p1, int p2,  struct S_IF (*cb)(struct S_IF, int, int)) ;
+EXPORT struct S_ID f16_S_SII_ID(struct S_ID p0, int p1, int p2,  struct S_ID (*cb)(struct S_ID, int, int)) ;
+EXPORT struct S_IP f16_S_SII_IP(struct S_IP p0, int p1, int p2,  struct S_IP (*cb)(struct S_IP, int, int)) ;
+EXPORT struct S_FI f16_S_SII_FI(struct S_FI p0, int p1, int p2,  struct S_FI (*cb)(struct S_FI, int, int)) ;
+EXPORT struct S_FF f16_S_SII_FF(struct S_FF p0, int p1, int p2,  struct S_FF (*cb)(struct S_FF, int, int)) ;
+EXPORT struct S_FD f16_S_SII_FD(struct S_FD p0, int p1, int p2,  struct S_FD (*cb)(struct S_FD, int, int)) ;
+EXPORT struct S_FP f16_S_SII_FP(struct S_FP p0, int p1, int p2,  struct S_FP (*cb)(struct S_FP, int, int)) ;
+EXPORT struct S_DI f16_S_SII_DI(struct S_DI p0, int p1, int p2,  struct S_DI (*cb)(struct S_DI, int, int)) ;
+EXPORT struct S_DF f16_S_SII_DF(struct S_DF p0, int p1, int p2,  struct S_DF (*cb)(struct S_DF, int, int)) ;
+EXPORT struct S_DD f16_S_SII_DD(struct S_DD p0, int p1, int p2,  struct S_DD (*cb)(struct S_DD, int, int)) ;
+EXPORT struct S_DP f16_S_SII_DP(struct S_DP p0, int p1, int p2,  struct S_DP (*cb)(struct S_DP, int, int)) ;
+EXPORT struct S_PI f16_S_SII_PI(struct S_PI p0, int p1, int p2,  struct S_PI (*cb)(struct S_PI, int, int)) ;
+EXPORT struct S_PF f16_S_SII_PF(struct S_PF p0, int p1, int p2,  struct S_PF (*cb)(struct S_PF, int, int)) ;
+EXPORT struct S_PD f16_S_SII_PD(struct S_PD p0, int p1, int p2,  struct S_PD (*cb)(struct S_PD, int, int)) ;
+EXPORT struct S_PP f16_S_SII_PP(struct S_PP p0, int p1, int p2,  struct S_PP (*cb)(struct S_PP, int, int)) ;
+EXPORT struct S_III f16_S_SII_III(struct S_III p0, int p1, int p2,  struct S_III (*cb)(struct S_III, int, int)) ;
+EXPORT struct S_IIF f16_S_SII_IIF(struct S_IIF p0, int p1, int p2,  struct S_IIF (*cb)(struct S_IIF, int, int)) ;
+EXPORT struct S_IID f16_S_SII_IID(struct S_IID p0, int p1, int p2,  struct S_IID (*cb)(struct S_IID, int, int)) ;
+EXPORT struct S_IIP f16_S_SII_IIP(struct S_IIP p0, int p1, int p2,  struct S_IIP (*cb)(struct S_IIP, int, int)) ;
+EXPORT struct S_IFI f16_S_SII_IFI(struct S_IFI p0, int p1, int p2,  struct S_IFI (*cb)(struct S_IFI, int, int)) ;
+EXPORT struct S_IFF f16_S_SII_IFF(struct S_IFF p0, int p1, int p2,  struct S_IFF (*cb)(struct S_IFF, int, int)) ;
+EXPORT struct S_IFD f16_S_SII_IFD(struct S_IFD p0, int p1, int p2,  struct S_IFD (*cb)(struct S_IFD, int, int)) ;
+EXPORT struct S_IFP f16_S_SII_IFP(struct S_IFP p0, int p1, int p2,  struct S_IFP (*cb)(struct S_IFP, int, int)) ;
+EXPORT struct S_IDI f16_S_SII_IDI(struct S_IDI p0, int p1, int p2,  struct S_IDI (*cb)(struct S_IDI, int, int)) ;
+EXPORT struct S_IDF f16_S_SII_IDF(struct S_IDF p0, int p1, int p2,  struct S_IDF (*cb)(struct S_IDF, int, int)) ;
+EXPORT struct S_IDD f16_S_SII_IDD(struct S_IDD p0, int p1, int p2,  struct S_IDD (*cb)(struct S_IDD, int, int)) ;
+EXPORT struct S_IDP f16_S_SII_IDP(struct S_IDP p0, int p1, int p2,  struct S_IDP (*cb)(struct S_IDP, int, int)) ;
+EXPORT struct S_IPI f16_S_SII_IPI(struct S_IPI p0, int p1, int p2,  struct S_IPI (*cb)(struct S_IPI, int, int)) ;
+EXPORT struct S_IPF f16_S_SII_IPF(struct S_IPF p0, int p1, int p2,  struct S_IPF (*cb)(struct S_IPF, int, int)) ;
+EXPORT struct S_IPD f16_S_SII_IPD(struct S_IPD p0, int p1, int p2,  struct S_IPD (*cb)(struct S_IPD, int, int)) ;
+EXPORT struct S_IPP f16_S_SII_IPP(struct S_IPP p0, int p1, int p2,  struct S_IPP (*cb)(struct S_IPP, int, int)) ;
+EXPORT struct S_FII f16_S_SII_FII(struct S_FII p0, int p1, int p2,  struct S_FII (*cb)(struct S_FII, int, int)) ;
+EXPORT struct S_FIF f16_S_SII_FIF(struct S_FIF p0, int p1, int p2,  struct S_FIF (*cb)(struct S_FIF, int, int)) ;
+EXPORT struct S_FID f16_S_SII_FID(struct S_FID p0, int p1, int p2,  struct S_FID (*cb)(struct S_FID, int, int)) ;
+EXPORT struct S_FIP f16_S_SII_FIP(struct S_FIP p0, int p1, int p2,  struct S_FIP (*cb)(struct S_FIP, int, int)) ;
+EXPORT struct S_FFI f16_S_SII_FFI(struct S_FFI p0, int p1, int p2,  struct S_FFI (*cb)(struct S_FFI, int, int)) ;
+EXPORT struct S_FFF f16_S_SII_FFF(struct S_FFF p0, int p1, int p2,  struct S_FFF (*cb)(struct S_FFF, int, int)) ;
+EXPORT struct S_FFD f16_S_SII_FFD(struct S_FFD p0, int p1, int p2,  struct S_FFD (*cb)(struct S_FFD, int, int)) ;
+EXPORT struct S_FFP f16_S_SII_FFP(struct S_FFP p0, int p1, int p2,  struct S_FFP (*cb)(struct S_FFP, int, int)) ;
+EXPORT struct S_FDI f16_S_SII_FDI(struct S_FDI p0, int p1, int p2,  struct S_FDI (*cb)(struct S_FDI, int, int)) ;
+EXPORT struct S_FDF f16_S_SII_FDF(struct S_FDF p0, int p1, int p2,  struct S_FDF (*cb)(struct S_FDF, int, int)) ;
+EXPORT struct S_FDD f16_S_SII_FDD(struct S_FDD p0, int p1, int p2,  struct S_FDD (*cb)(struct S_FDD, int, int)) ;
+EXPORT struct S_FDP f16_S_SII_FDP(struct S_FDP p0, int p1, int p2,  struct S_FDP (*cb)(struct S_FDP, int, int)) ;
+EXPORT struct S_FPI f16_S_SII_FPI(struct S_FPI p0, int p1, int p2,  struct S_FPI (*cb)(struct S_FPI, int, int)) ;
+EXPORT struct S_FPF f16_S_SII_FPF(struct S_FPF p0, int p1, int p2,  struct S_FPF (*cb)(struct S_FPF, int, int)) ;
+EXPORT struct S_FPD f16_S_SII_FPD(struct S_FPD p0, int p1, int p2,  struct S_FPD (*cb)(struct S_FPD, int, int)) ;
+EXPORT struct S_FPP f16_S_SII_FPP(struct S_FPP p0, int p1, int p2,  struct S_FPP (*cb)(struct S_FPP, int, int)) ;
+EXPORT struct S_DII f16_S_SII_DII(struct S_DII p0, int p1, int p2,  struct S_DII (*cb)(struct S_DII, int, int)) ;
+EXPORT struct S_DIF f16_S_SII_DIF(struct S_DIF p0, int p1, int p2,  struct S_DIF (*cb)(struct S_DIF, int, int)) ;
+EXPORT struct S_DID f16_S_SII_DID(struct S_DID p0, int p1, int p2,  struct S_DID (*cb)(struct S_DID, int, int)) ;
+EXPORT struct S_DIP f16_S_SII_DIP(struct S_DIP p0, int p1, int p2,  struct S_DIP (*cb)(struct S_DIP, int, int)) ;
+EXPORT struct S_DFI f16_S_SII_DFI(struct S_DFI p0, int p1, int p2,  struct S_DFI (*cb)(struct S_DFI, int, int)) ;
+EXPORT struct S_DFF f16_S_SII_DFF(struct S_DFF p0, int p1, int p2,  struct S_DFF (*cb)(struct S_DFF, int, int)) ;
+EXPORT struct S_DFD f16_S_SII_DFD(struct S_DFD p0, int p1, int p2,  struct S_DFD (*cb)(struct S_DFD, int, int)) ;
+EXPORT struct S_DFP f16_S_SII_DFP(struct S_DFP p0, int p1, int p2,  struct S_DFP (*cb)(struct S_DFP, int, int)) ;
+EXPORT struct S_DDI f16_S_SII_DDI(struct S_DDI p0, int p1, int p2,  struct S_DDI (*cb)(struct S_DDI, int, int)) ;
+EXPORT struct S_DDF f16_S_SII_DDF(struct S_DDF p0, int p1, int p2,  struct S_DDF (*cb)(struct S_DDF, int, int)) ;
+EXPORT struct S_DDD f16_S_SII_DDD(struct S_DDD p0, int p1, int p2,  struct S_DDD (*cb)(struct S_DDD, int, int)) ;
+EXPORT struct S_DDP f16_S_SII_DDP(struct S_DDP p0, int p1, int p2,  struct S_DDP (*cb)(struct S_DDP, int, int)) ;
+EXPORT struct S_DPI f16_S_SII_DPI(struct S_DPI p0, int p1, int p2,  struct S_DPI (*cb)(struct S_DPI, int, int)) ;
+EXPORT struct S_DPF f16_S_SII_DPF(struct S_DPF p0, int p1, int p2,  struct S_DPF (*cb)(struct S_DPF, int, int)) ;
+EXPORT struct S_DPD f16_S_SII_DPD(struct S_DPD p0, int p1, int p2,  struct S_DPD (*cb)(struct S_DPD, int, int)) ;
+EXPORT struct S_DPP f16_S_SII_DPP(struct S_DPP p0, int p1, int p2,  struct S_DPP (*cb)(struct S_DPP, int, int)) ;
+EXPORT struct S_PII f16_S_SII_PII(struct S_PII p0, int p1, int p2,  struct S_PII (*cb)(struct S_PII, int, int)) ;
+EXPORT struct S_PIF f16_S_SII_PIF(struct S_PIF p0, int p1, int p2,  struct S_PIF (*cb)(struct S_PIF, int, int)) ;
+EXPORT struct S_PID f16_S_SII_PID(struct S_PID p0, int p1, int p2,  struct S_PID (*cb)(struct S_PID, int, int)) ;
+EXPORT struct S_PIP f16_S_SII_PIP(struct S_PIP p0, int p1, int p2,  struct S_PIP (*cb)(struct S_PIP, int, int)) ;
+EXPORT struct S_PFI f16_S_SII_PFI(struct S_PFI p0, int p1, int p2,  struct S_PFI (*cb)(struct S_PFI, int, int)) ;
+EXPORT struct S_PFF f16_S_SII_PFF(struct S_PFF p0, int p1, int p2,  struct S_PFF (*cb)(struct S_PFF, int, int)) ;
+EXPORT struct S_PFD f16_S_SII_PFD(struct S_PFD p0, int p1, int p2,  struct S_PFD (*cb)(struct S_PFD, int, int)) ;
+EXPORT struct S_PFP f16_S_SII_PFP(struct S_PFP p0, int p1, int p2,  struct S_PFP (*cb)(struct S_PFP, int, int)) ;
+EXPORT struct S_PDI f16_S_SII_PDI(struct S_PDI p0, int p1, int p2,  struct S_PDI (*cb)(struct S_PDI, int, int)) ;
+EXPORT struct S_PDF f16_S_SII_PDF(struct S_PDF p0, int p1, int p2,  struct S_PDF (*cb)(struct S_PDF, int, int)) ;
+EXPORT struct S_PDD f16_S_SII_PDD(struct S_PDD p0, int p1, int p2,  struct S_PDD (*cb)(struct S_PDD, int, int)) ;
+EXPORT struct S_PDP f16_S_SII_PDP(struct S_PDP p0, int p1, int p2,  struct S_PDP (*cb)(struct S_PDP, int, int)) ;
+EXPORT struct S_PPI f16_S_SII_PPI(struct S_PPI p0, int p1, int p2,  struct S_PPI (*cb)(struct S_PPI, int, int)) ;
+EXPORT struct S_PPF f16_S_SII_PPF(struct S_PPF p0, int p1, int p2,  struct S_PPF (*cb)(struct S_PPF, int, int)) ;
+EXPORT struct S_PPD f16_S_SII_PPD(struct S_PPD p0, int p1, int p2,  struct S_PPD (*cb)(struct S_PPD, int, int)) ;
+EXPORT struct S_PPP f16_S_SII_PPP(struct S_PPP p0, int p1, int p2,  struct S_PPP (*cb)(struct S_PPP, int, int)) ;
+EXPORT struct S_I f16_S_SIF_I(struct S_I p0, int p1, float p2,  struct S_I (*cb)(struct S_I, int, float)) ;
+EXPORT struct S_F f16_S_SIF_F(struct S_F p0, int p1, float p2,  struct S_F (*cb)(struct S_F, int, float)) ;
+EXPORT struct S_D f16_S_SIF_D(struct S_D p0, int p1, float p2,  struct S_D (*cb)(struct S_D, int, float)) ;
+EXPORT struct S_P f16_S_SIF_P(struct S_P p0, int p1, float p2,  struct S_P (*cb)(struct S_P, int, float)) ;
+EXPORT struct S_II f16_S_SIF_II(struct S_II p0, int p1, float p2,  struct S_II (*cb)(struct S_II, int, float)) ;
+EXPORT struct S_IF f16_S_SIF_IF(struct S_IF p0, int p1, float p2,  struct S_IF (*cb)(struct S_IF, int, float)) ;
+EXPORT struct S_ID f16_S_SIF_ID(struct S_ID p0, int p1, float p2,  struct S_ID (*cb)(struct S_ID, int, float)) ;
+EXPORT struct S_IP f16_S_SIF_IP(struct S_IP p0, int p1, float p2,  struct S_IP (*cb)(struct S_IP, int, float)) ;
+EXPORT struct S_FI f16_S_SIF_FI(struct S_FI p0, int p1, float p2,  struct S_FI (*cb)(struct S_FI, int, float)) ;
+EXPORT struct S_FF f16_S_SIF_FF(struct S_FF p0, int p1, float p2,  struct S_FF (*cb)(struct S_FF, int, float)) ;
+EXPORT struct S_FD f16_S_SIF_FD(struct S_FD p0, int p1, float p2,  struct S_FD (*cb)(struct S_FD, int, float)) ;
+EXPORT struct S_FP f16_S_SIF_FP(struct S_FP p0, int p1, float p2,  struct S_FP (*cb)(struct S_FP, int, float)) ;
+EXPORT struct S_DI f16_S_SIF_DI(struct S_DI p0, int p1, float p2,  struct S_DI (*cb)(struct S_DI, int, float)) ;
+EXPORT struct S_DF f16_S_SIF_DF(struct S_DF p0, int p1, float p2,  struct S_DF (*cb)(struct S_DF, int, float)) ;
+EXPORT struct S_DD f16_S_SIF_DD(struct S_DD p0, int p1, float p2,  struct S_DD (*cb)(struct S_DD, int, float)) ;
+EXPORT struct S_DP f16_S_SIF_DP(struct S_DP p0, int p1, float p2,  struct S_DP (*cb)(struct S_DP, int, float)) ;
+EXPORT struct S_PI f16_S_SIF_PI(struct S_PI p0, int p1, float p2,  struct S_PI (*cb)(struct S_PI, int, float)) ;
+EXPORT struct S_PF f16_S_SIF_PF(struct S_PF p0, int p1, float p2,  struct S_PF (*cb)(struct S_PF, int, float)) ;
+EXPORT struct S_PD f16_S_SIF_PD(struct S_PD p0, int p1, float p2,  struct S_PD (*cb)(struct S_PD, int, float)) ;
+EXPORT struct S_PP f16_S_SIF_PP(struct S_PP p0, int p1, float p2,  struct S_PP (*cb)(struct S_PP, int, float)) ;
+EXPORT struct S_III f16_S_SIF_III(struct S_III p0, int p1, float p2,  struct S_III (*cb)(struct S_III, int, float)) ;
+EXPORT struct S_IIF f16_S_SIF_IIF(struct S_IIF p0, int p1, float p2,  struct S_IIF (*cb)(struct S_IIF, int, float)) ;
+EXPORT struct S_IID f16_S_SIF_IID(struct S_IID p0, int p1, float p2,  struct S_IID (*cb)(struct S_IID, int, float)) ;
+EXPORT struct S_IIP f16_S_SIF_IIP(struct S_IIP p0, int p1, float p2,  struct S_IIP (*cb)(struct S_IIP, int, float)) ;
+EXPORT struct S_IFI f16_S_SIF_IFI(struct S_IFI p0, int p1, float p2,  struct S_IFI (*cb)(struct S_IFI, int, float)) ;
+EXPORT struct S_IFF f16_S_SIF_IFF(struct S_IFF p0, int p1, float p2,  struct S_IFF (*cb)(struct S_IFF, int, float)) ;
+EXPORT struct S_IFD f16_S_SIF_IFD(struct S_IFD p0, int p1, float p2,  struct S_IFD (*cb)(struct S_IFD, int, float)) ;
+EXPORT struct S_IFP f16_S_SIF_IFP(struct S_IFP p0, int p1, float p2,  struct S_IFP (*cb)(struct S_IFP, int, float)) ;
+EXPORT struct S_IDI f16_S_SIF_IDI(struct S_IDI p0, int p1, float p2,  struct S_IDI (*cb)(struct S_IDI, int, float)) ;
+EXPORT struct S_IDF f16_S_SIF_IDF(struct S_IDF p0, int p1, float p2,  struct S_IDF (*cb)(struct S_IDF, int, float)) ;
+EXPORT struct S_IDD f16_S_SIF_IDD(struct S_IDD p0, int p1, float p2,  struct S_IDD (*cb)(struct S_IDD, int, float)) ;
+EXPORT struct S_IDP f16_S_SIF_IDP(struct S_IDP p0, int p1, float p2,  struct S_IDP (*cb)(struct S_IDP, int, float)) ;
+EXPORT struct S_IPI f16_S_SIF_IPI(struct S_IPI p0, int p1, float p2,  struct S_IPI (*cb)(struct S_IPI, int, float)) ;
+EXPORT struct S_IPF f16_S_SIF_IPF(struct S_IPF p0, int p1, float p2,  struct S_IPF (*cb)(struct S_IPF, int, float)) ;
+EXPORT struct S_IPD f16_S_SIF_IPD(struct S_IPD p0, int p1, float p2,  struct S_IPD (*cb)(struct S_IPD, int, float)) ;
+EXPORT struct S_IPP f16_S_SIF_IPP(struct S_IPP p0, int p1, float p2,  struct S_IPP (*cb)(struct S_IPP, int, float)) ;
+EXPORT struct S_FII f16_S_SIF_FII(struct S_FII p0, int p1, float p2,  struct S_FII (*cb)(struct S_FII, int, float)) ;
+EXPORT struct S_FIF f16_S_SIF_FIF(struct S_FIF p0, int p1, float p2,  struct S_FIF (*cb)(struct S_FIF, int, float)) ;
+EXPORT struct S_FID f16_S_SIF_FID(struct S_FID p0, int p1, float p2,  struct S_FID (*cb)(struct S_FID, int, float)) ;
+EXPORT struct S_FIP f16_S_SIF_FIP(struct S_FIP p0, int p1, float p2,  struct S_FIP (*cb)(struct S_FIP, int, float)) ;
+EXPORT struct S_FFI f16_S_SIF_FFI(struct S_FFI p0, int p1, float p2,  struct S_FFI (*cb)(struct S_FFI, int, float)) ;
+EXPORT struct S_FFF f16_S_SIF_FFF(struct S_FFF p0, int p1, float p2,  struct S_FFF (*cb)(struct S_FFF, int, float)) ;
+EXPORT struct S_FFD f16_S_SIF_FFD(struct S_FFD p0, int p1, float p2,  struct S_FFD (*cb)(struct S_FFD, int, float)) ;
+EXPORT struct S_FFP f16_S_SIF_FFP(struct S_FFP p0, int p1, float p2,  struct S_FFP (*cb)(struct S_FFP, int, float)) ;
+EXPORT struct S_FDI f16_S_SIF_FDI(struct S_FDI p0, int p1, float p2,  struct S_FDI (*cb)(struct S_FDI, int, float)) ;
+EXPORT struct S_FDF f16_S_SIF_FDF(struct S_FDF p0, int p1, float p2,  struct S_FDF (*cb)(struct S_FDF, int, float)) ;
+EXPORT struct S_FDD f16_S_SIF_FDD(struct S_FDD p0, int p1, float p2,  struct S_FDD (*cb)(struct S_FDD, int, float)) ;
+EXPORT struct S_FDP f16_S_SIF_FDP(struct S_FDP p0, int p1, float p2,  struct S_FDP (*cb)(struct S_FDP, int, float)) ;
+EXPORT struct S_FPI f16_S_SIF_FPI(struct S_FPI p0, int p1, float p2,  struct S_FPI (*cb)(struct S_FPI, int, float)) ;
+EXPORT struct S_FPF f16_S_SIF_FPF(struct S_FPF p0, int p1, float p2,  struct S_FPF (*cb)(struct S_FPF, int, float)) ;
+EXPORT struct S_FPD f16_S_SIF_FPD(struct S_FPD p0, int p1, float p2,  struct S_FPD (*cb)(struct S_FPD, int, float)) ;
+EXPORT struct S_FPP f16_S_SIF_FPP(struct S_FPP p0, int p1, float p2,  struct S_FPP (*cb)(struct S_FPP, int, float)) ;
+EXPORT struct S_DII f16_S_SIF_DII(struct S_DII p0, int p1, float p2,  struct S_DII (*cb)(struct S_DII, int, float)) ;
+EXPORT struct S_DIF f16_S_SIF_DIF(struct S_DIF p0, int p1, float p2,  struct S_DIF (*cb)(struct S_DIF, int, float)) ;
+EXPORT struct S_DID f16_S_SIF_DID(struct S_DID p0, int p1, float p2,  struct S_DID (*cb)(struct S_DID, int, float)) ;
+EXPORT struct S_DIP f16_S_SIF_DIP(struct S_DIP p0, int p1, float p2,  struct S_DIP (*cb)(struct S_DIP, int, float)) ;
+EXPORT struct S_DFI f16_S_SIF_DFI(struct S_DFI p0, int p1, float p2,  struct S_DFI (*cb)(struct S_DFI, int, float)) ;
+EXPORT struct S_DFF f16_S_SIF_DFF(struct S_DFF p0, int p1, float p2,  struct S_DFF (*cb)(struct S_DFF, int, float)) ;
+EXPORT struct S_DFD f16_S_SIF_DFD(struct S_DFD p0, int p1, float p2,  struct S_DFD (*cb)(struct S_DFD, int, float)) ;
+EXPORT struct S_DFP f16_S_SIF_DFP(struct S_DFP p0, int p1, float p2,  struct S_DFP (*cb)(struct S_DFP, int, float)) ;
+EXPORT struct S_DDI f16_S_SIF_DDI(struct S_DDI p0, int p1, float p2,  struct S_DDI (*cb)(struct S_DDI, int, float)) ;
+EXPORT struct S_DDF f16_S_SIF_DDF(struct S_DDF p0, int p1, float p2,  struct S_DDF (*cb)(struct S_DDF, int, float)) ;
+EXPORT struct S_DDD f16_S_SIF_DDD(struct S_DDD p0, int p1, float p2,  struct S_DDD (*cb)(struct S_DDD, int, float)) ;
+EXPORT struct S_DDP f16_S_SIF_DDP(struct S_DDP p0, int p1, float p2,  struct S_DDP (*cb)(struct S_DDP, int, float)) ;
+EXPORT struct S_DPI f16_S_SIF_DPI(struct S_DPI p0, int p1, float p2,  struct S_DPI (*cb)(struct S_DPI, int, float)) ;
+EXPORT struct S_DPF f16_S_SIF_DPF(struct S_DPF p0, int p1, float p2,  struct S_DPF (*cb)(struct S_DPF, int, float)) ;
+EXPORT struct S_DPD f16_S_SIF_DPD(struct S_DPD p0, int p1, float p2,  struct S_DPD (*cb)(struct S_DPD, int, float)) ;
+EXPORT struct S_DPP f16_S_SIF_DPP(struct S_DPP p0, int p1, float p2,  struct S_DPP (*cb)(struct S_DPP, int, float)) ;
+EXPORT struct S_PII f16_S_SIF_PII(struct S_PII p0, int p1, float p2,  struct S_PII (*cb)(struct S_PII, int, float)) ;
+EXPORT struct S_PIF f16_S_SIF_PIF(struct S_PIF p0, int p1, float p2,  struct S_PIF (*cb)(struct S_PIF, int, float)) ;
+EXPORT struct S_PID f16_S_SIF_PID(struct S_PID p0, int p1, float p2,  struct S_PID (*cb)(struct S_PID, int, float)) ;
+EXPORT struct S_PIP f16_S_SIF_PIP(struct S_PIP p0, int p1, float p2,  struct S_PIP (*cb)(struct S_PIP, int, float)) ;
+EXPORT struct S_PFI f16_S_SIF_PFI(struct S_PFI p0, int p1, float p2,  struct S_PFI (*cb)(struct S_PFI, int, float)) ;
+EXPORT struct S_PFF f16_S_SIF_PFF(struct S_PFF p0, int p1, float p2,  struct S_PFF (*cb)(struct S_PFF, int, float)) ;
+EXPORT struct S_PFD f16_S_SIF_PFD(struct S_PFD p0, int p1, float p2,  struct S_PFD (*cb)(struct S_PFD, int, float)) ;
+EXPORT struct S_PFP f16_S_SIF_PFP(struct S_PFP p0, int p1, float p2,  struct S_PFP (*cb)(struct S_PFP, int, float)) ;
+EXPORT struct S_PDI f16_S_SIF_PDI(struct S_PDI p0, int p1, float p2,  struct S_PDI (*cb)(struct S_PDI, int, float)) ;
+EXPORT struct S_PDF f16_S_SIF_PDF(struct S_PDF p0, int p1, float p2,  struct S_PDF (*cb)(struct S_PDF, int, float)) ;
+EXPORT struct S_PDD f16_S_SIF_PDD(struct S_PDD p0, int p1, float p2,  struct S_PDD (*cb)(struct S_PDD, int, float)) ;
+EXPORT struct S_PDP f16_S_SIF_PDP(struct S_PDP p0, int p1, float p2,  struct S_PDP (*cb)(struct S_PDP, int, float)) ;
+EXPORT struct S_PPI f16_S_SIF_PPI(struct S_PPI p0, int p1, float p2,  struct S_PPI (*cb)(struct S_PPI, int, float)) ;
+EXPORT struct S_PPF f16_S_SIF_PPF(struct S_PPF p0, int p1, float p2,  struct S_PPF (*cb)(struct S_PPF, int, float)) ;
+EXPORT struct S_PPD f16_S_SIF_PPD(struct S_PPD p0, int p1, float p2,  struct S_PPD (*cb)(struct S_PPD, int, float)) ;
+EXPORT struct S_PPP f16_S_SIF_PPP(struct S_PPP p0, int p1, float p2,  struct S_PPP (*cb)(struct S_PPP, int, float)) ;
+EXPORT struct S_I f16_S_SID_I(struct S_I p0, int p1, double p2,  struct S_I (*cb)(struct S_I, int, double)) ;
+EXPORT struct S_F f16_S_SID_F(struct S_F p0, int p1, double p2,  struct S_F (*cb)(struct S_F, int, double)) ;
+EXPORT struct S_D f16_S_SID_D(struct S_D p0, int p1, double p2,  struct S_D (*cb)(struct S_D, int, double)) ;
+EXPORT struct S_P f16_S_SID_P(struct S_P p0, int p1, double p2,  struct S_P (*cb)(struct S_P, int, double)) ;
+EXPORT struct S_II f16_S_SID_II(struct S_II p0, int p1, double p2,  struct S_II (*cb)(struct S_II, int, double)) ;
+EXPORT struct S_IF f16_S_SID_IF(struct S_IF p0, int p1, double p2,  struct S_IF (*cb)(struct S_IF, int, double)) ;
+EXPORT struct S_ID f16_S_SID_ID(struct S_ID p0, int p1, double p2,  struct S_ID (*cb)(struct S_ID, int, double)) ;
+EXPORT struct S_IP f16_S_SID_IP(struct S_IP p0, int p1, double p2,  struct S_IP (*cb)(struct S_IP, int, double)) ;
+EXPORT struct S_FI f16_S_SID_FI(struct S_FI p0, int p1, double p2,  struct S_FI (*cb)(struct S_FI, int, double)) ;
+EXPORT struct S_FF f16_S_SID_FF(struct S_FF p0, int p1, double p2,  struct S_FF (*cb)(struct S_FF, int, double)) ;
+EXPORT struct S_FD f16_S_SID_FD(struct S_FD p0, int p1, double p2,  struct S_FD (*cb)(struct S_FD, int, double)) ;
+EXPORT struct S_FP f16_S_SID_FP(struct S_FP p0, int p1, double p2,  struct S_FP (*cb)(struct S_FP, int, double)) ;
+EXPORT struct S_DI f16_S_SID_DI(struct S_DI p0, int p1, double p2,  struct S_DI (*cb)(struct S_DI, int, double)) ;
+EXPORT struct S_DF f16_S_SID_DF(struct S_DF p0, int p1, double p2,  struct S_DF (*cb)(struct S_DF, int, double)) ;
+EXPORT struct S_DD f16_S_SID_DD(struct S_DD p0, int p1, double p2,  struct S_DD (*cb)(struct S_DD, int, double)) ;
+EXPORT struct S_DP f16_S_SID_DP(struct S_DP p0, int p1, double p2,  struct S_DP (*cb)(struct S_DP, int, double)) ;
+EXPORT struct S_PI f16_S_SID_PI(struct S_PI p0, int p1, double p2,  struct S_PI (*cb)(struct S_PI, int, double)) ;
+EXPORT struct S_PF f16_S_SID_PF(struct S_PF p0, int p1, double p2,  struct S_PF (*cb)(struct S_PF, int, double)) ;
+EXPORT struct S_PD f16_S_SID_PD(struct S_PD p0, int p1, double p2,  struct S_PD (*cb)(struct S_PD, int, double)) ;
+EXPORT struct S_PP f16_S_SID_PP(struct S_PP p0, int p1, double p2,  struct S_PP (*cb)(struct S_PP, int, double)) ;
+EXPORT struct S_III f16_S_SID_III(struct S_III p0, int p1, double p2,  struct S_III (*cb)(struct S_III, int, double)) ;
+EXPORT struct S_IIF f16_S_SID_IIF(struct S_IIF p0, int p1, double p2,  struct S_IIF (*cb)(struct S_IIF, int, double)) ;
+EXPORT struct S_IID f16_S_SID_IID(struct S_IID p0, int p1, double p2,  struct S_IID (*cb)(struct S_IID, int, double)) ;
+EXPORT struct S_IIP f16_S_SID_IIP(struct S_IIP p0, int p1, double p2,  struct S_IIP (*cb)(struct S_IIP, int, double)) ;
+EXPORT struct S_IFI f16_S_SID_IFI(struct S_IFI p0, int p1, double p2,  struct S_IFI (*cb)(struct S_IFI, int, double)) ;
+EXPORT struct S_IFF f16_S_SID_IFF(struct S_IFF p0, int p1, double p2,  struct S_IFF (*cb)(struct S_IFF, int, double)) ;
+EXPORT struct S_IFD f16_S_SID_IFD(struct S_IFD p0, int p1, double p2,  struct S_IFD (*cb)(struct S_IFD, int, double)) ;
+EXPORT struct S_IFP f16_S_SID_IFP(struct S_IFP p0, int p1, double p2,  struct S_IFP (*cb)(struct S_IFP, int, double)) ;
+EXPORT struct S_IDI f16_S_SID_IDI(struct S_IDI p0, int p1, double p2,  struct S_IDI (*cb)(struct S_IDI, int, double)) ;
+EXPORT struct S_IDF f16_S_SID_IDF(struct S_IDF p0, int p1, double p2,  struct S_IDF (*cb)(struct S_IDF, int, double)) ;
+EXPORT struct S_IDD f16_S_SID_IDD(struct S_IDD p0, int p1, double p2,  struct S_IDD (*cb)(struct S_IDD, int, double)) ;
+EXPORT struct S_IDP f16_S_SID_IDP(struct S_IDP p0, int p1, double p2,  struct S_IDP (*cb)(struct S_IDP, int, double)) ;
+EXPORT struct S_IPI f16_S_SID_IPI(struct S_IPI p0, int p1, double p2,  struct S_IPI (*cb)(struct S_IPI, int, double)) ;
+EXPORT struct S_IPF f16_S_SID_IPF(struct S_IPF p0, int p1, double p2,  struct S_IPF (*cb)(struct S_IPF, int, double)) ;
+EXPORT struct S_IPD f16_S_SID_IPD(struct S_IPD p0, int p1, double p2,  struct S_IPD (*cb)(struct S_IPD, int, double)) ;
+EXPORT struct S_IPP f17_S_SID_IPP(struct S_IPP p0, int p1, double p2,  struct S_IPP (*cb)(struct S_IPP, int, double)) ;
+EXPORT struct S_FII f17_S_SID_FII(struct S_FII p0, int p1, double p2,  struct S_FII (*cb)(struct S_FII, int, double)) ;
+EXPORT struct S_FIF f17_S_SID_FIF(struct S_FIF p0, int p1, double p2,  struct S_FIF (*cb)(struct S_FIF, int, double)) ;
+EXPORT struct S_FID f17_S_SID_FID(struct S_FID p0, int p1, double p2,  struct S_FID (*cb)(struct S_FID, int, double)) ;
+EXPORT struct S_FIP f17_S_SID_FIP(struct S_FIP p0, int p1, double p2,  struct S_FIP (*cb)(struct S_FIP, int, double)) ;
+EXPORT struct S_FFI f17_S_SID_FFI(struct S_FFI p0, int p1, double p2,  struct S_FFI (*cb)(struct S_FFI, int, double)) ;
+EXPORT struct S_FFF f17_S_SID_FFF(struct S_FFF p0, int p1, double p2,  struct S_FFF (*cb)(struct S_FFF, int, double)) ;
+EXPORT struct S_FFD f17_S_SID_FFD(struct S_FFD p0, int p1, double p2,  struct S_FFD (*cb)(struct S_FFD, int, double)) ;
+EXPORT struct S_FFP f17_S_SID_FFP(struct S_FFP p0, int p1, double p2,  struct S_FFP (*cb)(struct S_FFP, int, double)) ;
+EXPORT struct S_FDI f17_S_SID_FDI(struct S_FDI p0, int p1, double p2,  struct S_FDI (*cb)(struct S_FDI, int, double)) ;
+EXPORT struct S_FDF f17_S_SID_FDF(struct S_FDF p0, int p1, double p2,  struct S_FDF (*cb)(struct S_FDF, int, double)) ;
+EXPORT struct S_FDD f17_S_SID_FDD(struct S_FDD p0, int p1, double p2,  struct S_FDD (*cb)(struct S_FDD, int, double)) ;
+EXPORT struct S_FDP f17_S_SID_FDP(struct S_FDP p0, int p1, double p2,  struct S_FDP (*cb)(struct S_FDP, int, double)) ;
+EXPORT struct S_FPI f17_S_SID_FPI(struct S_FPI p0, int p1, double p2,  struct S_FPI (*cb)(struct S_FPI, int, double)) ;
+EXPORT struct S_FPF f17_S_SID_FPF(struct S_FPF p0, int p1, double p2,  struct S_FPF (*cb)(struct S_FPF, int, double)) ;
+EXPORT struct S_FPD f17_S_SID_FPD(struct S_FPD p0, int p1, double p2,  struct S_FPD (*cb)(struct S_FPD, int, double)) ;
+EXPORT struct S_FPP f17_S_SID_FPP(struct S_FPP p0, int p1, double p2,  struct S_FPP (*cb)(struct S_FPP, int, double)) ;
+EXPORT struct S_DII f17_S_SID_DII(struct S_DII p0, int p1, double p2,  struct S_DII (*cb)(struct S_DII, int, double)) ;
+EXPORT struct S_DIF f17_S_SID_DIF(struct S_DIF p0, int p1, double p2,  struct S_DIF (*cb)(struct S_DIF, int, double)) ;
+EXPORT struct S_DID f17_S_SID_DID(struct S_DID p0, int p1, double p2,  struct S_DID (*cb)(struct S_DID, int, double)) ;
+EXPORT struct S_DIP f17_S_SID_DIP(struct S_DIP p0, int p1, double p2,  struct S_DIP (*cb)(struct S_DIP, int, double)) ;
+EXPORT struct S_DFI f17_S_SID_DFI(struct S_DFI p0, int p1, double p2,  struct S_DFI (*cb)(struct S_DFI, int, double)) ;
+EXPORT struct S_DFF f17_S_SID_DFF(struct S_DFF p0, int p1, double p2,  struct S_DFF (*cb)(struct S_DFF, int, double)) ;
+EXPORT struct S_DFD f17_S_SID_DFD(struct S_DFD p0, int p1, double p2,  struct S_DFD (*cb)(struct S_DFD, int, double)) ;
+EXPORT struct S_DFP f17_S_SID_DFP(struct S_DFP p0, int p1, double p2,  struct S_DFP (*cb)(struct S_DFP, int, double)) ;
+EXPORT struct S_DDI f17_S_SID_DDI(struct S_DDI p0, int p1, double p2,  struct S_DDI (*cb)(struct S_DDI, int, double)) ;
+EXPORT struct S_DDF f17_S_SID_DDF(struct S_DDF p0, int p1, double p2,  struct S_DDF (*cb)(struct S_DDF, int, double)) ;
+EXPORT struct S_DDD f17_S_SID_DDD(struct S_DDD p0, int p1, double p2,  struct S_DDD (*cb)(struct S_DDD, int, double)) ;
+EXPORT struct S_DDP f17_S_SID_DDP(struct S_DDP p0, int p1, double p2,  struct S_DDP (*cb)(struct S_DDP, int, double)) ;
+EXPORT struct S_DPI f17_S_SID_DPI(struct S_DPI p0, int p1, double p2,  struct S_DPI (*cb)(struct S_DPI, int, double)) ;
+EXPORT struct S_DPF f17_S_SID_DPF(struct S_DPF p0, int p1, double p2,  struct S_DPF (*cb)(struct S_DPF, int, double)) ;
+EXPORT struct S_DPD f17_S_SID_DPD(struct S_DPD p0, int p1, double p2,  struct S_DPD (*cb)(struct S_DPD, int, double)) ;
+EXPORT struct S_DPP f17_S_SID_DPP(struct S_DPP p0, int p1, double p2,  struct S_DPP (*cb)(struct S_DPP, int, double)) ;
+EXPORT struct S_PII f17_S_SID_PII(struct S_PII p0, int p1, double p2,  struct S_PII (*cb)(struct S_PII, int, double)) ;
+EXPORT struct S_PIF f17_S_SID_PIF(struct S_PIF p0, int p1, double p2,  struct S_PIF (*cb)(struct S_PIF, int, double)) ;
+EXPORT struct S_PID f17_S_SID_PID(struct S_PID p0, int p1, double p2,  struct S_PID (*cb)(struct S_PID, int, double)) ;
+EXPORT struct S_PIP f17_S_SID_PIP(struct S_PIP p0, int p1, double p2,  struct S_PIP (*cb)(struct S_PIP, int, double)) ;
+EXPORT struct S_PFI f17_S_SID_PFI(struct S_PFI p0, int p1, double p2,  struct S_PFI (*cb)(struct S_PFI, int, double)) ;
+EXPORT struct S_PFF f17_S_SID_PFF(struct S_PFF p0, int p1, double p2,  struct S_PFF (*cb)(struct S_PFF, int, double)) ;
+EXPORT struct S_PFD f17_S_SID_PFD(struct S_PFD p0, int p1, double p2,  struct S_PFD (*cb)(struct S_PFD, int, double)) ;
+EXPORT struct S_PFP f17_S_SID_PFP(struct S_PFP p0, int p1, double p2,  struct S_PFP (*cb)(struct S_PFP, int, double)) ;
+EXPORT struct S_PDI f17_S_SID_PDI(struct S_PDI p0, int p1, double p2,  struct S_PDI (*cb)(struct S_PDI, int, double)) ;
+EXPORT struct S_PDF f17_S_SID_PDF(struct S_PDF p0, int p1, double p2,  struct S_PDF (*cb)(struct S_PDF, int, double)) ;
+EXPORT struct S_PDD f17_S_SID_PDD(struct S_PDD p0, int p1, double p2,  struct S_PDD (*cb)(struct S_PDD, int, double)) ;
+EXPORT struct S_PDP f17_S_SID_PDP(struct S_PDP p0, int p1, double p2,  struct S_PDP (*cb)(struct S_PDP, int, double)) ;
+EXPORT struct S_PPI f17_S_SID_PPI(struct S_PPI p0, int p1, double p2,  struct S_PPI (*cb)(struct S_PPI, int, double)) ;
+EXPORT struct S_PPF f17_S_SID_PPF(struct S_PPF p0, int p1, double p2,  struct S_PPF (*cb)(struct S_PPF, int, double)) ;
+EXPORT struct S_PPD f17_S_SID_PPD(struct S_PPD p0, int p1, double p2,  struct S_PPD (*cb)(struct S_PPD, int, double)) ;
+EXPORT struct S_PPP f17_S_SID_PPP(struct S_PPP p0, int p1, double p2,  struct S_PPP (*cb)(struct S_PPP, int, double)) ;
+EXPORT struct S_I f17_S_SIP_I(struct S_I p0, int p1, void* p2,  struct S_I (*cb)(struct S_I, int, void*)) ;
+EXPORT struct S_F f17_S_SIP_F(struct S_F p0, int p1, void* p2,  struct S_F (*cb)(struct S_F, int, void*)) ;
+EXPORT struct S_D f17_S_SIP_D(struct S_D p0, int p1, void* p2,  struct S_D (*cb)(struct S_D, int, void*)) ;
+EXPORT struct S_P f17_S_SIP_P(struct S_P p0, int p1, void* p2,  struct S_P (*cb)(struct S_P, int, void*)) ;
+EXPORT struct S_II f17_S_SIP_II(struct S_II p0, int p1, void* p2,  struct S_II (*cb)(struct S_II, int, void*)) ;
+EXPORT struct S_IF f17_S_SIP_IF(struct S_IF p0, int p1, void* p2,  struct S_IF (*cb)(struct S_IF, int, void*)) ;
+EXPORT struct S_ID f17_S_SIP_ID(struct S_ID p0, int p1, void* p2,  struct S_ID (*cb)(struct S_ID, int, void*)) ;
+EXPORT struct S_IP f17_S_SIP_IP(struct S_IP p0, int p1, void* p2,  struct S_IP (*cb)(struct S_IP, int, void*)) ;
+EXPORT struct S_FI f17_S_SIP_FI(struct S_FI p0, int p1, void* p2,  struct S_FI (*cb)(struct S_FI, int, void*)) ;
+EXPORT struct S_FF f17_S_SIP_FF(struct S_FF p0, int p1, void* p2,  struct S_FF (*cb)(struct S_FF, int, void*)) ;
+EXPORT struct S_FD f17_S_SIP_FD(struct S_FD p0, int p1, void* p2,  struct S_FD (*cb)(struct S_FD, int, void*)) ;
+EXPORT struct S_FP f17_S_SIP_FP(struct S_FP p0, int p1, void* p2,  struct S_FP (*cb)(struct S_FP, int, void*)) ;
+EXPORT struct S_DI f17_S_SIP_DI(struct S_DI p0, int p1, void* p2,  struct S_DI (*cb)(struct S_DI, int, void*)) ;
+EXPORT struct S_DF f17_S_SIP_DF(struct S_DF p0, int p1, void* p2,  struct S_DF (*cb)(struct S_DF, int, void*)) ;
+EXPORT struct S_DD f17_S_SIP_DD(struct S_DD p0, int p1, void* p2,  struct S_DD (*cb)(struct S_DD, int, void*)) ;
+EXPORT struct S_DP f17_S_SIP_DP(struct S_DP p0, int p1, void* p2,  struct S_DP (*cb)(struct S_DP, int, void*)) ;
+EXPORT struct S_PI f17_S_SIP_PI(struct S_PI p0, int p1, void* p2,  struct S_PI (*cb)(struct S_PI, int, void*)) ;
+EXPORT struct S_PF f17_S_SIP_PF(struct S_PF p0, int p1, void* p2,  struct S_PF (*cb)(struct S_PF, int, void*)) ;
+EXPORT struct S_PD f17_S_SIP_PD(struct S_PD p0, int p1, void* p2,  struct S_PD (*cb)(struct S_PD, int, void*)) ;
+EXPORT struct S_PP f17_S_SIP_PP(struct S_PP p0, int p1, void* p2,  struct S_PP (*cb)(struct S_PP, int, void*)) ;
+EXPORT struct S_III f17_S_SIP_III(struct S_III p0, int p1, void* p2,  struct S_III (*cb)(struct S_III, int, void*)) ;
+EXPORT struct S_IIF f17_S_SIP_IIF(struct S_IIF p0, int p1, void* p2,  struct S_IIF (*cb)(struct S_IIF, int, void*)) ;
+EXPORT struct S_IID f17_S_SIP_IID(struct S_IID p0, int p1, void* p2,  struct S_IID (*cb)(struct S_IID, int, void*)) ;
+EXPORT struct S_IIP f17_S_SIP_IIP(struct S_IIP p0, int p1, void* p2,  struct S_IIP (*cb)(struct S_IIP, int, void*)) ;
+EXPORT struct S_IFI f17_S_SIP_IFI(struct S_IFI p0, int p1, void* p2,  struct S_IFI (*cb)(struct S_IFI, int, void*)) ;
+EXPORT struct S_IFF f17_S_SIP_IFF(struct S_IFF p0, int p1, void* p2,  struct S_IFF (*cb)(struct S_IFF, int, void*)) ;
+EXPORT struct S_IFD f17_S_SIP_IFD(struct S_IFD p0, int p1, void* p2,  struct S_IFD (*cb)(struct S_IFD, int, void*)) ;
+EXPORT struct S_IFP f17_S_SIP_IFP(struct S_IFP p0, int p1, void* p2,  struct S_IFP (*cb)(struct S_IFP, int, void*)) ;
+EXPORT struct S_IDI f17_S_SIP_IDI(struct S_IDI p0, int p1, void* p2,  struct S_IDI (*cb)(struct S_IDI, int, void*)) ;
+EXPORT struct S_IDF f17_S_SIP_IDF(struct S_IDF p0, int p1, void* p2,  struct S_IDF (*cb)(struct S_IDF, int, void*)) ;
+EXPORT struct S_IDD f17_S_SIP_IDD(struct S_IDD p0, int p1, void* p2,  struct S_IDD (*cb)(struct S_IDD, int, void*)) ;
+EXPORT struct S_IDP f17_S_SIP_IDP(struct S_IDP p0, int p1, void* p2,  struct S_IDP (*cb)(struct S_IDP, int, void*)) ;
+EXPORT struct S_IPI f17_S_SIP_IPI(struct S_IPI p0, int p1, void* p2,  struct S_IPI (*cb)(struct S_IPI, int, void*)) ;
+EXPORT struct S_IPF f17_S_SIP_IPF(struct S_IPF p0, int p1, void* p2,  struct S_IPF (*cb)(struct S_IPF, int, void*)) ;
+EXPORT struct S_IPD f17_S_SIP_IPD(struct S_IPD p0, int p1, void* p2,  struct S_IPD (*cb)(struct S_IPD, int, void*)) ;
+EXPORT struct S_IPP f17_S_SIP_IPP(struct S_IPP p0, int p1, void* p2,  struct S_IPP (*cb)(struct S_IPP, int, void*)) ;
+EXPORT struct S_FII f17_S_SIP_FII(struct S_FII p0, int p1, void* p2,  struct S_FII (*cb)(struct S_FII, int, void*)) ;
+EXPORT struct S_FIF f17_S_SIP_FIF(struct S_FIF p0, int p1, void* p2,  struct S_FIF (*cb)(struct S_FIF, int, void*)) ;
+EXPORT struct S_FID f17_S_SIP_FID(struct S_FID p0, int p1, void* p2,  struct S_FID (*cb)(struct S_FID, int, void*)) ;
+EXPORT struct S_FIP f17_S_SIP_FIP(struct S_FIP p0, int p1, void* p2,  struct S_FIP (*cb)(struct S_FIP, int, void*)) ;
+EXPORT struct S_FFI f17_S_SIP_FFI(struct S_FFI p0, int p1, void* p2,  struct S_FFI (*cb)(struct S_FFI, int, void*)) ;
+EXPORT struct S_FFF f17_S_SIP_FFF(struct S_FFF p0, int p1, void* p2,  struct S_FFF (*cb)(struct S_FFF, int, void*)) ;
+EXPORT struct S_FFD f17_S_SIP_FFD(struct S_FFD p0, int p1, void* p2,  struct S_FFD (*cb)(struct S_FFD, int, void*)) ;
+EXPORT struct S_FFP f17_S_SIP_FFP(struct S_FFP p0, int p1, void* p2,  struct S_FFP (*cb)(struct S_FFP, int, void*)) ;
+EXPORT struct S_FDI f17_S_SIP_FDI(struct S_FDI p0, int p1, void* p2,  struct S_FDI (*cb)(struct S_FDI, int, void*)) ;
+EXPORT struct S_FDF f17_S_SIP_FDF(struct S_FDF p0, int p1, void* p2,  struct S_FDF (*cb)(struct S_FDF, int, void*)) ;
+EXPORT struct S_FDD f17_S_SIP_FDD(struct S_FDD p0, int p1, void* p2,  struct S_FDD (*cb)(struct S_FDD, int, void*)) ;
+EXPORT struct S_FDP f17_S_SIP_FDP(struct S_FDP p0, int p1, void* p2,  struct S_FDP (*cb)(struct S_FDP, int, void*)) ;
+EXPORT struct S_FPI f17_S_SIP_FPI(struct S_FPI p0, int p1, void* p2,  struct S_FPI (*cb)(struct S_FPI, int, void*)) ;
+EXPORT struct S_FPF f17_S_SIP_FPF(struct S_FPF p0, int p1, void* p2,  struct S_FPF (*cb)(struct S_FPF, int, void*)) ;
+EXPORT struct S_FPD f17_S_SIP_FPD(struct S_FPD p0, int p1, void* p2,  struct S_FPD (*cb)(struct S_FPD, int, void*)) ;
+EXPORT struct S_FPP f17_S_SIP_FPP(struct S_FPP p0, int p1, void* p2,  struct S_FPP (*cb)(struct S_FPP, int, void*)) ;
+EXPORT struct S_DII f17_S_SIP_DII(struct S_DII p0, int p1, void* p2,  struct S_DII (*cb)(struct S_DII, int, void*)) ;
+EXPORT struct S_DIF f17_S_SIP_DIF(struct S_DIF p0, int p1, void* p2,  struct S_DIF (*cb)(struct S_DIF, int, void*)) ;
+EXPORT struct S_DID f17_S_SIP_DID(struct S_DID p0, int p1, void* p2,  struct S_DID (*cb)(struct S_DID, int, void*)) ;
+EXPORT struct S_DIP f17_S_SIP_DIP(struct S_DIP p0, int p1, void* p2,  struct S_DIP (*cb)(struct S_DIP, int, void*)) ;
+EXPORT struct S_DFI f17_S_SIP_DFI(struct S_DFI p0, int p1, void* p2,  struct S_DFI (*cb)(struct S_DFI, int, void*)) ;
+EXPORT struct S_DFF f17_S_SIP_DFF(struct S_DFF p0, int p1, void* p2,  struct S_DFF (*cb)(struct S_DFF, int, void*)) ;
+EXPORT struct S_DFD f17_S_SIP_DFD(struct S_DFD p0, int p1, void* p2,  struct S_DFD (*cb)(struct S_DFD, int, void*)) ;
+EXPORT struct S_DFP f17_S_SIP_DFP(struct S_DFP p0, int p1, void* p2,  struct S_DFP (*cb)(struct S_DFP, int, void*)) ;
+EXPORT struct S_DDI f17_S_SIP_DDI(struct S_DDI p0, int p1, void* p2,  struct S_DDI (*cb)(struct S_DDI, int, void*)) ;
+EXPORT struct S_DDF f17_S_SIP_DDF(struct S_DDF p0, int p1, void* p2,  struct S_DDF (*cb)(struct S_DDF, int, void*)) ;
+EXPORT struct S_DDD f17_S_SIP_DDD(struct S_DDD p0, int p1, void* p2,  struct S_DDD (*cb)(struct S_DDD, int, void*)) ;
+EXPORT struct S_DDP f17_S_SIP_DDP(struct S_DDP p0, int p1, void* p2,  struct S_DDP (*cb)(struct S_DDP, int, void*)) ;
+EXPORT struct S_DPI f17_S_SIP_DPI(struct S_DPI p0, int p1, void* p2,  struct S_DPI (*cb)(struct S_DPI, int, void*)) ;
+EXPORT struct S_DPF f17_S_SIP_DPF(struct S_DPF p0, int p1, void* p2,  struct S_DPF (*cb)(struct S_DPF, int, void*)) ;
+EXPORT struct S_DPD f17_S_SIP_DPD(struct S_DPD p0, int p1, void* p2,  struct S_DPD (*cb)(struct S_DPD, int, void*)) ;
+EXPORT struct S_DPP f17_S_SIP_DPP(struct S_DPP p0, int p1, void* p2,  struct S_DPP (*cb)(struct S_DPP, int, void*)) ;
+EXPORT struct S_PII f17_S_SIP_PII(struct S_PII p0, int p1, void* p2,  struct S_PII (*cb)(struct S_PII, int, void*)) ;
+EXPORT struct S_PIF f17_S_SIP_PIF(struct S_PIF p0, int p1, void* p2,  struct S_PIF (*cb)(struct S_PIF, int, void*)) ;
+EXPORT struct S_PID f17_S_SIP_PID(struct S_PID p0, int p1, void* p2,  struct S_PID (*cb)(struct S_PID, int, void*)) ;
+EXPORT struct S_PIP f17_S_SIP_PIP(struct S_PIP p0, int p1, void* p2,  struct S_PIP (*cb)(struct S_PIP, int, void*)) ;
+EXPORT struct S_PFI f17_S_SIP_PFI(struct S_PFI p0, int p1, void* p2,  struct S_PFI (*cb)(struct S_PFI, int, void*)) ;
+EXPORT struct S_PFF f17_S_SIP_PFF(struct S_PFF p0, int p1, void* p2,  struct S_PFF (*cb)(struct S_PFF, int, void*)) ;
+EXPORT struct S_PFD f17_S_SIP_PFD(struct S_PFD p0, int p1, void* p2,  struct S_PFD (*cb)(struct S_PFD, int, void*)) ;
+EXPORT struct S_PFP f17_S_SIP_PFP(struct S_PFP p0, int p1, void* p2,  struct S_PFP (*cb)(struct S_PFP, int, void*)) ;
+EXPORT struct S_PDI f17_S_SIP_PDI(struct S_PDI p0, int p1, void* p2,  struct S_PDI (*cb)(struct S_PDI, int, void*)) ;
+EXPORT struct S_PDF f17_S_SIP_PDF(struct S_PDF p0, int p1, void* p2,  struct S_PDF (*cb)(struct S_PDF, int, void*)) ;
+EXPORT struct S_PDD f17_S_SIP_PDD(struct S_PDD p0, int p1, void* p2,  struct S_PDD (*cb)(struct S_PDD, int, void*)) ;
+EXPORT struct S_PDP f17_S_SIP_PDP(struct S_PDP p0, int p1, void* p2,  struct S_PDP (*cb)(struct S_PDP, int, void*)) ;
+EXPORT struct S_PPI f17_S_SIP_PPI(struct S_PPI p0, int p1, void* p2,  struct S_PPI (*cb)(struct S_PPI, int, void*)) ;
+EXPORT struct S_PPF f17_S_SIP_PPF(struct S_PPF p0, int p1, void* p2,  struct S_PPF (*cb)(struct S_PPF, int, void*)) ;
+EXPORT struct S_PPD f17_S_SIP_PPD(struct S_PPD p0, int p1, void* p2,  struct S_PPD (*cb)(struct S_PPD, int, void*)) ;
+EXPORT struct S_PPP f17_S_SIP_PPP(struct S_PPP p0, int p1, void* p2,  struct S_PPP (*cb)(struct S_PPP, int, void*)) ;
+EXPORT struct S_I f17_S_SIS_I(struct S_I p0, int p1, struct S_I p2,  struct S_I (*cb)(struct S_I, int, struct S_I)) ;
+EXPORT struct S_F f17_S_SIS_F(struct S_F p0, int p1, struct S_F p2,  struct S_F (*cb)(struct S_F, int, struct S_F)) ;
+EXPORT struct S_D f17_S_SIS_D(struct S_D p0, int p1, struct S_D p2,  struct S_D (*cb)(struct S_D, int, struct S_D)) ;
+EXPORT struct S_P f17_S_SIS_P(struct S_P p0, int p1, struct S_P p2,  struct S_P (*cb)(struct S_P, int, struct S_P)) ;
+EXPORT struct S_II f17_S_SIS_II(struct S_II p0, int p1, struct S_II p2,  struct S_II (*cb)(struct S_II, int, struct S_II)) ;
+EXPORT struct S_IF f17_S_SIS_IF(struct S_IF p0, int p1, struct S_IF p2,  struct S_IF (*cb)(struct S_IF, int, struct S_IF)) ;
+EXPORT struct S_ID f17_S_SIS_ID(struct S_ID p0, int p1, struct S_ID p2,  struct S_ID (*cb)(struct S_ID, int, struct S_ID)) ;
+EXPORT struct S_IP f17_S_SIS_IP(struct S_IP p0, int p1, struct S_IP p2,  struct S_IP (*cb)(struct S_IP, int, struct S_IP)) ;
+EXPORT struct S_FI f17_S_SIS_FI(struct S_FI p0, int p1, struct S_FI p2,  struct S_FI (*cb)(struct S_FI, int, struct S_FI)) ;
+EXPORT struct S_FF f17_S_SIS_FF(struct S_FF p0, int p1, struct S_FF p2,  struct S_FF (*cb)(struct S_FF, int, struct S_FF)) ;
+EXPORT struct S_FD f17_S_SIS_FD(struct S_FD p0, int p1, struct S_FD p2,  struct S_FD (*cb)(struct S_FD, int, struct S_FD)) ;
+EXPORT struct S_FP f17_S_SIS_FP(struct S_FP p0, int p1, struct S_FP p2,  struct S_FP (*cb)(struct S_FP, int, struct S_FP)) ;
+EXPORT struct S_DI f17_S_SIS_DI(struct S_DI p0, int p1, struct S_DI p2,  struct S_DI (*cb)(struct S_DI, int, struct S_DI)) ;
+EXPORT struct S_DF f17_S_SIS_DF(struct S_DF p0, int p1, struct S_DF p2,  struct S_DF (*cb)(struct S_DF, int, struct S_DF)) ;
+EXPORT struct S_DD f17_S_SIS_DD(struct S_DD p0, int p1, struct S_DD p2,  struct S_DD (*cb)(struct S_DD, int, struct S_DD)) ;
+EXPORT struct S_DP f17_S_SIS_DP(struct S_DP p0, int p1, struct S_DP p2,  struct S_DP (*cb)(struct S_DP, int, struct S_DP)) ;
+EXPORT struct S_PI f17_S_SIS_PI(struct S_PI p0, int p1, struct S_PI p2,  struct S_PI (*cb)(struct S_PI, int, struct S_PI)) ;
+EXPORT struct S_PF f17_S_SIS_PF(struct S_PF p0, int p1, struct S_PF p2,  struct S_PF (*cb)(struct S_PF, int, struct S_PF)) ;
+EXPORT struct S_PD f17_S_SIS_PD(struct S_PD p0, int p1, struct S_PD p2,  struct S_PD (*cb)(struct S_PD, int, struct S_PD)) ;
+EXPORT struct S_PP f17_S_SIS_PP(struct S_PP p0, int p1, struct S_PP p2,  struct S_PP (*cb)(struct S_PP, int, struct S_PP)) ;
+EXPORT struct S_III f17_S_SIS_III(struct S_III p0, int p1, struct S_III p2,  struct S_III (*cb)(struct S_III, int, struct S_III)) ;
+EXPORT struct S_IIF f17_S_SIS_IIF(struct S_IIF p0, int p1, struct S_IIF p2,  struct S_IIF (*cb)(struct S_IIF, int, struct S_IIF)) ;
+EXPORT struct S_IID f17_S_SIS_IID(struct S_IID p0, int p1, struct S_IID p2,  struct S_IID (*cb)(struct S_IID, int, struct S_IID)) ;
+EXPORT struct S_IIP f17_S_SIS_IIP(struct S_IIP p0, int p1, struct S_IIP p2,  struct S_IIP (*cb)(struct S_IIP, int, struct S_IIP)) ;
+EXPORT struct S_IFI f17_S_SIS_IFI(struct S_IFI p0, int p1, struct S_IFI p2,  struct S_IFI (*cb)(struct S_IFI, int, struct S_IFI)) ;
+EXPORT struct S_IFF f17_S_SIS_IFF(struct S_IFF p0, int p1, struct S_IFF p2,  struct S_IFF (*cb)(struct S_IFF, int, struct S_IFF)) ;
+EXPORT struct S_IFD f17_S_SIS_IFD(struct S_IFD p0, int p1, struct S_IFD p2,  struct S_IFD (*cb)(struct S_IFD, int, struct S_IFD)) ;
+EXPORT struct S_IFP f17_S_SIS_IFP(struct S_IFP p0, int p1, struct S_IFP p2,  struct S_IFP (*cb)(struct S_IFP, int, struct S_IFP)) ;
+EXPORT struct S_IDI f17_S_SIS_IDI(struct S_IDI p0, int p1, struct S_IDI p2,  struct S_IDI (*cb)(struct S_IDI, int, struct S_IDI)) ;
+EXPORT struct S_IDF f17_S_SIS_IDF(struct S_IDF p0, int p1, struct S_IDF p2,  struct S_IDF (*cb)(struct S_IDF, int, struct S_IDF)) ;
+EXPORT struct S_IDD f17_S_SIS_IDD(struct S_IDD p0, int p1, struct S_IDD p2,  struct S_IDD (*cb)(struct S_IDD, int, struct S_IDD)) ;
+EXPORT struct S_IDP f17_S_SIS_IDP(struct S_IDP p0, int p1, struct S_IDP p2,  struct S_IDP (*cb)(struct S_IDP, int, struct S_IDP)) ;
+EXPORT struct S_IPI f17_S_SIS_IPI(struct S_IPI p0, int p1, struct S_IPI p2,  struct S_IPI (*cb)(struct S_IPI, int, struct S_IPI)) ;
+EXPORT struct S_IPF f17_S_SIS_IPF(struct S_IPF p0, int p1, struct S_IPF p2,  struct S_IPF (*cb)(struct S_IPF, int, struct S_IPF)) ;
+EXPORT struct S_IPD f17_S_SIS_IPD(struct S_IPD p0, int p1, struct S_IPD p2,  struct S_IPD (*cb)(struct S_IPD, int, struct S_IPD)) ;
+EXPORT struct S_IPP f17_S_SIS_IPP(struct S_IPP p0, int p1, struct S_IPP p2,  struct S_IPP (*cb)(struct S_IPP, int, struct S_IPP)) ;
+EXPORT struct S_FII f17_S_SIS_FII(struct S_FII p0, int p1, struct S_FII p2,  struct S_FII (*cb)(struct S_FII, int, struct S_FII)) ;
+EXPORT struct S_FIF f17_S_SIS_FIF(struct S_FIF p0, int p1, struct S_FIF p2,  struct S_FIF (*cb)(struct S_FIF, int, struct S_FIF)) ;
+EXPORT struct S_FID f17_S_SIS_FID(struct S_FID p0, int p1, struct S_FID p2,  struct S_FID (*cb)(struct S_FID, int, struct S_FID)) ;
+EXPORT struct S_FIP f17_S_SIS_FIP(struct S_FIP p0, int p1, struct S_FIP p2,  struct S_FIP (*cb)(struct S_FIP, int, struct S_FIP)) ;
+EXPORT struct S_FFI f17_S_SIS_FFI(struct S_FFI p0, int p1, struct S_FFI p2,  struct S_FFI (*cb)(struct S_FFI, int, struct S_FFI)) ;
+EXPORT struct S_FFF f17_S_SIS_FFF(struct S_FFF p0, int p1, struct S_FFF p2,  struct S_FFF (*cb)(struct S_FFF, int, struct S_FFF)) ;
+EXPORT struct S_FFD f17_S_SIS_FFD(struct S_FFD p0, int p1, struct S_FFD p2,  struct S_FFD (*cb)(struct S_FFD, int, struct S_FFD)) ;
+EXPORT struct S_FFP f17_S_SIS_FFP(struct S_FFP p0, int p1, struct S_FFP p2,  struct S_FFP (*cb)(struct S_FFP, int, struct S_FFP)) ;
+EXPORT struct S_FDI f17_S_SIS_FDI(struct S_FDI p0, int p1, struct S_FDI p2,  struct S_FDI (*cb)(struct S_FDI, int, struct S_FDI)) ;
+EXPORT struct S_FDF f17_S_SIS_FDF(struct S_FDF p0, int p1, struct S_FDF p2,  struct S_FDF (*cb)(struct S_FDF, int, struct S_FDF)) ;
+EXPORT struct S_FDD f17_S_SIS_FDD(struct S_FDD p0, int p1, struct S_FDD p2,  struct S_FDD (*cb)(struct S_FDD, int, struct S_FDD)) ;
+EXPORT struct S_FDP f17_S_SIS_FDP(struct S_FDP p0, int p1, struct S_FDP p2,  struct S_FDP (*cb)(struct S_FDP, int, struct S_FDP)) ;
+EXPORT struct S_FPI f17_S_SIS_FPI(struct S_FPI p0, int p1, struct S_FPI p2,  struct S_FPI (*cb)(struct S_FPI, int, struct S_FPI)) ;
+EXPORT struct S_FPF f17_S_SIS_FPF(struct S_FPF p0, int p1, struct S_FPF p2,  struct S_FPF (*cb)(struct S_FPF, int, struct S_FPF)) ;
+EXPORT struct S_FPD f17_S_SIS_FPD(struct S_FPD p0, int p1, struct S_FPD p2,  struct S_FPD (*cb)(struct S_FPD, int, struct S_FPD)) ;
+EXPORT struct S_FPP f17_S_SIS_FPP(struct S_FPP p0, int p1, struct S_FPP p2,  struct S_FPP (*cb)(struct S_FPP, int, struct S_FPP)) ;
+EXPORT struct S_DII f17_S_SIS_DII(struct S_DII p0, int p1, struct S_DII p2,  struct S_DII (*cb)(struct S_DII, int, struct S_DII)) ;
+EXPORT struct S_DIF f17_S_SIS_DIF(struct S_DIF p0, int p1, struct S_DIF p2,  struct S_DIF (*cb)(struct S_DIF, int, struct S_DIF)) ;
+EXPORT struct S_DID f17_S_SIS_DID(struct S_DID p0, int p1, struct S_DID p2,  struct S_DID (*cb)(struct S_DID, int, struct S_DID)) ;
+EXPORT struct S_DIP f17_S_SIS_DIP(struct S_DIP p0, int p1, struct S_DIP p2,  struct S_DIP (*cb)(struct S_DIP, int, struct S_DIP)) ;
+EXPORT struct S_DFI f17_S_SIS_DFI(struct S_DFI p0, int p1, struct S_DFI p2,  struct S_DFI (*cb)(struct S_DFI, int, struct S_DFI)) ;
+EXPORT struct S_DFF f17_S_SIS_DFF(struct S_DFF p0, int p1, struct S_DFF p2,  struct S_DFF (*cb)(struct S_DFF, int, struct S_DFF)) ;
+EXPORT struct S_DFD f17_S_SIS_DFD(struct S_DFD p0, int p1, struct S_DFD p2,  struct S_DFD (*cb)(struct S_DFD, int, struct S_DFD)) ;
+EXPORT struct S_DFP f17_S_SIS_DFP(struct S_DFP p0, int p1, struct S_DFP p2,  struct S_DFP (*cb)(struct S_DFP, int, struct S_DFP)) ;
+EXPORT struct S_DDI f17_S_SIS_DDI(struct S_DDI p0, int p1, struct S_DDI p2,  struct S_DDI (*cb)(struct S_DDI, int, struct S_DDI)) ;
+EXPORT struct S_DDF f17_S_SIS_DDF(struct S_DDF p0, int p1, struct S_DDF p2,  struct S_DDF (*cb)(struct S_DDF, int, struct S_DDF)) ;
+EXPORT struct S_DDD f17_S_SIS_DDD(struct S_DDD p0, int p1, struct S_DDD p2,  struct S_DDD (*cb)(struct S_DDD, int, struct S_DDD)) ;
+EXPORT struct S_DDP f17_S_SIS_DDP(struct S_DDP p0, int p1, struct S_DDP p2,  struct S_DDP (*cb)(struct S_DDP, int, struct S_DDP)) ;
+EXPORT struct S_DPI f17_S_SIS_DPI(struct S_DPI p0, int p1, struct S_DPI p2,  struct S_DPI (*cb)(struct S_DPI, int, struct S_DPI)) ;
+EXPORT struct S_DPF f17_S_SIS_DPF(struct S_DPF p0, int p1, struct S_DPF p2,  struct S_DPF (*cb)(struct S_DPF, int, struct S_DPF)) ;
+EXPORT struct S_DPD f17_S_SIS_DPD(struct S_DPD p0, int p1, struct S_DPD p2,  struct S_DPD (*cb)(struct S_DPD, int, struct S_DPD)) ;
+EXPORT struct S_DPP f17_S_SIS_DPP(struct S_DPP p0, int p1, struct S_DPP p2,  struct S_DPP (*cb)(struct S_DPP, int, struct S_DPP)) ;
+EXPORT struct S_PII f17_S_SIS_PII(struct S_PII p0, int p1, struct S_PII p2,  struct S_PII (*cb)(struct S_PII, int, struct S_PII)) ;
+EXPORT struct S_PIF f17_S_SIS_PIF(struct S_PIF p0, int p1, struct S_PIF p2,  struct S_PIF (*cb)(struct S_PIF, int, struct S_PIF)) ;
+EXPORT struct S_PID f17_S_SIS_PID(struct S_PID p0, int p1, struct S_PID p2,  struct S_PID (*cb)(struct S_PID, int, struct S_PID)) ;
+EXPORT struct S_PIP f17_S_SIS_PIP(struct S_PIP p0, int p1, struct S_PIP p2,  struct S_PIP (*cb)(struct S_PIP, int, struct S_PIP)) ;
+EXPORT struct S_PFI f17_S_SIS_PFI(struct S_PFI p0, int p1, struct S_PFI p2,  struct S_PFI (*cb)(struct S_PFI, int, struct S_PFI)) ;
+EXPORT struct S_PFF f17_S_SIS_PFF(struct S_PFF p0, int p1, struct S_PFF p2,  struct S_PFF (*cb)(struct S_PFF, int, struct S_PFF)) ;
+EXPORT struct S_PFD f17_S_SIS_PFD(struct S_PFD p0, int p1, struct S_PFD p2,  struct S_PFD (*cb)(struct S_PFD, int, struct S_PFD)) ;
+EXPORT struct S_PFP f17_S_SIS_PFP(struct S_PFP p0, int p1, struct S_PFP p2,  struct S_PFP (*cb)(struct S_PFP, int, struct S_PFP)) ;
+EXPORT struct S_PDI f17_S_SIS_PDI(struct S_PDI p0, int p1, struct S_PDI p2,  struct S_PDI (*cb)(struct S_PDI, int, struct S_PDI)) ;
+EXPORT struct S_PDF f17_S_SIS_PDF(struct S_PDF p0, int p1, struct S_PDF p2,  struct S_PDF (*cb)(struct S_PDF, int, struct S_PDF)) ;
+EXPORT struct S_PDD f17_S_SIS_PDD(struct S_PDD p0, int p1, struct S_PDD p2,  struct S_PDD (*cb)(struct S_PDD, int, struct S_PDD)) ;
+EXPORT struct S_PDP f17_S_SIS_PDP(struct S_PDP p0, int p1, struct S_PDP p2,  struct S_PDP (*cb)(struct S_PDP, int, struct S_PDP)) ;
+EXPORT struct S_PPI f17_S_SIS_PPI(struct S_PPI p0, int p1, struct S_PPI p2,  struct S_PPI (*cb)(struct S_PPI, int, struct S_PPI)) ;
+EXPORT struct S_PPF f17_S_SIS_PPF(struct S_PPF p0, int p1, struct S_PPF p2,  struct S_PPF (*cb)(struct S_PPF, int, struct S_PPF)) ;
+EXPORT struct S_PPD f17_S_SIS_PPD(struct S_PPD p0, int p1, struct S_PPD p2,  struct S_PPD (*cb)(struct S_PPD, int, struct S_PPD)) ;
+EXPORT struct S_PPP f17_S_SIS_PPP(struct S_PPP p0, int p1, struct S_PPP p2,  struct S_PPP (*cb)(struct S_PPP, int, struct S_PPP)) ;
+EXPORT struct S_I f17_S_SFI_I(struct S_I p0, float p1, int p2,  struct S_I (*cb)(struct S_I, float, int)) ;
+EXPORT struct S_F f17_S_SFI_F(struct S_F p0, float p1, int p2,  struct S_F (*cb)(struct S_F, float, int)) ;
+EXPORT struct S_D f17_S_SFI_D(struct S_D p0, float p1, int p2,  struct S_D (*cb)(struct S_D, float, int)) ;
+EXPORT struct S_P f17_S_SFI_P(struct S_P p0, float p1, int p2,  struct S_P (*cb)(struct S_P, float, int)) ;
+EXPORT struct S_II f17_S_SFI_II(struct S_II p0, float p1, int p2,  struct S_II (*cb)(struct S_II, float, int)) ;
+EXPORT struct S_IF f17_S_SFI_IF(struct S_IF p0, float p1, int p2,  struct S_IF (*cb)(struct S_IF, float, int)) ;
+EXPORT struct S_ID f17_S_SFI_ID(struct S_ID p0, float p1, int p2,  struct S_ID (*cb)(struct S_ID, float, int)) ;
+EXPORT struct S_IP f17_S_SFI_IP(struct S_IP p0, float p1, int p2,  struct S_IP (*cb)(struct S_IP, float, int)) ;
+EXPORT struct S_FI f17_S_SFI_FI(struct S_FI p0, float p1, int p2,  struct S_FI (*cb)(struct S_FI, float, int)) ;
+EXPORT struct S_FF f17_S_SFI_FF(struct S_FF p0, float p1, int p2,  struct S_FF (*cb)(struct S_FF, float, int)) ;
+EXPORT struct S_FD f17_S_SFI_FD(struct S_FD p0, float p1, int p2,  struct S_FD (*cb)(struct S_FD, float, int)) ;
+EXPORT struct S_FP f17_S_SFI_FP(struct S_FP p0, float p1, int p2,  struct S_FP (*cb)(struct S_FP, float, int)) ;
+EXPORT struct S_DI f17_S_SFI_DI(struct S_DI p0, float p1, int p2,  struct S_DI (*cb)(struct S_DI, float, int)) ;
+EXPORT struct S_DF f17_S_SFI_DF(struct S_DF p0, float p1, int p2,  struct S_DF (*cb)(struct S_DF, float, int)) ;
+EXPORT struct S_DD f17_S_SFI_DD(struct S_DD p0, float p1, int p2,  struct S_DD (*cb)(struct S_DD, float, int)) ;
+EXPORT struct S_DP f17_S_SFI_DP(struct S_DP p0, float p1, int p2,  struct S_DP (*cb)(struct S_DP, float, int)) ;
+EXPORT struct S_PI f17_S_SFI_PI(struct S_PI p0, float p1, int p2,  struct S_PI (*cb)(struct S_PI, float, int)) ;
+EXPORT struct S_PF f17_S_SFI_PF(struct S_PF p0, float p1, int p2,  struct S_PF (*cb)(struct S_PF, float, int)) ;
+EXPORT struct S_PD f17_S_SFI_PD(struct S_PD p0, float p1, int p2,  struct S_PD (*cb)(struct S_PD, float, int)) ;
+EXPORT struct S_PP f17_S_SFI_PP(struct S_PP p0, float p1, int p2,  struct S_PP (*cb)(struct S_PP, float, int)) ;
+EXPORT struct S_III f17_S_SFI_III(struct S_III p0, float p1, int p2,  struct S_III (*cb)(struct S_III, float, int)) ;
+EXPORT struct S_IIF f17_S_SFI_IIF(struct S_IIF p0, float p1, int p2,  struct S_IIF (*cb)(struct S_IIF, float, int)) ;
+EXPORT struct S_IID f17_S_SFI_IID(struct S_IID p0, float p1, int p2,  struct S_IID (*cb)(struct S_IID, float, int)) ;
+EXPORT struct S_IIP f17_S_SFI_IIP(struct S_IIP p0, float p1, int p2,  struct S_IIP (*cb)(struct S_IIP, float, int)) ;
+EXPORT struct S_IFI f17_S_SFI_IFI(struct S_IFI p0, float p1, int p2,  struct S_IFI (*cb)(struct S_IFI, float, int)) ;
+EXPORT struct S_IFF f17_S_SFI_IFF(struct S_IFF p0, float p1, int p2,  struct S_IFF (*cb)(struct S_IFF, float, int)) ;
+EXPORT struct S_IFD f17_S_SFI_IFD(struct S_IFD p0, float p1, int p2,  struct S_IFD (*cb)(struct S_IFD, float, int)) ;
+EXPORT struct S_IFP f17_S_SFI_IFP(struct S_IFP p0, float p1, int p2,  struct S_IFP (*cb)(struct S_IFP, float, int)) ;
+EXPORT struct S_IDI f17_S_SFI_IDI(struct S_IDI p0, float p1, int p2,  struct S_IDI (*cb)(struct S_IDI, float, int)) ;
+EXPORT struct S_IDF f17_S_SFI_IDF(struct S_IDF p0, float p1, int p2,  struct S_IDF (*cb)(struct S_IDF, float, int)) ;
+EXPORT struct S_IDD f17_S_SFI_IDD(struct S_IDD p0, float p1, int p2,  struct S_IDD (*cb)(struct S_IDD, float, int)) ;
+EXPORT struct S_IDP f17_S_SFI_IDP(struct S_IDP p0, float p1, int p2,  struct S_IDP (*cb)(struct S_IDP, float, int)) ;
+EXPORT struct S_IPI f17_S_SFI_IPI(struct S_IPI p0, float p1, int p2,  struct S_IPI (*cb)(struct S_IPI, float, int)) ;
+EXPORT struct S_IPF f17_S_SFI_IPF(struct S_IPF p0, float p1, int p2,  struct S_IPF (*cb)(struct S_IPF, float, int)) ;
+EXPORT struct S_IPD f17_S_SFI_IPD(struct S_IPD p0, float p1, int p2,  struct S_IPD (*cb)(struct S_IPD, float, int)) ;
+EXPORT struct S_IPP f17_S_SFI_IPP(struct S_IPP p0, float p1, int p2,  struct S_IPP (*cb)(struct S_IPP, float, int)) ;
+EXPORT struct S_FII f17_S_SFI_FII(struct S_FII p0, float p1, int p2,  struct S_FII (*cb)(struct S_FII, float, int)) ;
+EXPORT struct S_FIF f17_S_SFI_FIF(struct S_FIF p0, float p1, int p2,  struct S_FIF (*cb)(struct S_FIF, float, int)) ;
+EXPORT struct S_FID f17_S_SFI_FID(struct S_FID p0, float p1, int p2,  struct S_FID (*cb)(struct S_FID, float, int)) ;
+EXPORT struct S_FIP f17_S_SFI_FIP(struct S_FIP p0, float p1, int p2,  struct S_FIP (*cb)(struct S_FIP, float, int)) ;
+EXPORT struct S_FFI f17_S_SFI_FFI(struct S_FFI p0, float p1, int p2,  struct S_FFI (*cb)(struct S_FFI, float, int)) ;
+EXPORT struct S_FFF f17_S_SFI_FFF(struct S_FFF p0, float p1, int p2,  struct S_FFF (*cb)(struct S_FFF, float, int)) ;
+EXPORT struct S_FFD f17_S_SFI_FFD(struct S_FFD p0, float p1, int p2,  struct S_FFD (*cb)(struct S_FFD, float, int)) ;
+EXPORT struct S_FFP f17_S_SFI_FFP(struct S_FFP p0, float p1, int p2,  struct S_FFP (*cb)(struct S_FFP, float, int)) ;
+EXPORT struct S_FDI f17_S_SFI_FDI(struct S_FDI p0, float p1, int p2,  struct S_FDI (*cb)(struct S_FDI, float, int)) ;
+EXPORT struct S_FDF f17_S_SFI_FDF(struct S_FDF p0, float p1, int p2,  struct S_FDF (*cb)(struct S_FDF, float, int)) ;
+EXPORT struct S_FDD f17_S_SFI_FDD(struct S_FDD p0, float p1, int p2,  struct S_FDD (*cb)(struct S_FDD, float, int)) ;
+EXPORT struct S_FDP f17_S_SFI_FDP(struct S_FDP p0, float p1, int p2,  struct S_FDP (*cb)(struct S_FDP, float, int)) ;
+EXPORT struct S_FPI f17_S_SFI_FPI(struct S_FPI p0, float p1, int p2,  struct S_FPI (*cb)(struct S_FPI, float, int)) ;
+EXPORT struct S_FPF f17_S_SFI_FPF(struct S_FPF p0, float p1, int p2,  struct S_FPF (*cb)(struct S_FPF, float, int)) ;
+EXPORT struct S_FPD f17_S_SFI_FPD(struct S_FPD p0, float p1, int p2,  struct S_FPD (*cb)(struct S_FPD, float, int)) ;
+EXPORT struct S_FPP f17_S_SFI_FPP(struct S_FPP p0, float p1, int p2,  struct S_FPP (*cb)(struct S_FPP, float, int)) ;
+EXPORT struct S_DII f17_S_SFI_DII(struct S_DII p0, float p1, int p2,  struct S_DII (*cb)(struct S_DII, float, int)) ;
+EXPORT struct S_DIF f17_S_SFI_DIF(struct S_DIF p0, float p1, int p2,  struct S_DIF (*cb)(struct S_DIF, float, int)) ;
+EXPORT struct S_DID f17_S_SFI_DID(struct S_DID p0, float p1, int p2,  struct S_DID (*cb)(struct S_DID, float, int)) ;
+EXPORT struct S_DIP f17_S_SFI_DIP(struct S_DIP p0, float p1, int p2,  struct S_DIP (*cb)(struct S_DIP, float, int)) ;
+EXPORT struct S_DFI f17_S_SFI_DFI(struct S_DFI p0, float p1, int p2,  struct S_DFI (*cb)(struct S_DFI, float, int)) ;
+EXPORT struct S_DFF f17_S_SFI_DFF(struct S_DFF p0, float p1, int p2,  struct S_DFF (*cb)(struct S_DFF, float, int)) ;
+EXPORT struct S_DFD f17_S_SFI_DFD(struct S_DFD p0, float p1, int p2,  struct S_DFD (*cb)(struct S_DFD, float, int)) ;
+EXPORT struct S_DFP f17_S_SFI_DFP(struct S_DFP p0, float p1, int p2,  struct S_DFP (*cb)(struct S_DFP, float, int)) ;
+EXPORT struct S_DDI f17_S_SFI_DDI(struct S_DDI p0, float p1, int p2,  struct S_DDI (*cb)(struct S_DDI, float, int)) ;
+EXPORT struct S_DDF f17_S_SFI_DDF(struct S_DDF p0, float p1, int p2,  struct S_DDF (*cb)(struct S_DDF, float, int)) ;
+EXPORT struct S_DDD f17_S_SFI_DDD(struct S_DDD p0, float p1, int p2,  struct S_DDD (*cb)(struct S_DDD, float, int)) ;
+EXPORT struct S_DDP f17_S_SFI_DDP(struct S_DDP p0, float p1, int p2,  struct S_DDP (*cb)(struct S_DDP, float, int)) ;
+EXPORT struct S_DPI f17_S_SFI_DPI(struct S_DPI p0, float p1, int p2,  struct S_DPI (*cb)(struct S_DPI, float, int)) ;
+EXPORT struct S_DPF f17_S_SFI_DPF(struct S_DPF p0, float p1, int p2,  struct S_DPF (*cb)(struct S_DPF, float, int)) ;
+EXPORT struct S_DPD f17_S_SFI_DPD(struct S_DPD p0, float p1, int p2,  struct S_DPD (*cb)(struct S_DPD, float, int)) ;
+EXPORT struct S_DPP f17_S_SFI_DPP(struct S_DPP p0, float p1, int p2,  struct S_DPP (*cb)(struct S_DPP, float, int)) ;
+EXPORT struct S_PII f17_S_SFI_PII(struct S_PII p0, float p1, int p2,  struct S_PII (*cb)(struct S_PII, float, int)) ;
+EXPORT struct S_PIF f17_S_SFI_PIF(struct S_PIF p0, float p1, int p2,  struct S_PIF (*cb)(struct S_PIF, float, int)) ;
+EXPORT struct S_PID f17_S_SFI_PID(struct S_PID p0, float p1, int p2,  struct S_PID (*cb)(struct S_PID, float, int)) ;
+EXPORT struct S_PIP f17_S_SFI_PIP(struct S_PIP p0, float p1, int p2,  struct S_PIP (*cb)(struct S_PIP, float, int)) ;
+EXPORT struct S_PFI f17_S_SFI_PFI(struct S_PFI p0, float p1, int p2,  struct S_PFI (*cb)(struct S_PFI, float, int)) ;
+EXPORT struct S_PFF f17_S_SFI_PFF(struct S_PFF p0, float p1, int p2,  struct S_PFF (*cb)(struct S_PFF, float, int)) ;
+EXPORT struct S_PFD f17_S_SFI_PFD(struct S_PFD p0, float p1, int p2,  struct S_PFD (*cb)(struct S_PFD, float, int)) ;
+EXPORT struct S_PFP f17_S_SFI_PFP(struct S_PFP p0, float p1, int p2,  struct S_PFP (*cb)(struct S_PFP, float, int)) ;
+EXPORT struct S_PDI f17_S_SFI_PDI(struct S_PDI p0, float p1, int p2,  struct S_PDI (*cb)(struct S_PDI, float, int)) ;
+EXPORT struct S_PDF f17_S_SFI_PDF(struct S_PDF p0, float p1, int p2,  struct S_PDF (*cb)(struct S_PDF, float, int)) ;
+EXPORT struct S_PDD f17_S_SFI_PDD(struct S_PDD p0, float p1, int p2,  struct S_PDD (*cb)(struct S_PDD, float, int)) ;
+EXPORT struct S_PDP f17_S_SFI_PDP(struct S_PDP p0, float p1, int p2,  struct S_PDP (*cb)(struct S_PDP, float, int)) ;
+EXPORT struct S_PPI f17_S_SFI_PPI(struct S_PPI p0, float p1, int p2,  struct S_PPI (*cb)(struct S_PPI, float, int)) ;
+EXPORT struct S_PPF f17_S_SFI_PPF(struct S_PPF p0, float p1, int p2,  struct S_PPF (*cb)(struct S_PPF, float, int)) ;
+EXPORT struct S_PPD f17_S_SFI_PPD(struct S_PPD p0, float p1, int p2,  struct S_PPD (*cb)(struct S_PPD, float, int)) ;
+EXPORT struct S_PPP f17_S_SFI_PPP(struct S_PPP p0, float p1, int p2,  struct S_PPP (*cb)(struct S_PPP, float, int)) ;
+EXPORT struct S_I f17_S_SFF_I(struct S_I p0, float p1, float p2,  struct S_I (*cb)(struct S_I, float, float)) ;
+EXPORT struct S_F f17_S_SFF_F(struct S_F p0, float p1, float p2,  struct S_F (*cb)(struct S_F, float, float)) ;
+EXPORT struct S_D f17_S_SFF_D(struct S_D p0, float p1, float p2,  struct S_D (*cb)(struct S_D, float, float)) ;
+EXPORT struct S_P f17_S_SFF_P(struct S_P p0, float p1, float p2,  struct S_P (*cb)(struct S_P, float, float)) ;
+EXPORT struct S_II f17_S_SFF_II(struct S_II p0, float p1, float p2,  struct S_II (*cb)(struct S_II, float, float)) ;
+EXPORT struct S_IF f17_S_SFF_IF(struct S_IF p0, float p1, float p2,  struct S_IF (*cb)(struct S_IF, float, float)) ;
+EXPORT struct S_ID f17_S_SFF_ID(struct S_ID p0, float p1, float p2,  struct S_ID (*cb)(struct S_ID, float, float)) ;
+EXPORT struct S_IP f17_S_SFF_IP(struct S_IP p0, float p1, float p2,  struct S_IP (*cb)(struct S_IP, float, float)) ;
+EXPORT struct S_FI f17_S_SFF_FI(struct S_FI p0, float p1, float p2,  struct S_FI (*cb)(struct S_FI, float, float)) ;
+EXPORT struct S_FF f17_S_SFF_FF(struct S_FF p0, float p1, float p2,  struct S_FF (*cb)(struct S_FF, float, float)) ;
+EXPORT struct S_FD f17_S_SFF_FD(struct S_FD p0, float p1, float p2,  struct S_FD (*cb)(struct S_FD, float, float)) ;
+EXPORT struct S_FP f17_S_SFF_FP(struct S_FP p0, float p1, float p2,  struct S_FP (*cb)(struct S_FP, float, float)) ;
+EXPORT struct S_DI f17_S_SFF_DI(struct S_DI p0, float p1, float p2,  struct S_DI (*cb)(struct S_DI, float, float)) ;
+EXPORT struct S_DF f17_S_SFF_DF(struct S_DF p0, float p1, float p2,  struct S_DF (*cb)(struct S_DF, float, float)) ;
+EXPORT struct S_DD f17_S_SFF_DD(struct S_DD p0, float p1, float p2,  struct S_DD (*cb)(struct S_DD, float, float)) ;
+EXPORT struct S_DP f17_S_SFF_DP(struct S_DP p0, float p1, float p2,  struct S_DP (*cb)(struct S_DP, float, float)) ;
+EXPORT struct S_PI f17_S_SFF_PI(struct S_PI p0, float p1, float p2,  struct S_PI (*cb)(struct S_PI, float, float)) ;
+EXPORT struct S_PF f17_S_SFF_PF(struct S_PF p0, float p1, float p2,  struct S_PF (*cb)(struct S_PF, float, float)) ;
+EXPORT struct S_PD f17_S_SFF_PD(struct S_PD p0, float p1, float p2,  struct S_PD (*cb)(struct S_PD, float, float)) ;
+EXPORT struct S_PP f17_S_SFF_PP(struct S_PP p0, float p1, float p2,  struct S_PP (*cb)(struct S_PP, float, float)) ;
+EXPORT struct S_III f17_S_SFF_III(struct S_III p0, float p1, float p2,  struct S_III (*cb)(struct S_III, float, float)) ;
+EXPORT struct S_IIF f17_S_SFF_IIF(struct S_IIF p0, float p1, float p2,  struct S_IIF (*cb)(struct S_IIF, float, float)) ;
+EXPORT struct S_IID f17_S_SFF_IID(struct S_IID p0, float p1, float p2,  struct S_IID (*cb)(struct S_IID, float, float)) ;
+EXPORT struct S_IIP f17_S_SFF_IIP(struct S_IIP p0, float p1, float p2,  struct S_IIP (*cb)(struct S_IIP, float, float)) ;
+EXPORT struct S_IFI f17_S_SFF_IFI(struct S_IFI p0, float p1, float p2,  struct S_IFI (*cb)(struct S_IFI, float, float)) ;
+EXPORT struct S_IFF f17_S_SFF_IFF(struct S_IFF p0, float p1, float p2,  struct S_IFF (*cb)(struct S_IFF, float, float)) ;
+EXPORT struct S_IFD f17_S_SFF_IFD(struct S_IFD p0, float p1, float p2,  struct S_IFD (*cb)(struct S_IFD, float, float)) ;
+EXPORT struct S_IFP f17_S_SFF_IFP(struct S_IFP p0, float p1, float p2,  struct S_IFP (*cb)(struct S_IFP, float, float)) ;
+EXPORT struct S_IDI f17_S_SFF_IDI(struct S_IDI p0, float p1, float p2,  struct S_IDI (*cb)(struct S_IDI, float, float)) ;
+EXPORT struct S_IDF f17_S_SFF_IDF(struct S_IDF p0, float p1, float p2,  struct S_IDF (*cb)(struct S_IDF, float, float)) ;
+EXPORT struct S_IDD f17_S_SFF_IDD(struct S_IDD p0, float p1, float p2,  struct S_IDD (*cb)(struct S_IDD, float, float)) ;
+EXPORT struct S_IDP f17_S_SFF_IDP(struct S_IDP p0, float p1, float p2,  struct S_IDP (*cb)(struct S_IDP, float, float)) ;
+EXPORT struct S_IPI f17_S_SFF_IPI(struct S_IPI p0, float p1, float p2,  struct S_IPI (*cb)(struct S_IPI, float, float)) ;
+EXPORT struct S_IPF f17_S_SFF_IPF(struct S_IPF p0, float p1, float p2,  struct S_IPF (*cb)(struct S_IPF, float, float)) ;
+EXPORT struct S_IPD f17_S_SFF_IPD(struct S_IPD p0, float p1, float p2,  struct S_IPD (*cb)(struct S_IPD, float, float)) ;
+EXPORT struct S_IPP f17_S_SFF_IPP(struct S_IPP p0, float p1, float p2,  struct S_IPP (*cb)(struct S_IPP, float, float)) ;
+EXPORT struct S_FII f17_S_SFF_FII(struct S_FII p0, float p1, float p2,  struct S_FII (*cb)(struct S_FII, float, float)) ;
+EXPORT struct S_FIF f17_S_SFF_FIF(struct S_FIF p0, float p1, float p2,  struct S_FIF (*cb)(struct S_FIF, float, float)) ;
+EXPORT struct S_FID f17_S_SFF_FID(struct S_FID p0, float p1, float p2,  struct S_FID (*cb)(struct S_FID, float, float)) ;
+EXPORT struct S_FIP f17_S_SFF_FIP(struct S_FIP p0, float p1, float p2,  struct S_FIP (*cb)(struct S_FIP, float, float)) ;
+EXPORT struct S_FFI f17_S_SFF_FFI(struct S_FFI p0, float p1, float p2,  struct S_FFI (*cb)(struct S_FFI, float, float)) ;
+EXPORT struct S_FFF f17_S_SFF_FFF(struct S_FFF p0, float p1, float p2,  struct S_FFF (*cb)(struct S_FFF, float, float)) ;
+EXPORT struct S_FFD f17_S_SFF_FFD(struct S_FFD p0, float p1, float p2,  struct S_FFD (*cb)(struct S_FFD, float, float)) ;
+EXPORT struct S_FFP f17_S_SFF_FFP(struct S_FFP p0, float p1, float p2,  struct S_FFP (*cb)(struct S_FFP, float, float)) ;
+EXPORT struct S_FDI f17_S_SFF_FDI(struct S_FDI p0, float p1, float p2,  struct S_FDI (*cb)(struct S_FDI, float, float)) ;
+EXPORT struct S_FDF f17_S_SFF_FDF(struct S_FDF p0, float p1, float p2,  struct S_FDF (*cb)(struct S_FDF, float, float)) ;
+EXPORT struct S_FDD f17_S_SFF_FDD(struct S_FDD p0, float p1, float p2,  struct S_FDD (*cb)(struct S_FDD, float, float)) ;
+EXPORT struct S_FDP f17_S_SFF_FDP(struct S_FDP p0, float p1, float p2,  struct S_FDP (*cb)(struct S_FDP, float, float)) ;
+EXPORT struct S_FPI f17_S_SFF_FPI(struct S_FPI p0, float p1, float p2,  struct S_FPI (*cb)(struct S_FPI, float, float)) ;
+EXPORT struct S_FPF f17_S_SFF_FPF(struct S_FPF p0, float p1, float p2,  struct S_FPF (*cb)(struct S_FPF, float, float)) ;
+EXPORT struct S_FPD f17_S_SFF_FPD(struct S_FPD p0, float p1, float p2,  struct S_FPD (*cb)(struct S_FPD, float, float)) ;
+EXPORT struct S_FPP f17_S_SFF_FPP(struct S_FPP p0, float p1, float p2,  struct S_FPP (*cb)(struct S_FPP, float, float)) ;
+EXPORT struct S_DII f17_S_SFF_DII(struct S_DII p0, float p1, float p2,  struct S_DII (*cb)(struct S_DII, float, float)) ;
+EXPORT struct S_DIF f17_S_SFF_DIF(struct S_DIF p0, float p1, float p2,  struct S_DIF (*cb)(struct S_DIF, float, float)) ;
+EXPORT struct S_DID f17_S_SFF_DID(struct S_DID p0, float p1, float p2,  struct S_DID (*cb)(struct S_DID, float, float)) ;
+EXPORT struct S_DIP f17_S_SFF_DIP(struct S_DIP p0, float p1, float p2,  struct S_DIP (*cb)(struct S_DIP, float, float)) ;
+EXPORT struct S_DFI f17_S_SFF_DFI(struct S_DFI p0, float p1, float p2,  struct S_DFI (*cb)(struct S_DFI, float, float)) ;
+EXPORT struct S_DFF f17_S_SFF_DFF(struct S_DFF p0, float p1, float p2,  struct S_DFF (*cb)(struct S_DFF, float, float)) ;
+EXPORT struct S_DFD f17_S_SFF_DFD(struct S_DFD p0, float p1, float p2,  struct S_DFD (*cb)(struct S_DFD, float, float)) ;
+EXPORT struct S_DFP f17_S_SFF_DFP(struct S_DFP p0, float p1, float p2,  struct S_DFP (*cb)(struct S_DFP, float, float)) ;
+EXPORT struct S_DDI f17_S_SFF_DDI(struct S_DDI p0, float p1, float p2,  struct S_DDI (*cb)(struct S_DDI, float, float)) ;
+EXPORT struct S_DDF f17_S_SFF_DDF(struct S_DDF p0, float p1, float p2,  struct S_DDF (*cb)(struct S_DDF, float, float)) ;
+EXPORT struct S_DDD f17_S_SFF_DDD(struct S_DDD p0, float p1, float p2,  struct S_DDD (*cb)(struct S_DDD, float, float)) ;
+EXPORT struct S_DDP f17_S_SFF_DDP(struct S_DDP p0, float p1, float p2,  struct S_DDP (*cb)(struct S_DDP, float, float)) ;
+EXPORT struct S_DPI f17_S_SFF_DPI(struct S_DPI p0, float p1, float p2,  struct S_DPI (*cb)(struct S_DPI, float, float)) ;
+EXPORT struct S_DPF f17_S_SFF_DPF(struct S_DPF p0, float p1, float p2,  struct S_DPF (*cb)(struct S_DPF, float, float)) ;
+EXPORT struct S_DPD f17_S_SFF_DPD(struct S_DPD p0, float p1, float p2,  struct S_DPD (*cb)(struct S_DPD, float, float)) ;
+EXPORT struct S_DPP f17_S_SFF_DPP(struct S_DPP p0, float p1, float p2,  struct S_DPP (*cb)(struct S_DPP, float, float)) ;
+EXPORT struct S_PII f17_S_SFF_PII(struct S_PII p0, float p1, float p2,  struct S_PII (*cb)(struct S_PII, float, float)) ;
+EXPORT struct S_PIF f17_S_SFF_PIF(struct S_PIF p0, float p1, float p2,  struct S_PIF (*cb)(struct S_PIF, float, float)) ;
+EXPORT struct S_PID f17_S_SFF_PID(struct S_PID p0, float p1, float p2,  struct S_PID (*cb)(struct S_PID, float, float)) ;
+EXPORT struct S_PIP f17_S_SFF_PIP(struct S_PIP p0, float p1, float p2,  struct S_PIP (*cb)(struct S_PIP, float, float)) ;
+EXPORT struct S_PFI f17_S_SFF_PFI(struct S_PFI p0, float p1, float p2,  struct S_PFI (*cb)(struct S_PFI, float, float)) ;
+EXPORT struct S_PFF f17_S_SFF_PFF(struct S_PFF p0, float p1, float p2,  struct S_PFF (*cb)(struct S_PFF, float, float)) ;
+EXPORT struct S_PFD f17_S_SFF_PFD(struct S_PFD p0, float p1, float p2,  struct S_PFD (*cb)(struct S_PFD, float, float)) ;
+EXPORT struct S_PFP f17_S_SFF_PFP(struct S_PFP p0, float p1, float p2,  struct S_PFP (*cb)(struct S_PFP, float, float)) ;
+EXPORT struct S_PDI f17_S_SFF_PDI(struct S_PDI p0, float p1, float p2,  struct S_PDI (*cb)(struct S_PDI, float, float)) ;
+EXPORT struct S_PDF f17_S_SFF_PDF(struct S_PDF p0, float p1, float p2,  struct S_PDF (*cb)(struct S_PDF, float, float)) ;
+EXPORT struct S_PDD f17_S_SFF_PDD(struct S_PDD p0, float p1, float p2,  struct S_PDD (*cb)(struct S_PDD, float, float)) ;
+EXPORT struct S_PDP f17_S_SFF_PDP(struct S_PDP p0, float p1, float p2,  struct S_PDP (*cb)(struct S_PDP, float, float)) ;
+EXPORT struct S_PPI f17_S_SFF_PPI(struct S_PPI p0, float p1, float p2,  struct S_PPI (*cb)(struct S_PPI, float, float)) ;
+EXPORT struct S_PPF f17_S_SFF_PPF(struct S_PPF p0, float p1, float p2,  struct S_PPF (*cb)(struct S_PPF, float, float)) ;
+EXPORT struct S_PPD f17_S_SFF_PPD(struct S_PPD p0, float p1, float p2,  struct S_PPD (*cb)(struct S_PPD, float, float)) ;
+EXPORT struct S_PPP f17_S_SFF_PPP(struct S_PPP p0, float p1, float p2,  struct S_PPP (*cb)(struct S_PPP, float, float)) ;
+EXPORT struct S_I f17_S_SFD_I(struct S_I p0, float p1, double p2,  struct S_I (*cb)(struct S_I, float, double)) ;
+EXPORT struct S_F f17_S_SFD_F(struct S_F p0, float p1, double p2,  struct S_F (*cb)(struct S_F, float, double)) ;
+EXPORT struct S_D f17_S_SFD_D(struct S_D p0, float p1, double p2,  struct S_D (*cb)(struct S_D, float, double)) ;
+EXPORT struct S_P f17_S_SFD_P(struct S_P p0, float p1, double p2,  struct S_P (*cb)(struct S_P, float, double)) ;
+EXPORT struct S_II f17_S_SFD_II(struct S_II p0, float p1, double p2,  struct S_II (*cb)(struct S_II, float, double)) ;
+EXPORT struct S_IF f17_S_SFD_IF(struct S_IF p0, float p1, double p2,  struct S_IF (*cb)(struct S_IF, float, double)) ;
+EXPORT struct S_ID f17_S_SFD_ID(struct S_ID p0, float p1, double p2,  struct S_ID (*cb)(struct S_ID, float, double)) ;
+EXPORT struct S_IP f17_S_SFD_IP(struct S_IP p0, float p1, double p2,  struct S_IP (*cb)(struct S_IP, float, double)) ;
+EXPORT struct S_FI f17_S_SFD_FI(struct S_FI p0, float p1, double p2,  struct S_FI (*cb)(struct S_FI, float, double)) ;
+EXPORT struct S_FF f17_S_SFD_FF(struct S_FF p0, float p1, double p2,  struct S_FF (*cb)(struct S_FF, float, double)) ;
+EXPORT struct S_FD f17_S_SFD_FD(struct S_FD p0, float p1, double p2,  struct S_FD (*cb)(struct S_FD, float, double)) ;
+EXPORT struct S_FP f17_S_SFD_FP(struct S_FP p0, float p1, double p2,  struct S_FP (*cb)(struct S_FP, float, double)) ;
+EXPORT struct S_DI f17_S_SFD_DI(struct S_DI p0, float p1, double p2,  struct S_DI (*cb)(struct S_DI, float, double)) ;
+EXPORT struct S_DF f17_S_SFD_DF(struct S_DF p0, float p1, double p2,  struct S_DF (*cb)(struct S_DF, float, double)) ;
+EXPORT struct S_DD f17_S_SFD_DD(struct S_DD p0, float p1, double p2,  struct S_DD (*cb)(struct S_DD, float, double)) ;
+EXPORT struct S_DP f17_S_SFD_DP(struct S_DP p0, float p1, double p2,  struct S_DP (*cb)(struct S_DP, float, double)) ;
+EXPORT struct S_PI f17_S_SFD_PI(struct S_PI p0, float p1, double p2,  struct S_PI (*cb)(struct S_PI, float, double)) ;
+EXPORT struct S_PF f17_S_SFD_PF(struct S_PF p0, float p1, double p2,  struct S_PF (*cb)(struct S_PF, float, double)) ;
+EXPORT struct S_PD f17_S_SFD_PD(struct S_PD p0, float p1, double p2,  struct S_PD (*cb)(struct S_PD, float, double)) ;
+EXPORT struct S_PP f17_S_SFD_PP(struct S_PP p0, float p1, double p2,  struct S_PP (*cb)(struct S_PP, float, double)) ;
+EXPORT struct S_III f17_S_SFD_III(struct S_III p0, float p1, double p2,  struct S_III (*cb)(struct S_III, float, double)) ;
+EXPORT struct S_IIF f17_S_SFD_IIF(struct S_IIF p0, float p1, double p2,  struct S_IIF (*cb)(struct S_IIF, float, double)) ;
+EXPORT struct S_IID f17_S_SFD_IID(struct S_IID p0, float p1, double p2,  struct S_IID (*cb)(struct S_IID, float, double)) ;
+EXPORT struct S_IIP f17_S_SFD_IIP(struct S_IIP p0, float p1, double p2,  struct S_IIP (*cb)(struct S_IIP, float, double)) ;
+EXPORT struct S_IFI f17_S_SFD_IFI(struct S_IFI p0, float p1, double p2,  struct S_IFI (*cb)(struct S_IFI, float, double)) ;
+EXPORT struct S_IFF f17_S_SFD_IFF(struct S_IFF p0, float p1, double p2,  struct S_IFF (*cb)(struct S_IFF, float, double)) ;
+EXPORT struct S_IFD f17_S_SFD_IFD(struct S_IFD p0, float p1, double p2,  struct S_IFD (*cb)(struct S_IFD, float, double)) ;
+EXPORT struct S_IFP f17_S_SFD_IFP(struct S_IFP p0, float p1, double p2,  struct S_IFP (*cb)(struct S_IFP, float, double)) ;
+EXPORT struct S_IDI f17_S_SFD_IDI(struct S_IDI p0, float p1, double p2,  struct S_IDI (*cb)(struct S_IDI, float, double)) ;
+EXPORT struct S_IDF f17_S_SFD_IDF(struct S_IDF p0, float p1, double p2,  struct S_IDF (*cb)(struct S_IDF, float, double)) ;
+EXPORT struct S_IDD f17_S_SFD_IDD(struct S_IDD p0, float p1, double p2,  struct S_IDD (*cb)(struct S_IDD, float, double)) ;
+EXPORT struct S_IDP f17_S_SFD_IDP(struct S_IDP p0, float p1, double p2,  struct S_IDP (*cb)(struct S_IDP, float, double)) ;
+EXPORT struct S_IPI f17_S_SFD_IPI(struct S_IPI p0, float p1, double p2,  struct S_IPI (*cb)(struct S_IPI, float, double)) ;
+EXPORT struct S_IPF f17_S_SFD_IPF(struct S_IPF p0, float p1, double p2,  struct S_IPF (*cb)(struct S_IPF, float, double)) ;
+EXPORT struct S_IPD f17_S_SFD_IPD(struct S_IPD p0, float p1, double p2,  struct S_IPD (*cb)(struct S_IPD, float, double)) ;
+EXPORT struct S_IPP f17_S_SFD_IPP(struct S_IPP p0, float p1, double p2,  struct S_IPP (*cb)(struct S_IPP, float, double)) ;
+EXPORT struct S_FII f17_S_SFD_FII(struct S_FII p0, float p1, double p2,  struct S_FII (*cb)(struct S_FII, float, double)) ;
+EXPORT struct S_FIF f17_S_SFD_FIF(struct S_FIF p0, float p1, double p2,  struct S_FIF (*cb)(struct S_FIF, float, double)) ;
+EXPORT struct S_FID f17_S_SFD_FID(struct S_FID p0, float p1, double p2,  struct S_FID (*cb)(struct S_FID, float, double)) ;
+EXPORT struct S_FIP f17_S_SFD_FIP(struct S_FIP p0, float p1, double p2,  struct S_FIP (*cb)(struct S_FIP, float, double)) ;
+EXPORT struct S_FFI f17_S_SFD_FFI(struct S_FFI p0, float p1, double p2,  struct S_FFI (*cb)(struct S_FFI, float, double)) ;
+EXPORT struct S_FFF f17_S_SFD_FFF(struct S_FFF p0, float p1, double p2,  struct S_FFF (*cb)(struct S_FFF, float, double)) ;
+EXPORT struct S_FFD f17_S_SFD_FFD(struct S_FFD p0, float p1, double p2,  struct S_FFD (*cb)(struct S_FFD, float, double)) ;
+EXPORT struct S_FFP f17_S_SFD_FFP(struct S_FFP p0, float p1, double p2,  struct S_FFP (*cb)(struct S_FFP, float, double)) ;
+EXPORT struct S_FDI f17_S_SFD_FDI(struct S_FDI p0, float p1, double p2,  struct S_FDI (*cb)(struct S_FDI, float, double)) ;
+EXPORT struct S_FDF f17_S_SFD_FDF(struct S_FDF p0, float p1, double p2,  struct S_FDF (*cb)(struct S_FDF, float, double)) ;
+EXPORT struct S_FDD f17_S_SFD_FDD(struct S_FDD p0, float p1, double p2,  struct S_FDD (*cb)(struct S_FDD, float, double)) ;
+EXPORT struct S_FDP f17_S_SFD_FDP(struct S_FDP p0, float p1, double p2,  struct S_FDP (*cb)(struct S_FDP, float, double)) ;
+EXPORT struct S_FPI f17_S_SFD_FPI(struct S_FPI p0, float p1, double p2,  struct S_FPI (*cb)(struct S_FPI, float, double)) ;
+EXPORT struct S_FPF f17_S_SFD_FPF(struct S_FPF p0, float p1, double p2,  struct S_FPF (*cb)(struct S_FPF, float, double)) ;
+EXPORT struct S_FPD f17_S_SFD_FPD(struct S_FPD p0, float p1, double p2,  struct S_FPD (*cb)(struct S_FPD, float, double)) ;
+EXPORT struct S_FPP f17_S_SFD_FPP(struct S_FPP p0, float p1, double p2,  struct S_FPP (*cb)(struct S_FPP, float, double)) ;
+EXPORT struct S_DII f17_S_SFD_DII(struct S_DII p0, float p1, double p2,  struct S_DII (*cb)(struct S_DII, float, double)) ;
+EXPORT struct S_DIF f17_S_SFD_DIF(struct S_DIF p0, float p1, double p2,  struct S_DIF (*cb)(struct S_DIF, float, double)) ;
+EXPORT struct S_DID f17_S_SFD_DID(struct S_DID p0, float p1, double p2,  struct S_DID (*cb)(struct S_DID, float, double)) ;
+EXPORT struct S_DIP f17_S_SFD_DIP(struct S_DIP p0, float p1, double p2,  struct S_DIP (*cb)(struct S_DIP, float, double)) ;
+EXPORT struct S_DFI f17_S_SFD_DFI(struct S_DFI p0, float p1, double p2,  struct S_DFI (*cb)(struct S_DFI, float, double)) ;
+EXPORT struct S_DFF f17_S_SFD_DFF(struct S_DFF p0, float p1, double p2,  struct S_DFF (*cb)(struct S_DFF, float, double)) ;
+EXPORT struct S_DFD f17_S_SFD_DFD(struct S_DFD p0, float p1, double p2,  struct S_DFD (*cb)(struct S_DFD, float, double)) ;
+EXPORT struct S_DFP f17_S_SFD_DFP(struct S_DFP p0, float p1, double p2,  struct S_DFP (*cb)(struct S_DFP, float, double)) ;
+EXPORT struct S_DDI f17_S_SFD_DDI(struct S_DDI p0, float p1, double p2,  struct S_DDI (*cb)(struct S_DDI, float, double)) ;
+EXPORT struct S_DDF f17_S_SFD_DDF(struct S_DDF p0, float p1, double p2,  struct S_DDF (*cb)(struct S_DDF, float, double)) ;
+EXPORT struct S_DDD f17_S_SFD_DDD(struct S_DDD p0, float p1, double p2,  struct S_DDD (*cb)(struct S_DDD, float, double)) ;
+EXPORT struct S_DDP f17_S_SFD_DDP(struct S_DDP p0, float p1, double p2,  struct S_DDP (*cb)(struct S_DDP, float, double)) ;
+EXPORT struct S_DPI f17_S_SFD_DPI(struct S_DPI p0, float p1, double p2,  struct S_DPI (*cb)(struct S_DPI, float, double)) ;
+EXPORT struct S_DPF f17_S_SFD_DPF(struct S_DPF p0, float p1, double p2,  struct S_DPF (*cb)(struct S_DPF, float, double)) ;
+EXPORT struct S_DPD f17_S_SFD_DPD(struct S_DPD p0, float p1, double p2,  struct S_DPD (*cb)(struct S_DPD, float, double)) ;
+EXPORT struct S_DPP f17_S_SFD_DPP(struct S_DPP p0, float p1, double p2,  struct S_DPP (*cb)(struct S_DPP, float, double)) ;
+EXPORT struct S_PII f17_S_SFD_PII(struct S_PII p0, float p1, double p2,  struct S_PII (*cb)(struct S_PII, float, double)) ;
+EXPORT struct S_PIF f17_S_SFD_PIF(struct S_PIF p0, float p1, double p2,  struct S_PIF (*cb)(struct S_PIF, float, double)) ;
+EXPORT struct S_PID f17_S_SFD_PID(struct S_PID p0, float p1, double p2,  struct S_PID (*cb)(struct S_PID, float, double)) ;
+EXPORT struct S_PIP f17_S_SFD_PIP(struct S_PIP p0, float p1, double p2,  struct S_PIP (*cb)(struct S_PIP, float, double)) ;
+EXPORT struct S_PFI f17_S_SFD_PFI(struct S_PFI p0, float p1, double p2,  struct S_PFI (*cb)(struct S_PFI, float, double)) ;
+EXPORT struct S_PFF f17_S_SFD_PFF(struct S_PFF p0, float p1, double p2,  struct S_PFF (*cb)(struct S_PFF, float, double)) ;
+EXPORT struct S_PFD f17_S_SFD_PFD(struct S_PFD p0, float p1, double p2,  struct S_PFD (*cb)(struct S_PFD, float, double)) ;
+EXPORT struct S_PFP f17_S_SFD_PFP(struct S_PFP p0, float p1, double p2,  struct S_PFP (*cb)(struct S_PFP, float, double)) ;
+EXPORT struct S_PDI f17_S_SFD_PDI(struct S_PDI p0, float p1, double p2,  struct S_PDI (*cb)(struct S_PDI, float, double)) ;
+EXPORT struct S_PDF f17_S_SFD_PDF(struct S_PDF p0, float p1, double p2,  struct S_PDF (*cb)(struct S_PDF, float, double)) ;
+EXPORT struct S_PDD f17_S_SFD_PDD(struct S_PDD p0, float p1, double p2,  struct S_PDD (*cb)(struct S_PDD, float, double)) ;
+EXPORT struct S_PDP f17_S_SFD_PDP(struct S_PDP p0, float p1, double p2,  struct S_PDP (*cb)(struct S_PDP, float, double)) ;
+EXPORT struct S_PPI f17_S_SFD_PPI(struct S_PPI p0, float p1, double p2,  struct S_PPI (*cb)(struct S_PPI, float, double)) ;
+EXPORT struct S_PPF f17_S_SFD_PPF(struct S_PPF p0, float p1, double p2,  struct S_PPF (*cb)(struct S_PPF, float, double)) ;
+EXPORT struct S_PPD f17_S_SFD_PPD(struct S_PPD p0, float p1, double p2,  struct S_PPD (*cb)(struct S_PPD, float, double)) ;
+EXPORT struct S_PPP f17_S_SFD_PPP(struct S_PPP p0, float p1, double p2,  struct S_PPP (*cb)(struct S_PPP, float, double)) ;
+EXPORT struct S_I f17_S_SFP_I(struct S_I p0, float p1, void* p2,  struct S_I (*cb)(struct S_I, float, void*)) ;
+EXPORT struct S_F f17_S_SFP_F(struct S_F p0, float p1, void* p2,  struct S_F (*cb)(struct S_F, float, void*)) ;
+EXPORT struct S_D f17_S_SFP_D(struct S_D p0, float p1, void* p2,  struct S_D (*cb)(struct S_D, float, void*)) ;
+EXPORT struct S_P f17_S_SFP_P(struct S_P p0, float p1, void* p2,  struct S_P (*cb)(struct S_P, float, void*)) ;
+EXPORT struct S_II f17_S_SFP_II(struct S_II p0, float p1, void* p2,  struct S_II (*cb)(struct S_II, float, void*)) ;
+EXPORT struct S_IF f17_S_SFP_IF(struct S_IF p0, float p1, void* p2,  struct S_IF (*cb)(struct S_IF, float, void*)) ;
+EXPORT struct S_ID f17_S_SFP_ID(struct S_ID p0, float p1, void* p2,  struct S_ID (*cb)(struct S_ID, float, void*)) ;
+EXPORT struct S_IP f17_S_SFP_IP(struct S_IP p0, float p1, void* p2,  struct S_IP (*cb)(struct S_IP, float, void*)) ;
+EXPORT struct S_FI f17_S_SFP_FI(struct S_FI p0, float p1, void* p2,  struct S_FI (*cb)(struct S_FI, float, void*)) ;
+EXPORT struct S_FF f17_S_SFP_FF(struct S_FF p0, float p1, void* p2,  struct S_FF (*cb)(struct S_FF, float, void*)) ;
+EXPORT struct S_FD f17_S_SFP_FD(struct S_FD p0, float p1, void* p2,  struct S_FD (*cb)(struct S_FD, float, void*)) ;
+EXPORT struct S_FP f17_S_SFP_FP(struct S_FP p0, float p1, void* p2,  struct S_FP (*cb)(struct S_FP, float, void*)) ;
+EXPORT struct S_DI f17_S_SFP_DI(struct S_DI p0, float p1, void* p2,  struct S_DI (*cb)(struct S_DI, float, void*)) ;
+EXPORT struct S_DF f17_S_SFP_DF(struct S_DF p0, float p1, void* p2,  struct S_DF (*cb)(struct S_DF, float, void*)) ;
+EXPORT struct S_DD f17_S_SFP_DD(struct S_DD p0, float p1, void* p2,  struct S_DD (*cb)(struct S_DD, float, void*)) ;
+EXPORT struct S_DP f17_S_SFP_DP(struct S_DP p0, float p1, void* p2,  struct S_DP (*cb)(struct S_DP, float, void*)) ;
+EXPORT struct S_PI f17_S_SFP_PI(struct S_PI p0, float p1, void* p2,  struct S_PI (*cb)(struct S_PI, float, void*)) ;
+EXPORT struct S_PF f17_S_SFP_PF(struct S_PF p0, float p1, void* p2,  struct S_PF (*cb)(struct S_PF, float, void*)) ;
+EXPORT struct S_PD f17_S_SFP_PD(struct S_PD p0, float p1, void* p2,  struct S_PD (*cb)(struct S_PD, float, void*)) ;
+EXPORT struct S_PP f17_S_SFP_PP(struct S_PP p0, float p1, void* p2,  struct S_PP (*cb)(struct S_PP, float, void*)) ;
+EXPORT struct S_III f17_S_SFP_III(struct S_III p0, float p1, void* p2,  struct S_III (*cb)(struct S_III, float, void*)) ;
+EXPORT struct S_IIF f17_S_SFP_IIF(struct S_IIF p0, float p1, void* p2,  struct S_IIF (*cb)(struct S_IIF, float, void*)) ;
+EXPORT struct S_IID f17_S_SFP_IID(struct S_IID p0, float p1, void* p2,  struct S_IID (*cb)(struct S_IID, float, void*)) ;
+EXPORT struct S_IIP f17_S_SFP_IIP(struct S_IIP p0, float p1, void* p2,  struct S_IIP (*cb)(struct S_IIP, float, void*)) ;
+EXPORT struct S_IFI f17_S_SFP_IFI(struct S_IFI p0, float p1, void* p2,  struct S_IFI (*cb)(struct S_IFI, float, void*)) ;
+EXPORT struct S_IFF f17_S_SFP_IFF(struct S_IFF p0, float p1, void* p2,  struct S_IFF (*cb)(struct S_IFF, float, void*)) ;
+EXPORT struct S_IFD f17_S_SFP_IFD(struct S_IFD p0, float p1, void* p2,  struct S_IFD (*cb)(struct S_IFD, float, void*)) ;
+EXPORT struct S_IFP f17_S_SFP_IFP(struct S_IFP p0, float p1, void* p2,  struct S_IFP (*cb)(struct S_IFP, float, void*)) ;
+EXPORT struct S_IDI f17_S_SFP_IDI(struct S_IDI p0, float p1, void* p2,  struct S_IDI (*cb)(struct S_IDI, float, void*)) ;
+EXPORT struct S_IDF f17_S_SFP_IDF(struct S_IDF p0, float p1, void* p2,  struct S_IDF (*cb)(struct S_IDF, float, void*)) ;
+EXPORT struct S_IDD f17_S_SFP_IDD(struct S_IDD p0, float p1, void* p2,  struct S_IDD (*cb)(struct S_IDD, float, void*)) ;
+EXPORT struct S_IDP f17_S_SFP_IDP(struct S_IDP p0, float p1, void* p2,  struct S_IDP (*cb)(struct S_IDP, float, void*)) ;
+EXPORT struct S_IPI f17_S_SFP_IPI(struct S_IPI p0, float p1, void* p2,  struct S_IPI (*cb)(struct S_IPI, float, void*)) ;
+EXPORT struct S_IPF f17_S_SFP_IPF(struct S_IPF p0, float p1, void* p2,  struct S_IPF (*cb)(struct S_IPF, float, void*)) ;
+EXPORT struct S_IPD f17_S_SFP_IPD(struct S_IPD p0, float p1, void* p2,  struct S_IPD (*cb)(struct S_IPD, float, void*)) ;
+EXPORT struct S_IPP f17_S_SFP_IPP(struct S_IPP p0, float p1, void* p2,  struct S_IPP (*cb)(struct S_IPP, float, void*)) ;
+EXPORT struct S_FII f17_S_SFP_FII(struct S_FII p0, float p1, void* p2,  struct S_FII (*cb)(struct S_FII, float, void*)) ;
+EXPORT struct S_FIF f17_S_SFP_FIF(struct S_FIF p0, float p1, void* p2,  struct S_FIF (*cb)(struct S_FIF, float, void*)) ;
+EXPORT struct S_FID f17_S_SFP_FID(struct S_FID p0, float p1, void* p2,  struct S_FID (*cb)(struct S_FID, float, void*)) ;
+EXPORT struct S_FIP f17_S_SFP_FIP(struct S_FIP p0, float p1, void* p2,  struct S_FIP (*cb)(struct S_FIP, float, void*)) ;
+EXPORT struct S_FFI f17_S_SFP_FFI(struct S_FFI p0, float p1, void* p2,  struct S_FFI (*cb)(struct S_FFI, float, void*)) ;
+EXPORT struct S_FFF f17_S_SFP_FFF(struct S_FFF p0, float p1, void* p2,  struct S_FFF (*cb)(struct S_FFF, float, void*)) ;
+EXPORT struct S_FFD f17_S_SFP_FFD(struct S_FFD p0, float p1, void* p2,  struct S_FFD (*cb)(struct S_FFD, float, void*)) ;
+EXPORT struct S_FFP f17_S_SFP_FFP(struct S_FFP p0, float p1, void* p2,  struct S_FFP (*cb)(struct S_FFP, float, void*)) ;
+EXPORT struct S_FDI f17_S_SFP_FDI(struct S_FDI p0, float p1, void* p2,  struct S_FDI (*cb)(struct S_FDI, float, void*)) ;
+EXPORT struct S_FDF f17_S_SFP_FDF(struct S_FDF p0, float p1, void* p2,  struct S_FDF (*cb)(struct S_FDF, float, void*)) ;
+EXPORT struct S_FDD f17_S_SFP_FDD(struct S_FDD p0, float p1, void* p2,  struct S_FDD (*cb)(struct S_FDD, float, void*)) ;
+EXPORT struct S_FDP f17_S_SFP_FDP(struct S_FDP p0, float p1, void* p2,  struct S_FDP (*cb)(struct S_FDP, float, void*)) ;
+EXPORT struct S_FPI f17_S_SFP_FPI(struct S_FPI p0, float p1, void* p2,  struct S_FPI (*cb)(struct S_FPI, float, void*)) ;
+EXPORT struct S_FPF f17_S_SFP_FPF(struct S_FPF p0, float p1, void* p2,  struct S_FPF (*cb)(struct S_FPF, float, void*)) ;
+EXPORT struct S_FPD f17_S_SFP_FPD(struct S_FPD p0, float p1, void* p2,  struct S_FPD (*cb)(struct S_FPD, float, void*)) ;
+EXPORT struct S_FPP f17_S_SFP_FPP(struct S_FPP p0, float p1, void* p2,  struct S_FPP (*cb)(struct S_FPP, float, void*)) ;
+EXPORT struct S_DII f17_S_SFP_DII(struct S_DII p0, float p1, void* p2,  struct S_DII (*cb)(struct S_DII, float, void*)) ;
+EXPORT struct S_DIF f17_S_SFP_DIF(struct S_DIF p0, float p1, void* p2,  struct S_DIF (*cb)(struct S_DIF, float, void*)) ;
+EXPORT struct S_DID f17_S_SFP_DID(struct S_DID p0, float p1, void* p2,  struct S_DID (*cb)(struct S_DID, float, void*)) ;
+EXPORT struct S_DIP f17_S_SFP_DIP(struct S_DIP p0, float p1, void* p2,  struct S_DIP (*cb)(struct S_DIP, float, void*)) ;
+EXPORT struct S_DFI f17_S_SFP_DFI(struct S_DFI p0, float p1, void* p2,  struct S_DFI (*cb)(struct S_DFI, float, void*)) ;
+EXPORT struct S_DFF f17_S_SFP_DFF(struct S_DFF p0, float p1, void* p2,  struct S_DFF (*cb)(struct S_DFF, float, void*)) ;
+EXPORT struct S_DFD f17_S_SFP_DFD(struct S_DFD p0, float p1, void* p2,  struct S_DFD (*cb)(struct S_DFD, float, void*)) ;
+EXPORT struct S_DFP f17_S_SFP_DFP(struct S_DFP p0, float p1, void* p2,  struct S_DFP (*cb)(struct S_DFP, float, void*)) ;
+EXPORT struct S_DDI f17_S_SFP_DDI(struct S_DDI p0, float p1, void* p2,  struct S_DDI (*cb)(struct S_DDI, float, void*)) ;
+EXPORT struct S_DDF f17_S_SFP_DDF(struct S_DDF p0, float p1, void* p2,  struct S_DDF (*cb)(struct S_DDF, float, void*)) ;
+EXPORT struct S_DDD f17_S_SFP_DDD(struct S_DDD p0, float p1, void* p2,  struct S_DDD (*cb)(struct S_DDD, float, void*)) ;
+EXPORT struct S_DDP f17_S_SFP_DDP(struct S_DDP p0, float p1, void* p2,  struct S_DDP (*cb)(struct S_DDP, float, void*)) ;
+EXPORT struct S_DPI f17_S_SFP_DPI(struct S_DPI p0, float p1, void* p2,  struct S_DPI (*cb)(struct S_DPI, float, void*)) ;
+EXPORT struct S_DPF f17_S_SFP_DPF(struct S_DPF p0, float p1, void* p2,  struct S_DPF (*cb)(struct S_DPF, float, void*)) ;
+EXPORT struct S_DPD f17_S_SFP_DPD(struct S_DPD p0, float p1, void* p2,  struct S_DPD (*cb)(struct S_DPD, float, void*)) ;
+EXPORT struct S_DPP f17_S_SFP_DPP(struct S_DPP p0, float p1, void* p2,  struct S_DPP (*cb)(struct S_DPP, float, void*)) ;
+EXPORT struct S_PII f17_S_SFP_PII(struct S_PII p0, float p1, void* p2,  struct S_PII (*cb)(struct S_PII, float, void*)) ;
+EXPORT struct S_PIF f17_S_SFP_PIF(struct S_PIF p0, float p1, void* p2,  struct S_PIF (*cb)(struct S_PIF, float, void*)) ;
+EXPORT struct S_PID f17_S_SFP_PID(struct S_PID p0, float p1, void* p2,  struct S_PID (*cb)(struct S_PID, float, void*)) ;
+EXPORT struct S_PIP f17_S_SFP_PIP(struct S_PIP p0, float p1, void* p2,  struct S_PIP (*cb)(struct S_PIP, float, void*)) ;
+EXPORT struct S_PFI f17_S_SFP_PFI(struct S_PFI p0, float p1, void* p2,  struct S_PFI (*cb)(struct S_PFI, float, void*)) ;
+EXPORT struct S_PFF f17_S_SFP_PFF(struct S_PFF p0, float p1, void* p2,  struct S_PFF (*cb)(struct S_PFF, float, void*)) ;
+EXPORT struct S_PFD f17_S_SFP_PFD(struct S_PFD p0, float p1, void* p2,  struct S_PFD (*cb)(struct S_PFD, float, void*)) ;
+EXPORT struct S_PFP f17_S_SFP_PFP(struct S_PFP p0, float p1, void* p2,  struct S_PFP (*cb)(struct S_PFP, float, void*)) ;
+EXPORT struct S_PDI f17_S_SFP_PDI(struct S_PDI p0, float p1, void* p2,  struct S_PDI (*cb)(struct S_PDI, float, void*)) ;
+EXPORT struct S_PDF f17_S_SFP_PDF(struct S_PDF p0, float p1, void* p2,  struct S_PDF (*cb)(struct S_PDF, float, void*)) ;
+EXPORT struct S_PDD f17_S_SFP_PDD(struct S_PDD p0, float p1, void* p2,  struct S_PDD (*cb)(struct S_PDD, float, void*)) ;
+EXPORT struct S_PDP f17_S_SFP_PDP(struct S_PDP p0, float p1, void* p2,  struct S_PDP (*cb)(struct S_PDP, float, void*)) ;
+EXPORT struct S_PPI f17_S_SFP_PPI(struct S_PPI p0, float p1, void* p2,  struct S_PPI (*cb)(struct S_PPI, float, void*)) ;
+EXPORT struct S_PPF f17_S_SFP_PPF(struct S_PPF p0, float p1, void* p2,  struct S_PPF (*cb)(struct S_PPF, float, void*)) ;
+EXPORT struct S_PPD f17_S_SFP_PPD(struct S_PPD p0, float p1, void* p2,  struct S_PPD (*cb)(struct S_PPD, float, void*)) ;
+EXPORT struct S_PPP f17_S_SFP_PPP(struct S_PPP p0, float p1, void* p2,  struct S_PPP (*cb)(struct S_PPP, float, void*)) ;
+EXPORT struct S_I f17_S_SFS_I(struct S_I p0, float p1, struct S_I p2,  struct S_I (*cb)(struct S_I, float, struct S_I)) ;
+EXPORT struct S_F f17_S_SFS_F(struct S_F p0, float p1, struct S_F p2,  struct S_F (*cb)(struct S_F, float, struct S_F)) ;
+EXPORT struct S_D f17_S_SFS_D(struct S_D p0, float p1, struct S_D p2,  struct S_D (*cb)(struct S_D, float, struct S_D)) ;
+EXPORT struct S_P f17_S_SFS_P(struct S_P p0, float p1, struct S_P p2,  struct S_P (*cb)(struct S_P, float, struct S_P)) ;
+EXPORT struct S_II f17_S_SFS_II(struct S_II p0, float p1, struct S_II p2,  struct S_II (*cb)(struct S_II, float, struct S_II)) ;
+EXPORT struct S_IF f17_S_SFS_IF(struct S_IF p0, float p1, struct S_IF p2,  struct S_IF (*cb)(struct S_IF, float, struct S_IF)) ;
+EXPORT struct S_ID f17_S_SFS_ID(struct S_ID p0, float p1, struct S_ID p2,  struct S_ID (*cb)(struct S_ID, float, struct S_ID)) ;
+EXPORT struct S_IP f17_S_SFS_IP(struct S_IP p0, float p1, struct S_IP p2,  struct S_IP (*cb)(struct S_IP, float, struct S_IP)) ;
+EXPORT struct S_FI f17_S_SFS_FI(struct S_FI p0, float p1, struct S_FI p2,  struct S_FI (*cb)(struct S_FI, float, struct S_FI)) ;
+EXPORT struct S_FF f17_S_SFS_FF(struct S_FF p0, float p1, struct S_FF p2,  struct S_FF (*cb)(struct S_FF, float, struct S_FF)) ;
+EXPORT struct S_FD f17_S_SFS_FD(struct S_FD p0, float p1, struct S_FD p2,  struct S_FD (*cb)(struct S_FD, float, struct S_FD)) ;
+EXPORT struct S_FP f17_S_SFS_FP(struct S_FP p0, float p1, struct S_FP p2,  struct S_FP (*cb)(struct S_FP, float, struct S_FP)) ;
+EXPORT struct S_DI f17_S_SFS_DI(struct S_DI p0, float p1, struct S_DI p2,  struct S_DI (*cb)(struct S_DI, float, struct S_DI)) ;
+EXPORT struct S_DF f17_S_SFS_DF(struct S_DF p0, float p1, struct S_DF p2,  struct S_DF (*cb)(struct S_DF, float, struct S_DF)) ;
+EXPORT struct S_DD f17_S_SFS_DD(struct S_DD p0, float p1, struct S_DD p2,  struct S_DD (*cb)(struct S_DD, float, struct S_DD)) ;
+EXPORT struct S_DP f17_S_SFS_DP(struct S_DP p0, float p1, struct S_DP p2,  struct S_DP (*cb)(struct S_DP, float, struct S_DP)) ;
+EXPORT struct S_PI f17_S_SFS_PI(struct S_PI p0, float p1, struct S_PI p2,  struct S_PI (*cb)(struct S_PI, float, struct S_PI)) ;
+EXPORT struct S_PF f17_S_SFS_PF(struct S_PF p0, float p1, struct S_PF p2,  struct S_PF (*cb)(struct S_PF, float, struct S_PF)) ;
+EXPORT struct S_PD f17_S_SFS_PD(struct S_PD p0, float p1, struct S_PD p2,  struct S_PD (*cb)(struct S_PD, float, struct S_PD)) ;
+EXPORT struct S_PP f17_S_SFS_PP(struct S_PP p0, float p1, struct S_PP p2,  struct S_PP (*cb)(struct S_PP, float, struct S_PP)) ;
+EXPORT struct S_III f17_S_SFS_III(struct S_III p0, float p1, struct S_III p2,  struct S_III (*cb)(struct S_III, float, struct S_III)) ;
+EXPORT struct S_IIF f17_S_SFS_IIF(struct S_IIF p0, float p1, struct S_IIF p2,  struct S_IIF (*cb)(struct S_IIF, float, struct S_IIF)) ;
+EXPORT struct S_IID f17_S_SFS_IID(struct S_IID p0, float p1, struct S_IID p2,  struct S_IID (*cb)(struct S_IID, float, struct S_IID)) ;
+EXPORT struct S_IIP f17_S_SFS_IIP(struct S_IIP p0, float p1, struct S_IIP p2,  struct S_IIP (*cb)(struct S_IIP, float, struct S_IIP)) ;
+EXPORT struct S_IFI f17_S_SFS_IFI(struct S_IFI p0, float p1, struct S_IFI p2,  struct S_IFI (*cb)(struct S_IFI, float, struct S_IFI)) ;
+EXPORT struct S_IFF f17_S_SFS_IFF(struct S_IFF p0, float p1, struct S_IFF p2,  struct S_IFF (*cb)(struct S_IFF, float, struct S_IFF)) ;
+EXPORT struct S_IFD f17_S_SFS_IFD(struct S_IFD p0, float p1, struct S_IFD p2,  struct S_IFD (*cb)(struct S_IFD, float, struct S_IFD)) ;
+EXPORT struct S_IFP f17_S_SFS_IFP(struct S_IFP p0, float p1, struct S_IFP p2,  struct S_IFP (*cb)(struct S_IFP, float, struct S_IFP)) ;
+EXPORT struct S_IDI f17_S_SFS_IDI(struct S_IDI p0, float p1, struct S_IDI p2,  struct S_IDI (*cb)(struct S_IDI, float, struct S_IDI)) ;
+EXPORT struct S_IDF f17_S_SFS_IDF(struct S_IDF p0, float p1, struct S_IDF p2,  struct S_IDF (*cb)(struct S_IDF, float, struct S_IDF)) ;
+EXPORT struct S_IDD f17_S_SFS_IDD(struct S_IDD p0, float p1, struct S_IDD p2,  struct S_IDD (*cb)(struct S_IDD, float, struct S_IDD)) ;
+EXPORT struct S_IDP f17_S_SFS_IDP(struct S_IDP p0, float p1, struct S_IDP p2,  struct S_IDP (*cb)(struct S_IDP, float, struct S_IDP)) ;
+EXPORT struct S_IPI f17_S_SFS_IPI(struct S_IPI p0, float p1, struct S_IPI p2,  struct S_IPI (*cb)(struct S_IPI, float, struct S_IPI)) ;
+EXPORT struct S_IPF f17_S_SFS_IPF(struct S_IPF p0, float p1, struct S_IPF p2,  struct S_IPF (*cb)(struct S_IPF, float, struct S_IPF)) ;
+EXPORT struct S_IPD f17_S_SFS_IPD(struct S_IPD p0, float p1, struct S_IPD p2,  struct S_IPD (*cb)(struct S_IPD, float, struct S_IPD)) ;
+EXPORT struct S_IPP f17_S_SFS_IPP(struct S_IPP p0, float p1, struct S_IPP p2,  struct S_IPP (*cb)(struct S_IPP, float, struct S_IPP)) ;
+EXPORT struct S_FII f17_S_SFS_FII(struct S_FII p0, float p1, struct S_FII p2,  struct S_FII (*cb)(struct S_FII, float, struct S_FII)) ;
+EXPORT struct S_FIF f17_S_SFS_FIF(struct S_FIF p0, float p1, struct S_FIF p2,  struct S_FIF (*cb)(struct S_FIF, float, struct S_FIF)) ;
+EXPORT struct S_FID f17_S_SFS_FID(struct S_FID p0, float p1, struct S_FID p2,  struct S_FID (*cb)(struct S_FID, float, struct S_FID)) ;
+EXPORT struct S_FIP f17_S_SFS_FIP(struct S_FIP p0, float p1, struct S_FIP p2,  struct S_FIP (*cb)(struct S_FIP, float, struct S_FIP)) ;
+EXPORT struct S_FFI f17_S_SFS_FFI(struct S_FFI p0, float p1, struct S_FFI p2,  struct S_FFI (*cb)(struct S_FFI, float, struct S_FFI)) ;
+EXPORT struct S_FFF f17_S_SFS_FFF(struct S_FFF p0, float p1, struct S_FFF p2,  struct S_FFF (*cb)(struct S_FFF, float, struct S_FFF)) ;
+EXPORT struct S_FFD f17_S_SFS_FFD(struct S_FFD p0, float p1, struct S_FFD p2,  struct S_FFD (*cb)(struct S_FFD, float, struct S_FFD)) ;
+EXPORT struct S_FFP f17_S_SFS_FFP(struct S_FFP p0, float p1, struct S_FFP p2,  struct S_FFP (*cb)(struct S_FFP, float, struct S_FFP)) ;
+EXPORT struct S_FDI f17_S_SFS_FDI(struct S_FDI p0, float p1, struct S_FDI p2,  struct S_FDI (*cb)(struct S_FDI, float, struct S_FDI)) ;
+EXPORT struct S_FDF f17_S_SFS_FDF(struct S_FDF p0, float p1, struct S_FDF p2,  struct S_FDF (*cb)(struct S_FDF, float, struct S_FDF)) ;
+EXPORT struct S_FDD f17_S_SFS_FDD(struct S_FDD p0, float p1, struct S_FDD p2,  struct S_FDD (*cb)(struct S_FDD, float, struct S_FDD)) ;
+EXPORT struct S_FDP f18_S_SFS_FDP(struct S_FDP p0, float p1, struct S_FDP p2,  struct S_FDP (*cb)(struct S_FDP, float, struct S_FDP)) ;
+EXPORT struct S_FPI f18_S_SFS_FPI(struct S_FPI p0, float p1, struct S_FPI p2,  struct S_FPI (*cb)(struct S_FPI, float, struct S_FPI)) ;
+EXPORT struct S_FPF f18_S_SFS_FPF(struct S_FPF p0, float p1, struct S_FPF p2,  struct S_FPF (*cb)(struct S_FPF, float, struct S_FPF)) ;
+EXPORT struct S_FPD f18_S_SFS_FPD(struct S_FPD p0, float p1, struct S_FPD p2,  struct S_FPD (*cb)(struct S_FPD, float, struct S_FPD)) ;
+EXPORT struct S_FPP f18_S_SFS_FPP(struct S_FPP p0, float p1, struct S_FPP p2,  struct S_FPP (*cb)(struct S_FPP, float, struct S_FPP)) ;
+EXPORT struct S_DII f18_S_SFS_DII(struct S_DII p0, float p1, struct S_DII p2,  struct S_DII (*cb)(struct S_DII, float, struct S_DII)) ;
+EXPORT struct S_DIF f18_S_SFS_DIF(struct S_DIF p0, float p1, struct S_DIF p2,  struct S_DIF (*cb)(struct S_DIF, float, struct S_DIF)) ;
+EXPORT struct S_DID f18_S_SFS_DID(struct S_DID p0, float p1, struct S_DID p2,  struct S_DID (*cb)(struct S_DID, float, struct S_DID)) ;
+EXPORT struct S_DIP f18_S_SFS_DIP(struct S_DIP p0, float p1, struct S_DIP p2,  struct S_DIP (*cb)(struct S_DIP, float, struct S_DIP)) ;
+EXPORT struct S_DFI f18_S_SFS_DFI(struct S_DFI p0, float p1, struct S_DFI p2,  struct S_DFI (*cb)(struct S_DFI, float, struct S_DFI)) ;
+EXPORT struct S_DFF f18_S_SFS_DFF(struct S_DFF p0, float p1, struct S_DFF p2,  struct S_DFF (*cb)(struct S_DFF, float, struct S_DFF)) ;
+EXPORT struct S_DFD f18_S_SFS_DFD(struct S_DFD p0, float p1, struct S_DFD p2,  struct S_DFD (*cb)(struct S_DFD, float, struct S_DFD)) ;
+EXPORT struct S_DFP f18_S_SFS_DFP(struct S_DFP p0, float p1, struct S_DFP p2,  struct S_DFP (*cb)(struct S_DFP, float, struct S_DFP)) ;
+EXPORT struct S_DDI f18_S_SFS_DDI(struct S_DDI p0, float p1, struct S_DDI p2,  struct S_DDI (*cb)(struct S_DDI, float, struct S_DDI)) ;
+EXPORT struct S_DDF f18_S_SFS_DDF(struct S_DDF p0, float p1, struct S_DDF p2,  struct S_DDF (*cb)(struct S_DDF, float, struct S_DDF)) ;
+EXPORT struct S_DDD f18_S_SFS_DDD(struct S_DDD p0, float p1, struct S_DDD p2,  struct S_DDD (*cb)(struct S_DDD, float, struct S_DDD)) ;
+EXPORT struct S_DDP f18_S_SFS_DDP(struct S_DDP p0, float p1, struct S_DDP p2,  struct S_DDP (*cb)(struct S_DDP, float, struct S_DDP)) ;
+EXPORT struct S_DPI f18_S_SFS_DPI(struct S_DPI p0, float p1, struct S_DPI p2,  struct S_DPI (*cb)(struct S_DPI, float, struct S_DPI)) ;
+EXPORT struct S_DPF f18_S_SFS_DPF(struct S_DPF p0, float p1, struct S_DPF p2,  struct S_DPF (*cb)(struct S_DPF, float, struct S_DPF)) ;
+EXPORT struct S_DPD f18_S_SFS_DPD(struct S_DPD p0, float p1, struct S_DPD p2,  struct S_DPD (*cb)(struct S_DPD, float, struct S_DPD)) ;
+EXPORT struct S_DPP f18_S_SFS_DPP(struct S_DPP p0, float p1, struct S_DPP p2,  struct S_DPP (*cb)(struct S_DPP, float, struct S_DPP)) ;
+EXPORT struct S_PII f18_S_SFS_PII(struct S_PII p0, float p1, struct S_PII p2,  struct S_PII (*cb)(struct S_PII, float, struct S_PII)) ;
+EXPORT struct S_PIF f18_S_SFS_PIF(struct S_PIF p0, float p1, struct S_PIF p2,  struct S_PIF (*cb)(struct S_PIF, float, struct S_PIF)) ;
+EXPORT struct S_PID f18_S_SFS_PID(struct S_PID p0, float p1, struct S_PID p2,  struct S_PID (*cb)(struct S_PID, float, struct S_PID)) ;
+EXPORT struct S_PIP f18_S_SFS_PIP(struct S_PIP p0, float p1, struct S_PIP p2,  struct S_PIP (*cb)(struct S_PIP, float, struct S_PIP)) ;
+EXPORT struct S_PFI f18_S_SFS_PFI(struct S_PFI p0, float p1, struct S_PFI p2,  struct S_PFI (*cb)(struct S_PFI, float, struct S_PFI)) ;
+EXPORT struct S_PFF f18_S_SFS_PFF(struct S_PFF p0, float p1, struct S_PFF p2,  struct S_PFF (*cb)(struct S_PFF, float, struct S_PFF)) ;
+EXPORT struct S_PFD f18_S_SFS_PFD(struct S_PFD p0, float p1, struct S_PFD p2,  struct S_PFD (*cb)(struct S_PFD, float, struct S_PFD)) ;
+EXPORT struct S_PFP f18_S_SFS_PFP(struct S_PFP p0, float p1, struct S_PFP p2,  struct S_PFP (*cb)(struct S_PFP, float, struct S_PFP)) ;
+EXPORT struct S_PDI f18_S_SFS_PDI(struct S_PDI p0, float p1, struct S_PDI p2,  struct S_PDI (*cb)(struct S_PDI, float, struct S_PDI)) ;
+EXPORT struct S_PDF f18_S_SFS_PDF(struct S_PDF p0, float p1, struct S_PDF p2,  struct S_PDF (*cb)(struct S_PDF, float, struct S_PDF)) ;
+EXPORT struct S_PDD f18_S_SFS_PDD(struct S_PDD p0, float p1, struct S_PDD p2,  struct S_PDD (*cb)(struct S_PDD, float, struct S_PDD)) ;
+EXPORT struct S_PDP f18_S_SFS_PDP(struct S_PDP p0, float p1, struct S_PDP p2,  struct S_PDP (*cb)(struct S_PDP, float, struct S_PDP)) ;
+EXPORT struct S_PPI f18_S_SFS_PPI(struct S_PPI p0, float p1, struct S_PPI p2,  struct S_PPI (*cb)(struct S_PPI, float, struct S_PPI)) ;
+EXPORT struct S_PPF f18_S_SFS_PPF(struct S_PPF p0, float p1, struct S_PPF p2,  struct S_PPF (*cb)(struct S_PPF, float, struct S_PPF)) ;
+EXPORT struct S_PPD f18_S_SFS_PPD(struct S_PPD p0, float p1, struct S_PPD p2,  struct S_PPD (*cb)(struct S_PPD, float, struct S_PPD)) ;
+EXPORT struct S_PPP f18_S_SFS_PPP(struct S_PPP p0, float p1, struct S_PPP p2,  struct S_PPP (*cb)(struct S_PPP, float, struct S_PPP)) ;
+EXPORT struct S_I f18_S_SDI_I(struct S_I p0, double p1, int p2,  struct S_I (*cb)(struct S_I, double, int)) ;
+EXPORT struct S_F f18_S_SDI_F(struct S_F p0, double p1, int p2,  struct S_F (*cb)(struct S_F, double, int)) ;
+EXPORT struct S_D f18_S_SDI_D(struct S_D p0, double p1, int p2,  struct S_D (*cb)(struct S_D, double, int)) ;
+EXPORT struct S_P f18_S_SDI_P(struct S_P p0, double p1, int p2,  struct S_P (*cb)(struct S_P, double, int)) ;
+EXPORT struct S_II f18_S_SDI_II(struct S_II p0, double p1, int p2,  struct S_II (*cb)(struct S_II, double, int)) ;
+EXPORT struct S_IF f18_S_SDI_IF(struct S_IF p0, double p1, int p2,  struct S_IF (*cb)(struct S_IF, double, int)) ;
+EXPORT struct S_ID f18_S_SDI_ID(struct S_ID p0, double p1, int p2,  struct S_ID (*cb)(struct S_ID, double, int)) ;
+EXPORT struct S_IP f18_S_SDI_IP(struct S_IP p0, double p1, int p2,  struct S_IP (*cb)(struct S_IP, double, int)) ;
+EXPORT struct S_FI f18_S_SDI_FI(struct S_FI p0, double p1, int p2,  struct S_FI (*cb)(struct S_FI, double, int)) ;
+EXPORT struct S_FF f18_S_SDI_FF(struct S_FF p0, double p1, int p2,  struct S_FF (*cb)(struct S_FF, double, int)) ;
+EXPORT struct S_FD f18_S_SDI_FD(struct S_FD p0, double p1, int p2,  struct S_FD (*cb)(struct S_FD, double, int)) ;
+EXPORT struct S_FP f18_S_SDI_FP(struct S_FP p0, double p1, int p2,  struct S_FP (*cb)(struct S_FP, double, int)) ;
+EXPORT struct S_DI f18_S_SDI_DI(struct S_DI p0, double p1, int p2,  struct S_DI (*cb)(struct S_DI, double, int)) ;
+EXPORT struct S_DF f18_S_SDI_DF(struct S_DF p0, double p1, int p2,  struct S_DF (*cb)(struct S_DF, double, int)) ;
+EXPORT struct S_DD f18_S_SDI_DD(struct S_DD p0, double p1, int p2,  struct S_DD (*cb)(struct S_DD, double, int)) ;
+EXPORT struct S_DP f18_S_SDI_DP(struct S_DP p0, double p1, int p2,  struct S_DP (*cb)(struct S_DP, double, int)) ;
+EXPORT struct S_PI f18_S_SDI_PI(struct S_PI p0, double p1, int p2,  struct S_PI (*cb)(struct S_PI, double, int)) ;
+EXPORT struct S_PF f18_S_SDI_PF(struct S_PF p0, double p1, int p2,  struct S_PF (*cb)(struct S_PF, double, int)) ;
+EXPORT struct S_PD f18_S_SDI_PD(struct S_PD p0, double p1, int p2,  struct S_PD (*cb)(struct S_PD, double, int)) ;
+EXPORT struct S_PP f18_S_SDI_PP(struct S_PP p0, double p1, int p2,  struct S_PP (*cb)(struct S_PP, double, int)) ;
+EXPORT struct S_III f18_S_SDI_III(struct S_III p0, double p1, int p2,  struct S_III (*cb)(struct S_III, double, int)) ;
+EXPORT struct S_IIF f18_S_SDI_IIF(struct S_IIF p0, double p1, int p2,  struct S_IIF (*cb)(struct S_IIF, double, int)) ;
+EXPORT struct S_IID f18_S_SDI_IID(struct S_IID p0, double p1, int p2,  struct S_IID (*cb)(struct S_IID, double, int)) ;
+EXPORT struct S_IIP f18_S_SDI_IIP(struct S_IIP p0, double p1, int p2,  struct S_IIP (*cb)(struct S_IIP, double, int)) ;
+EXPORT struct S_IFI f18_S_SDI_IFI(struct S_IFI p0, double p1, int p2,  struct S_IFI (*cb)(struct S_IFI, double, int)) ;
+EXPORT struct S_IFF f18_S_SDI_IFF(struct S_IFF p0, double p1, int p2,  struct S_IFF (*cb)(struct S_IFF, double, int)) ;
+EXPORT struct S_IFD f18_S_SDI_IFD(struct S_IFD p0, double p1, int p2,  struct S_IFD (*cb)(struct S_IFD, double, int)) ;
+EXPORT struct S_IFP f18_S_SDI_IFP(struct S_IFP p0, double p1, int p2,  struct S_IFP (*cb)(struct S_IFP, double, int)) ;
+EXPORT struct S_IDI f18_S_SDI_IDI(struct S_IDI p0, double p1, int p2,  struct S_IDI (*cb)(struct S_IDI, double, int)) ;
+EXPORT struct S_IDF f18_S_SDI_IDF(struct S_IDF p0, double p1, int p2,  struct S_IDF (*cb)(struct S_IDF, double, int)) ;
+EXPORT struct S_IDD f18_S_SDI_IDD(struct S_IDD p0, double p1, int p2,  struct S_IDD (*cb)(struct S_IDD, double, int)) ;
+EXPORT struct S_IDP f18_S_SDI_IDP(struct S_IDP p0, double p1, int p2,  struct S_IDP (*cb)(struct S_IDP, double, int)) ;
+EXPORT struct S_IPI f18_S_SDI_IPI(struct S_IPI p0, double p1, int p2,  struct S_IPI (*cb)(struct S_IPI, double, int)) ;
+EXPORT struct S_IPF f18_S_SDI_IPF(struct S_IPF p0, double p1, int p2,  struct S_IPF (*cb)(struct S_IPF, double, int)) ;
+EXPORT struct S_IPD f18_S_SDI_IPD(struct S_IPD p0, double p1, int p2,  struct S_IPD (*cb)(struct S_IPD, double, int)) ;
+EXPORT struct S_IPP f18_S_SDI_IPP(struct S_IPP p0, double p1, int p2,  struct S_IPP (*cb)(struct S_IPP, double, int)) ;
+EXPORT struct S_FII f18_S_SDI_FII(struct S_FII p0, double p1, int p2,  struct S_FII (*cb)(struct S_FII, double, int)) ;
+EXPORT struct S_FIF f18_S_SDI_FIF(struct S_FIF p0, double p1, int p2,  struct S_FIF (*cb)(struct S_FIF, double, int)) ;
+EXPORT struct S_FID f18_S_SDI_FID(struct S_FID p0, double p1, int p2,  struct S_FID (*cb)(struct S_FID, double, int)) ;
+EXPORT struct S_FIP f18_S_SDI_FIP(struct S_FIP p0, double p1, int p2,  struct S_FIP (*cb)(struct S_FIP, double, int)) ;
+EXPORT struct S_FFI f18_S_SDI_FFI(struct S_FFI p0, double p1, int p2,  struct S_FFI (*cb)(struct S_FFI, double, int)) ;
+EXPORT struct S_FFF f18_S_SDI_FFF(struct S_FFF p0, double p1, int p2,  struct S_FFF (*cb)(struct S_FFF, double, int)) ;
+EXPORT struct S_FFD f18_S_SDI_FFD(struct S_FFD p0, double p1, int p2,  struct S_FFD (*cb)(struct S_FFD, double, int)) ;
+EXPORT struct S_FFP f18_S_SDI_FFP(struct S_FFP p0, double p1, int p2,  struct S_FFP (*cb)(struct S_FFP, double, int)) ;
+EXPORT struct S_FDI f18_S_SDI_FDI(struct S_FDI p0, double p1, int p2,  struct S_FDI (*cb)(struct S_FDI, double, int)) ;
+EXPORT struct S_FDF f18_S_SDI_FDF(struct S_FDF p0, double p1, int p2,  struct S_FDF (*cb)(struct S_FDF, double, int)) ;
+EXPORT struct S_FDD f18_S_SDI_FDD(struct S_FDD p0, double p1, int p2,  struct S_FDD (*cb)(struct S_FDD, double, int)) ;
+EXPORT struct S_FDP f18_S_SDI_FDP(struct S_FDP p0, double p1, int p2,  struct S_FDP (*cb)(struct S_FDP, double, int)) ;
+EXPORT struct S_FPI f18_S_SDI_FPI(struct S_FPI p0, double p1, int p2,  struct S_FPI (*cb)(struct S_FPI, double, int)) ;
+EXPORT struct S_FPF f18_S_SDI_FPF(struct S_FPF p0, double p1, int p2,  struct S_FPF (*cb)(struct S_FPF, double, int)) ;
+EXPORT struct S_FPD f18_S_SDI_FPD(struct S_FPD p0, double p1, int p2,  struct S_FPD (*cb)(struct S_FPD, double, int)) ;
+EXPORT struct S_FPP f18_S_SDI_FPP(struct S_FPP p0, double p1, int p2,  struct S_FPP (*cb)(struct S_FPP, double, int)) ;
+EXPORT struct S_DII f18_S_SDI_DII(struct S_DII p0, double p1, int p2,  struct S_DII (*cb)(struct S_DII, double, int)) ;
+EXPORT struct S_DIF f18_S_SDI_DIF(struct S_DIF p0, double p1, int p2,  struct S_DIF (*cb)(struct S_DIF, double, int)) ;
+EXPORT struct S_DID f18_S_SDI_DID(struct S_DID p0, double p1, int p2,  struct S_DID (*cb)(struct S_DID, double, int)) ;
+EXPORT struct S_DIP f18_S_SDI_DIP(struct S_DIP p0, double p1, int p2,  struct S_DIP (*cb)(struct S_DIP, double, int)) ;
+EXPORT struct S_DFI f18_S_SDI_DFI(struct S_DFI p0, double p1, int p2,  struct S_DFI (*cb)(struct S_DFI, double, int)) ;
+EXPORT struct S_DFF f18_S_SDI_DFF(struct S_DFF p0, double p1, int p2,  struct S_DFF (*cb)(struct S_DFF, double, int)) ;
+EXPORT struct S_DFD f18_S_SDI_DFD(struct S_DFD p0, double p1, int p2,  struct S_DFD (*cb)(struct S_DFD, double, int)) ;
+EXPORT struct S_DFP f18_S_SDI_DFP(struct S_DFP p0, double p1, int p2,  struct S_DFP (*cb)(struct S_DFP, double, int)) ;
+EXPORT struct S_DDI f18_S_SDI_DDI(struct S_DDI p0, double p1, int p2,  struct S_DDI (*cb)(struct S_DDI, double, int)) ;
+EXPORT struct S_DDF f18_S_SDI_DDF(struct S_DDF p0, double p1, int p2,  struct S_DDF (*cb)(struct S_DDF, double, int)) ;
+EXPORT struct S_DDD f18_S_SDI_DDD(struct S_DDD p0, double p1, int p2,  struct S_DDD (*cb)(struct S_DDD, double, int)) ;
+EXPORT struct S_DDP f18_S_SDI_DDP(struct S_DDP p0, double p1, int p2,  struct S_DDP (*cb)(struct S_DDP, double, int)) ;
+EXPORT struct S_DPI f18_S_SDI_DPI(struct S_DPI p0, double p1, int p2,  struct S_DPI (*cb)(struct S_DPI, double, int)) ;
+EXPORT struct S_DPF f18_S_SDI_DPF(struct S_DPF p0, double p1, int p2,  struct S_DPF (*cb)(struct S_DPF, double, int)) ;
+EXPORT struct S_DPD f18_S_SDI_DPD(struct S_DPD p0, double p1, int p2,  struct S_DPD (*cb)(struct S_DPD, double, int)) ;
+EXPORT struct S_DPP f18_S_SDI_DPP(struct S_DPP p0, double p1, int p2,  struct S_DPP (*cb)(struct S_DPP, double, int)) ;
+EXPORT struct S_PII f18_S_SDI_PII(struct S_PII p0, double p1, int p2,  struct S_PII (*cb)(struct S_PII, double, int)) ;
+EXPORT struct S_PIF f18_S_SDI_PIF(struct S_PIF p0, double p1, int p2,  struct S_PIF (*cb)(struct S_PIF, double, int)) ;
+EXPORT struct S_PID f18_S_SDI_PID(struct S_PID p0, double p1, int p2,  struct S_PID (*cb)(struct S_PID, double, int)) ;
+EXPORT struct S_PIP f18_S_SDI_PIP(struct S_PIP p0, double p1, int p2,  struct S_PIP (*cb)(struct S_PIP, double, int)) ;
+EXPORT struct S_PFI f18_S_SDI_PFI(struct S_PFI p0, double p1, int p2,  struct S_PFI (*cb)(struct S_PFI, double, int)) ;
+EXPORT struct S_PFF f18_S_SDI_PFF(struct S_PFF p0, double p1, int p2,  struct S_PFF (*cb)(struct S_PFF, double, int)) ;
+EXPORT struct S_PFD f18_S_SDI_PFD(struct S_PFD p0, double p1, int p2,  struct S_PFD (*cb)(struct S_PFD, double, int)) ;
+EXPORT struct S_PFP f18_S_SDI_PFP(struct S_PFP p0, double p1, int p2,  struct S_PFP (*cb)(struct S_PFP, double, int)) ;
+EXPORT struct S_PDI f18_S_SDI_PDI(struct S_PDI p0, double p1, int p2,  struct S_PDI (*cb)(struct S_PDI, double, int)) ;
+EXPORT struct S_PDF f18_S_SDI_PDF(struct S_PDF p0, double p1, int p2,  struct S_PDF (*cb)(struct S_PDF, double, int)) ;
+EXPORT struct S_PDD f18_S_SDI_PDD(struct S_PDD p0, double p1, int p2,  struct S_PDD (*cb)(struct S_PDD, double, int)) ;
+EXPORT struct S_PDP f18_S_SDI_PDP(struct S_PDP p0, double p1, int p2,  struct S_PDP (*cb)(struct S_PDP, double, int)) ;
+EXPORT struct S_PPI f18_S_SDI_PPI(struct S_PPI p0, double p1, int p2,  struct S_PPI (*cb)(struct S_PPI, double, int)) ;
+EXPORT struct S_PPF f18_S_SDI_PPF(struct S_PPF p0, double p1, int p2,  struct S_PPF (*cb)(struct S_PPF, double, int)) ;
+EXPORT struct S_PPD f18_S_SDI_PPD(struct S_PPD p0, double p1, int p2,  struct S_PPD (*cb)(struct S_PPD, double, int)) ;
+EXPORT struct S_PPP f18_S_SDI_PPP(struct S_PPP p0, double p1, int p2,  struct S_PPP (*cb)(struct S_PPP, double, int)) ;
+EXPORT struct S_I f18_S_SDF_I(struct S_I p0, double p1, float p2,  struct S_I (*cb)(struct S_I, double, float)) ;
+EXPORT struct S_F f18_S_SDF_F(struct S_F p0, double p1, float p2,  struct S_F (*cb)(struct S_F, double, float)) ;
+EXPORT struct S_D f18_S_SDF_D(struct S_D p0, double p1, float p2,  struct S_D (*cb)(struct S_D, double, float)) ;
+EXPORT struct S_P f18_S_SDF_P(struct S_P p0, double p1, float p2,  struct S_P (*cb)(struct S_P, double, float)) ;
+EXPORT struct S_II f18_S_SDF_II(struct S_II p0, double p1, float p2,  struct S_II (*cb)(struct S_II, double, float)) ;
+EXPORT struct S_IF f18_S_SDF_IF(struct S_IF p0, double p1, float p2,  struct S_IF (*cb)(struct S_IF, double, float)) ;
+EXPORT struct S_ID f18_S_SDF_ID(struct S_ID p0, double p1, float p2,  struct S_ID (*cb)(struct S_ID, double, float)) ;
+EXPORT struct S_IP f18_S_SDF_IP(struct S_IP p0, double p1, float p2,  struct S_IP (*cb)(struct S_IP, double, float)) ;
+EXPORT struct S_FI f18_S_SDF_FI(struct S_FI p0, double p1, float p2,  struct S_FI (*cb)(struct S_FI, double, float)) ;
+EXPORT struct S_FF f18_S_SDF_FF(struct S_FF p0, double p1, float p2,  struct S_FF (*cb)(struct S_FF, double, float)) ;
+EXPORT struct S_FD f18_S_SDF_FD(struct S_FD p0, double p1, float p2,  struct S_FD (*cb)(struct S_FD, double, float)) ;
+EXPORT struct S_FP f18_S_SDF_FP(struct S_FP p0, double p1, float p2,  struct S_FP (*cb)(struct S_FP, double, float)) ;
+EXPORT struct S_DI f18_S_SDF_DI(struct S_DI p0, double p1, float p2,  struct S_DI (*cb)(struct S_DI, double, float)) ;
+EXPORT struct S_DF f18_S_SDF_DF(struct S_DF p0, double p1, float p2,  struct S_DF (*cb)(struct S_DF, double, float)) ;
+EXPORT struct S_DD f18_S_SDF_DD(struct S_DD p0, double p1, float p2,  struct S_DD (*cb)(struct S_DD, double, float)) ;
+EXPORT struct S_DP f18_S_SDF_DP(struct S_DP p0, double p1, float p2,  struct S_DP (*cb)(struct S_DP, double, float)) ;
+EXPORT struct S_PI f18_S_SDF_PI(struct S_PI p0, double p1, float p2,  struct S_PI (*cb)(struct S_PI, double, float)) ;
+EXPORT struct S_PF f18_S_SDF_PF(struct S_PF p0, double p1, float p2,  struct S_PF (*cb)(struct S_PF, double, float)) ;
+EXPORT struct S_PD f18_S_SDF_PD(struct S_PD p0, double p1, float p2,  struct S_PD (*cb)(struct S_PD, double, float)) ;
+EXPORT struct S_PP f18_S_SDF_PP(struct S_PP p0, double p1, float p2,  struct S_PP (*cb)(struct S_PP, double, float)) ;
+EXPORT struct S_III f18_S_SDF_III(struct S_III p0, double p1, float p2,  struct S_III (*cb)(struct S_III, double, float)) ;
+EXPORT struct S_IIF f18_S_SDF_IIF(struct S_IIF p0, double p1, float p2,  struct S_IIF (*cb)(struct S_IIF, double, float)) ;
+EXPORT struct S_IID f18_S_SDF_IID(struct S_IID p0, double p1, float p2,  struct S_IID (*cb)(struct S_IID, double, float)) ;
+EXPORT struct S_IIP f18_S_SDF_IIP(struct S_IIP p0, double p1, float p2,  struct S_IIP (*cb)(struct S_IIP, double, float)) ;
+EXPORT struct S_IFI f18_S_SDF_IFI(struct S_IFI p0, double p1, float p2,  struct S_IFI (*cb)(struct S_IFI, double, float)) ;
+EXPORT struct S_IFF f18_S_SDF_IFF(struct S_IFF p0, double p1, float p2,  struct S_IFF (*cb)(struct S_IFF, double, float)) ;
+EXPORT struct S_IFD f18_S_SDF_IFD(struct S_IFD p0, double p1, float p2,  struct S_IFD (*cb)(struct S_IFD, double, float)) ;
+EXPORT struct S_IFP f18_S_SDF_IFP(struct S_IFP p0, double p1, float p2,  struct S_IFP (*cb)(struct S_IFP, double, float)) ;
+EXPORT struct S_IDI f18_S_SDF_IDI(struct S_IDI p0, double p1, float p2,  struct S_IDI (*cb)(struct S_IDI, double, float)) ;
+EXPORT struct S_IDF f18_S_SDF_IDF(struct S_IDF p0, double p1, float p2,  struct S_IDF (*cb)(struct S_IDF, double, float)) ;
+EXPORT struct S_IDD f18_S_SDF_IDD(struct S_IDD p0, double p1, float p2,  struct S_IDD (*cb)(struct S_IDD, double, float)) ;
+EXPORT struct S_IDP f18_S_SDF_IDP(struct S_IDP p0, double p1, float p2,  struct S_IDP (*cb)(struct S_IDP, double, float)) ;
+EXPORT struct S_IPI f18_S_SDF_IPI(struct S_IPI p0, double p1, float p2,  struct S_IPI (*cb)(struct S_IPI, double, float)) ;
+EXPORT struct S_IPF f18_S_SDF_IPF(struct S_IPF p0, double p1, float p2,  struct S_IPF (*cb)(struct S_IPF, double, float)) ;
+EXPORT struct S_IPD f18_S_SDF_IPD(struct S_IPD p0, double p1, float p2,  struct S_IPD (*cb)(struct S_IPD, double, float)) ;
+EXPORT struct S_IPP f18_S_SDF_IPP(struct S_IPP p0, double p1, float p2,  struct S_IPP (*cb)(struct S_IPP, double, float)) ;
+EXPORT struct S_FII f18_S_SDF_FII(struct S_FII p0, double p1, float p2,  struct S_FII (*cb)(struct S_FII, double, float)) ;
+EXPORT struct S_FIF f18_S_SDF_FIF(struct S_FIF p0, double p1, float p2,  struct S_FIF (*cb)(struct S_FIF, double, float)) ;
+EXPORT struct S_FID f18_S_SDF_FID(struct S_FID p0, double p1, float p2,  struct S_FID (*cb)(struct S_FID, double, float)) ;
+EXPORT struct S_FIP f18_S_SDF_FIP(struct S_FIP p0, double p1, float p2,  struct S_FIP (*cb)(struct S_FIP, double, float)) ;
+EXPORT struct S_FFI f18_S_SDF_FFI(struct S_FFI p0, double p1, float p2,  struct S_FFI (*cb)(struct S_FFI, double, float)) ;
+EXPORT struct S_FFF f18_S_SDF_FFF(struct S_FFF p0, double p1, float p2,  struct S_FFF (*cb)(struct S_FFF, double, float)) ;
+EXPORT struct S_FFD f18_S_SDF_FFD(struct S_FFD p0, double p1, float p2,  struct S_FFD (*cb)(struct S_FFD, double, float)) ;
+EXPORT struct S_FFP f18_S_SDF_FFP(struct S_FFP p0, double p1, float p2,  struct S_FFP (*cb)(struct S_FFP, double, float)) ;
+EXPORT struct S_FDI f18_S_SDF_FDI(struct S_FDI p0, double p1, float p2,  struct S_FDI (*cb)(struct S_FDI, double, float)) ;
+EXPORT struct S_FDF f18_S_SDF_FDF(struct S_FDF p0, double p1, float p2,  struct S_FDF (*cb)(struct S_FDF, double, float)) ;
+EXPORT struct S_FDD f18_S_SDF_FDD(struct S_FDD p0, double p1, float p2,  struct S_FDD (*cb)(struct S_FDD, double, float)) ;
+EXPORT struct S_FDP f18_S_SDF_FDP(struct S_FDP p0, double p1, float p2,  struct S_FDP (*cb)(struct S_FDP, double, float)) ;
+EXPORT struct S_FPI f18_S_SDF_FPI(struct S_FPI p0, double p1, float p2,  struct S_FPI (*cb)(struct S_FPI, double, float)) ;
+EXPORT struct S_FPF f18_S_SDF_FPF(struct S_FPF p0, double p1, float p2,  struct S_FPF (*cb)(struct S_FPF, double, float)) ;
+EXPORT struct S_FPD f18_S_SDF_FPD(struct S_FPD p0, double p1, float p2,  struct S_FPD (*cb)(struct S_FPD, double, float)) ;
+EXPORT struct S_FPP f18_S_SDF_FPP(struct S_FPP p0, double p1, float p2,  struct S_FPP (*cb)(struct S_FPP, double, float)) ;
+EXPORT struct S_DII f18_S_SDF_DII(struct S_DII p0, double p1, float p2,  struct S_DII (*cb)(struct S_DII, double, float)) ;
+EXPORT struct S_DIF f18_S_SDF_DIF(struct S_DIF p0, double p1, float p2,  struct S_DIF (*cb)(struct S_DIF, double, float)) ;
+EXPORT struct S_DID f18_S_SDF_DID(struct S_DID p0, double p1, float p2,  struct S_DID (*cb)(struct S_DID, double, float)) ;
+EXPORT struct S_DIP f18_S_SDF_DIP(struct S_DIP p0, double p1, float p2,  struct S_DIP (*cb)(struct S_DIP, double, float)) ;
+EXPORT struct S_DFI f18_S_SDF_DFI(struct S_DFI p0, double p1, float p2,  struct S_DFI (*cb)(struct S_DFI, double, float)) ;
+EXPORT struct S_DFF f18_S_SDF_DFF(struct S_DFF p0, double p1, float p2,  struct S_DFF (*cb)(struct S_DFF, double, float)) ;
+EXPORT struct S_DFD f18_S_SDF_DFD(struct S_DFD p0, double p1, float p2,  struct S_DFD (*cb)(struct S_DFD, double, float)) ;
+EXPORT struct S_DFP f18_S_SDF_DFP(struct S_DFP p0, double p1, float p2,  struct S_DFP (*cb)(struct S_DFP, double, float)) ;
+EXPORT struct S_DDI f18_S_SDF_DDI(struct S_DDI p0, double p1, float p2,  struct S_DDI (*cb)(struct S_DDI, double, float)) ;
+EXPORT struct S_DDF f18_S_SDF_DDF(struct S_DDF p0, double p1, float p2,  struct S_DDF (*cb)(struct S_DDF, double, float)) ;
+EXPORT struct S_DDD f18_S_SDF_DDD(struct S_DDD p0, double p1, float p2,  struct S_DDD (*cb)(struct S_DDD, double, float)) ;
+EXPORT struct S_DDP f18_S_SDF_DDP(struct S_DDP p0, double p1, float p2,  struct S_DDP (*cb)(struct S_DDP, double, float)) ;
+EXPORT struct S_DPI f18_S_SDF_DPI(struct S_DPI p0, double p1, float p2,  struct S_DPI (*cb)(struct S_DPI, double, float)) ;
+EXPORT struct S_DPF f18_S_SDF_DPF(struct S_DPF p0, double p1, float p2,  struct S_DPF (*cb)(struct S_DPF, double, float)) ;
+EXPORT struct S_DPD f18_S_SDF_DPD(struct S_DPD p0, double p1, float p2,  struct S_DPD (*cb)(struct S_DPD, double, float)) ;
+EXPORT struct S_DPP f18_S_SDF_DPP(struct S_DPP p0, double p1, float p2,  struct S_DPP (*cb)(struct S_DPP, double, float)) ;
+EXPORT struct S_PII f18_S_SDF_PII(struct S_PII p0, double p1, float p2,  struct S_PII (*cb)(struct S_PII, double, float)) ;
+EXPORT struct S_PIF f18_S_SDF_PIF(struct S_PIF p0, double p1, float p2,  struct S_PIF (*cb)(struct S_PIF, double, float)) ;
+EXPORT struct S_PID f18_S_SDF_PID(struct S_PID p0, double p1, float p2,  struct S_PID (*cb)(struct S_PID, double, float)) ;
+EXPORT struct S_PIP f18_S_SDF_PIP(struct S_PIP p0, double p1, float p2,  struct S_PIP (*cb)(struct S_PIP, double, float)) ;
+EXPORT struct S_PFI f18_S_SDF_PFI(struct S_PFI p0, double p1, float p2,  struct S_PFI (*cb)(struct S_PFI, double, float)) ;
+EXPORT struct S_PFF f18_S_SDF_PFF(struct S_PFF p0, double p1, float p2,  struct S_PFF (*cb)(struct S_PFF, double, float)) ;
+EXPORT struct S_PFD f18_S_SDF_PFD(struct S_PFD p0, double p1, float p2,  struct S_PFD (*cb)(struct S_PFD, double, float)) ;
+EXPORT struct S_PFP f18_S_SDF_PFP(struct S_PFP p0, double p1, float p2,  struct S_PFP (*cb)(struct S_PFP, double, float)) ;
+EXPORT struct S_PDI f18_S_SDF_PDI(struct S_PDI p0, double p1, float p2,  struct S_PDI (*cb)(struct S_PDI, double, float)) ;
+EXPORT struct S_PDF f18_S_SDF_PDF(struct S_PDF p0, double p1, float p2,  struct S_PDF (*cb)(struct S_PDF, double, float)) ;
+EXPORT struct S_PDD f18_S_SDF_PDD(struct S_PDD p0, double p1, float p2,  struct S_PDD (*cb)(struct S_PDD, double, float)) ;
+EXPORT struct S_PDP f18_S_SDF_PDP(struct S_PDP p0, double p1, float p2,  struct S_PDP (*cb)(struct S_PDP, double, float)) ;
+EXPORT struct S_PPI f18_S_SDF_PPI(struct S_PPI p0, double p1, float p2,  struct S_PPI (*cb)(struct S_PPI, double, float)) ;
+EXPORT struct S_PPF f18_S_SDF_PPF(struct S_PPF p0, double p1, float p2,  struct S_PPF (*cb)(struct S_PPF, double, float)) ;
+EXPORT struct S_PPD f18_S_SDF_PPD(struct S_PPD p0, double p1, float p2,  struct S_PPD (*cb)(struct S_PPD, double, float)) ;
+EXPORT struct S_PPP f18_S_SDF_PPP(struct S_PPP p0, double p1, float p2,  struct S_PPP (*cb)(struct S_PPP, double, float)) ;
+EXPORT struct S_I f18_S_SDD_I(struct S_I p0, double p1, double p2,  struct S_I (*cb)(struct S_I, double, double)) ;
+EXPORT struct S_F f18_S_SDD_F(struct S_F p0, double p1, double p2,  struct S_F (*cb)(struct S_F, double, double)) ;
+EXPORT struct S_D f18_S_SDD_D(struct S_D p0, double p1, double p2,  struct S_D (*cb)(struct S_D, double, double)) ;
+EXPORT struct S_P f18_S_SDD_P(struct S_P p0, double p1, double p2,  struct S_P (*cb)(struct S_P, double, double)) ;
+EXPORT struct S_II f18_S_SDD_II(struct S_II p0, double p1, double p2,  struct S_II (*cb)(struct S_II, double, double)) ;
+EXPORT struct S_IF f18_S_SDD_IF(struct S_IF p0, double p1, double p2,  struct S_IF (*cb)(struct S_IF, double, double)) ;
+EXPORT struct S_ID f18_S_SDD_ID(struct S_ID p0, double p1, double p2,  struct S_ID (*cb)(struct S_ID, double, double)) ;
+EXPORT struct S_IP f18_S_SDD_IP(struct S_IP p0, double p1, double p2,  struct S_IP (*cb)(struct S_IP, double, double)) ;
+EXPORT struct S_FI f18_S_SDD_FI(struct S_FI p0, double p1, double p2,  struct S_FI (*cb)(struct S_FI, double, double)) ;
+EXPORT struct S_FF f18_S_SDD_FF(struct S_FF p0, double p1, double p2,  struct S_FF (*cb)(struct S_FF, double, double)) ;
+EXPORT struct S_FD f18_S_SDD_FD(struct S_FD p0, double p1, double p2,  struct S_FD (*cb)(struct S_FD, double, double)) ;
+EXPORT struct S_FP f18_S_SDD_FP(struct S_FP p0, double p1, double p2,  struct S_FP (*cb)(struct S_FP, double, double)) ;
+EXPORT struct S_DI f18_S_SDD_DI(struct S_DI p0, double p1, double p2,  struct S_DI (*cb)(struct S_DI, double, double)) ;
+EXPORT struct S_DF f18_S_SDD_DF(struct S_DF p0, double p1, double p2,  struct S_DF (*cb)(struct S_DF, double, double)) ;
+EXPORT struct S_DD f18_S_SDD_DD(struct S_DD p0, double p1, double p2,  struct S_DD (*cb)(struct S_DD, double, double)) ;
+EXPORT struct S_DP f18_S_SDD_DP(struct S_DP p0, double p1, double p2,  struct S_DP (*cb)(struct S_DP, double, double)) ;
+EXPORT struct S_PI f18_S_SDD_PI(struct S_PI p0, double p1, double p2,  struct S_PI (*cb)(struct S_PI, double, double)) ;
+EXPORT struct S_PF f18_S_SDD_PF(struct S_PF p0, double p1, double p2,  struct S_PF (*cb)(struct S_PF, double, double)) ;
+EXPORT struct S_PD f18_S_SDD_PD(struct S_PD p0, double p1, double p2,  struct S_PD (*cb)(struct S_PD, double, double)) ;
+EXPORT struct S_PP f18_S_SDD_PP(struct S_PP p0, double p1, double p2,  struct S_PP (*cb)(struct S_PP, double, double)) ;
+EXPORT struct S_III f18_S_SDD_III(struct S_III p0, double p1, double p2,  struct S_III (*cb)(struct S_III, double, double)) ;
+EXPORT struct S_IIF f18_S_SDD_IIF(struct S_IIF p0, double p1, double p2,  struct S_IIF (*cb)(struct S_IIF, double, double)) ;
+EXPORT struct S_IID f18_S_SDD_IID(struct S_IID p0, double p1, double p2,  struct S_IID (*cb)(struct S_IID, double, double)) ;
+EXPORT struct S_IIP f18_S_SDD_IIP(struct S_IIP p0, double p1, double p2,  struct S_IIP (*cb)(struct S_IIP, double, double)) ;
+EXPORT struct S_IFI f18_S_SDD_IFI(struct S_IFI p0, double p1, double p2,  struct S_IFI (*cb)(struct S_IFI, double, double)) ;
+EXPORT struct S_IFF f18_S_SDD_IFF(struct S_IFF p0, double p1, double p2,  struct S_IFF (*cb)(struct S_IFF, double, double)) ;
+EXPORT struct S_IFD f18_S_SDD_IFD(struct S_IFD p0, double p1, double p2,  struct S_IFD (*cb)(struct S_IFD, double, double)) ;
+EXPORT struct S_IFP f18_S_SDD_IFP(struct S_IFP p0, double p1, double p2,  struct S_IFP (*cb)(struct S_IFP, double, double)) ;
+EXPORT struct S_IDI f18_S_SDD_IDI(struct S_IDI p0, double p1, double p2,  struct S_IDI (*cb)(struct S_IDI, double, double)) ;
+EXPORT struct S_IDF f18_S_SDD_IDF(struct S_IDF p0, double p1, double p2,  struct S_IDF (*cb)(struct S_IDF, double, double)) ;
+EXPORT struct S_IDD f18_S_SDD_IDD(struct S_IDD p0, double p1, double p2,  struct S_IDD (*cb)(struct S_IDD, double, double)) ;
+EXPORT struct S_IDP f18_S_SDD_IDP(struct S_IDP p0, double p1, double p2,  struct S_IDP (*cb)(struct S_IDP, double, double)) ;
+EXPORT struct S_IPI f18_S_SDD_IPI(struct S_IPI p0, double p1, double p2,  struct S_IPI (*cb)(struct S_IPI, double, double)) ;
+EXPORT struct S_IPF f18_S_SDD_IPF(struct S_IPF p0, double p1, double p2,  struct S_IPF (*cb)(struct S_IPF, double, double)) ;
+EXPORT struct S_IPD f18_S_SDD_IPD(struct S_IPD p0, double p1, double p2,  struct S_IPD (*cb)(struct S_IPD, double, double)) ;
+EXPORT struct S_IPP f18_S_SDD_IPP(struct S_IPP p0, double p1, double p2,  struct S_IPP (*cb)(struct S_IPP, double, double)) ;
+EXPORT struct S_FII f18_S_SDD_FII(struct S_FII p0, double p1, double p2,  struct S_FII (*cb)(struct S_FII, double, double)) ;
+EXPORT struct S_FIF f18_S_SDD_FIF(struct S_FIF p0, double p1, double p2,  struct S_FIF (*cb)(struct S_FIF, double, double)) ;
+EXPORT struct S_FID f18_S_SDD_FID(struct S_FID p0, double p1, double p2,  struct S_FID (*cb)(struct S_FID, double, double)) ;
+EXPORT struct S_FIP f18_S_SDD_FIP(struct S_FIP p0, double p1, double p2,  struct S_FIP (*cb)(struct S_FIP, double, double)) ;
+EXPORT struct S_FFI f18_S_SDD_FFI(struct S_FFI p0, double p1, double p2,  struct S_FFI (*cb)(struct S_FFI, double, double)) ;
+EXPORT struct S_FFF f18_S_SDD_FFF(struct S_FFF p0, double p1, double p2,  struct S_FFF (*cb)(struct S_FFF, double, double)) ;
+EXPORT struct S_FFD f18_S_SDD_FFD(struct S_FFD p0, double p1, double p2,  struct S_FFD (*cb)(struct S_FFD, double, double)) ;
+EXPORT struct S_FFP f18_S_SDD_FFP(struct S_FFP p0, double p1, double p2,  struct S_FFP (*cb)(struct S_FFP, double, double)) ;
+EXPORT struct S_FDI f18_S_SDD_FDI(struct S_FDI p0, double p1, double p2,  struct S_FDI (*cb)(struct S_FDI, double, double)) ;
+EXPORT struct S_FDF f18_S_SDD_FDF(struct S_FDF p0, double p1, double p2,  struct S_FDF (*cb)(struct S_FDF, double, double)) ;
+EXPORT struct S_FDD f18_S_SDD_FDD(struct S_FDD p0, double p1, double p2,  struct S_FDD (*cb)(struct S_FDD, double, double)) ;
+EXPORT struct S_FDP f18_S_SDD_FDP(struct S_FDP p0, double p1, double p2,  struct S_FDP (*cb)(struct S_FDP, double, double)) ;
+EXPORT struct S_FPI f18_S_SDD_FPI(struct S_FPI p0, double p1, double p2,  struct S_FPI (*cb)(struct S_FPI, double, double)) ;
+EXPORT struct S_FPF f18_S_SDD_FPF(struct S_FPF p0, double p1, double p2,  struct S_FPF (*cb)(struct S_FPF, double, double)) ;
+EXPORT struct S_FPD f18_S_SDD_FPD(struct S_FPD p0, double p1, double p2,  struct S_FPD (*cb)(struct S_FPD, double, double)) ;
+EXPORT struct S_FPP f18_S_SDD_FPP(struct S_FPP p0, double p1, double p2,  struct S_FPP (*cb)(struct S_FPP, double, double)) ;
+EXPORT struct S_DII f18_S_SDD_DII(struct S_DII p0, double p1, double p2,  struct S_DII (*cb)(struct S_DII, double, double)) ;
+EXPORT struct S_DIF f18_S_SDD_DIF(struct S_DIF p0, double p1, double p2,  struct S_DIF (*cb)(struct S_DIF, double, double)) ;
+EXPORT struct S_DID f18_S_SDD_DID(struct S_DID p0, double p1, double p2,  struct S_DID (*cb)(struct S_DID, double, double)) ;
+EXPORT struct S_DIP f18_S_SDD_DIP(struct S_DIP p0, double p1, double p2,  struct S_DIP (*cb)(struct S_DIP, double, double)) ;
+EXPORT struct S_DFI f18_S_SDD_DFI(struct S_DFI p0, double p1, double p2,  struct S_DFI (*cb)(struct S_DFI, double, double)) ;
+EXPORT struct S_DFF f18_S_SDD_DFF(struct S_DFF p0, double p1, double p2,  struct S_DFF (*cb)(struct S_DFF, double, double)) ;
+EXPORT struct S_DFD f18_S_SDD_DFD(struct S_DFD p0, double p1, double p2,  struct S_DFD (*cb)(struct S_DFD, double, double)) ;
+EXPORT struct S_DFP f18_S_SDD_DFP(struct S_DFP p0, double p1, double p2,  struct S_DFP (*cb)(struct S_DFP, double, double)) ;
+EXPORT struct S_DDI f18_S_SDD_DDI(struct S_DDI p0, double p1, double p2,  struct S_DDI (*cb)(struct S_DDI, double, double)) ;
+EXPORT struct S_DDF f18_S_SDD_DDF(struct S_DDF p0, double p1, double p2,  struct S_DDF (*cb)(struct S_DDF, double, double)) ;
+EXPORT struct S_DDD f18_S_SDD_DDD(struct S_DDD p0, double p1, double p2,  struct S_DDD (*cb)(struct S_DDD, double, double)) ;
+EXPORT struct S_DDP f18_S_SDD_DDP(struct S_DDP p0, double p1, double p2,  struct S_DDP (*cb)(struct S_DDP, double, double)) ;
+EXPORT struct S_DPI f18_S_SDD_DPI(struct S_DPI p0, double p1, double p2,  struct S_DPI (*cb)(struct S_DPI, double, double)) ;
+EXPORT struct S_DPF f18_S_SDD_DPF(struct S_DPF p0, double p1, double p2,  struct S_DPF (*cb)(struct S_DPF, double, double)) ;
+EXPORT struct S_DPD f18_S_SDD_DPD(struct S_DPD p0, double p1, double p2,  struct S_DPD (*cb)(struct S_DPD, double, double)) ;
+EXPORT struct S_DPP f18_S_SDD_DPP(struct S_DPP p0, double p1, double p2,  struct S_DPP (*cb)(struct S_DPP, double, double)) ;
+EXPORT struct S_PII f18_S_SDD_PII(struct S_PII p0, double p1, double p2,  struct S_PII (*cb)(struct S_PII, double, double)) ;
+EXPORT struct S_PIF f18_S_SDD_PIF(struct S_PIF p0, double p1, double p2,  struct S_PIF (*cb)(struct S_PIF, double, double)) ;
+EXPORT struct S_PID f18_S_SDD_PID(struct S_PID p0, double p1, double p2,  struct S_PID (*cb)(struct S_PID, double, double)) ;
+EXPORT struct S_PIP f18_S_SDD_PIP(struct S_PIP p0, double p1, double p2,  struct S_PIP (*cb)(struct S_PIP, double, double)) ;
+EXPORT struct S_PFI f18_S_SDD_PFI(struct S_PFI p0, double p1, double p2,  struct S_PFI (*cb)(struct S_PFI, double, double)) ;
+EXPORT struct S_PFF f18_S_SDD_PFF(struct S_PFF p0, double p1, double p2,  struct S_PFF (*cb)(struct S_PFF, double, double)) ;
+EXPORT struct S_PFD f18_S_SDD_PFD(struct S_PFD p0, double p1, double p2,  struct S_PFD (*cb)(struct S_PFD, double, double)) ;
+EXPORT struct S_PFP f18_S_SDD_PFP(struct S_PFP p0, double p1, double p2,  struct S_PFP (*cb)(struct S_PFP, double, double)) ;
+EXPORT struct S_PDI f18_S_SDD_PDI(struct S_PDI p0, double p1, double p2,  struct S_PDI (*cb)(struct S_PDI, double, double)) ;
+EXPORT struct S_PDF f18_S_SDD_PDF(struct S_PDF p0, double p1, double p2,  struct S_PDF (*cb)(struct S_PDF, double, double)) ;
+EXPORT struct S_PDD f18_S_SDD_PDD(struct S_PDD p0, double p1, double p2,  struct S_PDD (*cb)(struct S_PDD, double, double)) ;
+EXPORT struct S_PDP f18_S_SDD_PDP(struct S_PDP p0, double p1, double p2,  struct S_PDP (*cb)(struct S_PDP, double, double)) ;
+EXPORT struct S_PPI f18_S_SDD_PPI(struct S_PPI p0, double p1, double p2,  struct S_PPI (*cb)(struct S_PPI, double, double)) ;
+EXPORT struct S_PPF f18_S_SDD_PPF(struct S_PPF p0, double p1, double p2,  struct S_PPF (*cb)(struct S_PPF, double, double)) ;
+EXPORT struct S_PPD f18_S_SDD_PPD(struct S_PPD p0, double p1, double p2,  struct S_PPD (*cb)(struct S_PPD, double, double)) ;
+EXPORT struct S_PPP f18_S_SDD_PPP(struct S_PPP p0, double p1, double p2,  struct S_PPP (*cb)(struct S_PPP, double, double)) ;
+EXPORT struct S_I f18_S_SDP_I(struct S_I p0, double p1, void* p2,  struct S_I (*cb)(struct S_I, double, void*)) ;
+EXPORT struct S_F f18_S_SDP_F(struct S_F p0, double p1, void* p2,  struct S_F (*cb)(struct S_F, double, void*)) ;
+EXPORT struct S_D f18_S_SDP_D(struct S_D p0, double p1, void* p2,  struct S_D (*cb)(struct S_D, double, void*)) ;
+EXPORT struct S_P f18_S_SDP_P(struct S_P p0, double p1, void* p2,  struct S_P (*cb)(struct S_P, double, void*)) ;
+EXPORT struct S_II f18_S_SDP_II(struct S_II p0, double p1, void* p2,  struct S_II (*cb)(struct S_II, double, void*)) ;
+EXPORT struct S_IF f18_S_SDP_IF(struct S_IF p0, double p1, void* p2,  struct S_IF (*cb)(struct S_IF, double, void*)) ;
+EXPORT struct S_ID f18_S_SDP_ID(struct S_ID p0, double p1, void* p2,  struct S_ID (*cb)(struct S_ID, double, void*)) ;
+EXPORT struct S_IP f18_S_SDP_IP(struct S_IP p0, double p1, void* p2,  struct S_IP (*cb)(struct S_IP, double, void*)) ;
+EXPORT struct S_FI f18_S_SDP_FI(struct S_FI p0, double p1, void* p2,  struct S_FI (*cb)(struct S_FI, double, void*)) ;
+EXPORT struct S_FF f18_S_SDP_FF(struct S_FF p0, double p1, void* p2,  struct S_FF (*cb)(struct S_FF, double, void*)) ;
+EXPORT struct S_FD f18_S_SDP_FD(struct S_FD p0, double p1, void* p2,  struct S_FD (*cb)(struct S_FD, double, void*)) ;
+EXPORT struct S_FP f18_S_SDP_FP(struct S_FP p0, double p1, void* p2,  struct S_FP (*cb)(struct S_FP, double, void*)) ;
+EXPORT struct S_DI f18_S_SDP_DI(struct S_DI p0, double p1, void* p2,  struct S_DI (*cb)(struct S_DI, double, void*)) ;
+EXPORT struct S_DF f18_S_SDP_DF(struct S_DF p0, double p1, void* p2,  struct S_DF (*cb)(struct S_DF, double, void*)) ;
+EXPORT struct S_DD f18_S_SDP_DD(struct S_DD p0, double p1, void* p2,  struct S_DD (*cb)(struct S_DD, double, void*)) ;
+EXPORT struct S_DP f18_S_SDP_DP(struct S_DP p0, double p1, void* p2,  struct S_DP (*cb)(struct S_DP, double, void*)) ;
+EXPORT struct S_PI f18_S_SDP_PI(struct S_PI p0, double p1, void* p2,  struct S_PI (*cb)(struct S_PI, double, void*)) ;
+EXPORT struct S_PF f18_S_SDP_PF(struct S_PF p0, double p1, void* p2,  struct S_PF (*cb)(struct S_PF, double, void*)) ;
+EXPORT struct S_PD f18_S_SDP_PD(struct S_PD p0, double p1, void* p2,  struct S_PD (*cb)(struct S_PD, double, void*)) ;
+EXPORT struct S_PP f18_S_SDP_PP(struct S_PP p0, double p1, void* p2,  struct S_PP (*cb)(struct S_PP, double, void*)) ;
+EXPORT struct S_III f18_S_SDP_III(struct S_III p0, double p1, void* p2,  struct S_III (*cb)(struct S_III, double, void*)) ;
+EXPORT struct S_IIF f18_S_SDP_IIF(struct S_IIF p0, double p1, void* p2,  struct S_IIF (*cb)(struct S_IIF, double, void*)) ;
+EXPORT struct S_IID f18_S_SDP_IID(struct S_IID p0, double p1, void* p2,  struct S_IID (*cb)(struct S_IID, double, void*)) ;
+EXPORT struct S_IIP f18_S_SDP_IIP(struct S_IIP p0, double p1, void* p2,  struct S_IIP (*cb)(struct S_IIP, double, void*)) ;
+EXPORT struct S_IFI f18_S_SDP_IFI(struct S_IFI p0, double p1, void* p2,  struct S_IFI (*cb)(struct S_IFI, double, void*)) ;
+EXPORT struct S_IFF f18_S_SDP_IFF(struct S_IFF p0, double p1, void* p2,  struct S_IFF (*cb)(struct S_IFF, double, void*)) ;
+EXPORT struct S_IFD f18_S_SDP_IFD(struct S_IFD p0, double p1, void* p2,  struct S_IFD (*cb)(struct S_IFD, double, void*)) ;
+EXPORT struct S_IFP f18_S_SDP_IFP(struct S_IFP p0, double p1, void* p2,  struct S_IFP (*cb)(struct S_IFP, double, void*)) ;
+EXPORT struct S_IDI f18_S_SDP_IDI(struct S_IDI p0, double p1, void* p2,  struct S_IDI (*cb)(struct S_IDI, double, void*)) ;
+EXPORT struct S_IDF f18_S_SDP_IDF(struct S_IDF p0, double p1, void* p2,  struct S_IDF (*cb)(struct S_IDF, double, void*)) ;
+EXPORT struct S_IDD f18_S_SDP_IDD(struct S_IDD p0, double p1, void* p2,  struct S_IDD (*cb)(struct S_IDD, double, void*)) ;
+EXPORT struct S_IDP f18_S_SDP_IDP(struct S_IDP p0, double p1, void* p2,  struct S_IDP (*cb)(struct S_IDP, double, void*)) ;
+EXPORT struct S_IPI f18_S_SDP_IPI(struct S_IPI p0, double p1, void* p2,  struct S_IPI (*cb)(struct S_IPI, double, void*)) ;
+EXPORT struct S_IPF f18_S_SDP_IPF(struct S_IPF p0, double p1, void* p2,  struct S_IPF (*cb)(struct S_IPF, double, void*)) ;
+EXPORT struct S_IPD f18_S_SDP_IPD(struct S_IPD p0, double p1, void* p2,  struct S_IPD (*cb)(struct S_IPD, double, void*)) ;
+EXPORT struct S_IPP f18_S_SDP_IPP(struct S_IPP p0, double p1, void* p2,  struct S_IPP (*cb)(struct S_IPP, double, void*)) ;
+EXPORT struct S_FII f18_S_SDP_FII(struct S_FII p0, double p1, void* p2,  struct S_FII (*cb)(struct S_FII, double, void*)) ;
+EXPORT struct S_FIF f18_S_SDP_FIF(struct S_FIF p0, double p1, void* p2,  struct S_FIF (*cb)(struct S_FIF, double, void*)) ;
+EXPORT struct S_FID f18_S_SDP_FID(struct S_FID p0, double p1, void* p2,  struct S_FID (*cb)(struct S_FID, double, void*)) ;
+EXPORT struct S_FIP f18_S_SDP_FIP(struct S_FIP p0, double p1, void* p2,  struct S_FIP (*cb)(struct S_FIP, double, void*)) ;
+EXPORT struct S_FFI f18_S_SDP_FFI(struct S_FFI p0, double p1, void* p2,  struct S_FFI (*cb)(struct S_FFI, double, void*)) ;
+EXPORT struct S_FFF f18_S_SDP_FFF(struct S_FFF p0, double p1, void* p2,  struct S_FFF (*cb)(struct S_FFF, double, void*)) ;
+EXPORT struct S_FFD f18_S_SDP_FFD(struct S_FFD p0, double p1, void* p2,  struct S_FFD (*cb)(struct S_FFD, double, void*)) ;
+EXPORT struct S_FFP f18_S_SDP_FFP(struct S_FFP p0, double p1, void* p2,  struct S_FFP (*cb)(struct S_FFP, double, void*)) ;
+EXPORT struct S_FDI f18_S_SDP_FDI(struct S_FDI p0, double p1, void* p2,  struct S_FDI (*cb)(struct S_FDI, double, void*)) ;
+EXPORT struct S_FDF f18_S_SDP_FDF(struct S_FDF p0, double p1, void* p2,  struct S_FDF (*cb)(struct S_FDF, double, void*)) ;
+EXPORT struct S_FDD f18_S_SDP_FDD(struct S_FDD p0, double p1, void* p2,  struct S_FDD (*cb)(struct S_FDD, double, void*)) ;
+EXPORT struct S_FDP f18_S_SDP_FDP(struct S_FDP p0, double p1, void* p2,  struct S_FDP (*cb)(struct S_FDP, double, void*)) ;
+EXPORT struct S_FPI f18_S_SDP_FPI(struct S_FPI p0, double p1, void* p2,  struct S_FPI (*cb)(struct S_FPI, double, void*)) ;
+EXPORT struct S_FPF f18_S_SDP_FPF(struct S_FPF p0, double p1, void* p2,  struct S_FPF (*cb)(struct S_FPF, double, void*)) ;
+EXPORT struct S_FPD f18_S_SDP_FPD(struct S_FPD p0, double p1, void* p2,  struct S_FPD (*cb)(struct S_FPD, double, void*)) ;
+EXPORT struct S_FPP f18_S_SDP_FPP(struct S_FPP p0, double p1, void* p2,  struct S_FPP (*cb)(struct S_FPP, double, void*)) ;
+EXPORT struct S_DII f18_S_SDP_DII(struct S_DII p0, double p1, void* p2,  struct S_DII (*cb)(struct S_DII, double, void*)) ;
+EXPORT struct S_DIF f18_S_SDP_DIF(struct S_DIF p0, double p1, void* p2,  struct S_DIF (*cb)(struct S_DIF, double, void*)) ;
+EXPORT struct S_DID f18_S_SDP_DID(struct S_DID p0, double p1, void* p2,  struct S_DID (*cb)(struct S_DID, double, void*)) ;
+EXPORT struct S_DIP f18_S_SDP_DIP(struct S_DIP p0, double p1, void* p2,  struct S_DIP (*cb)(struct S_DIP, double, void*)) ;
+EXPORT struct S_DFI f18_S_SDP_DFI(struct S_DFI p0, double p1, void* p2,  struct S_DFI (*cb)(struct S_DFI, double, void*)) ;
+EXPORT struct S_DFF f18_S_SDP_DFF(struct S_DFF p0, double p1, void* p2,  struct S_DFF (*cb)(struct S_DFF, double, void*)) ;
+EXPORT struct S_DFD f18_S_SDP_DFD(struct S_DFD p0, double p1, void* p2,  struct S_DFD (*cb)(struct S_DFD, double, void*)) ;
+EXPORT struct S_DFP f18_S_SDP_DFP(struct S_DFP p0, double p1, void* p2,  struct S_DFP (*cb)(struct S_DFP, double, void*)) ;
+EXPORT struct S_DDI f18_S_SDP_DDI(struct S_DDI p0, double p1, void* p2,  struct S_DDI (*cb)(struct S_DDI, double, void*)) ;
+EXPORT struct S_DDF f18_S_SDP_DDF(struct S_DDF p0, double p1, void* p2,  struct S_DDF (*cb)(struct S_DDF, double, void*)) ;
+EXPORT struct S_DDD f18_S_SDP_DDD(struct S_DDD p0, double p1, void* p2,  struct S_DDD (*cb)(struct S_DDD, double, void*)) ;
+EXPORT struct S_DDP f18_S_SDP_DDP(struct S_DDP p0, double p1, void* p2,  struct S_DDP (*cb)(struct S_DDP, double, void*)) ;
+EXPORT struct S_DPI f18_S_SDP_DPI(struct S_DPI p0, double p1, void* p2,  struct S_DPI (*cb)(struct S_DPI, double, void*)) ;
+EXPORT struct S_DPF f18_S_SDP_DPF(struct S_DPF p0, double p1, void* p2,  struct S_DPF (*cb)(struct S_DPF, double, void*)) ;
+EXPORT struct S_DPD f18_S_SDP_DPD(struct S_DPD p0, double p1, void* p2,  struct S_DPD (*cb)(struct S_DPD, double, void*)) ;
+EXPORT struct S_DPP f18_S_SDP_DPP(struct S_DPP p0, double p1, void* p2,  struct S_DPP (*cb)(struct S_DPP, double, void*)) ;
+EXPORT struct S_PII f18_S_SDP_PII(struct S_PII p0, double p1, void* p2,  struct S_PII (*cb)(struct S_PII, double, void*)) ;
+EXPORT struct S_PIF f18_S_SDP_PIF(struct S_PIF p0, double p1, void* p2,  struct S_PIF (*cb)(struct S_PIF, double, void*)) ;
+EXPORT struct S_PID f18_S_SDP_PID(struct S_PID p0, double p1, void* p2,  struct S_PID (*cb)(struct S_PID, double, void*)) ;
+EXPORT struct S_PIP f18_S_SDP_PIP(struct S_PIP p0, double p1, void* p2,  struct S_PIP (*cb)(struct S_PIP, double, void*)) ;
+EXPORT struct S_PFI f18_S_SDP_PFI(struct S_PFI p0, double p1, void* p2,  struct S_PFI (*cb)(struct S_PFI, double, void*)) ;
+EXPORT struct S_PFF f18_S_SDP_PFF(struct S_PFF p0, double p1, void* p2,  struct S_PFF (*cb)(struct S_PFF, double, void*)) ;
+EXPORT struct S_PFD f18_S_SDP_PFD(struct S_PFD p0, double p1, void* p2,  struct S_PFD (*cb)(struct S_PFD, double, void*)) ;
+EXPORT struct S_PFP f18_S_SDP_PFP(struct S_PFP p0, double p1, void* p2,  struct S_PFP (*cb)(struct S_PFP, double, void*)) ;
+EXPORT struct S_PDI f18_S_SDP_PDI(struct S_PDI p0, double p1, void* p2,  struct S_PDI (*cb)(struct S_PDI, double, void*)) ;
+EXPORT struct S_PDF f18_S_SDP_PDF(struct S_PDF p0, double p1, void* p2,  struct S_PDF (*cb)(struct S_PDF, double, void*)) ;
+EXPORT struct S_PDD f18_S_SDP_PDD(struct S_PDD p0, double p1, void* p2,  struct S_PDD (*cb)(struct S_PDD, double, void*)) ;
+EXPORT struct S_PDP f18_S_SDP_PDP(struct S_PDP p0, double p1, void* p2,  struct S_PDP (*cb)(struct S_PDP, double, void*)) ;
+EXPORT struct S_PPI f18_S_SDP_PPI(struct S_PPI p0, double p1, void* p2,  struct S_PPI (*cb)(struct S_PPI, double, void*)) ;
+EXPORT struct S_PPF f18_S_SDP_PPF(struct S_PPF p0, double p1, void* p2,  struct S_PPF (*cb)(struct S_PPF, double, void*)) ;
+EXPORT struct S_PPD f18_S_SDP_PPD(struct S_PPD p0, double p1, void* p2,  struct S_PPD (*cb)(struct S_PPD, double, void*)) ;
+EXPORT struct S_PPP f18_S_SDP_PPP(struct S_PPP p0, double p1, void* p2,  struct S_PPP (*cb)(struct S_PPP, double, void*)) ;
+EXPORT struct S_I f18_S_SDS_I(struct S_I p0, double p1, struct S_I p2,  struct S_I (*cb)(struct S_I, double, struct S_I)) ;
+EXPORT struct S_F f18_S_SDS_F(struct S_F p0, double p1, struct S_F p2,  struct S_F (*cb)(struct S_F, double, struct S_F)) ;
+EXPORT struct S_D f18_S_SDS_D(struct S_D p0, double p1, struct S_D p2,  struct S_D (*cb)(struct S_D, double, struct S_D)) ;
+EXPORT struct S_P f18_S_SDS_P(struct S_P p0, double p1, struct S_P p2,  struct S_P (*cb)(struct S_P, double, struct S_P)) ;
+EXPORT struct S_II f18_S_SDS_II(struct S_II p0, double p1, struct S_II p2,  struct S_II (*cb)(struct S_II, double, struct S_II)) ;
+EXPORT struct S_IF f18_S_SDS_IF(struct S_IF p0, double p1, struct S_IF p2,  struct S_IF (*cb)(struct S_IF, double, struct S_IF)) ;
+EXPORT struct S_ID f18_S_SDS_ID(struct S_ID p0, double p1, struct S_ID p2,  struct S_ID (*cb)(struct S_ID, double, struct S_ID)) ;
+EXPORT struct S_IP f18_S_SDS_IP(struct S_IP p0, double p1, struct S_IP p2,  struct S_IP (*cb)(struct S_IP, double, struct S_IP)) ;
+EXPORT struct S_FI f18_S_SDS_FI(struct S_FI p0, double p1, struct S_FI p2,  struct S_FI (*cb)(struct S_FI, double, struct S_FI)) ;
+EXPORT struct S_FF f18_S_SDS_FF(struct S_FF p0, double p1, struct S_FF p2,  struct S_FF (*cb)(struct S_FF, double, struct S_FF)) ;
+EXPORT struct S_FD f18_S_SDS_FD(struct S_FD p0, double p1, struct S_FD p2,  struct S_FD (*cb)(struct S_FD, double, struct S_FD)) ;
+EXPORT struct S_FP f18_S_SDS_FP(struct S_FP p0, double p1, struct S_FP p2,  struct S_FP (*cb)(struct S_FP, double, struct S_FP)) ;
+EXPORT struct S_DI f18_S_SDS_DI(struct S_DI p0, double p1, struct S_DI p2,  struct S_DI (*cb)(struct S_DI, double, struct S_DI)) ;
+EXPORT struct S_DF f18_S_SDS_DF(struct S_DF p0, double p1, struct S_DF p2,  struct S_DF (*cb)(struct S_DF, double, struct S_DF)) ;
+EXPORT struct S_DD f18_S_SDS_DD(struct S_DD p0, double p1, struct S_DD p2,  struct S_DD (*cb)(struct S_DD, double, struct S_DD)) ;
+EXPORT struct S_DP f18_S_SDS_DP(struct S_DP p0, double p1, struct S_DP p2,  struct S_DP (*cb)(struct S_DP, double, struct S_DP)) ;
+EXPORT struct S_PI f18_S_SDS_PI(struct S_PI p0, double p1, struct S_PI p2,  struct S_PI (*cb)(struct S_PI, double, struct S_PI)) ;
+EXPORT struct S_PF f18_S_SDS_PF(struct S_PF p0, double p1, struct S_PF p2,  struct S_PF (*cb)(struct S_PF, double, struct S_PF)) ;
+EXPORT struct S_PD f18_S_SDS_PD(struct S_PD p0, double p1, struct S_PD p2,  struct S_PD (*cb)(struct S_PD, double, struct S_PD)) ;
+EXPORT struct S_PP f18_S_SDS_PP(struct S_PP p0, double p1, struct S_PP p2,  struct S_PP (*cb)(struct S_PP, double, struct S_PP)) ;
+EXPORT struct S_III f18_S_SDS_III(struct S_III p0, double p1, struct S_III p2,  struct S_III (*cb)(struct S_III, double, struct S_III)) ;
+EXPORT struct S_IIF f18_S_SDS_IIF(struct S_IIF p0, double p1, struct S_IIF p2,  struct S_IIF (*cb)(struct S_IIF, double, struct S_IIF)) ;
+EXPORT struct S_IID f18_S_SDS_IID(struct S_IID p0, double p1, struct S_IID p2,  struct S_IID (*cb)(struct S_IID, double, struct S_IID)) ;
+EXPORT struct S_IIP f18_S_SDS_IIP(struct S_IIP p0, double p1, struct S_IIP p2,  struct S_IIP (*cb)(struct S_IIP, double, struct S_IIP)) ;
+EXPORT struct S_IFI f18_S_SDS_IFI(struct S_IFI p0, double p1, struct S_IFI p2,  struct S_IFI (*cb)(struct S_IFI, double, struct S_IFI)) ;
+EXPORT struct S_IFF f18_S_SDS_IFF(struct S_IFF p0, double p1, struct S_IFF p2,  struct S_IFF (*cb)(struct S_IFF, double, struct S_IFF)) ;
+EXPORT struct S_IFD f18_S_SDS_IFD(struct S_IFD p0, double p1, struct S_IFD p2,  struct S_IFD (*cb)(struct S_IFD, double, struct S_IFD)) ;
+EXPORT struct S_IFP f18_S_SDS_IFP(struct S_IFP p0, double p1, struct S_IFP p2,  struct S_IFP (*cb)(struct S_IFP, double, struct S_IFP)) ;
+EXPORT struct S_IDI f18_S_SDS_IDI(struct S_IDI p0, double p1, struct S_IDI p2,  struct S_IDI (*cb)(struct S_IDI, double, struct S_IDI)) ;
+EXPORT struct S_IDF f18_S_SDS_IDF(struct S_IDF p0, double p1, struct S_IDF p2,  struct S_IDF (*cb)(struct S_IDF, double, struct S_IDF)) ;
+EXPORT struct S_IDD f18_S_SDS_IDD(struct S_IDD p0, double p1, struct S_IDD p2,  struct S_IDD (*cb)(struct S_IDD, double, struct S_IDD)) ;
+EXPORT struct S_IDP f18_S_SDS_IDP(struct S_IDP p0, double p1, struct S_IDP p2,  struct S_IDP (*cb)(struct S_IDP, double, struct S_IDP)) ;
+EXPORT struct S_IPI f18_S_SDS_IPI(struct S_IPI p0, double p1, struct S_IPI p2,  struct S_IPI (*cb)(struct S_IPI, double, struct S_IPI)) ;
+EXPORT struct S_IPF f18_S_SDS_IPF(struct S_IPF p0, double p1, struct S_IPF p2,  struct S_IPF (*cb)(struct S_IPF, double, struct S_IPF)) ;
+EXPORT struct S_IPD f18_S_SDS_IPD(struct S_IPD p0, double p1, struct S_IPD p2,  struct S_IPD (*cb)(struct S_IPD, double, struct S_IPD)) ;
+EXPORT struct S_IPP f18_S_SDS_IPP(struct S_IPP p0, double p1, struct S_IPP p2,  struct S_IPP (*cb)(struct S_IPP, double, struct S_IPP)) ;
+EXPORT struct S_FII f18_S_SDS_FII(struct S_FII p0, double p1, struct S_FII p2,  struct S_FII (*cb)(struct S_FII, double, struct S_FII)) ;
+EXPORT struct S_FIF f18_S_SDS_FIF(struct S_FIF p0, double p1, struct S_FIF p2,  struct S_FIF (*cb)(struct S_FIF, double, struct S_FIF)) ;
+EXPORT struct S_FID f18_S_SDS_FID(struct S_FID p0, double p1, struct S_FID p2,  struct S_FID (*cb)(struct S_FID, double, struct S_FID)) ;
+EXPORT struct S_FIP f18_S_SDS_FIP(struct S_FIP p0, double p1, struct S_FIP p2,  struct S_FIP (*cb)(struct S_FIP, double, struct S_FIP)) ;
+EXPORT struct S_FFI f18_S_SDS_FFI(struct S_FFI p0, double p1, struct S_FFI p2,  struct S_FFI (*cb)(struct S_FFI, double, struct S_FFI)) ;
+EXPORT struct S_FFF f18_S_SDS_FFF(struct S_FFF p0, double p1, struct S_FFF p2,  struct S_FFF (*cb)(struct S_FFF, double, struct S_FFF)) ;
+EXPORT struct S_FFD f18_S_SDS_FFD(struct S_FFD p0, double p1, struct S_FFD p2,  struct S_FFD (*cb)(struct S_FFD, double, struct S_FFD)) ;
+EXPORT struct S_FFP f18_S_SDS_FFP(struct S_FFP p0, double p1, struct S_FFP p2,  struct S_FFP (*cb)(struct S_FFP, double, struct S_FFP)) ;
+EXPORT struct S_FDI f18_S_SDS_FDI(struct S_FDI p0, double p1, struct S_FDI p2,  struct S_FDI (*cb)(struct S_FDI, double, struct S_FDI)) ;
+EXPORT struct S_FDF f18_S_SDS_FDF(struct S_FDF p0, double p1, struct S_FDF p2,  struct S_FDF (*cb)(struct S_FDF, double, struct S_FDF)) ;
+EXPORT struct S_FDD f18_S_SDS_FDD(struct S_FDD p0, double p1, struct S_FDD p2,  struct S_FDD (*cb)(struct S_FDD, double, struct S_FDD)) ;
+EXPORT struct S_FDP f18_S_SDS_FDP(struct S_FDP p0, double p1, struct S_FDP p2,  struct S_FDP (*cb)(struct S_FDP, double, struct S_FDP)) ;
+EXPORT struct S_FPI f18_S_SDS_FPI(struct S_FPI p0, double p1, struct S_FPI p2,  struct S_FPI (*cb)(struct S_FPI, double, struct S_FPI)) ;
+EXPORT struct S_FPF f18_S_SDS_FPF(struct S_FPF p0, double p1, struct S_FPF p2,  struct S_FPF (*cb)(struct S_FPF, double, struct S_FPF)) ;
+EXPORT struct S_FPD f18_S_SDS_FPD(struct S_FPD p0, double p1, struct S_FPD p2,  struct S_FPD (*cb)(struct S_FPD, double, struct S_FPD)) ;
+EXPORT struct S_FPP f18_S_SDS_FPP(struct S_FPP p0, double p1, struct S_FPP p2,  struct S_FPP (*cb)(struct S_FPP, double, struct S_FPP)) ;
+EXPORT struct S_DII f18_S_SDS_DII(struct S_DII p0, double p1, struct S_DII p2,  struct S_DII (*cb)(struct S_DII, double, struct S_DII)) ;
+EXPORT struct S_DIF f18_S_SDS_DIF(struct S_DIF p0, double p1, struct S_DIF p2,  struct S_DIF (*cb)(struct S_DIF, double, struct S_DIF)) ;
+EXPORT struct S_DID f18_S_SDS_DID(struct S_DID p0, double p1, struct S_DID p2,  struct S_DID (*cb)(struct S_DID, double, struct S_DID)) ;
+EXPORT struct S_DIP f18_S_SDS_DIP(struct S_DIP p0, double p1, struct S_DIP p2,  struct S_DIP (*cb)(struct S_DIP, double, struct S_DIP)) ;
+EXPORT struct S_DFI f18_S_SDS_DFI(struct S_DFI p0, double p1, struct S_DFI p2,  struct S_DFI (*cb)(struct S_DFI, double, struct S_DFI)) ;
+EXPORT struct S_DFF f18_S_SDS_DFF(struct S_DFF p0, double p1, struct S_DFF p2,  struct S_DFF (*cb)(struct S_DFF, double, struct S_DFF)) ;
+EXPORT struct S_DFD f18_S_SDS_DFD(struct S_DFD p0, double p1, struct S_DFD p2,  struct S_DFD (*cb)(struct S_DFD, double, struct S_DFD)) ;
+EXPORT struct S_DFP f18_S_SDS_DFP(struct S_DFP p0, double p1, struct S_DFP p2,  struct S_DFP (*cb)(struct S_DFP, double, struct S_DFP)) ;
+EXPORT struct S_DDI f18_S_SDS_DDI(struct S_DDI p0, double p1, struct S_DDI p2,  struct S_DDI (*cb)(struct S_DDI, double, struct S_DDI)) ;
+EXPORT struct S_DDF f18_S_SDS_DDF(struct S_DDF p0, double p1, struct S_DDF p2,  struct S_DDF (*cb)(struct S_DDF, double, struct S_DDF)) ;
+EXPORT struct S_DDD f18_S_SDS_DDD(struct S_DDD p0, double p1, struct S_DDD p2,  struct S_DDD (*cb)(struct S_DDD, double, struct S_DDD)) ;
+EXPORT struct S_DDP f18_S_SDS_DDP(struct S_DDP p0, double p1, struct S_DDP p2,  struct S_DDP (*cb)(struct S_DDP, double, struct S_DDP)) ;
+EXPORT struct S_DPI f18_S_SDS_DPI(struct S_DPI p0, double p1, struct S_DPI p2,  struct S_DPI (*cb)(struct S_DPI, double, struct S_DPI)) ;
+EXPORT struct S_DPF f18_S_SDS_DPF(struct S_DPF p0, double p1, struct S_DPF p2,  struct S_DPF (*cb)(struct S_DPF, double, struct S_DPF)) ;
+EXPORT struct S_DPD f18_S_SDS_DPD(struct S_DPD p0, double p1, struct S_DPD p2,  struct S_DPD (*cb)(struct S_DPD, double, struct S_DPD)) ;
+EXPORT struct S_DPP f18_S_SDS_DPP(struct S_DPP p0, double p1, struct S_DPP p2,  struct S_DPP (*cb)(struct S_DPP, double, struct S_DPP)) ;
+EXPORT struct S_PII f18_S_SDS_PII(struct S_PII p0, double p1, struct S_PII p2,  struct S_PII (*cb)(struct S_PII, double, struct S_PII)) ;
+EXPORT struct S_PIF f18_S_SDS_PIF(struct S_PIF p0, double p1, struct S_PIF p2,  struct S_PIF (*cb)(struct S_PIF, double, struct S_PIF)) ;
+EXPORT struct S_PID f18_S_SDS_PID(struct S_PID p0, double p1, struct S_PID p2,  struct S_PID (*cb)(struct S_PID, double, struct S_PID)) ;
+EXPORT struct S_PIP f18_S_SDS_PIP(struct S_PIP p0, double p1, struct S_PIP p2,  struct S_PIP (*cb)(struct S_PIP, double, struct S_PIP)) ;
+EXPORT struct S_PFI f18_S_SDS_PFI(struct S_PFI p0, double p1, struct S_PFI p2,  struct S_PFI (*cb)(struct S_PFI, double, struct S_PFI)) ;
+EXPORT struct S_PFF f18_S_SDS_PFF(struct S_PFF p0, double p1, struct S_PFF p2,  struct S_PFF (*cb)(struct S_PFF, double, struct S_PFF)) ;
+EXPORT struct S_PFD f18_S_SDS_PFD(struct S_PFD p0, double p1, struct S_PFD p2,  struct S_PFD (*cb)(struct S_PFD, double, struct S_PFD)) ;
+EXPORT struct S_PFP f18_S_SDS_PFP(struct S_PFP p0, double p1, struct S_PFP p2,  struct S_PFP (*cb)(struct S_PFP, double, struct S_PFP)) ;
+EXPORT struct S_PDI f18_S_SDS_PDI(struct S_PDI p0, double p1, struct S_PDI p2,  struct S_PDI (*cb)(struct S_PDI, double, struct S_PDI)) ;
+EXPORT struct S_PDF f18_S_SDS_PDF(struct S_PDF p0, double p1, struct S_PDF p2,  struct S_PDF (*cb)(struct S_PDF, double, struct S_PDF)) ;
+EXPORT struct S_PDD f18_S_SDS_PDD(struct S_PDD p0, double p1, struct S_PDD p2,  struct S_PDD (*cb)(struct S_PDD, double, struct S_PDD)) ;
+EXPORT struct S_PDP f18_S_SDS_PDP(struct S_PDP p0, double p1, struct S_PDP p2,  struct S_PDP (*cb)(struct S_PDP, double, struct S_PDP)) ;
+EXPORT struct S_PPI f18_S_SDS_PPI(struct S_PPI p0, double p1, struct S_PPI p2,  struct S_PPI (*cb)(struct S_PPI, double, struct S_PPI)) ;
+EXPORT struct S_PPF f18_S_SDS_PPF(struct S_PPF p0, double p1, struct S_PPF p2,  struct S_PPF (*cb)(struct S_PPF, double, struct S_PPF)) ;
+EXPORT struct S_PPD f18_S_SDS_PPD(struct S_PPD p0, double p1, struct S_PPD p2,  struct S_PPD (*cb)(struct S_PPD, double, struct S_PPD)) ;
+EXPORT struct S_PPP f18_S_SDS_PPP(struct S_PPP p0, double p1, struct S_PPP p2,  struct S_PPP (*cb)(struct S_PPP, double, struct S_PPP)) ;
+EXPORT struct S_I f18_S_SPI_I(struct S_I p0, void* p1, int p2,  struct S_I (*cb)(struct S_I, void*, int)) ;
+EXPORT struct S_F f18_S_SPI_F(struct S_F p0, void* p1, int p2,  struct S_F (*cb)(struct S_F, void*, int)) ;
+EXPORT struct S_D f18_S_SPI_D(struct S_D p0, void* p1, int p2,  struct S_D (*cb)(struct S_D, void*, int)) ;
+EXPORT struct S_P f18_S_SPI_P(struct S_P p0, void* p1, int p2,  struct S_P (*cb)(struct S_P, void*, int)) ;
+EXPORT struct S_II f18_S_SPI_II(struct S_II p0, void* p1, int p2,  struct S_II (*cb)(struct S_II, void*, int)) ;
+EXPORT struct S_IF f18_S_SPI_IF(struct S_IF p0, void* p1, int p2,  struct S_IF (*cb)(struct S_IF, void*, int)) ;
+EXPORT struct S_ID f18_S_SPI_ID(struct S_ID p0, void* p1, int p2,  struct S_ID (*cb)(struct S_ID, void*, int)) ;
+EXPORT struct S_IP f18_S_SPI_IP(struct S_IP p0, void* p1, int p2,  struct S_IP (*cb)(struct S_IP, void*, int)) ;
+EXPORT struct S_FI f18_S_SPI_FI(struct S_FI p0, void* p1, int p2,  struct S_FI (*cb)(struct S_FI, void*, int)) ;
+EXPORT struct S_FF f18_S_SPI_FF(struct S_FF p0, void* p1, int p2,  struct S_FF (*cb)(struct S_FF, void*, int)) ;
+EXPORT struct S_FD f18_S_SPI_FD(struct S_FD p0, void* p1, int p2,  struct S_FD (*cb)(struct S_FD, void*, int)) ;
+EXPORT struct S_FP f18_S_SPI_FP(struct S_FP p0, void* p1, int p2,  struct S_FP (*cb)(struct S_FP, void*, int)) ;
+EXPORT struct S_DI f18_S_SPI_DI(struct S_DI p0, void* p1, int p2,  struct S_DI (*cb)(struct S_DI, void*, int)) ;
+EXPORT struct S_DF f18_S_SPI_DF(struct S_DF p0, void* p1, int p2,  struct S_DF (*cb)(struct S_DF, void*, int)) ;
+EXPORT struct S_DD f18_S_SPI_DD(struct S_DD p0, void* p1, int p2,  struct S_DD (*cb)(struct S_DD, void*, int)) ;
+EXPORT struct S_DP f18_S_SPI_DP(struct S_DP p0, void* p1, int p2,  struct S_DP (*cb)(struct S_DP, void*, int)) ;
+EXPORT struct S_PI f18_S_SPI_PI(struct S_PI p0, void* p1, int p2,  struct S_PI (*cb)(struct S_PI, void*, int)) ;
+EXPORT struct S_PF f18_S_SPI_PF(struct S_PF p0, void* p1, int p2,  struct S_PF (*cb)(struct S_PF, void*, int)) ;
+EXPORT struct S_PD f18_S_SPI_PD(struct S_PD p0, void* p1, int p2,  struct S_PD (*cb)(struct S_PD, void*, int)) ;
+EXPORT struct S_PP f18_S_SPI_PP(struct S_PP p0, void* p1, int p2,  struct S_PP (*cb)(struct S_PP, void*, int)) ;
+EXPORT struct S_III f18_S_SPI_III(struct S_III p0, void* p1, int p2,  struct S_III (*cb)(struct S_III, void*, int)) ;
+EXPORT struct S_IIF f18_S_SPI_IIF(struct S_IIF p0, void* p1, int p2,  struct S_IIF (*cb)(struct S_IIF, void*, int)) ;
+EXPORT struct S_IID f18_S_SPI_IID(struct S_IID p0, void* p1, int p2,  struct S_IID (*cb)(struct S_IID, void*, int)) ;
+EXPORT struct S_IIP f18_S_SPI_IIP(struct S_IIP p0, void* p1, int p2,  struct S_IIP (*cb)(struct S_IIP, void*, int)) ;
+EXPORT struct S_IFI f18_S_SPI_IFI(struct S_IFI p0, void* p1, int p2,  struct S_IFI (*cb)(struct S_IFI, void*, int)) ;
+EXPORT struct S_IFF f18_S_SPI_IFF(struct S_IFF p0, void* p1, int p2,  struct S_IFF (*cb)(struct S_IFF, void*, int)) ;
+EXPORT struct S_IFD f18_S_SPI_IFD(struct S_IFD p0, void* p1, int p2,  struct S_IFD (*cb)(struct S_IFD, void*, int)) ;
+EXPORT struct S_IFP f18_S_SPI_IFP(struct S_IFP p0, void* p1, int p2,  struct S_IFP (*cb)(struct S_IFP, void*, int)) ;
+EXPORT struct S_IDI f18_S_SPI_IDI(struct S_IDI p0, void* p1, int p2,  struct S_IDI (*cb)(struct S_IDI, void*, int)) ;
+EXPORT struct S_IDF f18_S_SPI_IDF(struct S_IDF p0, void* p1, int p2,  struct S_IDF (*cb)(struct S_IDF, void*, int)) ;
+EXPORT struct S_IDD f18_S_SPI_IDD(struct S_IDD p0, void* p1, int p2,  struct S_IDD (*cb)(struct S_IDD, void*, int)) ;
+EXPORT struct S_IDP f18_S_SPI_IDP(struct S_IDP p0, void* p1, int p2,  struct S_IDP (*cb)(struct S_IDP, void*, int)) ;
+EXPORT struct S_IPI f18_S_SPI_IPI(struct S_IPI p0, void* p1, int p2,  struct S_IPI (*cb)(struct S_IPI, void*, int)) ;
+EXPORT struct S_IPF f18_S_SPI_IPF(struct S_IPF p0, void* p1, int p2,  struct S_IPF (*cb)(struct S_IPF, void*, int)) ;
+EXPORT struct S_IPD f18_S_SPI_IPD(struct S_IPD p0, void* p1, int p2,  struct S_IPD (*cb)(struct S_IPD, void*, int)) ;
+EXPORT struct S_IPP f18_S_SPI_IPP(struct S_IPP p0, void* p1, int p2,  struct S_IPP (*cb)(struct S_IPP, void*, int)) ;
+EXPORT struct S_FII f18_S_SPI_FII(struct S_FII p0, void* p1, int p2,  struct S_FII (*cb)(struct S_FII, void*, int)) ;
+EXPORT struct S_FIF f18_S_SPI_FIF(struct S_FIF p0, void* p1, int p2,  struct S_FIF (*cb)(struct S_FIF, void*, int)) ;
+EXPORT struct S_FID f18_S_SPI_FID(struct S_FID p0, void* p1, int p2,  struct S_FID (*cb)(struct S_FID, void*, int)) ;
+EXPORT struct S_FIP f18_S_SPI_FIP(struct S_FIP p0, void* p1, int p2,  struct S_FIP (*cb)(struct S_FIP, void*, int)) ;
+EXPORT struct S_FFI f18_S_SPI_FFI(struct S_FFI p0, void* p1, int p2,  struct S_FFI (*cb)(struct S_FFI, void*, int)) ;
+EXPORT struct S_FFF f18_S_SPI_FFF(struct S_FFF p0, void* p1, int p2,  struct S_FFF (*cb)(struct S_FFF, void*, int)) ;
+EXPORT struct S_FFD f18_S_SPI_FFD(struct S_FFD p0, void* p1, int p2,  struct S_FFD (*cb)(struct S_FFD, void*, int)) ;
+EXPORT struct S_FFP f18_S_SPI_FFP(struct S_FFP p0, void* p1, int p2,  struct S_FFP (*cb)(struct S_FFP, void*, int)) ;
+EXPORT struct S_FDI f18_S_SPI_FDI(struct S_FDI p0, void* p1, int p2,  struct S_FDI (*cb)(struct S_FDI, void*, int)) ;
+EXPORT struct S_FDF f18_S_SPI_FDF(struct S_FDF p0, void* p1, int p2,  struct S_FDF (*cb)(struct S_FDF, void*, int)) ;
+EXPORT struct S_FDD f18_S_SPI_FDD(struct S_FDD p0, void* p1, int p2,  struct S_FDD (*cb)(struct S_FDD, void*, int)) ;
+EXPORT struct S_FDP f18_S_SPI_FDP(struct S_FDP p0, void* p1, int p2,  struct S_FDP (*cb)(struct S_FDP, void*, int)) ;
+EXPORT struct S_FPI f18_S_SPI_FPI(struct S_FPI p0, void* p1, int p2,  struct S_FPI (*cb)(struct S_FPI, void*, int)) ;
+EXPORT struct S_FPF f18_S_SPI_FPF(struct S_FPF p0, void* p1, int p2,  struct S_FPF (*cb)(struct S_FPF, void*, int)) ;
+EXPORT struct S_FPD f18_S_SPI_FPD(struct S_FPD p0, void* p1, int p2,  struct S_FPD (*cb)(struct S_FPD, void*, int)) ;
+EXPORT struct S_FPP f18_S_SPI_FPP(struct S_FPP p0, void* p1, int p2,  struct S_FPP (*cb)(struct S_FPP, void*, int)) ;
+EXPORT struct S_DII f18_S_SPI_DII(struct S_DII p0, void* p1, int p2,  struct S_DII (*cb)(struct S_DII, void*, int)) ;
+EXPORT struct S_DIF f18_S_SPI_DIF(struct S_DIF p0, void* p1, int p2,  struct S_DIF (*cb)(struct S_DIF, void*, int)) ;
+EXPORT struct S_DID f18_S_SPI_DID(struct S_DID p0, void* p1, int p2,  struct S_DID (*cb)(struct S_DID, void*, int)) ;
+EXPORT struct S_DIP f18_S_SPI_DIP(struct S_DIP p0, void* p1, int p2,  struct S_DIP (*cb)(struct S_DIP, void*, int)) ;
+EXPORT struct S_DFI f18_S_SPI_DFI(struct S_DFI p0, void* p1, int p2,  struct S_DFI (*cb)(struct S_DFI, void*, int)) ;
+EXPORT struct S_DFF f18_S_SPI_DFF(struct S_DFF p0, void* p1, int p2,  struct S_DFF (*cb)(struct S_DFF, void*, int)) ;
+EXPORT struct S_DFD f18_S_SPI_DFD(struct S_DFD p0, void* p1, int p2,  struct S_DFD (*cb)(struct S_DFD, void*, int)) ;
+EXPORT struct S_DFP f18_S_SPI_DFP(struct S_DFP p0, void* p1, int p2,  struct S_DFP (*cb)(struct S_DFP, void*, int)) ;
+EXPORT struct S_DDI f18_S_SPI_DDI(struct S_DDI p0, void* p1, int p2,  struct S_DDI (*cb)(struct S_DDI, void*, int)) ;
+EXPORT struct S_DDF f18_S_SPI_DDF(struct S_DDF p0, void* p1, int p2,  struct S_DDF (*cb)(struct S_DDF, void*, int)) ;
+EXPORT struct S_DDD f18_S_SPI_DDD(struct S_DDD p0, void* p1, int p2,  struct S_DDD (*cb)(struct S_DDD, void*, int)) ;
+EXPORT struct S_DDP f18_S_SPI_DDP(struct S_DDP p0, void* p1, int p2,  struct S_DDP (*cb)(struct S_DDP, void*, int)) ;
+EXPORT struct S_DPI f18_S_SPI_DPI(struct S_DPI p0, void* p1, int p2,  struct S_DPI (*cb)(struct S_DPI, void*, int)) ;
+EXPORT struct S_DPF f18_S_SPI_DPF(struct S_DPF p0, void* p1, int p2,  struct S_DPF (*cb)(struct S_DPF, void*, int)) ;
+EXPORT struct S_DPD f18_S_SPI_DPD(struct S_DPD p0, void* p1, int p2,  struct S_DPD (*cb)(struct S_DPD, void*, int)) ;
+EXPORT struct S_DPP f18_S_SPI_DPP(struct S_DPP p0, void* p1, int p2,  struct S_DPP (*cb)(struct S_DPP, void*, int)) ;
+EXPORT struct S_PII f18_S_SPI_PII(struct S_PII p0, void* p1, int p2,  struct S_PII (*cb)(struct S_PII, void*, int)) ;
+EXPORT struct S_PIF f18_S_SPI_PIF(struct S_PIF p0, void* p1, int p2,  struct S_PIF (*cb)(struct S_PIF, void*, int)) ;
+EXPORT struct S_PID f18_S_SPI_PID(struct S_PID p0, void* p1, int p2,  struct S_PID (*cb)(struct S_PID, void*, int)) ;
+EXPORT struct S_PIP f18_S_SPI_PIP(struct S_PIP p0, void* p1, int p2,  struct S_PIP (*cb)(struct S_PIP, void*, int)) ;
+EXPORT struct S_PFI f18_S_SPI_PFI(struct S_PFI p0, void* p1, int p2,  struct S_PFI (*cb)(struct S_PFI, void*, int)) ;
+EXPORT struct S_PFF f18_S_SPI_PFF(struct S_PFF p0, void* p1, int p2,  struct S_PFF (*cb)(struct S_PFF, void*, int)) ;
+EXPORT struct S_PFD f18_S_SPI_PFD(struct S_PFD p0, void* p1, int p2,  struct S_PFD (*cb)(struct S_PFD, void*, int)) ;
+EXPORT struct S_PFP f18_S_SPI_PFP(struct S_PFP p0, void* p1, int p2,  struct S_PFP (*cb)(struct S_PFP, void*, int)) ;
+EXPORT struct S_PDI f18_S_SPI_PDI(struct S_PDI p0, void* p1, int p2,  struct S_PDI (*cb)(struct S_PDI, void*, int)) ;
+EXPORT struct S_PDF f18_S_SPI_PDF(struct S_PDF p0, void* p1, int p2,  struct S_PDF (*cb)(struct S_PDF, void*, int)) ;
+EXPORT struct S_PDD f18_S_SPI_PDD(struct S_PDD p0, void* p1, int p2,  struct S_PDD (*cb)(struct S_PDD, void*, int)) ;
+EXPORT struct S_PDP f18_S_SPI_PDP(struct S_PDP p0, void* p1, int p2,  struct S_PDP (*cb)(struct S_PDP, void*, int)) ;
+EXPORT struct S_PPI f18_S_SPI_PPI(struct S_PPI p0, void* p1, int p2,  struct S_PPI (*cb)(struct S_PPI, void*, int)) ;
+EXPORT struct S_PPF f18_S_SPI_PPF(struct S_PPF p0, void* p1, int p2,  struct S_PPF (*cb)(struct S_PPF, void*, int)) ;
+EXPORT struct S_PPD f18_S_SPI_PPD(struct S_PPD p0, void* p1, int p2,  struct S_PPD (*cb)(struct S_PPD, void*, int)) ;
+EXPORT struct S_PPP f18_S_SPI_PPP(struct S_PPP p0, void* p1, int p2,  struct S_PPP (*cb)(struct S_PPP, void*, int)) ;
+EXPORT struct S_I f18_S_SPF_I(struct S_I p0, void* p1, float p2,  struct S_I (*cb)(struct S_I, void*, float)) ;
+EXPORT struct S_F f18_S_SPF_F(struct S_F p0, void* p1, float p2,  struct S_F (*cb)(struct S_F, void*, float)) ;
+EXPORT struct S_D f18_S_SPF_D(struct S_D p0, void* p1, float p2,  struct S_D (*cb)(struct S_D, void*, float)) ;
+EXPORT struct S_P f18_S_SPF_P(struct S_P p0, void* p1, float p2,  struct S_P (*cb)(struct S_P, void*, float)) ;
+EXPORT struct S_II f18_S_SPF_II(struct S_II p0, void* p1, float p2,  struct S_II (*cb)(struct S_II, void*, float)) ;
+EXPORT struct S_IF f18_S_SPF_IF(struct S_IF p0, void* p1, float p2,  struct S_IF (*cb)(struct S_IF, void*, float)) ;
+EXPORT struct S_ID f18_S_SPF_ID(struct S_ID p0, void* p1, float p2,  struct S_ID (*cb)(struct S_ID, void*, float)) ;
+EXPORT struct S_IP f18_S_SPF_IP(struct S_IP p0, void* p1, float p2,  struct S_IP (*cb)(struct S_IP, void*, float)) ;
+EXPORT struct S_FI f18_S_SPF_FI(struct S_FI p0, void* p1, float p2,  struct S_FI (*cb)(struct S_FI, void*, float)) ;
+EXPORT struct S_FF f18_S_SPF_FF(struct S_FF p0, void* p1, float p2,  struct S_FF (*cb)(struct S_FF, void*, float)) ;
+EXPORT struct S_FD f18_S_SPF_FD(struct S_FD p0, void* p1, float p2,  struct S_FD (*cb)(struct S_FD, void*, float)) ;
+EXPORT struct S_FP f18_S_SPF_FP(struct S_FP p0, void* p1, float p2,  struct S_FP (*cb)(struct S_FP, void*, float)) ;
+EXPORT struct S_DI f18_S_SPF_DI(struct S_DI p0, void* p1, float p2,  struct S_DI (*cb)(struct S_DI, void*, float)) ;
+EXPORT struct S_DF f18_S_SPF_DF(struct S_DF p0, void* p1, float p2,  struct S_DF (*cb)(struct S_DF, void*, float)) ;
+EXPORT struct S_DD f18_S_SPF_DD(struct S_DD p0, void* p1, float p2,  struct S_DD (*cb)(struct S_DD, void*, float)) ;
+EXPORT struct S_DP f18_S_SPF_DP(struct S_DP p0, void* p1, float p2,  struct S_DP (*cb)(struct S_DP, void*, float)) ;
+EXPORT struct S_PI f18_S_SPF_PI(struct S_PI p0, void* p1, float p2,  struct S_PI (*cb)(struct S_PI, void*, float)) ;
+EXPORT struct S_PF f18_S_SPF_PF(struct S_PF p0, void* p1, float p2,  struct S_PF (*cb)(struct S_PF, void*, float)) ;
+EXPORT struct S_PD f18_S_SPF_PD(struct S_PD p0, void* p1, float p2,  struct S_PD (*cb)(struct S_PD, void*, float)) ;
+EXPORT struct S_PP f18_S_SPF_PP(struct S_PP p0, void* p1, float p2,  struct S_PP (*cb)(struct S_PP, void*, float)) ;
+EXPORT struct S_III f18_S_SPF_III(struct S_III p0, void* p1, float p2,  struct S_III (*cb)(struct S_III, void*, float)) ;
+EXPORT struct S_IIF f18_S_SPF_IIF(struct S_IIF p0, void* p1, float p2,  struct S_IIF (*cb)(struct S_IIF, void*, float)) ;
+EXPORT struct S_IID f18_S_SPF_IID(struct S_IID p0, void* p1, float p2,  struct S_IID (*cb)(struct S_IID, void*, float)) ;
+EXPORT struct S_IIP f18_S_SPF_IIP(struct S_IIP p0, void* p1, float p2,  struct S_IIP (*cb)(struct S_IIP, void*, float)) ;
+EXPORT struct S_IFI f18_S_SPF_IFI(struct S_IFI p0, void* p1, float p2,  struct S_IFI (*cb)(struct S_IFI, void*, float)) ;
+EXPORT struct S_IFF f18_S_SPF_IFF(struct S_IFF p0, void* p1, float p2,  struct S_IFF (*cb)(struct S_IFF, void*, float)) ;
+EXPORT struct S_IFD f18_S_SPF_IFD(struct S_IFD p0, void* p1, float p2,  struct S_IFD (*cb)(struct S_IFD, void*, float)) ;
+EXPORT struct S_IFP f18_S_SPF_IFP(struct S_IFP p0, void* p1, float p2,  struct S_IFP (*cb)(struct S_IFP, void*, float)) ;
+EXPORT struct S_IDI f18_S_SPF_IDI(struct S_IDI p0, void* p1, float p2,  struct S_IDI (*cb)(struct S_IDI, void*, float)) ;
+EXPORT struct S_IDF f18_S_SPF_IDF(struct S_IDF p0, void* p1, float p2,  struct S_IDF (*cb)(struct S_IDF, void*, float)) ;
+EXPORT struct S_IDD f18_S_SPF_IDD(struct S_IDD p0, void* p1, float p2,  struct S_IDD (*cb)(struct S_IDD, void*, float)) ;
+EXPORT struct S_IDP f18_S_SPF_IDP(struct S_IDP p0, void* p1, float p2,  struct S_IDP (*cb)(struct S_IDP, void*, float)) ;
+EXPORT struct S_IPI f18_S_SPF_IPI(struct S_IPI p0, void* p1, float p2,  struct S_IPI (*cb)(struct S_IPI, void*, float)) ;
+EXPORT struct S_IPF f18_S_SPF_IPF(struct S_IPF p0, void* p1, float p2,  struct S_IPF (*cb)(struct S_IPF, void*, float)) ;
+EXPORT struct S_IPD f18_S_SPF_IPD(struct S_IPD p0, void* p1, float p2,  struct S_IPD (*cb)(struct S_IPD, void*, float)) ;
+EXPORT struct S_IPP f18_S_SPF_IPP(struct S_IPP p0, void* p1, float p2,  struct S_IPP (*cb)(struct S_IPP, void*, float)) ;
+EXPORT struct S_FII f18_S_SPF_FII(struct S_FII p0, void* p1, float p2,  struct S_FII (*cb)(struct S_FII, void*, float)) ;
+EXPORT struct S_FIF f18_S_SPF_FIF(struct S_FIF p0, void* p1, float p2,  struct S_FIF (*cb)(struct S_FIF, void*, float)) ;
+EXPORT struct S_FID f18_S_SPF_FID(struct S_FID p0, void* p1, float p2,  struct S_FID (*cb)(struct S_FID, void*, float)) ;
+EXPORT struct S_FIP f18_S_SPF_FIP(struct S_FIP p0, void* p1, float p2,  struct S_FIP (*cb)(struct S_FIP, void*, float)) ;
+EXPORT struct S_FFI f18_S_SPF_FFI(struct S_FFI p0, void* p1, float p2,  struct S_FFI (*cb)(struct S_FFI, void*, float)) ;
+EXPORT struct S_FFF f18_S_SPF_FFF(struct S_FFF p0, void* p1, float p2,  struct S_FFF (*cb)(struct S_FFF, void*, float)) ;
+EXPORT struct S_FFD f18_S_SPF_FFD(struct S_FFD p0, void* p1, float p2,  struct S_FFD (*cb)(struct S_FFD, void*, float)) ;
+EXPORT struct S_FFP f18_S_SPF_FFP(struct S_FFP p0, void* p1, float p2,  struct S_FFP (*cb)(struct S_FFP, void*, float)) ;
+EXPORT struct S_FDI f18_S_SPF_FDI(struct S_FDI p0, void* p1, float p2,  struct S_FDI (*cb)(struct S_FDI, void*, float)) ;
+EXPORT struct S_FDF f18_S_SPF_FDF(struct S_FDF p0, void* p1, float p2,  struct S_FDF (*cb)(struct S_FDF, void*, float)) ;
+EXPORT struct S_FDD f18_S_SPF_FDD(struct S_FDD p0, void* p1, float p2,  struct S_FDD (*cb)(struct S_FDD, void*, float)) ;
+EXPORT struct S_FDP f18_S_SPF_FDP(struct S_FDP p0, void* p1, float p2,  struct S_FDP (*cb)(struct S_FDP, void*, float)) ;
+EXPORT struct S_FPI f18_S_SPF_FPI(struct S_FPI p0, void* p1, float p2,  struct S_FPI (*cb)(struct S_FPI, void*, float)) ;
+EXPORT struct S_FPF f18_S_SPF_FPF(struct S_FPF p0, void* p1, float p2,  struct S_FPF (*cb)(struct S_FPF, void*, float)) ;
+EXPORT struct S_FPD f18_S_SPF_FPD(struct S_FPD p0, void* p1, float p2,  struct S_FPD (*cb)(struct S_FPD, void*, float)) ;
+EXPORT struct S_FPP f18_S_SPF_FPP(struct S_FPP p0, void* p1, float p2,  struct S_FPP (*cb)(struct S_FPP, void*, float)) ;
+EXPORT struct S_DII f18_S_SPF_DII(struct S_DII p0, void* p1, float p2,  struct S_DII (*cb)(struct S_DII, void*, float)) ;
+EXPORT struct S_DIF f18_S_SPF_DIF(struct S_DIF p0, void* p1, float p2,  struct S_DIF (*cb)(struct S_DIF, void*, float)) ;
+EXPORT struct S_DID f18_S_SPF_DID(struct S_DID p0, void* p1, float p2,  struct S_DID (*cb)(struct S_DID, void*, float)) ;
+EXPORT struct S_DIP f18_S_SPF_DIP(struct S_DIP p0, void* p1, float p2,  struct S_DIP (*cb)(struct S_DIP, void*, float)) ;
+EXPORT struct S_DFI f18_S_SPF_DFI(struct S_DFI p0, void* p1, float p2,  struct S_DFI (*cb)(struct S_DFI, void*, float)) ;
+EXPORT struct S_DFF f18_S_SPF_DFF(struct S_DFF p0, void* p1, float p2,  struct S_DFF (*cb)(struct S_DFF, void*, float)) ;
+EXPORT struct S_DFD f18_S_SPF_DFD(struct S_DFD p0, void* p1, float p2,  struct S_DFD (*cb)(struct S_DFD, void*, float)) ;
+EXPORT struct S_DFP f19_S_SPF_DFP(struct S_DFP p0, void* p1, float p2,  struct S_DFP (*cb)(struct S_DFP, void*, float)) ;
+EXPORT struct S_DDI f19_S_SPF_DDI(struct S_DDI p0, void* p1, float p2,  struct S_DDI (*cb)(struct S_DDI, void*, float)) ;
+EXPORT struct S_DDF f19_S_SPF_DDF(struct S_DDF p0, void* p1, float p2,  struct S_DDF (*cb)(struct S_DDF, void*, float)) ;
+EXPORT struct S_DDD f19_S_SPF_DDD(struct S_DDD p0, void* p1, float p2,  struct S_DDD (*cb)(struct S_DDD, void*, float)) ;
+EXPORT struct S_DDP f19_S_SPF_DDP(struct S_DDP p0, void* p1, float p2,  struct S_DDP (*cb)(struct S_DDP, void*, float)) ;
+EXPORT struct S_DPI f19_S_SPF_DPI(struct S_DPI p0, void* p1, float p2,  struct S_DPI (*cb)(struct S_DPI, void*, float)) ;
+EXPORT struct S_DPF f19_S_SPF_DPF(struct S_DPF p0, void* p1, float p2,  struct S_DPF (*cb)(struct S_DPF, void*, float)) ;
+EXPORT struct S_DPD f19_S_SPF_DPD(struct S_DPD p0, void* p1, float p2,  struct S_DPD (*cb)(struct S_DPD, void*, float)) ;
+EXPORT struct S_DPP f19_S_SPF_DPP(struct S_DPP p0, void* p1, float p2,  struct S_DPP (*cb)(struct S_DPP, void*, float)) ;
+EXPORT struct S_PII f19_S_SPF_PII(struct S_PII p0, void* p1, float p2,  struct S_PII (*cb)(struct S_PII, void*, float)) ;
+EXPORT struct S_PIF f19_S_SPF_PIF(struct S_PIF p0, void* p1, float p2,  struct S_PIF (*cb)(struct S_PIF, void*, float)) ;
+EXPORT struct S_PID f19_S_SPF_PID(struct S_PID p0, void* p1, float p2,  struct S_PID (*cb)(struct S_PID, void*, float)) ;
+EXPORT struct S_PIP f19_S_SPF_PIP(struct S_PIP p0, void* p1, float p2,  struct S_PIP (*cb)(struct S_PIP, void*, float)) ;
+EXPORT struct S_PFI f19_S_SPF_PFI(struct S_PFI p0, void* p1, float p2,  struct S_PFI (*cb)(struct S_PFI, void*, float)) ;
+EXPORT struct S_PFF f19_S_SPF_PFF(struct S_PFF p0, void* p1, float p2,  struct S_PFF (*cb)(struct S_PFF, void*, float)) ;
+EXPORT struct S_PFD f19_S_SPF_PFD(struct S_PFD p0, void* p1, float p2,  struct S_PFD (*cb)(struct S_PFD, void*, float)) ;
+EXPORT struct S_PFP f19_S_SPF_PFP(struct S_PFP p0, void* p1, float p2,  struct S_PFP (*cb)(struct S_PFP, void*, float)) ;
+EXPORT struct S_PDI f19_S_SPF_PDI(struct S_PDI p0, void* p1, float p2,  struct S_PDI (*cb)(struct S_PDI, void*, float)) ;
+EXPORT struct S_PDF f19_S_SPF_PDF(struct S_PDF p0, void* p1, float p2,  struct S_PDF (*cb)(struct S_PDF, void*, float)) ;
+EXPORT struct S_PDD f19_S_SPF_PDD(struct S_PDD p0, void* p1, float p2,  struct S_PDD (*cb)(struct S_PDD, void*, float)) ;
+EXPORT struct S_PDP f19_S_SPF_PDP(struct S_PDP p0, void* p1, float p2,  struct S_PDP (*cb)(struct S_PDP, void*, float)) ;
+EXPORT struct S_PPI f19_S_SPF_PPI(struct S_PPI p0, void* p1, float p2,  struct S_PPI (*cb)(struct S_PPI, void*, float)) ;
+EXPORT struct S_PPF f19_S_SPF_PPF(struct S_PPF p0, void* p1, float p2,  struct S_PPF (*cb)(struct S_PPF, void*, float)) ;
+EXPORT struct S_PPD f19_S_SPF_PPD(struct S_PPD p0, void* p1, float p2,  struct S_PPD (*cb)(struct S_PPD, void*, float)) ;
+EXPORT struct S_PPP f19_S_SPF_PPP(struct S_PPP p0, void* p1, float p2,  struct S_PPP (*cb)(struct S_PPP, void*, float)) ;
+EXPORT struct S_I f19_S_SPD_I(struct S_I p0, void* p1, double p2,  struct S_I (*cb)(struct S_I, void*, double)) ;
+EXPORT struct S_F f19_S_SPD_F(struct S_F p0, void* p1, double p2,  struct S_F (*cb)(struct S_F, void*, double)) ;
+EXPORT struct S_D f19_S_SPD_D(struct S_D p0, void* p1, double p2,  struct S_D (*cb)(struct S_D, void*, double)) ;
+EXPORT struct S_P f19_S_SPD_P(struct S_P p0, void* p1, double p2,  struct S_P (*cb)(struct S_P, void*, double)) ;
+EXPORT struct S_II f19_S_SPD_II(struct S_II p0, void* p1, double p2,  struct S_II (*cb)(struct S_II, void*, double)) ;
+EXPORT struct S_IF f19_S_SPD_IF(struct S_IF p0, void* p1, double p2,  struct S_IF (*cb)(struct S_IF, void*, double)) ;
+EXPORT struct S_ID f19_S_SPD_ID(struct S_ID p0, void* p1, double p2,  struct S_ID (*cb)(struct S_ID, void*, double)) ;
+EXPORT struct S_IP f19_S_SPD_IP(struct S_IP p0, void* p1, double p2,  struct S_IP (*cb)(struct S_IP, void*, double)) ;
+EXPORT struct S_FI f19_S_SPD_FI(struct S_FI p0, void* p1, double p2,  struct S_FI (*cb)(struct S_FI, void*, double)) ;
+EXPORT struct S_FF f19_S_SPD_FF(struct S_FF p0, void* p1, double p2,  struct S_FF (*cb)(struct S_FF, void*, double)) ;
+EXPORT struct S_FD f19_S_SPD_FD(struct S_FD p0, void* p1, double p2,  struct S_FD (*cb)(struct S_FD, void*, double)) ;
+EXPORT struct S_FP f19_S_SPD_FP(struct S_FP p0, void* p1, double p2,  struct S_FP (*cb)(struct S_FP, void*, double)) ;
+EXPORT struct S_DI f19_S_SPD_DI(struct S_DI p0, void* p1, double p2,  struct S_DI (*cb)(struct S_DI, void*, double)) ;
+EXPORT struct S_DF f19_S_SPD_DF(struct S_DF p0, void* p1, double p2,  struct S_DF (*cb)(struct S_DF, void*, double)) ;
+EXPORT struct S_DD f19_S_SPD_DD(struct S_DD p0, void* p1, double p2,  struct S_DD (*cb)(struct S_DD, void*, double)) ;
+EXPORT struct S_DP f19_S_SPD_DP(struct S_DP p0, void* p1, double p2,  struct S_DP (*cb)(struct S_DP, void*, double)) ;
+EXPORT struct S_PI f19_S_SPD_PI(struct S_PI p0, void* p1, double p2,  struct S_PI (*cb)(struct S_PI, void*, double)) ;
+EXPORT struct S_PF f19_S_SPD_PF(struct S_PF p0, void* p1, double p2,  struct S_PF (*cb)(struct S_PF, void*, double)) ;
+EXPORT struct S_PD f19_S_SPD_PD(struct S_PD p0, void* p1, double p2,  struct S_PD (*cb)(struct S_PD, void*, double)) ;
+EXPORT struct S_PP f19_S_SPD_PP(struct S_PP p0, void* p1, double p2,  struct S_PP (*cb)(struct S_PP, void*, double)) ;
+EXPORT struct S_III f19_S_SPD_III(struct S_III p0, void* p1, double p2,  struct S_III (*cb)(struct S_III, void*, double)) ;
+EXPORT struct S_IIF f19_S_SPD_IIF(struct S_IIF p0, void* p1, double p2,  struct S_IIF (*cb)(struct S_IIF, void*, double)) ;
+EXPORT struct S_IID f19_S_SPD_IID(struct S_IID p0, void* p1, double p2,  struct S_IID (*cb)(struct S_IID, void*, double)) ;
+EXPORT struct S_IIP f19_S_SPD_IIP(struct S_IIP p0, void* p1, double p2,  struct S_IIP (*cb)(struct S_IIP, void*, double)) ;
+EXPORT struct S_IFI f19_S_SPD_IFI(struct S_IFI p0, void* p1, double p2,  struct S_IFI (*cb)(struct S_IFI, void*, double)) ;
+EXPORT struct S_IFF f19_S_SPD_IFF(struct S_IFF p0, void* p1, double p2,  struct S_IFF (*cb)(struct S_IFF, void*, double)) ;
+EXPORT struct S_IFD f19_S_SPD_IFD(struct S_IFD p0, void* p1, double p2,  struct S_IFD (*cb)(struct S_IFD, void*, double)) ;
+EXPORT struct S_IFP f19_S_SPD_IFP(struct S_IFP p0, void* p1, double p2,  struct S_IFP (*cb)(struct S_IFP, void*, double)) ;
+EXPORT struct S_IDI f19_S_SPD_IDI(struct S_IDI p0, void* p1, double p2,  struct S_IDI (*cb)(struct S_IDI, void*, double)) ;
+EXPORT struct S_IDF f19_S_SPD_IDF(struct S_IDF p0, void* p1, double p2,  struct S_IDF (*cb)(struct S_IDF, void*, double)) ;
+EXPORT struct S_IDD f19_S_SPD_IDD(struct S_IDD p0, void* p1, double p2,  struct S_IDD (*cb)(struct S_IDD, void*, double)) ;
+EXPORT struct S_IDP f19_S_SPD_IDP(struct S_IDP p0, void* p1, double p2,  struct S_IDP (*cb)(struct S_IDP, void*, double)) ;
+EXPORT struct S_IPI f19_S_SPD_IPI(struct S_IPI p0, void* p1, double p2,  struct S_IPI (*cb)(struct S_IPI, void*, double)) ;
+EXPORT struct S_IPF f19_S_SPD_IPF(struct S_IPF p0, void* p1, double p2,  struct S_IPF (*cb)(struct S_IPF, void*, double)) ;
+EXPORT struct S_IPD f19_S_SPD_IPD(struct S_IPD p0, void* p1, double p2,  struct S_IPD (*cb)(struct S_IPD, void*, double)) ;
+EXPORT struct S_IPP f19_S_SPD_IPP(struct S_IPP p0, void* p1, double p2,  struct S_IPP (*cb)(struct S_IPP, void*, double)) ;
+EXPORT struct S_FII f19_S_SPD_FII(struct S_FII p0, void* p1, double p2,  struct S_FII (*cb)(struct S_FII, void*, double)) ;
+EXPORT struct S_FIF f19_S_SPD_FIF(struct S_FIF p0, void* p1, double p2,  struct S_FIF (*cb)(struct S_FIF, void*, double)) ;
+EXPORT struct S_FID f19_S_SPD_FID(struct S_FID p0, void* p1, double p2,  struct S_FID (*cb)(struct S_FID, void*, double)) ;
+EXPORT struct S_FIP f19_S_SPD_FIP(struct S_FIP p0, void* p1, double p2,  struct S_FIP (*cb)(struct S_FIP, void*, double)) ;
+EXPORT struct S_FFI f19_S_SPD_FFI(struct S_FFI p0, void* p1, double p2,  struct S_FFI (*cb)(struct S_FFI, void*, double)) ;
+EXPORT struct S_FFF f19_S_SPD_FFF(struct S_FFF p0, void* p1, double p2,  struct S_FFF (*cb)(struct S_FFF, void*, double)) ;
+EXPORT struct S_FFD f19_S_SPD_FFD(struct S_FFD p0, void* p1, double p2,  struct S_FFD (*cb)(struct S_FFD, void*, double)) ;
+EXPORT struct S_FFP f19_S_SPD_FFP(struct S_FFP p0, void* p1, double p2,  struct S_FFP (*cb)(struct S_FFP, void*, double)) ;
+EXPORT struct S_FDI f19_S_SPD_FDI(struct S_FDI p0, void* p1, double p2,  struct S_FDI (*cb)(struct S_FDI, void*, double)) ;
+EXPORT struct S_FDF f19_S_SPD_FDF(struct S_FDF p0, void* p1, double p2,  struct S_FDF (*cb)(struct S_FDF, void*, double)) ;
+EXPORT struct S_FDD f19_S_SPD_FDD(struct S_FDD p0, void* p1, double p2,  struct S_FDD (*cb)(struct S_FDD, void*, double)) ;
+EXPORT struct S_FDP f19_S_SPD_FDP(struct S_FDP p0, void* p1, double p2,  struct S_FDP (*cb)(struct S_FDP, void*, double)) ;
+EXPORT struct S_FPI f19_S_SPD_FPI(struct S_FPI p0, void* p1, double p2,  struct S_FPI (*cb)(struct S_FPI, void*, double)) ;
+EXPORT struct S_FPF f19_S_SPD_FPF(struct S_FPF p0, void* p1, double p2,  struct S_FPF (*cb)(struct S_FPF, void*, double)) ;
+EXPORT struct S_FPD f19_S_SPD_FPD(struct S_FPD p0, void* p1, double p2,  struct S_FPD (*cb)(struct S_FPD, void*, double)) ;
+EXPORT struct S_FPP f19_S_SPD_FPP(struct S_FPP p0, void* p1, double p2,  struct S_FPP (*cb)(struct S_FPP, void*, double)) ;
+EXPORT struct S_DII f19_S_SPD_DII(struct S_DII p0, void* p1, double p2,  struct S_DII (*cb)(struct S_DII, void*, double)) ;
+EXPORT struct S_DIF f19_S_SPD_DIF(struct S_DIF p0, void* p1, double p2,  struct S_DIF (*cb)(struct S_DIF, void*, double)) ;
+EXPORT struct S_DID f19_S_SPD_DID(struct S_DID p0, void* p1, double p2,  struct S_DID (*cb)(struct S_DID, void*, double)) ;
+EXPORT struct S_DIP f19_S_SPD_DIP(struct S_DIP p0, void* p1, double p2,  struct S_DIP (*cb)(struct S_DIP, void*, double)) ;
+EXPORT struct S_DFI f19_S_SPD_DFI(struct S_DFI p0, void* p1, double p2,  struct S_DFI (*cb)(struct S_DFI, void*, double)) ;
+EXPORT struct S_DFF f19_S_SPD_DFF(struct S_DFF p0, void* p1, double p2,  struct S_DFF (*cb)(struct S_DFF, void*, double)) ;
+EXPORT struct S_DFD f19_S_SPD_DFD(struct S_DFD p0, void* p1, double p2,  struct S_DFD (*cb)(struct S_DFD, void*, double)) ;
+EXPORT struct S_DFP f19_S_SPD_DFP(struct S_DFP p0, void* p1, double p2,  struct S_DFP (*cb)(struct S_DFP, void*, double)) ;
+EXPORT struct S_DDI f19_S_SPD_DDI(struct S_DDI p0, void* p1, double p2,  struct S_DDI (*cb)(struct S_DDI, void*, double)) ;
+EXPORT struct S_DDF f19_S_SPD_DDF(struct S_DDF p0, void* p1, double p2,  struct S_DDF (*cb)(struct S_DDF, void*, double)) ;
+EXPORT struct S_DDD f19_S_SPD_DDD(struct S_DDD p0, void* p1, double p2,  struct S_DDD (*cb)(struct S_DDD, void*, double)) ;
+EXPORT struct S_DDP f19_S_SPD_DDP(struct S_DDP p0, void* p1, double p2,  struct S_DDP (*cb)(struct S_DDP, void*, double)) ;
+EXPORT struct S_DPI f19_S_SPD_DPI(struct S_DPI p0, void* p1, double p2,  struct S_DPI (*cb)(struct S_DPI, void*, double)) ;
+EXPORT struct S_DPF f19_S_SPD_DPF(struct S_DPF p0, void* p1, double p2,  struct S_DPF (*cb)(struct S_DPF, void*, double)) ;
+EXPORT struct S_DPD f19_S_SPD_DPD(struct S_DPD p0, void* p1, double p2,  struct S_DPD (*cb)(struct S_DPD, void*, double)) ;
+EXPORT struct S_DPP f19_S_SPD_DPP(struct S_DPP p0, void* p1, double p2,  struct S_DPP (*cb)(struct S_DPP, void*, double)) ;
+EXPORT struct S_PII f19_S_SPD_PII(struct S_PII p0, void* p1, double p2,  struct S_PII (*cb)(struct S_PII, void*, double)) ;
+EXPORT struct S_PIF f19_S_SPD_PIF(struct S_PIF p0, void* p1, double p2,  struct S_PIF (*cb)(struct S_PIF, void*, double)) ;
+EXPORT struct S_PID f19_S_SPD_PID(struct S_PID p0, void* p1, double p2,  struct S_PID (*cb)(struct S_PID, void*, double)) ;
+EXPORT struct S_PIP f19_S_SPD_PIP(struct S_PIP p0, void* p1, double p2,  struct S_PIP (*cb)(struct S_PIP, void*, double)) ;
+EXPORT struct S_PFI f19_S_SPD_PFI(struct S_PFI p0, void* p1, double p2,  struct S_PFI (*cb)(struct S_PFI, void*, double)) ;
+EXPORT struct S_PFF f19_S_SPD_PFF(struct S_PFF p0, void* p1, double p2,  struct S_PFF (*cb)(struct S_PFF, void*, double)) ;
+EXPORT struct S_PFD f19_S_SPD_PFD(struct S_PFD p0, void* p1, double p2,  struct S_PFD (*cb)(struct S_PFD, void*, double)) ;
+EXPORT struct S_PFP f19_S_SPD_PFP(struct S_PFP p0, void* p1, double p2,  struct S_PFP (*cb)(struct S_PFP, void*, double)) ;
+EXPORT struct S_PDI f19_S_SPD_PDI(struct S_PDI p0, void* p1, double p2,  struct S_PDI (*cb)(struct S_PDI, void*, double)) ;
+EXPORT struct S_PDF f19_S_SPD_PDF(struct S_PDF p0, void* p1, double p2,  struct S_PDF (*cb)(struct S_PDF, void*, double)) ;
+EXPORT struct S_PDD f19_S_SPD_PDD(struct S_PDD p0, void* p1, double p2,  struct S_PDD (*cb)(struct S_PDD, void*, double)) ;
+EXPORT struct S_PDP f19_S_SPD_PDP(struct S_PDP p0, void* p1, double p2,  struct S_PDP (*cb)(struct S_PDP, void*, double)) ;
+EXPORT struct S_PPI f19_S_SPD_PPI(struct S_PPI p0, void* p1, double p2,  struct S_PPI (*cb)(struct S_PPI, void*, double)) ;
+EXPORT struct S_PPF f19_S_SPD_PPF(struct S_PPF p0, void* p1, double p2,  struct S_PPF (*cb)(struct S_PPF, void*, double)) ;
+EXPORT struct S_PPD f19_S_SPD_PPD(struct S_PPD p0, void* p1, double p2,  struct S_PPD (*cb)(struct S_PPD, void*, double)) ;
+EXPORT struct S_PPP f19_S_SPD_PPP(struct S_PPP p0, void* p1, double p2,  struct S_PPP (*cb)(struct S_PPP, void*, double)) ;
+EXPORT struct S_I f19_S_SPP_I(struct S_I p0, void* p1, void* p2,  struct S_I (*cb)(struct S_I, void*, void*)) ;
+EXPORT struct S_F f19_S_SPP_F(struct S_F p0, void* p1, void* p2,  struct S_F (*cb)(struct S_F, void*, void*)) ;
+EXPORT struct S_D f19_S_SPP_D(struct S_D p0, void* p1, void* p2,  struct S_D (*cb)(struct S_D, void*, void*)) ;
+EXPORT struct S_P f19_S_SPP_P(struct S_P p0, void* p1, void* p2,  struct S_P (*cb)(struct S_P, void*, void*)) ;
+EXPORT struct S_II f19_S_SPP_II(struct S_II p0, void* p1, void* p2,  struct S_II (*cb)(struct S_II, void*, void*)) ;
+EXPORT struct S_IF f19_S_SPP_IF(struct S_IF p0, void* p1, void* p2,  struct S_IF (*cb)(struct S_IF, void*, void*)) ;
+EXPORT struct S_ID f19_S_SPP_ID(struct S_ID p0, void* p1, void* p2,  struct S_ID (*cb)(struct S_ID, void*, void*)) ;
+EXPORT struct S_IP f19_S_SPP_IP(struct S_IP p0, void* p1, void* p2,  struct S_IP (*cb)(struct S_IP, void*, void*)) ;
+EXPORT struct S_FI f19_S_SPP_FI(struct S_FI p0, void* p1, void* p2,  struct S_FI (*cb)(struct S_FI, void*, void*)) ;
+EXPORT struct S_FF f19_S_SPP_FF(struct S_FF p0, void* p1, void* p2,  struct S_FF (*cb)(struct S_FF, void*, void*)) ;
+EXPORT struct S_FD f19_S_SPP_FD(struct S_FD p0, void* p1, void* p2,  struct S_FD (*cb)(struct S_FD, void*, void*)) ;
+EXPORT struct S_FP f19_S_SPP_FP(struct S_FP p0, void* p1, void* p2,  struct S_FP (*cb)(struct S_FP, void*, void*)) ;
+EXPORT struct S_DI f19_S_SPP_DI(struct S_DI p0, void* p1, void* p2,  struct S_DI (*cb)(struct S_DI, void*, void*)) ;
+EXPORT struct S_DF f19_S_SPP_DF(struct S_DF p0, void* p1, void* p2,  struct S_DF (*cb)(struct S_DF, void*, void*)) ;
+EXPORT struct S_DD f19_S_SPP_DD(struct S_DD p0, void* p1, void* p2,  struct S_DD (*cb)(struct S_DD, void*, void*)) ;
+EXPORT struct S_DP f19_S_SPP_DP(struct S_DP p0, void* p1, void* p2,  struct S_DP (*cb)(struct S_DP, void*, void*)) ;
+EXPORT struct S_PI f19_S_SPP_PI(struct S_PI p0, void* p1, void* p2,  struct S_PI (*cb)(struct S_PI, void*, void*)) ;
+EXPORT struct S_PF f19_S_SPP_PF(struct S_PF p0, void* p1, void* p2,  struct S_PF (*cb)(struct S_PF, void*, void*)) ;
+EXPORT struct S_PD f19_S_SPP_PD(struct S_PD p0, void* p1, void* p2,  struct S_PD (*cb)(struct S_PD, void*, void*)) ;
+EXPORT struct S_PP f19_S_SPP_PP(struct S_PP p0, void* p1, void* p2,  struct S_PP (*cb)(struct S_PP, void*, void*)) ;
+EXPORT struct S_III f19_S_SPP_III(struct S_III p0, void* p1, void* p2,  struct S_III (*cb)(struct S_III, void*, void*)) ;
+EXPORT struct S_IIF f19_S_SPP_IIF(struct S_IIF p0, void* p1, void* p2,  struct S_IIF (*cb)(struct S_IIF, void*, void*)) ;
+EXPORT struct S_IID f19_S_SPP_IID(struct S_IID p0, void* p1, void* p2,  struct S_IID (*cb)(struct S_IID, void*, void*)) ;
+EXPORT struct S_IIP f19_S_SPP_IIP(struct S_IIP p0, void* p1, void* p2,  struct S_IIP (*cb)(struct S_IIP, void*, void*)) ;
+EXPORT struct S_IFI f19_S_SPP_IFI(struct S_IFI p0, void* p1, void* p2,  struct S_IFI (*cb)(struct S_IFI, void*, void*)) ;
+EXPORT struct S_IFF f19_S_SPP_IFF(struct S_IFF p0, void* p1, void* p2,  struct S_IFF (*cb)(struct S_IFF, void*, void*)) ;
+EXPORT struct S_IFD f19_S_SPP_IFD(struct S_IFD p0, void* p1, void* p2,  struct S_IFD (*cb)(struct S_IFD, void*, void*)) ;
+EXPORT struct S_IFP f19_S_SPP_IFP(struct S_IFP p0, void* p1, void* p2,  struct S_IFP (*cb)(struct S_IFP, void*, void*)) ;
+EXPORT struct S_IDI f19_S_SPP_IDI(struct S_IDI p0, void* p1, void* p2,  struct S_IDI (*cb)(struct S_IDI, void*, void*)) ;
+EXPORT struct S_IDF f19_S_SPP_IDF(struct S_IDF p0, void* p1, void* p2,  struct S_IDF (*cb)(struct S_IDF, void*, void*)) ;
+EXPORT struct S_IDD f19_S_SPP_IDD(struct S_IDD p0, void* p1, void* p2,  struct S_IDD (*cb)(struct S_IDD, void*, void*)) ;
+EXPORT struct S_IDP f19_S_SPP_IDP(struct S_IDP p0, void* p1, void* p2,  struct S_IDP (*cb)(struct S_IDP, void*, void*)) ;
+EXPORT struct S_IPI f19_S_SPP_IPI(struct S_IPI p0, void* p1, void* p2,  struct S_IPI (*cb)(struct S_IPI, void*, void*)) ;
+EXPORT struct S_IPF f19_S_SPP_IPF(struct S_IPF p0, void* p1, void* p2,  struct S_IPF (*cb)(struct S_IPF, void*, void*)) ;
+EXPORT struct S_IPD f19_S_SPP_IPD(struct S_IPD p0, void* p1, void* p2,  struct S_IPD (*cb)(struct S_IPD, void*, void*)) ;
+EXPORT struct S_IPP f19_S_SPP_IPP(struct S_IPP p0, void* p1, void* p2,  struct S_IPP (*cb)(struct S_IPP, void*, void*)) ;
+EXPORT struct S_FII f19_S_SPP_FII(struct S_FII p0, void* p1, void* p2,  struct S_FII (*cb)(struct S_FII, void*, void*)) ;
+EXPORT struct S_FIF f19_S_SPP_FIF(struct S_FIF p0, void* p1, void* p2,  struct S_FIF (*cb)(struct S_FIF, void*, void*)) ;
+EXPORT struct S_FID f19_S_SPP_FID(struct S_FID p0, void* p1, void* p2,  struct S_FID (*cb)(struct S_FID, void*, void*)) ;
+EXPORT struct S_FIP f19_S_SPP_FIP(struct S_FIP p0, void* p1, void* p2,  struct S_FIP (*cb)(struct S_FIP, void*, void*)) ;
+EXPORT struct S_FFI f19_S_SPP_FFI(struct S_FFI p0, void* p1, void* p2,  struct S_FFI (*cb)(struct S_FFI, void*, void*)) ;
+EXPORT struct S_FFF f19_S_SPP_FFF(struct S_FFF p0, void* p1, void* p2,  struct S_FFF (*cb)(struct S_FFF, void*, void*)) ;
+EXPORT struct S_FFD f19_S_SPP_FFD(struct S_FFD p0, void* p1, void* p2,  struct S_FFD (*cb)(struct S_FFD, void*, void*)) ;
+EXPORT struct S_FFP f19_S_SPP_FFP(struct S_FFP p0, void* p1, void* p2,  struct S_FFP (*cb)(struct S_FFP, void*, void*)) ;
+EXPORT struct S_FDI f19_S_SPP_FDI(struct S_FDI p0, void* p1, void* p2,  struct S_FDI (*cb)(struct S_FDI, void*, void*)) ;
+EXPORT struct S_FDF f19_S_SPP_FDF(struct S_FDF p0, void* p1, void* p2,  struct S_FDF (*cb)(struct S_FDF, void*, void*)) ;
+EXPORT struct S_FDD f19_S_SPP_FDD(struct S_FDD p0, void* p1, void* p2,  struct S_FDD (*cb)(struct S_FDD, void*, void*)) ;
+EXPORT struct S_FDP f19_S_SPP_FDP(struct S_FDP p0, void* p1, void* p2,  struct S_FDP (*cb)(struct S_FDP, void*, void*)) ;
+EXPORT struct S_FPI f19_S_SPP_FPI(struct S_FPI p0, void* p1, void* p2,  struct S_FPI (*cb)(struct S_FPI, void*, void*)) ;
+EXPORT struct S_FPF f19_S_SPP_FPF(struct S_FPF p0, void* p1, void* p2,  struct S_FPF (*cb)(struct S_FPF, void*, void*)) ;
+EXPORT struct S_FPD f19_S_SPP_FPD(struct S_FPD p0, void* p1, void* p2,  struct S_FPD (*cb)(struct S_FPD, void*, void*)) ;
+EXPORT struct S_FPP f19_S_SPP_FPP(struct S_FPP p0, void* p1, void* p2,  struct S_FPP (*cb)(struct S_FPP, void*, void*)) ;
+EXPORT struct S_DII f19_S_SPP_DII(struct S_DII p0, void* p1, void* p2,  struct S_DII (*cb)(struct S_DII, void*, void*)) ;
+EXPORT struct S_DIF f19_S_SPP_DIF(struct S_DIF p0, void* p1, void* p2,  struct S_DIF (*cb)(struct S_DIF, void*, void*)) ;
+EXPORT struct S_DID f19_S_SPP_DID(struct S_DID p0, void* p1, void* p2,  struct S_DID (*cb)(struct S_DID, void*, void*)) ;
+EXPORT struct S_DIP f19_S_SPP_DIP(struct S_DIP p0, void* p1, void* p2,  struct S_DIP (*cb)(struct S_DIP, void*, void*)) ;
+EXPORT struct S_DFI f19_S_SPP_DFI(struct S_DFI p0, void* p1, void* p2,  struct S_DFI (*cb)(struct S_DFI, void*, void*)) ;
+EXPORT struct S_DFF f19_S_SPP_DFF(struct S_DFF p0, void* p1, void* p2,  struct S_DFF (*cb)(struct S_DFF, void*, void*)) ;
+EXPORT struct S_DFD f19_S_SPP_DFD(struct S_DFD p0, void* p1, void* p2,  struct S_DFD (*cb)(struct S_DFD, void*, void*)) ;
+EXPORT struct S_DFP f19_S_SPP_DFP(struct S_DFP p0, void* p1, void* p2,  struct S_DFP (*cb)(struct S_DFP, void*, void*)) ;
+EXPORT struct S_DDI f19_S_SPP_DDI(struct S_DDI p0, void* p1, void* p2,  struct S_DDI (*cb)(struct S_DDI, void*, void*)) ;
+EXPORT struct S_DDF f19_S_SPP_DDF(struct S_DDF p0, void* p1, void* p2,  struct S_DDF (*cb)(struct S_DDF, void*, void*)) ;
+EXPORT struct S_DDD f19_S_SPP_DDD(struct S_DDD p0, void* p1, void* p2,  struct S_DDD (*cb)(struct S_DDD, void*, void*)) ;
+EXPORT struct S_DDP f19_S_SPP_DDP(struct S_DDP p0, void* p1, void* p2,  struct S_DDP (*cb)(struct S_DDP, void*, void*)) ;
+EXPORT struct S_DPI f19_S_SPP_DPI(struct S_DPI p0, void* p1, void* p2,  struct S_DPI (*cb)(struct S_DPI, void*, void*)) ;
+EXPORT struct S_DPF f19_S_SPP_DPF(struct S_DPF p0, void* p1, void* p2,  struct S_DPF (*cb)(struct S_DPF, void*, void*)) ;
+EXPORT struct S_DPD f19_S_SPP_DPD(struct S_DPD p0, void* p1, void* p2,  struct S_DPD (*cb)(struct S_DPD, void*, void*)) ;
+EXPORT struct S_DPP f19_S_SPP_DPP(struct S_DPP p0, void* p1, void* p2,  struct S_DPP (*cb)(struct S_DPP, void*, void*)) ;
+EXPORT struct S_PII f19_S_SPP_PII(struct S_PII p0, void* p1, void* p2,  struct S_PII (*cb)(struct S_PII, void*, void*)) ;
+EXPORT struct S_PIF f19_S_SPP_PIF(struct S_PIF p0, void* p1, void* p2,  struct S_PIF (*cb)(struct S_PIF, void*, void*)) ;
+EXPORT struct S_PID f19_S_SPP_PID(struct S_PID p0, void* p1, void* p2,  struct S_PID (*cb)(struct S_PID, void*, void*)) ;
+EXPORT struct S_PIP f19_S_SPP_PIP(struct S_PIP p0, void* p1, void* p2,  struct S_PIP (*cb)(struct S_PIP, void*, void*)) ;
+EXPORT struct S_PFI f19_S_SPP_PFI(struct S_PFI p0, void* p1, void* p2,  struct S_PFI (*cb)(struct S_PFI, void*, void*)) ;
+EXPORT struct S_PFF f19_S_SPP_PFF(struct S_PFF p0, void* p1, void* p2,  struct S_PFF (*cb)(struct S_PFF, void*, void*)) ;
+EXPORT struct S_PFD f19_S_SPP_PFD(struct S_PFD p0, void* p1, void* p2,  struct S_PFD (*cb)(struct S_PFD, void*, void*)) ;
+EXPORT struct S_PFP f19_S_SPP_PFP(struct S_PFP p0, void* p1, void* p2,  struct S_PFP (*cb)(struct S_PFP, void*, void*)) ;
+EXPORT struct S_PDI f19_S_SPP_PDI(struct S_PDI p0, void* p1, void* p2,  struct S_PDI (*cb)(struct S_PDI, void*, void*)) ;
+EXPORT struct S_PDF f19_S_SPP_PDF(struct S_PDF p0, void* p1, void* p2,  struct S_PDF (*cb)(struct S_PDF, void*, void*)) ;
+EXPORT struct S_PDD f19_S_SPP_PDD(struct S_PDD p0, void* p1, void* p2,  struct S_PDD (*cb)(struct S_PDD, void*, void*)) ;
+EXPORT struct S_PDP f19_S_SPP_PDP(struct S_PDP p0, void* p1, void* p2,  struct S_PDP (*cb)(struct S_PDP, void*, void*)) ;
+EXPORT struct S_PPI f19_S_SPP_PPI(struct S_PPI p0, void* p1, void* p2,  struct S_PPI (*cb)(struct S_PPI, void*, void*)) ;
+EXPORT struct S_PPF f19_S_SPP_PPF(struct S_PPF p0, void* p1, void* p2,  struct S_PPF (*cb)(struct S_PPF, void*, void*)) ;
+EXPORT struct S_PPD f19_S_SPP_PPD(struct S_PPD p0, void* p1, void* p2,  struct S_PPD (*cb)(struct S_PPD, void*, void*)) ;
+EXPORT struct S_PPP f19_S_SPP_PPP(struct S_PPP p0, void* p1, void* p2,  struct S_PPP (*cb)(struct S_PPP, void*, void*)) ;
+EXPORT struct S_I f19_S_SPS_I(struct S_I p0, void* p1, struct S_I p2,  struct S_I (*cb)(struct S_I, void*, struct S_I)) ;
+EXPORT struct S_F f19_S_SPS_F(struct S_F p0, void* p1, struct S_F p2,  struct S_F (*cb)(struct S_F, void*, struct S_F)) ;
+EXPORT struct S_D f19_S_SPS_D(struct S_D p0, void* p1, struct S_D p2,  struct S_D (*cb)(struct S_D, void*, struct S_D)) ;
+EXPORT struct S_P f19_S_SPS_P(struct S_P p0, void* p1, struct S_P p2,  struct S_P (*cb)(struct S_P, void*, struct S_P)) ;
+EXPORT struct S_II f19_S_SPS_II(struct S_II p0, void* p1, struct S_II p2,  struct S_II (*cb)(struct S_II, void*, struct S_II)) ;
+EXPORT struct S_IF f19_S_SPS_IF(struct S_IF p0, void* p1, struct S_IF p2,  struct S_IF (*cb)(struct S_IF, void*, struct S_IF)) ;
+EXPORT struct S_ID f19_S_SPS_ID(struct S_ID p0, void* p1, struct S_ID p2,  struct S_ID (*cb)(struct S_ID, void*, struct S_ID)) ;
+EXPORT struct S_IP f19_S_SPS_IP(struct S_IP p0, void* p1, struct S_IP p2,  struct S_IP (*cb)(struct S_IP, void*, struct S_IP)) ;
+EXPORT struct S_FI f19_S_SPS_FI(struct S_FI p0, void* p1, struct S_FI p2,  struct S_FI (*cb)(struct S_FI, void*, struct S_FI)) ;
+EXPORT struct S_FF f19_S_SPS_FF(struct S_FF p0, void* p1, struct S_FF p2,  struct S_FF (*cb)(struct S_FF, void*, struct S_FF)) ;
+EXPORT struct S_FD f19_S_SPS_FD(struct S_FD p0, void* p1, struct S_FD p2,  struct S_FD (*cb)(struct S_FD, void*, struct S_FD)) ;
+EXPORT struct S_FP f19_S_SPS_FP(struct S_FP p0, void* p1, struct S_FP p2,  struct S_FP (*cb)(struct S_FP, void*, struct S_FP)) ;
+EXPORT struct S_DI f19_S_SPS_DI(struct S_DI p0, void* p1, struct S_DI p2,  struct S_DI (*cb)(struct S_DI, void*, struct S_DI)) ;
+EXPORT struct S_DF f19_S_SPS_DF(struct S_DF p0, void* p1, struct S_DF p2,  struct S_DF (*cb)(struct S_DF, void*, struct S_DF)) ;
+EXPORT struct S_DD f19_S_SPS_DD(struct S_DD p0, void* p1, struct S_DD p2,  struct S_DD (*cb)(struct S_DD, void*, struct S_DD)) ;
+EXPORT struct S_DP f19_S_SPS_DP(struct S_DP p0, void* p1, struct S_DP p2,  struct S_DP (*cb)(struct S_DP, void*, struct S_DP)) ;
+EXPORT struct S_PI f19_S_SPS_PI(struct S_PI p0, void* p1, struct S_PI p2,  struct S_PI (*cb)(struct S_PI, void*, struct S_PI)) ;
+EXPORT struct S_PF f19_S_SPS_PF(struct S_PF p0, void* p1, struct S_PF p2,  struct S_PF (*cb)(struct S_PF, void*, struct S_PF)) ;
+EXPORT struct S_PD f19_S_SPS_PD(struct S_PD p0, void* p1, struct S_PD p2,  struct S_PD (*cb)(struct S_PD, void*, struct S_PD)) ;
+EXPORT struct S_PP f19_S_SPS_PP(struct S_PP p0, void* p1, struct S_PP p2,  struct S_PP (*cb)(struct S_PP, void*, struct S_PP)) ;
+EXPORT struct S_III f19_S_SPS_III(struct S_III p0, void* p1, struct S_III p2,  struct S_III (*cb)(struct S_III, void*, struct S_III)) ;
+EXPORT struct S_IIF f19_S_SPS_IIF(struct S_IIF p0, void* p1, struct S_IIF p2,  struct S_IIF (*cb)(struct S_IIF, void*, struct S_IIF)) ;
+EXPORT struct S_IID f19_S_SPS_IID(struct S_IID p0, void* p1, struct S_IID p2,  struct S_IID (*cb)(struct S_IID, void*, struct S_IID)) ;
+EXPORT struct S_IIP f19_S_SPS_IIP(struct S_IIP p0, void* p1, struct S_IIP p2,  struct S_IIP (*cb)(struct S_IIP, void*, struct S_IIP)) ;
+EXPORT struct S_IFI f19_S_SPS_IFI(struct S_IFI p0, void* p1, struct S_IFI p2,  struct S_IFI (*cb)(struct S_IFI, void*, struct S_IFI)) ;
+EXPORT struct S_IFF f19_S_SPS_IFF(struct S_IFF p0, void* p1, struct S_IFF p2,  struct S_IFF (*cb)(struct S_IFF, void*, struct S_IFF)) ;
+EXPORT struct S_IFD f19_S_SPS_IFD(struct S_IFD p0, void* p1, struct S_IFD p2,  struct S_IFD (*cb)(struct S_IFD, void*, struct S_IFD)) ;
+EXPORT struct S_IFP f19_S_SPS_IFP(struct S_IFP p0, void* p1, struct S_IFP p2,  struct S_IFP (*cb)(struct S_IFP, void*, struct S_IFP)) ;
+EXPORT struct S_IDI f19_S_SPS_IDI(struct S_IDI p0, void* p1, struct S_IDI p2,  struct S_IDI (*cb)(struct S_IDI, void*, struct S_IDI)) ;
+EXPORT struct S_IDF f19_S_SPS_IDF(struct S_IDF p0, void* p1, struct S_IDF p2,  struct S_IDF (*cb)(struct S_IDF, void*, struct S_IDF)) ;
+EXPORT struct S_IDD f19_S_SPS_IDD(struct S_IDD p0, void* p1, struct S_IDD p2,  struct S_IDD (*cb)(struct S_IDD, void*, struct S_IDD)) ;
+EXPORT struct S_IDP f19_S_SPS_IDP(struct S_IDP p0, void* p1, struct S_IDP p2,  struct S_IDP (*cb)(struct S_IDP, void*, struct S_IDP)) ;
+EXPORT struct S_IPI f19_S_SPS_IPI(struct S_IPI p0, void* p1, struct S_IPI p2,  struct S_IPI (*cb)(struct S_IPI, void*, struct S_IPI)) ;
+EXPORT struct S_IPF f19_S_SPS_IPF(struct S_IPF p0, void* p1, struct S_IPF p2,  struct S_IPF (*cb)(struct S_IPF, void*, struct S_IPF)) ;
+EXPORT struct S_IPD f19_S_SPS_IPD(struct S_IPD p0, void* p1, struct S_IPD p2,  struct S_IPD (*cb)(struct S_IPD, void*, struct S_IPD)) ;
+EXPORT struct S_IPP f19_S_SPS_IPP(struct S_IPP p0, void* p1, struct S_IPP p2,  struct S_IPP (*cb)(struct S_IPP, void*, struct S_IPP)) ;
+EXPORT struct S_FII f19_S_SPS_FII(struct S_FII p0, void* p1, struct S_FII p2,  struct S_FII (*cb)(struct S_FII, void*, struct S_FII)) ;
+EXPORT struct S_FIF f19_S_SPS_FIF(struct S_FIF p0, void* p1, struct S_FIF p2,  struct S_FIF (*cb)(struct S_FIF, void*, struct S_FIF)) ;
+EXPORT struct S_FID f19_S_SPS_FID(struct S_FID p0, void* p1, struct S_FID p2,  struct S_FID (*cb)(struct S_FID, void*, struct S_FID)) ;
+EXPORT struct S_FIP f19_S_SPS_FIP(struct S_FIP p0, void* p1, struct S_FIP p2,  struct S_FIP (*cb)(struct S_FIP, void*, struct S_FIP)) ;
+EXPORT struct S_FFI f19_S_SPS_FFI(struct S_FFI p0, void* p1, struct S_FFI p2,  struct S_FFI (*cb)(struct S_FFI, void*, struct S_FFI)) ;
+EXPORT struct S_FFF f19_S_SPS_FFF(struct S_FFF p0, void* p1, struct S_FFF p2,  struct S_FFF (*cb)(struct S_FFF, void*, struct S_FFF)) ;
+EXPORT struct S_FFD f19_S_SPS_FFD(struct S_FFD p0, void* p1, struct S_FFD p2,  struct S_FFD (*cb)(struct S_FFD, void*, struct S_FFD)) ;
+EXPORT struct S_FFP f19_S_SPS_FFP(struct S_FFP p0, void* p1, struct S_FFP p2,  struct S_FFP (*cb)(struct S_FFP, void*, struct S_FFP)) ;
+EXPORT struct S_FDI f19_S_SPS_FDI(struct S_FDI p0, void* p1, struct S_FDI p2,  struct S_FDI (*cb)(struct S_FDI, void*, struct S_FDI)) ;
+EXPORT struct S_FDF f19_S_SPS_FDF(struct S_FDF p0, void* p1, struct S_FDF p2,  struct S_FDF (*cb)(struct S_FDF, void*, struct S_FDF)) ;
+EXPORT struct S_FDD f19_S_SPS_FDD(struct S_FDD p0, void* p1, struct S_FDD p2,  struct S_FDD (*cb)(struct S_FDD, void*, struct S_FDD)) ;
+EXPORT struct S_FDP f19_S_SPS_FDP(struct S_FDP p0, void* p1, struct S_FDP p2,  struct S_FDP (*cb)(struct S_FDP, void*, struct S_FDP)) ;
+EXPORT struct S_FPI f19_S_SPS_FPI(struct S_FPI p0, void* p1, struct S_FPI p2,  struct S_FPI (*cb)(struct S_FPI, void*, struct S_FPI)) ;
+EXPORT struct S_FPF f19_S_SPS_FPF(struct S_FPF p0, void* p1, struct S_FPF p2,  struct S_FPF (*cb)(struct S_FPF, void*, struct S_FPF)) ;
+EXPORT struct S_FPD f19_S_SPS_FPD(struct S_FPD p0, void* p1, struct S_FPD p2,  struct S_FPD (*cb)(struct S_FPD, void*, struct S_FPD)) ;
+EXPORT struct S_FPP f19_S_SPS_FPP(struct S_FPP p0, void* p1, struct S_FPP p2,  struct S_FPP (*cb)(struct S_FPP, void*, struct S_FPP)) ;
+EXPORT struct S_DII f19_S_SPS_DII(struct S_DII p0, void* p1, struct S_DII p2,  struct S_DII (*cb)(struct S_DII, void*, struct S_DII)) ;
+EXPORT struct S_DIF f19_S_SPS_DIF(struct S_DIF p0, void* p1, struct S_DIF p2,  struct S_DIF (*cb)(struct S_DIF, void*, struct S_DIF)) ;
+EXPORT struct S_DID f19_S_SPS_DID(struct S_DID p0, void* p1, struct S_DID p2,  struct S_DID (*cb)(struct S_DID, void*, struct S_DID)) ;
+EXPORT struct S_DIP f19_S_SPS_DIP(struct S_DIP p0, void* p1, struct S_DIP p2,  struct S_DIP (*cb)(struct S_DIP, void*, struct S_DIP)) ;
+EXPORT struct S_DFI f19_S_SPS_DFI(struct S_DFI p0, void* p1, struct S_DFI p2,  struct S_DFI (*cb)(struct S_DFI, void*, struct S_DFI)) ;
+EXPORT struct S_DFF f19_S_SPS_DFF(struct S_DFF p0, void* p1, struct S_DFF p2,  struct S_DFF (*cb)(struct S_DFF, void*, struct S_DFF)) ;
+EXPORT struct S_DFD f19_S_SPS_DFD(struct S_DFD p0, void* p1, struct S_DFD p2,  struct S_DFD (*cb)(struct S_DFD, void*, struct S_DFD)) ;
+EXPORT struct S_DFP f19_S_SPS_DFP(struct S_DFP p0, void* p1, struct S_DFP p2,  struct S_DFP (*cb)(struct S_DFP, void*, struct S_DFP)) ;
+EXPORT struct S_DDI f19_S_SPS_DDI(struct S_DDI p0, void* p1, struct S_DDI p2,  struct S_DDI (*cb)(struct S_DDI, void*, struct S_DDI)) ;
+EXPORT struct S_DDF f19_S_SPS_DDF(struct S_DDF p0, void* p1, struct S_DDF p2,  struct S_DDF (*cb)(struct S_DDF, void*, struct S_DDF)) ;
+EXPORT struct S_DDD f19_S_SPS_DDD(struct S_DDD p0, void* p1, struct S_DDD p2,  struct S_DDD (*cb)(struct S_DDD, void*, struct S_DDD)) ;
+EXPORT struct S_DDP f19_S_SPS_DDP(struct S_DDP p0, void* p1, struct S_DDP p2,  struct S_DDP (*cb)(struct S_DDP, void*, struct S_DDP)) ;
+EXPORT struct S_DPI f19_S_SPS_DPI(struct S_DPI p0, void* p1, struct S_DPI p2,  struct S_DPI (*cb)(struct S_DPI, void*, struct S_DPI)) ;
+EXPORT struct S_DPF f19_S_SPS_DPF(struct S_DPF p0, void* p1, struct S_DPF p2,  struct S_DPF (*cb)(struct S_DPF, void*, struct S_DPF)) ;
+EXPORT struct S_DPD f19_S_SPS_DPD(struct S_DPD p0, void* p1, struct S_DPD p2,  struct S_DPD (*cb)(struct S_DPD, void*, struct S_DPD)) ;
+EXPORT struct S_DPP f19_S_SPS_DPP(struct S_DPP p0, void* p1, struct S_DPP p2,  struct S_DPP (*cb)(struct S_DPP, void*, struct S_DPP)) ;
+EXPORT struct S_PII f19_S_SPS_PII(struct S_PII p0, void* p1, struct S_PII p2,  struct S_PII (*cb)(struct S_PII, void*, struct S_PII)) ;
+EXPORT struct S_PIF f19_S_SPS_PIF(struct S_PIF p0, void* p1, struct S_PIF p2,  struct S_PIF (*cb)(struct S_PIF, void*, struct S_PIF)) ;
+EXPORT struct S_PID f19_S_SPS_PID(struct S_PID p0, void* p1, struct S_PID p2,  struct S_PID (*cb)(struct S_PID, void*, struct S_PID)) ;
+EXPORT struct S_PIP f19_S_SPS_PIP(struct S_PIP p0, void* p1, struct S_PIP p2,  struct S_PIP (*cb)(struct S_PIP, void*, struct S_PIP)) ;
+EXPORT struct S_PFI f19_S_SPS_PFI(struct S_PFI p0, void* p1, struct S_PFI p2,  struct S_PFI (*cb)(struct S_PFI, void*, struct S_PFI)) ;
+EXPORT struct S_PFF f19_S_SPS_PFF(struct S_PFF p0, void* p1, struct S_PFF p2,  struct S_PFF (*cb)(struct S_PFF, void*, struct S_PFF)) ;
+EXPORT struct S_PFD f19_S_SPS_PFD(struct S_PFD p0, void* p1, struct S_PFD p2,  struct S_PFD (*cb)(struct S_PFD, void*, struct S_PFD)) ;
+EXPORT struct S_PFP f19_S_SPS_PFP(struct S_PFP p0, void* p1, struct S_PFP p2,  struct S_PFP (*cb)(struct S_PFP, void*, struct S_PFP)) ;
+EXPORT struct S_PDI f19_S_SPS_PDI(struct S_PDI p0, void* p1, struct S_PDI p2,  struct S_PDI (*cb)(struct S_PDI, void*, struct S_PDI)) ;
+EXPORT struct S_PDF f19_S_SPS_PDF(struct S_PDF p0, void* p1, struct S_PDF p2,  struct S_PDF (*cb)(struct S_PDF, void*, struct S_PDF)) ;
+EXPORT struct S_PDD f19_S_SPS_PDD(struct S_PDD p0, void* p1, struct S_PDD p2,  struct S_PDD (*cb)(struct S_PDD, void*, struct S_PDD)) ;
+EXPORT struct S_PDP f19_S_SPS_PDP(struct S_PDP p0, void* p1, struct S_PDP p2,  struct S_PDP (*cb)(struct S_PDP, void*, struct S_PDP)) ;
+EXPORT struct S_PPI f19_S_SPS_PPI(struct S_PPI p0, void* p1, struct S_PPI p2,  struct S_PPI (*cb)(struct S_PPI, void*, struct S_PPI)) ;
+EXPORT struct S_PPF f19_S_SPS_PPF(struct S_PPF p0, void* p1, struct S_PPF p2,  struct S_PPF (*cb)(struct S_PPF, void*, struct S_PPF)) ;
+EXPORT struct S_PPD f19_S_SPS_PPD(struct S_PPD p0, void* p1, struct S_PPD p2,  struct S_PPD (*cb)(struct S_PPD, void*, struct S_PPD)) ;
+EXPORT struct S_PPP f19_S_SPS_PPP(struct S_PPP p0, void* p1, struct S_PPP p2,  struct S_PPP (*cb)(struct S_PPP, void*, struct S_PPP)) ;
+EXPORT struct S_I f19_S_SSI_I(struct S_I p0, struct S_I p1, int p2,  struct S_I (*cb)(struct S_I, struct S_I, int)) ;
+EXPORT struct S_F f19_S_SSI_F(struct S_F p0, struct S_F p1, int p2,  struct S_F (*cb)(struct S_F, struct S_F, int)) ;
+EXPORT struct S_D f19_S_SSI_D(struct S_D p0, struct S_D p1, int p2,  struct S_D (*cb)(struct S_D, struct S_D, int)) ;
+EXPORT struct S_P f19_S_SSI_P(struct S_P p0, struct S_P p1, int p2,  struct S_P (*cb)(struct S_P, struct S_P, int)) ;
+EXPORT struct S_II f19_S_SSI_II(struct S_II p0, struct S_II p1, int p2,  struct S_II (*cb)(struct S_II, struct S_II, int)) ;
+EXPORT struct S_IF f19_S_SSI_IF(struct S_IF p0, struct S_IF p1, int p2,  struct S_IF (*cb)(struct S_IF, struct S_IF, int)) ;
+EXPORT struct S_ID f19_S_SSI_ID(struct S_ID p0, struct S_ID p1, int p2,  struct S_ID (*cb)(struct S_ID, struct S_ID, int)) ;
+EXPORT struct S_IP f19_S_SSI_IP(struct S_IP p0, struct S_IP p1, int p2,  struct S_IP (*cb)(struct S_IP, struct S_IP, int)) ;
+EXPORT struct S_FI f19_S_SSI_FI(struct S_FI p0, struct S_FI p1, int p2,  struct S_FI (*cb)(struct S_FI, struct S_FI, int)) ;
+EXPORT struct S_FF f19_S_SSI_FF(struct S_FF p0, struct S_FF p1, int p2,  struct S_FF (*cb)(struct S_FF, struct S_FF, int)) ;
+EXPORT struct S_FD f19_S_SSI_FD(struct S_FD p0, struct S_FD p1, int p2,  struct S_FD (*cb)(struct S_FD, struct S_FD, int)) ;
+EXPORT struct S_FP f19_S_SSI_FP(struct S_FP p0, struct S_FP p1, int p2,  struct S_FP (*cb)(struct S_FP, struct S_FP, int)) ;
+EXPORT struct S_DI f19_S_SSI_DI(struct S_DI p0, struct S_DI p1, int p2,  struct S_DI (*cb)(struct S_DI, struct S_DI, int)) ;
+EXPORT struct S_DF f19_S_SSI_DF(struct S_DF p0, struct S_DF p1, int p2,  struct S_DF (*cb)(struct S_DF, struct S_DF, int)) ;
+EXPORT struct S_DD f19_S_SSI_DD(struct S_DD p0, struct S_DD p1, int p2,  struct S_DD (*cb)(struct S_DD, struct S_DD, int)) ;
+EXPORT struct S_DP f19_S_SSI_DP(struct S_DP p0, struct S_DP p1, int p2,  struct S_DP (*cb)(struct S_DP, struct S_DP, int)) ;
+EXPORT struct S_PI f19_S_SSI_PI(struct S_PI p0, struct S_PI p1, int p2,  struct S_PI (*cb)(struct S_PI, struct S_PI, int)) ;
+EXPORT struct S_PF f19_S_SSI_PF(struct S_PF p0, struct S_PF p1, int p2,  struct S_PF (*cb)(struct S_PF, struct S_PF, int)) ;
+EXPORT struct S_PD f19_S_SSI_PD(struct S_PD p0, struct S_PD p1, int p2,  struct S_PD (*cb)(struct S_PD, struct S_PD, int)) ;
+EXPORT struct S_PP f19_S_SSI_PP(struct S_PP p0, struct S_PP p1, int p2,  struct S_PP (*cb)(struct S_PP, struct S_PP, int)) ;
+EXPORT struct S_III f19_S_SSI_III(struct S_III p0, struct S_III p1, int p2,  struct S_III (*cb)(struct S_III, struct S_III, int)) ;
+EXPORT struct S_IIF f19_S_SSI_IIF(struct S_IIF p0, struct S_IIF p1, int p2,  struct S_IIF (*cb)(struct S_IIF, struct S_IIF, int)) ;
+EXPORT struct S_IID f19_S_SSI_IID(struct S_IID p0, struct S_IID p1, int p2,  struct S_IID (*cb)(struct S_IID, struct S_IID, int)) ;
+EXPORT struct S_IIP f19_S_SSI_IIP(struct S_IIP p0, struct S_IIP p1, int p2,  struct S_IIP (*cb)(struct S_IIP, struct S_IIP, int)) ;
+EXPORT struct S_IFI f19_S_SSI_IFI(struct S_IFI p0, struct S_IFI p1, int p2,  struct S_IFI (*cb)(struct S_IFI, struct S_IFI, int)) ;
+EXPORT struct S_IFF f19_S_SSI_IFF(struct S_IFF p0, struct S_IFF p1, int p2,  struct S_IFF (*cb)(struct S_IFF, struct S_IFF, int)) ;
+EXPORT struct S_IFD f19_S_SSI_IFD(struct S_IFD p0, struct S_IFD p1, int p2,  struct S_IFD (*cb)(struct S_IFD, struct S_IFD, int)) ;
+EXPORT struct S_IFP f19_S_SSI_IFP(struct S_IFP p0, struct S_IFP p1, int p2,  struct S_IFP (*cb)(struct S_IFP, struct S_IFP, int)) ;
+EXPORT struct S_IDI f19_S_SSI_IDI(struct S_IDI p0, struct S_IDI p1, int p2,  struct S_IDI (*cb)(struct S_IDI, struct S_IDI, int)) ;
+EXPORT struct S_IDF f19_S_SSI_IDF(struct S_IDF p0, struct S_IDF p1, int p2,  struct S_IDF (*cb)(struct S_IDF, struct S_IDF, int)) ;
+EXPORT struct S_IDD f19_S_SSI_IDD(struct S_IDD p0, struct S_IDD p1, int p2,  struct S_IDD (*cb)(struct S_IDD, struct S_IDD, int)) ;
+EXPORT struct S_IDP f19_S_SSI_IDP(struct S_IDP p0, struct S_IDP p1, int p2,  struct S_IDP (*cb)(struct S_IDP, struct S_IDP, int)) ;
+EXPORT struct S_IPI f19_S_SSI_IPI(struct S_IPI p0, struct S_IPI p1, int p2,  struct S_IPI (*cb)(struct S_IPI, struct S_IPI, int)) ;
+EXPORT struct S_IPF f19_S_SSI_IPF(struct S_IPF p0, struct S_IPF p1, int p2,  struct S_IPF (*cb)(struct S_IPF, struct S_IPF, int)) ;
+EXPORT struct S_IPD f19_S_SSI_IPD(struct S_IPD p0, struct S_IPD p1, int p2,  struct S_IPD (*cb)(struct S_IPD, struct S_IPD, int)) ;
+EXPORT struct S_IPP f19_S_SSI_IPP(struct S_IPP p0, struct S_IPP p1, int p2,  struct S_IPP (*cb)(struct S_IPP, struct S_IPP, int)) ;
+EXPORT struct S_FII f19_S_SSI_FII(struct S_FII p0, struct S_FII p1, int p2,  struct S_FII (*cb)(struct S_FII, struct S_FII, int)) ;
+EXPORT struct S_FIF f19_S_SSI_FIF(struct S_FIF p0, struct S_FIF p1, int p2,  struct S_FIF (*cb)(struct S_FIF, struct S_FIF, int)) ;
+EXPORT struct S_FID f19_S_SSI_FID(struct S_FID p0, struct S_FID p1, int p2,  struct S_FID (*cb)(struct S_FID, struct S_FID, int)) ;
+EXPORT struct S_FIP f19_S_SSI_FIP(struct S_FIP p0, struct S_FIP p1, int p2,  struct S_FIP (*cb)(struct S_FIP, struct S_FIP, int)) ;
+EXPORT struct S_FFI f19_S_SSI_FFI(struct S_FFI p0, struct S_FFI p1, int p2,  struct S_FFI (*cb)(struct S_FFI, struct S_FFI, int)) ;
+EXPORT struct S_FFF f19_S_SSI_FFF(struct S_FFF p0, struct S_FFF p1, int p2,  struct S_FFF (*cb)(struct S_FFF, struct S_FFF, int)) ;
+EXPORT struct S_FFD f19_S_SSI_FFD(struct S_FFD p0, struct S_FFD p1, int p2,  struct S_FFD (*cb)(struct S_FFD, struct S_FFD, int)) ;
+EXPORT struct S_FFP f19_S_SSI_FFP(struct S_FFP p0, struct S_FFP p1, int p2,  struct S_FFP (*cb)(struct S_FFP, struct S_FFP, int)) ;
+EXPORT struct S_FDI f19_S_SSI_FDI(struct S_FDI p0, struct S_FDI p1, int p2,  struct S_FDI (*cb)(struct S_FDI, struct S_FDI, int)) ;
+EXPORT struct S_FDF f19_S_SSI_FDF(struct S_FDF p0, struct S_FDF p1, int p2,  struct S_FDF (*cb)(struct S_FDF, struct S_FDF, int)) ;
+EXPORT struct S_FDD f19_S_SSI_FDD(struct S_FDD p0, struct S_FDD p1, int p2,  struct S_FDD (*cb)(struct S_FDD, struct S_FDD, int)) ;
+EXPORT struct S_FDP f19_S_SSI_FDP(struct S_FDP p0, struct S_FDP p1, int p2,  struct S_FDP (*cb)(struct S_FDP, struct S_FDP, int)) ;
+EXPORT struct S_FPI f19_S_SSI_FPI(struct S_FPI p0, struct S_FPI p1, int p2,  struct S_FPI (*cb)(struct S_FPI, struct S_FPI, int)) ;
+EXPORT struct S_FPF f19_S_SSI_FPF(struct S_FPF p0, struct S_FPF p1, int p2,  struct S_FPF (*cb)(struct S_FPF, struct S_FPF, int)) ;
+EXPORT struct S_FPD f19_S_SSI_FPD(struct S_FPD p0, struct S_FPD p1, int p2,  struct S_FPD (*cb)(struct S_FPD, struct S_FPD, int)) ;
+EXPORT struct S_FPP f19_S_SSI_FPP(struct S_FPP p0, struct S_FPP p1, int p2,  struct S_FPP (*cb)(struct S_FPP, struct S_FPP, int)) ;
+EXPORT struct S_DII f19_S_SSI_DII(struct S_DII p0, struct S_DII p1, int p2,  struct S_DII (*cb)(struct S_DII, struct S_DII, int)) ;
+EXPORT struct S_DIF f19_S_SSI_DIF(struct S_DIF p0, struct S_DIF p1, int p2,  struct S_DIF (*cb)(struct S_DIF, struct S_DIF, int)) ;
+EXPORT struct S_DID f19_S_SSI_DID(struct S_DID p0, struct S_DID p1, int p2,  struct S_DID (*cb)(struct S_DID, struct S_DID, int)) ;
+EXPORT struct S_DIP f19_S_SSI_DIP(struct S_DIP p0, struct S_DIP p1, int p2,  struct S_DIP (*cb)(struct S_DIP, struct S_DIP, int)) ;
+EXPORT struct S_DFI f19_S_SSI_DFI(struct S_DFI p0, struct S_DFI p1, int p2,  struct S_DFI (*cb)(struct S_DFI, struct S_DFI, int)) ;
+EXPORT struct S_DFF f19_S_SSI_DFF(struct S_DFF p0, struct S_DFF p1, int p2,  struct S_DFF (*cb)(struct S_DFF, struct S_DFF, int)) ;
+EXPORT struct S_DFD f19_S_SSI_DFD(struct S_DFD p0, struct S_DFD p1, int p2,  struct S_DFD (*cb)(struct S_DFD, struct S_DFD, int)) ;
+EXPORT struct S_DFP f19_S_SSI_DFP(struct S_DFP p0, struct S_DFP p1, int p2,  struct S_DFP (*cb)(struct S_DFP, struct S_DFP, int)) ;
+EXPORT struct S_DDI f19_S_SSI_DDI(struct S_DDI p0, struct S_DDI p1, int p2,  struct S_DDI (*cb)(struct S_DDI, struct S_DDI, int)) ;
+EXPORT struct S_DDF f19_S_SSI_DDF(struct S_DDF p0, struct S_DDF p1, int p2,  struct S_DDF (*cb)(struct S_DDF, struct S_DDF, int)) ;
+EXPORT struct S_DDD f19_S_SSI_DDD(struct S_DDD p0, struct S_DDD p1, int p2,  struct S_DDD (*cb)(struct S_DDD, struct S_DDD, int)) ;
+EXPORT struct S_DDP f19_S_SSI_DDP(struct S_DDP p0, struct S_DDP p1, int p2,  struct S_DDP (*cb)(struct S_DDP, struct S_DDP, int)) ;
+EXPORT struct S_DPI f19_S_SSI_DPI(struct S_DPI p0, struct S_DPI p1, int p2,  struct S_DPI (*cb)(struct S_DPI, struct S_DPI, int)) ;
+EXPORT struct S_DPF f19_S_SSI_DPF(struct S_DPF p0, struct S_DPF p1, int p2,  struct S_DPF (*cb)(struct S_DPF, struct S_DPF, int)) ;
+EXPORT struct S_DPD f19_S_SSI_DPD(struct S_DPD p0, struct S_DPD p1, int p2,  struct S_DPD (*cb)(struct S_DPD, struct S_DPD, int)) ;
+EXPORT struct S_DPP f19_S_SSI_DPP(struct S_DPP p0, struct S_DPP p1, int p2,  struct S_DPP (*cb)(struct S_DPP, struct S_DPP, int)) ;
+EXPORT struct S_PII f19_S_SSI_PII(struct S_PII p0, struct S_PII p1, int p2,  struct S_PII (*cb)(struct S_PII, struct S_PII, int)) ;
+EXPORT struct S_PIF f19_S_SSI_PIF(struct S_PIF p0, struct S_PIF p1, int p2,  struct S_PIF (*cb)(struct S_PIF, struct S_PIF, int)) ;
+EXPORT struct S_PID f19_S_SSI_PID(struct S_PID p0, struct S_PID p1, int p2,  struct S_PID (*cb)(struct S_PID, struct S_PID, int)) ;
+EXPORT struct S_PIP f19_S_SSI_PIP(struct S_PIP p0, struct S_PIP p1, int p2,  struct S_PIP (*cb)(struct S_PIP, struct S_PIP, int)) ;
+EXPORT struct S_PFI f19_S_SSI_PFI(struct S_PFI p0, struct S_PFI p1, int p2,  struct S_PFI (*cb)(struct S_PFI, struct S_PFI, int)) ;
+EXPORT struct S_PFF f19_S_SSI_PFF(struct S_PFF p0, struct S_PFF p1, int p2,  struct S_PFF (*cb)(struct S_PFF, struct S_PFF, int)) ;
+EXPORT struct S_PFD f19_S_SSI_PFD(struct S_PFD p0, struct S_PFD p1, int p2,  struct S_PFD (*cb)(struct S_PFD, struct S_PFD, int)) ;
+EXPORT struct S_PFP f19_S_SSI_PFP(struct S_PFP p0, struct S_PFP p1, int p2,  struct S_PFP (*cb)(struct S_PFP, struct S_PFP, int)) ;
+EXPORT struct S_PDI f19_S_SSI_PDI(struct S_PDI p0, struct S_PDI p1, int p2,  struct S_PDI (*cb)(struct S_PDI, struct S_PDI, int)) ;
+EXPORT struct S_PDF f19_S_SSI_PDF(struct S_PDF p0, struct S_PDF p1, int p2,  struct S_PDF (*cb)(struct S_PDF, struct S_PDF, int)) ;
+EXPORT struct S_PDD f19_S_SSI_PDD(struct S_PDD p0, struct S_PDD p1, int p2,  struct S_PDD (*cb)(struct S_PDD, struct S_PDD, int)) ;
+EXPORT struct S_PDP f19_S_SSI_PDP(struct S_PDP p0, struct S_PDP p1, int p2,  struct S_PDP (*cb)(struct S_PDP, struct S_PDP, int)) ;
+EXPORT struct S_PPI f19_S_SSI_PPI(struct S_PPI p0, struct S_PPI p1, int p2,  struct S_PPI (*cb)(struct S_PPI, struct S_PPI, int)) ;
+EXPORT struct S_PPF f19_S_SSI_PPF(struct S_PPF p0, struct S_PPF p1, int p2,  struct S_PPF (*cb)(struct S_PPF, struct S_PPF, int)) ;
+EXPORT struct S_PPD f19_S_SSI_PPD(struct S_PPD p0, struct S_PPD p1, int p2,  struct S_PPD (*cb)(struct S_PPD, struct S_PPD, int)) ;
+EXPORT struct S_PPP f19_S_SSI_PPP(struct S_PPP p0, struct S_PPP p1, int p2,  struct S_PPP (*cb)(struct S_PPP, struct S_PPP, int)) ;
+EXPORT struct S_I f19_S_SSF_I(struct S_I p0, struct S_I p1, float p2,  struct S_I (*cb)(struct S_I, struct S_I, float)) ;
+EXPORT struct S_F f19_S_SSF_F(struct S_F p0, struct S_F p1, float p2,  struct S_F (*cb)(struct S_F, struct S_F, float)) ;
+EXPORT struct S_D f19_S_SSF_D(struct S_D p0, struct S_D p1, float p2,  struct S_D (*cb)(struct S_D, struct S_D, float)) ;
+EXPORT struct S_P f19_S_SSF_P(struct S_P p0, struct S_P p1, float p2,  struct S_P (*cb)(struct S_P, struct S_P, float)) ;
+EXPORT struct S_II f19_S_SSF_II(struct S_II p0, struct S_II p1, float p2,  struct S_II (*cb)(struct S_II, struct S_II, float)) ;
+EXPORT struct S_IF f19_S_SSF_IF(struct S_IF p0, struct S_IF p1, float p2,  struct S_IF (*cb)(struct S_IF, struct S_IF, float)) ;
+EXPORT struct S_ID f19_S_SSF_ID(struct S_ID p0, struct S_ID p1, float p2,  struct S_ID (*cb)(struct S_ID, struct S_ID, float)) ;
+EXPORT struct S_IP f19_S_SSF_IP(struct S_IP p0, struct S_IP p1, float p2,  struct S_IP (*cb)(struct S_IP, struct S_IP, float)) ;
+EXPORT struct S_FI f19_S_SSF_FI(struct S_FI p0, struct S_FI p1, float p2,  struct S_FI (*cb)(struct S_FI, struct S_FI, float)) ;
+EXPORT struct S_FF f19_S_SSF_FF(struct S_FF p0, struct S_FF p1, float p2,  struct S_FF (*cb)(struct S_FF, struct S_FF, float)) ;
+EXPORT struct S_FD f19_S_SSF_FD(struct S_FD p0, struct S_FD p1, float p2,  struct S_FD (*cb)(struct S_FD, struct S_FD, float)) ;
+EXPORT struct S_FP f19_S_SSF_FP(struct S_FP p0, struct S_FP p1, float p2,  struct S_FP (*cb)(struct S_FP, struct S_FP, float)) ;
+EXPORT struct S_DI f19_S_SSF_DI(struct S_DI p0, struct S_DI p1, float p2,  struct S_DI (*cb)(struct S_DI, struct S_DI, float)) ;
+EXPORT struct S_DF f19_S_SSF_DF(struct S_DF p0, struct S_DF p1, float p2,  struct S_DF (*cb)(struct S_DF, struct S_DF, float)) ;
+EXPORT struct S_DD f19_S_SSF_DD(struct S_DD p0, struct S_DD p1, float p2,  struct S_DD (*cb)(struct S_DD, struct S_DD, float)) ;
+EXPORT struct S_DP f19_S_SSF_DP(struct S_DP p0, struct S_DP p1, float p2,  struct S_DP (*cb)(struct S_DP, struct S_DP, float)) ;
+EXPORT struct S_PI f19_S_SSF_PI(struct S_PI p0, struct S_PI p1, float p2,  struct S_PI (*cb)(struct S_PI, struct S_PI, float)) ;
+EXPORT struct S_PF f19_S_SSF_PF(struct S_PF p0, struct S_PF p1, float p2,  struct S_PF (*cb)(struct S_PF, struct S_PF, float)) ;
+EXPORT struct S_PD f19_S_SSF_PD(struct S_PD p0, struct S_PD p1, float p2,  struct S_PD (*cb)(struct S_PD, struct S_PD, float)) ;
+EXPORT struct S_PP f19_S_SSF_PP(struct S_PP p0, struct S_PP p1, float p2,  struct S_PP (*cb)(struct S_PP, struct S_PP, float)) ;
+EXPORT struct S_III f19_S_SSF_III(struct S_III p0, struct S_III p1, float p2,  struct S_III (*cb)(struct S_III, struct S_III, float)) ;
+EXPORT struct S_IIF f19_S_SSF_IIF(struct S_IIF p0, struct S_IIF p1, float p2,  struct S_IIF (*cb)(struct S_IIF, struct S_IIF, float)) ;
+EXPORT struct S_IID f19_S_SSF_IID(struct S_IID p0, struct S_IID p1, float p2,  struct S_IID (*cb)(struct S_IID, struct S_IID, float)) ;
+EXPORT struct S_IIP f19_S_SSF_IIP(struct S_IIP p0, struct S_IIP p1, float p2,  struct S_IIP (*cb)(struct S_IIP, struct S_IIP, float)) ;
+EXPORT struct S_IFI f19_S_SSF_IFI(struct S_IFI p0, struct S_IFI p1, float p2,  struct S_IFI (*cb)(struct S_IFI, struct S_IFI, float)) ;
+EXPORT struct S_IFF f19_S_SSF_IFF(struct S_IFF p0, struct S_IFF p1, float p2,  struct S_IFF (*cb)(struct S_IFF, struct S_IFF, float)) ;
+EXPORT struct S_IFD f19_S_SSF_IFD(struct S_IFD p0, struct S_IFD p1, float p2,  struct S_IFD (*cb)(struct S_IFD, struct S_IFD, float)) ;
+EXPORT struct S_IFP f19_S_SSF_IFP(struct S_IFP p0, struct S_IFP p1, float p2,  struct S_IFP (*cb)(struct S_IFP, struct S_IFP, float)) ;
+EXPORT struct S_IDI f19_S_SSF_IDI(struct S_IDI p0, struct S_IDI p1, float p2,  struct S_IDI (*cb)(struct S_IDI, struct S_IDI, float)) ;
+EXPORT struct S_IDF f19_S_SSF_IDF(struct S_IDF p0, struct S_IDF p1, float p2,  struct S_IDF (*cb)(struct S_IDF, struct S_IDF, float)) ;
+EXPORT struct S_IDD f19_S_SSF_IDD(struct S_IDD p0, struct S_IDD p1, float p2,  struct S_IDD (*cb)(struct S_IDD, struct S_IDD, float)) ;
+EXPORT struct S_IDP f19_S_SSF_IDP(struct S_IDP p0, struct S_IDP p1, float p2,  struct S_IDP (*cb)(struct S_IDP, struct S_IDP, float)) ;
+EXPORT struct S_IPI f19_S_SSF_IPI(struct S_IPI p0, struct S_IPI p1, float p2,  struct S_IPI (*cb)(struct S_IPI, struct S_IPI, float)) ;
+EXPORT struct S_IPF f19_S_SSF_IPF(struct S_IPF p0, struct S_IPF p1, float p2,  struct S_IPF (*cb)(struct S_IPF, struct S_IPF, float)) ;
+EXPORT struct S_IPD f19_S_SSF_IPD(struct S_IPD p0, struct S_IPD p1, float p2,  struct S_IPD (*cb)(struct S_IPD, struct S_IPD, float)) ;
+EXPORT struct S_IPP f19_S_SSF_IPP(struct S_IPP p0, struct S_IPP p1, float p2,  struct S_IPP (*cb)(struct S_IPP, struct S_IPP, float)) ;
+EXPORT struct S_FII f19_S_SSF_FII(struct S_FII p0, struct S_FII p1, float p2,  struct S_FII (*cb)(struct S_FII, struct S_FII, float)) ;
+EXPORT struct S_FIF f19_S_SSF_FIF(struct S_FIF p0, struct S_FIF p1, float p2,  struct S_FIF (*cb)(struct S_FIF, struct S_FIF, float)) ;
+EXPORT struct S_FID f19_S_SSF_FID(struct S_FID p0, struct S_FID p1, float p2,  struct S_FID (*cb)(struct S_FID, struct S_FID, float)) ;
+EXPORT struct S_FIP f19_S_SSF_FIP(struct S_FIP p0, struct S_FIP p1, float p2,  struct S_FIP (*cb)(struct S_FIP, struct S_FIP, float)) ;
+EXPORT struct S_FFI f19_S_SSF_FFI(struct S_FFI p0, struct S_FFI p1, float p2,  struct S_FFI (*cb)(struct S_FFI, struct S_FFI, float)) ;
+EXPORT struct S_FFF f19_S_SSF_FFF(struct S_FFF p0, struct S_FFF p1, float p2,  struct S_FFF (*cb)(struct S_FFF, struct S_FFF, float)) ;
+EXPORT struct S_FFD f19_S_SSF_FFD(struct S_FFD p0, struct S_FFD p1, float p2,  struct S_FFD (*cb)(struct S_FFD, struct S_FFD, float)) ;
+EXPORT struct S_FFP f19_S_SSF_FFP(struct S_FFP p0, struct S_FFP p1, float p2,  struct S_FFP (*cb)(struct S_FFP, struct S_FFP, float)) ;
+EXPORT struct S_FDI f19_S_SSF_FDI(struct S_FDI p0, struct S_FDI p1, float p2,  struct S_FDI (*cb)(struct S_FDI, struct S_FDI, float)) ;
+EXPORT struct S_FDF f19_S_SSF_FDF(struct S_FDF p0, struct S_FDF p1, float p2,  struct S_FDF (*cb)(struct S_FDF, struct S_FDF, float)) ;
+EXPORT struct S_FDD f19_S_SSF_FDD(struct S_FDD p0, struct S_FDD p1, float p2,  struct S_FDD (*cb)(struct S_FDD, struct S_FDD, float)) ;
+EXPORT struct S_FDP f19_S_SSF_FDP(struct S_FDP p0, struct S_FDP p1, float p2,  struct S_FDP (*cb)(struct S_FDP, struct S_FDP, float)) ;
+EXPORT struct S_FPI f19_S_SSF_FPI(struct S_FPI p0, struct S_FPI p1, float p2,  struct S_FPI (*cb)(struct S_FPI, struct S_FPI, float)) ;
+EXPORT struct S_FPF f19_S_SSF_FPF(struct S_FPF p0, struct S_FPF p1, float p2,  struct S_FPF (*cb)(struct S_FPF, struct S_FPF, float)) ;
+EXPORT struct S_FPD f19_S_SSF_FPD(struct S_FPD p0, struct S_FPD p1, float p2,  struct S_FPD (*cb)(struct S_FPD, struct S_FPD, float)) ;
+EXPORT struct S_FPP f19_S_SSF_FPP(struct S_FPP p0, struct S_FPP p1, float p2,  struct S_FPP (*cb)(struct S_FPP, struct S_FPP, float)) ;
+EXPORT struct S_DII f19_S_SSF_DII(struct S_DII p0, struct S_DII p1, float p2,  struct S_DII (*cb)(struct S_DII, struct S_DII, float)) ;
+EXPORT struct S_DIF f19_S_SSF_DIF(struct S_DIF p0, struct S_DIF p1, float p2,  struct S_DIF (*cb)(struct S_DIF, struct S_DIF, float)) ;
+EXPORT struct S_DID f19_S_SSF_DID(struct S_DID p0, struct S_DID p1, float p2,  struct S_DID (*cb)(struct S_DID, struct S_DID, float)) ;
+EXPORT struct S_DIP f19_S_SSF_DIP(struct S_DIP p0, struct S_DIP p1, float p2,  struct S_DIP (*cb)(struct S_DIP, struct S_DIP, float)) ;
+EXPORT struct S_DFI f19_S_SSF_DFI(struct S_DFI p0, struct S_DFI p1, float p2,  struct S_DFI (*cb)(struct S_DFI, struct S_DFI, float)) ;
+EXPORT struct S_DFF f19_S_SSF_DFF(struct S_DFF p0, struct S_DFF p1, float p2,  struct S_DFF (*cb)(struct S_DFF, struct S_DFF, float)) ;
+EXPORT struct S_DFD f19_S_SSF_DFD(struct S_DFD p0, struct S_DFD p1, float p2,  struct S_DFD (*cb)(struct S_DFD, struct S_DFD, float)) ;
+EXPORT struct S_DFP f19_S_SSF_DFP(struct S_DFP p0, struct S_DFP p1, float p2,  struct S_DFP (*cb)(struct S_DFP, struct S_DFP, float)) ;
+EXPORT struct S_DDI f19_S_SSF_DDI(struct S_DDI p0, struct S_DDI p1, float p2,  struct S_DDI (*cb)(struct S_DDI, struct S_DDI, float)) ;
+EXPORT struct S_DDF f19_S_SSF_DDF(struct S_DDF p0, struct S_DDF p1, float p2,  struct S_DDF (*cb)(struct S_DDF, struct S_DDF, float)) ;
+EXPORT struct S_DDD f19_S_SSF_DDD(struct S_DDD p0, struct S_DDD p1, float p2,  struct S_DDD (*cb)(struct S_DDD, struct S_DDD, float)) ;
+EXPORT struct S_DDP f19_S_SSF_DDP(struct S_DDP p0, struct S_DDP p1, float p2,  struct S_DDP (*cb)(struct S_DDP, struct S_DDP, float)) ;
+EXPORT struct S_DPI f19_S_SSF_DPI(struct S_DPI p0, struct S_DPI p1, float p2,  struct S_DPI (*cb)(struct S_DPI, struct S_DPI, float)) ;
+EXPORT struct S_DPF f19_S_SSF_DPF(struct S_DPF p0, struct S_DPF p1, float p2,  struct S_DPF (*cb)(struct S_DPF, struct S_DPF, float)) ;
+EXPORT struct S_DPD f19_S_SSF_DPD(struct S_DPD p0, struct S_DPD p1, float p2,  struct S_DPD (*cb)(struct S_DPD, struct S_DPD, float)) ;
+EXPORT struct S_DPP f19_S_SSF_DPP(struct S_DPP p0, struct S_DPP p1, float p2,  struct S_DPP (*cb)(struct S_DPP, struct S_DPP, float)) ;
+EXPORT struct S_PII f19_S_SSF_PII(struct S_PII p0, struct S_PII p1, float p2,  struct S_PII (*cb)(struct S_PII, struct S_PII, float)) ;
+EXPORT struct S_PIF f19_S_SSF_PIF(struct S_PIF p0, struct S_PIF p1, float p2,  struct S_PIF (*cb)(struct S_PIF, struct S_PIF, float)) ;
+EXPORT struct S_PID f19_S_SSF_PID(struct S_PID p0, struct S_PID p1, float p2,  struct S_PID (*cb)(struct S_PID, struct S_PID, float)) ;
+EXPORT struct S_PIP f19_S_SSF_PIP(struct S_PIP p0, struct S_PIP p1, float p2,  struct S_PIP (*cb)(struct S_PIP, struct S_PIP, float)) ;
+EXPORT struct S_PFI f19_S_SSF_PFI(struct S_PFI p0, struct S_PFI p1, float p2,  struct S_PFI (*cb)(struct S_PFI, struct S_PFI, float)) ;
+EXPORT struct S_PFF f19_S_SSF_PFF(struct S_PFF p0, struct S_PFF p1, float p2,  struct S_PFF (*cb)(struct S_PFF, struct S_PFF, float)) ;
+EXPORT struct S_PFD f19_S_SSF_PFD(struct S_PFD p0, struct S_PFD p1, float p2,  struct S_PFD (*cb)(struct S_PFD, struct S_PFD, float)) ;
+EXPORT struct S_PFP f19_S_SSF_PFP(struct S_PFP p0, struct S_PFP p1, float p2,  struct S_PFP (*cb)(struct S_PFP, struct S_PFP, float)) ;
+EXPORT struct S_PDI f19_S_SSF_PDI(struct S_PDI p0, struct S_PDI p1, float p2,  struct S_PDI (*cb)(struct S_PDI, struct S_PDI, float)) ;
+EXPORT struct S_PDF f19_S_SSF_PDF(struct S_PDF p0, struct S_PDF p1, float p2,  struct S_PDF (*cb)(struct S_PDF, struct S_PDF, float)) ;
+EXPORT struct S_PDD f19_S_SSF_PDD(struct S_PDD p0, struct S_PDD p1, float p2,  struct S_PDD (*cb)(struct S_PDD, struct S_PDD, float)) ;
+EXPORT struct S_PDP f19_S_SSF_PDP(struct S_PDP p0, struct S_PDP p1, float p2,  struct S_PDP (*cb)(struct S_PDP, struct S_PDP, float)) ;
+EXPORT struct S_PPI f19_S_SSF_PPI(struct S_PPI p0, struct S_PPI p1, float p2,  struct S_PPI (*cb)(struct S_PPI, struct S_PPI, float)) ;
+EXPORT struct S_PPF f19_S_SSF_PPF(struct S_PPF p0, struct S_PPF p1, float p2,  struct S_PPF (*cb)(struct S_PPF, struct S_PPF, float)) ;
+EXPORT struct S_PPD f19_S_SSF_PPD(struct S_PPD p0, struct S_PPD p1, float p2,  struct S_PPD (*cb)(struct S_PPD, struct S_PPD, float)) ;
+EXPORT struct S_PPP f19_S_SSF_PPP(struct S_PPP p0, struct S_PPP p1, float p2,  struct S_PPP (*cb)(struct S_PPP, struct S_PPP, float)) ;
+EXPORT struct S_I f19_S_SSD_I(struct S_I p0, struct S_I p1, double p2,  struct S_I (*cb)(struct S_I, struct S_I, double)) ;
+EXPORT struct S_F f19_S_SSD_F(struct S_F p0, struct S_F p1, double p2,  struct S_F (*cb)(struct S_F, struct S_F, double)) ;
+EXPORT struct S_D f19_S_SSD_D(struct S_D p0, struct S_D p1, double p2,  struct S_D (*cb)(struct S_D, struct S_D, double)) ;
+EXPORT struct S_P f19_S_SSD_P(struct S_P p0, struct S_P p1, double p2,  struct S_P (*cb)(struct S_P, struct S_P, double)) ;
+EXPORT struct S_II f19_S_SSD_II(struct S_II p0, struct S_II p1, double p2,  struct S_II (*cb)(struct S_II, struct S_II, double)) ;
+EXPORT struct S_IF f19_S_SSD_IF(struct S_IF p0, struct S_IF p1, double p2,  struct S_IF (*cb)(struct S_IF, struct S_IF, double)) ;
+EXPORT struct S_ID f19_S_SSD_ID(struct S_ID p0, struct S_ID p1, double p2,  struct S_ID (*cb)(struct S_ID, struct S_ID, double)) ;
+EXPORT struct S_IP f19_S_SSD_IP(struct S_IP p0, struct S_IP p1, double p2,  struct S_IP (*cb)(struct S_IP, struct S_IP, double)) ;
+EXPORT struct S_FI f19_S_SSD_FI(struct S_FI p0, struct S_FI p1, double p2,  struct S_FI (*cb)(struct S_FI, struct S_FI, double)) ;
+EXPORT struct S_FF f19_S_SSD_FF(struct S_FF p0, struct S_FF p1, double p2,  struct S_FF (*cb)(struct S_FF, struct S_FF, double)) ;
+EXPORT struct S_FD f19_S_SSD_FD(struct S_FD p0, struct S_FD p1, double p2,  struct S_FD (*cb)(struct S_FD, struct S_FD, double)) ;
+EXPORT struct S_FP f19_S_SSD_FP(struct S_FP p0, struct S_FP p1, double p2,  struct S_FP (*cb)(struct S_FP, struct S_FP, double)) ;
+EXPORT struct S_DI f19_S_SSD_DI(struct S_DI p0, struct S_DI p1, double p2,  struct S_DI (*cb)(struct S_DI, struct S_DI, double)) ;
+EXPORT struct S_DF f19_S_SSD_DF(struct S_DF p0, struct S_DF p1, double p2,  struct S_DF (*cb)(struct S_DF, struct S_DF, double)) ;
+EXPORT struct S_DD f19_S_SSD_DD(struct S_DD p0, struct S_DD p1, double p2,  struct S_DD (*cb)(struct S_DD, struct S_DD, double)) ;
+EXPORT struct S_DP f19_S_SSD_DP(struct S_DP p0, struct S_DP p1, double p2,  struct S_DP (*cb)(struct S_DP, struct S_DP, double)) ;
+EXPORT struct S_PI f19_S_SSD_PI(struct S_PI p0, struct S_PI p1, double p2,  struct S_PI (*cb)(struct S_PI, struct S_PI, double)) ;
+EXPORT struct S_PF f19_S_SSD_PF(struct S_PF p0, struct S_PF p1, double p2,  struct S_PF (*cb)(struct S_PF, struct S_PF, double)) ;
+EXPORT struct S_PD f19_S_SSD_PD(struct S_PD p0, struct S_PD p1, double p2,  struct S_PD (*cb)(struct S_PD, struct S_PD, double)) ;
+EXPORT struct S_PP f19_S_SSD_PP(struct S_PP p0, struct S_PP p1, double p2,  struct S_PP (*cb)(struct S_PP, struct S_PP, double)) ;
+EXPORT struct S_III f19_S_SSD_III(struct S_III p0, struct S_III p1, double p2,  struct S_III (*cb)(struct S_III, struct S_III, double)) ;
+EXPORT struct S_IIF f19_S_SSD_IIF(struct S_IIF p0, struct S_IIF p1, double p2,  struct S_IIF (*cb)(struct S_IIF, struct S_IIF, double)) ;
+EXPORT struct S_IID f19_S_SSD_IID(struct S_IID p0, struct S_IID p1, double p2,  struct S_IID (*cb)(struct S_IID, struct S_IID, double)) ;
+EXPORT struct S_IIP f19_S_SSD_IIP(struct S_IIP p0, struct S_IIP p1, double p2,  struct S_IIP (*cb)(struct S_IIP, struct S_IIP, double)) ;
+EXPORT struct S_IFI f19_S_SSD_IFI(struct S_IFI p0, struct S_IFI p1, double p2,  struct S_IFI (*cb)(struct S_IFI, struct S_IFI, double)) ;
+EXPORT struct S_IFF f19_S_SSD_IFF(struct S_IFF p0, struct S_IFF p1, double p2,  struct S_IFF (*cb)(struct S_IFF, struct S_IFF, double)) ;
+EXPORT struct S_IFD f19_S_SSD_IFD(struct S_IFD p0, struct S_IFD p1, double p2,  struct S_IFD (*cb)(struct S_IFD, struct S_IFD, double)) ;
+EXPORT struct S_IFP f19_S_SSD_IFP(struct S_IFP p0, struct S_IFP p1, double p2,  struct S_IFP (*cb)(struct S_IFP, struct S_IFP, double)) ;
+EXPORT struct S_IDI f19_S_SSD_IDI(struct S_IDI p0, struct S_IDI p1, double p2,  struct S_IDI (*cb)(struct S_IDI, struct S_IDI, double)) ;
+EXPORT struct S_IDF f19_S_SSD_IDF(struct S_IDF p0, struct S_IDF p1, double p2,  struct S_IDF (*cb)(struct S_IDF, struct S_IDF, double)) ;
+EXPORT struct S_IDD f19_S_SSD_IDD(struct S_IDD p0, struct S_IDD p1, double p2,  struct S_IDD (*cb)(struct S_IDD, struct S_IDD, double)) ;
+EXPORT struct S_IDP f19_S_SSD_IDP(struct S_IDP p0, struct S_IDP p1, double p2,  struct S_IDP (*cb)(struct S_IDP, struct S_IDP, double)) ;
+EXPORT struct S_IPI f19_S_SSD_IPI(struct S_IPI p0, struct S_IPI p1, double p2,  struct S_IPI (*cb)(struct S_IPI, struct S_IPI, double)) ;
+EXPORT struct S_IPF f19_S_SSD_IPF(struct S_IPF p0, struct S_IPF p1, double p2,  struct S_IPF (*cb)(struct S_IPF, struct S_IPF, double)) ;
+EXPORT struct S_IPD f19_S_SSD_IPD(struct S_IPD p0, struct S_IPD p1, double p2,  struct S_IPD (*cb)(struct S_IPD, struct S_IPD, double)) ;
+EXPORT struct S_IPP f19_S_SSD_IPP(struct S_IPP p0, struct S_IPP p1, double p2,  struct S_IPP (*cb)(struct S_IPP, struct S_IPP, double)) ;
+EXPORT struct S_FII f19_S_SSD_FII(struct S_FII p0, struct S_FII p1, double p2,  struct S_FII (*cb)(struct S_FII, struct S_FII, double)) ;
+EXPORT struct S_FIF f19_S_SSD_FIF(struct S_FIF p0, struct S_FIF p1, double p2,  struct S_FIF (*cb)(struct S_FIF, struct S_FIF, double)) ;
+EXPORT struct S_FID f19_S_SSD_FID(struct S_FID p0, struct S_FID p1, double p2,  struct S_FID (*cb)(struct S_FID, struct S_FID, double)) ;
+EXPORT struct S_FIP f19_S_SSD_FIP(struct S_FIP p0, struct S_FIP p1, double p2,  struct S_FIP (*cb)(struct S_FIP, struct S_FIP, double)) ;
+EXPORT struct S_FFI f19_S_SSD_FFI(struct S_FFI p0, struct S_FFI p1, double p2,  struct S_FFI (*cb)(struct S_FFI, struct S_FFI, double)) ;
+EXPORT struct S_FFF f19_S_SSD_FFF(struct S_FFF p0, struct S_FFF p1, double p2,  struct S_FFF (*cb)(struct S_FFF, struct S_FFF, double)) ;
+EXPORT struct S_FFD f19_S_SSD_FFD(struct S_FFD p0, struct S_FFD p1, double p2,  struct S_FFD (*cb)(struct S_FFD, struct S_FFD, double)) ;
+EXPORT struct S_FFP f19_S_SSD_FFP(struct S_FFP p0, struct S_FFP p1, double p2,  struct S_FFP (*cb)(struct S_FFP, struct S_FFP, double)) ;
+EXPORT struct S_FDI f19_S_SSD_FDI(struct S_FDI p0, struct S_FDI p1, double p2,  struct S_FDI (*cb)(struct S_FDI, struct S_FDI, double)) ;
+EXPORT struct S_FDF f19_S_SSD_FDF(struct S_FDF p0, struct S_FDF p1, double p2,  struct S_FDF (*cb)(struct S_FDF, struct S_FDF, double)) ;
+EXPORT struct S_FDD f19_S_SSD_FDD(struct S_FDD p0, struct S_FDD p1, double p2,  struct S_FDD (*cb)(struct S_FDD, struct S_FDD, double)) ;
+EXPORT struct S_FDP f19_S_SSD_FDP(struct S_FDP p0, struct S_FDP p1, double p2,  struct S_FDP (*cb)(struct S_FDP, struct S_FDP, double)) ;
+EXPORT struct S_FPI f19_S_SSD_FPI(struct S_FPI p0, struct S_FPI p1, double p2,  struct S_FPI (*cb)(struct S_FPI, struct S_FPI, double)) ;
+EXPORT struct S_FPF f19_S_SSD_FPF(struct S_FPF p0, struct S_FPF p1, double p2,  struct S_FPF (*cb)(struct S_FPF, struct S_FPF, double)) ;
+EXPORT struct S_FPD f19_S_SSD_FPD(struct S_FPD p0, struct S_FPD p1, double p2,  struct S_FPD (*cb)(struct S_FPD, struct S_FPD, double)) ;
+EXPORT struct S_FPP f19_S_SSD_FPP(struct S_FPP p0, struct S_FPP p1, double p2,  struct S_FPP (*cb)(struct S_FPP, struct S_FPP, double)) ;
+EXPORT struct S_DII f19_S_SSD_DII(struct S_DII p0, struct S_DII p1, double p2,  struct S_DII (*cb)(struct S_DII, struct S_DII, double)) ;
+EXPORT struct S_DIF f19_S_SSD_DIF(struct S_DIF p0, struct S_DIF p1, double p2,  struct S_DIF (*cb)(struct S_DIF, struct S_DIF, double)) ;
+EXPORT struct S_DID f19_S_SSD_DID(struct S_DID p0, struct S_DID p1, double p2,  struct S_DID (*cb)(struct S_DID, struct S_DID, double)) ;
+EXPORT struct S_DIP f19_S_SSD_DIP(struct S_DIP p0, struct S_DIP p1, double p2,  struct S_DIP (*cb)(struct S_DIP, struct S_DIP, double)) ;
+EXPORT struct S_DFI f19_S_SSD_DFI(struct S_DFI p0, struct S_DFI p1, double p2,  struct S_DFI (*cb)(struct S_DFI, struct S_DFI, double)) ;
+EXPORT struct S_DFF f19_S_SSD_DFF(struct S_DFF p0, struct S_DFF p1, double p2,  struct S_DFF (*cb)(struct S_DFF, struct S_DFF, double)) ;
+EXPORT struct S_DFD f19_S_SSD_DFD(struct S_DFD p0, struct S_DFD p1, double p2,  struct S_DFD (*cb)(struct S_DFD, struct S_DFD, double)) ;
+EXPORT struct S_DFP f19_S_SSD_DFP(struct S_DFP p0, struct S_DFP p1, double p2,  struct S_DFP (*cb)(struct S_DFP, struct S_DFP, double)) ;
+EXPORT struct S_DDI f19_S_SSD_DDI(struct S_DDI p0, struct S_DDI p1, double p2,  struct S_DDI (*cb)(struct S_DDI, struct S_DDI, double)) ;
+EXPORT struct S_DDF f19_S_SSD_DDF(struct S_DDF p0, struct S_DDF p1, double p2,  struct S_DDF (*cb)(struct S_DDF, struct S_DDF, double)) ;
+EXPORT struct S_DDD f19_S_SSD_DDD(struct S_DDD p0, struct S_DDD p1, double p2,  struct S_DDD (*cb)(struct S_DDD, struct S_DDD, double)) ;
+EXPORT struct S_DDP f19_S_SSD_DDP(struct S_DDP p0, struct S_DDP p1, double p2,  struct S_DDP (*cb)(struct S_DDP, struct S_DDP, double)) ;
+EXPORT struct S_DPI f19_S_SSD_DPI(struct S_DPI p0, struct S_DPI p1, double p2,  struct S_DPI (*cb)(struct S_DPI, struct S_DPI, double)) ;
+EXPORT struct S_DPF f19_S_SSD_DPF(struct S_DPF p0, struct S_DPF p1, double p2,  struct S_DPF (*cb)(struct S_DPF, struct S_DPF, double)) ;
+EXPORT struct S_DPD f19_S_SSD_DPD(struct S_DPD p0, struct S_DPD p1, double p2,  struct S_DPD (*cb)(struct S_DPD, struct S_DPD, double)) ;
+EXPORT struct S_DPP f19_S_SSD_DPP(struct S_DPP p0, struct S_DPP p1, double p2,  struct S_DPP (*cb)(struct S_DPP, struct S_DPP, double)) ;
+EXPORT struct S_PII f19_S_SSD_PII(struct S_PII p0, struct S_PII p1, double p2,  struct S_PII (*cb)(struct S_PII, struct S_PII, double)) ;
+EXPORT struct S_PIF f19_S_SSD_PIF(struct S_PIF p0, struct S_PIF p1, double p2,  struct S_PIF (*cb)(struct S_PIF, struct S_PIF, double)) ;
+EXPORT struct S_PID f19_S_SSD_PID(struct S_PID p0, struct S_PID p1, double p2,  struct S_PID (*cb)(struct S_PID, struct S_PID, double)) ;
+EXPORT struct S_PIP f19_S_SSD_PIP(struct S_PIP p0, struct S_PIP p1, double p2,  struct S_PIP (*cb)(struct S_PIP, struct S_PIP, double)) ;
+EXPORT struct S_PFI f19_S_SSD_PFI(struct S_PFI p0, struct S_PFI p1, double p2,  struct S_PFI (*cb)(struct S_PFI, struct S_PFI, double)) ;
+EXPORT struct S_PFF f19_S_SSD_PFF(struct S_PFF p0, struct S_PFF p1, double p2,  struct S_PFF (*cb)(struct S_PFF, struct S_PFF, double)) ;
+EXPORT struct S_PFD f19_S_SSD_PFD(struct S_PFD p0, struct S_PFD p1, double p2,  struct S_PFD (*cb)(struct S_PFD, struct S_PFD, double)) ;
+EXPORT struct S_PFP f19_S_SSD_PFP(struct S_PFP p0, struct S_PFP p1, double p2,  struct S_PFP (*cb)(struct S_PFP, struct S_PFP, double)) ;
+EXPORT struct S_PDI f19_S_SSD_PDI(struct S_PDI p0, struct S_PDI p1, double p2,  struct S_PDI (*cb)(struct S_PDI, struct S_PDI, double)) ;
+EXPORT struct S_PDF f19_S_SSD_PDF(struct S_PDF p0, struct S_PDF p1, double p2,  struct S_PDF (*cb)(struct S_PDF, struct S_PDF, double)) ;
+EXPORT struct S_PDD f19_S_SSD_PDD(struct S_PDD p0, struct S_PDD p1, double p2,  struct S_PDD (*cb)(struct S_PDD, struct S_PDD, double)) ;
+EXPORT struct S_PDP f19_S_SSD_PDP(struct S_PDP p0, struct S_PDP p1, double p2,  struct S_PDP (*cb)(struct S_PDP, struct S_PDP, double)) ;
+EXPORT struct S_PPI f19_S_SSD_PPI(struct S_PPI p0, struct S_PPI p1, double p2,  struct S_PPI (*cb)(struct S_PPI, struct S_PPI, double)) ;
+EXPORT struct S_PPF f19_S_SSD_PPF(struct S_PPF p0, struct S_PPF p1, double p2,  struct S_PPF (*cb)(struct S_PPF, struct S_PPF, double)) ;
+EXPORT struct S_PPD f19_S_SSD_PPD(struct S_PPD p0, struct S_PPD p1, double p2,  struct S_PPD (*cb)(struct S_PPD, struct S_PPD, double)) ;
+EXPORT struct S_PPP f19_S_SSD_PPP(struct S_PPP p0, struct S_PPP p1, double p2,  struct S_PPP (*cb)(struct S_PPP, struct S_PPP, double)) ;
+EXPORT struct S_I f19_S_SSP_I(struct S_I p0, struct S_I p1, void* p2,  struct S_I (*cb)(struct S_I, struct S_I, void*)) ;
+EXPORT struct S_F f19_S_SSP_F(struct S_F p0, struct S_F p1, void* p2,  struct S_F (*cb)(struct S_F, struct S_F, void*)) ;
+EXPORT struct S_D f19_S_SSP_D(struct S_D p0, struct S_D p1, void* p2,  struct S_D (*cb)(struct S_D, struct S_D, void*)) ;
+EXPORT struct S_P f19_S_SSP_P(struct S_P p0, struct S_P p1, void* p2,  struct S_P (*cb)(struct S_P, struct S_P, void*)) ;
+EXPORT struct S_II f19_S_SSP_II(struct S_II p0, struct S_II p1, void* p2,  struct S_II (*cb)(struct S_II, struct S_II, void*)) ;
+EXPORT struct S_IF f19_S_SSP_IF(struct S_IF p0, struct S_IF p1, void* p2,  struct S_IF (*cb)(struct S_IF, struct S_IF, void*)) ;
+EXPORT struct S_ID f19_S_SSP_ID(struct S_ID p0, struct S_ID p1, void* p2,  struct S_ID (*cb)(struct S_ID, struct S_ID, void*)) ;
+EXPORT struct S_IP f19_S_SSP_IP(struct S_IP p0, struct S_IP p1, void* p2,  struct S_IP (*cb)(struct S_IP, struct S_IP, void*)) ;
+EXPORT struct S_FI f19_S_SSP_FI(struct S_FI p0, struct S_FI p1, void* p2,  struct S_FI (*cb)(struct S_FI, struct S_FI, void*)) ;
+EXPORT struct S_FF f19_S_SSP_FF(struct S_FF p0, struct S_FF p1, void* p2,  struct S_FF (*cb)(struct S_FF, struct S_FF, void*)) ;
+EXPORT struct S_FD f19_S_SSP_FD(struct S_FD p0, struct S_FD p1, void* p2,  struct S_FD (*cb)(struct S_FD, struct S_FD, void*)) ;
+EXPORT struct S_FP f19_S_SSP_FP(struct S_FP p0, struct S_FP p1, void* p2,  struct S_FP (*cb)(struct S_FP, struct S_FP, void*)) ;
+EXPORT struct S_DI f19_S_SSP_DI(struct S_DI p0, struct S_DI p1, void* p2,  struct S_DI (*cb)(struct S_DI, struct S_DI, void*)) ;
+EXPORT struct S_DF f19_S_SSP_DF(struct S_DF p0, struct S_DF p1, void* p2,  struct S_DF (*cb)(struct S_DF, struct S_DF, void*)) ;
+EXPORT struct S_DD f19_S_SSP_DD(struct S_DD p0, struct S_DD p1, void* p2,  struct S_DD (*cb)(struct S_DD, struct S_DD, void*)) ;
+EXPORT struct S_DP f19_S_SSP_DP(struct S_DP p0, struct S_DP p1, void* p2,  struct S_DP (*cb)(struct S_DP, struct S_DP, void*)) ;
+EXPORT struct S_PI f19_S_SSP_PI(struct S_PI p0, struct S_PI p1, void* p2,  struct S_PI (*cb)(struct S_PI, struct S_PI, void*)) ;
+EXPORT struct S_PF f19_S_SSP_PF(struct S_PF p0, struct S_PF p1, void* p2,  struct S_PF (*cb)(struct S_PF, struct S_PF, void*)) ;
+EXPORT struct S_PD f19_S_SSP_PD(struct S_PD p0, struct S_PD p1, void* p2,  struct S_PD (*cb)(struct S_PD, struct S_PD, void*)) ;
+EXPORT struct S_PP f19_S_SSP_PP(struct S_PP p0, struct S_PP p1, void* p2,  struct S_PP (*cb)(struct S_PP, struct S_PP, void*)) ;
+EXPORT struct S_III f19_S_SSP_III(struct S_III p0, struct S_III p1, void* p2,  struct S_III (*cb)(struct S_III, struct S_III, void*)) ;
+EXPORT struct S_IIF f19_S_SSP_IIF(struct S_IIF p0, struct S_IIF p1, void* p2,  struct S_IIF (*cb)(struct S_IIF, struct S_IIF, void*)) ;
+EXPORT struct S_IID f19_S_SSP_IID(struct S_IID p0, struct S_IID p1, void* p2,  struct S_IID (*cb)(struct S_IID, struct S_IID, void*)) ;
+EXPORT struct S_IIP f19_S_SSP_IIP(struct S_IIP p0, struct S_IIP p1, void* p2,  struct S_IIP (*cb)(struct S_IIP, struct S_IIP, void*)) ;
+EXPORT struct S_IFI f19_S_SSP_IFI(struct S_IFI p0, struct S_IFI p1, void* p2,  struct S_IFI (*cb)(struct S_IFI, struct S_IFI, void*)) ;
+EXPORT struct S_IFF f19_S_SSP_IFF(struct S_IFF p0, struct S_IFF p1, void* p2,  struct S_IFF (*cb)(struct S_IFF, struct S_IFF, void*)) ;
+EXPORT struct S_IFD f19_S_SSP_IFD(struct S_IFD p0, struct S_IFD p1, void* p2,  struct S_IFD (*cb)(struct S_IFD, struct S_IFD, void*)) ;
+EXPORT struct S_IFP f19_S_SSP_IFP(struct S_IFP p0, struct S_IFP p1, void* p2,  struct S_IFP (*cb)(struct S_IFP, struct S_IFP, void*)) ;
+EXPORT struct S_IDI f19_S_SSP_IDI(struct S_IDI p0, struct S_IDI p1, void* p2,  struct S_IDI (*cb)(struct S_IDI, struct S_IDI, void*)) ;
+EXPORT struct S_IDF f19_S_SSP_IDF(struct S_IDF p0, struct S_IDF p1, void* p2,  struct S_IDF (*cb)(struct S_IDF, struct S_IDF, void*)) ;
+EXPORT struct S_IDD f19_S_SSP_IDD(struct S_IDD p0, struct S_IDD p1, void* p2,  struct S_IDD (*cb)(struct S_IDD, struct S_IDD, void*)) ;
+EXPORT struct S_IDP f19_S_SSP_IDP(struct S_IDP p0, struct S_IDP p1, void* p2,  struct S_IDP (*cb)(struct S_IDP, struct S_IDP, void*)) ;
+EXPORT struct S_IPI f19_S_SSP_IPI(struct S_IPI p0, struct S_IPI p1, void* p2,  struct S_IPI (*cb)(struct S_IPI, struct S_IPI, void*)) ;
+EXPORT struct S_IPF f19_S_SSP_IPF(struct S_IPF p0, struct S_IPF p1, void* p2,  struct S_IPF (*cb)(struct S_IPF, struct S_IPF, void*)) ;
+EXPORT struct S_IPD f19_S_SSP_IPD(struct S_IPD p0, struct S_IPD p1, void* p2,  struct S_IPD (*cb)(struct S_IPD, struct S_IPD, void*)) ;
+EXPORT struct S_IPP f19_S_SSP_IPP(struct S_IPP p0, struct S_IPP p1, void* p2,  struct S_IPP (*cb)(struct S_IPP, struct S_IPP, void*)) ;
+EXPORT struct S_FII f19_S_SSP_FII(struct S_FII p0, struct S_FII p1, void* p2,  struct S_FII (*cb)(struct S_FII, struct S_FII, void*)) ;
+EXPORT struct S_FIF f19_S_SSP_FIF(struct S_FIF p0, struct S_FIF p1, void* p2,  struct S_FIF (*cb)(struct S_FIF, struct S_FIF, void*)) ;
+EXPORT struct S_FID f19_S_SSP_FID(struct S_FID p0, struct S_FID p1, void* p2,  struct S_FID (*cb)(struct S_FID, struct S_FID, void*)) ;
+EXPORT struct S_FIP f19_S_SSP_FIP(struct S_FIP p0, struct S_FIP p1, void* p2,  struct S_FIP (*cb)(struct S_FIP, struct S_FIP, void*)) ;
+EXPORT struct S_FFI f19_S_SSP_FFI(struct S_FFI p0, struct S_FFI p1, void* p2,  struct S_FFI (*cb)(struct S_FFI, struct S_FFI, void*)) ;
+EXPORT struct S_FFF f19_S_SSP_FFF(struct S_FFF p0, struct S_FFF p1, void* p2,  struct S_FFF (*cb)(struct S_FFF, struct S_FFF, void*)) ;
+EXPORT struct S_FFD f19_S_SSP_FFD(struct S_FFD p0, struct S_FFD p1, void* p2,  struct S_FFD (*cb)(struct S_FFD, struct S_FFD, void*)) ;
+EXPORT struct S_FFP f19_S_SSP_FFP(struct S_FFP p0, struct S_FFP p1, void* p2,  struct S_FFP (*cb)(struct S_FFP, struct S_FFP, void*)) ;
+EXPORT struct S_FDI f19_S_SSP_FDI(struct S_FDI p0, struct S_FDI p1, void* p2,  struct S_FDI (*cb)(struct S_FDI, struct S_FDI, void*)) ;
+EXPORT struct S_FDF f19_S_SSP_FDF(struct S_FDF p0, struct S_FDF p1, void* p2,  struct S_FDF (*cb)(struct S_FDF, struct S_FDF, void*)) ;
+EXPORT struct S_FDD f19_S_SSP_FDD(struct S_FDD p0, struct S_FDD p1, void* p2,  struct S_FDD (*cb)(struct S_FDD, struct S_FDD, void*)) ;
+EXPORT struct S_FDP f19_S_SSP_FDP(struct S_FDP p0, struct S_FDP p1, void* p2,  struct S_FDP (*cb)(struct S_FDP, struct S_FDP, void*)) ;
+EXPORT struct S_FPI f19_S_SSP_FPI(struct S_FPI p0, struct S_FPI p1, void* p2,  struct S_FPI (*cb)(struct S_FPI, struct S_FPI, void*)) ;
+EXPORT struct S_FPF f19_S_SSP_FPF(struct S_FPF p0, struct S_FPF p1, void* p2,  struct S_FPF (*cb)(struct S_FPF, struct S_FPF, void*)) ;
+EXPORT struct S_FPD f19_S_SSP_FPD(struct S_FPD p0, struct S_FPD p1, void* p2,  struct S_FPD (*cb)(struct S_FPD, struct S_FPD, void*)) ;
+EXPORT struct S_FPP f19_S_SSP_FPP(struct S_FPP p0, struct S_FPP p1, void* p2,  struct S_FPP (*cb)(struct S_FPP, struct S_FPP, void*)) ;
+EXPORT struct S_DII f19_S_SSP_DII(struct S_DII p0, struct S_DII p1, void* p2,  struct S_DII (*cb)(struct S_DII, struct S_DII, void*)) ;
+EXPORT struct S_DIF f19_S_SSP_DIF(struct S_DIF p0, struct S_DIF p1, void* p2,  struct S_DIF (*cb)(struct S_DIF, struct S_DIF, void*)) ;
+EXPORT struct S_DID f19_S_SSP_DID(struct S_DID p0, struct S_DID p1, void* p2,  struct S_DID (*cb)(struct S_DID, struct S_DID, void*)) ;
+EXPORT struct S_DIP f19_S_SSP_DIP(struct S_DIP p0, struct S_DIP p1, void* p2,  struct S_DIP (*cb)(struct S_DIP, struct S_DIP, void*)) ;
+EXPORT struct S_DFI f19_S_SSP_DFI(struct S_DFI p0, struct S_DFI p1, void* p2,  struct S_DFI (*cb)(struct S_DFI, struct S_DFI, void*)) ;
+EXPORT struct S_DFF f19_S_SSP_DFF(struct S_DFF p0, struct S_DFF p1, void* p2,  struct S_DFF (*cb)(struct S_DFF, struct S_DFF, void*)) ;
+EXPORT struct S_DFD f19_S_SSP_DFD(struct S_DFD p0, struct S_DFD p1, void* p2,  struct S_DFD (*cb)(struct S_DFD, struct S_DFD, void*)) ;
+EXPORT struct S_DFP f19_S_SSP_DFP(struct S_DFP p0, struct S_DFP p1, void* p2,  struct S_DFP (*cb)(struct S_DFP, struct S_DFP, void*)) ;
+EXPORT struct S_DDI f19_S_SSP_DDI(struct S_DDI p0, struct S_DDI p1, void* p2,  struct S_DDI (*cb)(struct S_DDI, struct S_DDI, void*)) ;
+EXPORT struct S_DDF f19_S_SSP_DDF(struct S_DDF p0, struct S_DDF p1, void* p2,  struct S_DDF (*cb)(struct S_DDF, struct S_DDF, void*)) ;
+EXPORT struct S_DDD f19_S_SSP_DDD(struct S_DDD p0, struct S_DDD p1, void* p2,  struct S_DDD (*cb)(struct S_DDD, struct S_DDD, void*)) ;
+EXPORT struct S_DDP f19_S_SSP_DDP(struct S_DDP p0, struct S_DDP p1, void* p2,  struct S_DDP (*cb)(struct S_DDP, struct S_DDP, void*)) ;
+EXPORT struct S_DPI f19_S_SSP_DPI(struct S_DPI p0, struct S_DPI p1, void* p2,  struct S_DPI (*cb)(struct S_DPI, struct S_DPI, void*)) ;
+EXPORT struct S_DPF f19_S_SSP_DPF(struct S_DPF p0, struct S_DPF p1, void* p2,  struct S_DPF (*cb)(struct S_DPF, struct S_DPF, void*)) ;
+EXPORT struct S_DPD f19_S_SSP_DPD(struct S_DPD p0, struct S_DPD p1, void* p2,  struct S_DPD (*cb)(struct S_DPD, struct S_DPD, void*)) ;
+EXPORT struct S_DPP f19_S_SSP_DPP(struct S_DPP p0, struct S_DPP p1, void* p2,  struct S_DPP (*cb)(struct S_DPP, struct S_DPP, void*)) ;
+EXPORT struct S_PII f19_S_SSP_PII(struct S_PII p0, struct S_PII p1, void* p2,  struct S_PII (*cb)(struct S_PII, struct S_PII, void*)) ;
+EXPORT struct S_PIF f19_S_SSP_PIF(struct S_PIF p0, struct S_PIF p1, void* p2,  struct S_PIF (*cb)(struct S_PIF, struct S_PIF, void*)) ;
+EXPORT struct S_PID f19_S_SSP_PID(struct S_PID p0, struct S_PID p1, void* p2,  struct S_PID (*cb)(struct S_PID, struct S_PID, void*)) ;
+EXPORT struct S_PIP f20_S_SSP_PIP(struct S_PIP p0, struct S_PIP p1, void* p2,  struct S_PIP (*cb)(struct S_PIP, struct S_PIP, void*)) ;
+EXPORT struct S_PFI f20_S_SSP_PFI(struct S_PFI p0, struct S_PFI p1, void* p2,  struct S_PFI (*cb)(struct S_PFI, struct S_PFI, void*)) ;
+EXPORT struct S_PFF f20_S_SSP_PFF(struct S_PFF p0, struct S_PFF p1, void* p2,  struct S_PFF (*cb)(struct S_PFF, struct S_PFF, void*)) ;
+EXPORT struct S_PFD f20_S_SSP_PFD(struct S_PFD p0, struct S_PFD p1, void* p2,  struct S_PFD (*cb)(struct S_PFD, struct S_PFD, void*)) ;
+EXPORT struct S_PFP f20_S_SSP_PFP(struct S_PFP p0, struct S_PFP p1, void* p2,  struct S_PFP (*cb)(struct S_PFP, struct S_PFP, void*)) ;
+EXPORT struct S_PDI f20_S_SSP_PDI(struct S_PDI p0, struct S_PDI p1, void* p2,  struct S_PDI (*cb)(struct S_PDI, struct S_PDI, void*)) ;
+EXPORT struct S_PDF f20_S_SSP_PDF(struct S_PDF p0, struct S_PDF p1, void* p2,  struct S_PDF (*cb)(struct S_PDF, struct S_PDF, void*)) ;
+EXPORT struct S_PDD f20_S_SSP_PDD(struct S_PDD p0, struct S_PDD p1, void* p2,  struct S_PDD (*cb)(struct S_PDD, struct S_PDD, void*)) ;
+EXPORT struct S_PDP f20_S_SSP_PDP(struct S_PDP p0, struct S_PDP p1, void* p2,  struct S_PDP (*cb)(struct S_PDP, struct S_PDP, void*)) ;
+EXPORT struct S_PPI f20_S_SSP_PPI(struct S_PPI p0, struct S_PPI p1, void* p2,  struct S_PPI (*cb)(struct S_PPI, struct S_PPI, void*)) ;
+EXPORT struct S_PPF f20_S_SSP_PPF(struct S_PPF p0, struct S_PPF p1, void* p2,  struct S_PPF (*cb)(struct S_PPF, struct S_PPF, void*)) ;
+EXPORT struct S_PPD f20_S_SSP_PPD(struct S_PPD p0, struct S_PPD p1, void* p2,  struct S_PPD (*cb)(struct S_PPD, struct S_PPD, void*)) ;
+EXPORT struct S_PPP f20_S_SSP_PPP(struct S_PPP p0, struct S_PPP p1, void* p2,  struct S_PPP (*cb)(struct S_PPP, struct S_PPP, void*)) ;
+EXPORT struct S_I f20_S_SSS_I(struct S_I p0, struct S_I p1, struct S_I p2,  struct S_I (*cb)(struct S_I, struct S_I, struct S_I)) ;
+EXPORT struct S_F f20_S_SSS_F(struct S_F p0, struct S_F p1, struct S_F p2,  struct S_F (*cb)(struct S_F, struct S_F, struct S_F)) ;
+EXPORT struct S_D f20_S_SSS_D(struct S_D p0, struct S_D p1, struct S_D p2,  struct S_D (*cb)(struct S_D, struct S_D, struct S_D)) ;
+EXPORT struct S_P f20_S_SSS_P(struct S_P p0, struct S_P p1, struct S_P p2,  struct S_P (*cb)(struct S_P, struct S_P, struct S_P)) ;
+EXPORT struct S_II f20_S_SSS_II(struct S_II p0, struct S_II p1, struct S_II p2,  struct S_II (*cb)(struct S_II, struct S_II, struct S_II)) ;
+EXPORT struct S_IF f20_S_SSS_IF(struct S_IF p0, struct S_IF p1, struct S_IF p2,  struct S_IF (*cb)(struct S_IF, struct S_IF, struct S_IF)) ;
+EXPORT struct S_ID f20_S_SSS_ID(struct S_ID p0, struct S_ID p1, struct S_ID p2,  struct S_ID (*cb)(struct S_ID, struct S_ID, struct S_ID)) ;
+EXPORT struct S_IP f20_S_SSS_IP(struct S_IP p0, struct S_IP p1, struct S_IP p2,  struct S_IP (*cb)(struct S_IP, struct S_IP, struct S_IP)) ;
+EXPORT struct S_FI f20_S_SSS_FI(struct S_FI p0, struct S_FI p1, struct S_FI p2,  struct S_FI (*cb)(struct S_FI, struct S_FI, struct S_FI)) ;
+EXPORT struct S_FF f20_S_SSS_FF(struct S_FF p0, struct S_FF p1, struct S_FF p2,  struct S_FF (*cb)(struct S_FF, struct S_FF, struct S_FF)) ;
+EXPORT struct S_FD f20_S_SSS_FD(struct S_FD p0, struct S_FD p1, struct S_FD p2,  struct S_FD (*cb)(struct S_FD, struct S_FD, struct S_FD)) ;
+EXPORT struct S_FP f20_S_SSS_FP(struct S_FP p0, struct S_FP p1, struct S_FP p2,  struct S_FP (*cb)(struct S_FP, struct S_FP, struct S_FP)) ;
+EXPORT struct S_DI f20_S_SSS_DI(struct S_DI p0, struct S_DI p1, struct S_DI p2,  struct S_DI (*cb)(struct S_DI, struct S_DI, struct S_DI)) ;
+EXPORT struct S_DF f20_S_SSS_DF(struct S_DF p0, struct S_DF p1, struct S_DF p2,  struct S_DF (*cb)(struct S_DF, struct S_DF, struct S_DF)) ;
+EXPORT struct S_DD f20_S_SSS_DD(struct S_DD p0, struct S_DD p1, struct S_DD p2,  struct S_DD (*cb)(struct S_DD, struct S_DD, struct S_DD)) ;
+EXPORT struct S_DP f20_S_SSS_DP(struct S_DP p0, struct S_DP p1, struct S_DP p2,  struct S_DP (*cb)(struct S_DP, struct S_DP, struct S_DP)) ;
+EXPORT struct S_PI f20_S_SSS_PI(struct S_PI p0, struct S_PI p1, struct S_PI p2,  struct S_PI (*cb)(struct S_PI, struct S_PI, struct S_PI)) ;
+EXPORT struct S_PF f20_S_SSS_PF(struct S_PF p0, struct S_PF p1, struct S_PF p2,  struct S_PF (*cb)(struct S_PF, struct S_PF, struct S_PF)) ;
+EXPORT struct S_PD f20_S_SSS_PD(struct S_PD p0, struct S_PD p1, struct S_PD p2,  struct S_PD (*cb)(struct S_PD, struct S_PD, struct S_PD)) ;
+EXPORT struct S_PP f20_S_SSS_PP(struct S_PP p0, struct S_PP p1, struct S_PP p2,  struct S_PP (*cb)(struct S_PP, struct S_PP, struct S_PP)) ;
+EXPORT struct S_III f20_S_SSS_III(struct S_III p0, struct S_III p1, struct S_III p2,  struct S_III (*cb)(struct S_III, struct S_III, struct S_III)) ;
+EXPORT struct S_IIF f20_S_SSS_IIF(struct S_IIF p0, struct S_IIF p1, struct S_IIF p2,  struct S_IIF (*cb)(struct S_IIF, struct S_IIF, struct S_IIF)) ;
+EXPORT struct S_IID f20_S_SSS_IID(struct S_IID p0, struct S_IID p1, struct S_IID p2,  struct S_IID (*cb)(struct S_IID, struct S_IID, struct S_IID)) ;
+EXPORT struct S_IIP f20_S_SSS_IIP(struct S_IIP p0, struct S_IIP p1, struct S_IIP p2,  struct S_IIP (*cb)(struct S_IIP, struct S_IIP, struct S_IIP)) ;
+EXPORT struct S_IFI f20_S_SSS_IFI(struct S_IFI p0, struct S_IFI p1, struct S_IFI p2,  struct S_IFI (*cb)(struct S_IFI, struct S_IFI, struct S_IFI)) ;
+EXPORT struct S_IFF f20_S_SSS_IFF(struct S_IFF p0, struct S_IFF p1, struct S_IFF p2,  struct S_IFF (*cb)(struct S_IFF, struct S_IFF, struct S_IFF)) ;
+EXPORT struct S_IFD f20_S_SSS_IFD(struct S_IFD p0, struct S_IFD p1, struct S_IFD p2,  struct S_IFD (*cb)(struct S_IFD, struct S_IFD, struct S_IFD)) ;
+EXPORT struct S_IFP f20_S_SSS_IFP(struct S_IFP p0, struct S_IFP p1, struct S_IFP p2,  struct S_IFP (*cb)(struct S_IFP, struct S_IFP, struct S_IFP)) ;
+EXPORT struct S_IDI f20_S_SSS_IDI(struct S_IDI p0, struct S_IDI p1, struct S_IDI p2,  struct S_IDI (*cb)(struct S_IDI, struct S_IDI, struct S_IDI)) ;
+EXPORT struct S_IDF f20_S_SSS_IDF(struct S_IDF p0, struct S_IDF p1, struct S_IDF p2,  struct S_IDF (*cb)(struct S_IDF, struct S_IDF, struct S_IDF)) ;
+EXPORT struct S_IDD f20_S_SSS_IDD(struct S_IDD p0, struct S_IDD p1, struct S_IDD p2,  struct S_IDD (*cb)(struct S_IDD, struct S_IDD, struct S_IDD)) ;
+EXPORT struct S_IDP f20_S_SSS_IDP(struct S_IDP p0, struct S_IDP p1, struct S_IDP p2,  struct S_IDP (*cb)(struct S_IDP, struct S_IDP, struct S_IDP)) ;
+EXPORT struct S_IPI f20_S_SSS_IPI(struct S_IPI p0, struct S_IPI p1, struct S_IPI p2,  struct S_IPI (*cb)(struct S_IPI, struct S_IPI, struct S_IPI)) ;
+EXPORT struct S_IPF f20_S_SSS_IPF(struct S_IPF p0, struct S_IPF p1, struct S_IPF p2,  struct S_IPF (*cb)(struct S_IPF, struct S_IPF, struct S_IPF)) ;
+EXPORT struct S_IPD f20_S_SSS_IPD(struct S_IPD p0, struct S_IPD p1, struct S_IPD p2,  struct S_IPD (*cb)(struct S_IPD, struct S_IPD, struct S_IPD)) ;
+EXPORT struct S_IPP f20_S_SSS_IPP(struct S_IPP p0, struct S_IPP p1, struct S_IPP p2,  struct S_IPP (*cb)(struct S_IPP, struct S_IPP, struct S_IPP)) ;
+EXPORT struct S_FII f20_S_SSS_FII(struct S_FII p0, struct S_FII p1, struct S_FII p2,  struct S_FII (*cb)(struct S_FII, struct S_FII, struct S_FII)) ;
+EXPORT struct S_FIF f20_S_SSS_FIF(struct S_FIF p0, struct S_FIF p1, struct S_FIF p2,  struct S_FIF (*cb)(struct S_FIF, struct S_FIF, struct S_FIF)) ;
+EXPORT struct S_FID f20_S_SSS_FID(struct S_FID p0, struct S_FID p1, struct S_FID p2,  struct S_FID (*cb)(struct S_FID, struct S_FID, struct S_FID)) ;
+EXPORT struct S_FIP f20_S_SSS_FIP(struct S_FIP p0, struct S_FIP p1, struct S_FIP p2,  struct S_FIP (*cb)(struct S_FIP, struct S_FIP, struct S_FIP)) ;
+EXPORT struct S_FFI f20_S_SSS_FFI(struct S_FFI p0, struct S_FFI p1, struct S_FFI p2,  struct S_FFI (*cb)(struct S_FFI, struct S_FFI, struct S_FFI)) ;
+EXPORT struct S_FFF f20_S_SSS_FFF(struct S_FFF p0, struct S_FFF p1, struct S_FFF p2,  struct S_FFF (*cb)(struct S_FFF, struct S_FFF, struct S_FFF)) ;
+EXPORT struct S_FFD f20_S_SSS_FFD(struct S_FFD p0, struct S_FFD p1, struct S_FFD p2,  struct S_FFD (*cb)(struct S_FFD, struct S_FFD, struct S_FFD)) ;
+EXPORT struct S_FFP f20_S_SSS_FFP(struct S_FFP p0, struct S_FFP p1, struct S_FFP p2,  struct S_FFP (*cb)(struct S_FFP, struct S_FFP, struct S_FFP)) ;
+EXPORT struct S_FDI f20_S_SSS_FDI(struct S_FDI p0, struct S_FDI p1, struct S_FDI p2,  struct S_FDI (*cb)(struct S_FDI, struct S_FDI, struct S_FDI)) ;
+EXPORT struct S_FDF f20_S_SSS_FDF(struct S_FDF p0, struct S_FDF p1, struct S_FDF p2,  struct S_FDF (*cb)(struct S_FDF, struct S_FDF, struct S_FDF)) ;
+EXPORT struct S_FDD f20_S_SSS_FDD(struct S_FDD p0, struct S_FDD p1, struct S_FDD p2,  struct S_FDD (*cb)(struct S_FDD, struct S_FDD, struct S_FDD)) ;
+EXPORT struct S_FDP f20_S_SSS_FDP(struct S_FDP p0, struct S_FDP p1, struct S_FDP p2,  struct S_FDP (*cb)(struct S_FDP, struct S_FDP, struct S_FDP)) ;
+EXPORT struct S_FPI f20_S_SSS_FPI(struct S_FPI p0, struct S_FPI p1, struct S_FPI p2,  struct S_FPI (*cb)(struct S_FPI, struct S_FPI, struct S_FPI)) ;
+EXPORT struct S_FPF f20_S_SSS_FPF(struct S_FPF p0, struct S_FPF p1, struct S_FPF p2,  struct S_FPF (*cb)(struct S_FPF, struct S_FPF, struct S_FPF)) ;
+EXPORT struct S_FPD f20_S_SSS_FPD(struct S_FPD p0, struct S_FPD p1, struct S_FPD p2,  struct S_FPD (*cb)(struct S_FPD, struct S_FPD, struct S_FPD)) ;
+EXPORT struct S_FPP f20_S_SSS_FPP(struct S_FPP p0, struct S_FPP p1, struct S_FPP p2,  struct S_FPP (*cb)(struct S_FPP, struct S_FPP, struct S_FPP)) ;
+EXPORT struct S_DII f20_S_SSS_DII(struct S_DII p0, struct S_DII p1, struct S_DII p2,  struct S_DII (*cb)(struct S_DII, struct S_DII, struct S_DII)) ;
+EXPORT struct S_DIF f20_S_SSS_DIF(struct S_DIF p0, struct S_DIF p1, struct S_DIF p2,  struct S_DIF (*cb)(struct S_DIF, struct S_DIF, struct S_DIF)) ;
+EXPORT struct S_DID f20_S_SSS_DID(struct S_DID p0, struct S_DID p1, struct S_DID p2,  struct S_DID (*cb)(struct S_DID, struct S_DID, struct S_DID)) ;
+EXPORT struct S_DIP f20_S_SSS_DIP(struct S_DIP p0, struct S_DIP p1, struct S_DIP p2,  struct S_DIP (*cb)(struct S_DIP, struct S_DIP, struct S_DIP)) ;
+EXPORT struct S_DFI f20_S_SSS_DFI(struct S_DFI p0, struct S_DFI p1, struct S_DFI p2,  struct S_DFI (*cb)(struct S_DFI, struct S_DFI, struct S_DFI)) ;
+EXPORT struct S_DFF f20_S_SSS_DFF(struct S_DFF p0, struct S_DFF p1, struct S_DFF p2,  struct S_DFF (*cb)(struct S_DFF, struct S_DFF, struct S_DFF)) ;
+EXPORT struct S_DFD f20_S_SSS_DFD(struct S_DFD p0, struct S_DFD p1, struct S_DFD p2,  struct S_DFD (*cb)(struct S_DFD, struct S_DFD, struct S_DFD)) ;
+EXPORT struct S_DFP f20_S_SSS_DFP(struct S_DFP p0, struct S_DFP p1, struct S_DFP p2,  struct S_DFP (*cb)(struct S_DFP, struct S_DFP, struct S_DFP)) ;
+EXPORT struct S_DDI f20_S_SSS_DDI(struct S_DDI p0, struct S_DDI p1, struct S_DDI p2,  struct S_DDI (*cb)(struct S_DDI, struct S_DDI, struct S_DDI)) ;
+EXPORT struct S_DDF f20_S_SSS_DDF(struct S_DDF p0, struct S_DDF p1, struct S_DDF p2,  struct S_DDF (*cb)(struct S_DDF, struct S_DDF, struct S_DDF)) ;
+EXPORT struct S_DDD f20_S_SSS_DDD(struct S_DDD p0, struct S_DDD p1, struct S_DDD p2,  struct S_DDD (*cb)(struct S_DDD, struct S_DDD, struct S_DDD)) ;
+EXPORT struct S_DDP f20_S_SSS_DDP(struct S_DDP p0, struct S_DDP p1, struct S_DDP p2,  struct S_DDP (*cb)(struct S_DDP, struct S_DDP, struct S_DDP)) ;
+EXPORT struct S_DPI f20_S_SSS_DPI(struct S_DPI p0, struct S_DPI p1, struct S_DPI p2,  struct S_DPI (*cb)(struct S_DPI, struct S_DPI, struct S_DPI)) ;
+EXPORT struct S_DPF f20_S_SSS_DPF(struct S_DPF p0, struct S_DPF p1, struct S_DPF p2,  struct S_DPF (*cb)(struct S_DPF, struct S_DPF, struct S_DPF)) ;
+EXPORT struct S_DPD f20_S_SSS_DPD(struct S_DPD p0, struct S_DPD p1, struct S_DPD p2,  struct S_DPD (*cb)(struct S_DPD, struct S_DPD, struct S_DPD)) ;
+EXPORT struct S_DPP f20_S_SSS_DPP(struct S_DPP p0, struct S_DPP p1, struct S_DPP p2,  struct S_DPP (*cb)(struct S_DPP, struct S_DPP, struct S_DPP)) ;
+EXPORT struct S_PII f20_S_SSS_PII(struct S_PII p0, struct S_PII p1, struct S_PII p2,  struct S_PII (*cb)(struct S_PII, struct S_PII, struct S_PII)) ;
+EXPORT struct S_PIF f20_S_SSS_PIF(struct S_PIF p0, struct S_PIF p1, struct S_PIF p2,  struct S_PIF (*cb)(struct S_PIF, struct S_PIF, struct S_PIF)) ;
+EXPORT struct S_PID f20_S_SSS_PID(struct S_PID p0, struct S_PID p1, struct S_PID p2,  struct S_PID (*cb)(struct S_PID, struct S_PID, struct S_PID)) ;
+EXPORT struct S_PIP f20_S_SSS_PIP(struct S_PIP p0, struct S_PIP p1, struct S_PIP p2,  struct S_PIP (*cb)(struct S_PIP, struct S_PIP, struct S_PIP)) ;
+EXPORT struct S_PFI f20_S_SSS_PFI(struct S_PFI p0, struct S_PFI p1, struct S_PFI p2,  struct S_PFI (*cb)(struct S_PFI, struct S_PFI, struct S_PFI)) ;
+EXPORT struct S_PFF f20_S_SSS_PFF(struct S_PFF p0, struct S_PFF p1, struct S_PFF p2,  struct S_PFF (*cb)(struct S_PFF, struct S_PFF, struct S_PFF)) ;
+EXPORT struct S_PFD f20_S_SSS_PFD(struct S_PFD p0, struct S_PFD p1, struct S_PFD p2,  struct S_PFD (*cb)(struct S_PFD, struct S_PFD, struct S_PFD)) ;
+EXPORT struct S_PFP f20_S_SSS_PFP(struct S_PFP p0, struct S_PFP p1, struct S_PFP p2,  struct S_PFP (*cb)(struct S_PFP, struct S_PFP, struct S_PFP)) ;
+EXPORT struct S_PDI f20_S_SSS_PDI(struct S_PDI p0, struct S_PDI p1, struct S_PDI p2,  struct S_PDI (*cb)(struct S_PDI, struct S_PDI, struct S_PDI)) ;
+EXPORT struct S_PDF f20_S_SSS_PDF(struct S_PDF p0, struct S_PDF p1, struct S_PDF p2,  struct S_PDF (*cb)(struct S_PDF, struct S_PDF, struct S_PDF)) ;
+EXPORT struct S_PDD f20_S_SSS_PDD(struct S_PDD p0, struct S_PDD p1, struct S_PDD p2,  struct S_PDD (*cb)(struct S_PDD, struct S_PDD, struct S_PDD)) ;
+EXPORT struct S_PDP f20_S_SSS_PDP(struct S_PDP p0, struct S_PDP p1, struct S_PDP p2,  struct S_PDP (*cb)(struct S_PDP, struct S_PDP, struct S_PDP)) ;
+EXPORT struct S_PPI f20_S_SSS_PPI(struct S_PPI p0, struct S_PPI p1, struct S_PPI p2,  struct S_PPI (*cb)(struct S_PPI, struct S_PPI, struct S_PPI)) ;
+EXPORT struct S_PPF f20_S_SSS_PPF(struct S_PPF p0, struct S_PPF p1, struct S_PPF p2,  struct S_PPF (*cb)(struct S_PPF, struct S_PPF, struct S_PPF)) ;
+EXPORT struct S_PPD f20_S_SSS_PPD(struct S_PPD p0, struct S_PPD p1, struct S_PPD p2,  struct S_PPD (*cb)(struct S_PPD, struct S_PPD, struct S_PPD)) ;
+EXPORT struct S_PPP f20_S_SSS_PPP(struct S_PPP p0, struct S_PPP p1, struct S_PPP p2,  struct S_PPP (*cb)(struct S_PPP, struct S_PPP, struct S_PPP)) ;
diff --git a/test/jdk/java/foreign/libTestUpcallHighArity.c b/test/jdk/java/foreign/libTestUpcallHighArity.c
new file mode 100644
index 0000000000000..052bd2ce1686b
--- /dev/null
+++ b/test/jdk/java/foreign/libTestUpcallHighArity.c
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+#ifdef _WIN64
+#define EXPORT __declspec(dllexport)
+#else
+#define EXPORT
+#endif
+
+struct S_PDI { void* p0; double p1; int p2; };
+
+
+EXPORT void do_upcall(void (*cb)(struct S_PDI, int, double, void*, struct S_PDI, int, double, void*,
+                                 struct S_PDI, int, double, void*, struct S_PDI, int, double, void*),
+        struct S_PDI a0, int a1, double a2, void* a3, struct S_PDI a4, int a5, double a6, void* a7,
+        struct S_PDI a8, int a9, double a10, void* a11, struct S_PDI a12, int a13, double a14, void* a15) {
+    cb(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
+}
diff --git a/test/jdk/java/foreign/libVarArgs.c b/test/jdk/java/foreign/libVarArgs.c
new file mode 100644
index 0000000000000..f6f1209a60a26
--- /dev/null
+++ b/test/jdk/java/foreign/libVarArgs.c
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
+ *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ *  This code is free software; you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License version 2 only, as
+ *  published by the Free Software Foundation.
+ *
+ *  This code 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
+ *  version 2 for more details (a copy is included in the LICENSE file that
+ *  accompanied this code).
+ *
+ *  You should have received a copy of the GNU General Public License version
+ *  2 along with this work; if not, write to the Free Software Foundation,
+ *  Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ *   Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ *  or visit www.oracle.com if you need additional information or have any
+ *  questions.
+ *
+ */
+
+#include 
+
+#ifdef _WIN64
+#define EXPORT __declspec(dllexport)
+#else
+#define EXPORT
+#endif
+
+typedef struct {
+    unsigned char* writeback;
+    int* argids;
+} call_info;
+
+#define WRITEBACK_BYTES_PER_ARG 8
+#define write_back_ptr(type) ((type*)(info->writeback + (i * WRITEBACK_BYTES_PER_ARG)))
+
+// need to pass `num` separately as last argument preceding varargs according to spec (and for MSVC)
+EXPORT void varargs(call_info* info, int num, ...) {
+    va_list a_list;
+    va_start(a_list, num);
+
+    for (int i = 0; i < num; i++) {
+        int id = info->argids[i];
+        switch (id) {
+            case 0: // int
+                *write_back_ptr(int) = va_arg(a_list, int);
+                break;
+            case 1: // double
+                *write_back_ptr(double) = va_arg(a_list, double);
+                break;
+        }
+    }
+
+    va_end(a_list);
+}
diff --git a/test/jdk/java/foreign/stackwalk/TestStackWalk.java b/test/jdk/java/foreign/stackwalk/TestStackWalk.java
new file mode 100644
index 0000000000000..c12e33c2cec1e
--- /dev/null
+++ b/test/jdk/java/foreign/stackwalk/TestStackWalk.java
@@ -0,0 +1,111 @@
+/*
+ *  Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ *  This code is free software; you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License version 2 only, as
+ *  published by the Free Software Foundation.
+ *
+ *  This code 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
+ *  version 2 for more details (a copy is included in the LICENSE file that
+ *  accompanied this code).
+ *
+ *  You should have received a copy of the GNU General Public License version
+ *  2 along with this work; if not, write to the Free Software Foundation,
+ *  Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ *  Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ *  or visit www.oracle.com if you need additional information or have any
+ *  questions.
+ */
+
+/*
+ * @test
+ * @library /test/lib
+ * @build sun.hotspot.WhiteBox
+ * @run driver ClassFileInstaller sun.hotspot.WhiteBox
+ *
+ * @run main/othervm
+ *   -Xbootclasspath/a:.
+ *   -XX:+UnlockDiagnosticVMOptions
+ *   -XX:+WhiteBoxAPI
+ *   -Djdk.internal.foreign.ProgrammableInvoker.USE_INTRINSICS=true
+ *   -Dforeign.restricted=permit
+ *   -Xbatch
+ *   TestStackWalk
+ *
+ * @run main/othervm
+ *   -Xbootclasspath/a:.
+ *   -XX:+UnlockDiagnosticVMOptions
+ *   -XX:+WhiteBoxAPI
+ *   -Djdk.internal.foreign.ProgrammableInvoker.USE_INTRINSICS=false
+ *   -Dforeign.restricted=permit
+ *   -Xbatch
+ *   TestStackWalk
+ */
+
+import jdk.incubator.foreign.CLinker;
+import jdk.incubator.foreign.FunctionDescriptor;
+import jdk.incubator.foreign.LibraryLookup;
+import jdk.incubator.foreign.MemoryAddress;
+import jdk.incubator.foreign.MemorySegment;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodType;
+import java.lang.ref.Reference;
+
+import sun.hotspot.WhiteBox;
+
+import static java.lang.invoke.MethodHandles.lookup;
+import static jdk.incubator.foreign.CLinker.C_POINTER;
+
+public class TestStackWalk {
+    static final WhiteBox WB = WhiteBox.getWhiteBox();
+
+    static final CLinker linker = CLinker.getInstance();
+
+    static final MethodHandle MH_foo;
+    static final MethodHandle MH_m;
+
+    static {
+        try {
+            LibraryLookup lookup = LibraryLookup.ofLibrary("StackWalk");
+            MH_foo = linker.downcallHandle(
+                    lookup.lookup("foo").get(),
+                    MethodType.methodType(void.class, MemoryAddress.class),
+                    FunctionDescriptor.ofVoid(C_POINTER));
+            MH_m = lookup().findStatic(TestStackWalk.class, "m", MethodType.methodType(void.class));
+        } catch (ReflectiveOperationException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    static boolean armed;
+
+    public static void main(String[] args) throws Throwable {
+        try (MemorySegment stub = linker.upcallStub(MH_m, FunctionDescriptor.ofVoid())) {
+            MemoryAddress stubAddress = stub.address();
+            armed = false;
+            for (int i = 0; i < 20_000; i++) {
+                payload(stubAddress); // warmup
+            }
+
+            armed = true;
+            payload(stubAddress); // test
+        }
+    }
+
+    static void payload(MemoryAddress cb) throws Throwable {
+        MH_foo.invokeExact(cb);
+        Reference.reachabilityFence(cb); // keep oop alive across call
+    }
+
+    static void m() {
+        if (armed) {
+            WB.verifyFrames(true);
+        }
+    }
+
+}
diff --git a/test/jdk/java/foreign/stackwalk/libStackWalk.c b/test/jdk/java/foreign/stackwalk/libStackWalk.c
new file mode 100644
index 0000000000000..c1aa0112215f1
--- /dev/null
+++ b/test/jdk/java/foreign/stackwalk/libStackWalk.c
@@ -0,0 +1,33 @@
+/*
+ *  Copyright (c) 2020 Oracle and/or its affiliates. All rights reserved.
+ *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ *  This code is free software; you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License version 2 only, as
+ *  published by the Free Software Foundation.
+ *
+ *  This code 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
+ *  version 2 for more details (a copy is included in the LICENSE file that
+ *  accompanied this code).
+ *
+ *  You should have received a copy of the GNU General Public License version
+ *  2 along with this work; if not, write to the Free Software Foundation,
+ *  Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ *  Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ *  or visit www.oracle.com if you need additional information or have any
+ *  questions.
+ *
+ */
+
+#ifdef _WIN64
+#define EXPORT __declspec(dllexport)
+#else
+#define EXPORT
+#endif
+
+EXPORT void foo(void (*cb)(void)) {
+    cb();
+}
diff --git a/test/jdk/java/foreign/valist/VaListTest.java b/test/jdk/java/foreign/valist/VaListTest.java
new file mode 100644
index 0000000000000..de68bd61631eb
--- /dev/null
+++ b/test/jdk/java/foreign/valist/VaListTest.java
@@ -0,0 +1,807 @@
+/*
+ *  Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ *  This code is free software; you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License version 2 only, as
+ *  published by the Free Software Foundation.
+ *
+ *  This code 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
+ *  version 2 for more details (a copy is included in the LICENSE file that
+ *  accompanied this code).
+ *
+ *  You should have received a copy of the GNU General Public License version
+ *  2 along with this work; if not, write to the Free Software Foundation,
+ *  Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ *   Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ *  or visit www.oracle.com if you need additional information or have any
+ *  questions.
+ *
+ */
+
+/*
+ * @test
+ * @modules jdk.incubator.foreign/jdk.internal.foreign
+ *          jdk.incubator.foreign/jdk.internal.foreign.abi
+ *          jdk.incubator.foreign/jdk.internal.foreign.abi.aarch64
+ *          jdk.incubator.foreign/jdk.internal.foreign.abi.x64.windows
+ *          jdk.incubator.foreign/jdk.internal.foreign.abi.x64.sysv
+ * @run testng/othervm -Dforeign.restricted=permit VaListTest
+ */
+
+import jdk.incubator.foreign.*;
+import jdk.incubator.foreign.CLinker.VaList;
+import jdk.internal.foreign.abi.SharedUtils;
+import jdk.internal.foreign.abi.aarch64.AArch64Linker;
+import jdk.internal.foreign.abi.x64.sysv.SysVx64Linker;
+import jdk.internal.foreign.abi.x64.windows.Windowsx64Linker;
+import org.testng.annotations.DataProvider;
+import org.testng.annotations.Test;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandleProxies;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
+import java.lang.invoke.VarHandle;
+import java.util.function.BiFunction;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.stream.DoubleStream;
+import java.util.stream.IntStream;
+
+import static jdk.incubator.foreign.CLinker.C_DOUBLE;
+import static jdk.incubator.foreign.CLinker.C_FLOAT;
+import static jdk.incubator.foreign.CLinker.C_INT;
+import static jdk.incubator.foreign.CLinker.C_LONGLONG;
+import static jdk.incubator.foreign.CLinker.C_POINTER;
+import static jdk.incubator.foreign.CLinker.C_VA_LIST;
+import static jdk.incubator.foreign.MemoryLayout.PathElement.groupElement;
+import static jdk.incubator.foreign.MemoryLayouts.JAVA_INT;
+import static jdk.internal.foreign.PlatformLayouts.*;
+import static org.testng.Assert.assertEquals;
+import static org.testng.Assert.assertFalse;
+import static org.testng.Assert.assertTrue;
+
+public class VaListTest {
+
+    private static final CLinker abi = CLinker.getInstance();
+    private static final LibraryLookup lookup = LibraryLookup.ofLibrary("VaList");
+
+    private static final MethodHandle MH_sumInts = link("sumInts",
+            MethodType.methodType(int.class, int.class, VaList.class),
+            FunctionDescriptor.of(C_INT, C_INT, C_VA_LIST));
+    private static final MethodHandle MH_sumDoubles = link("sumDoubles",
+            MethodType.methodType(double.class, int.class, VaList.class),
+            FunctionDescriptor.of(C_DOUBLE, C_INT, C_VA_LIST));
+    private static final MethodHandle MH_getInt = link("getInt",
+            MethodType.methodType(int.class, VaList.class),
+            FunctionDescriptor.of(C_INT, C_VA_LIST));
+    private static final MethodHandle MH_sumStruct = link("sumStruct",
+            MethodType.methodType(int.class, VaList.class),
+            FunctionDescriptor.of(C_INT, C_VA_LIST));
+    private static final MethodHandle MH_sumBigStruct = link("sumBigStruct",
+            MethodType.methodType(long.class, VaList.class),
+            FunctionDescriptor.of(C_LONGLONG, C_VA_LIST));
+    private static final MethodHandle MH_sumHugeStruct = link("sumHugeStruct",
+            MethodType.methodType(long.class, VaList.class),
+            FunctionDescriptor.of(C_LONGLONG, C_VA_LIST));
+    private static final MethodHandle MH_sumFloatStruct = link("sumFloatStruct",
+            MethodType.methodType(float.class, VaList.class),
+            FunctionDescriptor.of(C_FLOAT, C_VA_LIST));
+    private static final MethodHandle MH_sumStack = link("sumStack",
+            MethodType.methodType(void.class, MemoryAddress.class, MemoryAddress.class, VaList.class),
+            FunctionDescriptor.ofVoid(C_POINTER, C_POINTER, C_VA_LIST));
+
+    private static MethodHandle link(String symbol, MethodType mt, FunctionDescriptor fd) {
+        return abi.downcallHandle(lookup.lookup(symbol).get(), mt, fd);
+    }
+
+    private static MethodHandle linkVaListCB(String symbol) {
+        return link(symbol,
+                MethodType.methodType(void.class, MemoryAddress.class),
+                FunctionDescriptor.ofVoid(C_POINTER));
+
+    }
+
+    private static final Function, VaList> winVaListFactory
+            = actions -> Windowsx64Linker.newVaList(actions, MemorySegment::allocateNative);
+    private static final Function, VaList> sysvVaListFactory
+            = actions -> SysVx64Linker.newVaList(actions, MemorySegment::allocateNative);
+    private static final Function, VaList> aarch64VaListFactory
+            = actions -> AArch64Linker.newVaList(actions, MemorySegment::allocateNative);
+    private static final Function, VaList> platformVaListFactory
+            = VaList::make;
+
+    private static final BiFunction, NativeScope, VaList> winVaListScopedFactory
+            = (actions, scope) -> Windowsx64Linker.newVaList(actions, SharedUtils.Allocator.ofScope(scope));
+    private static final BiFunction, NativeScope, VaList> sysvVaListScopedFactory
+            = (actions, scope) -> SysVx64Linker.newVaList(actions, SharedUtils.Allocator.ofScope(scope));
+    private static final BiFunction, NativeScope, VaList> aarch64VaListScopedFactory
+            = (actions, scope) -> AArch64Linker.newVaList(actions, SharedUtils.Allocator.ofScope(scope));
+    private static final BiFunction, NativeScope, VaList> platformVaListScopedFactory
+            = VaList::make;
+
+    @DataProvider
+    @SuppressWarnings("unchecked")
+    public static Object[][] sumInts() {
+        Function> sumIntsJavaFact = layout ->
+                (num, list) -> IntStream.generate(() -> list.vargAsInt(layout)).limit(num).sum();
+        BiFunction sumIntsNative
+                = MethodHandleProxies.asInterfaceInstance(BiFunction.class, MH_sumInts);
+        return new Object[][]{
+                { winVaListFactory,      sumIntsJavaFact.apply(Win64.C_INT),   Win64.C_INT   },
+                { sysvVaListFactory,     sumIntsJavaFact.apply(SysV.C_INT),    SysV.C_INT    },
+                { aarch64VaListFactory,  sumIntsJavaFact.apply(AArch64.C_INT), AArch64.C_INT },
+                { platformVaListFactory, sumIntsNative,                        C_INT         },
+        };
+    }
+
+    @Test(dataProvider = "sumInts")
+    public void testIntSum(Function, VaList> vaListFactory,
+                           BiFunction sumInts,
+                           ValueLayout intLayout) {
+        try (VaList vaList = vaListFactory.apply(b ->
+                b.vargFromInt(intLayout, 10)
+                        .vargFromInt(intLayout, 15)
+                        .vargFromInt(intLayout, 20))) {
+            int x = sumInts.apply(3, vaList);
+            assertEquals(x, 45);
+        }
+    }
+
+    @DataProvider
+    @SuppressWarnings("unchecked")
+    public static Object[][] sumDoubles() {
+        Function> sumDoublesJavaFact  = layout ->
+                (num, list) -> DoubleStream.generate(() -> list.vargAsDouble(layout)).limit(num).sum();
+        BiFunction sumDoublesNative
+                = MethodHandleProxies.asInterfaceInstance(BiFunction.class, MH_sumDoubles);
+        return new Object[][]{
+                { winVaListFactory,      sumDoublesJavaFact.apply(Win64.C_DOUBLE),   Win64.C_DOUBLE   },
+                { sysvVaListFactory,     sumDoublesJavaFact.apply(SysV.C_DOUBLE),    SysV.C_DOUBLE    },
+                { aarch64VaListFactory,  sumDoublesJavaFact.apply(AArch64.C_DOUBLE), AArch64.C_DOUBLE },
+                { platformVaListFactory, sumDoublesNative,                           C_DOUBLE         },
+        };
+    }
+
+    @Test(dataProvider = "sumDoubles")
+    public void testDoubleSum(Function, VaList> vaListFactory,
+                              BiFunction sumDoubles,
+                              ValueLayout doubleLayout) {
+        try (VaList vaList = vaListFactory.apply(b ->
+                b.vargFromDouble(doubleLayout, 3.0D)
+                        .vargFromDouble(doubleLayout, 4.0D)
+                        .vargFromDouble(doubleLayout, 5.0D))) {
+            double x = sumDoubles.apply(3, vaList);
+            assertEquals(x, 12.0D);
+        }
+    }
+
+    @DataProvider
+    @SuppressWarnings("unchecked")
+    public static Object[][] pointers() {
+        Function> getIntJavaFact = layout ->
+                list -> {
+                    MemoryAddress ma = list.vargAsAddress(layout);
+                    return MemoryAccess.getIntAtOffset(MemorySegment.ofNativeRestricted(), ma.toRawLongValue());
+                };
+        Function getIntNative = MethodHandleProxies.asInterfaceInstance(Function.class, MH_getInt);
+        return new Object[][]{
+                { winVaListFactory,      getIntJavaFact.apply(Win64.C_POINTER),   Win64.C_POINTER   },
+                { sysvVaListFactory,     getIntJavaFact.apply(SysV.C_POINTER),    SysV.C_POINTER    },
+                { aarch64VaListFactory,  getIntJavaFact.apply(AArch64.C_POINTER), AArch64.C_POINTER },
+                { platformVaListFactory, getIntNative,                            C_POINTER         },
+        };
+    }
+
+    @Test(dataProvider = "pointers")
+    public void testVaListMemoryAddress(Function, VaList> vaListFactory,
+                                        Function getFromPointer,
+                                        ValueLayout pointerLayout) {
+        try (MemorySegment msInt = MemorySegment.allocateNative(JAVA_INT)) {
+            MemoryAccess.setInt(msInt, 10);
+            try (VaList vaList = vaListFactory.apply(b -> b.vargFromAddress(pointerLayout, msInt.address()))) {
+                int x = getFromPointer.apply(vaList);
+                assertEquals(x, 10);
+            }
+        }
+    }
+
+    interface TriFunction {
+        R apply(S s, T t, U u);
+    }
+
+    @DataProvider
+    @SuppressWarnings("unchecked")
+    public static Object[][] structs() {
+        TriFunction> sumStructJavaFact
+                = (pointLayout, VH_Point_x, VH_Point_y) ->
+                list -> {
+                    MemorySegment struct = list.vargAsSegment(pointLayout);
+                    int x = (int) VH_Point_x.get(struct);
+                    int y = (int) VH_Point_y.get(struct);
+                    return x + y;
+                };
+
+        TriFunction> sumStructNativeFact
+                = (pointLayout, VH_Point_x, VH_Point_y) ->
+                MethodHandleProxies.asInterfaceInstance(Function.class, MH_sumStruct);
+
+        TriFunction, VaList>, MemoryLayout,
+                TriFunction>, Object[]> argsFact
+                = (vaListFact, intLayout, sumStructFact) -> {
+            GroupLayout pointLayout =  MemoryLayout.ofStruct(
+                    intLayout.withName("x"),
+                    intLayout.withName("y")
+            );
+            VarHandle VH_Point_x = pointLayout.varHandle(int.class, groupElement("x"));
+            VarHandle VH_Point_y = pointLayout.varHandle(int.class, groupElement("y"));
+            return new Object[] { vaListFact, sumStructFact.apply(pointLayout, VH_Point_x, VH_Point_y),
+                    pointLayout, VH_Point_x, VH_Point_y  };
+        };
+        return new Object[][]{
+                argsFact.apply(winVaListFactory,      Win64.C_INT,   sumStructJavaFact),
+                argsFact.apply(sysvVaListFactory,     SysV.C_INT,    sumStructJavaFact),
+                argsFact.apply(aarch64VaListFactory,  AArch64.C_INT, sumStructJavaFact),
+                argsFact.apply(platformVaListFactory, C_INT,         sumStructNativeFact),
+        };
+    }
+
+    @Test(dataProvider = "structs")
+    public void testStruct(Function, VaList> vaListFactory,
+                           Function sumStruct,
+                           GroupLayout Point_LAYOUT, VarHandle VH_Point_x, VarHandle VH_Point_y) {
+        try (MemorySegment struct = MemorySegment.allocateNative(Point_LAYOUT)) {
+            VH_Point_x.set(struct, 5);
+            VH_Point_y.set(struct, 10);
+
+            try (VaList vaList = vaListFactory.apply(b -> b.vargFromSegment(Point_LAYOUT, struct))) {
+                int sum = sumStruct.apply(vaList);
+                assertEquals(sum, 15);
+            }
+        }
+    }
+
+    @DataProvider
+    @SuppressWarnings("unchecked")
+    public static Object[][] bigStructs() {
+        TriFunction> sumStructJavaFact
+                = (BigPoint_LAYOUT, VH_BigPoint_x, VH_BigPoint_y) ->
+                list -> {
+                    MemorySegment struct = list.vargAsSegment(BigPoint_LAYOUT);
+                    long x = (long) VH_BigPoint_x.get(struct);
+                    long y = (long) VH_BigPoint_y.get(struct);
+                    return x + y;
+                };
+
+        TriFunction> sumStructNativeFact
+                = (pointLayout, VH_BigPoint_x, VH_BigPoint_y) ->
+                MethodHandleProxies.asInterfaceInstance(Function.class, MH_sumBigStruct);
+
+        TriFunction, VaList>, MemoryLayout,
+                TriFunction>, Object[]> argsFact
+                = (vaListFact, longLongLayout, sumBigStructFact) -> {
+            GroupLayout BigPoint_LAYOUT =  MemoryLayout.ofStruct(
+                    longLongLayout.withName("x"),
+                    longLongLayout.withName("y")
+            );
+            VarHandle VH_BigPoint_x = BigPoint_LAYOUT.varHandle(long.class, groupElement("x"));
+            VarHandle VH_BigPoint_y = BigPoint_LAYOUT.varHandle(long.class, groupElement("y"));
+            return new Object[] { vaListFact, sumBigStructFact.apply(BigPoint_LAYOUT, VH_BigPoint_x, VH_BigPoint_y),
+                    BigPoint_LAYOUT, VH_BigPoint_x, VH_BigPoint_y  };
+        };
+        return new Object[][]{
+                argsFact.apply(winVaListFactory,      Win64.C_LONGLONG,   sumStructJavaFact),
+                argsFact.apply(sysvVaListFactory,     SysV.C_LONGLONG,    sumStructJavaFact),
+                argsFact.apply(aarch64VaListFactory,  AArch64.C_LONGLONG, sumStructJavaFact),
+                argsFact.apply(platformVaListFactory, C_LONGLONG,         sumStructNativeFact),
+        };
+    }
+
+    @Test(dataProvider = "bigStructs")
+    public void testBigStruct(Function, VaList> vaListFactory,
+                              Function sumBigStruct,
+                              GroupLayout BigPoint_LAYOUT, VarHandle VH_BigPoint_x, VarHandle VH_BigPoint_y) {
+        try (MemorySegment struct = MemorySegment.allocateNative(BigPoint_LAYOUT)) {
+            VH_BigPoint_x.set(struct, 5);
+            VH_BigPoint_y.set(struct, 10);
+
+            try (VaList vaList = vaListFactory.apply(b -> b.vargFromSegment(BigPoint_LAYOUT, struct))) {
+                long sum = sumBigStruct.apply(vaList);
+                assertEquals(sum, 15);
+            }
+        }
+    }
+
+    @DataProvider
+    @SuppressWarnings("unchecked")
+    public static Object[][] floatStructs() {
+        TriFunction> sumStructJavaFact
+                = (FloatPoint_LAYOUT, VH_FloatPoint_x, VH_FloatPoint_y) ->
+                list -> {
+                    MemorySegment struct = list.vargAsSegment(FloatPoint_LAYOUT);
+                    float x = (float) VH_FloatPoint_x.get(struct);
+                    float y = (float) VH_FloatPoint_y.get(struct);
+                    return x + y;
+                };
+
+        TriFunction> sumStructNativeFact
+                = (pointLayout, VH_FloatPoint_x, VH_FloatPoint_y) ->
+                MethodHandleProxies.asInterfaceInstance(Function.class, MH_sumFloatStruct);
+
+        TriFunction, VaList>, MemoryLayout,
+                TriFunction>, Object[]> argsFact
+                = (vaListFact, floatLayout, sumFloatStructFact) -> {
+            GroupLayout FloatPoint_LAYOUT = MemoryLayout.ofStruct(
+                    floatLayout.withName("x"),
+                    floatLayout.withName("y")
+            );
+            VarHandle VH_FloatPoint_x = FloatPoint_LAYOUT.varHandle(float.class, groupElement("x"));
+            VarHandle VH_FloatPoint_y = FloatPoint_LAYOUT.varHandle(float.class, groupElement("y"));
+            return new Object[] { vaListFact, sumFloatStructFact.apply(FloatPoint_LAYOUT, VH_FloatPoint_x, VH_FloatPoint_y),
+                    FloatPoint_LAYOUT, VH_FloatPoint_x, VH_FloatPoint_y  };
+        };
+        return new Object[][]{
+                argsFact.apply(winVaListFactory,      Win64.C_FLOAT,   sumStructJavaFact),
+                argsFact.apply(sysvVaListFactory,     SysV.C_FLOAT,    sumStructJavaFact),
+                argsFact.apply(aarch64VaListFactory,  AArch64.C_FLOAT, sumStructJavaFact),
+                argsFact.apply(platformVaListFactory, C_FLOAT,         sumStructNativeFact),
+        };
+    }
+
+    @Test(dataProvider = "floatStructs")
+    public void testFloatStruct(Function, VaList> vaListFactory,
+                                Function sumFloatStruct,
+                                GroupLayout FloatPoint_LAYOUT,
+                                VarHandle VH_FloatPoint_x, VarHandle VH_FloatPoint_y) {
+        try (MemorySegment struct = MemorySegment.allocateNative(FloatPoint_LAYOUT)) {
+            VH_FloatPoint_x.set(struct, 1.234f);
+            VH_FloatPoint_y.set(struct, 3.142f);
+
+            try (VaList vaList = vaListFactory.apply(b -> b.vargFromSegment(FloatPoint_LAYOUT, struct))) {
+                float sum = sumFloatStruct.apply(vaList);
+                assertEquals(sum, 4.376f, 0.00001f);
+            }
+        }
+    }
+
+    interface QuadFunc {
+        R apply(T0 t0, T1 t1, T2 t2, T3 t3);
+    }
+
+    @DataProvider
+    @SuppressWarnings("unchecked")
+    public static Object[][] hugeStructs() {
+        QuadFunc> sumStructJavaFact
+                = (HugePoint_LAYOUT, VH_HugePoint_x, VH_HugePoint_y, VH_HugePoint_z) ->
+                list -> {
+                    MemorySegment struct = list.vargAsSegment(HugePoint_LAYOUT);
+                    long x = (long) VH_HugePoint_x.get(struct);
+                    long y = (long) VH_HugePoint_y.get(struct);
+                    long z = (long) VH_HugePoint_z.get(struct);
+                    return x + y + z;
+                };
+
+        QuadFunc> sumStructNativeFact
+                = (pointLayout, VH_HugePoint_x, VH_HugePoint_y, VH_HugePoint_z) ->
+                MethodHandleProxies.asInterfaceInstance(Function.class, MH_sumHugeStruct);
+
+        TriFunction, VaList>, MemoryLayout,
+                QuadFunc>, Object[]> argsFact
+                = (vaListFact, longLongLayout, sumBigStructFact) -> {
+            GroupLayout HugePoint_LAYOUT = MemoryLayout.ofStruct(
+                    longLongLayout.withName("x"),
+                    longLongLayout.withName("y"),
+                    longLongLayout.withName("z")
+            );
+            VarHandle VH_HugePoint_x = HugePoint_LAYOUT.varHandle(long.class, groupElement("x"));
+            VarHandle VH_HugePoint_y = HugePoint_LAYOUT.varHandle(long.class, groupElement("y"));
+            VarHandle VH_HugePoint_z = HugePoint_LAYOUT.varHandle(long.class, groupElement("z"));
+            return new Object[] { vaListFact,
+                    sumBigStructFact.apply(HugePoint_LAYOUT, VH_HugePoint_x, VH_HugePoint_y, VH_HugePoint_z),
+                    HugePoint_LAYOUT, VH_HugePoint_x, VH_HugePoint_y, VH_HugePoint_z  };
+        };
+        return new Object[][]{
+                argsFact.apply(winVaListFactory,      Win64.C_LONGLONG,   sumStructJavaFact),
+                argsFact.apply(sysvVaListFactory,     SysV.C_LONGLONG,    sumStructJavaFact),
+                argsFact.apply(aarch64VaListFactory,  AArch64.C_LONGLONG, sumStructJavaFact),
+                argsFact.apply(platformVaListFactory, C_LONGLONG,         sumStructNativeFact),
+        };
+    }
+
+    @Test(dataProvider = "hugeStructs")
+    public void testHugeStruct(Function, VaList> vaListFactory,
+                               Function sumHugeStruct,
+                               GroupLayout HugePoint_LAYOUT,
+                               VarHandle VH_HugePoint_x, VarHandle VH_HugePoint_y, VarHandle VH_HugePoint_z) {
+        // On AArch64 a struct needs to be larger than 16 bytes to be
+        // passed by reference.
+        try (MemorySegment struct = MemorySegment.allocateNative(HugePoint_LAYOUT)) {
+            VH_HugePoint_x.set(struct, 1);
+            VH_HugePoint_y.set(struct, 2);
+            VH_HugePoint_z.set(struct, 3);
+
+            try (VaList vaList = vaListFactory.apply(b -> b.vargFromSegment(HugePoint_LAYOUT, struct))) {
+                long sum = sumHugeStruct.apply(vaList);
+                assertEquals(sum, 6);
+            }
+        }
+    }
+
+    public interface SumStackFunc {
+        void invoke(MemorySegment longSum, MemorySegment doubleSum, VaList list);
+    }
+
+    @DataProvider
+    public static Object[][] sumStack() {
+        BiFunction sumStackJavaFact = (longLayout, doubleLayout) ->
+                (longSum, doubleSum, list) -> {
+                    long lSum = 0L;
+                    for (int i = 0; i < 16; i++) {
+                        lSum += list.vargAsLong(longLayout);
+                    }
+                    MemoryAccess.setLong(longSum, lSum);
+                    double dSum = 0D;
+                    for (int i = 0; i < 16; i++) {
+                        dSum += list.vargAsDouble(doubleLayout);
+                    }
+                    MemoryAccess.setDouble(doubleSum, dSum);
+                };
+        SumStackFunc sumStackNative = (longSum, doubleSum, list) -> {
+            try {
+                MH_sumStack.invokeExact(longSum.address(), doubleSum.address(), list);
+            } catch (Throwable ex) {
+                throw new AssertionError(ex);
+            }
+        };
+        return new Object[][]{
+                { winVaListFactory,      sumStackJavaFact.apply(Win64.C_LONGLONG, Win64.C_DOUBLE),     Win64.C_LONGLONG,   Win64.C_DOUBLE   },
+                { sysvVaListFactory,     sumStackJavaFact.apply(SysV.C_LONGLONG, SysV.C_DOUBLE),       SysV.C_LONGLONG,    SysV.C_DOUBLE    },
+                { aarch64VaListFactory,  sumStackJavaFact.apply(AArch64.C_LONGLONG, AArch64.C_DOUBLE), AArch64.C_LONGLONG, AArch64.C_DOUBLE },
+                { platformVaListFactory, sumStackNative,                                               C_LONGLONG,         C_DOUBLE         },
+        };
+    }
+
+    @Test(dataProvider = "sumStack")
+    public void testStack(Function, VaList> vaListFactory,
+                          SumStackFunc sumStack,
+                          ValueLayout longLayout,
+                          ValueLayout doubleLayout) {
+        try (MemorySegment longSum = MemorySegment.allocateNative(longLayout);
+             MemorySegment doubleSum = MemorySegment.allocateNative(doubleLayout)) {
+            MemoryAccess.setLong(longSum, 0L);
+            MemoryAccess.setDouble(doubleSum, 0D);
+
+            VaList list = vaListFactory.apply(b -> {
+                for (long l = 1; l <= 16L; l++) {
+                    b.vargFromLong(longLayout, l);
+                }
+                for (double d = 1; d <= 16D; d++) {
+                    b.vargFromDouble(doubleLayout, d);
+                }
+            });
+
+            try (list) {
+                sumStack.invoke(longSum, doubleSum, list);
+            }
+
+            long lSum = MemoryAccess.getLong(longSum);
+            double dSum = MemoryAccess.getDouble(doubleSum);
+
+            assertEquals(lSum, 136L);
+            assertEquals(dSum, 136D);
+        }
+    }
+
+    @Test(dataProvider = "upcalls")
+    public void testUpcall(MethodHandle target, MethodHandle callback) throws Throwable {
+        FunctionDescriptor desc = FunctionDescriptor.ofVoid(C_VA_LIST);
+        try (MemorySegment stub = abi.upcallStub(callback, desc)) {
+            target.invokeExact(stub.address());
+        }
+    }
+
+    @DataProvider
+    public Object[][] emptyVaLists() {
+        return new Object[][] {
+                { Windowsx64Linker.emptyVaList()      },
+                { winVaListFactory.apply(b -> {})     },
+                { SysVx64Linker.emptyVaList()         },
+                { sysvVaListFactory.apply(b -> {})    },
+                { AArch64Linker.emptyVaList()         },
+                { aarch64VaListFactory.apply(b -> {}) },
+        };
+    }
+
+    @Test(expectedExceptions = UnsupportedOperationException.class,
+            expectedExceptionsMessageRegExp = ".*Empty VaList.*",
+            dataProvider = "emptyVaLists")
+    public void testEmptyNotCloseable(VaList emptyList) {
+        emptyList.close();
+    }
+
+    @DataProvider
+    @SuppressWarnings("unchecked")
+    public static Object[][] sumIntsScoped() {
+        Function> sumIntsJavaFact = layout ->
+                (num, list) -> IntStream.generate(() -> list.vargAsInt(layout)).limit(num).sum();
+        BiFunction sumIntsNative
+                = MethodHandleProxies.asInterfaceInstance(BiFunction.class, MH_sumInts);
+        return new Object[][]{
+                { winVaListScopedFactory,      sumIntsJavaFact.apply(Win64.C_INT),   Win64.C_INT   },
+                { sysvVaListScopedFactory,     sumIntsJavaFact.apply(SysV.C_INT),    SysV.C_INT    },
+                { aarch64VaListScopedFactory,  sumIntsJavaFact.apply(AArch64.C_INT), AArch64.C_INT },
+                { platformVaListScopedFactory, sumIntsNative,                        C_INT         },
+        };
+    }
+
+    @Test(dataProvider = "sumIntsScoped")
+    public void testScopedVaList(BiFunction, NativeScope, VaList> vaListFactory,
+                                 BiFunction sumInts,
+                                 ValueLayout intLayout) {
+        VaList listLeaked;
+        try (NativeScope scope = NativeScope.unboundedScope()) {
+            VaList list = vaListFactory.apply(b -> b.vargFromInt(intLayout, 4)
+                            .vargFromInt(intLayout, 8),
+                    scope);
+            int x = sumInts.apply(2, list);
+            assertEquals(x, 12);
+            listLeaked = list;
+        }
+        assertFalse(listLeaked.isAlive());
+    }
+
+    @Test(dataProvider = "structs")
+    public void testScopeMSRead(Function, VaList> vaListFactory,
+                                Function sumStruct, // ignored
+                                GroupLayout Point_LAYOUT, VarHandle VH_Point_x, VarHandle VH_Point_y) {
+        MemorySegment pointOut;
+        try (NativeScope scope = NativeScope.unboundedScope()) {
+            try (MemorySegment pointIn = MemorySegment.allocateNative(Point_LAYOUT)) {
+                VH_Point_x.set(pointIn, 3);
+                VH_Point_y.set(pointIn, 6);
+                try (VaList list = vaListFactory.apply(b -> b.vargFromSegment(Point_LAYOUT, pointIn))) {
+                    pointOut = list.vargAsSegment(Point_LAYOUT, scope);
+                    assertEquals((int) VH_Point_x.get(pointOut), 3);
+                    assertEquals((int) VH_Point_y.get(pointOut), 6);
+                }
+                assertTrue(pointOut.isAlive()); // after VaList freed
+            }
+            assertTrue(pointOut.isAlive()); // after input MS freed
+        }
+        assertFalse(pointOut.isAlive()); // after scope freed
+    }
+
+    @DataProvider
+    public Object[][] copy() {
+        return new Object[][] {
+                { winVaListFactory,      Win64.C_INT   },
+                { sysvVaListFactory,     SysV.C_INT    },
+                { aarch64VaListFactory,  AArch64.C_INT },
+        };
+    }
+
+    @Test(dataProvider = "copy")
+    public void testCopy(Function, VaList> vaListFactory, ValueLayout intLayout) {
+        try (VaList list = vaListFactory.apply(b -> b.vargFromInt(intLayout, 4)
+                .vargFromInt(intLayout, 8))) {
+            VaList  copy = list.copy();
+            assertEquals(copy.vargAsInt(intLayout), 4);
+            assertEquals(copy.vargAsInt(intLayout), 8);
+            copy.close();
+
+            assertFalse(copy.isAlive());
+
+            assertEquals(list.vargAsInt(intLayout), 4);
+            assertEquals(list.vargAsInt(intLayout), 8);
+        }
+    }
+
+    @Test(dataProvider = "copy")
+    public void testScopedCopy(Function, VaList> vaListFactory, ValueLayout intLayout) {
+        try (VaList list = vaListFactory.apply(b -> b.vargFromInt(intLayout, 4)
+                .vargFromInt(intLayout, 8))) {
+            VaList copy;
+            try (NativeScope scope = NativeScope.unboundedScope()) {
+                copy = list.copy(scope);
+
+                assertEquals(copy.vargAsInt(intLayout), 4);
+                assertEquals(copy.vargAsInt(intLayout), 8);
+            }
+            assertFalse(copy.isAlive());
+
+            assertEquals(list.vargAsInt(intLayout), 4);
+            assertEquals(list.vargAsInt(intLayout), 8);
+        }
+    }
+
+    @Test(dataProvider = "copy",
+            expectedExceptions = IllegalStateException.class)
+    public void testCopyUnusableAfterOriginalClosed(Function, VaList> vaListFactory,
+                                                    ValueLayout intLayout) {
+        VaList list = vaListFactory.apply(b -> b.vargFromInt(intLayout, 4)
+                .vargFromInt(intLayout, 8));
+        try (VaList copy = list.copy()) {
+            list.close();
+
+            copy.vargAsInt(intLayout); // should throw
+        }
+    }
+
+    @Test(dataProvider = "copy",
+            expectedExceptions = IllegalStateException.class)
+    public void testCopyUnusableAfterOriginalClosedScope(Function, VaList> vaListFactory,
+                                                         ValueLayout intLayout) {
+        VaList list = vaListFactory.apply(b -> b.vargFromInt(intLayout, 4)
+                .vargFromInt(intLayout, 8));
+        try (NativeScope scope = NativeScope.unboundedScope()) {
+            VaList copy = list.copy(scope);
+            list.close();
+
+            copy.vargAsInt(intLayout); // should throw
+        }
+    }
+
+    @DataProvider
+    public static Object[][] upcalls() {
+        GroupLayout BigPoint_LAYOUT = MemoryLayout.ofStruct(
+                C_LONGLONG.withName("x"),
+                C_LONGLONG.withName("y")
+        );
+        VarHandle VH_BigPoint_x = BigPoint_LAYOUT.varHandle(long.class, groupElement("x"));
+        VarHandle VH_BigPoint_y = BigPoint_LAYOUT.varHandle(long.class, groupElement("y"));
+        GroupLayout Point_LAYOUT = MemoryLayout.ofStruct(
+                C_INT.withName("x"),
+                C_INT.withName("y")
+        );
+        VarHandle VH_Point_x = Point_LAYOUT.varHandle(int.class, groupElement("x"));
+        VarHandle VH_Point_y = Point_LAYOUT.varHandle(int.class, groupElement("y"));
+        GroupLayout FloatPoint_LAYOUT = MemoryLayout.ofStruct(
+                C_FLOAT.withName("x"),
+                C_FLOAT.withName("y")
+        );
+        VarHandle VH_FloatPoint_x = FloatPoint_LAYOUT.varHandle(float.class, groupElement("x"));
+        VarHandle VH_FloatPoint_y = FloatPoint_LAYOUT.varHandle(float.class, groupElement("y"));
+        GroupLayout HugePoint_LAYOUT = MemoryLayout.ofStruct(
+                C_LONGLONG.withName("x"),
+                C_LONGLONG.withName("y"),
+                C_LONGLONG.withName("z")
+        );
+        VarHandle VH_HugePoint_x = HugePoint_LAYOUT.varHandle(long.class, groupElement("x"));
+        VarHandle VH_HugePoint_y = HugePoint_LAYOUT.varHandle(long.class, groupElement("y"));
+        VarHandle VH_HugePoint_z = HugePoint_LAYOUT.varHandle(long.class, groupElement("z"));
+
+        return new Object[][]{
+                { linkVaListCB("upcallBigStruct"), VaListConsumer.mh(vaList -> {
+                    try (MemorySegment struct = vaList.vargAsSegment(BigPoint_LAYOUT)) {
+                        assertEquals((long) VH_BigPoint_x.get(struct), 8);
+                        assertEquals((long) VH_BigPoint_y.get(struct), 16);
+                    }
+                })},
+                { linkVaListCB("upcallBigStruct"), VaListConsumer.mh(vaList -> {
+                    VaList copy = vaList.copy();
+                    try (MemorySegment struct = vaList.vargAsSegment(BigPoint_LAYOUT)) {
+                        assertEquals((long) VH_BigPoint_x.get(struct), 8);
+                        assertEquals((long) VH_BigPoint_y.get(struct), 16);
+
+                        VH_BigPoint_x.set(struct, 0);
+                        VH_BigPoint_y.set(struct, 0);
+                    }
+
+                    // should be independent
+                    try (MemorySegment struct = copy.vargAsSegment(BigPoint_LAYOUT)) {
+                        assertEquals((long) VH_BigPoint_x.get(struct), 8);
+                        assertEquals((long) VH_BigPoint_y.get(struct), 16);
+                    }
+                })},
+                { linkVaListCB("upcallStruct"), VaListConsumer.mh(vaList -> {
+                    try (MemorySegment struct = vaList.vargAsSegment(Point_LAYOUT)) {
+                        assertEquals((int) VH_Point_x.get(struct), 5);
+                        assertEquals((int) VH_Point_y.get(struct), 10);
+                    }
+                })},
+                { linkVaListCB("upcallHugeStruct"), VaListConsumer.mh(vaList -> {
+                    try (MemorySegment struct = vaList.vargAsSegment(HugePoint_LAYOUT)) {
+                        assertEquals((long) VH_HugePoint_x.get(struct), 1);
+                        assertEquals((long) VH_HugePoint_y.get(struct), 2);
+                        assertEquals((long) VH_HugePoint_z.get(struct), 3);
+                    }
+                })},
+                { linkVaListCB("upcallFloatStruct"), VaListConsumer.mh(vaList -> {
+                    try (MemorySegment struct = vaList.vargAsSegment(FloatPoint_LAYOUT)) {
+                        assertEquals((float) VH_FloatPoint_x.get(struct), 1.0f);
+                        assertEquals((float) VH_FloatPoint_y.get(struct), 2.0f);
+                    }
+                })},
+                { linkVaListCB("upcallMemoryAddress"), VaListConsumer.mh(vaList -> {
+                    MemoryAddress intPtr = vaList.vargAsAddress(C_POINTER);
+                    MemorySegment ms = intPtr.asSegmentRestricted(C_INT.byteSize());
+                    int x = MemoryAccess.getInt(ms);
+                    assertEquals(x, 10);
+                })},
+                { linkVaListCB("upcallDoubles"), VaListConsumer.mh(vaList -> {
+                    assertEquals(vaList.vargAsDouble(C_DOUBLE), 3.0);
+                    assertEquals(vaList.vargAsDouble(C_DOUBLE), 4.0);
+                    assertEquals(vaList.vargAsDouble(C_DOUBLE), 5.0);
+                })},
+                { linkVaListCB("upcallInts"), VaListConsumer.mh(vaList -> {
+                    assertEquals(vaList.vargAsInt(C_INT), 10);
+                    assertEquals(vaList.vargAsInt(C_INT), 15);
+                    assertEquals(vaList.vargAsInt(C_INT), 20);
+                })},
+                { linkVaListCB("upcallStack"), VaListConsumer.mh(vaList -> {
+                    // skip all registers
+                    for (long l = 1; l <= 16; l++) {
+                        assertEquals(vaList.vargAsLong(C_LONGLONG), l);
+                    }
+                    for (double d = 1; d <= 16; d++) {
+                        assertEquals(vaList.vargAsDouble(C_DOUBLE), d);
+                    }
+
+                    // test some arbitrary values on the stack
+                    assertEquals((byte) vaList.vargAsInt(C_INT), (byte) 1);
+                    assertEquals((char) vaList.vargAsInt(C_INT), 'a');
+                    assertEquals((short) vaList.vargAsInt(C_INT), (short) 3);
+                    assertEquals(vaList.vargAsInt(C_INT), 4);
+                    assertEquals(vaList.vargAsLong(C_LONGLONG), 5L);
+                    assertEquals((float) vaList.vargAsDouble(C_DOUBLE), 6.0F);
+                    assertEquals(vaList.vargAsDouble(C_DOUBLE), 7.0D);
+                    assertEquals((byte) vaList.vargAsInt(C_INT), (byte) 8);
+                    assertEquals((char) vaList.vargAsInt(C_INT), 'b');
+                    assertEquals((short) vaList.vargAsInt(C_INT), (short) 10);
+                    assertEquals(vaList.vargAsInt(C_INT), 11);
+                    assertEquals(vaList.vargAsLong(C_LONGLONG), 12L);
+                    assertEquals((float) vaList.vargAsDouble(C_DOUBLE), 13.0F);
+                    assertEquals(vaList.vargAsDouble(C_DOUBLE), 14.0D);
+
+                    try (MemorySegment point = vaList.vargAsSegment(Point_LAYOUT)) {
+                        assertEquals((int) VH_Point_x.get(point), 5);
+                        assertEquals((int) VH_Point_y.get(point), 10);
+                    }
+
+                    VaList copy = vaList.copy();
+                    try (MemorySegment bigPoint = vaList.vargAsSegment(BigPoint_LAYOUT)) {
+                        assertEquals((long) VH_BigPoint_x.get(bigPoint), 15);
+                        assertEquals((long) VH_BigPoint_y.get(bigPoint), 20);
+
+                        VH_BigPoint_x.set(bigPoint, 0);
+                        VH_BigPoint_y.set(bigPoint, 0);
+                    }
+
+                    // should be independent
+                    try (MemorySegment struct = copy.vargAsSegment(BigPoint_LAYOUT)) {
+                        assertEquals((long) VH_BigPoint_x.get(struct), 15);
+                        assertEquals((long) VH_BigPoint_y.get(struct), 20);
+                    }
+                })},
+                // test skip
+                { linkVaListCB("upcallStack"), VaListConsumer.mh(vaList -> {
+                    vaList.skip(C_LONGLONG, C_LONGLONG, C_LONGLONG, C_LONGLONG);
+                    assertEquals(vaList.vargAsLong(C_LONGLONG), 5L);
+                    vaList.skip(C_LONGLONG, C_LONGLONG, C_LONGLONG, C_LONGLONG);
+                    assertEquals(vaList.vargAsLong(C_LONGLONG), 10L);
+                    vaList.skip(C_LONGLONG, C_LONGLONG, C_LONGLONG, C_LONGLONG, C_LONGLONG, C_LONGLONG);
+                    assertEquals(vaList.vargAsDouble(C_DOUBLE), 1.0D);
+                    vaList.skip(C_DOUBLE, C_DOUBLE, C_DOUBLE, C_DOUBLE);
+                    assertEquals(vaList.vargAsDouble(C_DOUBLE), 6.0D);
+                })},
+        };
+    }
+
+    interface VaListConsumer {
+        void accept(VaList list);
+
+        static MethodHandle mh(VaListConsumer instance) {
+            try {
+                return MethodHandles.lookup().findVirtual(VaListConsumer.class, "accept",
+                        MethodType.methodType(void.class, VaList.class)).bindTo(instance);
+            } catch (ReflectiveOperationException e) {
+                throw new InternalError(e);
+            }
+        }
+    }
+
+}
diff --git a/test/jdk/java/foreign/valist/libVaList.c b/test/jdk/java/foreign/valist/libVaList.c
new file mode 100644
index 0000000000000..ebb02e46a64a1
--- /dev/null
+++ b/test/jdk/java/foreign/valist/libVaList.c
@@ -0,0 +1,181 @@
+/*
+ *  Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ *  This code is free software; you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License version 2 only, as
+ *  published by the Free Software Foundation.
+ *
+ *  This code 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
+ *  version 2 for more details (a copy is included in the LICENSE file that
+ *  accompanied this code).
+ *
+ *  You should have received a copy of the GNU General Public License version
+ *  2 along with this work; if not, write to the Free Software Foundation,
+ *  Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ *   Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ *  or visit www.oracle.com if you need additional information or have any
+ *  questions.
+ *
+ */
+
+#include 
+
+#ifdef _WIN64
+#define EXPORT __declspec(dllexport)
+#else
+#define EXPORT
+#endif
+
+// ###### Down calls
+
+EXPORT int sumInts(int argNum, va_list list) {
+    int sum = 0;
+    for (int i = 0; i < argNum; i++) {
+        sum += va_arg(list, int);
+    }
+    return sum;
+}
+
+EXPORT double sumDoubles(int argNum, va_list list) {
+    double sum = 0;
+    for (int i = 0; i < argNum; i++) {
+        sum += va_arg(list, double);
+    }
+    return sum;
+}
+
+EXPORT int getInt(va_list list) {
+    int* ptr = va_arg(list, int*);
+    return *ptr;
+}
+
+typedef struct {
+    int x;
+    int y;
+} Point;
+
+EXPORT int sumStruct(va_list list) {
+    Point point = va_arg(list, Point);
+    return point.x + point.y;
+}
+
+typedef struct {
+    long long x;
+    long long y;
+} BigPoint;
+
+EXPORT long long sumBigStruct(va_list list) {
+    BigPoint point = va_arg(list, BigPoint);
+    return point.x + point.y;
+}
+
+typedef struct {
+    long long x;
+    long long y;
+    long long z;
+} HugePoint;
+
+EXPORT long long sumHugeStruct(va_list list) {
+    HugePoint point = va_arg(list, HugePoint);
+    return point.x + point.y + point.z;
+}
+
+typedef struct {
+    float x;
+    float y;
+} FloatPoint;
+
+EXPORT float sumFloatStruct(va_list list) {
+    FloatPoint point = va_arg(list, FloatPoint);
+    return point.x + point.y;
+}
+
+EXPORT void sumStack(long long* longSum, double* doubleSum, va_list list) {
+    long long lSum = 0;
+    for (int i = 0; i < 16; i++) {
+        lSum += va_arg(list, long long);
+    }
+    *longSum = lSum;
+    double dSum = 0.0;
+    for (int i = 0; i < 16; i++) {
+        dSum += va_arg(list, double);
+    }
+    *doubleSum = dSum;
+}
+
+// ###### Up calls
+
+typedef void CB(va_list);
+
+static void passToUpcall(CB cb, int numArgs, ...) {
+    va_list list;
+    va_start(list, numArgs);
+    cb(list);
+    va_end(list);
+}
+
+EXPORT void upcallInts(CB cb) {
+    passToUpcall(cb, 3, 10, 15, 20);
+}
+
+EXPORT void upcallDoubles(CB cb) {
+    passToUpcall(cb, 3, 3.0, 4.0, 5.0);
+}
+
+EXPORT void upcallStack(CB cb) {
+    Point point;
+    point.x = 5;
+    point.y = 10;
+
+    BigPoint bigPoint;
+    bigPoint.x = 15;
+    bigPoint.y = 20;
+
+    passToUpcall(cb, 32 + 14,
+        1LL, 2LL, 3LL, 4LL, 5LL, 6LL, 7LL, 8LL,
+        9LL, 10LL, 11LL, 12LL, 13LL, 14LL, 15LL, 16LL,
+        1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0,
+        9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
+        // should all be passed on the stack
+        1, 'a', 3,  4,  5LL,  6.0f,  7.0,
+        8, 'b', 10, 11, 12LL, 13.0f, 14.0,
+        point, bigPoint);
+}
+
+EXPORT void upcallMemoryAddress(CB cb) {
+    int x = 10;
+    passToUpcall(cb, 1, &x);
+}
+
+EXPORT void upcallStruct(CB cb) {
+    Point point;
+    point.x = 5;
+    point.y = 10;
+    passToUpcall(cb, 1, point);
+}
+
+EXPORT void upcallFloatStruct(CB cb) {
+    FloatPoint point;
+    point.x = 1.0f;
+    point.y = 2.0f;
+    passToUpcall(cb, 1, point);
+}
+
+EXPORT void upcallBigStruct(CB cb) {
+    BigPoint point;
+    point.x = 8;
+    point.y = 16;
+    passToUpcall(cb, 1, point);
+}
+
+EXPORT void upcallHugeStruct(CB cb) {
+    HugePoint point;
+    point.x = 1;
+    point.y = 2;
+    point.z = 3;
+    passToUpcall(cb, 1, point);
+}
diff --git a/test/micro/org/openjdk/bench/jdk/incubator/foreign/CallOverhead.java b/test/micro/org/openjdk/bench/jdk/incubator/foreign/CallOverhead.java
new file mode 100644
index 0000000000000..0f3029541064c
--- /dev/null
+++ b/test/micro/org/openjdk/bench/jdk/incubator/foreign/CallOverhead.java
@@ -0,0 +1,161 @@
+/*
+ * Copyright (c) 2020 Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package org.openjdk.bench.jdk.incubator.foreign;
+
+import jdk.incubator.foreign.FunctionDescriptor;
+import jdk.incubator.foreign.LibraryLookup;
+import jdk.incubator.foreign.MemoryAddress;
+import jdk.incubator.foreign.MemoryLayout;
+import jdk.incubator.foreign.MemorySegment;
+import jdk.incubator.foreign.CLinker;
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.Fork;
+import org.openjdk.jmh.annotations.Measurement;
+import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+import org.openjdk.jmh.annotations.State;
+import org.openjdk.jmh.annotations.Warmup;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodType;
+import java.util.concurrent.TimeUnit;
+
+import static jdk.incubator.foreign.CLinker.C_DOUBLE;
+import static jdk.incubator.foreign.CLinker.C_INT;
+import static jdk.incubator.foreign.CLinker.C_LONGLONG;
+import static jdk.incubator.foreign.CLinker.C_POINTER;
+
+@BenchmarkMode(Mode.AverageTime)
+@Warmup(iterations = 5, time = 500, timeUnit = TimeUnit.MILLISECONDS)
+@Measurement(iterations = 10, time = 500, timeUnit = TimeUnit.MILLISECONDS)
+@State(org.openjdk.jmh.annotations.Scope.Thread)
+@OutputTimeUnit(TimeUnit.NANOSECONDS)
+@Fork(value = 3, jvmArgsAppend = { "--add-modules=jdk.incubator.foreign", "-Dforeign.restricted=permit" })
+public class CallOverhead {
+
+    static final CLinker abi = CLinker.getInstance();
+
+    static final MethodHandle func;
+    static final MethodHandle identity;
+    static final MethodHandle identity_struct;
+    static final MethodHandle identity_memory_address;
+    static final MethodHandle args5;
+    static final MethodHandle args10;
+    static final MethodHandle func_trivial;
+    static final MethodHandle identity_trivial;
+
+    static final MemoryLayout POINT_LAYOUT = MemoryLayout.ofStruct(
+        C_LONGLONG, C_LONGLONG
+    );
+
+    static final MemorySegment point = MemorySegment.allocateNative(POINT_LAYOUT);
+
+    static {
+        System.loadLibrary("CallOverheadJNI");
+
+        LibraryLookup ll = LibraryLookup.ofLibrary("CallOverhead");
+        {
+            LibraryLookup.Symbol addr = ll.lookup("func").get();
+            MethodType mt = MethodType.methodType(void.class);
+            FunctionDescriptor fd = FunctionDescriptor.ofVoid();
+            func = abi.downcallHandle(addr, mt, fd);
+            func_trivial = abi.downcallHandle(addr, mt, fd.withAttribute(FunctionDescriptor.TRIVIAL_ATTRIBUTE_NAME, true));
+        }
+        {
+            LibraryLookup.Symbol addr = ll.lookup("identity").get();
+            MethodType mt = MethodType.methodType(int.class, int.class);
+            FunctionDescriptor fd = FunctionDescriptor.of(C_INT, C_INT);
+            identity = abi.downcallHandle(addr, mt, fd);
+            identity_trivial = abi.downcallHandle(addr, mt, fd.withAttribute(FunctionDescriptor.TRIVIAL_ATTRIBUTE_NAME, true));
+        }
+        identity_struct = abi.downcallHandle(ll.lookup("identity_struct").get(),
+                MethodType.methodType(MemorySegment.class, MemorySegment.class),
+                FunctionDescriptor.of(POINT_LAYOUT, POINT_LAYOUT));
+        identity_memory_address = abi.downcallHandle(ll.lookup("identity_memory_address").get(),
+                MethodType.methodType(MemoryAddress.class, MemoryAddress.class),
+                FunctionDescriptor.of(C_POINTER, C_POINTER));
+        args5 = abi.downcallHandle(ll.lookup("args5").get(),
+                MethodType.methodType(void.class, long.class, double.class, long.class, double.class, long.class),
+                FunctionDescriptor.ofVoid(C_LONGLONG, C_DOUBLE, C_LONGLONG, C_DOUBLE, C_LONGLONG));
+        args10 = abi.downcallHandle(ll.lookup("args10").get(),
+                MethodType.methodType(void.class, long.class, double.class, long.class, double.class, long.class,
+                                                  double.class, long.class, double.class, long.class, double.class),
+                FunctionDescriptor.ofVoid(C_LONGLONG, C_DOUBLE, C_LONGLONG, C_DOUBLE, C_LONGLONG,
+                                          C_DOUBLE, C_LONGLONG, C_DOUBLE, C_LONGLONG, C_DOUBLE));
+    }
+
+    static native void blank();
+    static native int identity(int x);
+
+    @Benchmark
+    public void jni_blank() throws Throwable {
+        blank();
+    }
+
+    @Benchmark
+    public void panama_blank() throws Throwable {
+        func.invokeExact();
+    }
+
+    @Benchmark
+    public void panama_blank_trivial() throws Throwable {
+        func_trivial.invokeExact();
+    }
+
+    @Benchmark
+    public int jni_identity() throws Throwable {
+        return identity(10);
+    }
+
+    @Benchmark
+    public int panama_identity() throws Throwable {
+        return (int) identity.invokeExact(10);
+    }
+
+    @Benchmark
+    public int panama_identity_trivial() throws Throwable {
+        return (int) identity_trivial.invokeExact(10);
+    }
+
+    @Benchmark
+    public MemorySegment panama_identity_struct() throws Throwable {
+        return (MemorySegment) identity_struct.invokeExact(point);
+    }
+
+    @Benchmark
+    public MemoryAddress panama_identity_memory_address() throws Throwable {
+        return (MemoryAddress) identity_memory_address.invokeExact(MemoryAddress.NULL);
+    }
+
+    @Benchmark
+    public void panama_args5() throws Throwable {
+        args5.invokeExact(10L, 11D, 12L, 13D, 14L);
+    }
+
+    @Benchmark
+    public void panama_args10() throws Throwable {
+        args10.invokeExact(10L, 11D, 12L, 13D, 14L,
+                           15D, 16L, 17D, 18L, 19D);
+    }
+}
diff --git a/test/micro/org/openjdk/bench/jdk/incubator/foreign/Upcalls.java b/test/micro/org/openjdk/bench/jdk/incubator/foreign/Upcalls.java
new file mode 100644
index 0000000000000..9351b8a664048
--- /dev/null
+++ b/test/micro/org/openjdk/bench/jdk/incubator/foreign/Upcalls.java
@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) 2020 Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package org.openjdk.bench.jdk.incubator.foreign;
+
+import jdk.incubator.foreign.FunctionDescriptor;
+import jdk.incubator.foreign.LibraryLookup;
+import jdk.incubator.foreign.MemoryAddress;
+import jdk.incubator.foreign.CLinker;
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.Fork;
+import org.openjdk.jmh.annotations.Measurement;
+import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+import org.openjdk.jmh.annotations.State;
+import org.openjdk.jmh.annotations.Warmup;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodType;
+import java.util.concurrent.TimeUnit;
+
+import static java.lang.invoke.MethodHandles.lookup;
+import static jdk.incubator.foreign.CLinker.C_INT;
+import static jdk.incubator.foreign.CLinker.C_POINTER;
+
+@BenchmarkMode(Mode.AverageTime)
+@Warmup(iterations = 5, time = 500, timeUnit = TimeUnit.MILLISECONDS)
+@Measurement(iterations = 10, time = 500, timeUnit = TimeUnit.MILLISECONDS)
+@State(org.openjdk.jmh.annotations.Scope.Thread)
+@OutputTimeUnit(TimeUnit.NANOSECONDS)
+@Fork(value = 3, jvmArgsAppend = { "--add-modules=jdk.incubator.foreign", "-Dforeign.restricted=permit" })
+public class Upcalls {
+
+    static final CLinker abi = CLinker.getInstance();
+    static final MethodHandle blank;
+    static final MethodHandle identity;
+
+    static final MemoryAddress cb_blank;
+    static final MemoryAddress cb_identity;
+
+    static final long cb_blank_jni;
+    static final long cb_identity_jni;
+
+    static {
+        System.loadLibrary("UpcallsJNI");
+
+        String className = "org/openjdk/bench/jdk/incubator/foreign/Upcalls";
+        cb_blank_jni = makeCB(className, "blank", "()V");
+        cb_identity_jni = makeCB(className, "identity", "(I)I");
+
+        try {
+            LibraryLookup ll = LibraryLookup.ofLibrary("Upcalls");
+            {
+                LibraryLookup.Symbol addr = ll.lookup("blank").get();
+                MethodType mt = MethodType.methodType(void.class, MemoryAddress.class);
+                FunctionDescriptor fd = FunctionDescriptor.ofVoid(C_POINTER);
+                blank = abi.downcallHandle(addr, mt, fd);
+
+                cb_blank = abi.upcallStub(
+                    lookup().findStatic(Upcalls.class, "blank", MethodType.methodType(void.class)),
+                    FunctionDescriptor.ofVoid()
+                ).address();
+            }
+            {
+                LibraryLookup.Symbol addr = ll.lookup("identity").get();
+                MethodType mt = MethodType.methodType(int.class, int.class, MemoryAddress.class);
+                FunctionDescriptor fd = FunctionDescriptor.of(C_INT, C_INT, C_POINTER);
+                identity = abi.downcallHandle(addr, mt, fd);
+
+                cb_identity = abi.upcallStub(
+                    lookup().findStatic(Upcalls.class, "identity", MethodType.methodType(int.class, int.class)),
+                    FunctionDescriptor.of(C_INT, C_INT)
+                ).address();
+            }
+        } catch (ReflectiveOperationException e) {
+            throw new BootstrapMethodError(e);
+        }
+    }
+
+    static native void blank(long cb);
+    static native int identity(int x, long cb);
+    static native long makeCB(String holder, String name, String signature);
+
+    @Benchmark
+    public void jni_blank() throws Throwable {
+        blank(cb_blank_jni);
+    }
+
+    @Benchmark
+    public void panama_blank() throws Throwable {
+        blank.invokeExact(cb_blank);
+    }
+
+    @Benchmark
+    public int jni_identity() throws Throwable {
+        return identity(10, cb_identity_jni);
+    }
+
+    @Benchmark
+    public int panama_identity() throws Throwable {
+        return (int) identity.invokeExact(10, cb_identity);
+    }
+
+    static void blank() {}
+    static int identity(int x) { return x; }
+}
diff --git a/test/micro/org/openjdk/bench/jdk/incubator/foreign/VaList.java b/test/micro/org/openjdk/bench/jdk/incubator/foreign/VaList.java
new file mode 100644
index 0000000000000..33ebe88160e61
--- /dev/null
+++ b/test/micro/org/openjdk/bench/jdk/incubator/foreign/VaList.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package org.openjdk.bench.jdk.incubator.foreign;
+
+import jdk.incubator.foreign.FunctionDescriptor;
+import jdk.incubator.foreign.LibraryLookup;
+import jdk.incubator.foreign.CLinker;
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.Fork;
+import org.openjdk.jmh.annotations.Measurement;
+import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+import org.openjdk.jmh.annotations.State;
+import org.openjdk.jmh.annotations.Warmup;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodType;
+import java.util.concurrent.TimeUnit;
+
+import static jdk.incubator.foreign.CLinker.C_DOUBLE;
+import static jdk.incubator.foreign.CLinker.C_INT;
+import static jdk.incubator.foreign.CLinker.C_LONGLONG;
+import static jdk.incubator.foreign.CLinker.C_VA_LIST;
+import static jdk.incubator.foreign.CLinker.asVarArg;
+
+@BenchmarkMode(Mode.AverageTime)
+@Warmup(iterations = 5, time = 500, timeUnit = TimeUnit.MILLISECONDS)
+@Measurement(iterations = 10, time = 500, timeUnit = TimeUnit.MILLISECONDS)
+@State(org.openjdk.jmh.annotations.Scope.Thread)
+@OutputTimeUnit(TimeUnit.NANOSECONDS)
+@Fork(value = 3, jvmArgsAppend = { "--add-modules=jdk.incubator.foreign", "-Dforeign.restricted=permit" })
+public class VaList {
+
+    static final CLinker linker = CLinker.getInstance();
+    static final LibraryLookup lookup = LibraryLookup.ofLibrary("VaList");
+
+    static final MethodHandle MH_ellipsis;
+    static final MethodHandle MH_vaList;
+
+    static {
+        MH_ellipsis = linker.downcallHandle(lookup.lookup("ellipsis").get(),
+                MethodType.methodType(void.class, int.class, int.class, double.class, long.class),
+                FunctionDescriptor.ofVoid(C_INT, asVarArg(C_INT), asVarArg(C_DOUBLE), asVarArg(C_LONGLONG)));
+        MH_vaList = linker.downcallHandle(lookup.lookup("vaList").get(),
+                MethodType.methodType(void.class, int.class, VaList.class),
+                FunctionDescriptor.ofVoid(C_INT, C_VA_LIST));
+    }
+
+    @Benchmark
+    public void ellipsis() throws Throwable {
+        MH_ellipsis.invokeExact(3,
+                                1, 2D, 3L);
+    }
+
+    @Benchmark
+    public void vaList() throws Throwable {
+        try (CLinker.VaList vaList = CLinker.VaList.make(b ->
+            b.vargFromInt(C_INT, 1)
+             .vargFromDouble(C_DOUBLE, 2D)
+             .vargFromLong(C_LONGLONG, 3L)
+        )) {
+            MH_vaList.invokeExact(3,
+                                  vaList);
+        }
+    }
+}
diff --git a/test/micro/org/openjdk/bench/jdk/incubator/foreign/libCallOverhead.c b/test/micro/org/openjdk/bench/jdk/incubator/foreign/libCallOverhead.c
new file mode 100644
index 0000000000000..01630b4ea67fc
--- /dev/null
+++ b/test/micro/org/openjdk/bench/jdk/incubator/foreign/libCallOverhead.c
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2020 Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+#ifdef _WIN64
+#define EXPORT __declspec(dllexport)
+#else
+#define EXPORT
+#endif
+
+EXPORT void func() {}
+
+EXPORT int identity(int x) {
+  return x;
+}
+
+typedef struct {
+    long long x;
+    long long y;
+} Point;
+
+EXPORT Point identity_struct(Point p) {
+    return p;
+}
+
+EXPORT void* identity_memory_address(void* p) {
+    return p;
+}
+
+EXPORT void args5(long long a0, double a1, long long a2, double a3, long long a4) {}
+EXPORT void args10(long long a0, double a1, long long a2, double a3, long long a4,
+                   double a5, long long a6, double a7, long long a8, double a9) {}
diff --git a/test/micro/org/openjdk/bench/jdk/incubator/foreign/libCallOverheadJNI.c b/test/micro/org/openjdk/bench/jdk/incubator/foreign/libCallOverheadJNI.c
new file mode 100644
index 0000000000000..1344f29f1764e
--- /dev/null
+++ b/test/micro/org/openjdk/bench/jdk/incubator/foreign/libCallOverheadJNI.c
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2020 Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+#include 
+
+void func() {}
+
+int identity(int x) {
+  return x;
+}
+
+JNIEXPORT void JNICALL Java_org_openjdk_bench_jdk_incubator_foreign_CallOverhead_blank
+  (JNIEnv *env, jclass cls) {
+    func();
+}
+
+JNIEXPORT jint JNICALL Java_org_openjdk_bench_jdk_incubator_foreign_CallOverhead_identity
+  (JNIEnv *env, jclass cls, jint x) {
+    return identity(x);
+}
diff --git a/test/micro/org/openjdk/bench/jdk/incubator/foreign/libUpcalls.c b/test/micro/org/openjdk/bench/jdk/incubator/foreign/libUpcalls.c
new file mode 100644
index 0000000000000..92d7cabf8c546
--- /dev/null
+++ b/test/micro/org/openjdk/bench/jdk/incubator/foreign/libUpcalls.c
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2020 Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+#ifdef _WIN64
+#define EXPORT __declspec(dllexport)
+#else
+#define EXPORT
+#endif
+
+EXPORT void blank(void (*cb)(void)) {
+    cb();
+}
+
+EXPORT int identity(int x, int (*cb)(int)) {
+    return cb(x);
+}
diff --git a/test/micro/org/openjdk/bench/jdk/incubator/foreign/libUpcallsJNI.c b/test/micro/org/openjdk/bench/jdk/incubator/foreign/libUpcallsJNI.c
new file mode 100644
index 0000000000000..00b4c52b6d332
--- /dev/null
+++ b/test/micro/org/openjdk/bench/jdk/incubator/foreign/libUpcallsJNI.c
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) 2020 Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+#include 
+#include 
+
+void blank(void (*cb)(void)) {
+    cb();
+}
+
+int identity(int x, int (*cb)(int)) {
+    return cb(x);
+}
+
+typedef struct {
+    jclass holder;
+    jmethodID mid;
+} *JNICB;
+
+#define CHECK_NULL(thing, message) \
+    if (thing == NULL) { \
+        jclass cls = (*env)->FindClass(env, "java/lang/Exception"); \
+        (*env)->ThrowNew(env, cls, message); \
+        return 0; \
+    }
+
+JNIEXPORT jlong JNICALL Java_org_openjdk_bench_jdk_incubator_foreign_Upcalls_makeCB
+  (JNIEnv *env, jclass cls, jstring holderName, jstring methodName, jstring descriptor) {
+
+  const char* holderNameC = (*env)->GetStringUTFChars(env, holderName, NULL);
+  const char* methodNameC = (*env)->GetStringUTFChars(env, methodName, NULL);
+  const char* descriptorC = (*env)->GetStringUTFChars(env, descriptor, NULL);
+
+  JNICB cb = malloc(sizeof *cb);
+  CHECK_NULL(cb, "Can not allocate cb");
+
+  jclass holder = (*env)->FindClass(env, holderNameC);
+  CHECK_NULL(holder, "Can not find class");
+  holder = (jclass) (*env)->NewGlobalRef(env, holder);
+  cb->holder = holder;
+
+  jmethodID methodID = (*env)->GetStaticMethodID(env, holder, methodNameC, descriptorC);
+  CHECK_NULL(methodID, "Can not find method");
+  //methodID = (jmethodID) (*env)->NewGlobalRef(env, methodID); // DON'T DO THIS! -> Crashes GC
+  cb->mid = methodID;
+
+  (*env)->ReleaseStringUTFChars(env, holderName, holderNameC);
+  (*env)->ReleaseStringUTFChars(env, methodName, methodNameC);
+  (*env)->ReleaseStringUTFChars(env, descriptor, descriptorC);
+
+  return (jlong) cb;
+}
+
+JNIEXPORT void JNICALL Java_org_openjdk_bench_jdk_incubator_foreign_Upcalls_blank
+  (JNIEnv *env, jclass cls, jlong cb) {
+    JNICB jniCb = (JNICB) cb;
+    (*env)->CallStaticVoidMethod(env, jniCb->holder, jniCb->mid);
+}
+
+JNIEXPORT jint JNICALL Java_org_openjdk_bench_jdk_incubator_foreign_Upcalls_identity
+  (JNIEnv *env, jclass cls, jint x, jlong cb) {
+    JNICB jniCb = (JNICB) cb;
+    return (*env)->CallStaticIntMethod(env, jniCb->holder, jniCb->mid, x);
+}
diff --git a/test/micro/org/openjdk/bench/jdk/incubator/foreign/libVaList.c b/test/micro/org/openjdk/bench/jdk/incubator/foreign/libVaList.c
new file mode 100644
index 0000000000000..27f612bc70d3e
--- /dev/null
+++ b/test/micro/org/openjdk/bench/jdk/incubator/foreign/libVaList.c
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+#include 
+
+#ifdef _WIN64
+#define EXPORT __declspec(dllexport)
+#else
+#define EXPORT
+#endif
+
+EXPORT void vaList(int argCount, va_list list) {
+    //...
+}
+
+EXPORT void ellipsis(int argCount, ...) {
+    va_list list;
+    va_start(list, argCount);
+    vaList(argCount, list);
+    va_end(list);
+}
diff --git a/test/micro/org/openjdk/bench/jdk/incubator/foreign/points/PointsDistance.java b/test/micro/org/openjdk/bench/jdk/incubator/foreign/points/PointsDistance.java
new file mode 100644
index 0000000000000..e1283b34ba0d7
--- /dev/null
+++ b/test/micro/org/openjdk/bench/jdk/incubator/foreign/points/PointsDistance.java
@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) 2020 Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package org.openjdk.bench.jdk.incubator.foreign.points;
+
+import org.openjdk.bench.jdk.incubator.foreign.points.support.BBPoint;
+import org.openjdk.bench.jdk.incubator.foreign.points.support.JNIPoint;
+import org.openjdk.bench.jdk.incubator.foreign.points.support.PanamaPoint;
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.Fork;
+import org.openjdk.jmh.annotations.Measurement;
+import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+import org.openjdk.jmh.annotations.Setup;
+import org.openjdk.jmh.annotations.State;
+import org.openjdk.jmh.annotations.TearDown;
+import org.openjdk.jmh.annotations.Warmup;
+
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.AverageTime)
+@Warmup(iterations = 5, time = 500, timeUnit = TimeUnit.MILLISECONDS)
+@Measurement(iterations = 10, time = 500, timeUnit = TimeUnit.MILLISECONDS)
+@State(org.openjdk.jmh.annotations.Scope.Thread)
+@OutputTimeUnit(TimeUnit.NANOSECONDS)
+@Fork(value = 3, jvmArgsAppend = { "--add-modules=jdk.incubator.foreign", "-Dforeign.restricted=permit" })
+public class PointsDistance {
+
+    BBPoint jniP1;
+    BBPoint jniP2;
+
+    JNIPoint nativeP1;
+    JNIPoint nativeP2;
+
+    PanamaPoint panamaPointP1;
+    PanamaPoint panamaPointP2;
+
+    @Setup
+    public void setup() {
+        jniP1 = new BBPoint(0, 0);
+        jniP2 = new BBPoint(1, 1);
+
+        nativeP1 = new JNIPoint(0, 0);
+        nativeP2 = new JNIPoint(1, 1);
+
+        panamaPointP1 = new PanamaPoint(0, 0);
+        panamaPointP2 = new PanamaPoint(1, 1);
+    }
+
+    @TearDown
+    public void tearDown() {
+        nativeP1.free();
+        nativeP2.free();
+
+        panamaPointP1.close();
+        panamaPointP2.close();
+    }
+
+    @Benchmark
+    public double jni_ByteBuffer() throws Throwable {
+        return jniP1.distanceTo(jniP2);
+    }
+
+    @Benchmark
+    public double jni_long() throws Throwable {
+        return nativeP1.distanceTo(nativeP2);
+    }
+
+    @Benchmark
+    public double panama_MemorySegment() throws Throwable {
+        return panamaPointP1.distanceTo(panamaPointP2);
+    }
+
+    @Benchmark
+    public double panama_MemoryAddress() throws Throwable {
+        return panamaPointP1.distanceToPtrs(panamaPointP2);
+    }
+
+}
diff --git a/test/micro/org/openjdk/bench/jdk/incubator/foreign/points/support/libPoint.c b/test/micro/org/openjdk/bench/jdk/incubator/foreign/points/support/libPoint.c
new file mode 100644
index 0000000000000..480f54b39a796
--- /dev/null
+++ b/test/micro/org/openjdk/bench/jdk/incubator/foreign/points/support/libPoint.c
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2020 Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+#include 
+#include 
+
+#include "points.h"
+
+#ifdef _WIN64
+#define EXPORT __declspec(dllexport)
+#else
+#define EXPORT
+#endif
+
+EXPORT double distance(Point p1, Point p2) {
+    int xDist = abs(p1.x - p2.x);
+    int yDist = abs(p1.y - p2.y);
+    return sqrt((xDist * xDist) + (yDist * yDist));
+}
+
+EXPORT double distance_ptrs(Point* p1, Point* p2) {
+    return distance(*p1, *p2);
+}

From 4f2ed7ca0abae8558e6ce1fe984b69e42d4feff2 Mon Sep 17 00:00:00 2001
From: Maurizio Cimadamore 
Date: Tue, 13 Oct 2020 11:44:50 +0100
Subject: [PATCH 13/70] More updates

---
 .../jdk/internal/invoke/NativeEntryPoint.java  |  5 ++++-
 .../jdk/incubator/foreign/GroupLayout.java     |  1 -
 .../foreign/AbstractMemorySegmentImpl.java.rej | 18 ------------------
 3 files changed, 4 insertions(+), 20 deletions(-)
 delete mode 100644 src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/AbstractMemorySegmentImpl.java.rej

diff --git a/src/java.base/share/classes/jdk/internal/invoke/NativeEntryPoint.java b/src/java.base/share/classes/jdk/internal/invoke/NativeEntryPoint.java
index 0cbab48bce5aa..d3947724de75c 100644
--- a/src/java.base/share/classes/jdk/internal/invoke/NativeEntryPoint.java
+++ b/src/java.base/share/classes/jdk/internal/invoke/NativeEntryPoint.java
@@ -28,7 +28,10 @@
 import java.lang.invoke.MethodType;
 import java.util.Objects;
 
-/** TODO */
+/**
+ * This class describes a native call, including arguments/return shuffle moves, PC entry point and
+ * various other info which are relevant when the call will be intrinsified by C2.
+ */
 public class NativeEntryPoint {
     static {
         registerNatives();
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/GroupLayout.java b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/GroupLayout.java
index a158a649d6802..fc1fbe6c2125f 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/GroupLayout.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/GroupLayout.java
@@ -31,7 +31,6 @@
 import java.lang.constant.DynamicConstantDesc;
 import java.lang.constant.MethodHandleDesc;
 import java.util.Collections;
-import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/AbstractMemorySegmentImpl.java.rej b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/AbstractMemorySegmentImpl.java.rej
deleted file mode 100644
index 9c9e55966562a..0000000000000
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/AbstractMemorySegmentImpl.java.rej
+++ /dev/null
@@ -1,18 +0,0 @@
-diff a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/AbstractMemorySegmentImpl.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/AbstractMemorySegmentImpl.java	(rejected hunks)
-@@ -136,6 +136,16 @@ public abstract class AbstractMemorySegmentImpl implements MemorySegment, Memory
-                 base(), min(), size);
-     }
- 
-+    public void copyFromSwap(MemorySegment src, long elemSize) {
-+        AbstractMemorySegmentImpl that = (AbstractMemorySegmentImpl)src;
-+        long size = that.byteSize();
-+        checkAccess(0, size, false);
-+        that.checkAccess(0, size, true);
-+        SCOPED_MEMORY_ACCESS.copySwapMemory(scope, that.scope,
-+                that.base(), that.min(),
-+                base(), min(), size, elemSize);
-+    }
-+
-     private final static VarHandle BYTE_HANDLE = MemoryLayout.ofSequence(MemoryLayouts.JAVA_BYTE)
-             .varHandle(byte.class, MemoryLayout.PathElement.sequenceElement());
- 

From 8ce0357404159a705a8bdc217c90a3d7bfce09e1 Mon Sep 17 00:00:00 2001
From: Maurizio Cimadamore 
Date: Tue, 13 Oct 2020 11:52:19 +0100
Subject: [PATCH 14/70] Remove rejected file

---
 .../classes/jdk/internal/foreign/Utils.java.rej    | 14 --------------
 1 file changed, 14 deletions(-)
 delete mode 100644 src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/Utils.java.rej

diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/Utils.java.rej b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/Utils.java.rej
deleted file mode 100644
index 5d51563157596..0000000000000
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/Utils.java.rej
+++ /dev/null
@@ -1,14 +0,0 @@
-diff a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/Utils.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/Utils.java	(rejected hunks)
-@@ -28,9 +28,12 @@ package jdk.internal.foreign;
- 
- import jdk.incubator.foreign.MemoryAddress;
- import jdk.incubator.foreign.MemoryHandles;
-+import jdk.incubator.foreign.MemoryLayout;
- import jdk.incubator.foreign.MemorySegment;
-+import jdk.incubator.foreign.ValueLayout;
- import jdk.internal.access.foreign.MemorySegmentProxy;
- import jdk.internal.misc.VM;
-+import sun.invoke.util.Wrapper;
- 
- import java.lang.invoke.MethodHandle;
- import java.lang.invoke.MethodHandles;

From 7cc344cc3686208c7cd75009b5b095e83712546a Mon Sep 17 00:00:00 2001
From: Maurizio Cimadamore 
Date: Tue, 13 Oct 2020 14:15:29 +0100
Subject: [PATCH 15/70] Fix whitespaces

---
 .../share/classes/jdk/incubator/foreign/FunctionDescriptor.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/FunctionDescriptor.java b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/FunctionDescriptor.java
index b5314b233a58c..f9d83cb4db36a 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/FunctionDescriptor.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/FunctionDescriptor.java
@@ -48,7 +48,7 @@ public final class FunctionDescriptor implements Constable {
      * attribute value must be a boolean.
      */
     public static final String TRIVIAL_ATTRIBUTE_NAME = "abi/trivial";
-    
+
     private final MemoryLayout resLayout;
     private final MemoryLayout[] argLayouts;
     private final Map attributes;

From 7cf0ef09f17c5b5d94f692fae27265962ce68457 Mon Sep 17 00:00:00 2001
From: Maurizio Cimadamore 
Date: Tue, 13 Oct 2020 14:24:08 +0100
Subject: [PATCH 16/70] Fix more whitespaces

---
 src/hotspot/share/prims/universalNativeInvoker.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/hotspot/share/prims/universalNativeInvoker.hpp b/src/hotspot/share/prims/universalNativeInvoker.hpp
index b1c9cfecb3657..d9298cdf5a812 100644
--- a/src/hotspot/share/prims/universalNativeInvoker.hpp
+++ b/src/hotspot/share/prims/universalNativeInvoker.hpp
@@ -43,7 +43,7 @@ class ShuffleRecipe;
 typedef void (*ProgrammableStub)(address);
 
 class ProgrammableInvoker: AllStatic {
-public:  
+public:
   static void invoke_native(ProgrammableStub stub, address buff, JavaThread* thread);
   static jlong generate_adapter(JNIEnv* env, jobject abi, jobject layout);
 };

From 2184831e0f35be00b09b58cdc07a8a55979727ec Mon Sep 17 00:00:00 2001
From: Jorn Vernee 
Date: Thu, 15 Oct 2020 18:27:46 +0200
Subject: [PATCH 17/70] Re-add erroneously removed files

---
 src/hotspot/cpu/aarch64/aarch64_neon.ad       | 3456 +++++++++++++++++
 src/hotspot/cpu/aarch64/aarch64_neon_ad.m4    | 1424 +++++++
 src/hotspot/share/gc/shared/pretouchTask.cpp  |   82 +
 src/hotspot/share/gc/shared/pretouchTask.hpp  |   48 +
 src/hotspot/share/opto/library_call.hpp       |  348 ++
 src/hotspot/share/opto/vector.cpp             |  466 +++
 src/hotspot/share/opto/vector.hpp             |   62 +
 src/hotspot/share/opto/vectorIntrinsics.cpp   | 1594 ++++++++
 src/hotspot/share/prims/vectorSupport.cpp     |  429 ++
 src/hotspot/share/prims/vectorSupport.hpp     |   90 +
 src/hotspot/share/utilities/enumIterator.hpp  |  215 +
 .../jdk/internal/vm/vector/VectorSupport.java |  468 +++
 .../jdk/incubator/vector/AbstractMask.java    |  290 ++
 .../jdk/incubator/vector/AbstractShuffle.java |  246 ++
 14 files changed, 9218 insertions(+)
 create mode 100644 src/hotspot/cpu/aarch64/aarch64_neon.ad
 create mode 100644 src/hotspot/cpu/aarch64/aarch64_neon_ad.m4
 create mode 100644 src/hotspot/share/gc/shared/pretouchTask.cpp
 create mode 100644 src/hotspot/share/gc/shared/pretouchTask.hpp
 create mode 100644 src/hotspot/share/opto/library_call.hpp
 create mode 100644 src/hotspot/share/opto/vector.cpp
 create mode 100644 src/hotspot/share/opto/vector.hpp
 create mode 100644 src/hotspot/share/opto/vectorIntrinsics.cpp
 create mode 100644 src/hotspot/share/prims/vectorSupport.cpp
 create mode 100644 src/hotspot/share/prims/vectorSupport.hpp
 create mode 100644 src/hotspot/share/utilities/enumIterator.hpp
 create mode 100644 src/java.base/share/classes/jdk/internal/vm/vector/VectorSupport.java
 create mode 100644 src/jdk.incubator.vector/share/classes/jdk/incubator/vector/AbstractMask.java
 create mode 100644 src/jdk.incubator.vector/share/classes/jdk/incubator/vector/AbstractShuffle.java

diff --git a/src/hotspot/cpu/aarch64/aarch64_neon.ad b/src/hotspot/cpu/aarch64/aarch64_neon.ad
new file mode 100644
index 0000000000000..33b1a869cc363
--- /dev/null
+++ b/src/hotspot/cpu/aarch64/aarch64_neon.ad
@@ -0,0 +1,3456 @@
+// Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+// Copyright (c) 2020, Arm Limited. All rights reserved.
+// DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+//
+// This code is free software; you can redistribute it and/or modify it
+// under the terms of the GNU General Public License version 2 only, as
+// published by the Free Software Foundation.
+//
+// This code 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
+// version 2 for more details (a copy is included in the LICENSE file that
+// accompanied this code).
+//
+// You should have received a copy of the GNU General Public License version
+// 2 along with this work; if not, write to the Free Software Foundation,
+// Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+// or visit www.oracle.com if you need additional information or have any
+// questions.
+//
+//
+
+// This file is automatically generated by running "m4 aarch64_neon_ad.m4". Do not edit ----
+
+// AArch64 NEON Architecture Description File
+
+// ====================VECTOR INSTRUCTIONS==================================
+
+// ------------------------------ Load/store/reinterpret -----------------------
+
+// Load vector (16 bits)
+instruct loadV2(vecD dst, memory mem)
+%{
+  predicate(n->as_LoadVector()->memory_size() == 2);
+  match(Set dst (LoadVector mem));
+  ins_cost(4 * INSN_COST);
+  format %{ "ldrh   $dst,$mem\t# vector (16 bits)" %}
+  ins_encode( aarch64_enc_ldrvH(dst, mem) );
+  ins_pipe(vload_reg_mem64);
+%}
+
+// Store Vector (16 bits)
+instruct storeV2(vecD src, memory mem)
+%{
+  predicate(n->as_StoreVector()->memory_size() == 2);
+  match(Set mem (StoreVector mem src));
+  ins_cost(4 * INSN_COST);
+  format %{ "strh   $mem,$src\t# vector (16 bits)" %}
+  ins_encode( aarch64_enc_strvH(src, mem) );
+  ins_pipe(vstore_reg_mem64);
+%}
+
+instruct reinterpretD(vecD dst)
+%{
+  predicate(n->bottom_type()->is_vect()->length_in_bytes() == 8 &&
+            n->in(1)->bottom_type()->is_vect()->length_in_bytes() == 8);
+  match(Set dst (VectorReinterpret dst));
+  ins_cost(0);
+  format %{ " # reinterpret $dst" %}
+  ins_encode %{
+    // empty
+  %}
+  ins_pipe(pipe_class_empty);
+%}
+
+instruct reinterpretX(vecX dst)
+%{
+  predicate(n->bottom_type()->is_vect()->length_in_bytes() == 16 &&
+            n->in(1)->bottom_type()->is_vect()->length_in_bytes() == 16);
+  match(Set dst (VectorReinterpret dst));
+  ins_cost(0);
+  format %{ " # reinterpret $dst" %}
+  ins_encode %{
+    // empty
+  %}
+  ins_pipe(pipe_class_empty);
+%}
+
+instruct reinterpretD2X(vecX dst, vecD src)
+%{
+  predicate(n->bottom_type()->is_vect()->length_in_bytes() == 16 &&
+            n->in(1)->bottom_type()->is_vect()->length_in_bytes() == 8);
+  match(Set dst (VectorReinterpret src));
+  ins_cost(INSN_COST);
+  format %{ " # reinterpret $dst,$src" %}
+  ins_encode %{
+    // If register is the same, then move is not needed.
+    if (as_FloatRegister($dst$$reg) != as_FloatRegister($src$$reg)) {
+      __ orr(as_FloatRegister($dst$$reg), __ T8B,
+             as_FloatRegister($src$$reg),
+             as_FloatRegister($src$$reg));
+    }
+  %}
+  ins_pipe(vlogical64);
+%}
+
+instruct reinterpretX2D(vecD dst, vecX src)
+%{
+  predicate(n->bottom_type()->is_vect()->length_in_bytes() == 8 &&
+            n->in(1)->bottom_type()->is_vect()->length_in_bytes() == 16);
+  match(Set dst (VectorReinterpret src));
+  ins_cost(INSN_COST);
+  format %{ " # reinterpret $dst,$src" %}
+  ins_encode %{
+    // If register is the same, then move is not needed.
+    if (as_FloatRegister($dst$$reg) != as_FloatRegister($src$$reg)) {
+      __ orr(as_FloatRegister($dst$$reg), __ T8B,
+             as_FloatRegister($src$$reg),
+             as_FloatRegister($src$$reg));
+    }
+  %}
+  ins_pipe(vlogical64);
+%}
+
+// ------------------------------ Vector cast -------------------------------
+
+instruct vcvt4Bto4S(vecD dst, vecD src)
+%{
+  predicate(n->as_Vector()->length() == 4 && n->bottom_type()->is_vect()->element_basic_type() == T_SHORT);
+  match(Set dst (VectorCastB2X src));
+  format %{ "sxtl  $dst, T8H, $src, T8B\t# convert 4B to 4S vector" %}
+  ins_encode %{
+    __ sxtl(as_FloatRegister($dst$$reg), __ T8H, as_FloatRegister($src$$reg), __ T8B);
+  %}
+  ins_pipe(pipe_class_default);
+%}
+
+instruct vcvt8Bto8S(vecX dst, vecD src)
+%{
+  predicate(n->as_Vector()->length() == 8 && n->bottom_type()->is_vect()->element_basic_type() == T_SHORT);
+  match(Set dst (VectorCastB2X src));
+  format %{ "sxtl  $dst, T8H, $src, T8B\t# convert 8B to 8S vector" %}
+  ins_encode %{
+    __ sxtl(as_FloatRegister($dst$$reg), __ T8H, as_FloatRegister($src$$reg), __ T8B);
+  %}
+  ins_pipe(pipe_class_default);
+%}
+
+instruct vcvt4Sto4B(vecD dst, vecD src)
+%{
+  predicate(n->as_Vector()->length() == 4 && n->bottom_type()->is_vect()->element_basic_type() == T_BYTE);
+  match(Set dst (VectorCastS2X src));
+  format %{ "xtn  $dst, T8B, $src, T8H\t# convert 4S to 4B vector" %}
+  ins_encode %{
+    __ xtn(as_FloatRegister($dst$$reg), __ T8B, as_FloatRegister($src$$reg), __ T8H);
+  %}
+  ins_pipe(pipe_class_default);
+%}
+
+instruct vcvt8Sto8B(vecD dst, vecX src)
+%{
+  predicate(n->as_Vector()->length() == 8 && n->bottom_type()->is_vect()->element_basic_type() == T_BYTE);
+  match(Set dst (VectorCastS2X src));
+  format %{ "xtn  $dst, T8B, $src, T8H\t# convert 8S to 8B vector" %}
+  ins_encode %{
+    __ xtn(as_FloatRegister($dst$$reg), __ T8B, as_FloatRegister($src$$reg), __ T8H);
+  %}
+  ins_pipe(pipe_class_default);
+%}
+
+instruct vcvt4Sto4I(vecX dst, vecD src)
+%{
+  predicate(n->as_Vector()->length() == 4 && n->bottom_type()->is_vect()->element_basic_type() == T_INT);
+  match(Set dst (VectorCastS2X src));
+  format %{ "sxtl  $dst, T4S, $src, T4H\t# convert 4S to 4I vector" %}
+  ins_encode %{
+    __ sxtl(as_FloatRegister($dst$$reg), __ T4S, as_FloatRegister($src$$reg), __ T4H);
+  %}
+  ins_pipe(pipe_class_default);
+%}
+
+instruct vcvt4Ito4S(vecD dst, vecX src)
+%{
+  predicate(n->as_Vector()->length() == 4 && n->bottom_type()->is_vect()->element_basic_type() == T_SHORT);
+  match(Set dst (VectorCastI2X src));
+  format %{ "xtn  $dst, T4H, $src, T4S\t# convert 4I to 4S vector" %}
+  ins_encode %{
+    __ xtn(as_FloatRegister($dst$$reg), __ T4H, as_FloatRegister($src$$reg), __ T4S);
+  %}
+  ins_pipe(pipe_class_default);
+%}
+
+instruct vcvt2Ito2L(vecX dst, vecD src)
+%{
+  predicate(n->as_Vector()->length() == 2 && n->bottom_type()->is_vect()->element_basic_type() == T_LONG);
+  match(Set dst (VectorCastI2X src));
+  format %{ "sxtl  $dst, T2D, $src, T2S\t# convert 2I to 2L vector" %}
+  ins_encode %{
+    __ sxtl(as_FloatRegister($dst$$reg), __ T2D, as_FloatRegister($src$$reg), __ T2S);
+  %}
+  ins_pipe(pipe_class_default);
+%}
+
+instruct vcvt2Lto2I(vecD dst, vecX src)
+%{
+  predicate(n->as_Vector()->length() == 2 && n->bottom_type()->is_vect()->element_basic_type() == T_INT);
+  match(Set dst (VectorCastL2X src));
+  format %{ "xtn  $dst, T2S, $src, T2D\t# convert 2L to 2I vector" %}
+  ins_encode %{
+    __ xtn(as_FloatRegister($dst$$reg), __ T2S, as_FloatRegister($src$$reg), __ T2D);
+  %}
+  ins_pipe(pipe_class_default);
+%}
+
+instruct vcvt4Bto4I(vecX dst, vecD src)
+%{
+  predicate(n->as_Vector()->length() == 4 && n->bottom_type()->is_vect()->element_basic_type() == T_INT);
+  match(Set dst (VectorCastB2X src));
+  format %{ "sxtl  $dst, T8H, $src, T8B\n\t"
+            "sxtl  $dst, T4S, $dst, T4H\t# convert 4B to 4I vector"
+  %}
+  ins_encode %{
+    __ sxtl(as_FloatRegister($dst$$reg), __ T8H, as_FloatRegister($src$$reg), __ T8B);
+    __ sxtl(as_FloatRegister($dst$$reg), __ T4S, as_FloatRegister($dst$$reg), __ T4H);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct vcvt4Ito4B(vecD dst, vecX src)
+%{
+  predicate(n->as_Vector()->length() == 4 && n->bottom_type()->is_vect()->element_basic_type() == T_BYTE);
+  match(Set dst (VectorCastI2X src));
+  format %{ "xtn  $dst, T4H, $src, T4S\n\t"
+            "xtn  $dst, T8B, $dst, T8H\t# convert 4I to 4B vector"
+  %}
+  ins_encode %{
+    __ xtn(as_FloatRegister($dst$$reg), __ T4H, as_FloatRegister($src$$reg), __ T4S);
+    __ xtn(as_FloatRegister($dst$$reg), __ T8B, as_FloatRegister($dst$$reg), __ T8H);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct vcvt4Bto4F(vecX dst, vecD src)
+%{
+  predicate(n->as_Vector()->length() == 4 && n->bottom_type()->is_vect()->element_basic_type() == T_FLOAT);
+  match(Set dst (VectorCastB2X src));
+  format %{ "sxtl  $dst, T8H, $src, T8B\n\t"
+            "sxtl  $dst, T4S, $dst, T4H\n\t"
+            "scvtfv  T4S, $dst, $dst\t# convert 4B to 4F vector"
+  %}
+  ins_encode %{
+    __ sxtl(as_FloatRegister($dst$$reg), __ T8H, as_FloatRegister($src$$reg), __ T8B);
+    __ sxtl(as_FloatRegister($dst$$reg), __ T4S, as_FloatRegister($dst$$reg), __ T4H);
+    __ scvtfv(__ T4S, as_FloatRegister($dst$$reg), as_FloatRegister($dst$$reg));
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct vcvt4Sto4F(vecX dst, vecD src)
+%{
+  predicate(n->as_Vector()->length() == 4 && n->bottom_type()->is_vect()->element_basic_type() == T_FLOAT);
+  match(Set dst (VectorCastS2X src));
+  format %{ "sxtl    $dst, T4S, $src, T4H\n\t"
+            "scvtfv  T4S, $dst, $dst\t# convert 4S to 4F vector"
+  %}
+  ins_encode %{
+    __ sxtl(as_FloatRegister($dst$$reg), __ T4S, as_FloatRegister($src$$reg), __ T4H);
+    __ scvtfv(__ T4S, as_FloatRegister($dst$$reg), as_FloatRegister($dst$$reg));
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct vcvt2Ito2D(vecX dst, vecD src)
+%{
+  predicate(n->as_Vector()->length() == 2 && n->bottom_type()->is_vect()->element_basic_type() == T_DOUBLE);
+  match(Set dst (VectorCastI2X src));
+  format %{ "sxtl    $dst, T2D, $src, T2S\n\t"
+            "scvtfv  T2D, $dst, $dst\t# convert 2I to 2D vector"
+  %}
+  ins_encode %{
+    __ sxtl(as_FloatRegister($dst$$reg), __ T2D, as_FloatRegister($src$$reg), __ T2S);
+    __ scvtfv(__ T2D, as_FloatRegister($dst$$reg), as_FloatRegister($dst$$reg));
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct vcvt2Ito2F(vecD dst, vecD src)
+%{
+  predicate(n->as_Vector()->length() == 2 && n->bottom_type()->is_vect()->element_basic_type() == T_FLOAT);
+  match(Set dst (VectorCastI2X src));
+  format %{ "scvtfv  T2S, $dst, $src\t# convert 2I to 2F vector" %}
+  ins_encode %{
+    __ scvtfv(__ T2S, as_FloatRegister($dst$$reg), as_FloatRegister($src$$reg));
+  %}
+  ins_pipe(pipe_class_default);
+%}
+
+instruct vcvt4Ito4F(vecX dst, vecX src)
+%{
+  predicate(n->as_Vector()->length() == 4 && n->bottom_type()->is_vect()->element_basic_type() == T_FLOAT);
+  match(Set dst (VectorCastI2X src));
+  format %{ "scvtfv  T4S, $dst, $src\t# convert 4I to 4F vector" %}
+  ins_encode %{
+    __ scvtfv(__ T4S, as_FloatRegister($dst$$reg), as_FloatRegister($src$$reg));
+  %}
+  ins_pipe(pipe_class_default);
+%}
+
+instruct vcvt2Lto2D(vecX dst, vecX src)
+%{
+  predicate(n->as_Vector()->length() == 2 && n->bottom_type()->is_vect()->element_basic_type() == T_DOUBLE);
+  match(Set dst (VectorCastL2X src));
+  format %{ "scvtfv  T2D, $dst, $src\t# convert 2L to 2D vector" %}
+  ins_encode %{
+    __ scvtfv(__ T2D, as_FloatRegister($dst$$reg), as_FloatRegister($src$$reg));
+  %}
+  ins_pipe(pipe_class_default);
+%}
+
+instruct vcvt2Fto2D(vecX dst, vecD src)
+%{
+  predicate(n->as_Vector()->length() == 2 && n->bottom_type()->is_vect()->element_basic_type() == T_DOUBLE);
+  match(Set dst (VectorCastF2X src));
+  format %{ "fcvtl  $dst, T2D, $src, T2S\t# convert 2F to 2D vector" %}
+  ins_encode %{
+    __ fcvtl(as_FloatRegister($dst$$reg), __ T2D, as_FloatRegister($src$$reg), __ T2S);
+  %}
+  ins_pipe(pipe_class_default);
+%}
+
+instruct vcvt2Dto2F(vecD dst, vecX src)
+%{
+  predicate(n->as_Vector()->length() == 2 && n->bottom_type()->is_vect()->element_basic_type() == T_FLOAT);
+  match(Set dst (VectorCastD2X src));
+  format %{ "fcvtn  $dst, T2S, $src, T2D\t# convert 2D to 2F vector" %}
+  ins_encode %{
+    __ fcvtn(as_FloatRegister($dst$$reg), __ T2S, as_FloatRegister($src$$reg), __ T2D);
+  %}
+  ins_pipe(pipe_class_default);
+%}
+
+instruct vcvt2Lto2F(vecD dst, vecX src)
+%{
+  predicate(n->as_Vector()->length() == 2 && n->bottom_type()->is_vect()->element_basic_type() == T_FLOAT);
+  match(Set dst (VectorCastL2X src));
+  format %{ "scvtfv  T2D, $dst, $src\n\t"
+            "fcvtn   $dst, T2S, $dst, T2D\t# convert 2L to 2F vector"
+  %}
+  ins_encode %{
+    __ scvtfv(__ T2D, as_FloatRegister($dst$$reg), as_FloatRegister($src$$reg));
+    __ fcvtn(as_FloatRegister($dst$$reg), __ T2S, as_FloatRegister($dst$$reg), __ T2D);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+// ------------------------------ Reduction -------------------------------
+
+instruct reduce_add8B(iRegINoSp dst, iRegIorL2I isrc, vecD vsrc, vecD tmp)
+%{
+  predicate(n->in(2)->bottom_type()->is_vect()->element_basic_type() == T_BYTE);
+  match(Set dst (AddReductionVI isrc vsrc));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst, TEMP tmp);
+  format %{ "addv  $tmp, T8B, $vsrc\n\t"
+            "smov  $dst, $tmp, B, 0\n\t"
+            "addw  $dst, $dst, $isrc\n\t"
+            "sxtb  $dst, $dst\t# add reduction8B"
+  %}
+  ins_encode %{
+    __ addv(as_FloatRegister($tmp$$reg), __ T8B, as_FloatRegister($vsrc$$reg));
+    __ smov($dst$$Register, as_FloatRegister($tmp$$reg), __ B, 0);
+    __ addw($dst$$Register, $dst$$Register, $isrc$$Register);
+    __ sxtb($dst$$Register, $dst$$Register);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct reduce_add16B(iRegINoSp dst, iRegIorL2I isrc, vecX vsrc, vecX tmp)
+%{
+  predicate(n->in(2)->bottom_type()->is_vect()->element_basic_type() == T_BYTE);
+  match(Set dst (AddReductionVI isrc vsrc));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst, TEMP tmp);
+  format %{ "addv  $tmp, T16B, $vsrc\n\t"
+            "smov  $dst, $tmp, B, 0\n\t"
+            "addw  $dst, $dst, $isrc\n\t"
+            "sxtb  $dst, $dst\t# add reduction16B"
+  %}
+  ins_encode %{
+    __ addv(as_FloatRegister($tmp$$reg), __ T16B, as_FloatRegister($vsrc$$reg));
+    __ smov($dst$$Register, as_FloatRegister($tmp$$reg), __ B, 0);
+    __ addw($dst$$Register, $dst$$Register, $isrc$$Register);
+    __ sxtb($dst$$Register, $dst$$Register);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct reduce_add4S(iRegINoSp dst, iRegIorL2I isrc, vecD vsrc, vecD tmp)
+%{
+  predicate(n->in(2)->bottom_type()->is_vect()->element_basic_type() == T_SHORT);
+  match(Set dst (AddReductionVI isrc vsrc));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst, TEMP tmp);
+  format %{ "addv  $tmp, T4H, $vsrc\n\t"
+            "smov  $dst, $tmp, H, 0\n\t"
+            "addw  $dst, $dst, $isrc\n\t"
+            "sxth  $dst, $dst\t# add reduction4S"
+  %}
+  ins_encode %{
+    __ addv(as_FloatRegister($tmp$$reg), __ T4H, as_FloatRegister($vsrc$$reg));
+    __ smov($dst$$Register, as_FloatRegister($tmp$$reg), __ H, 0);
+    __ addw($dst$$Register, $dst$$Register, $isrc$$Register);
+    __ sxth($dst$$Register, $dst$$Register);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct reduce_add8S(iRegINoSp dst, iRegIorL2I isrc, vecX vsrc, vecX tmp)
+%{
+  predicate(n->in(2)->bottom_type()->is_vect()->element_basic_type() == T_SHORT);
+  match(Set dst (AddReductionVI isrc vsrc));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst, TEMP tmp);
+  format %{ "addv  $tmp, T8H, $vsrc\n\t"
+            "smov  $dst, $tmp, H, 0\n\t"
+            "addw  $dst, $dst, $isrc\n\t"
+            "sxth  $dst, $dst\t# add reduction8S"
+  %}
+  ins_encode %{
+    __ addv(as_FloatRegister($tmp$$reg), __ T8H, as_FloatRegister($vsrc$$reg));
+    __ smov($dst$$Register, as_FloatRegister($tmp$$reg), __ H, 0);
+    __ addw($dst$$Register, $dst$$Register, $isrc$$Register);
+    __ sxth($dst$$Register, $dst$$Register);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct reduce_add2L(iRegLNoSp dst, iRegL isrc, vecX vsrc, vecX tmp)
+%{
+  match(Set dst (AddReductionVL isrc vsrc));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst, TEMP tmp);
+  format %{ "addpd $tmp, $vsrc\n\t"
+            "umov  $dst, $tmp, D, 0\n\t"
+            "add   $dst, $isrc, $dst\t# add reduction2L"
+  %}
+  ins_encode %{
+    __ addpd(as_FloatRegister($tmp$$reg), as_FloatRegister($vsrc$$reg));
+    __ umov($dst$$Register, as_FloatRegister($tmp$$reg), __ D, 0);
+    __ add($dst$$Register, $isrc$$Register, $dst$$Register);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct reduce_mul8B(iRegINoSp dst, iRegIorL2I isrc, vecD vsrc, vecD vtmp1, vecD vtmp2, iRegINoSp itmp)
+%{
+  predicate(n->in(2)->bottom_type()->is_vect()->element_basic_type() == T_BYTE);
+  match(Set dst (MulReductionVI isrc vsrc));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst, TEMP vtmp1, TEMP vtmp2, TEMP itmp);
+  format %{ "ins   $vtmp1, S, $vsrc, 0, 1\n\t"
+            "mulv  $vtmp1, T8B, $vtmp1, $vsrc\n\t"
+            "ins   $vtmp2, H, $vtmp1, 0, 1\n\t"
+            "mulv  $vtmp2, T8B, $vtmp2, $vtmp1\n\t"
+            "umov  $itmp, $vtmp2, B, 0\n\t"
+            "mulw  $dst, $itmp, $isrc\n\t"
+            "sxtb  $dst, $dst\n\t"
+            "umov  $itmp, $vtmp2, B, 1\n\t"
+            "mulw  $dst, $itmp, $dst\n\t"
+            "sxtb  $dst, $dst\t# mul reduction8B"
+  %}
+  ins_encode %{
+    __ ins(as_FloatRegister($vtmp1$$reg), __ S,
+           as_FloatRegister($vsrc$$reg), 0, 1);
+    __ mulv(as_FloatRegister($vtmp1$$reg), __ T8B,
+            as_FloatRegister($vtmp1$$reg), as_FloatRegister($vsrc$$reg));
+    __ ins(as_FloatRegister($vtmp2$$reg), __ H,
+           as_FloatRegister($vtmp1$$reg), 0, 1);
+    __ mulv(as_FloatRegister($vtmp2$$reg), __ T8B,
+            as_FloatRegister($vtmp2$$reg), as_FloatRegister($vtmp1$$reg));
+    __ umov($itmp$$Register, as_FloatRegister($vtmp2$$reg), __ B, 0);
+    __ mulw($dst$$Register, $itmp$$Register, $isrc$$Register);
+    __ sxtb($dst$$Register, $dst$$Register);
+    __ umov($itmp$$Register, as_FloatRegister($vtmp2$$reg), __ B, 1);
+    __ mulw($dst$$Register, $itmp$$Register, $dst$$Register);
+    __ sxtb($dst$$Register, $dst$$Register);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct reduce_mul16B(iRegINoSp dst, iRegIorL2I isrc, vecX vsrc, vecX vtmp1, vecX vtmp2, iRegINoSp itmp)
+%{
+  predicate(n->in(2)->bottom_type()->is_vect()->element_basic_type() == T_BYTE);
+  match(Set dst (MulReductionVI isrc vsrc));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst, TEMP vtmp1, TEMP vtmp2, TEMP itmp);
+  format %{ "ins   $vtmp1, D, $vsrc, 0, 1\n\t"
+            "mulv  $vtmp1, T8B, $vtmp1, $vsrc\n\t"
+            "ins   $vtmp2, S, $vtmp1, 0, 1\n\t"
+            "mulv  $vtmp1, T8B, $vtmp2, $vtmp1\n\t"
+            "ins   $vtmp2, H, $vtmp1, 0, 1\n\t"
+            "mulv  $vtmp2, T8B, $vtmp2, $vtmp1\n\t"
+            "umov  $itmp, $vtmp2, B, 0\n\t"
+            "mulw  $dst, $itmp, $isrc\n\t"
+            "sxtb  $dst, $dst\n\t"
+            "umov  $itmp, $vtmp2, B, 1\n\t"
+            "mulw  $dst, $itmp, $dst\n\t"
+            "sxtb  $dst, $dst\t# mul reduction16B"
+  %}
+  ins_encode %{
+    __ ins(as_FloatRegister($vtmp1$$reg), __ D,
+           as_FloatRegister($vsrc$$reg), 0, 1);
+    __ mulv(as_FloatRegister($vtmp1$$reg), __ T8B,
+            as_FloatRegister($vtmp1$$reg), as_FloatRegister($vsrc$$reg));
+    __ ins(as_FloatRegister($vtmp2$$reg), __ S,
+           as_FloatRegister($vtmp1$$reg), 0, 1);
+    __ mulv(as_FloatRegister($vtmp1$$reg), __ T8B,
+            as_FloatRegister($vtmp2$$reg), as_FloatRegister($vtmp1$$reg));
+    __ ins(as_FloatRegister($vtmp2$$reg), __ H,
+           as_FloatRegister($vtmp1$$reg), 0, 1);
+    __ mulv(as_FloatRegister($vtmp2$$reg), __ T8B,
+            as_FloatRegister($vtmp2$$reg), as_FloatRegister($vtmp1$$reg));
+    __ umov($itmp$$Register, as_FloatRegister($vtmp2$$reg), __ B, 0);
+    __ mulw($dst$$Register, $itmp$$Register, $isrc$$Register);
+    __ sxtb($dst$$Register, $dst$$Register);
+    __ umov($itmp$$Register, as_FloatRegister($vtmp2$$reg), __ B, 1);
+    __ mulw($dst$$Register, $itmp$$Register, $dst$$Register);
+    __ sxtb($dst$$Register, $dst$$Register);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct reduce_mul4S(iRegINoSp dst, iRegIorL2I isrc, vecD vsrc, vecD vtmp, iRegINoSp itmp)
+%{
+  predicate(n->in(2)->bottom_type()->is_vect()->element_basic_type() == T_SHORT);
+  match(Set dst (MulReductionVI isrc vsrc));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst, TEMP vtmp, TEMP itmp);
+  format %{ "ins   $vtmp, S, $vsrc, 0, 1\n\t"
+            "mulv  $vtmp, T4H, $vtmp, $vsrc\n\t"
+            "umov  $itmp, $vtmp, H, 0\n\t"
+            "mulw  $dst, $itmp, $isrc\n\t"
+            "sxth  $dst, $dst\n\t"
+            "umov  $itmp, $vtmp, H, 1\n\t"
+            "mulw  $dst, $itmp, $dst\n\t"
+            "sxth  $dst, $dst\t# mul reduction4S"
+  %}
+  ins_encode %{
+    __ ins(as_FloatRegister($vtmp$$reg), __ S,
+           as_FloatRegister($vsrc$$reg), 0, 1);
+    __ mulv(as_FloatRegister($vtmp$$reg), __ T4H,
+            as_FloatRegister($vtmp$$reg), as_FloatRegister($vsrc$$reg));
+    __ umov($itmp$$Register, as_FloatRegister($vtmp$$reg), __ H, 0);
+    __ mulw($dst$$Register, $itmp$$Register, $isrc$$Register);
+    __ sxth($dst$$Register, $dst$$Register);
+    __ umov($itmp$$Register, as_FloatRegister($vtmp$$reg), __ H, 1);
+    __ mulw($dst$$Register, $itmp$$Register, $dst$$Register);
+    __ sxth($dst$$Register, $dst$$Register);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct reduce_mul8S(iRegINoSp dst, iRegIorL2I isrc, vecX vsrc, vecX vtmp1, vecX vtmp2, iRegINoSp itmp)
+%{
+  predicate(n->in(2)->bottom_type()->is_vect()->element_basic_type() == T_SHORT);
+  match(Set dst (MulReductionVI isrc vsrc));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst, TEMP vtmp1, TEMP vtmp2, TEMP itmp);
+  format %{ "ins   $vtmp1, D, $vsrc, 0, 1\n\t"
+            "mulv  $vtmp1, T4H, $vtmp1, $vsrc\n\t"
+            "ins   $vtmp2, S, $vtmp1, 0, 1\n\t"
+            "mulv  $vtmp2, T4H, $vtmp2, $vtmp1\n\t"
+            "umov  $itmp, $vtmp2, H, 0\n\t"
+            "mulw  $dst, $itmp, $isrc\n\t"
+            "sxth  $dst, $dst\n\t"
+            "umov  $itmp, $vtmp2, H, 1\n\t"
+            "mulw  $dst, $itmp, $dst\n\t"
+            "sxth  $dst, $dst\t# mul reduction8S"
+  %}
+  ins_encode %{
+    __ ins(as_FloatRegister($vtmp1$$reg), __ D,
+           as_FloatRegister($vsrc$$reg), 0, 1);
+    __ mulv(as_FloatRegister($vtmp1$$reg), __ T4H,
+            as_FloatRegister($vtmp1$$reg), as_FloatRegister($vsrc$$reg));
+    __ ins(as_FloatRegister($vtmp2$$reg), __ S,
+           as_FloatRegister($vtmp1$$reg), 0, 1);
+    __ mulv(as_FloatRegister($vtmp2$$reg), __ T4H,
+            as_FloatRegister($vtmp2$$reg), as_FloatRegister($vtmp1$$reg));
+    __ umov($itmp$$Register, as_FloatRegister($vtmp2$$reg), __ H, 0);
+    __ mulw($dst$$Register, $itmp$$Register, $isrc$$Register);
+    __ sxth($dst$$Register, $dst$$Register);
+    __ umov($itmp$$Register, as_FloatRegister($vtmp2$$reg), __ H, 1);
+    __ mulw($dst$$Register, $itmp$$Register, $dst$$Register);
+    __ sxth($dst$$Register, $dst$$Register);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct reduce_mul2L(iRegLNoSp dst, iRegL isrc, vecX vsrc, iRegLNoSp tmp)
+%{
+  match(Set dst (MulReductionVL isrc vsrc));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst, TEMP tmp);
+  format %{ "umov  $tmp, $vsrc, D, 0\n\t"
+            "mul   $dst, $isrc, $tmp\n\t"
+            "umov  $tmp, $vsrc, D, 1\n\t"
+            "mul   $dst, $dst, $tmp\t# mul reduction2L"
+  %}
+  ins_encode %{
+    __ umov($tmp$$Register, as_FloatRegister($vsrc$$reg), __ D, 0);
+    __ mul($dst$$Register, $isrc$$Register, $tmp$$Register);
+    __ umov($tmp$$Register, as_FloatRegister($vsrc$$reg), __ D, 1);
+    __ mul($dst$$Register, $dst$$Register, $tmp$$Register);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct reduce_max8B(iRegINoSp dst, iRegIorL2I isrc, vecD vsrc, vecD tmp, rFlagsReg cr)
+%{
+  predicate(n->in(2)->bottom_type()->is_vect()->element_basic_type() == T_BYTE);
+  match(Set dst (MaxReductionV isrc vsrc));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst, TEMP tmp, KILL cr);
+  format %{ "smaxv $tmp, T8B, $vsrc\n\t"
+            "smov  $dst, $tmp, B, 0\n\t"
+            "cmpw  $dst, $isrc\n\t"
+            "cselw $dst, $dst, $isrc GT\t# max reduction8B"
+  %}
+  ins_encode %{
+    __ smaxv(as_FloatRegister($tmp$$reg), __ T8B, as_FloatRegister($vsrc$$reg));
+    __ smov(as_Register($dst$$reg), as_FloatRegister($tmp$$reg), __ B, 0);
+    __ cmpw(as_Register($dst$$reg), as_Register($isrc$$reg));
+    __ cselw(as_Register($dst$$reg), as_Register($dst$$reg), as_Register($isrc$$reg), Assembler::GT);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct reduce_max16B(iRegINoSp dst, iRegIorL2I isrc, vecX vsrc, vecX tmp, rFlagsReg cr)
+%{
+  predicate(n->in(2)->bottom_type()->is_vect()->element_basic_type() == T_BYTE);
+  match(Set dst (MaxReductionV isrc vsrc));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst, TEMP tmp, KILL cr);
+  format %{ "smaxv $tmp, T16B, $vsrc\n\t"
+            "smov  $dst, $tmp, B, 0\n\t"
+            "cmpw  $dst, $isrc\n\t"
+            "cselw $dst, $dst, $isrc GT\t# max reduction16B"
+  %}
+  ins_encode %{
+    __ smaxv(as_FloatRegister($tmp$$reg), __ T16B, as_FloatRegister($vsrc$$reg));
+    __ smov(as_Register($dst$$reg), as_FloatRegister($tmp$$reg), __ B, 0);
+    __ cmpw(as_Register($dst$$reg), as_Register($isrc$$reg));
+    __ cselw(as_Register($dst$$reg), as_Register($dst$$reg), as_Register($isrc$$reg), Assembler::GT);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct reduce_max4S(iRegINoSp dst, iRegIorL2I isrc, vecD vsrc, vecD tmp, rFlagsReg cr)
+%{
+  predicate(n->in(2)->bottom_type()->is_vect()->element_basic_type() == T_SHORT);
+  match(Set dst (MaxReductionV isrc vsrc));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst, TEMP tmp, KILL cr);
+  format %{ "smaxv $tmp, T4H, $vsrc\n\t"
+            "smov  $dst, $tmp, H, 0\n\t"
+            "cmpw  $dst, $isrc\n\t"
+            "cselw $dst, $dst, $isrc GT\t# max reduction4S"
+  %}
+  ins_encode %{
+    __ smaxv(as_FloatRegister($tmp$$reg), __ T4H, as_FloatRegister($vsrc$$reg));
+    __ smov(as_Register($dst$$reg), as_FloatRegister($tmp$$reg), __ H, 0);
+    __ cmpw(as_Register($dst$$reg), as_Register($isrc$$reg));
+    __ cselw(as_Register($dst$$reg), as_Register($dst$$reg), as_Register($isrc$$reg), Assembler::GT);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct reduce_max8S(iRegINoSp dst, iRegIorL2I isrc, vecX vsrc, vecX tmp, rFlagsReg cr)
+%{
+  predicate(n->in(2)->bottom_type()->is_vect()->element_basic_type() == T_SHORT);
+  match(Set dst (MaxReductionV isrc vsrc));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst, TEMP tmp, KILL cr);
+  format %{ "smaxv $tmp, T8H, $vsrc\n\t"
+            "smov  $dst, $tmp, H, 0\n\t"
+            "cmpw  $dst, $isrc\n\t"
+            "cselw $dst, $dst, $isrc GT\t# max reduction8S"
+  %}
+  ins_encode %{
+    __ smaxv(as_FloatRegister($tmp$$reg), __ T8H, as_FloatRegister($vsrc$$reg));
+    __ smov(as_Register($dst$$reg), as_FloatRegister($tmp$$reg), __ H, 0);
+    __ cmpw(as_Register($dst$$reg), as_Register($isrc$$reg));
+    __ cselw(as_Register($dst$$reg), as_Register($dst$$reg), as_Register($isrc$$reg), Assembler::GT);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct reduce_max4I(iRegINoSp dst, iRegIorL2I isrc, vecX vsrc, vecX tmp, rFlagsReg cr)
+%{
+  predicate(n->in(2)->bottom_type()->is_vect()->element_basic_type() == T_INT);
+  match(Set dst (MaxReductionV isrc vsrc));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst, TEMP tmp, KILL cr);
+  format %{ "smaxv $tmp, T4S, $vsrc\n\t"
+            "umov  $dst, $tmp, S, 0\n\t"
+            "cmpw  $dst, $isrc\n\t"
+            "cselw $dst, $dst, $isrc GT\t# max reduction4I"
+  %}
+  ins_encode %{
+    __ smaxv(as_FloatRegister($tmp$$reg), __ T4S, as_FloatRegister($vsrc$$reg));
+    __ umov(as_Register($dst$$reg), as_FloatRegister($tmp$$reg), __ S, 0);
+    __ cmpw(as_Register($dst$$reg), as_Register($isrc$$reg));
+    __ cselw(as_Register($dst$$reg), as_Register($dst$$reg), as_Register($isrc$$reg), Assembler::GT);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct reduce_min8B(iRegINoSp dst, iRegIorL2I isrc, vecD vsrc, vecD tmp, rFlagsReg cr)
+%{
+  predicate(n->in(2)->bottom_type()->is_vect()->element_basic_type() == T_BYTE);
+  match(Set dst (MinReductionV isrc vsrc));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst, TEMP tmp, KILL cr);
+  format %{ "sminv $tmp, T8B, $vsrc\n\t"
+            "smov  $dst, $tmp, B, 0\n\t"
+            "cmpw  $dst, $isrc\n\t"
+            "cselw $dst, $dst, $isrc LT\t# min reduction8B"
+  %}
+  ins_encode %{
+    __ sminv(as_FloatRegister($tmp$$reg), __ T8B, as_FloatRegister($vsrc$$reg));
+    __ smov(as_Register($dst$$reg), as_FloatRegister($tmp$$reg), __ B, 0);
+    __ cmpw(as_Register($dst$$reg), as_Register($isrc$$reg));
+    __ cselw(as_Register($dst$$reg), as_Register($dst$$reg), as_Register($isrc$$reg), Assembler::LT);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct reduce_min16B(iRegINoSp dst, iRegIorL2I isrc, vecX vsrc, vecX tmp, rFlagsReg cr)
+%{
+  predicate(n->in(2)->bottom_type()->is_vect()->element_basic_type() == T_BYTE);
+  match(Set dst (MinReductionV isrc vsrc));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst, TEMP tmp, KILL cr);
+  format %{ "sminv $tmp, T16B, $vsrc\n\t"
+            "smov  $dst, $tmp, B, 0\n\t"
+            "cmpw  $dst, $isrc\n\t"
+            "cselw $dst, $dst, $isrc LT\t# min reduction16B"
+  %}
+  ins_encode %{
+    __ sminv(as_FloatRegister($tmp$$reg), __ T16B, as_FloatRegister($vsrc$$reg));
+    __ smov(as_Register($dst$$reg), as_FloatRegister($tmp$$reg), __ B, 0);
+    __ cmpw(as_Register($dst$$reg), as_Register($isrc$$reg));
+    __ cselw(as_Register($dst$$reg), as_Register($dst$$reg), as_Register($isrc$$reg), Assembler::LT);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct reduce_min4S(iRegINoSp dst, iRegIorL2I isrc, vecD vsrc, vecD tmp, rFlagsReg cr)
+%{
+  predicate(n->in(2)->bottom_type()->is_vect()->element_basic_type() == T_SHORT);
+  match(Set dst (MinReductionV isrc vsrc));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst, TEMP tmp, KILL cr);
+  format %{ "sminv $tmp, T4H, $vsrc\n\t"
+            "smov  $dst, $tmp, H, 0\n\t"
+            "cmpw  $dst, $isrc\n\t"
+            "cselw $dst, $dst, $isrc LT\t# min reduction4S"
+  %}
+  ins_encode %{
+    __ sminv(as_FloatRegister($tmp$$reg), __ T4H, as_FloatRegister($vsrc$$reg));
+    __ smov(as_Register($dst$$reg), as_FloatRegister($tmp$$reg), __ H, 0);
+    __ cmpw(as_Register($dst$$reg), as_Register($isrc$$reg));
+    __ cselw(as_Register($dst$$reg), as_Register($dst$$reg), as_Register($isrc$$reg), Assembler::LT);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct reduce_min8S(iRegINoSp dst, iRegIorL2I isrc, vecX vsrc, vecX tmp, rFlagsReg cr)
+%{
+  predicate(n->in(2)->bottom_type()->is_vect()->element_basic_type() == T_SHORT);
+  match(Set dst (MinReductionV isrc vsrc));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst, TEMP tmp, KILL cr);
+  format %{ "sminv $tmp, T8H, $vsrc\n\t"
+            "smov  $dst, $tmp, H, 0\n\t"
+            "cmpw  $dst, $isrc\n\t"
+            "cselw $dst, $dst, $isrc LT\t# min reduction8S"
+  %}
+  ins_encode %{
+    __ sminv(as_FloatRegister($tmp$$reg), __ T8H, as_FloatRegister($vsrc$$reg));
+    __ smov(as_Register($dst$$reg), as_FloatRegister($tmp$$reg), __ H, 0);
+    __ cmpw(as_Register($dst$$reg), as_Register($isrc$$reg));
+    __ cselw(as_Register($dst$$reg), as_Register($dst$$reg), as_Register($isrc$$reg), Assembler::LT);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct reduce_min4I(iRegINoSp dst, iRegIorL2I isrc, vecX vsrc, vecX tmp, rFlagsReg cr)
+%{
+  predicate(n->in(2)->bottom_type()->is_vect()->element_basic_type() == T_INT);
+  match(Set dst (MinReductionV isrc vsrc));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst, TEMP tmp, KILL cr);
+  format %{ "sminv $tmp, T4S, $vsrc\n\t"
+            "umov  $dst, $tmp, S, 0\n\t"
+            "cmpw  $dst, $isrc\n\t"
+            "cselw $dst, $dst, $isrc LT\t# min reduction4I"
+  %}
+  ins_encode %{
+    __ sminv(as_FloatRegister($tmp$$reg), __ T4S, as_FloatRegister($vsrc$$reg));
+    __ umov(as_Register($dst$$reg), as_FloatRegister($tmp$$reg), __ S, 0);
+    __ cmpw(as_Register($dst$$reg), as_Register($isrc$$reg));
+    __ cselw(as_Register($dst$$reg), as_Register($dst$$reg), as_Register($isrc$$reg), Assembler::LT);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct reduce_max2I(iRegINoSp dst, iRegIorL2I isrc, vecD vsrc, vecX tmp, rFlagsReg cr)
+%{
+  predicate(n->in(2)->bottom_type()->is_vect()->element_basic_type() == T_INT);
+  match(Set dst (MaxReductionV isrc vsrc));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst, TEMP tmp, KILL cr);
+  format %{ "dup   $tmp, T2D, $vsrc\n\t"
+            "smaxv $tmp, T4S, $tmp\n\t"
+            "umov  $dst, $tmp, S, 0\n\t"
+            "cmpw  $dst, $isrc\n\t"
+            "cselw $dst, $dst, $isrc GT\t# max reduction2I"
+  %}
+  ins_encode %{
+    __ dup(as_FloatRegister($tmp$$reg), __ T2D, as_FloatRegister($vsrc$$reg));
+    __ smaxv(as_FloatRegister($tmp$$reg), __ T4S, as_FloatRegister($tmp$$reg));
+    __ umov(as_Register($dst$$reg), as_FloatRegister($tmp$$reg), __ S, 0);
+    __ cmpw(as_Register($dst$$reg), as_Register($isrc$$reg));
+    __ cselw(as_Register($dst$$reg), as_Register($dst$$reg), as_Register($isrc$$reg), Assembler::GT);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct reduce_min2I(iRegINoSp dst, iRegIorL2I isrc, vecD vsrc, vecX tmp, rFlagsReg cr)
+%{
+  predicate(n->in(2)->bottom_type()->is_vect()->element_basic_type() == T_INT);
+  match(Set dst (MinReductionV isrc vsrc));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst, TEMP tmp, KILL cr);
+  format %{ "dup   $tmp, T2D, $vsrc\n\t"
+            "sminv $tmp, T4S, $tmp\n\t"
+            "umov  $dst, $tmp, S, 0\n\t"
+            "cmpw  $dst, $isrc\n\t"
+            "cselw $dst, $dst, $isrc LT\t# min reduction2I"
+  %}
+  ins_encode %{
+    __ dup(as_FloatRegister($tmp$$reg), __ T2D, as_FloatRegister($vsrc$$reg));
+    __ sminv(as_FloatRegister($tmp$$reg), __ T4S, as_FloatRegister($tmp$$reg));
+    __ umov(as_Register($dst$$reg), as_FloatRegister($tmp$$reg), __ S, 0);
+    __ cmpw(as_Register($dst$$reg), as_Register($isrc$$reg));
+    __ cselw(as_Register($dst$$reg), as_Register($dst$$reg), as_Register($isrc$$reg), Assembler::LT);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct reduce_max2L(iRegLNoSp dst, iRegL isrc, vecX vsrc, iRegLNoSp tmp, rFlagsReg cr)
+%{
+  predicate(n->in(2)->bottom_type()->is_vect()->element_basic_type() == T_LONG);
+  match(Set dst (MaxReductionV isrc vsrc));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst, TEMP tmp, KILL cr);
+  format %{ "umov  $tmp, $vsrc, D, 0\n\t"
+            "cmp   $isrc,$tmp\n\t"
+            "csel  $dst, $isrc, $tmp GT\n\t"
+            "umov  $tmp, $vsrc, D, 1\n\t"
+            "cmp   $dst, $tmp\n\t"
+            "csel  $dst, $dst, $tmp GT\t# max reduction2L"
+  %}
+  ins_encode %{
+    __ umov(as_Register($tmp$$reg), as_FloatRegister($vsrc$$reg), __ D, 0);
+    __ cmp(as_Register($isrc$$reg), as_Register($tmp$$reg));
+    __ csel(as_Register($dst$$reg), as_Register($isrc$$reg), as_Register($tmp$$reg), Assembler::GT);
+    __ umov(as_Register($tmp$$reg), as_FloatRegister($vsrc$$reg), __ D, 1);
+    __ cmp(as_Register($dst$$reg), as_Register($tmp$$reg));
+    __ csel(as_Register($dst$$reg), as_Register($dst$$reg), as_Register($tmp$$reg), Assembler::GT);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct reduce_min2L(iRegLNoSp dst, iRegL isrc, vecX vsrc, iRegLNoSp tmp, rFlagsReg cr)
+%{
+  predicate(n->in(2)->bottom_type()->is_vect()->element_basic_type() == T_LONG);
+  match(Set dst (MinReductionV isrc vsrc));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst, TEMP tmp, KILL cr);
+  format %{ "umov  $tmp, $vsrc, D, 0\n\t"
+            "cmp   $isrc,$tmp\n\t"
+            "csel  $dst, $isrc, $tmp LT\n\t"
+            "umov  $tmp, $vsrc, D, 1\n\t"
+            "cmp   $dst, $tmp\n\t"
+            "csel  $dst, $dst, $tmp LT\t# min reduction2L"
+  %}
+  ins_encode %{
+    __ umov(as_Register($tmp$$reg), as_FloatRegister($vsrc$$reg), __ D, 0);
+    __ cmp(as_Register($isrc$$reg), as_Register($tmp$$reg));
+    __ csel(as_Register($dst$$reg), as_Register($isrc$$reg), as_Register($tmp$$reg), Assembler::LT);
+    __ umov(as_Register($tmp$$reg), as_FloatRegister($vsrc$$reg), __ D, 1);
+    __ cmp(as_Register($dst$$reg), as_Register($tmp$$reg));
+    __ csel(as_Register($dst$$reg), as_Register($dst$$reg), as_Register($tmp$$reg), Assembler::LT);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct reduce_and8B(iRegINoSp dst, iRegIorL2I isrc, vecD vsrc, iRegINoSp tmp)
+%{
+  predicate(n->in(2)->bottom_type()->is_vect()->element_basic_type() == T_BYTE);
+  match(Set dst (AndReductionV isrc vsrc));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst, TEMP tmp);
+  format %{ "umov   $tmp, $vsrc, S, 0\n\t"
+            "umov   $dst, $vsrc, S, 1\n\t"
+            "andw   $dst, $dst, $tmp\n\t"
+            "andw   $dst, $dst, $dst, LSR #16\n\t"
+            "andw   $dst, $dst, $dst, LSR #8\n\t"
+            "andw   $dst, $isrc, $dst\n\t"
+            "sxtb   $dst, $dst\t# and reduction8B"
+  %}
+  ins_encode %{
+    __ umov($tmp$$Register, as_FloatRegister($vsrc$$reg), __ S, 0);
+    __ umov($dst$$Register, as_FloatRegister($vsrc$$reg), __ S, 1);
+    __ andw($dst$$Register, $dst$$Register, $tmp$$Register);
+    __ andw($dst$$Register, $dst$$Register, $dst$$Register, Assembler::LSR, 16);
+    __ andw($dst$$Register, $dst$$Register, $dst$$Register, Assembler::LSR, 8);
+    __ andw($dst$$Register, $isrc$$Register, $dst$$Register);
+    __ sxtb($dst$$Register, $dst$$Register);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct reduce_orr8B(iRegINoSp dst, iRegIorL2I isrc, vecD vsrc, iRegINoSp tmp)
+%{
+  predicate(n->in(2)->bottom_type()->is_vect()->element_basic_type() == T_BYTE);
+  match(Set dst (OrReductionV isrc vsrc));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst, TEMP tmp);
+  format %{ "umov   $tmp, $vsrc, S, 0\n\t"
+            "umov   $dst, $vsrc, S, 1\n\t"
+            "orrw   $dst, $dst, $tmp\n\t"
+            "orrw   $dst, $dst, $dst, LSR #16\n\t"
+            "orrw   $dst, $dst, $dst, LSR #8\n\t"
+            "orrw   $dst, $isrc, $dst\n\t"
+            "sxtb   $dst, $dst\t# orr reduction8B"
+  %}
+  ins_encode %{
+    __ umov($tmp$$Register, as_FloatRegister($vsrc$$reg), __ S, 0);
+    __ umov($dst$$Register, as_FloatRegister($vsrc$$reg), __ S, 1);
+    __ orrw($dst$$Register, $dst$$Register, $tmp$$Register);
+    __ orrw($dst$$Register, $dst$$Register, $dst$$Register, Assembler::LSR, 16);
+    __ orrw($dst$$Register, $dst$$Register, $dst$$Register, Assembler::LSR, 8);
+    __ orrw($dst$$Register, $isrc$$Register, $dst$$Register);
+    __ sxtb($dst$$Register, $dst$$Register);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct reduce_eor8B(iRegINoSp dst, iRegIorL2I isrc, vecD vsrc, iRegINoSp tmp)
+%{
+  predicate(n->in(2)->bottom_type()->is_vect()->element_basic_type() == T_BYTE);
+  match(Set dst (XorReductionV isrc vsrc));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst, TEMP tmp);
+  format %{ "umov   $tmp, $vsrc, S, 0\n\t"
+            "umov   $dst, $vsrc, S, 1\n\t"
+            "eorw   $dst, $dst, $tmp\n\t"
+            "eorw   $dst, $dst, $dst, LSR #16\n\t"
+            "eorw   $dst, $dst, $dst, LSR #8\n\t"
+            "eorw   $dst, $isrc, $dst\n\t"
+            "sxtb   $dst, $dst\t# eor reduction8B"
+  %}
+  ins_encode %{
+    __ umov($tmp$$Register, as_FloatRegister($vsrc$$reg), __ S, 0);
+    __ umov($dst$$Register, as_FloatRegister($vsrc$$reg), __ S, 1);
+    __ eorw($dst$$Register, $dst$$Register, $tmp$$Register);
+    __ eorw($dst$$Register, $dst$$Register, $dst$$Register, Assembler::LSR, 16);
+    __ eorw($dst$$Register, $dst$$Register, $dst$$Register, Assembler::LSR, 8);
+    __ eorw($dst$$Register, $isrc$$Register, $dst$$Register);
+    __ sxtb($dst$$Register, $dst$$Register);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct reduce_and16B(iRegINoSp dst, iRegIorL2I isrc, vecX vsrc, iRegINoSp tmp)
+%{
+  predicate(n->in(2)->bottom_type()->is_vect()->element_basic_type() == T_BYTE);
+  match(Set dst (AndReductionV isrc vsrc));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst, TEMP tmp);
+  format %{ "umov   $tmp, $vsrc, D, 0\n\t"
+            "umov   $dst, $vsrc, D, 1\n\t"
+            "andr   $dst, $dst, $tmp\n\t"
+            "andr   $dst, $dst, $dst, LSR #32\n\t"
+            "andw   $dst, $dst, $dst, LSR #16\n\t"
+            "andw   $dst, $dst, $dst, LSR #8\n\t"
+            "andw   $dst, $isrc, $dst\n\t"
+            "sxtb   $dst, $dst\t# and reduction16B"
+  %}
+  ins_encode %{
+    __ umov($tmp$$Register, as_FloatRegister($vsrc$$reg), __ D, 0);
+    __ umov($dst$$Register, as_FloatRegister($vsrc$$reg), __ D, 1);
+    __ andr($dst$$Register, $dst$$Register, $tmp$$Register);
+    __ andr($dst$$Register, $dst$$Register, $dst$$Register, Assembler::LSR, 32);
+    __ andw($dst$$Register, $dst$$Register, $dst$$Register, Assembler::LSR, 16);
+    __ andw($dst$$Register, $dst$$Register, $dst$$Register, Assembler::LSR, 8);
+    __ andw($dst$$Register, $isrc$$Register, $dst$$Register);
+    __ sxtb($dst$$Register, $dst$$Register);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct reduce_orr16B(iRegINoSp dst, iRegIorL2I isrc, vecX vsrc, iRegINoSp tmp)
+%{
+  predicate(n->in(2)->bottom_type()->is_vect()->element_basic_type() == T_BYTE);
+  match(Set dst (OrReductionV isrc vsrc));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst, TEMP tmp);
+  format %{ "umov   $tmp, $vsrc, D, 0\n\t"
+            "umov   $dst, $vsrc, D, 1\n\t"
+            "orr    $dst, $dst, $tmp\n\t"
+            "orr    $dst, $dst, $dst, LSR #32\n\t"
+            "orrw   $dst, $dst, $dst, LSR #16\n\t"
+            "orrw   $dst, $dst, $dst, LSR #8\n\t"
+            "orrw   $dst, $isrc, $dst\n\t"
+            "sxtb   $dst, $dst\t# orr reduction16B"
+  %}
+  ins_encode %{
+    __ umov($tmp$$Register, as_FloatRegister($vsrc$$reg), __ D, 0);
+    __ umov($dst$$Register, as_FloatRegister($vsrc$$reg), __ D, 1);
+    __ orr ($dst$$Register, $dst$$Register, $tmp$$Register);
+    __ orr ($dst$$Register, $dst$$Register, $dst$$Register, Assembler::LSR, 32);
+    __ orrw($dst$$Register, $dst$$Register, $dst$$Register, Assembler::LSR, 16);
+    __ orrw($dst$$Register, $dst$$Register, $dst$$Register, Assembler::LSR, 8);
+    __ orrw($dst$$Register, $isrc$$Register, $dst$$Register);
+    __ sxtb($dst$$Register, $dst$$Register);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct reduce_eor16B(iRegINoSp dst, iRegIorL2I isrc, vecX vsrc, iRegINoSp tmp)
+%{
+  predicate(n->in(2)->bottom_type()->is_vect()->element_basic_type() == T_BYTE);
+  match(Set dst (XorReductionV isrc vsrc));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst, TEMP tmp);
+  format %{ "umov   $tmp, $vsrc, D, 0\n\t"
+            "umov   $dst, $vsrc, D, 1\n\t"
+            "eor    $dst, $dst, $tmp\n\t"
+            "eor    $dst, $dst, $dst, LSR #32\n\t"
+            "eorw   $dst, $dst, $dst, LSR #16\n\t"
+            "eorw   $dst, $dst, $dst, LSR #8\n\t"
+            "eorw   $dst, $isrc, $dst\n\t"
+            "sxtb   $dst, $dst\t# eor reduction16B"
+  %}
+  ins_encode %{
+    __ umov($tmp$$Register, as_FloatRegister($vsrc$$reg), __ D, 0);
+    __ umov($dst$$Register, as_FloatRegister($vsrc$$reg), __ D, 1);
+    __ eor ($dst$$Register, $dst$$Register, $tmp$$Register);
+    __ eor ($dst$$Register, $dst$$Register, $dst$$Register, Assembler::LSR, 32);
+    __ eorw($dst$$Register, $dst$$Register, $dst$$Register, Assembler::LSR, 16);
+    __ eorw($dst$$Register, $dst$$Register, $dst$$Register, Assembler::LSR, 8);
+    __ eorw($dst$$Register, $isrc$$Register, $dst$$Register);
+    __ sxtb($dst$$Register, $dst$$Register);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct reduce_and4S(iRegINoSp dst, iRegIorL2I isrc, vecD vsrc, iRegINoSp tmp)
+%{
+  predicate(n->in(2)->bottom_type()->is_vect()->element_basic_type() == T_SHORT);
+  match(Set dst (AndReductionV isrc vsrc));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst, TEMP tmp);
+  format %{ "umov   $tmp, $vsrc, S, 0\n\t"
+            "umov   $dst, $vsrc, S, 1\n\t"
+            "andw   $dst, $dst, $tmp\n\t"
+            "andw   $dst, $dst, $dst, LSR #16\n\t"
+            "andw   $dst, $isrc, $dst\n\t"
+            "sxth   $dst, $dst\t# and reduction4S"
+  %}
+  ins_encode %{
+    __ umov($tmp$$Register, as_FloatRegister($vsrc$$reg), __ S, 0);
+    __ umov($dst$$Register, as_FloatRegister($vsrc$$reg), __ S, 1);
+    __ andw($dst$$Register, $dst$$Register, $tmp$$Register);
+    __ andw($dst$$Register, $dst$$Register, $dst$$Register, Assembler::LSR, 16);
+    __ andw($dst$$Register, $isrc$$Register, $dst$$Register);
+    __ sxth($dst$$Register, $dst$$Register);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct reduce_orr4S(iRegINoSp dst, iRegIorL2I isrc, vecD vsrc, iRegINoSp tmp)
+%{
+  predicate(n->in(2)->bottom_type()->is_vect()->element_basic_type() == T_SHORT);
+  match(Set dst (OrReductionV isrc vsrc));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst, TEMP tmp);
+  format %{ "umov   $tmp, $vsrc, S, 0\n\t"
+            "umov   $dst, $vsrc, S, 1\n\t"
+            "orrw   $dst, $dst, $tmp\n\t"
+            "orrw   $dst, $dst, $dst, LSR #16\n\t"
+            "orrw   $dst, $isrc, $dst\n\t"
+            "sxth   $dst, $dst\t# orr reduction4S"
+  %}
+  ins_encode %{
+    __ umov($tmp$$Register, as_FloatRegister($vsrc$$reg), __ S, 0);
+    __ umov($dst$$Register, as_FloatRegister($vsrc$$reg), __ S, 1);
+    __ orrw($dst$$Register, $dst$$Register, $tmp$$Register);
+    __ orrw($dst$$Register, $dst$$Register, $dst$$Register, Assembler::LSR, 16);
+    __ orrw($dst$$Register, $isrc$$Register, $dst$$Register);
+    __ sxth($dst$$Register, $dst$$Register);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct reduce_eor4S(iRegINoSp dst, iRegIorL2I isrc, vecD vsrc, iRegINoSp tmp)
+%{
+  predicate(n->in(2)->bottom_type()->is_vect()->element_basic_type() == T_SHORT);
+  match(Set dst (XorReductionV isrc vsrc));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst, TEMP tmp);
+  format %{ "umov   $tmp, $vsrc, S, 0\n\t"
+            "umov   $dst, $vsrc, S, 1\n\t"
+            "eorw   $dst, $dst, $tmp\n\t"
+            "eorw   $dst, $dst, $dst, LSR #16\n\t"
+            "eorw   $dst, $isrc, $dst\n\t"
+            "sxth   $dst, $dst\t# eor reduction4S"
+  %}
+  ins_encode %{
+    __ umov($tmp$$Register, as_FloatRegister($vsrc$$reg), __ S, 0);
+    __ umov($dst$$Register, as_FloatRegister($vsrc$$reg), __ S, 1);
+    __ eorw($dst$$Register, $dst$$Register, $tmp$$Register);
+    __ eorw($dst$$Register, $dst$$Register, $dst$$Register, Assembler::LSR, 16);
+    __ eorw($dst$$Register, $isrc$$Register, $dst$$Register);
+    __ sxth($dst$$Register, $dst$$Register);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct reduce_and8S(iRegINoSp dst, iRegIorL2I isrc, vecX vsrc, iRegINoSp tmp)
+%{
+  predicate(n->in(2)->bottom_type()->is_vect()->element_basic_type() == T_SHORT);
+  match(Set dst (AndReductionV isrc vsrc));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst, TEMP tmp);
+  format %{ "umov   $tmp, $vsrc, D, 0\n\t"
+            "umov   $dst, $vsrc, D, 1\n\t"
+            "andr   $dst, $dst, $tmp\n\t"
+            "andr   $dst, $dst, $dst, LSR #32\n\t"
+            "andw   $dst, $dst, $dst, LSR #16\n\t"
+            "andw   $dst, $isrc, $dst\n\t"
+            "sxth   $dst, $dst\t# and reduction8S"
+  %}
+  ins_encode %{
+    __ umov($tmp$$Register, as_FloatRegister($vsrc$$reg), __ D, 0);
+    __ umov($dst$$Register, as_FloatRegister($vsrc$$reg), __ D, 1);
+    __ andr($dst$$Register, $dst$$Register, $tmp$$Register);
+    __ andr($dst$$Register, $dst$$Register, $dst$$Register, Assembler::LSR, 32);
+    __ andw($dst$$Register, $dst$$Register, $dst$$Register, Assembler::LSR, 16);
+    __ andw($dst$$Register, $isrc$$Register, $dst$$Register);
+    __ sxth($dst$$Register, $dst$$Register);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct reduce_orr8S(iRegINoSp dst, iRegIorL2I isrc, vecX vsrc, iRegINoSp tmp)
+%{
+  predicate(n->in(2)->bottom_type()->is_vect()->element_basic_type() == T_SHORT);
+  match(Set dst (OrReductionV isrc vsrc));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst, TEMP tmp);
+  format %{ "umov   $tmp, $vsrc, D, 0\n\t"
+            "umov   $dst, $vsrc, D, 1\n\t"
+            "orr    $dst, $dst, $tmp\n\t"
+            "orr    $dst, $dst, $dst, LSR #32\n\t"
+            "orrw   $dst, $dst, $dst, LSR #16\n\t"
+            "orrw   $dst, $isrc, $dst\n\t"
+            "sxth   $dst, $dst\t# orr reduction8S"
+  %}
+  ins_encode %{
+    __ umov($tmp$$Register, as_FloatRegister($vsrc$$reg), __ D, 0);
+    __ umov($dst$$Register, as_FloatRegister($vsrc$$reg), __ D, 1);
+    __ orr ($dst$$Register, $dst$$Register, $tmp$$Register);
+    __ orr ($dst$$Register, $dst$$Register, $dst$$Register, Assembler::LSR, 32);
+    __ orrw($dst$$Register, $dst$$Register, $dst$$Register, Assembler::LSR, 16);
+    __ orrw($dst$$Register, $isrc$$Register, $dst$$Register);
+    __ sxth($dst$$Register, $dst$$Register);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct reduce_eor8S(iRegINoSp dst, iRegIorL2I isrc, vecX vsrc, iRegINoSp tmp)
+%{
+  predicate(n->in(2)->bottom_type()->is_vect()->element_basic_type() == T_SHORT);
+  match(Set dst (XorReductionV isrc vsrc));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst, TEMP tmp);
+  format %{ "umov   $tmp, $vsrc, D, 0\n\t"
+            "umov   $dst, $vsrc, D, 1\n\t"
+            "eor    $dst, $dst, $tmp\n\t"
+            "eor    $dst, $dst, $dst, LSR #32\n\t"
+            "eorw   $dst, $dst, $dst, LSR #16\n\t"
+            "eorw   $dst, $isrc, $dst\n\t"
+            "sxth   $dst, $dst\t# eor reduction8S"
+  %}
+  ins_encode %{
+    __ umov($tmp$$Register, as_FloatRegister($vsrc$$reg), __ D, 0);
+    __ umov($dst$$Register, as_FloatRegister($vsrc$$reg), __ D, 1);
+    __ eor ($dst$$Register, $dst$$Register, $tmp$$Register);
+    __ eor ($dst$$Register, $dst$$Register, $dst$$Register, Assembler::LSR, 32);
+    __ eorw($dst$$Register, $dst$$Register, $dst$$Register, Assembler::LSR, 16);
+    __ eorw($dst$$Register, $isrc$$Register, $dst$$Register);
+    __ sxth($dst$$Register, $dst$$Register);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct reduce_and2I(iRegINoSp dst, iRegIorL2I isrc, vecD vsrc, iRegINoSp tmp)
+%{
+  predicate(n->in(2)->bottom_type()->is_vect()->element_basic_type() == T_INT);
+  match(Set dst (AndReductionV isrc vsrc));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst, TEMP tmp);
+  format %{ "umov  $tmp, $vsrc, S, 0\n\t"
+            "andw  $dst, $tmp, $isrc\n\t"
+            "umov  $tmp, $vsrc, S, 1\n\t"
+            "andw  $dst, $tmp, $dst\t# and reduction2I"
+  %}
+  ins_encode %{
+    __ umov($tmp$$Register, as_FloatRegister($vsrc$$reg), __ S, 0);
+    __ andw($dst$$Register, $tmp$$Register, $isrc$$Register);
+    __ umov($tmp$$Register, as_FloatRegister($vsrc$$reg), __ S, 1);
+    __ andw($dst$$Register, $tmp$$Register, $dst$$Register);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct reduce_orr2I(iRegINoSp dst, iRegIorL2I isrc, vecD vsrc, iRegINoSp tmp)
+%{
+  predicate(n->in(2)->bottom_type()->is_vect()->element_basic_type() == T_INT);
+  match(Set dst (OrReductionV isrc vsrc));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst, TEMP tmp);
+  format %{ "umov  $tmp, $vsrc, S, 0\n\t"
+            "orrw  $dst, $tmp, $isrc\n\t"
+            "umov  $tmp, $vsrc, S, 1\n\t"
+            "orrw  $dst, $tmp, $dst\t# orr reduction2I"
+  %}
+  ins_encode %{
+    __ umov($tmp$$Register, as_FloatRegister($vsrc$$reg), __ S, 0);
+    __ orrw($dst$$Register, $tmp$$Register, $isrc$$Register);
+    __ umov($tmp$$Register, as_FloatRegister($vsrc$$reg), __ S, 1);
+    __ orrw($dst$$Register, $tmp$$Register, $dst$$Register);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct reduce_eor2I(iRegINoSp dst, iRegIorL2I isrc, vecD vsrc, iRegINoSp tmp)
+%{
+  predicate(n->in(2)->bottom_type()->is_vect()->element_basic_type() == T_INT);
+  match(Set dst (XorReductionV isrc vsrc));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst, TEMP tmp);
+  format %{ "umov  $tmp, $vsrc, S, 0\n\t"
+            "eorw  $dst, $tmp, $isrc\n\t"
+            "umov  $tmp, $vsrc, S, 1\n\t"
+            "eorw  $dst, $tmp, $dst\t# eor reduction2I"
+  %}
+  ins_encode %{
+    __ umov($tmp$$Register, as_FloatRegister($vsrc$$reg), __ S, 0);
+    __ eorw($dst$$Register, $tmp$$Register, $isrc$$Register);
+    __ umov($tmp$$Register, as_FloatRegister($vsrc$$reg), __ S, 1);
+    __ eorw($dst$$Register, $tmp$$Register, $dst$$Register);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct reduce_and4I(iRegINoSp dst, iRegIorL2I isrc, vecX vsrc, iRegINoSp tmp)
+%{
+  predicate(n->in(2)->bottom_type()->is_vect()->element_basic_type() == T_INT);
+  match(Set dst (AndReductionV isrc vsrc));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst, TEMP tmp);
+  format %{ "umov   $tmp, $vsrc, D, 0\n\t"
+            "umov   $dst, $vsrc, D, 1\n\t"
+            "andr   $dst, $dst, $tmp\n\t"
+            "andr   $dst, $dst, $dst, LSR #32\n\t"
+            "andw   $dst, $isrc, $dst\t# and reduction4I"
+  %}
+  ins_encode %{
+    __ umov($tmp$$Register, as_FloatRegister($vsrc$$reg), __ D, 0);
+    __ umov($dst$$Register, as_FloatRegister($vsrc$$reg), __ D, 1);
+    __ andr($dst$$Register, $dst$$Register, $tmp$$Register);
+    __ andr($dst$$Register, $dst$$Register, $dst$$Register, Assembler::LSR, 32);
+    __ andw($dst$$Register, $isrc$$Register, $dst$$Register);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct reduce_orr4I(iRegINoSp dst, iRegIorL2I isrc, vecX vsrc, iRegINoSp tmp)
+%{
+  predicate(n->in(2)->bottom_type()->is_vect()->element_basic_type() == T_INT);
+  match(Set dst (OrReductionV isrc vsrc));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst, TEMP tmp);
+  format %{ "umov   $tmp, $vsrc, D, 0\n\t"
+            "umov   $dst, $vsrc, D, 1\n\t"
+            "orr    $dst, $dst, $tmp\n\t"
+            "orr    $dst, $dst, $dst, LSR #32\n\t"
+            "orrw   $dst, $isrc, $dst\t# orr reduction4I"
+  %}
+  ins_encode %{
+    __ umov($tmp$$Register, as_FloatRegister($vsrc$$reg), __ D, 0);
+    __ umov($dst$$Register, as_FloatRegister($vsrc$$reg), __ D, 1);
+    __ orr ($dst$$Register, $dst$$Register, $tmp$$Register);
+    __ orr ($dst$$Register, $dst$$Register, $dst$$Register, Assembler::LSR, 32);
+    __ orrw($dst$$Register, $isrc$$Register, $dst$$Register);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct reduce_eor4I(iRegINoSp dst, iRegIorL2I isrc, vecX vsrc, iRegINoSp tmp)
+%{
+  predicate(n->in(2)->bottom_type()->is_vect()->element_basic_type() == T_INT);
+  match(Set dst (XorReductionV isrc vsrc));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst, TEMP tmp);
+  format %{ "umov   $tmp, $vsrc, D, 0\n\t"
+            "umov   $dst, $vsrc, D, 1\n\t"
+            "eor    $dst, $dst, $tmp\n\t"
+            "eor    $dst, $dst, $dst, LSR #32\n\t"
+            "eorw   $dst, $isrc, $dst\t# eor reduction4I"
+  %}
+  ins_encode %{
+    __ umov($tmp$$Register, as_FloatRegister($vsrc$$reg), __ D, 0);
+    __ umov($dst$$Register, as_FloatRegister($vsrc$$reg), __ D, 1);
+    __ eor ($dst$$Register, $dst$$Register, $tmp$$Register);
+    __ eor ($dst$$Register, $dst$$Register, $dst$$Register, Assembler::LSR, 32);
+    __ eorw($dst$$Register, $isrc$$Register, $dst$$Register);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct reduce_and2L(iRegLNoSp dst, iRegL isrc, vecX vsrc, iRegLNoSp tmp)
+%{
+  predicate(n->in(2)->bottom_type()->is_vect()->element_basic_type() == T_LONG);
+  match(Set dst (AndReductionV isrc vsrc));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst, TEMP tmp);
+  format %{ "umov  $tmp, $vsrc, D, 0\n\t"
+            "andr  $dst, $isrc, $tmp\n\t"
+            "umov  $tmp, $vsrc, D, 1\n\t"
+            "andr  $dst, $dst, $tmp\t# and reduction2L"
+  %}
+  ins_encode %{
+    __ umov($tmp$$Register, as_FloatRegister($vsrc$$reg), __ D, 0);
+    __ andr($dst$$Register, $isrc$$Register, $tmp$$Register);
+    __ umov($tmp$$Register, as_FloatRegister($vsrc$$reg), __ D, 1);
+    __ andr($dst$$Register, $dst$$Register, $tmp$$Register);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct reduce_orr2L(iRegLNoSp dst, iRegL isrc, vecX vsrc, iRegLNoSp tmp)
+%{
+  predicate(n->in(2)->bottom_type()->is_vect()->element_basic_type() == T_LONG);
+  match(Set dst (OrReductionV isrc vsrc));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst, TEMP tmp);
+  format %{ "umov  $tmp, $vsrc, D, 0\n\t"
+            "orr   $dst, $isrc, $tmp\n\t"
+            "umov  $tmp, $vsrc, D, 1\n\t"
+            "orr   $dst, $dst, $tmp\t# orr reduction2L"
+  %}
+  ins_encode %{
+    __ umov($tmp$$Register, as_FloatRegister($vsrc$$reg), __ D, 0);
+    __ orr ($dst$$Register, $isrc$$Register, $tmp$$Register);
+    __ umov($tmp$$Register, as_FloatRegister($vsrc$$reg), __ D, 1);
+    __ orr ($dst$$Register, $dst$$Register, $tmp$$Register);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct reduce_eor2L(iRegLNoSp dst, iRegL isrc, vecX vsrc, iRegLNoSp tmp)
+%{
+  predicate(n->in(2)->bottom_type()->is_vect()->element_basic_type() == T_LONG);
+  match(Set dst (XorReductionV isrc vsrc));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst, TEMP tmp);
+  format %{ "umov  $tmp, $vsrc, D, 0\n\t"
+            "eor   $dst, $isrc, $tmp\n\t"
+            "umov  $tmp, $vsrc, D, 1\n\t"
+            "eor   $dst, $dst, $tmp\t# eor reduction2L"
+  %}
+  ins_encode %{
+    __ umov($tmp$$Register, as_FloatRegister($vsrc$$reg), __ D, 0);
+    __ eor ($dst$$Register, $isrc$$Register, $tmp$$Register);
+    __ umov($tmp$$Register, as_FloatRegister($vsrc$$reg), __ D, 1);
+    __ eor ($dst$$Register, $dst$$Register, $tmp$$Register);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+// ------------------------------ Vector insert ---------------------------------
+
+instruct insert8B(vecD dst, vecD src, iRegIorL2I val, immI idx)
+%{
+  predicate(n->bottom_type()->is_vect()->element_basic_type() == T_BYTE);
+  match(Set dst (VectorInsert (Binary src val) idx));
+  ins_cost(INSN_COST);
+  format %{ "orr    $dst, T8B, $src, $src\n\t"
+            "mov    $dst, T8B, $idx, $val\t# insert into vector(8B)" %}
+  ins_encode %{
+    if (as_FloatRegister($dst$$reg) != as_FloatRegister($src$$reg)) {
+      __ orr(as_FloatRegister($dst$$reg), __ T8B,
+             as_FloatRegister($src$$reg), as_FloatRegister($src$$reg));
+    }
+    __ mov(as_FloatRegister($dst$$reg), __ T8B, $idx$$constant, $val$$Register);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct insert16B(vecX dst, vecX src, iRegIorL2I val, immI idx)
+%{
+  predicate(n->bottom_type()->is_vect()->element_basic_type() == T_BYTE);
+  match(Set dst (VectorInsert (Binary src val) idx));
+  ins_cost(INSN_COST);
+  format %{ "orr    $dst, T16B, $src, $src\n\t"
+            "mov    $dst, T16B, $idx, $val\t# insert into vector(16B)" %}
+  ins_encode %{
+    if (as_FloatRegister($dst$$reg) != as_FloatRegister($src$$reg)) {
+      __ orr(as_FloatRegister($dst$$reg), __ T16B,
+             as_FloatRegister($src$$reg), as_FloatRegister($src$$reg));
+    }
+    __ mov(as_FloatRegister($dst$$reg), __ T16B, $idx$$constant, $val$$Register);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct insert4S(vecD dst, vecD src, iRegIorL2I val, immI idx)
+%{
+  predicate(n->bottom_type()->is_vect()->element_basic_type() == T_SHORT);
+  match(Set dst (VectorInsert (Binary src val) idx));
+  ins_cost(INSN_COST);
+  format %{ "orr    $dst, T8B, $src, $src\n\t"
+            "mov    $dst, T4H, $idx, $val\t# insert into vector(4S)" %}
+  ins_encode %{
+    if (as_FloatRegister($dst$$reg) != as_FloatRegister($src$$reg)) {
+      __ orr(as_FloatRegister($dst$$reg), __ T8B,
+             as_FloatRegister($src$$reg), as_FloatRegister($src$$reg));
+    }
+    __ mov(as_FloatRegister($dst$$reg), __ T4H, $idx$$constant, $val$$Register);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct insert8S(vecX dst, vecX src, iRegIorL2I val, immI idx)
+%{
+  predicate(n->bottom_type()->is_vect()->element_basic_type() == T_SHORT);
+  match(Set dst (VectorInsert (Binary src val) idx));
+  ins_cost(INSN_COST);
+  format %{ "orr    $dst, T16B, $src, $src\n\t"
+            "mov    $dst, T8H, $idx, $val\t# insert into vector(8S)" %}
+  ins_encode %{
+    if (as_FloatRegister($dst$$reg) != as_FloatRegister($src$$reg)) {
+      __ orr(as_FloatRegister($dst$$reg), __ T16B,
+             as_FloatRegister($src$$reg), as_FloatRegister($src$$reg));
+    }
+    __ mov(as_FloatRegister($dst$$reg), __ T8H, $idx$$constant, $val$$Register);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct insert2I(vecD dst, vecD src, iRegIorL2I val, immI idx)
+%{
+  predicate(n->bottom_type()->is_vect()->element_basic_type() == T_INT);
+  match(Set dst (VectorInsert (Binary src val) idx));
+  ins_cost(INSN_COST);
+  format %{ "orr    $dst, T8B, $src, $src\n\t"
+            "mov    $dst, T2S, $idx, $val\t# insert into vector(2I)" %}
+  ins_encode %{
+    if (as_FloatRegister($dst$$reg) != as_FloatRegister($src$$reg)) {
+      __ orr(as_FloatRegister($dst$$reg), __ T8B,
+             as_FloatRegister($src$$reg), as_FloatRegister($src$$reg));
+    }
+    __ mov(as_FloatRegister($dst$$reg), __ T2S, $idx$$constant, $val$$Register);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct insert4I(vecX dst, vecX src, iRegIorL2I val, immI idx)
+%{
+  predicate(n->bottom_type()->is_vect()->element_basic_type() == T_INT);
+  match(Set dst (VectorInsert (Binary src val) idx));
+  ins_cost(INSN_COST);
+  format %{ "orr    $dst, T16B, $src, $src\n\t"
+            "mov    $dst, T4S, $idx, $val\t# insert into vector(4I)" %}
+  ins_encode %{
+    if (as_FloatRegister($dst$$reg) != as_FloatRegister($src$$reg)) {
+      __ orr(as_FloatRegister($dst$$reg), __ T16B,
+             as_FloatRegister($src$$reg), as_FloatRegister($src$$reg));
+    }
+    __ mov(as_FloatRegister($dst$$reg), __ T4S, $idx$$constant, $val$$Register);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct insert2L(vecX dst, vecX src, iRegL val, immI idx)
+%{
+  predicate(n->bottom_type()->is_vect()->element_basic_type() == T_LONG);
+  match(Set dst (VectorInsert (Binary src val) idx));
+  ins_cost(INSN_COST);
+  format %{ "orr    $dst, T16B, $src, $src\n\t"
+            "mov    $dst, T2D, $idx, $val\t# insert into vector(2L)" %}
+  ins_encode %{
+    if (as_FloatRegister($dst$$reg) != as_FloatRegister($src$$reg)) {
+      __ orr(as_FloatRegister($dst$$reg), __ T16B,
+             as_FloatRegister($src$$reg), as_FloatRegister($src$$reg));
+    }
+    __ mov(as_FloatRegister($dst$$reg), __ T2D, $idx$$constant, $val$$Register);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct insert2F(vecD dst, vecD src, vRegF val, immI idx)
+%{
+  predicate(n->bottom_type()->is_vect()->element_basic_type() == T_FLOAT);
+  match(Set dst (VectorInsert (Binary src val) idx));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst);
+  format %{ "orr    $dst, T8B, $src, $src\n\t"
+            "ins    $dst, S, $val, $idx, 0\t# insert into vector(2F)" %}
+  ins_encode %{
+    __ orr(as_FloatRegister($dst$$reg), __ T8B,
+           as_FloatRegister($src$$reg), as_FloatRegister($src$$reg));
+    __ ins(as_FloatRegister($dst$$reg), __ S,
+           as_FloatRegister($val$$reg), $idx$$constant, 0);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct insert4F(vecX dst, vecX src, vRegF val, immI idx)
+%{
+  predicate(n->bottom_type()->is_vect()->element_basic_type() == T_FLOAT);
+  match(Set dst (VectorInsert (Binary src val) idx));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst);
+  format %{ "orr    $dst, T16B, $src, $src\n\t"
+            "ins    $dst, S, $val, $idx, 0\t# insert into vector(4F)" %}
+  ins_encode %{
+    __ orr(as_FloatRegister($dst$$reg), __ T16B,
+           as_FloatRegister($src$$reg), as_FloatRegister($src$$reg));
+    __ ins(as_FloatRegister($dst$$reg), __ S,
+           as_FloatRegister($val$$reg), $idx$$constant, 0);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct insert2D(vecX dst, vecX src, vRegD val, immI idx)
+%{
+  predicate(n->bottom_type()->is_vect()->element_basic_type() == T_DOUBLE);
+  match(Set dst (VectorInsert (Binary src val) idx));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst);
+  format %{ "orr    $dst, T16B, $src, $src\n\t"
+            "ins    $dst, D, $val, $idx, 0\t# insert into vector(2D)" %}
+  ins_encode %{
+    __ orr(as_FloatRegister($dst$$reg), __ T16B,
+           as_FloatRegister($src$$reg), as_FloatRegister($src$$reg));
+    __ ins(as_FloatRegister($dst$$reg), __ D,
+           as_FloatRegister($val$$reg), $idx$$constant, 0);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+// ------------------------------ Vector extract ---------------------------------
+
+instruct extract8B(iRegINoSp dst, vecD src, immI idx)
+%{
+  predicate(n->in(1)->bottom_type()->is_vect()->length() == 8);
+  match(Set dst (ExtractB src idx));
+  ins_cost(INSN_COST);
+  format %{ "smov    $dst, $src, B, $idx\t# extract from vector(8B)" %}
+  ins_encode %{
+    __ smov($dst$$Register, as_FloatRegister($src$$reg), __ B, $idx$$constant);
+  %}
+  ins_pipe(pipe_class_default);
+%}
+
+instruct extract16B(iRegINoSp dst, vecX src, immI idx)
+%{
+  predicate(n->in(1)->bottom_type()->is_vect()->length() == 16);
+  match(Set dst (ExtractB src idx));
+  ins_cost(INSN_COST);
+  format %{ "smov    $dst, $src, B, $idx\t# extract from vector(16B)" %}
+  ins_encode %{
+    __ smov($dst$$Register, as_FloatRegister($src$$reg), __ B, $idx$$constant);
+  %}
+  ins_pipe(pipe_class_default);
+%}
+
+instruct extract4S(iRegINoSp dst, vecD src, immI idx)
+%{
+  predicate(n->in(1)->bottom_type()->is_vect()->length() == 4);
+  match(Set dst (ExtractS src idx));
+  ins_cost(INSN_COST);
+  format %{ "smov    $dst, $src, H, $idx\t# extract from vector(4S)" %}
+  ins_encode %{
+    __ smov($dst$$Register, as_FloatRegister($src$$reg), __ H, $idx$$constant);
+  %}
+  ins_pipe(pipe_class_default);
+%}
+
+instruct extract8S(iRegINoSp dst, vecX src, immI idx)
+%{
+  predicate(n->in(1)->bottom_type()->is_vect()->length() == 8);
+  match(Set dst (ExtractS src idx));
+  ins_cost(INSN_COST);
+  format %{ "smov    $dst, $src, H, $idx\t# extract from vector(8S)" %}
+  ins_encode %{
+    __ smov($dst$$Register, as_FloatRegister($src$$reg), __ H, $idx$$constant);
+  %}
+  ins_pipe(pipe_class_default);
+%}
+
+instruct extract2I(iRegINoSp dst, vecD src, immI idx)
+%{
+  predicate(n->in(1)->bottom_type()->is_vect()->length() == 2);
+  match(Set dst (ExtractI src idx));
+  ins_cost(INSN_COST);
+  format %{ "umov    $dst, $src, S, $idx\t# extract from vector(2I)" %}
+  ins_encode %{
+    __ umov($dst$$Register, as_FloatRegister($src$$reg), __ S, $idx$$constant);
+  %}
+  ins_pipe(pipe_class_default);
+%}
+
+instruct extract4I(iRegINoSp dst, vecX src, immI idx)
+%{
+  predicate(n->in(1)->bottom_type()->is_vect()->length() == 4);
+  match(Set dst (ExtractI src idx));
+  ins_cost(INSN_COST);
+  format %{ "umov    $dst, $src, S, $idx\t# extract from vector(4I)" %}
+  ins_encode %{
+    __ umov($dst$$Register, as_FloatRegister($src$$reg), __ S, $idx$$constant);
+  %}
+  ins_pipe(pipe_class_default);
+%}
+
+instruct extract2L(iRegLNoSp dst, vecX src, immI idx)
+%{
+  predicate(n->in(1)->bottom_type()->is_vect()->length() == 2);
+  match(Set dst (ExtractL src idx));
+  ins_cost(INSN_COST);
+  format %{ "umov    $dst, $src, D, $idx\t# extract from vector(2L)" %}
+  ins_encode %{
+    __ umov($dst$$Register, as_FloatRegister($src$$reg), __ D, $idx$$constant);
+  %}
+  ins_pipe(pipe_class_default);
+%}
+
+instruct extract2F(vRegF dst, vecD src, immI idx)
+%{
+  predicate(n->in(1)->bottom_type()->is_vect()->length() == 2);
+  match(Set dst (ExtractF src idx));
+  ins_cost(INSN_COST);
+  format %{ "ins   $dst, S, $src, 0, $idx\t# extract from vector(2F)" %}
+  ins_encode %{
+    __ ins(as_FloatRegister($dst$$reg), __ S,
+           as_FloatRegister($src$$reg), 0, $idx$$constant);
+  %}
+  ins_pipe(pipe_class_default);
+%}
+
+instruct extract4F(vRegF dst, vecX src, immI idx)
+%{
+  predicate(n->in(1)->bottom_type()->is_vect()->length() == 4);
+  match(Set dst (ExtractF src idx));
+  ins_cost(INSN_COST);
+  format %{ "ins   $dst, S, $src, 0, $idx\t# extract from vector(4F)" %}
+  ins_encode %{
+    __ ins(as_FloatRegister($dst$$reg), __ S,
+           as_FloatRegister($src$$reg), 0, $idx$$constant);
+  %}
+  ins_pipe(pipe_class_default);
+%}
+
+instruct extract2D(vRegD dst, vecX src, immI idx)
+%{
+  predicate(n->in(1)->bottom_type()->is_vect()->length() == 2);
+  match(Set dst (ExtractD src idx));
+  ins_cost(INSN_COST);
+  format %{ "ins   $dst, D, $src, 0, $idx\t# extract from vector(2D)" %}
+  ins_encode %{
+    __ ins(as_FloatRegister($dst$$reg), __ D,
+           as_FloatRegister($src$$reg), 0, $idx$$constant);
+  %}
+  ins_pipe(pipe_class_default);
+%}
+
+// ------------------------------ Vector comparison ---------------------------------
+
+instruct vcmeq8B(vecD dst, vecD src1, vecD src2, immI cond)
+%{
+  predicate(n->as_Vector()->length() == 8 &&
+            n->as_VectorMaskCmp()->get_predicate() == BoolTest::eq &&
+            n->in(1)->in(1)->bottom_type()->is_vect()->element_basic_type() == T_BYTE);
+  match(Set dst (VectorMaskCmp (Binary src1 src2) cond));
+  format %{ "cmeq  $dst, $src1, $src2\t# vector cmp (8B)" %}
+  ins_cost(INSN_COST);
+  ins_encode %{
+    __ cmeq(as_FloatRegister($dst$$reg), __ T8B,
+            as_FloatRegister($src1$$reg), as_FloatRegister($src2$$reg));
+  %}
+  ins_pipe(vdop64);
+%}
+
+instruct vcmeq16B(vecX dst, vecX src1, vecX src2, immI cond)
+%{
+  predicate(n->as_Vector()->length() == 16 &&
+            n->as_VectorMaskCmp()->get_predicate() == BoolTest::eq &&
+            n->in(1)->in(1)->bottom_type()->is_vect()->element_basic_type() == T_BYTE);
+  match(Set dst (VectorMaskCmp (Binary src1 src2) cond));
+  format %{ "cmeq  $dst, $src1, $src2\t# vector cmp (16B)" %}
+  ins_cost(INSN_COST);
+  ins_encode %{
+    __ cmeq(as_FloatRegister($dst$$reg), __ T16B,
+            as_FloatRegister($src1$$reg), as_FloatRegister($src2$$reg));
+  %}
+  ins_pipe(vdop128);
+%}
+
+instruct vcmeq4S(vecD dst, vecD src1, vecD src2, immI cond)
+%{
+  predicate(n->as_Vector()->length() == 4 &&
+            n->as_VectorMaskCmp()->get_predicate() == BoolTest::eq &&
+            n->in(1)->in(1)->bottom_type()->is_vect()->element_basic_type() == T_SHORT);
+  match(Set dst (VectorMaskCmp (Binary src1 src2) cond));
+  format %{ "cmeq  $dst, $src1, $src2\t# vector cmp (4S)" %}
+  ins_cost(INSN_COST);
+  ins_encode %{
+    __ cmeq(as_FloatRegister($dst$$reg), __ T4H,
+            as_FloatRegister($src1$$reg), as_FloatRegister($src2$$reg));
+  %}
+  ins_pipe(vdop64);
+%}
+
+instruct vcmeq8S(vecX dst, vecX src1, vecX src2, immI cond)
+%{
+  predicate(n->as_Vector()->length() == 8 &&
+            n->as_VectorMaskCmp()->get_predicate() == BoolTest::eq &&
+            n->in(1)->in(1)->bottom_type()->is_vect()->element_basic_type() == T_SHORT);
+  match(Set dst (VectorMaskCmp (Binary src1 src2) cond));
+  format %{ "cmeq  $dst, $src1, $src2\t# vector cmp (8S)" %}
+  ins_cost(INSN_COST);
+  ins_encode %{
+    __ cmeq(as_FloatRegister($dst$$reg), __ T8H,
+            as_FloatRegister($src1$$reg), as_FloatRegister($src2$$reg));
+  %}
+  ins_pipe(vdop128);
+%}
+
+instruct vcmeq2I(vecD dst, vecD src1, vecD src2, immI cond)
+%{
+  predicate(n->as_Vector()->length() == 2 &&
+            n->as_VectorMaskCmp()->get_predicate() == BoolTest::eq &&
+            n->in(1)->in(1)->bottom_type()->is_vect()->element_basic_type() == T_INT);
+  match(Set dst (VectorMaskCmp (Binary src1 src2) cond));
+  format %{ "cmeq  $dst, $src1, $src2\t# vector cmp (2I)" %}
+  ins_cost(INSN_COST);
+  ins_encode %{
+    __ cmeq(as_FloatRegister($dst$$reg), __ T2S,
+            as_FloatRegister($src1$$reg), as_FloatRegister($src2$$reg));
+  %}
+  ins_pipe(vdop64);
+%}
+
+instruct vcmeq4I(vecX dst, vecX src1, vecX src2, immI cond)
+%{
+  predicate(n->as_Vector()->length() == 4 &&
+            n->as_VectorMaskCmp()->get_predicate() == BoolTest::eq &&
+            n->in(1)->in(1)->bottom_type()->is_vect()->element_basic_type() == T_INT);
+  match(Set dst (VectorMaskCmp (Binary src1 src2) cond));
+  format %{ "cmeq  $dst, $src1, $src2\t# vector cmp (4I)" %}
+  ins_cost(INSN_COST);
+  ins_encode %{
+    __ cmeq(as_FloatRegister($dst$$reg), __ T4S,
+            as_FloatRegister($src1$$reg), as_FloatRegister($src2$$reg));
+  %}
+  ins_pipe(vdop128);
+%}
+
+instruct vcmeq2L(vecX dst, vecX src1, vecX src2, immI cond)
+%{
+  predicate(n->as_Vector()->length() == 2 &&
+            n->as_VectorMaskCmp()->get_predicate() == BoolTest::eq &&
+            n->in(1)->in(1)->bottom_type()->is_vect()->element_basic_type() == T_LONG);
+  match(Set dst (VectorMaskCmp (Binary src1 src2) cond));
+  format %{ "cmeq  $dst, $src1, $src2\t# vector cmp (2L)" %}
+  ins_cost(INSN_COST);
+  ins_encode %{
+    __ cmeq(as_FloatRegister($dst$$reg), __ T2D,
+            as_FloatRegister($src1$$reg), as_FloatRegister($src2$$reg));
+  %}
+  ins_pipe(vdop128);
+%}
+
+instruct vcmeq2F(vecD dst, vecD src1, vecD src2, immI cond)
+%{
+  predicate(n->as_Vector()->length() == 2 &&
+            n->as_VectorMaskCmp()->get_predicate() == BoolTest::eq &&
+            n->in(1)->in(1)->bottom_type()->is_vect()->element_basic_type() == T_FLOAT);
+  match(Set dst (VectorMaskCmp (Binary src1 src2) cond));
+  format %{ "fcmeq  $dst, $src1, $src2\t# vector cmp (2F)" %}
+  ins_cost(INSN_COST);
+  ins_encode %{
+    __ fcmeq(as_FloatRegister($dst$$reg), __ T2S,
+            as_FloatRegister($src1$$reg), as_FloatRegister($src2$$reg));
+  %}
+  ins_pipe(vdop64);
+%}
+
+instruct vcmeq4F(vecX dst, vecX src1, vecX src2, immI cond)
+%{
+  predicate(n->as_Vector()->length() == 4 &&
+            n->as_VectorMaskCmp()->get_predicate() == BoolTest::eq &&
+            n->in(1)->in(1)->bottom_type()->is_vect()->element_basic_type() == T_FLOAT);
+  match(Set dst (VectorMaskCmp (Binary src1 src2) cond));
+  format %{ "fcmeq  $dst, $src1, $src2\t# vector cmp (4F)" %}
+  ins_cost(INSN_COST);
+  ins_encode %{
+    __ fcmeq(as_FloatRegister($dst$$reg), __ T4S,
+            as_FloatRegister($src1$$reg), as_FloatRegister($src2$$reg));
+  %}
+  ins_pipe(vdop128);
+%}
+
+instruct vcmeq2D(vecX dst, vecX src1, vecX src2, immI cond)
+%{
+  predicate(n->as_Vector()->length() == 2 &&
+            n->as_VectorMaskCmp()->get_predicate() == BoolTest::eq &&
+            n->in(1)->in(1)->bottom_type()->is_vect()->element_basic_type() == T_DOUBLE);
+  match(Set dst (VectorMaskCmp (Binary src1 src2) cond));
+  format %{ "fcmeq  $dst, $src1, $src2\t# vector cmp (2D)" %}
+  ins_cost(INSN_COST);
+  ins_encode %{
+    __ fcmeq(as_FloatRegister($dst$$reg), __ T2D,
+            as_FloatRegister($src1$$reg), as_FloatRegister($src2$$reg));
+  %}
+  ins_pipe(vdop128);
+%}
+
+instruct vcmgt8B(vecD dst, vecD src1, vecD src2, immI cond)
+%{
+  predicate(n->as_Vector()->length() == 8 &&
+            n->as_VectorMaskCmp()->get_predicate() == BoolTest::gt &&
+            n->in(1)->in(1)->bottom_type()->is_vect()->element_basic_type() == T_BYTE);
+  match(Set dst (VectorMaskCmp (Binary src1 src2) cond));
+  format %{ "cmgt  $dst, $src1, $src2\t# vector cmp (8B)" %}
+  ins_cost(INSN_COST);
+  ins_encode %{
+    __ cmgt(as_FloatRegister($dst$$reg), __ T8B,
+            as_FloatRegister($src1$$reg), as_FloatRegister($src2$$reg));
+  %}
+  ins_pipe(vdop64);
+%}
+
+instruct vcmgt16B(vecX dst, vecX src1, vecX src2, immI cond)
+%{
+  predicate(n->as_Vector()->length() == 16 &&
+            n->as_VectorMaskCmp()->get_predicate() == BoolTest::gt &&
+            n->in(1)->in(1)->bottom_type()->is_vect()->element_basic_type() == T_BYTE);
+  match(Set dst (VectorMaskCmp (Binary src1 src2) cond));
+  format %{ "cmgt  $dst, $src1, $src2\t# vector cmp (16B)" %}
+  ins_cost(INSN_COST);
+  ins_encode %{
+    __ cmgt(as_FloatRegister($dst$$reg), __ T16B,
+            as_FloatRegister($src1$$reg), as_FloatRegister($src2$$reg));
+  %}
+  ins_pipe(vdop128);
+%}
+
+instruct vcmgt4S(vecD dst, vecD src1, vecD src2, immI cond)
+%{
+  predicate(n->as_Vector()->length() == 4 &&
+            n->as_VectorMaskCmp()->get_predicate() == BoolTest::gt &&
+            n->in(1)->in(1)->bottom_type()->is_vect()->element_basic_type() == T_SHORT);
+  match(Set dst (VectorMaskCmp (Binary src1 src2) cond));
+  format %{ "cmgt  $dst, $src1, $src2\t# vector cmp (4S)" %}
+  ins_cost(INSN_COST);
+  ins_encode %{
+    __ cmgt(as_FloatRegister($dst$$reg), __ T4H,
+            as_FloatRegister($src1$$reg), as_FloatRegister($src2$$reg));
+  %}
+  ins_pipe(vdop64);
+%}
+
+instruct vcmgt8S(vecX dst, vecX src1, vecX src2, immI cond)
+%{
+  predicate(n->as_Vector()->length() == 8 &&
+            n->as_VectorMaskCmp()->get_predicate() == BoolTest::gt &&
+            n->in(1)->in(1)->bottom_type()->is_vect()->element_basic_type() == T_SHORT);
+  match(Set dst (VectorMaskCmp (Binary src1 src2) cond));
+  format %{ "cmgt  $dst, $src1, $src2\t# vector cmp (8S)" %}
+  ins_cost(INSN_COST);
+  ins_encode %{
+    __ cmgt(as_FloatRegister($dst$$reg), __ T8H,
+            as_FloatRegister($src1$$reg), as_FloatRegister($src2$$reg));
+  %}
+  ins_pipe(vdop128);
+%}
+
+instruct vcmgt2I(vecD dst, vecD src1, vecD src2, immI cond)
+%{
+  predicate(n->as_Vector()->length() == 2 &&
+            n->as_VectorMaskCmp()->get_predicate() == BoolTest::gt &&
+            n->in(1)->in(1)->bottom_type()->is_vect()->element_basic_type() == T_INT);
+  match(Set dst (VectorMaskCmp (Binary src1 src2) cond));
+  format %{ "cmgt  $dst, $src1, $src2\t# vector cmp (2I)" %}
+  ins_cost(INSN_COST);
+  ins_encode %{
+    __ cmgt(as_FloatRegister($dst$$reg), __ T2S,
+            as_FloatRegister($src1$$reg), as_FloatRegister($src2$$reg));
+  %}
+  ins_pipe(vdop64);
+%}
+
+instruct vcmgt4I(vecX dst, vecX src1, vecX src2, immI cond)
+%{
+  predicate(n->as_Vector()->length() == 4 &&
+            n->as_VectorMaskCmp()->get_predicate() == BoolTest::gt &&
+            n->in(1)->in(1)->bottom_type()->is_vect()->element_basic_type() == T_INT);
+  match(Set dst (VectorMaskCmp (Binary src1 src2) cond));
+  format %{ "cmgt  $dst, $src1, $src2\t# vector cmp (4I)" %}
+  ins_cost(INSN_COST);
+  ins_encode %{
+    __ cmgt(as_FloatRegister($dst$$reg), __ T4S,
+            as_FloatRegister($src1$$reg), as_FloatRegister($src2$$reg));
+  %}
+  ins_pipe(vdop128);
+%}
+
+instruct vcmgt2L(vecX dst, vecX src1, vecX src2, immI cond)
+%{
+  predicate(n->as_Vector()->length() == 2 &&
+            n->as_VectorMaskCmp()->get_predicate() == BoolTest::gt &&
+            n->in(1)->in(1)->bottom_type()->is_vect()->element_basic_type() == T_LONG);
+  match(Set dst (VectorMaskCmp (Binary src1 src2) cond));
+  format %{ "cmgt  $dst, $src1, $src2\t# vector cmp (2L)" %}
+  ins_cost(INSN_COST);
+  ins_encode %{
+    __ cmgt(as_FloatRegister($dst$$reg), __ T2D,
+            as_FloatRegister($src1$$reg), as_FloatRegister($src2$$reg));
+  %}
+  ins_pipe(vdop128);
+%}
+
+instruct vcmgt2F(vecD dst, vecD src1, vecD src2, immI cond)
+%{
+  predicate(n->as_Vector()->length() == 2 &&
+            n->as_VectorMaskCmp()->get_predicate() == BoolTest::gt &&
+            n->in(1)->in(1)->bottom_type()->is_vect()->element_basic_type() == T_FLOAT);
+  match(Set dst (VectorMaskCmp (Binary src1 src2) cond));
+  format %{ "fcmgt  $dst, $src1, $src2\t# vector cmp (2F)" %}
+  ins_cost(INSN_COST);
+  ins_encode %{
+    __ fcmgt(as_FloatRegister($dst$$reg), __ T2S,
+            as_FloatRegister($src1$$reg), as_FloatRegister($src2$$reg));
+  %}
+  ins_pipe(vdop64);
+%}
+
+instruct vcmgt4F(vecX dst, vecX src1, vecX src2, immI cond)
+%{
+  predicate(n->as_Vector()->length() == 4 &&
+            n->as_VectorMaskCmp()->get_predicate() == BoolTest::gt &&
+            n->in(1)->in(1)->bottom_type()->is_vect()->element_basic_type() == T_FLOAT);
+  match(Set dst (VectorMaskCmp (Binary src1 src2) cond));
+  format %{ "fcmgt  $dst, $src1, $src2\t# vector cmp (4F)" %}
+  ins_cost(INSN_COST);
+  ins_encode %{
+    __ fcmgt(as_FloatRegister($dst$$reg), __ T4S,
+            as_FloatRegister($src1$$reg), as_FloatRegister($src2$$reg));
+  %}
+  ins_pipe(vdop128);
+%}
+
+instruct vcmgt2D(vecX dst, vecX src1, vecX src2, immI cond)
+%{
+  predicate(n->as_Vector()->length() == 2 &&
+            n->as_VectorMaskCmp()->get_predicate() == BoolTest::gt &&
+            n->in(1)->in(1)->bottom_type()->is_vect()->element_basic_type() == T_DOUBLE);
+  match(Set dst (VectorMaskCmp (Binary src1 src2) cond));
+  format %{ "fcmgt  $dst, $src1, $src2\t# vector cmp (2D)" %}
+  ins_cost(INSN_COST);
+  ins_encode %{
+    __ fcmgt(as_FloatRegister($dst$$reg), __ T2D,
+            as_FloatRegister($src1$$reg), as_FloatRegister($src2$$reg));
+  %}
+  ins_pipe(vdop128);
+%}
+
+instruct vcmge8B(vecD dst, vecD src1, vecD src2, immI cond)
+%{
+  predicate(n->as_Vector()->length() == 8 &&
+            n->as_VectorMaskCmp()->get_predicate() == BoolTest::ge &&
+            n->in(1)->in(1)->bottom_type()->is_vect()->element_basic_type() == T_BYTE);
+  match(Set dst (VectorMaskCmp (Binary src1 src2) cond));
+  format %{ "cmge  $dst, $src1, $src2\t# vector cmp (8B)" %}
+  ins_cost(INSN_COST);
+  ins_encode %{
+    __ cmge(as_FloatRegister($dst$$reg), __ T8B,
+            as_FloatRegister($src1$$reg), as_FloatRegister($src2$$reg));
+  %}
+  ins_pipe(vdop64);
+%}
+
+instruct vcmge16B(vecX dst, vecX src1, vecX src2, immI cond)
+%{
+  predicate(n->as_Vector()->length() == 16 &&
+            n->as_VectorMaskCmp()->get_predicate() == BoolTest::ge &&
+            n->in(1)->in(1)->bottom_type()->is_vect()->element_basic_type() == T_BYTE);
+  match(Set dst (VectorMaskCmp (Binary src1 src2) cond));
+  format %{ "cmge  $dst, $src1, $src2\t# vector cmp (16B)" %}
+  ins_cost(INSN_COST);
+  ins_encode %{
+    __ cmge(as_FloatRegister($dst$$reg), __ T16B,
+            as_FloatRegister($src1$$reg), as_FloatRegister($src2$$reg));
+  %}
+  ins_pipe(vdop128);
+%}
+
+instruct vcmge4S(vecD dst, vecD src1, vecD src2, immI cond)
+%{
+  predicate(n->as_Vector()->length() == 4 &&
+            n->as_VectorMaskCmp()->get_predicate() == BoolTest::ge &&
+            n->in(1)->in(1)->bottom_type()->is_vect()->element_basic_type() == T_SHORT);
+  match(Set dst (VectorMaskCmp (Binary src1 src2) cond));
+  format %{ "cmge  $dst, $src1, $src2\t# vector cmp (4S)" %}
+  ins_cost(INSN_COST);
+  ins_encode %{
+    __ cmge(as_FloatRegister($dst$$reg), __ T4H,
+            as_FloatRegister($src1$$reg), as_FloatRegister($src2$$reg));
+  %}
+  ins_pipe(vdop64);
+%}
+
+instruct vcmge8S(vecX dst, vecX src1, vecX src2, immI cond)
+%{
+  predicate(n->as_Vector()->length() == 8 &&
+            n->as_VectorMaskCmp()->get_predicate() == BoolTest::ge &&
+            n->in(1)->in(1)->bottom_type()->is_vect()->element_basic_type() == T_SHORT);
+  match(Set dst (VectorMaskCmp (Binary src1 src2) cond));
+  format %{ "cmge  $dst, $src1, $src2\t# vector cmp (8S)" %}
+  ins_cost(INSN_COST);
+  ins_encode %{
+    __ cmge(as_FloatRegister($dst$$reg), __ T8H,
+            as_FloatRegister($src1$$reg), as_FloatRegister($src2$$reg));
+  %}
+  ins_pipe(vdop128);
+%}
+
+instruct vcmge2I(vecD dst, vecD src1, vecD src2, immI cond)
+%{
+  predicate(n->as_Vector()->length() == 2 &&
+            n->as_VectorMaskCmp()->get_predicate() == BoolTest::ge &&
+            n->in(1)->in(1)->bottom_type()->is_vect()->element_basic_type() == T_INT);
+  match(Set dst (VectorMaskCmp (Binary src1 src2) cond));
+  format %{ "cmge  $dst, $src1, $src2\t# vector cmp (2I)" %}
+  ins_cost(INSN_COST);
+  ins_encode %{
+    __ cmge(as_FloatRegister($dst$$reg), __ T2S,
+            as_FloatRegister($src1$$reg), as_FloatRegister($src2$$reg));
+  %}
+  ins_pipe(vdop64);
+%}
+
+instruct vcmge4I(vecX dst, vecX src1, vecX src2, immI cond)
+%{
+  predicate(n->as_Vector()->length() == 4 &&
+            n->as_VectorMaskCmp()->get_predicate() == BoolTest::ge &&
+            n->in(1)->in(1)->bottom_type()->is_vect()->element_basic_type() == T_INT);
+  match(Set dst (VectorMaskCmp (Binary src1 src2) cond));
+  format %{ "cmge  $dst, $src1, $src2\t# vector cmp (4I)" %}
+  ins_cost(INSN_COST);
+  ins_encode %{
+    __ cmge(as_FloatRegister($dst$$reg), __ T4S,
+            as_FloatRegister($src1$$reg), as_FloatRegister($src2$$reg));
+  %}
+  ins_pipe(vdop128);
+%}
+
+instruct vcmge2L(vecX dst, vecX src1, vecX src2, immI cond)
+%{
+  predicate(n->as_Vector()->length() == 2 &&
+            n->as_VectorMaskCmp()->get_predicate() == BoolTest::ge &&
+            n->in(1)->in(1)->bottom_type()->is_vect()->element_basic_type() == T_LONG);
+  match(Set dst (VectorMaskCmp (Binary src1 src2) cond));
+  format %{ "cmge  $dst, $src1, $src2\t# vector cmp (2L)" %}
+  ins_cost(INSN_COST);
+  ins_encode %{
+    __ cmge(as_FloatRegister($dst$$reg), __ T2D,
+            as_FloatRegister($src1$$reg), as_FloatRegister($src2$$reg));
+  %}
+  ins_pipe(vdop128);
+%}
+
+instruct vcmge2F(vecD dst, vecD src1, vecD src2, immI cond)
+%{
+  predicate(n->as_Vector()->length() == 2 &&
+            n->as_VectorMaskCmp()->get_predicate() == BoolTest::ge &&
+            n->in(1)->in(1)->bottom_type()->is_vect()->element_basic_type() == T_FLOAT);
+  match(Set dst (VectorMaskCmp (Binary src1 src2) cond));
+  format %{ "fcmge  $dst, $src1, $src2\t# vector cmp (2F)" %}
+  ins_cost(INSN_COST);
+  ins_encode %{
+    __ fcmge(as_FloatRegister($dst$$reg), __ T2S,
+            as_FloatRegister($src1$$reg), as_FloatRegister($src2$$reg));
+  %}
+  ins_pipe(vdop64);
+%}
+
+instruct vcmge4F(vecX dst, vecX src1, vecX src2, immI cond)
+%{
+  predicate(n->as_Vector()->length() == 4 &&
+            n->as_VectorMaskCmp()->get_predicate() == BoolTest::ge &&
+            n->in(1)->in(1)->bottom_type()->is_vect()->element_basic_type() == T_FLOAT);
+  match(Set dst (VectorMaskCmp (Binary src1 src2) cond));
+  format %{ "fcmge  $dst, $src1, $src2\t# vector cmp (4F)" %}
+  ins_cost(INSN_COST);
+  ins_encode %{
+    __ fcmge(as_FloatRegister($dst$$reg), __ T4S,
+            as_FloatRegister($src1$$reg), as_FloatRegister($src2$$reg));
+  %}
+  ins_pipe(vdop128);
+%}
+
+instruct vcmge2D(vecX dst, vecX src1, vecX src2, immI cond)
+%{
+  predicate(n->as_Vector()->length() == 2 &&
+            n->as_VectorMaskCmp()->get_predicate() == BoolTest::ge &&
+            n->in(1)->in(1)->bottom_type()->is_vect()->element_basic_type() == T_DOUBLE);
+  match(Set dst (VectorMaskCmp (Binary src1 src2) cond));
+  format %{ "fcmge  $dst, $src1, $src2\t# vector cmp (2D)" %}
+  ins_cost(INSN_COST);
+  ins_encode %{
+    __ fcmge(as_FloatRegister($dst$$reg), __ T2D,
+            as_FloatRegister($src1$$reg), as_FloatRegister($src2$$reg));
+  %}
+  ins_pipe(vdop128);
+%}
+
+instruct vcmne8B(vecD dst, vecD src1, vecD src2, immI cond)
+%{
+  predicate(n->as_Vector()->length() == 8 &&
+            n->as_VectorMaskCmp()->get_predicate() == BoolTest::ne &&
+            n->in(1)->in(1)->bottom_type()->is_vect()->element_basic_type() == T_BYTE);
+  match(Set dst (VectorMaskCmp (Binary src1 src2) cond));
+  format %{ "cmeq  $dst, $src1, $src2\n\t# vector cmp (8B)"
+            "not   $dst, $dst\t" %}
+  ins_cost(INSN_COST);
+  ins_encode %{
+    __ cmeq(as_FloatRegister($dst$$reg), __ T8B,
+            as_FloatRegister($src1$$reg), as_FloatRegister($src2$$reg));
+    __ notr(as_FloatRegister($dst$$reg), __ T8B, as_FloatRegister($dst$$reg));
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct vcmne16B(vecX dst, vecX src1, vecX src2, immI cond)
+%{
+  predicate(n->as_Vector()->length() == 16 &&
+            n->as_VectorMaskCmp()->get_predicate() == BoolTest::ne &&
+            n->in(1)->in(1)->bottom_type()->is_vect()->element_basic_type() == T_BYTE);
+  match(Set dst (VectorMaskCmp (Binary src1 src2) cond));
+  format %{ "cmeq  $dst, $src1, $src2\n\t# vector cmp (16B)"
+            "not   $dst, $dst\t" %}
+  ins_cost(INSN_COST);
+  ins_encode %{
+    __ cmeq(as_FloatRegister($dst$$reg), __ T16B,
+            as_FloatRegister($src1$$reg), as_FloatRegister($src2$$reg));
+    __ notr(as_FloatRegister($dst$$reg), __ T16B, as_FloatRegister($dst$$reg));
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct vcmne4S(vecD dst, vecD src1, vecD src2, immI cond)
+%{
+  predicate(n->as_Vector()->length() == 4 &&
+            n->as_VectorMaskCmp()->get_predicate() == BoolTest::ne &&
+            n->in(1)->in(1)->bottom_type()->is_vect()->element_basic_type() == T_SHORT);
+  match(Set dst (VectorMaskCmp (Binary src1 src2) cond));
+  format %{ "cmeq  $dst, $src1, $src2\n\t# vector cmp (4S)"
+            "not   $dst, $dst\t" %}
+  ins_cost(INSN_COST);
+  ins_encode %{
+    __ cmeq(as_FloatRegister($dst$$reg), __ T4H,
+            as_FloatRegister($src1$$reg), as_FloatRegister($src2$$reg));
+    __ notr(as_FloatRegister($dst$$reg), __ T8B, as_FloatRegister($dst$$reg));
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct vcmne8S(vecX dst, vecX src1, vecX src2, immI cond)
+%{
+  predicate(n->as_Vector()->length() == 8 &&
+            n->as_VectorMaskCmp()->get_predicate() == BoolTest::ne &&
+            n->in(1)->in(1)->bottom_type()->is_vect()->element_basic_type() == T_SHORT);
+  match(Set dst (VectorMaskCmp (Binary src1 src2) cond));
+  format %{ "cmeq  $dst, $src1, $src2\n\t# vector cmp (8S)"
+            "not   $dst, $dst\t" %}
+  ins_cost(INSN_COST);
+  ins_encode %{
+    __ cmeq(as_FloatRegister($dst$$reg), __ T8H,
+            as_FloatRegister($src1$$reg), as_FloatRegister($src2$$reg));
+    __ notr(as_FloatRegister($dst$$reg), __ T16B, as_FloatRegister($dst$$reg));
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct vcmne2I(vecD dst, vecD src1, vecD src2, immI cond)
+%{
+  predicate(n->as_Vector()->length() == 2 &&
+            n->as_VectorMaskCmp()->get_predicate() == BoolTest::ne &&
+            n->in(1)->in(1)->bottom_type()->is_vect()->element_basic_type() == T_INT);
+  match(Set dst (VectorMaskCmp (Binary src1 src2) cond));
+  format %{ "cmeq  $dst, $src1, $src2\n\t# vector cmp (2I)"
+            "not   $dst, $dst\t" %}
+  ins_cost(INSN_COST);
+  ins_encode %{
+    __ cmeq(as_FloatRegister($dst$$reg), __ T2S,
+            as_FloatRegister($src1$$reg), as_FloatRegister($src2$$reg));
+    __ notr(as_FloatRegister($dst$$reg), __ T8B, as_FloatRegister($dst$$reg));
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct vcmne4I(vecX dst, vecX src1, vecX src2, immI cond)
+%{
+  predicate(n->as_Vector()->length() == 4 &&
+            n->as_VectorMaskCmp()->get_predicate() == BoolTest::ne &&
+            n->in(1)->in(1)->bottom_type()->is_vect()->element_basic_type() == T_INT);
+  match(Set dst (VectorMaskCmp (Binary src1 src2) cond));
+  format %{ "cmeq  $dst, $src1, $src2\n\t# vector cmp (4I)"
+            "not   $dst, $dst\t" %}
+  ins_cost(INSN_COST);
+  ins_encode %{
+    __ cmeq(as_FloatRegister($dst$$reg), __ T4S,
+            as_FloatRegister($src1$$reg), as_FloatRegister($src2$$reg));
+    __ notr(as_FloatRegister($dst$$reg), __ T16B, as_FloatRegister($dst$$reg));
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct vcmne2L(vecX dst, vecX src1, vecX src2, immI cond)
+%{
+  predicate(n->as_Vector()->length() == 2 &&
+            n->as_VectorMaskCmp()->get_predicate() == BoolTest::ne &&
+            n->in(1)->in(1)->bottom_type()->is_vect()->element_basic_type() == T_LONG);
+  match(Set dst (VectorMaskCmp (Binary src1 src2) cond));
+  format %{ "cmeq  $dst, $src1, $src2\n\t# vector cmp (2L)"
+            "not   $dst, $dst\t" %}
+  ins_cost(INSN_COST);
+  ins_encode %{
+    __ cmeq(as_FloatRegister($dst$$reg), __ T2D,
+            as_FloatRegister($src1$$reg), as_FloatRegister($src2$$reg));
+    __ notr(as_FloatRegister($dst$$reg), __ T16B, as_FloatRegister($dst$$reg));
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct vcmne2F(vecD dst, vecD src1, vecD src2, immI cond)
+%{
+  predicate(n->as_Vector()->length() == 2 &&
+            n->as_VectorMaskCmp()->get_predicate() == BoolTest::ne &&
+            n->in(1)->in(1)->bottom_type()->is_vect()->element_basic_type() == T_FLOAT);
+  match(Set dst (VectorMaskCmp (Binary src1 src2) cond));
+  format %{ "fcmeq  $dst, $src1, $src2\n\t# vector cmp (2F)"
+            "not   $dst, $dst\t" %}
+  ins_cost(INSN_COST);
+  ins_encode %{
+    __ fcmeq(as_FloatRegister($dst$$reg), __ T2S,
+            as_FloatRegister($src1$$reg), as_FloatRegister($src2$$reg));
+    __ notr(as_FloatRegister($dst$$reg), __ T8B, as_FloatRegister($dst$$reg));
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct vcmne4F(vecX dst, vecX src1, vecX src2, immI cond)
+%{
+  predicate(n->as_Vector()->length() == 4 &&
+            n->as_VectorMaskCmp()->get_predicate() == BoolTest::ne &&
+            n->in(1)->in(1)->bottom_type()->is_vect()->element_basic_type() == T_FLOAT);
+  match(Set dst (VectorMaskCmp (Binary src1 src2) cond));
+  format %{ "fcmeq  $dst, $src1, $src2\n\t# vector cmp (4F)"
+            "not   $dst, $dst\t" %}
+  ins_cost(INSN_COST);
+  ins_encode %{
+    __ fcmeq(as_FloatRegister($dst$$reg), __ T4S,
+            as_FloatRegister($src1$$reg), as_FloatRegister($src2$$reg));
+    __ notr(as_FloatRegister($dst$$reg), __ T16B, as_FloatRegister($dst$$reg));
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct vcmne2D(vecX dst, vecX src1, vecX src2, immI cond)
+%{
+  predicate(n->as_Vector()->length() == 2 &&
+            n->as_VectorMaskCmp()->get_predicate() == BoolTest::ne &&
+            n->in(1)->in(1)->bottom_type()->is_vect()->element_basic_type() == T_DOUBLE);
+  match(Set dst (VectorMaskCmp (Binary src1 src2) cond));
+  format %{ "fcmeq  $dst, $src1, $src2\n\t# vector cmp (2D)"
+            "not   $dst, $dst\t" %}
+  ins_cost(INSN_COST);
+  ins_encode %{
+    __ fcmeq(as_FloatRegister($dst$$reg), __ T2D,
+            as_FloatRegister($src1$$reg), as_FloatRegister($src2$$reg));
+    __ notr(as_FloatRegister($dst$$reg), __ T16B, as_FloatRegister($dst$$reg));
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct vcmlt8B(vecD dst, vecD src1, vecD src2, immI cond)
+%{
+  predicate(n->as_Vector()->length() == 8 &&
+            n->as_VectorMaskCmp()->get_predicate() == BoolTest::lt &&
+            n->in(1)->in(1)->bottom_type()->is_vect()->element_basic_type() == T_BYTE);
+  match(Set dst (VectorMaskCmp (Binary src1 src2) cond));
+  format %{ "cmgt  $dst, $src2, $src1\t# vector cmp (8B)" %}
+  ins_cost(INSN_COST);
+  ins_encode %{
+    __ cmgt(as_FloatRegister($dst$$reg), __ T8B,
+            as_FloatRegister($src2$$reg), as_FloatRegister($src1$$reg));
+  %}
+  ins_pipe(vdop64);
+%}
+
+instruct vcmlt16B(vecX dst, vecX src1, vecX src2, immI cond)
+%{
+  predicate(n->as_Vector()->length() == 16 &&
+            n->as_VectorMaskCmp()->get_predicate() == BoolTest::lt &&
+            n->in(1)->in(1)->bottom_type()->is_vect()->element_basic_type() == T_BYTE);
+  match(Set dst (VectorMaskCmp (Binary src1 src2) cond));
+  format %{ "cmgt  $dst, $src2, $src1\t# vector cmp (16B)" %}
+  ins_cost(INSN_COST);
+  ins_encode %{
+    __ cmgt(as_FloatRegister($dst$$reg), __ T16B,
+            as_FloatRegister($src2$$reg), as_FloatRegister($src1$$reg));
+  %}
+  ins_pipe(vdop128);
+%}
+
+instruct vcmlt4S(vecD dst, vecD src1, vecD src2, immI cond)
+%{
+  predicate(n->as_Vector()->length() == 4 &&
+            n->as_VectorMaskCmp()->get_predicate() == BoolTest::lt &&
+            n->in(1)->in(1)->bottom_type()->is_vect()->element_basic_type() == T_SHORT);
+  match(Set dst (VectorMaskCmp (Binary src1 src2) cond));
+  format %{ "cmgt  $dst, $src2, $src1\t# vector cmp (4S)" %}
+  ins_cost(INSN_COST);
+  ins_encode %{
+    __ cmgt(as_FloatRegister($dst$$reg), __ T4H,
+            as_FloatRegister($src2$$reg), as_FloatRegister($src1$$reg));
+  %}
+  ins_pipe(vdop64);
+%}
+
+instruct vcmlt8S(vecX dst, vecX src1, vecX src2, immI cond)
+%{
+  predicate(n->as_Vector()->length() == 8 &&
+            n->as_VectorMaskCmp()->get_predicate() == BoolTest::lt &&
+            n->in(1)->in(1)->bottom_type()->is_vect()->element_basic_type() == T_SHORT);
+  match(Set dst (VectorMaskCmp (Binary src1 src2) cond));
+  format %{ "cmgt  $dst, $src2, $src1\t# vector cmp (8S)" %}
+  ins_cost(INSN_COST);
+  ins_encode %{
+    __ cmgt(as_FloatRegister($dst$$reg), __ T8H,
+            as_FloatRegister($src2$$reg), as_FloatRegister($src1$$reg));
+  %}
+  ins_pipe(vdop128);
+%}
+
+instruct vcmlt2I(vecD dst, vecD src1, vecD src2, immI cond)
+%{
+  predicate(n->as_Vector()->length() == 2 &&
+            n->as_VectorMaskCmp()->get_predicate() == BoolTest::lt &&
+            n->in(1)->in(1)->bottom_type()->is_vect()->element_basic_type() == T_INT);
+  match(Set dst (VectorMaskCmp (Binary src1 src2) cond));
+  format %{ "cmgt  $dst, $src2, $src1\t# vector cmp (2I)" %}
+  ins_cost(INSN_COST);
+  ins_encode %{
+    __ cmgt(as_FloatRegister($dst$$reg), __ T2S,
+            as_FloatRegister($src2$$reg), as_FloatRegister($src1$$reg));
+  %}
+  ins_pipe(vdop64);
+%}
+
+instruct vcmlt4I(vecX dst, vecX src1, vecX src2, immI cond)
+%{
+  predicate(n->as_Vector()->length() == 4 &&
+            n->as_VectorMaskCmp()->get_predicate() == BoolTest::lt &&
+            n->in(1)->in(1)->bottom_type()->is_vect()->element_basic_type() == T_INT);
+  match(Set dst (VectorMaskCmp (Binary src1 src2) cond));
+  format %{ "cmgt  $dst, $src2, $src1\t# vector cmp (4I)" %}
+  ins_cost(INSN_COST);
+  ins_encode %{
+    __ cmgt(as_FloatRegister($dst$$reg), __ T4S,
+            as_FloatRegister($src2$$reg), as_FloatRegister($src1$$reg));
+  %}
+  ins_pipe(vdop128);
+%}
+
+instruct vcmlt2L(vecX dst, vecX src1, vecX src2, immI cond)
+%{
+  predicate(n->as_Vector()->length() == 2 &&
+            n->as_VectorMaskCmp()->get_predicate() == BoolTest::lt &&
+            n->in(1)->in(1)->bottom_type()->is_vect()->element_basic_type() == T_LONG);
+  match(Set dst (VectorMaskCmp (Binary src1 src2) cond));
+  format %{ "cmgt  $dst, $src2, $src1\t# vector cmp (2L)" %}
+  ins_cost(INSN_COST);
+  ins_encode %{
+    __ cmgt(as_FloatRegister($dst$$reg), __ T2D,
+            as_FloatRegister($src2$$reg), as_FloatRegister($src1$$reg));
+  %}
+  ins_pipe(vdop128);
+%}
+
+instruct vcmlt2F(vecD dst, vecD src1, vecD src2, immI cond)
+%{
+  predicate(n->as_Vector()->length() == 2 &&
+            n->as_VectorMaskCmp()->get_predicate() == BoolTest::lt &&
+            n->in(1)->in(1)->bottom_type()->is_vect()->element_basic_type() == T_FLOAT);
+  match(Set dst (VectorMaskCmp (Binary src1 src2) cond));
+  format %{ "fcmgt  $dst, $src2, $src1\t# vector cmp (2F)" %}
+  ins_cost(INSN_COST);
+  ins_encode %{
+    __ fcmgt(as_FloatRegister($dst$$reg), __ T2S,
+            as_FloatRegister($src2$$reg), as_FloatRegister($src1$$reg));
+  %}
+  ins_pipe(vdop64);
+%}
+
+instruct vcmlt4F(vecX dst, vecX src1, vecX src2, immI cond)
+%{
+  predicate(n->as_Vector()->length() == 4 &&
+            n->as_VectorMaskCmp()->get_predicate() == BoolTest::lt &&
+            n->in(1)->in(1)->bottom_type()->is_vect()->element_basic_type() == T_FLOAT);
+  match(Set dst (VectorMaskCmp (Binary src1 src2) cond));
+  format %{ "fcmgt  $dst, $src2, $src1\t# vector cmp (4F)" %}
+  ins_cost(INSN_COST);
+  ins_encode %{
+    __ fcmgt(as_FloatRegister($dst$$reg), __ T4S,
+            as_FloatRegister($src2$$reg), as_FloatRegister($src1$$reg));
+  %}
+  ins_pipe(vdop128);
+%}
+
+instruct vcmlt2D(vecX dst, vecX src1, vecX src2, immI cond)
+%{
+  predicate(n->as_Vector()->length() == 2 &&
+            n->as_VectorMaskCmp()->get_predicate() == BoolTest::lt &&
+            n->in(1)->in(1)->bottom_type()->is_vect()->element_basic_type() == T_DOUBLE);
+  match(Set dst (VectorMaskCmp (Binary src1 src2) cond));
+  format %{ "fcmgt  $dst, $src2, $src1\t# vector cmp (2D)" %}
+  ins_cost(INSN_COST);
+  ins_encode %{
+    __ fcmgt(as_FloatRegister($dst$$reg), __ T2D,
+            as_FloatRegister($src2$$reg), as_FloatRegister($src1$$reg));
+  %}
+  ins_pipe(vdop128);
+%}
+
+instruct vcmle8B(vecD dst, vecD src1, vecD src2, immI cond)
+%{
+  predicate(n->as_Vector()->length() == 8 &&
+            n->as_VectorMaskCmp()->get_predicate() == BoolTest::le &&
+            n->in(1)->in(1)->bottom_type()->is_vect()->element_basic_type() == T_BYTE);
+  match(Set dst (VectorMaskCmp (Binary src1 src2) cond));
+  format %{ "cmge  $dst, $src2, $src1\t# vector cmp (8B)" %}
+  ins_cost(INSN_COST);
+  ins_encode %{
+    __ cmge(as_FloatRegister($dst$$reg), __ T8B,
+            as_FloatRegister($src2$$reg), as_FloatRegister($src1$$reg));
+  %}
+  ins_pipe(vdop64);
+%}
+
+instruct vcmle16B(vecX dst, vecX src1, vecX src2, immI cond)
+%{
+  predicate(n->as_Vector()->length() == 16 &&
+            n->as_VectorMaskCmp()->get_predicate() == BoolTest::le &&
+            n->in(1)->in(1)->bottom_type()->is_vect()->element_basic_type() == T_BYTE);
+  match(Set dst (VectorMaskCmp (Binary src1 src2) cond));
+  format %{ "cmge  $dst, $src2, $src1\t# vector cmp (16B)" %}
+  ins_cost(INSN_COST);
+  ins_encode %{
+    __ cmge(as_FloatRegister($dst$$reg), __ T16B,
+            as_FloatRegister($src2$$reg), as_FloatRegister($src1$$reg));
+  %}
+  ins_pipe(vdop128);
+%}
+
+instruct vcmle4S(vecD dst, vecD src1, vecD src2, immI cond)
+%{
+  predicate(n->as_Vector()->length() == 4 &&
+            n->as_VectorMaskCmp()->get_predicate() == BoolTest::le &&
+            n->in(1)->in(1)->bottom_type()->is_vect()->element_basic_type() == T_SHORT);
+  match(Set dst (VectorMaskCmp (Binary src1 src2) cond));
+  format %{ "cmge  $dst, $src2, $src1\t# vector cmp (4S)" %}
+  ins_cost(INSN_COST);
+  ins_encode %{
+    __ cmge(as_FloatRegister($dst$$reg), __ T4H,
+            as_FloatRegister($src2$$reg), as_FloatRegister($src1$$reg));
+  %}
+  ins_pipe(vdop64);
+%}
+
+instruct vcmle8S(vecX dst, vecX src1, vecX src2, immI cond)
+%{
+  predicate(n->as_Vector()->length() == 8 &&
+            n->as_VectorMaskCmp()->get_predicate() == BoolTest::le &&
+            n->in(1)->in(1)->bottom_type()->is_vect()->element_basic_type() == T_SHORT);
+  match(Set dst (VectorMaskCmp (Binary src1 src2) cond));
+  format %{ "cmge  $dst, $src2, $src1\t# vector cmp (8S)" %}
+  ins_cost(INSN_COST);
+  ins_encode %{
+    __ cmge(as_FloatRegister($dst$$reg), __ T8H,
+            as_FloatRegister($src2$$reg), as_FloatRegister($src1$$reg));
+  %}
+  ins_pipe(vdop128);
+%}
+
+instruct vcmle2I(vecD dst, vecD src1, vecD src2, immI cond)
+%{
+  predicate(n->as_Vector()->length() == 2 &&
+            n->as_VectorMaskCmp()->get_predicate() == BoolTest::le &&
+            n->in(1)->in(1)->bottom_type()->is_vect()->element_basic_type() == T_INT);
+  match(Set dst (VectorMaskCmp (Binary src1 src2) cond));
+  format %{ "cmge  $dst, $src2, $src1\t# vector cmp (2I)" %}
+  ins_cost(INSN_COST);
+  ins_encode %{
+    __ cmge(as_FloatRegister($dst$$reg), __ T2S,
+            as_FloatRegister($src2$$reg), as_FloatRegister($src1$$reg));
+  %}
+  ins_pipe(vdop64);
+%}
+
+instruct vcmle4I(vecX dst, vecX src1, vecX src2, immI cond)
+%{
+  predicate(n->as_Vector()->length() == 4 &&
+            n->as_VectorMaskCmp()->get_predicate() == BoolTest::le &&
+            n->in(1)->in(1)->bottom_type()->is_vect()->element_basic_type() == T_INT);
+  match(Set dst (VectorMaskCmp (Binary src1 src2) cond));
+  format %{ "cmge  $dst, $src2, $src1\t# vector cmp (4I)" %}
+  ins_cost(INSN_COST);
+  ins_encode %{
+    __ cmge(as_FloatRegister($dst$$reg), __ T4S,
+            as_FloatRegister($src2$$reg), as_FloatRegister($src1$$reg));
+  %}
+  ins_pipe(vdop128);
+%}
+
+instruct vcmle2L(vecX dst, vecX src1, vecX src2, immI cond)
+%{
+  predicate(n->as_Vector()->length() == 2 &&
+            n->as_VectorMaskCmp()->get_predicate() == BoolTest::le &&
+            n->in(1)->in(1)->bottom_type()->is_vect()->element_basic_type() == T_LONG);
+  match(Set dst (VectorMaskCmp (Binary src1 src2) cond));
+  format %{ "cmge  $dst, $src2, $src1\t# vector cmp (2L)" %}
+  ins_cost(INSN_COST);
+  ins_encode %{
+    __ cmge(as_FloatRegister($dst$$reg), __ T2D,
+            as_FloatRegister($src2$$reg), as_FloatRegister($src1$$reg));
+  %}
+  ins_pipe(vdop128);
+%}
+
+instruct vcmle2F(vecD dst, vecD src1, vecD src2, immI cond)
+%{
+  predicate(n->as_Vector()->length() == 2 &&
+            n->as_VectorMaskCmp()->get_predicate() == BoolTest::le &&
+            n->in(1)->in(1)->bottom_type()->is_vect()->element_basic_type() == T_FLOAT);
+  match(Set dst (VectorMaskCmp (Binary src1 src2) cond));
+  format %{ "fcmge  $dst, $src2, $src1\t# vector cmp (2F)" %}
+  ins_cost(INSN_COST);
+  ins_encode %{
+    __ fcmge(as_FloatRegister($dst$$reg), __ T2S,
+            as_FloatRegister($src2$$reg), as_FloatRegister($src1$$reg));
+  %}
+  ins_pipe(vdop64);
+%}
+
+instruct vcmle4F(vecX dst, vecX src1, vecX src2, immI cond)
+%{
+  predicate(n->as_Vector()->length() == 4 &&
+            n->as_VectorMaskCmp()->get_predicate() == BoolTest::le &&
+            n->in(1)->in(1)->bottom_type()->is_vect()->element_basic_type() == T_FLOAT);
+  match(Set dst (VectorMaskCmp (Binary src1 src2) cond));
+  format %{ "fcmge  $dst, $src2, $src1\t# vector cmp (4F)" %}
+  ins_cost(INSN_COST);
+  ins_encode %{
+    __ fcmge(as_FloatRegister($dst$$reg), __ T4S,
+            as_FloatRegister($src2$$reg), as_FloatRegister($src1$$reg));
+  %}
+  ins_pipe(vdop128);
+%}
+
+instruct vcmle2D(vecX dst, vecX src1, vecX src2, immI cond)
+%{
+  predicate(n->as_Vector()->length() == 2 &&
+            n->as_VectorMaskCmp()->get_predicate() == BoolTest::le &&
+            n->in(1)->in(1)->bottom_type()->is_vect()->element_basic_type() == T_DOUBLE);
+  match(Set dst (VectorMaskCmp (Binary src1 src2) cond));
+  format %{ "fcmge  $dst, $src2, $src1\t# vector cmp (2D)" %}
+  ins_cost(INSN_COST);
+  ins_encode %{
+    __ fcmge(as_FloatRegister($dst$$reg), __ T2D,
+            as_FloatRegister($src2$$reg), as_FloatRegister($src1$$reg));
+  %}
+  ins_pipe(vdop128);
+%}
+
+// ------------------------------ Vector mul -----------------------------------
+
+instruct vmul2L(vecX dst, vecX src1, vecX src2, iRegLNoSp tmp1, iRegLNoSp tmp2)
+%{
+  predicate(n->as_Vector()->length() == 2);
+  match(Set dst (MulVL src1 src2));
+  ins_cost(INSN_COST);
+  effect(TEMP tmp1, TEMP tmp2);
+  format %{ "umov   $tmp1, $src1, D, 0\n\t"
+            "umov   $tmp2, $src2, D, 0\n\t"
+            "mul    $tmp2, $tmp2, $tmp1\n\t"
+            "mov    $dst,  T2D,   0, $tmp2\t# insert into vector(2L)\n\t"
+            "umov   $tmp1, $src1, D, 1\n\t"
+            "umov   $tmp2, $src2, D, 1\n\t"
+            "mul    $tmp2, $tmp2, $tmp1\n\t"
+            "mov    $dst,  T2D,   1, $tmp2\t# insert into vector(2L)\n\t"
+  %}
+  ins_encode %{
+    __ umov($tmp1$$Register, as_FloatRegister($src1$$reg), __ D, 0);
+    __ umov($tmp2$$Register, as_FloatRegister($src2$$reg), __ D, 0);
+    __ mul(as_Register($tmp2$$reg), as_Register($tmp2$$reg), as_Register($tmp1$$reg));
+    __ mov(as_FloatRegister($dst$$reg), __ T2D, 0, $tmp2$$Register);
+    __ umov($tmp1$$Register, as_FloatRegister($src1$$reg), __ D, 1);
+    __ umov($tmp2$$Register, as_FloatRegister($src2$$reg), __ D, 1);
+    __ mul(as_Register($tmp2$$reg), as_Register($tmp2$$reg), as_Register($tmp1$$reg));
+    __ mov(as_FloatRegister($dst$$reg), __ T2D, 1, $tmp2$$Register);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+// --------------------------------- Vector not --------------------------------
+
+instruct vnot2I(vecD dst, vecD src, immI_M1 m1)
+%{
+  predicate(n->as_Vector()->length_in_bytes() == 8);
+  match(Set dst (XorV src (ReplicateB m1)));
+  match(Set dst (XorV src (ReplicateS m1)));
+  match(Set dst (XorV src (ReplicateI m1)));
+  ins_cost(INSN_COST);
+  format %{ "not  $dst, $src\t# vector (8B)" %}
+  ins_encode %{
+    __ notr(as_FloatRegister($dst$$reg), __ T8B,
+            as_FloatRegister($src$$reg));
+  %}
+  ins_pipe(pipe_class_default);
+%}
+
+instruct vnot4I(vecX dst, vecX src, immI_M1 m1)
+%{
+  predicate(n->as_Vector()->length_in_bytes() == 16);
+  match(Set dst (XorV src (ReplicateB m1)));
+  match(Set dst (XorV src (ReplicateS m1)));
+  match(Set dst (XorV src (ReplicateI m1)));
+  ins_cost(INSN_COST);
+  format %{ "not  $dst, $src\t# vector (16B)" %}
+  ins_encode %{
+    __ notr(as_FloatRegister($dst$$reg), __ T16B,
+            as_FloatRegister($src$$reg));
+  %}
+  ins_pipe(pipe_class_default);
+%}
+
+instruct vnot2L(vecX dst, vecX src, immL_M1 m1)
+%{
+  predicate(n->as_Vector()->length_in_bytes() == 16);
+  match(Set dst (XorV src (ReplicateL m1)));
+  ins_cost(INSN_COST);
+  format %{ "not  $dst, $src\t# vector (16B)" %}
+  ins_encode %{
+    __ notr(as_FloatRegister($dst$$reg), __ T16B,
+            as_FloatRegister($src$$reg));
+  %}
+  ins_pipe(pipe_class_default);
+%}
+
+// ------------------------------ Vector max/min -------------------------------
+
+instruct vmax8B(vecD dst, vecD src1, vecD src2)
+%{
+  predicate((n->as_Vector()->length() == 4 || n->as_Vector()->length() == 8) &&
+             n->bottom_type()->is_vect()->element_basic_type() == T_BYTE);
+  match(Set dst (MaxV src1 src2));
+  ins_cost(INSN_COST);
+  format %{ "maxv  $dst, $src1, $src2\t# vector (8B)" %}
+  ins_encode %{
+    __ maxv(as_FloatRegister($dst$$reg), __ T8B,
+            as_FloatRegister($src1$$reg),
+            as_FloatRegister($src2$$reg));
+  %}
+  ins_pipe(vdop64);
+%}
+
+instruct vmax16B(vecX dst, vecX src1, vecX src2)
+%{
+  predicate(n->as_Vector()->length() == 16 && n->bottom_type()->is_vect()->element_basic_type() == T_BYTE);
+  match(Set dst (MaxV src1 src2));
+  ins_cost(INSN_COST);
+  format %{ "maxv  $dst, $src1, $src2\t# vector (16B)" %}
+  ins_encode %{
+    __ maxv(as_FloatRegister($dst$$reg), __ T16B,
+            as_FloatRegister($src1$$reg),
+            as_FloatRegister($src2$$reg));
+  %}
+  ins_pipe(vdop128);
+%}
+
+instruct vmax4S(vecD dst, vecD src1, vecD src2)
+%{
+  predicate(n->as_Vector()->length() == 4 && n->bottom_type()->is_vect()->element_basic_type() == T_SHORT);
+  match(Set dst (MaxV src1 src2));
+  ins_cost(INSN_COST);
+  format %{ "maxv  $dst, $src1, $src2\t# vector (4S)" %}
+  ins_encode %{
+    __ maxv(as_FloatRegister($dst$$reg), __ T4H,
+            as_FloatRegister($src1$$reg),
+            as_FloatRegister($src2$$reg));
+  %}
+  ins_pipe(vdop64);
+%}
+
+instruct vmax8S(vecX dst, vecX src1, vecX src2)
+%{
+  predicate(n->as_Vector()->length() == 8 && n->bottom_type()->is_vect()->element_basic_type() == T_SHORT);
+  match(Set dst (MaxV src1 src2));
+  ins_cost(INSN_COST);
+  format %{ "maxv  $dst, $src1, $src2\t# vector (8S)" %}
+  ins_encode %{
+    __ maxv(as_FloatRegister($dst$$reg), __ T8H,
+            as_FloatRegister($src1$$reg),
+            as_FloatRegister($src2$$reg));
+  %}
+  ins_pipe(vdop128);
+%}
+
+instruct vmax2I(vecD dst, vecD src1, vecD src2)
+%{
+  predicate(n->as_Vector()->length() == 2 && n->bottom_type()->is_vect()->element_basic_type() == T_INT);
+  match(Set dst (MaxV src1 src2));
+  ins_cost(INSN_COST);
+  format %{ "maxv  $dst, $src1, $src2\t# vector (2I)" %}
+  ins_encode %{
+    __ maxv(as_FloatRegister($dst$$reg), __ T2S,
+            as_FloatRegister($src1$$reg),
+            as_FloatRegister($src2$$reg));
+  %}
+  ins_pipe(vdop64);
+%}
+
+instruct vmax4I(vecX dst, vecX src1, vecX src2)
+%{
+  predicate(n->as_Vector()->length() == 4 && n->bottom_type()->is_vect()->element_basic_type() == T_INT);
+  match(Set dst (MaxV src1 src2));
+  ins_cost(INSN_COST);
+  format %{ "maxv  $dst, $src1, $src2\t# vector (4I)" %}
+  ins_encode %{
+    __ maxv(as_FloatRegister($dst$$reg), __ T4S,
+            as_FloatRegister($src1$$reg),
+            as_FloatRegister($src2$$reg));
+  %}
+  ins_pipe(vdop128);
+%}
+
+instruct vmin8B(vecD dst, vecD src1, vecD src2)
+%{
+  predicate((n->as_Vector()->length() == 4 || n->as_Vector()->length() == 8) &&
+             n->bottom_type()->is_vect()->element_basic_type() == T_BYTE);
+  match(Set dst (MinV src1 src2));
+  ins_cost(INSN_COST);
+  format %{ "minv  $dst, $src1, $src2\t# vector (8B)" %}
+  ins_encode %{
+    __ minv(as_FloatRegister($dst$$reg), __ T8B,
+            as_FloatRegister($src1$$reg),
+            as_FloatRegister($src2$$reg));
+  %}
+  ins_pipe(vdop64);
+%}
+
+instruct vmin16B(vecX dst, vecX src1, vecX src2)
+%{
+  predicate(n->as_Vector()->length() == 16 && n->bottom_type()->is_vect()->element_basic_type() == T_BYTE);
+  match(Set dst (MinV src1 src2));
+  ins_cost(INSN_COST);
+  format %{ "minv  $dst, $src1, $src2\t# vector (16B)" %}
+  ins_encode %{
+    __ minv(as_FloatRegister($dst$$reg), __ T16B,
+            as_FloatRegister($src1$$reg),
+            as_FloatRegister($src2$$reg));
+  %}
+  ins_pipe(vdop128);
+%}
+
+instruct vmin4S(vecD dst, vecD src1, vecD src2)
+%{
+  predicate(n->as_Vector()->length() == 4 && n->bottom_type()->is_vect()->element_basic_type() == T_SHORT);
+  match(Set dst (MinV src1 src2));
+  ins_cost(INSN_COST);
+  format %{ "minv  $dst, $src1, $src2\t# vector (4S)" %}
+  ins_encode %{
+    __ minv(as_FloatRegister($dst$$reg), __ T4H,
+            as_FloatRegister($src1$$reg),
+            as_FloatRegister($src2$$reg));
+  %}
+  ins_pipe(vdop64);
+%}
+
+instruct vmin8S(vecX dst, vecX src1, vecX src2)
+%{
+  predicate(n->as_Vector()->length() == 8 && n->bottom_type()->is_vect()->element_basic_type() == T_SHORT);
+  match(Set dst (MinV src1 src2));
+  ins_cost(INSN_COST);
+  format %{ "minv  $dst, $src1, $src2\t# vector (8S)" %}
+  ins_encode %{
+    __ minv(as_FloatRegister($dst$$reg), __ T8H,
+            as_FloatRegister($src1$$reg),
+            as_FloatRegister($src2$$reg));
+  %}
+  ins_pipe(vdop128);
+%}
+
+instruct vmin2I(vecD dst, vecD src1, vecD src2)
+%{
+  predicate(n->as_Vector()->length() == 2 && n->bottom_type()->is_vect()->element_basic_type() == T_INT);
+  match(Set dst (MinV src1 src2));
+  ins_cost(INSN_COST);
+  format %{ "minv  $dst, $src1, $src2\t# vector (2I)" %}
+  ins_encode %{
+    __ minv(as_FloatRegister($dst$$reg), __ T2S,
+            as_FloatRegister($src1$$reg),
+            as_FloatRegister($src2$$reg));
+  %}
+  ins_pipe(vdop64);
+%}
+
+instruct vmin4I(vecX dst, vecX src1, vecX src2)
+%{
+  predicate(n->as_Vector()->length() == 4 && n->bottom_type()->is_vect()->element_basic_type() == T_INT);
+  match(Set dst (MinV src1 src2));
+  ins_cost(INSN_COST);
+  format %{ "minv  $dst, $src1, $src2\t# vector (4I)" %}
+  ins_encode %{
+    __ minv(as_FloatRegister($dst$$reg), __ T4S,
+            as_FloatRegister($src1$$reg),
+            as_FloatRegister($src2$$reg));
+  %}
+  ins_pipe(vdop128);
+%}
+
+
+instruct vmax2L(vecX dst, vecX src1, vecX src2)
+%{
+  predicate(n->as_Vector()->length() == 2 && n->bottom_type()->is_vect()->element_basic_type() == T_LONG);
+  match(Set dst (MaxV src1 src2));
+  ins_cost(INSN_COST);
+  effect(TEMP dst);
+  format %{ "cmgt  $dst, $src1, $src2\t# vector (2L)\n\t"
+            "bsl   $dst, $src1, $src2\t# vector (16B)" %}
+  ins_encode %{
+    __ cmgt(as_FloatRegister($dst$$reg), __ T2D,
+            as_FloatRegister($src1$$reg), as_FloatRegister($src2$$reg));
+    __ bsl(as_FloatRegister($dst$$reg), __ T16B,
+           as_FloatRegister($src1$$reg), as_FloatRegister($src2$$reg));
+  %}
+  ins_pipe(vdop128);
+%}
+
+instruct vmin2L(vecX dst, vecX src1, vecX src2)
+%{
+  predicate(n->as_Vector()->length() == 2 && n->bottom_type()->is_vect()->element_basic_type() == T_LONG);
+  match(Set dst (MinV src1 src2));
+  ins_cost(INSN_COST);
+  effect(TEMP dst);
+  format %{ "cmgt  $dst, $src1, $src2\t# vector (2L)\n\t"
+            "bsl   $dst, $src2, $src1\t# vector (16B)" %}
+  ins_encode %{
+    __ cmgt(as_FloatRegister($dst$$reg), __ T2D,
+            as_FloatRegister($src1$$reg), as_FloatRegister($src2$$reg));
+    __ bsl(as_FloatRegister($dst$$reg), __ T16B,
+           as_FloatRegister($src2$$reg), as_FloatRegister($src1$$reg));
+  %}
+  ins_pipe(vdop128);
+%}
+
+// --------------------------------- blend (bsl) ----------------------------
+
+instruct vbsl8B(vecD dst, vecD src1, vecD src2)
+%{
+  predicate(n->as_Vector()->length_in_bytes() == 8);
+  match(Set dst (VectorBlend (Binary src1 src2) dst));
+  ins_cost(INSN_COST);
+  format %{ "bsl  $dst, $src2, $src1\t# vector (8B)" %}
+  ins_encode %{
+    __ bsl(as_FloatRegister($dst$$reg), __ T8B,
+           as_FloatRegister($src2$$reg), as_FloatRegister($src1$$reg));
+  %}
+  ins_pipe(vlogical64);
+%}
+
+instruct vbsl16B(vecX dst, vecX src1, vecX src2)
+%{
+  predicate(n->as_Vector()->length_in_bytes() == 16);
+  match(Set dst (VectorBlend (Binary src1 src2) dst));
+  ins_cost(INSN_COST);
+  format %{ "bsl  $dst, $src2, $src1\t# vector (16B)" %}
+  ins_encode %{
+    __ bsl(as_FloatRegister($dst$$reg), __ T16B,
+           as_FloatRegister($src2$$reg), as_FloatRegister($src1$$reg));
+  %}
+  ins_pipe(vlogical128);
+%}
+
+// --------------------------------- Load/store Mask ----------------------------
+
+instruct loadmask8B(vecD dst, vecD src  )
+%{
+  predicate(n->as_Vector()->length() == 8 && n->bottom_type()->is_vect()->element_basic_type() == T_BYTE);
+  match(Set dst (VectorLoadMask src ));
+  ins_cost(INSN_COST);
+  format %{ "negr  $dst, $src\t# load mask (8B to 8B)" %}
+  ins_encode %{
+    __ negr(as_FloatRegister($dst$$reg), __ T8B, as_FloatRegister($src$$reg));
+  %}
+  ins_pipe(pipe_class_default);
+%}
+
+instruct loadmask16B(vecX dst, vecX src  )
+%{
+  predicate(n->as_Vector()->length() == 16 && n->bottom_type()->is_vect()->element_basic_type() == T_BYTE);
+  match(Set dst (VectorLoadMask src ));
+  ins_cost(INSN_COST);
+  format %{ "negr  $dst, $src\t# load mask (16B to 16B)" %}
+  ins_encode %{
+    __ negr(as_FloatRegister($dst$$reg), __ T16B, as_FloatRegister($src$$reg));
+  %}
+  ins_pipe(pipe_class_default);
+%}
+
+instruct storemask8B(vecD dst, vecD src , immI_1 size)
+%{
+  predicate(n->as_Vector()->length() == 8);
+  match(Set dst (VectorStoreMask src size));
+  ins_cost(INSN_COST);
+  format %{ "negr  $dst, $src\t# store mask (8B to 8B)" %}
+  ins_encode %{
+    __ negr(as_FloatRegister($dst$$reg), __ T8B, as_FloatRegister($src$$reg));
+  %}
+  ins_pipe(pipe_class_default);
+%}
+
+instruct storemask16B(vecX dst, vecX src , immI_1 size)
+%{
+  predicate(n->as_Vector()->length() == 16);
+  match(Set dst (VectorStoreMask src size));
+  ins_cost(INSN_COST);
+  format %{ "negr  $dst, $src\t# store mask (16B to 16B)" %}
+  ins_encode %{
+    __ negr(as_FloatRegister($dst$$reg), __ T16B, as_FloatRegister($src$$reg));
+  %}
+  ins_pipe(pipe_class_default);
+%}
+
+instruct loadmask4S(vecD dst, vecD src  )
+%{
+  predicate(n->as_Vector()->length() == 4 && n->bottom_type()->is_vect()->element_basic_type() == T_SHORT);
+  match(Set dst (VectorLoadMask src ));
+  ins_cost(INSN_COST);
+  format %{ "uxtl  $dst, $src\n\t"
+            "negr  $dst, $dst\t# load mask (4B to 4H)" %}
+  ins_encode %{
+    __ uxtl(as_FloatRegister($dst$$reg), __ T8H, as_FloatRegister($src$$reg), __ T8B);
+    __ negr(as_FloatRegister($dst$$reg), __ T8H, as_FloatRegister($dst$$reg));
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct loadmask8S(vecX dst, vecD src  )
+%{
+  predicate(n->as_Vector()->length() == 8 && n->bottom_type()->is_vect()->element_basic_type() == T_SHORT);
+  match(Set dst (VectorLoadMask src ));
+  ins_cost(INSN_COST);
+  format %{ "uxtl  $dst, $src\n\t"
+            "negr  $dst, $dst\t# load mask (8B to 8H)" %}
+  ins_encode %{
+    __ uxtl(as_FloatRegister($dst$$reg), __ T8H, as_FloatRegister($src$$reg), __ T8B);
+    __ negr(as_FloatRegister($dst$$reg), __ T8H, as_FloatRegister($dst$$reg));
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct storemask4S(vecD dst, vecD src , immI_2 size)
+%{
+  predicate(n->as_Vector()->length() == 4);
+  match(Set dst (VectorStoreMask src size));
+  ins_cost(INSN_COST);
+  format %{ "xtn  $dst, $src\n\t"
+            "negr  $dst, $dst\t# store mask (4H to 4B)" %}
+  ins_encode %{
+    __ xtn(as_FloatRegister($dst$$reg), __ T8B, as_FloatRegister($src$$reg), __ T8H);
+    __ negr(as_FloatRegister($dst$$reg), __ T8B, as_FloatRegister($dst$$reg));
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct storemask8S(vecD dst, vecX src , immI_2 size)
+%{
+  predicate(n->as_Vector()->length() == 8);
+  match(Set dst (VectorStoreMask src size));
+  ins_cost(INSN_COST);
+  format %{ "xtn  $dst, $src\n\t"
+            "negr  $dst, $dst\t# store mask (8H to 8B)" %}
+  ins_encode %{
+    __ xtn(as_FloatRegister($dst$$reg), __ T8B, as_FloatRegister($src$$reg), __ T8H);
+    __ negr(as_FloatRegister($dst$$reg), __ T8B, as_FloatRegister($dst$$reg));
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct loadmask2I(vecD dst, vecD src  )
+%{
+  predicate(n->as_Vector()->length() == 2 &&
+            (n->bottom_type()->is_vect()->element_basic_type() == T_INT ||
+             n->bottom_type()->is_vect()->element_basic_type() == T_FLOAT));
+  match(Set dst (VectorLoadMask src ));
+  ins_cost(INSN_COST);
+  format %{ "uxtl  $dst, $src\t# 2B to 2H\n\t"
+            "uxtl  $dst, $dst\t# 2H to 2S\n\t"
+            "negr   $dst, $dst\t# load mask (2B to 2S)" %}
+  ins_encode %{
+    __ uxtl(as_FloatRegister($dst$$reg), __ T8H, as_FloatRegister($src$$reg), __ T8B);
+    __ uxtl(as_FloatRegister($dst$$reg), __ T4S, as_FloatRegister($dst$$reg), __ T4H);
+    __ negr(as_FloatRegister($dst$$reg), __ T4S, as_FloatRegister($dst$$reg));
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct loadmask4I(vecX dst, vecD src  )
+%{
+  predicate(n->as_Vector()->length() == 4 &&
+            (n->bottom_type()->is_vect()->element_basic_type() == T_INT ||
+             n->bottom_type()->is_vect()->element_basic_type() == T_FLOAT));
+  match(Set dst (VectorLoadMask src ));
+  ins_cost(INSN_COST);
+  format %{ "uxtl  $dst, $src\t# 4B to 4H\n\t"
+            "uxtl  $dst, $dst\t# 4H to 4S\n\t"
+            "negr   $dst, $dst\t# load mask (4B to 4S)" %}
+  ins_encode %{
+    __ uxtl(as_FloatRegister($dst$$reg), __ T8H, as_FloatRegister($src$$reg), __ T8B);
+    __ uxtl(as_FloatRegister($dst$$reg), __ T4S, as_FloatRegister($dst$$reg), __ T4H);
+    __ negr(as_FloatRegister($dst$$reg), __ T4S, as_FloatRegister($dst$$reg));
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct storemask2I(vecD dst, vecD src , immI_4 size)
+%{
+  predicate(n->as_Vector()->length() == 2);
+  match(Set dst (VectorStoreMask src size));
+  ins_cost(INSN_COST);
+  format %{ "xtn  $dst, $src\t# 2S to 2H\n\t"
+            "xtn  $dst, $dst\t# 2H to 2B\n\t"
+            "negr   $dst, $dst\t# store mask (2S to 2B)" %}
+  ins_encode %{
+    __ xtn(as_FloatRegister($dst$$reg), __ T4H, as_FloatRegister($src$$reg), __ T4S);
+    __ xtn(as_FloatRegister($dst$$reg), __ T8B, as_FloatRegister($dst$$reg), __ T8H);
+    __ negr(as_FloatRegister($dst$$reg), __ T8B, as_FloatRegister($dst$$reg));
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct storemask4I(vecD dst, vecX src , immI_4 size)
+%{
+  predicate(n->as_Vector()->length() == 4);
+  match(Set dst (VectorStoreMask src size));
+  ins_cost(INSN_COST);
+  format %{ "xtn  $dst, $src\t# 4S to 4H\n\t"
+            "xtn  $dst, $dst\t# 4H to 4B\n\t"
+            "negr   $dst, $dst\t# store mask (4S to 4B)" %}
+  ins_encode %{
+    __ xtn(as_FloatRegister($dst$$reg), __ T4H, as_FloatRegister($src$$reg), __ T4S);
+    __ xtn(as_FloatRegister($dst$$reg), __ T8B, as_FloatRegister($dst$$reg), __ T8H);
+    __ negr(as_FloatRegister($dst$$reg), __ T8B, as_FloatRegister($dst$$reg));
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct loadmask2L(vecX dst, vecD src)
+%{
+  predicate(n->as_Vector()->length() == 2 &&
+            (n->bottom_type()->is_vect()->element_basic_type() == T_LONG ||
+             n->bottom_type()->is_vect()->element_basic_type() == T_DOUBLE));
+  match(Set dst (VectorLoadMask src));
+  ins_cost(INSN_COST);
+  format %{ "uxtl  $dst, $src\t# 2B to 2S\n\t"
+            "uxtl  $dst, $dst\t# 2S to 2I\n\t"
+            "uxtl  $dst, $dst\t# 2I to 2L\n\t"
+            "neg   $dst, $dst\t# load mask (2B to 2L)" %}
+  ins_encode %{
+    __ uxtl(as_FloatRegister($dst$$reg), __ T8H, as_FloatRegister($src$$reg), __ T8B);
+    __ uxtl(as_FloatRegister($dst$$reg), __ T4S, as_FloatRegister($dst$$reg), __ T4H);
+    __ uxtl(as_FloatRegister($dst$$reg), __ T2D, as_FloatRegister($dst$$reg), __ T2S);
+    __ negr(as_FloatRegister($dst$$reg), __ T2D, as_FloatRegister($dst$$reg));
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct storemask2L(vecD dst, vecX src, immI_8 size)
+%{
+  predicate(n->as_Vector()->length() == 2);
+  match(Set dst (VectorStoreMask src size));
+  ins_cost(INSN_COST);
+  format %{ "xtn  $dst, $src\t# 2L to 2I\n\t"
+            "xtn  $dst, $dst\t# 2I to 2S\n\t"
+            "xtn  $dst, $dst\t# 2S to 2B\n\t"
+            "neg  $dst, $dst\t# store mask (2L to 2B)" %}
+  ins_encode %{
+    __ xtn(as_FloatRegister($dst$$reg), __ T2S, as_FloatRegister($src$$reg), __ T2D);
+    __ xtn(as_FloatRegister($dst$$reg), __ T4H, as_FloatRegister($dst$$reg), __ T4S);
+    __ xtn(as_FloatRegister($dst$$reg), __ T8B, as_FloatRegister($dst$$reg), __ T8H);
+    __ negr(as_FloatRegister($dst$$reg), __ T8B, as_FloatRegister($dst$$reg));
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+//-------------------------------- LOAD_IOTA_INDICES----------------------------------
+
+instruct loadcon8B(vecD dst, immI0 src)
+%{
+  predicate((n->as_Vector()->length() == 2 || n->as_Vector()->length() == 4 ||
+             n->as_Vector()->length() == 8) &&
+             n->bottom_type()->is_vect()->element_basic_type() == T_BYTE);
+  match(Set dst (VectorLoadConst src));
+  ins_cost(INSN_COST);
+  format %{ "ldr $dst, CONSTANT_MEMORY\t# load iota indices" %}
+  ins_encode %{
+    __ lea(rscratch1, ExternalAddress(StubRoutines::aarch64::vector_iota_indices()));
+    __ ldrd(as_FloatRegister($dst$$reg), rscratch1);
+  %}
+  ins_pipe(pipe_class_memory);
+%}
+
+instruct loadcon16B(vecX dst, immI0 src)
+%{
+  predicate(n->as_Vector()->length() == 16 && n->bottom_type()->is_vect()->element_basic_type() == T_BYTE);
+  match(Set dst (VectorLoadConst src));
+  ins_cost(INSN_COST);
+  format %{ "ldr $dst, CONSTANT_MEMORY\t# load iota indices" %}
+  ins_encode %{
+    __ lea(rscratch1, ExternalAddress(StubRoutines::aarch64::vector_iota_indices()));
+    __ ldrq(as_FloatRegister($dst$$reg), rscratch1);
+  %}
+  ins_pipe(pipe_class_memory);
+%}
+
+//-------------------------------- LOAD_SHUFFLE ----------------------------------
+
+instruct loadshuffle8B(vecD dst, vecD src)
+%{
+  predicate(n->as_Vector()->length() == 8 &&
+            n->bottom_type()->is_vect()->element_basic_type() == T_BYTE);
+  match(Set dst (VectorLoadShuffle src));
+  ins_cost(INSN_COST);
+  format %{ "mov  $dst, $src\t# get 8B shuffle" %}
+  ins_encode %{
+    __ orr(as_FloatRegister($dst$$reg), __ T8B,
+           as_FloatRegister($src$$reg), as_FloatRegister($src$$reg));
+  %}
+  ins_pipe(pipe_class_default);
+%}
+
+instruct loadshuffle16B(vecX dst, vecX src)
+%{
+  predicate(n->as_Vector()->length() == 16 &&
+            n->bottom_type()->is_vect()->element_basic_type() == T_BYTE);
+  match(Set dst (VectorLoadShuffle src));
+  ins_cost(INSN_COST);
+  format %{ "mov  $dst, $src\t# get 16B shuffle" %}
+  ins_encode %{
+    __ orr(as_FloatRegister($dst$$reg), __ T16B,
+           as_FloatRegister($src$$reg), as_FloatRegister($src$$reg));
+  %}
+  ins_pipe(pipe_class_default);
+%}
+
+instruct loadshuffle4S(vecD dst, vecD src)
+%{
+  predicate(n->as_Vector()->length() == 4 &&
+            n->bottom_type()->is_vect()->element_basic_type() == T_SHORT);
+  match(Set dst (VectorLoadShuffle src));
+  ins_cost(INSN_COST);
+  format %{ "uxtl  $dst, $src\t# 4B to 4H" %}
+  ins_encode %{
+    __ uxtl(as_FloatRegister($dst$$reg), __ T8H, as_FloatRegister($src$$reg), __ T8B);
+  %}
+  ins_pipe(pipe_class_default);
+%}
+
+instruct loadshuffle8S(vecX dst, vecD src)
+%{
+  predicate(n->as_Vector()->length() == 8 &&
+            n->bottom_type()->is_vect()->element_basic_type() == T_SHORT);
+  match(Set dst (VectorLoadShuffle src));
+  ins_cost(INSN_COST);
+  format %{ "uxtl  $dst, $src\t# 8B to 8H" %}
+  ins_encode %{
+    __ uxtl(as_FloatRegister($dst$$reg), __ T8H, as_FloatRegister($src$$reg), __ T8B);
+  %}
+  ins_pipe(pipe_class_default);
+%}
+
+instruct loadshuffle4I(vecX dst, vecD src)
+%{
+  predicate(n->as_Vector()->length() == 4 &&
+           (n->bottom_type()->is_vect()->element_basic_type() == T_INT ||
+            n->bottom_type()->is_vect()->element_basic_type() == T_FLOAT));
+  match(Set dst (VectorLoadShuffle src));
+  ins_cost(INSN_COST);
+  format %{ "uxtl  $dst, $src\t# 4B to 4H \n\t"
+            "uxtl  $dst, $dst\t# 4H to 4S" %}
+  ins_encode %{
+    __ uxtl(as_FloatRegister($dst$$reg), __ T8H, as_FloatRegister($src$$reg), __ T8B);
+    __ uxtl(as_FloatRegister($dst$$reg), __ T4S, as_FloatRegister($dst$$reg), __ T4H);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+//-------------------------------- Rearrange -------------------------------------
+// Here is an example that rearranges a NEON vector with 4 ints:
+// Rearrange V1 int[a0, a1, a2, a3] to V2 int[a2, a3, a0, a1]
+//   1. Get the indices of V1 and store them as Vi byte[0, 1, 2, 3].
+//   2. Convert Vi byte[0, 1, 2, 3] to the indices of V2 and also store them as Vi byte[2, 3, 0, 1].
+//   3. Unsigned extend Long Vi from byte[2, 3, 0, 1] to int[2, 3, 0, 1].
+//   4. Multiply Vi int[2, 3, 0, 1] with constant int[0x04040404, 0x04040404, 0x04040404, 0x04040404]
+//      and get tbl base Vm int[0x08080808, 0x0c0c0c0c, 0x00000000, 0x04040404].
+//   5. Add Vm with constant int[0x03020100, 0x03020100, 0x03020100, 0x03020100]
+//      and get tbl index Vm int[0x0b0a0908, 0x0f0e0d0c, 0x03020100, 0x07060504]
+//   6. Use Vm as index register, and use V1 as table register.
+//      Then get V2 as the result by tbl NEON instructions.
+// Notes:
+//   Step 1 matches VectorLoadConst.
+//   Step 3 matches VectorLoadShuffle.
+//   Step 4, 5, 6 match VectorRearrange.
+//   For VectorRearrange short/int, the reason why such complex calculation is
+//   required is because NEON tbl supports bytes table only, so for short/int, we
+//   need to lookup 2/4 bytes as a group. For VectorRearrange long, we use bsl
+//   to implement rearrange.
+
+instruct rearrange8B(vecD dst, vecD src, vecD shuffle)
+%{
+  predicate(n->as_Vector()->length() == 8 &&
+            n->bottom_type()->is_vect()->element_basic_type() == T_BYTE);
+  match(Set dst (VectorRearrange src shuffle));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst);
+  format %{ "tbl $dst, {$dst}, $shuffle\t# rearrange 8B" %}
+  ins_encode %{
+    __ tbl(as_FloatRegister($dst$$reg), __ T8B,
+           as_FloatRegister($src$$reg), 1, as_FloatRegister($shuffle$$reg));
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct rearrange16B(vecX dst, vecX src, vecX shuffle)
+%{
+  predicate(n->as_Vector()->length() == 16 &&
+            n->bottom_type()->is_vect()->element_basic_type() == T_BYTE);
+  match(Set dst (VectorRearrange src shuffle));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst);
+  format %{ "tbl $dst, {$dst}, $shuffle\t# rearrange 16B" %}
+  ins_encode %{
+    __ tbl(as_FloatRegister($dst$$reg), __ T16B,
+           as_FloatRegister($src$$reg), 1, as_FloatRegister($shuffle$$reg));
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct rearrange4S(vecD dst, vecD src, vecD shuffle, vecD tmp0, vecD tmp1)
+%{
+  predicate(n->as_Vector()->length() == 4 &&
+            n->bottom_type()->is_vect()->element_basic_type() == T_SHORT);
+  match(Set dst (VectorRearrange src shuffle));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst, TEMP tmp0, TEMP tmp1);
+  format %{ "mov   $tmp0, CONSTANT\t# constant 0x0202020202020202\n\t"
+            "mov   $tmp1, CONSTANT\t# constant 0x0100010001000100\n\t"
+            "mulv  $dst, T4H, $shuffle, $tmp0\n\t"
+            "addv  $dst, T8B, $dst, $tmp1\n\t"
+            "tbl   $dst, {$src}, $dst\t# rearrange 4S" %}
+  ins_encode %{
+    __ mov(as_FloatRegister($tmp0$$reg), __ T8B, 0x02);
+    __ mov(as_FloatRegister($tmp1$$reg), __ T4H, 0x0100);
+    __ mulv(as_FloatRegister($dst$$reg), __ T4H,
+            as_FloatRegister($shuffle$$reg), as_FloatRegister($tmp0$$reg));
+    __ addv(as_FloatRegister($dst$$reg), __ T8B,
+            as_FloatRegister($dst$$reg), as_FloatRegister($tmp1$$reg));
+    __ tbl(as_FloatRegister($dst$$reg), __ T8B,
+           as_FloatRegister($src$$reg), 1, as_FloatRegister($dst$$reg));
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct rearrange8S(vecX dst, vecX src, vecX shuffle, vecX tmp0, vecX tmp1)
+%{
+  predicate(n->as_Vector()->length() == 8 &&
+            n->bottom_type()->is_vect()->element_basic_type() == T_SHORT);
+  match(Set dst (VectorRearrange src shuffle));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst, TEMP tmp0, TEMP tmp1);
+  format %{ "mov   $tmp0, CONSTANT\t# constant 0x0202020202020202\n\t"
+            "mov   $tmp1, CONSTANT\t# constant 0x0100010001000100\n\t"
+            "mulv  $dst, T8H, $shuffle, $tmp0\n\t"
+            "addv  $dst, T16B, $dst, $tmp1\n\t"
+            "tbl   $dst, {$src}, $dst\t# rearrange 8S" %}
+  ins_encode %{
+    __ mov(as_FloatRegister($tmp0$$reg), __ T16B, 0x02);
+    __ mov(as_FloatRegister($tmp1$$reg), __ T8H, 0x0100);
+    __ mulv(as_FloatRegister($dst$$reg), __ T8H,
+            as_FloatRegister($shuffle$$reg), as_FloatRegister($tmp0$$reg));
+    __ addv(as_FloatRegister($dst$$reg), __ T16B,
+            as_FloatRegister($dst$$reg), as_FloatRegister($tmp1$$reg));
+    __ tbl(as_FloatRegister($dst$$reg), __ T16B,
+           as_FloatRegister($src$$reg), 1, as_FloatRegister($dst$$reg));
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct rearrange4I(vecX dst, vecX src, vecX shuffle, vecX tmp0, vecX tmp1)
+%{
+  predicate(n->as_Vector()->length() == 4 &&
+           (n->bottom_type()->is_vect()->element_basic_type() == T_INT ||
+            n->bottom_type()->is_vect()->element_basic_type() == T_FLOAT));
+  match(Set dst (VectorRearrange src shuffle));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst, TEMP tmp0, TEMP tmp1);
+  format %{ "mov   $tmp0, CONSTANT\t# constant 0x0404040404040404\n\t"
+            "mov   $tmp1, CONSTANT\t# constant 0x0302010003020100\n\t"
+            "mulv  $dst, T8H, $shuffle, $tmp0\n\t"
+            "addv  $dst, T16B, $dst, $tmp1\n\t"
+            "tbl   $dst, {$src}, $dst\t# rearrange 4I" %}
+  ins_encode %{
+    __ mov(as_FloatRegister($tmp0$$reg), __ T16B, 0x04);
+    __ mov(as_FloatRegister($tmp1$$reg), __ T4S, 0x03020100);
+    __ mulv(as_FloatRegister($dst$$reg), __ T4S,
+            as_FloatRegister($shuffle$$reg), as_FloatRegister($tmp0$$reg));
+    __ addv(as_FloatRegister($dst$$reg), __ T16B,
+            as_FloatRegister($dst$$reg), as_FloatRegister($tmp1$$reg));
+    __ tbl(as_FloatRegister($dst$$reg), __ T16B,
+           as_FloatRegister($src$$reg), 1, as_FloatRegister($dst$$reg));
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+//-------------------------------- Anytrue/alltrue -----------------------------
+
+instruct anytrue_in_mask8B(iRegINoSp dst, vecD src1, vecD src2, vecD tmp, rFlagsReg cr)
+%{
+  predicate(static_cast(n)->get_predicate() == BoolTest::ne);
+  match(Set dst (VectorTest src1 src2 ));
+  ins_cost(INSN_COST);
+  effect(TEMP tmp, KILL cr);
+  format %{ "addv  $tmp, T8B, $src1\t# src1 and src2 are the same\n\t"
+            "umov  $dst, $tmp, B, 0\n\t"
+            "cmp   $dst, 0\n\t"
+            "cset  $dst" %}
+  ins_encode %{
+    __ addv(as_FloatRegister($tmp$$reg), __ T8B, as_FloatRegister($src1$$reg));
+    __ umov($dst$$Register, as_FloatRegister($tmp$$reg), __ B, 0);
+    __ cmpw($dst$$Register, zr);
+    __ csetw($dst$$Register, Assembler::NE);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct anytrue_in_mask16B(iRegINoSp dst, vecX src1, vecX src2, vecX tmp, rFlagsReg cr)
+%{
+  predicate(static_cast(n)->get_predicate() == BoolTest::ne);
+  match(Set dst (VectorTest src1 src2 ));
+  ins_cost(INSN_COST);
+  effect(TEMP tmp, KILL cr);
+  format %{ "addv  $tmp, T16B, $src1\t# src1 and src2 are the same\n\t"
+            "umov  $dst, $tmp, B, 0\n\t"
+            "cmp   $dst, 0\n\t"
+            "cset  $dst" %}
+  ins_encode %{
+    __ addv(as_FloatRegister($tmp$$reg), __ T16B, as_FloatRegister($src1$$reg));
+    __ umov($dst$$Register, as_FloatRegister($tmp$$reg), __ B, 0);
+    __ cmpw($dst$$Register, zr);
+    __ csetw($dst$$Register, Assembler::NE);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct alltrue_in_mask8B(iRegINoSp dst, vecD src1, vecD src2, vecD tmp, rFlagsReg cr)
+%{
+  predicate(static_cast(n)->get_predicate() == BoolTest::overflow);
+  match(Set dst (VectorTest src1 src2 ));
+  ins_cost(INSN_COST);
+  effect(TEMP tmp, KILL cr);
+  format %{ "andr  $tmp, T8B, $src1, $src2\t# src2 is maskAllTrue\n\t"
+            "notr  $tmp, T8B, $tmp\n\t"
+            "addv  $tmp, T8B, $tmp\n\t"
+            "umov  $dst, $tmp, B, 0\n\t"
+            "cmp   $dst, 0\n\t"
+            "cset  $dst" %}
+  ins_encode %{
+    __ andr(as_FloatRegister($tmp$$reg), __ T8B,
+            as_FloatRegister($src1$$reg), as_FloatRegister($src2$$reg));
+    __ notr(as_FloatRegister($tmp$$reg), __ T8B, as_FloatRegister($tmp$$reg));
+    __ addv(as_FloatRegister($tmp$$reg), __ T8B, as_FloatRegister($tmp$$reg));
+    __ umov($dst$$Register, as_FloatRegister($tmp$$reg), __ B, 0);
+    __ cmpw($dst$$Register, zr);
+    __ csetw($dst$$Register, Assembler::EQ);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct alltrue_in_mask16B(iRegINoSp dst, vecX src1, vecX src2, vecX tmp, rFlagsReg cr)
+%{
+  predicate(static_cast(n)->get_predicate() == BoolTest::overflow);
+  match(Set dst (VectorTest src1 src2 ));
+  ins_cost(INSN_COST);
+  effect(TEMP tmp, KILL cr);
+  format %{ "andr  $tmp, T16B, $src1, $src2\t# src2 is maskAllTrue\n\t"
+            "notr  $tmp, T16B, $tmp\n\t"
+            "addv  $tmp, T16B, $tmp\n\t"
+            "umov  $dst, $tmp, B, 0\n\t"
+            "cmp   $dst, 0\n\t"
+            "cset  $dst" %}
+  ins_encode %{
+    __ andr(as_FloatRegister($tmp$$reg), __ T16B,
+            as_FloatRegister($src1$$reg), as_FloatRegister($src2$$reg));
+    __ notr(as_FloatRegister($tmp$$reg), __ T16B, as_FloatRegister($tmp$$reg));
+    __ addv(as_FloatRegister($tmp$$reg), __ T16B, as_FloatRegister($tmp$$reg));
+    __ umov($dst$$Register, as_FloatRegister($tmp$$reg), __ B, 0);
+    __ cmpw($dst$$Register, zr);
+    __ csetw($dst$$Register, Assembler::EQ);
+  %}
+  ins_pipe(pipe_slow);
+%}
diff --git a/src/hotspot/cpu/aarch64/aarch64_neon_ad.m4 b/src/hotspot/cpu/aarch64/aarch64_neon_ad.m4
new file mode 100644
index 0000000000000..0b1dc5cb7c684
--- /dev/null
+++ b/src/hotspot/cpu/aarch64/aarch64_neon_ad.m4
@@ -0,0 +1,1424 @@
+// Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+// Copyright (c) 2020, Arm Limited. All rights reserved.
+// DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+//
+// This code is free software; you can redistribute it and/or modify it
+// under the terms of the GNU General Public License version 2 only, as
+// published by the Free Software Foundation.
+//
+// This code 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
+// version 2 for more details (a copy is included in the LICENSE file that
+// accompanied this code).
+//
+// You should have received a copy of the GNU General Public License version
+// 2 along with this work; if not, write to the Free Software Foundation,
+// Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+// or visit www.oracle.com if you need additional information or have any
+// questions.
+//
+//
+
+dnl Generate the warning
+// This file is automatically generated by running "m4 aarch64_neon_ad.m4". Do not edit ----
+dnl
+
+// AArch64 NEON Architecture Description File
+
+dnl
+define(`ORL2I', `ifelse($1,I,orL2I)')dnl
+dnl
+define(`error', `__program__:__file__:__line__: Invalid argument ``$1''m4exit(`1')')dnl
+dnl
+define(`iTYPE2SIMD',
+`ifelse($1, `B', `B',
+        $1, `S', `H',
+        $1, `I', `S',
+        $1, `L', `D',
+        `error($1)')')dnl
+dnl
+define(`fTYPE2SIMD',
+`ifelse($1, `F', `S',
+        $1, `D', `D',
+        `error($1)')')dnl
+dnl
+define(`TYPE2DATATYPE',
+`ifelse($1, `B', `BYTE',
+        $1, `S', `SHORT',
+        $1, `I', `INT',
+        $1, `L', `LONG',
+        $1, `F', `FLOAT',
+        $1, `D', `DOUBLE',
+        `error($1)')')dnl
+dnl
+// ====================VECTOR INSTRUCTIONS==================================
+
+// ------------------------------ Load/store/reinterpret -----------------------
+
+// Load vector (16 bits)
+instruct loadV2(vecD dst, memory mem)
+%{
+  predicate(n->as_LoadVector()->memory_size() == 2);
+  match(Set dst (LoadVector mem));
+  ins_cost(4 * INSN_COST);
+  format %{ "ldrh   $dst,$mem\t# vector (16 bits)" %}
+  ins_encode( aarch64_enc_ldrvH(dst, mem) );
+  ins_pipe(vload_reg_mem64);
+%}
+
+// Store Vector (16 bits)
+instruct storeV2(vecD src, memory mem)
+%{
+  predicate(n->as_StoreVector()->memory_size() == 2);
+  match(Set mem (StoreVector mem src));
+  ins_cost(4 * INSN_COST);
+  format %{ "strh   $mem,$src\t# vector (16 bits)" %}
+  ins_encode( aarch64_enc_strvH(src, mem) );
+  ins_pipe(vstore_reg_mem64);
+%}
+dnl
+define(`REINTERPRET', `
+instruct reinterpret$1`'(vec$1 dst)
+%{
+  predicate(n->bottom_type()->is_vect()->length_in_bytes() == $2 &&
+            n->in(1)->bottom_type()->is_vect()->length_in_bytes() == $2);
+  match(Set dst (VectorReinterpret dst));
+  ins_cost(0);
+  format %{ " # reinterpret $dst" %}
+  ins_encode %{
+    // empty
+  %}
+  ins_pipe(pipe_class_empty);
+%}')dnl
+dnl         $1 $2
+REINTERPRET(D, 8)
+REINTERPRET(X, 16)
+dnl
+define(`REINTERPRET_X', `
+instruct reinterpret$1`'2$2`'(vec$2 dst, vec$1 src)
+%{
+  predicate(n->bottom_type()->is_vect()->length_in_bytes() == $3 &&
+            n->in(1)->bottom_type()->is_vect()->length_in_bytes() == $4);
+  match(Set dst (VectorReinterpret src));
+  ins_cost(INSN_COST);
+  format %{ " # reinterpret $dst,$src" %}
+  ins_encode %{
+    // If register is the same, then move is not needed.
+    if (as_FloatRegister($dst$$reg) != as_FloatRegister($src$$reg)) {
+      __ orr(as_FloatRegister($dst$$reg), __ T8B,
+             as_FloatRegister($src$$reg),
+             as_FloatRegister($src$$reg));
+    }
+  %}
+  ins_pipe(vlogical64);
+%}')dnl
+dnl           $1 $2 $3  $4
+REINTERPRET_X(D, X, 16, 8)
+REINTERPRET_X(X, D, 8,  16)
+dnl
+
+// ------------------------------ Vector cast -------------------------------
+dnl
+define(`VECTOR_CAST_I2I', `
+instruct vcvt$1$2to$1$3`'(vec$4 dst, vec$5 src)
+%{
+  predicate(n->as_Vector()->length() == $1 && n->bottom_type()->is_vect()->element_basic_type() == T_`'TYPE2DATATYPE($3));
+  match(Set dst (VectorCast$2`'2X src));
+  format %{ "$6  $dst, T$8, $src, T$7\t# convert $1$2 to $1$3 vector" %}
+  ins_encode %{
+    __ $6(as_FloatRegister($dst$$reg), __ T$8, as_FloatRegister($src$$reg), __ T$7);
+  %}
+  ins_pipe(pipe_class_default);
+%}')dnl
+dnl             $1 $2 $3 $4 $5 $6    $7  $8
+VECTOR_CAST_I2I(4, B, S, D, D, sxtl, 8B, 8H)
+VECTOR_CAST_I2I(8, B, S, X, D, sxtl, 8B, 8H)
+VECTOR_CAST_I2I(4, S, B, D, D, xtn,  8H, 8B)
+VECTOR_CAST_I2I(8, S, B, D, X, xtn,  8H, 8B)
+VECTOR_CAST_I2I(4, S, I, X, D, sxtl, 4H, 4S)
+VECTOR_CAST_I2I(4, I, S, D, X, xtn,  4S, 4H)
+VECTOR_CAST_I2I(2, I, L, X, D, sxtl, 2S, 2D)
+VECTOR_CAST_I2I(2, L, I, D, X, xtn,  2D, 2S)
+dnl
+define(`VECTOR_CAST_B2I', `
+instruct vcvt4$1to4$2`'(vec$3 dst, vec$4 src)
+%{
+  predicate(n->as_Vector()->length() == 4 && n->bottom_type()->is_vect()->element_basic_type() == T_`'TYPE2DATATYPE($2));
+  match(Set dst (VectorCast$1`'2X src));
+  format %{ "$5  $dst, T$7, $src, T$6\n\t"
+            "$5  $dst, T$9, $dst, T$8\t# convert 4$1 to 4$2 vector"
+  %}
+  ins_encode %{
+    __ $5(as_FloatRegister($dst$$reg), __ T$7, as_FloatRegister($src$$reg), __ T$6);
+    __ $5(as_FloatRegister($dst$$reg), __ T$9, as_FloatRegister($dst$$reg), __ T$8);
+  %}
+  ins_pipe(pipe_slow);
+%}')dnl
+dnl             $1 $2 $3 $4 $5    $6  $7  $8  $9
+VECTOR_CAST_B2I(B, I, X, D, sxtl, 8B, 8H, 4H, 4S)
+VECTOR_CAST_B2I(I, B, D, X, xtn,  4S, 4H, 8H, 8B)
+
+instruct vcvt4Bto4F(vecX dst, vecD src)
+%{
+  predicate(n->as_Vector()->length() == 4 && n->bottom_type()->is_vect()->element_basic_type() == T_FLOAT);
+  match(Set dst (VectorCastB2X src));
+  format %{ "sxtl  $dst, T8H, $src, T8B\n\t"
+            "sxtl  $dst, T4S, $dst, T4H\n\t"
+            "scvtfv  T4S, $dst, $dst\t# convert 4B to 4F vector"
+  %}
+  ins_encode %{
+    __ sxtl(as_FloatRegister($dst$$reg), __ T8H, as_FloatRegister($src$$reg), __ T8B);
+    __ sxtl(as_FloatRegister($dst$$reg), __ T4S, as_FloatRegister($dst$$reg), __ T4H);
+    __ scvtfv(__ T4S, as_FloatRegister($dst$$reg), as_FloatRegister($dst$$reg));
+  %}
+  ins_pipe(pipe_slow);
+%}
+dnl
+define(`VECTOR_CAST_I2F_L', `
+instruct vcvt$1$2to$1$3`'(vecX dst, vecD src)
+%{
+  predicate(n->as_Vector()->length() == $1 && n->bottom_type()->is_vect()->element_basic_type() == T_`'TYPE2DATATYPE($3));
+  match(Set dst (VectorCast$2`'2X src));
+  format %{ "sxtl    $dst, T$5, $src, T$4\n\t"
+            "scvtfv  T$5, $dst, $dst\t# convert $1$2 to $1$3 vector"
+  %}
+  ins_encode %{
+    __ sxtl(as_FloatRegister($dst$$reg), __ T$5, as_FloatRegister($src$$reg), __ T$4);
+    __ scvtfv(__ T$5, as_FloatRegister($dst$$reg), as_FloatRegister($dst$$reg));
+  %}
+  ins_pipe(pipe_slow);
+%}')dnl
+dnl               $1 $2 $3 $4  $5
+VECTOR_CAST_I2F_L(4, S, F, 4H, 4S)
+VECTOR_CAST_I2F_L(2, I, D, 2S, 2D)
+dnl
+define(`VECTOR_CAST_I2F', `
+instruct vcvt$1$2to$1$3`'(vec$4 dst, vec$4 src)
+%{
+  predicate(n->as_Vector()->length() == $1 && n->bottom_type()->is_vect()->element_basic_type() == T_`'TYPE2DATATYPE($3));
+  match(Set dst (VectorCast$2`'2X src));
+  format %{ "scvtfv  T$5, $dst, $src\t# convert $1$2 to $1$3 vector" %}
+  ins_encode %{
+    __ scvtfv(__ T$5, as_FloatRegister($dst$$reg), as_FloatRegister($src$$reg));
+  %}
+  ins_pipe(pipe_class_default);
+%}')dnl
+dnl             $1 $2 $3 $4 $5
+VECTOR_CAST_I2F(2, I, F, D, 2S)
+VECTOR_CAST_I2F(4, I, F, X, 4S)
+VECTOR_CAST_I2F(2, L, D, X, 2D)
+dnl
+define(`VECTOR_CAST_F2F', `
+instruct vcvt2$1to2$2`'(vec$3 dst, vec$4 src)
+%{
+  predicate(n->as_Vector()->length() == 2 && n->bottom_type()->is_vect()->element_basic_type() == T_`'TYPE2DATATYPE($2));
+  match(Set dst (VectorCast$1`'2X src));
+  format %{ "$5  $dst, T$7, $src, T$6\t# convert 2$1 to 2$2 vector" %}
+  ins_encode %{
+    __ $5(as_FloatRegister($dst$$reg), __ T$7, as_FloatRegister($src$$reg), __ T$6);
+  %}
+  ins_pipe(pipe_class_default);
+%}')dnl
+dnl             $1 $2 $3 $4 $5     $6  $7
+VECTOR_CAST_F2F(F, D, X, D, fcvtl, 2S, 2D)
+VECTOR_CAST_F2F(D, F, D, X, fcvtn, 2D, 2S)
+dnl
+
+instruct vcvt2Lto2F(vecD dst, vecX src)
+%{
+  predicate(n->as_Vector()->length() == 2 && n->bottom_type()->is_vect()->element_basic_type() == T_FLOAT);
+  match(Set dst (VectorCastL2X src));
+  format %{ "scvtfv  T2D, $dst, $src\n\t"
+            "fcvtn   $dst, T2S, $dst, T2D\t# convert 2L to 2F vector"
+  %}
+  ins_encode %{
+    __ scvtfv(__ T2D, as_FloatRegister($dst$$reg), as_FloatRegister($src$$reg));
+    __ fcvtn(as_FloatRegister($dst$$reg), __ T2S, as_FloatRegister($dst$$reg), __ T2D);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+// ------------------------------ Reduction -------------------------------
+dnl
+define(`REDUCE_ADD_BORS', `
+instruct reduce_add$1$2`'(iRegINoSp dst, iRegIorL2I isrc, vec$3 vsrc, vec$3 tmp)
+%{
+  predicate(n->in(2)->bottom_type()->is_vect()->element_basic_type() == T_`'TYPE2DATATYPE($2));
+  match(Set dst (AddReductionVI isrc vsrc));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst, TEMP tmp);
+  format %{ "addv  $tmp, T$1`'iTYPE2SIMD($2), $vsrc\n\t"
+            "smov  $dst, $tmp, iTYPE2SIMD($2), 0\n\t"
+            "addw  $dst, $dst, $isrc\n\t"
+            "sxt$4  $dst, $dst\t# add reduction$1$2"
+  %}
+  ins_encode %{
+    __ addv(as_FloatRegister($tmp$$reg), __ T$1`'iTYPE2SIMD($2), as_FloatRegister($vsrc$$reg));
+    __ smov($dst$$Register, as_FloatRegister($tmp$$reg), __ iTYPE2SIMD($2), 0);
+    __ addw($dst$$Register, $dst$$Register, $isrc$$Register);
+    __ sxt$4($dst$$Register, $dst$$Register);
+  %}
+  ins_pipe(pipe_slow);
+%}')dnl
+dnl             $1  $2 $3 $4
+REDUCE_ADD_BORS(8,  B, D, b)
+REDUCE_ADD_BORS(16, B, X, b)
+REDUCE_ADD_BORS(4,  S, D, h)
+REDUCE_ADD_BORS(8,  S, X, h)
+dnl
+
+instruct reduce_add2L(iRegLNoSp dst, iRegL isrc, vecX vsrc, vecX tmp)
+%{
+  match(Set dst (AddReductionVL isrc vsrc));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst, TEMP tmp);
+  format %{ "addpd $tmp, $vsrc\n\t"
+            "umov  $dst, $tmp, D, 0\n\t"
+            "add   $dst, $isrc, $dst\t# add reduction2L"
+  %}
+  ins_encode %{
+    __ addpd(as_FloatRegister($tmp$$reg), as_FloatRegister($vsrc$$reg));
+    __ umov($dst$$Register, as_FloatRegister($tmp$$reg), __ D, 0);
+    __ add($dst$$Register, $isrc$$Register, $dst$$Register);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct reduce_mul8B(iRegINoSp dst, iRegIorL2I isrc, vecD vsrc, vecD vtmp1, vecD vtmp2, iRegINoSp itmp)
+%{
+  predicate(n->in(2)->bottom_type()->is_vect()->element_basic_type() == T_BYTE);
+  match(Set dst (MulReductionVI isrc vsrc));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst, TEMP vtmp1, TEMP vtmp2, TEMP itmp);
+  format %{ "ins   $vtmp1, S, $vsrc, 0, 1\n\t"
+            "mulv  $vtmp1, T8B, $vtmp1, $vsrc\n\t"
+            "ins   $vtmp2, H, $vtmp1, 0, 1\n\t"
+            "mulv  $vtmp2, T8B, $vtmp2, $vtmp1\n\t"
+            "umov  $itmp, $vtmp2, B, 0\n\t"
+            "mulw  $dst, $itmp, $isrc\n\t"
+            "sxtb  $dst, $dst\n\t"
+            "umov  $itmp, $vtmp2, B, 1\n\t"
+            "mulw  $dst, $itmp, $dst\n\t"
+            "sxtb  $dst, $dst\t# mul reduction8B"
+  %}
+  ins_encode %{
+    __ ins(as_FloatRegister($vtmp1$$reg), __ S,
+           as_FloatRegister($vsrc$$reg), 0, 1);
+    __ mulv(as_FloatRegister($vtmp1$$reg), __ T8B,
+            as_FloatRegister($vtmp1$$reg), as_FloatRegister($vsrc$$reg));
+    __ ins(as_FloatRegister($vtmp2$$reg), __ H,
+           as_FloatRegister($vtmp1$$reg), 0, 1);
+    __ mulv(as_FloatRegister($vtmp2$$reg), __ T8B,
+            as_FloatRegister($vtmp2$$reg), as_FloatRegister($vtmp1$$reg));
+    __ umov($itmp$$Register, as_FloatRegister($vtmp2$$reg), __ B, 0);
+    __ mulw($dst$$Register, $itmp$$Register, $isrc$$Register);
+    __ sxtb($dst$$Register, $dst$$Register);
+    __ umov($itmp$$Register, as_FloatRegister($vtmp2$$reg), __ B, 1);
+    __ mulw($dst$$Register, $itmp$$Register, $dst$$Register);
+    __ sxtb($dst$$Register, $dst$$Register);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct reduce_mul16B(iRegINoSp dst, iRegIorL2I isrc, vecX vsrc, vecX vtmp1, vecX vtmp2, iRegINoSp itmp)
+%{
+  predicate(n->in(2)->bottom_type()->is_vect()->element_basic_type() == T_BYTE);
+  match(Set dst (MulReductionVI isrc vsrc));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst, TEMP vtmp1, TEMP vtmp2, TEMP itmp);
+  format %{ "ins   $vtmp1, D, $vsrc, 0, 1\n\t"
+            "mulv  $vtmp1, T8B, $vtmp1, $vsrc\n\t"
+            "ins   $vtmp2, S, $vtmp1, 0, 1\n\t"
+            "mulv  $vtmp1, T8B, $vtmp2, $vtmp1\n\t"
+            "ins   $vtmp2, H, $vtmp1, 0, 1\n\t"
+            "mulv  $vtmp2, T8B, $vtmp2, $vtmp1\n\t"
+            "umov  $itmp, $vtmp2, B, 0\n\t"
+            "mulw  $dst, $itmp, $isrc\n\t"
+            "sxtb  $dst, $dst\n\t"
+            "umov  $itmp, $vtmp2, B, 1\n\t"
+            "mulw  $dst, $itmp, $dst\n\t"
+            "sxtb  $dst, $dst\t# mul reduction16B"
+  %}
+  ins_encode %{
+    __ ins(as_FloatRegister($vtmp1$$reg), __ D,
+           as_FloatRegister($vsrc$$reg), 0, 1);
+    __ mulv(as_FloatRegister($vtmp1$$reg), __ T8B,
+            as_FloatRegister($vtmp1$$reg), as_FloatRegister($vsrc$$reg));
+    __ ins(as_FloatRegister($vtmp2$$reg), __ S,
+           as_FloatRegister($vtmp1$$reg), 0, 1);
+    __ mulv(as_FloatRegister($vtmp1$$reg), __ T8B,
+            as_FloatRegister($vtmp2$$reg), as_FloatRegister($vtmp1$$reg));
+    __ ins(as_FloatRegister($vtmp2$$reg), __ H,
+           as_FloatRegister($vtmp1$$reg), 0, 1);
+    __ mulv(as_FloatRegister($vtmp2$$reg), __ T8B,
+            as_FloatRegister($vtmp2$$reg), as_FloatRegister($vtmp1$$reg));
+    __ umov($itmp$$Register, as_FloatRegister($vtmp2$$reg), __ B, 0);
+    __ mulw($dst$$Register, $itmp$$Register, $isrc$$Register);
+    __ sxtb($dst$$Register, $dst$$Register);
+    __ umov($itmp$$Register, as_FloatRegister($vtmp2$$reg), __ B, 1);
+    __ mulw($dst$$Register, $itmp$$Register, $dst$$Register);
+    __ sxtb($dst$$Register, $dst$$Register);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct reduce_mul4S(iRegINoSp dst, iRegIorL2I isrc, vecD vsrc, vecD vtmp, iRegINoSp itmp)
+%{
+  predicate(n->in(2)->bottom_type()->is_vect()->element_basic_type() == T_SHORT);
+  match(Set dst (MulReductionVI isrc vsrc));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst, TEMP vtmp, TEMP itmp);
+  format %{ "ins   $vtmp, S, $vsrc, 0, 1\n\t"
+            "mulv  $vtmp, T4H, $vtmp, $vsrc\n\t"
+            "umov  $itmp, $vtmp, H, 0\n\t"
+            "mulw  $dst, $itmp, $isrc\n\t"
+            "sxth  $dst, $dst\n\t"
+            "umov  $itmp, $vtmp, H, 1\n\t"
+            "mulw  $dst, $itmp, $dst\n\t"
+            "sxth  $dst, $dst\t# mul reduction4S"
+  %}
+  ins_encode %{
+    __ ins(as_FloatRegister($vtmp$$reg), __ S,
+           as_FloatRegister($vsrc$$reg), 0, 1);
+    __ mulv(as_FloatRegister($vtmp$$reg), __ T4H,
+            as_FloatRegister($vtmp$$reg), as_FloatRegister($vsrc$$reg));
+    __ umov($itmp$$Register, as_FloatRegister($vtmp$$reg), __ H, 0);
+    __ mulw($dst$$Register, $itmp$$Register, $isrc$$Register);
+    __ sxth($dst$$Register, $dst$$Register);
+    __ umov($itmp$$Register, as_FloatRegister($vtmp$$reg), __ H, 1);
+    __ mulw($dst$$Register, $itmp$$Register, $dst$$Register);
+    __ sxth($dst$$Register, $dst$$Register);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct reduce_mul8S(iRegINoSp dst, iRegIorL2I isrc, vecX vsrc, vecX vtmp1, vecX vtmp2, iRegINoSp itmp)
+%{
+  predicate(n->in(2)->bottom_type()->is_vect()->element_basic_type() == T_SHORT);
+  match(Set dst (MulReductionVI isrc vsrc));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst, TEMP vtmp1, TEMP vtmp2, TEMP itmp);
+  format %{ "ins   $vtmp1, D, $vsrc, 0, 1\n\t"
+            "mulv  $vtmp1, T4H, $vtmp1, $vsrc\n\t"
+            "ins   $vtmp2, S, $vtmp1, 0, 1\n\t"
+            "mulv  $vtmp2, T4H, $vtmp2, $vtmp1\n\t"
+            "umov  $itmp, $vtmp2, H, 0\n\t"
+            "mulw  $dst, $itmp, $isrc\n\t"
+            "sxth  $dst, $dst\n\t"
+            "umov  $itmp, $vtmp2, H, 1\n\t"
+            "mulw  $dst, $itmp, $dst\n\t"
+            "sxth  $dst, $dst\t# mul reduction8S"
+  %}
+  ins_encode %{
+    __ ins(as_FloatRegister($vtmp1$$reg), __ D,
+           as_FloatRegister($vsrc$$reg), 0, 1);
+    __ mulv(as_FloatRegister($vtmp1$$reg), __ T4H,
+            as_FloatRegister($vtmp1$$reg), as_FloatRegister($vsrc$$reg));
+    __ ins(as_FloatRegister($vtmp2$$reg), __ S,
+           as_FloatRegister($vtmp1$$reg), 0, 1);
+    __ mulv(as_FloatRegister($vtmp2$$reg), __ T4H,
+            as_FloatRegister($vtmp2$$reg), as_FloatRegister($vtmp1$$reg));
+    __ umov($itmp$$Register, as_FloatRegister($vtmp2$$reg), __ H, 0);
+    __ mulw($dst$$Register, $itmp$$Register, $isrc$$Register);
+    __ sxth($dst$$Register, $dst$$Register);
+    __ umov($itmp$$Register, as_FloatRegister($vtmp2$$reg), __ H, 1);
+    __ mulw($dst$$Register, $itmp$$Register, $dst$$Register);
+    __ sxth($dst$$Register, $dst$$Register);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct reduce_mul2L(iRegLNoSp dst, iRegL isrc, vecX vsrc, iRegLNoSp tmp)
+%{
+  match(Set dst (MulReductionVL isrc vsrc));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst, TEMP tmp);
+  format %{ "umov  $tmp, $vsrc, D, 0\n\t"
+            "mul   $dst, $isrc, $tmp\n\t"
+            "umov  $tmp, $vsrc, D, 1\n\t"
+            "mul   $dst, $dst, $tmp\t# mul reduction2L"
+  %}
+  ins_encode %{
+    __ umov($tmp$$Register, as_FloatRegister($vsrc$$reg), __ D, 0);
+    __ mul($dst$$Register, $isrc$$Register, $tmp$$Register);
+    __ umov($tmp$$Register, as_FloatRegister($vsrc$$reg), __ D, 1);
+    __ mul($dst$$Register, $dst$$Register, $tmp$$Register);
+  %}
+  ins_pipe(pipe_slow);
+%}
+dnl
+define(`REDUCE_MAX_MIN_INT', `
+instruct reduce_$1$2$3`'(iRegINoSp dst, iRegIorL2I isrc, vec$4 vsrc, vec$4 tmp, rFlagsReg cr)
+%{
+  predicate(n->in(2)->bottom_type()->is_vect()->element_basic_type() == T_`'TYPE2DATATYPE($3));
+  match(Set dst ($5ReductionV isrc vsrc));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst, TEMP tmp, KILL cr);
+  format %{ "s$1v $tmp, T$2`'iTYPE2SIMD($3), $vsrc\n\t"
+            "$6mov  $dst, $tmp, iTYPE2SIMD($3), 0\n\t"
+            "cmpw  $dst, $isrc\n\t"
+            "cselw $dst, $dst, $isrc $7\t# $1 reduction$2$3"
+  %}
+  ins_encode %{
+    __ s$1v(as_FloatRegister($tmp$$reg), __ T$2`'iTYPE2SIMD($3), as_FloatRegister($vsrc$$reg));
+    __ $6mov(as_Register($dst$$reg), as_FloatRegister($tmp$$reg), __ iTYPE2SIMD($3), 0);
+    __ cmpw(as_Register($dst$$reg), as_Register($isrc$$reg));
+    __ cselw(as_Register($dst$$reg), as_Register($dst$$reg), as_Register($isrc$$reg), Assembler::$7);
+  %}
+  ins_pipe(pipe_slow);
+%}')dnl
+dnl                $1   $2  $3 $4 $5   $6 $7
+REDUCE_MAX_MIN_INT(max, 8,  B, D, Max, s, GT)
+REDUCE_MAX_MIN_INT(max, 16, B, X, Max, s, GT)
+REDUCE_MAX_MIN_INT(max, 4,  S, D, Max, s, GT)
+REDUCE_MAX_MIN_INT(max, 8,  S, X, Max, s, GT)
+REDUCE_MAX_MIN_INT(max, 4,  I, X, Max, u, GT)
+REDUCE_MAX_MIN_INT(min, 8,  B, D, Min, s, LT)
+REDUCE_MAX_MIN_INT(min, 16, B, X, Min, s, LT)
+REDUCE_MAX_MIN_INT(min, 4,  S, D, Min, s, LT)
+REDUCE_MAX_MIN_INT(min, 8,  S, X, Min, s, LT)
+REDUCE_MAX_MIN_INT(min, 4,  I, X, Min, u, LT)
+dnl
+define(`REDUCE_MAX_MIN_2I', `
+instruct reduce_$1`'2I(iRegINoSp dst, iRegIorL2I isrc, vecD vsrc, vecX tmp, rFlagsReg cr)
+%{
+  predicate(n->in(2)->bottom_type()->is_vect()->element_basic_type() == T_INT);
+  match(Set dst ($2ReductionV isrc vsrc));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst, TEMP tmp, KILL cr);
+  format %{ "dup   $tmp, T2D, $vsrc\n\t"
+            "s$1v $tmp, T4S, $tmp\n\t"
+            "umov  $dst, $tmp, S, 0\n\t"
+            "cmpw  $dst, $isrc\n\t"
+            "cselw $dst, $dst, $isrc $3\t# $1 reduction2I"
+  %}
+  ins_encode %{
+    __ dup(as_FloatRegister($tmp$$reg), __ T2D, as_FloatRegister($vsrc$$reg));
+    __ s$1v(as_FloatRegister($tmp$$reg), __ T4S, as_FloatRegister($tmp$$reg));
+    __ umov(as_Register($dst$$reg), as_FloatRegister($tmp$$reg), __ S, 0);
+    __ cmpw(as_Register($dst$$reg), as_Register($isrc$$reg));
+    __ cselw(as_Register($dst$$reg), as_Register($dst$$reg), as_Register($isrc$$reg), Assembler::$3);
+  %}
+  ins_pipe(pipe_slow);
+%}')dnl
+dnl               $1   $2   $3
+REDUCE_MAX_MIN_2I(max, Max, GT)
+REDUCE_MAX_MIN_2I(min, Min, LT)
+dnl
+define(`REDUCE_MAX_MIN_2L', `
+instruct reduce_$1`'2L(iRegLNoSp dst, iRegL isrc, vecX vsrc, iRegLNoSp tmp, rFlagsReg cr)
+%{
+  predicate(n->in(2)->bottom_type()->is_vect()->element_basic_type() == T_LONG);
+  match(Set dst ($2ReductionV isrc vsrc));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst, TEMP tmp, KILL cr);
+  format %{ "umov  $tmp, $vsrc, D, 0\n\t"
+            "cmp   $isrc,$tmp\n\t"
+            "csel  $dst, $isrc, $tmp $3\n\t"
+            "umov  $tmp, $vsrc, D, 1\n\t"
+            "cmp   $dst, $tmp\n\t"
+            "csel  $dst, $dst, $tmp $3\t# $1 reduction2L"
+  %}
+  ins_encode %{
+    __ umov(as_Register($tmp$$reg), as_FloatRegister($vsrc$$reg), __ D, 0);
+    __ cmp(as_Register($isrc$$reg), as_Register($tmp$$reg));
+    __ csel(as_Register($dst$$reg), as_Register($isrc$$reg), as_Register($tmp$$reg), Assembler::$3);
+    __ umov(as_Register($tmp$$reg), as_FloatRegister($vsrc$$reg), __ D, 1);
+    __ cmp(as_Register($dst$$reg), as_Register($tmp$$reg));
+    __ csel(as_Register($dst$$reg), as_Register($dst$$reg), as_Register($tmp$$reg), Assembler::$3);
+  %}
+  ins_pipe(pipe_slow);
+%}')dnl
+dnl               $1   $2   $3
+REDUCE_MAX_MIN_2L(max, Max, GT)
+REDUCE_MAX_MIN_2L(min, Min, LT)
+dnl
+define(`REDUCE_LOGIC_OP_8B', `
+instruct reduce_$1`'8B(iRegINoSp dst, iRegIorL2I isrc, vecD vsrc, iRegINoSp tmp)
+%{
+  predicate(n->in(2)->bottom_type()->is_vect()->element_basic_type() == T_BYTE);
+  match(Set dst ($2ReductionV isrc vsrc));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst, TEMP tmp);
+  format %{ "umov   $tmp, $vsrc, S, 0\n\t"
+            "umov   $dst, $vsrc, S, 1\n\t"
+            "$1w   $dst, $dst, $tmp\n\t"
+            "$1w   $dst, $dst, $dst, LSR #16\n\t"
+            "$1w   $dst, $dst, $dst, LSR #8\n\t"
+            "$1w   $dst, $isrc, $dst\n\t"
+            "sxtb   $dst, $dst\t# $1 reduction8B"
+  %}
+  ins_encode %{
+    __ umov($tmp$$Register, as_FloatRegister($vsrc$$reg), __ S, 0);
+    __ umov($dst$$Register, as_FloatRegister($vsrc$$reg), __ S, 1);
+    __ $1w($dst$$Register, $dst$$Register, $tmp$$Register);
+    __ $1w($dst$$Register, $dst$$Register, $dst$$Register, Assembler::LSR, 16);
+    __ $1w($dst$$Register, $dst$$Register, $dst$$Register, Assembler::LSR, 8);
+    __ $1w($dst$$Register, $isrc$$Register, $dst$$Register);
+    __ sxtb($dst$$Register, $dst$$Register);
+  %}
+  ins_pipe(pipe_slow);
+%}')dnl
+dnl                $1   $2
+REDUCE_LOGIC_OP_8B(and, And)
+REDUCE_LOGIC_OP_8B(orr, Or)
+REDUCE_LOGIC_OP_8B(eor, Xor)
+define(`REDUCE_LOGIC_OP_16B', `
+instruct reduce_$1`'16B(iRegINoSp dst, iRegIorL2I isrc, vecX vsrc, iRegINoSp tmp)
+%{
+  predicate(n->in(2)->bottom_type()->is_vect()->element_basic_type() == T_BYTE);
+  match(Set dst ($2ReductionV isrc vsrc));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst, TEMP tmp);
+  format %{ "umov   $tmp, $vsrc, D, 0\n\t"
+            "umov   $dst, $vsrc, D, 1\n\t"
+            "$3   $dst, $dst, $tmp\n\t"
+            "$3   $dst, $dst, $dst, LSR #32\n\t"
+            "$1w   $dst, $dst, $dst, LSR #16\n\t"
+            "$1w   $dst, $dst, $dst, LSR #8\n\t"
+            "$1w   $dst, $isrc, $dst\n\t"
+            "sxtb   $dst, $dst\t# $1 reduction16B"
+  %}
+  ins_encode %{
+    __ umov($tmp$$Register, as_FloatRegister($vsrc$$reg), __ D, 0);
+    __ umov($dst$$Register, as_FloatRegister($vsrc$$reg), __ D, 1);
+    __ $3($dst$$Register, $dst$$Register, $tmp$$Register);
+    __ $3($dst$$Register, $dst$$Register, $dst$$Register, Assembler::LSR, 32);
+    __ $1w($dst$$Register, $dst$$Register, $dst$$Register, Assembler::LSR, 16);
+    __ $1w($dst$$Register, $dst$$Register, $dst$$Register, Assembler::LSR, 8);
+    __ $1w($dst$$Register, $isrc$$Register, $dst$$Register);
+    __ sxtb($dst$$Register, $dst$$Register);
+  %}
+  ins_pipe(pipe_slow);
+%}')dnl
+dnl                 $1   $2   $3
+REDUCE_LOGIC_OP_16B(and, And, andr)
+REDUCE_LOGIC_OP_16B(orr, Or,  orr )
+REDUCE_LOGIC_OP_16B(eor, Xor, eor )
+dnl
+define(`REDUCE_LOGIC_OP_4S', `
+instruct reduce_$1`'4S(iRegINoSp dst, iRegIorL2I isrc, vecD vsrc, iRegINoSp tmp)
+%{
+  predicate(n->in(2)->bottom_type()->is_vect()->element_basic_type() == T_SHORT);
+  match(Set dst ($2ReductionV isrc vsrc));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst, TEMP tmp);
+  format %{ "umov   $tmp, $vsrc, S, 0\n\t"
+            "umov   $dst, $vsrc, S, 1\n\t"
+            "$1w   $dst, $dst, $tmp\n\t"
+            "$1w   $dst, $dst, $dst, LSR #16\n\t"
+            "$1w   $dst, $isrc, $dst\n\t"
+            "sxth   $dst, $dst\t# $1 reduction4S"
+  %}
+  ins_encode %{
+    __ umov($tmp$$Register, as_FloatRegister($vsrc$$reg), __ S, 0);
+    __ umov($dst$$Register, as_FloatRegister($vsrc$$reg), __ S, 1);
+    __ $1w($dst$$Register, $dst$$Register, $tmp$$Register);
+    __ $1w($dst$$Register, $dst$$Register, $dst$$Register, Assembler::LSR, 16);
+    __ $1w($dst$$Register, $isrc$$Register, $dst$$Register);
+    __ sxth($dst$$Register, $dst$$Register);
+  %}
+  ins_pipe(pipe_slow);
+%}')dnl
+dnl                $1   $2
+REDUCE_LOGIC_OP_4S(and, And)
+REDUCE_LOGIC_OP_4S(orr, Or)
+REDUCE_LOGIC_OP_4S(eor, Xor)
+dnl
+define(`REDUCE_LOGIC_OP_8S', `
+instruct reduce_$1`'8S(iRegINoSp dst, iRegIorL2I isrc, vecX vsrc, iRegINoSp tmp)
+%{
+  predicate(n->in(2)->bottom_type()->is_vect()->element_basic_type() == T_SHORT);
+  match(Set dst ($2ReductionV isrc vsrc));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst, TEMP tmp);
+  format %{ "umov   $tmp, $vsrc, D, 0\n\t"
+            "umov   $dst, $vsrc, D, 1\n\t"
+            "$3   $dst, $dst, $tmp\n\t"
+            "$3   $dst, $dst, $dst, LSR #32\n\t"
+            "$1w   $dst, $dst, $dst, LSR #16\n\t"
+            "$1w   $dst, $isrc, $dst\n\t"
+            "sxth   $dst, $dst\t# $1 reduction8S"
+  %}
+  ins_encode %{
+    __ umov($tmp$$Register, as_FloatRegister($vsrc$$reg), __ D, 0);
+    __ umov($dst$$Register, as_FloatRegister($vsrc$$reg), __ D, 1);
+    __ $3($dst$$Register, $dst$$Register, $tmp$$Register);
+    __ $3($dst$$Register, $dst$$Register, $dst$$Register, Assembler::LSR, 32);
+    __ $1w($dst$$Register, $dst$$Register, $dst$$Register, Assembler::LSR, 16);
+    __ $1w($dst$$Register, $isrc$$Register, $dst$$Register);
+    __ sxth($dst$$Register, $dst$$Register);
+  %}
+  ins_pipe(pipe_slow);
+%}')dnl
+dnl                $1   $2   $3
+REDUCE_LOGIC_OP_8S(and, And, andr)
+REDUCE_LOGIC_OP_8S(orr, Or,  orr )
+REDUCE_LOGIC_OP_8S(eor, Xor, eor )
+dnl
+define(`REDUCE_LOGIC_OP_2I', `
+instruct reduce_$1`'2I(iRegINoSp dst, iRegIorL2I isrc, vecD vsrc, iRegINoSp tmp)
+%{
+  predicate(n->in(2)->bottom_type()->is_vect()->element_basic_type() == T_INT);
+  match(Set dst ($2ReductionV isrc vsrc));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst, TEMP tmp);
+  format %{ "umov  $tmp, $vsrc, S, 0\n\t"
+            "$1w  $dst, $tmp, $isrc\n\t"
+            "umov  $tmp, $vsrc, S, 1\n\t"
+            "$1w  $dst, $tmp, $dst\t# $1 reduction2I"
+  %}
+  ins_encode %{
+    __ umov($tmp$$Register, as_FloatRegister($vsrc$$reg), __ S, 0);
+    __ $1w($dst$$Register, $tmp$$Register, $isrc$$Register);
+    __ umov($tmp$$Register, as_FloatRegister($vsrc$$reg), __ S, 1);
+    __ $1w($dst$$Register, $tmp$$Register, $dst$$Register);
+  %}
+  ins_pipe(pipe_slow);
+%}')dnl
+dnl                $1   $2
+REDUCE_LOGIC_OP_2I(and, And)
+REDUCE_LOGIC_OP_2I(orr, Or)
+REDUCE_LOGIC_OP_2I(eor, Xor)
+dnl
+define(`REDUCE_LOGIC_OP_4I', `
+instruct reduce_$1`'4I(iRegINoSp dst, iRegIorL2I isrc, vecX vsrc, iRegINoSp tmp)
+%{
+  predicate(n->in(2)->bottom_type()->is_vect()->element_basic_type() == T_INT);
+  match(Set dst ($2ReductionV isrc vsrc));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst, TEMP tmp);
+  format %{ "umov   $tmp, $vsrc, D, 0\n\t"
+            "umov   $dst, $vsrc, D, 1\n\t"
+            "$3   $dst, $dst, $tmp\n\t"
+            "$3   $dst, $dst, $dst, LSR #32\n\t"
+            "$1w   $dst, $isrc, $dst\t# $1 reduction4I"
+  %}
+  ins_encode %{
+    __ umov($tmp$$Register, as_FloatRegister($vsrc$$reg), __ D, 0);
+    __ umov($dst$$Register, as_FloatRegister($vsrc$$reg), __ D, 1);
+    __ $3($dst$$Register, $dst$$Register, $tmp$$Register);
+    __ $3($dst$$Register, $dst$$Register, $dst$$Register, Assembler::LSR, 32);
+    __ $1w($dst$$Register, $isrc$$Register, $dst$$Register);
+  %}
+  ins_pipe(pipe_slow);
+%}')dnl
+dnl                $1   $2   $3
+REDUCE_LOGIC_OP_4I(and, And, andr)
+REDUCE_LOGIC_OP_4I(orr, Or,  orr )
+REDUCE_LOGIC_OP_4I(eor, Xor, eor )
+dnl
+define(`REDUCE_LOGIC_OP_2L', `
+instruct reduce_$1`'2L(iRegLNoSp dst, iRegL isrc, vecX vsrc, iRegLNoSp tmp)
+%{
+  predicate(n->in(2)->bottom_type()->is_vect()->element_basic_type() == T_LONG);
+  match(Set dst ($2ReductionV isrc vsrc));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst, TEMP tmp);
+  format %{ "umov  $tmp, $vsrc, D, 0\n\t"
+            "$3  $dst, $isrc, $tmp\n\t"
+            "umov  $tmp, $vsrc, D, 1\n\t"
+            "$3  $dst, $dst, $tmp\t# $1 reduction2L"
+  %}
+  ins_encode %{
+    __ umov($tmp$$Register, as_FloatRegister($vsrc$$reg), __ D, 0);
+    __ $3($dst$$Register, $isrc$$Register, $tmp$$Register);
+    __ umov($tmp$$Register, as_FloatRegister($vsrc$$reg), __ D, 1);
+    __ $3($dst$$Register, $dst$$Register, $tmp$$Register);
+  %}
+  ins_pipe(pipe_slow);
+%}')dnl
+dnl                $1   $2   $3
+REDUCE_LOGIC_OP_2L(and, And, andr)
+REDUCE_LOGIC_OP_2L(orr, Or,  orr )
+REDUCE_LOGIC_OP_2L(eor, Xor, eor )
+dnl
+
+// ------------------------------ Vector insert ---------------------------------
+define(`VECTOR_INSERT_I', `
+instruct insert$1$2`'(vec$3 dst, vec$3 src, iReg$4`'ORL2I($4) val, immI idx)
+%{
+  predicate(n->bottom_type()->is_vect()->element_basic_type() == T_`'TYPE2DATATYPE($2));
+  match(Set dst (VectorInsert (Binary src val) idx));
+  ins_cost(INSN_COST);
+  format %{ "orr    $dst, T$5, $src, $src\n\t"
+            "mov    $dst, T$1`'iTYPE2SIMD($2), $idx, $val\t# insert into vector($1$2)" %}
+  ins_encode %{
+    if (as_FloatRegister($dst$$reg) != as_FloatRegister($src$$reg)) {
+      __ orr(as_FloatRegister($dst$$reg), __ T$5,
+             as_FloatRegister($src$$reg), as_FloatRegister($src$$reg));
+    }
+    __ mov(as_FloatRegister($dst$$reg), __ T$1`'iTYPE2SIMD($2), $idx$$constant, $val$$Register);
+  %}
+  ins_pipe(pipe_slow);
+%}')dnl
+dnl             $1  $2 $3 $4 $5
+VECTOR_INSERT_I(8,  B, D, I, 8B)
+VECTOR_INSERT_I(16, B, X, I, 16B)
+VECTOR_INSERT_I(4,  S, D, I, 8B)
+VECTOR_INSERT_I(8,  S, X, I, 16B)
+VECTOR_INSERT_I(2,  I, D, I, 8B)
+VECTOR_INSERT_I(4,  I, X, I, 16B)
+VECTOR_INSERT_I(2,  L, X, L, 16B)
+dnl
+define(`VECTOR_INSERT_F', `
+instruct insert$1`'(vec$2 dst, vec$2 src, vReg$3 val, immI idx)
+%{
+  predicate(n->bottom_type()->is_vect()->element_basic_type() == T_`'TYPE2DATATYPE($3));
+  match(Set dst (VectorInsert (Binary src val) idx));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst);
+  format %{ "orr    $dst, T$4, $src, $src\n\t"
+            "ins    $dst, $5, $val, $idx, 0\t# insert into vector($1)" %}
+  ins_encode %{
+    __ orr(as_FloatRegister($dst$$reg), __ T$4,
+           as_FloatRegister($src$$reg), as_FloatRegister($src$$reg));
+    __ ins(as_FloatRegister($dst$$reg), __ $5,
+           as_FloatRegister($val$$reg), $idx$$constant, 0);
+  %}
+  ins_pipe(pipe_slow);
+%}')dnl
+dnl             $1  $2 $3 $4   $5
+VECTOR_INSERT_F(2F, D, F, 8B,  S)
+VECTOR_INSERT_F(4F, X, F, 16B, S)
+VECTOR_INSERT_F(2D, X, D, 16B, D)
+dnl
+
+// ------------------------------ Vector extract ---------------------------------
+define(`VECTOR_EXTRACT_I', `
+instruct extract$1$2`'(iReg$3NoSp dst, vec$4 src, immI idx)
+%{
+  predicate(n->in(1)->bottom_type()->is_vect()->length() == $1);
+  match(Set dst (Extract$2 src idx));
+  ins_cost(INSN_COST);
+  format %{ "$5mov    $dst, $src, $6, $idx\t# extract from vector($1$2)" %}
+  ins_encode %{
+    __ $5mov($dst$$Register, as_FloatRegister($src$$reg), __ $6, $idx$$constant);
+  %}
+  ins_pipe(pipe_class_default);
+%}')dnl
+dnl             $1   $2 $3 $4 $5 $6
+VECTOR_EXTRACT_I(8,  B, I, D, s, B)
+VECTOR_EXTRACT_I(16, B, I, X, s, B)
+VECTOR_EXTRACT_I(4,  S, I, D, s, H)
+VECTOR_EXTRACT_I(8,  S, I, X, s, H)
+VECTOR_EXTRACT_I(2,  I, I, D, u, S)
+VECTOR_EXTRACT_I(4,  I, I, X, u, S)
+VECTOR_EXTRACT_I(2,  L, L, X, u, D)
+dnl
+define(`VECTOR_EXTRACT_F', `
+instruct extract$1$2`'(vReg$2 dst, vec$3 src, immI idx)
+%{
+  predicate(n->in(1)->bottom_type()->is_vect()->length() == $1);
+  match(Set dst (Extract$2 src idx));
+  ins_cost(INSN_COST);
+  format %{ "ins   $dst, $4, $src, 0, $idx\t# extract from vector($1$2)" %}
+  ins_encode %{
+    __ ins(as_FloatRegister($dst$$reg), __ $4,
+           as_FloatRegister($src$$reg), 0, $idx$$constant);
+  %}
+  ins_pipe(pipe_class_default);
+%}')dnl
+dnl             $1  $2 $3 $4
+VECTOR_EXTRACT_F(2, F, D, S)
+VECTOR_EXTRACT_F(4, F, X, S)
+VECTOR_EXTRACT_F(2, D, X, D)
+dnl
+
+// ------------------------------ Vector comparison ---------------------------------
+define(`VECTOR_CMP_EQ_GT_GE', `
+instruct vcm$1$2$3`'(vec$4 dst, vec$4 src1, vec$4 src2, immI cond)
+%{
+  predicate(n->as_Vector()->length() == $2 &&
+            n->as_VectorMaskCmp()->get_predicate() == BoolTest::$1 &&
+            n->in(1)->in(1)->bottom_type()->is_vect()->element_basic_type() == T_`'TYPE2DATATYPE($3));
+  match(Set dst (VectorMaskCmp (Binary src1 src2) cond));
+  format %{ "$6cm$1  $dst, $src1, $src2\t# vector cmp ($2$3)" %}
+  ins_cost(INSN_COST);
+  ins_encode %{
+    __ $6cm$1(as_FloatRegister($dst$$reg), __ T$2$5,
+            as_FloatRegister($src1$$reg), as_FloatRegister($src2$$reg));
+  %}
+  ins_pipe(vdop$7);
+%}')dnl
+dnl                $1   $2 $3 $4 $5 $6 $7
+VECTOR_CMP_EQ_GT_GE(eq, 8, B, D, B,  , 64)
+VECTOR_CMP_EQ_GT_GE(eq, 16,B, X, B,  , 128)
+VECTOR_CMP_EQ_GT_GE(eq, 4, S, D, H,  , 64)
+VECTOR_CMP_EQ_GT_GE(eq, 8, S, X, H,  , 128)
+VECTOR_CMP_EQ_GT_GE(eq, 2, I, D, S,  , 64)
+VECTOR_CMP_EQ_GT_GE(eq, 4, I, X, S,  , 128)
+VECTOR_CMP_EQ_GT_GE(eq, 2, L, X, D,  , 128)
+VECTOR_CMP_EQ_GT_GE(eq, 2, F, D, S, f, 64)
+VECTOR_CMP_EQ_GT_GE(eq, 4, F, X, S, f, 128)
+VECTOR_CMP_EQ_GT_GE(eq, 2, D, X, D, f, 128)
+VECTOR_CMP_EQ_GT_GE(gt, 8, B, D, B,  , 64)
+VECTOR_CMP_EQ_GT_GE(gt, 16,B, X, B,  , 128)
+VECTOR_CMP_EQ_GT_GE(gt, 4, S, D, H,  , 64)
+VECTOR_CMP_EQ_GT_GE(gt, 8, S, X, H,  , 128)
+VECTOR_CMP_EQ_GT_GE(gt, 2, I, D, S,  , 64)
+VECTOR_CMP_EQ_GT_GE(gt, 4, I, X, S,  , 128)
+VECTOR_CMP_EQ_GT_GE(gt, 2, L, X, D,  , 128)
+VECTOR_CMP_EQ_GT_GE(gt, 2, F, D, S, f, 64)
+VECTOR_CMP_EQ_GT_GE(gt, 4, F, X, S, f, 128)
+VECTOR_CMP_EQ_GT_GE(gt, 2, D, X, D, f, 128)
+VECTOR_CMP_EQ_GT_GE(ge, 8, B, D, B,  , 64)
+VECTOR_CMP_EQ_GT_GE(ge, 16,B, X, B,  , 128)
+VECTOR_CMP_EQ_GT_GE(ge, 4, S, D, H,  , 64)
+VECTOR_CMP_EQ_GT_GE(ge, 8, S, X, H,  , 128)
+VECTOR_CMP_EQ_GT_GE(ge, 2, I, D, S,  , 64)
+VECTOR_CMP_EQ_GT_GE(ge, 4, I, X, S,  , 128)
+VECTOR_CMP_EQ_GT_GE(ge, 2, L, X, D,  , 128)
+VECTOR_CMP_EQ_GT_GE(ge, 2, F, D, S, f, 64)
+VECTOR_CMP_EQ_GT_GE(ge, 4, F, X, S, f, 128)
+VECTOR_CMP_EQ_GT_GE(ge, 2, D, X, D, f, 128)
+dnl
+define(`VECTOR_CMP_NE', `
+instruct vcmne$1$2`'(vec$3 dst, vec$3 src1, vec$3 src2, immI cond)
+%{
+  predicate(n->as_Vector()->length() == $1 &&
+            n->as_VectorMaskCmp()->get_predicate() == BoolTest::ne &&
+            n->in(1)->in(1)->bottom_type()->is_vect()->element_basic_type() == T_`'TYPE2DATATYPE($2));
+  match(Set dst (VectorMaskCmp (Binary src1 src2) cond));
+  format %{ "$5cmeq  $dst, $src1, $src2\n\t# vector cmp ($1$2)"
+            "not   $dst, $dst\t" %}
+  ins_cost(INSN_COST);
+  ins_encode %{
+    __ $5cmeq(as_FloatRegister($dst$$reg), __ T$1$4,
+            as_FloatRegister($src1$$reg), as_FloatRegister($src2$$reg));
+    __ notr(as_FloatRegister($dst$$reg), __ T$6, as_FloatRegister($dst$$reg));
+  %}
+  ins_pipe(pipe_slow);
+%}')dnl
+dnl           $1 $2 $3 $4 $5 $6
+VECTOR_CMP_NE(8, B, D, B,  , 8B)
+VECTOR_CMP_NE(16,B, X, B,  , 16B)
+VECTOR_CMP_NE(4, S, D, H,  , 8B)
+VECTOR_CMP_NE(8, S, X, H,  , 16B)
+VECTOR_CMP_NE(2, I, D, S,  , 8B)
+VECTOR_CMP_NE(4, I, X, S,  , 16B)
+VECTOR_CMP_NE(2, L, X, D,  , 16B)
+VECTOR_CMP_NE(2, F, D, S, f, 8B)
+VECTOR_CMP_NE(4, F, X, S, f, 16B)
+VECTOR_CMP_NE(2, D, X, D, f, 16B)
+dnl
+define(`VECTOR_CMP_LT_LE', `
+instruct vcm$1$2$3`'(vec$4 dst, vec$4 src1, vec$4 src2, immI cond)
+%{
+  predicate(n->as_Vector()->length() == $2 &&
+            n->as_VectorMaskCmp()->get_predicate() == BoolTest::$1 &&
+            n->in(1)->in(1)->bottom_type()->is_vect()->element_basic_type() == T_`'TYPE2DATATYPE($3));
+  match(Set dst (VectorMaskCmp (Binary src1 src2) cond));
+  format %{ "$6cm$7  $dst, $src2, $src1\t# vector cmp ($2$3)" %}
+  ins_cost(INSN_COST);
+  ins_encode %{
+    __ $6cm$7(as_FloatRegister($dst$$reg), __ T$2$5,
+            as_FloatRegister($src2$$reg), as_FloatRegister($src1$$reg));
+  %}
+  ins_pipe(vdop$8);
+%}')dnl
+dnl              $1  $2 $3 $4 $5 $6 $7  $8
+VECTOR_CMP_LT_LE(lt, 8, B, D, B,  , gt, 64)
+VECTOR_CMP_LT_LE(lt, 16,B, X, B,  , gt, 128)
+VECTOR_CMP_LT_LE(lt, 4, S, D, H,  , gt, 64)
+VECTOR_CMP_LT_LE(lt, 8, S, X, H,  , gt, 128)
+VECTOR_CMP_LT_LE(lt, 2, I, D, S,  , gt, 64)
+VECTOR_CMP_LT_LE(lt, 4, I, X, S,  , gt, 128)
+VECTOR_CMP_LT_LE(lt, 2, L, X, D,  , gt, 128)
+VECTOR_CMP_LT_LE(lt, 2, F, D, S, f, gt, 64)
+VECTOR_CMP_LT_LE(lt, 4, F, X, S, f, gt, 128)
+VECTOR_CMP_LT_LE(lt, 2, D, X, D, f, gt, 128)
+VECTOR_CMP_LT_LE(le, 8, B, D, B,  , ge, 64)
+VECTOR_CMP_LT_LE(le, 16,B, X, B,  , ge, 128)
+VECTOR_CMP_LT_LE(le, 4, S, D, H,  , ge, 64)
+VECTOR_CMP_LT_LE(le, 8, S, X, H,  , ge, 128)
+VECTOR_CMP_LT_LE(le, 2, I, D, S,  , ge, 64)
+VECTOR_CMP_LT_LE(le, 4, I, X, S,  , ge, 128)
+VECTOR_CMP_LT_LE(le, 2, L, X, D,  , ge, 128)
+VECTOR_CMP_LT_LE(le, 2, F, D, S, f, ge, 64)
+VECTOR_CMP_LT_LE(le, 4, F, X, S, f, ge, 128)
+VECTOR_CMP_LT_LE(le, 2, D, X, D, f, ge, 128)
+dnl
+
+// ------------------------------ Vector mul -----------------------------------
+
+instruct vmul2L(vecX dst, vecX src1, vecX src2, iRegLNoSp tmp1, iRegLNoSp tmp2)
+%{
+  predicate(n->as_Vector()->length() == 2);
+  match(Set dst (MulVL src1 src2));
+  ins_cost(INSN_COST);
+  effect(TEMP tmp1, TEMP tmp2);
+  format %{ "umov   $tmp1, $src1, D, 0\n\t"
+            "umov   $tmp2, $src2, D, 0\n\t"
+            "mul    $tmp2, $tmp2, $tmp1\n\t"
+            "mov    $dst,  T2D,   0, $tmp2\t# insert into vector(2L)\n\t"
+            "umov   $tmp1, $src1, D, 1\n\t"
+            "umov   $tmp2, $src2, D, 1\n\t"
+            "mul    $tmp2, $tmp2, $tmp1\n\t"
+            "mov    $dst,  T2D,   1, $tmp2\t# insert into vector(2L)\n\t"
+  %}
+  ins_encode %{
+    __ umov($tmp1$$Register, as_FloatRegister($src1$$reg), __ D, 0);
+    __ umov($tmp2$$Register, as_FloatRegister($src2$$reg), __ D, 0);
+    __ mul(as_Register($tmp2$$reg), as_Register($tmp2$$reg), as_Register($tmp1$$reg));
+    __ mov(as_FloatRegister($dst$$reg), __ T2D, 0, $tmp2$$Register);
+    __ umov($tmp1$$Register, as_FloatRegister($src1$$reg), __ D, 1);
+    __ umov($tmp2$$Register, as_FloatRegister($src2$$reg), __ D, 1);
+    __ mul(as_Register($tmp2$$reg), as_Register($tmp2$$reg), as_Register($tmp1$$reg));
+    __ mov(as_FloatRegister($dst$$reg), __ T2D, 1, $tmp2$$Register);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+// --------------------------------- Vector not --------------------------------
+dnl
+define(`MATCH_RULE', `ifelse($1, I,
+`match(Set dst (XorV src (ReplicateB m1)));
+  match(Set dst (XorV src (ReplicateS m1)));
+  match(Set dst (XorV src (ReplicateI m1)));',
+`match(Set dst (XorV src (ReplicateL m1)));')')dnl
+dnl
+define(`VECTOR_NOT', `
+instruct vnot$1$2`'(vec$3 dst, vec$3 src, imm$2_M1 m1)
+%{
+  predicate(n->as_Vector()->length_in_bytes() == $4);
+  MATCH_RULE($2)
+  ins_cost(INSN_COST);
+  format %{ "not  $dst, $src\t# vector ($5)" %}
+  ins_encode %{
+    __ notr(as_FloatRegister($dst$$reg), __ T$5,
+            as_FloatRegister($src$$reg));
+  %}
+  ins_pipe(pipe_class_default);
+%}')dnl
+dnl        $1 $2 $3 $4  $5
+VECTOR_NOT(2, I, D, 8,  8B)
+VECTOR_NOT(4, I, X, 16, 16B)
+VECTOR_NOT(2, L, X, 16, 16B)
+undefine(MATCH_RULE)
+dnl
+// ------------------------------ Vector max/min -------------------------------
+dnl
+define(`PREDICATE', `ifelse($1, 8B,
+`predicate((n->as_Vector()->length() == 4 || n->as_Vector()->length() == 8) &&
+             n->bottom_type()->is_vect()->element_basic_type() == T_BYTE);',
+`predicate(n->as_Vector()->length() == $2 && n->bottom_type()->is_vect()->element_basic_type() == T_$3);')')dnl
+dnl
+define(`VECTOR_MAX_MIN_INT', `
+instruct v$1$2$3`'(vec$4 dst, vec$4 src1, vec$4 src2)
+%{
+  PREDICATE(`$2$3', $2, TYPE2DATATYPE($3))
+  match(Set dst ($5V src1 src2));
+  ins_cost(INSN_COST);
+  format %{ "$1v  $dst, $src1, $src2\t# vector ($2$3)" %}
+  ins_encode %{
+    __ $1v(as_FloatRegister($dst$$reg), __ T$2`'iTYPE2SIMD($3),
+            as_FloatRegister($src1$$reg),
+            as_FloatRegister($src2$$reg));
+  %}
+  ins_pipe(vdop$6);
+%}')dnl
+dnl                $1   $2  $3 $4 $5   $6
+VECTOR_MAX_MIN_INT(max, 8,  B, D, Max, 64)
+VECTOR_MAX_MIN_INT(max, 16, B, X, Max, 128)
+VECTOR_MAX_MIN_INT(max, 4,  S, D, Max, 64)
+VECTOR_MAX_MIN_INT(max, 8,  S, X, Max, 128)
+VECTOR_MAX_MIN_INT(max, 2,  I, D, Max, 64)
+VECTOR_MAX_MIN_INT(max, 4,  I, X, Max, 128)
+VECTOR_MAX_MIN_INT(min, 8,  B, D, Min, 64)
+VECTOR_MAX_MIN_INT(min, 16, B, X, Min, 128)
+VECTOR_MAX_MIN_INT(min, 4,  S, D, Min, 64)
+VECTOR_MAX_MIN_INT(min, 8,  S, X, Min, 128)
+VECTOR_MAX_MIN_INT(min, 2,  I, D, Min, 64)
+VECTOR_MAX_MIN_INT(min, 4,  I, X, Min, 128)
+undefine(PREDICATE)
+dnl
+define(`VECTOR_MAX_MIN_LONG', `
+instruct v$1`'2L`'(vecX dst, vecX src1, vecX src2)
+%{
+  predicate(n->as_Vector()->length() == 2 && n->bottom_type()->is_vect()->element_basic_type() == T_LONG);
+  match(Set dst ($2V src1 src2));
+  ins_cost(INSN_COST);
+  effect(TEMP dst);
+  format %{ "cmgt  $dst, $src1, $src2\t# vector (2L)\n\t"
+            "bsl   $dst, $$3, $$4\t# vector (16B)" %}
+  ins_encode %{
+    __ cmgt(as_FloatRegister($dst$$reg), __ T2D,
+            as_FloatRegister($src1$$reg), as_FloatRegister($src2$$reg));
+    __ bsl(as_FloatRegister($dst$$reg), __ T16B,
+           as_FloatRegister($$3$$reg), as_FloatRegister($$4$$reg));
+  %}
+  ins_pipe(vdop128);
+%}')dnl
+dnl                $1   $2   $3    $4
+VECTOR_MAX_MIN_LONG(max, Max, src1, src2)
+VECTOR_MAX_MIN_LONG(min, Min, src2, src1)
+dnl
+
+// --------------------------------- blend (bsl) ----------------------------
+dnl
+define(`VECTOR_BSL', `
+instruct vbsl$1B`'(vec$2 dst, vec$2 src1, vec$2 src2)
+%{
+  predicate(n->as_Vector()->length_in_bytes() == $1);
+  match(Set dst (VectorBlend (Binary src1 src2) dst));
+  ins_cost(INSN_COST);
+  format %{ "bsl  $dst, $src2, $src1\t# vector ($1B)" %}
+  ins_encode %{
+    __ bsl(as_FloatRegister($dst$$reg), __ T$1B,
+           as_FloatRegister($src2$$reg), as_FloatRegister($src1$$reg));
+  %}
+  ins_pipe(vlogical$3);
+%}')dnl
+dnl        $1  $2 $3
+VECTOR_BSL(8,  D, 64)
+VECTOR_BSL(16, X, 128)
+dnl
+
+// --------------------------------- Load/store Mask ----------------------------
+dnl
+define(`PREDICATE', `ifelse($1, load,
+`predicate(n->as_Vector()->length() == $2 && n->bottom_type()->is_vect()->element_basic_type() == T_BYTE);',
+`predicate(n->as_Vector()->length() == $2);')')dnl
+dnl
+define(`VECTOR_LOAD_STORE_MASK_B', `
+instruct $1mask$2B`'(vec$3 dst, vec$3 src $5 $6)
+%{
+  PREDICATE($1, $2)
+  match(Set dst (Vector$4Mask src $6));
+  ins_cost(INSN_COST);
+  format %{ "negr  $dst, $src\t# $1 mask ($2B to $2B)" %}
+  ins_encode %{
+    __ negr(as_FloatRegister($dst$$reg), __ T$2B, as_FloatRegister($src$$reg));
+  %}
+  ins_pipe(pipe_class_default);
+%}')dnl
+dnl                      $1     $2  $3 $4     $5      $6
+VECTOR_LOAD_STORE_MASK_B(load,  8,  D, Load)
+VECTOR_LOAD_STORE_MASK_B(load,  16, X, Load)
+VECTOR_LOAD_STORE_MASK_B(store, 8,  D, Store, `, immI_1', size)
+VECTOR_LOAD_STORE_MASK_B(store, 16, X, Store, `, immI_1', size)
+undefine(PREDICATE)dnl
+dnl
+define(`PREDICATE', `ifelse($1, load,
+`predicate(n->as_Vector()->length() == $2 && n->bottom_type()->is_vect()->element_basic_type() == T_SHORT);',
+`predicate(n->as_Vector()->length() == $2);')')dnl
+dnl
+define(`VECTOR_LOAD_STORE_MASK_S', `
+instruct $1mask$2S`'(vec$3 dst, vec$4 src $9 $10)
+%{
+  PREDICATE($1, $2)
+  match(Set dst (Vector$5Mask src $10));
+  ins_cost(INSN_COST);
+  format %{ "$6  $dst, $src\n\t"
+            "negr  $dst, $dst\t# $1 mask ($2$7 to $2$8)" %}
+  ins_encode %{
+    __ $6(as_FloatRegister($dst$$reg), __ T8$8, as_FloatRegister($src$$reg), __ T8$7);
+    __ negr(as_FloatRegister($dst$$reg), __ T8$8, as_FloatRegister($dst$$reg));
+  %}
+  ins_pipe(pipe_slow);
+%}')dnl
+dnl                      $1     $2 $3 $4 $5     $6    $7 $8    $9       $10
+VECTOR_LOAD_STORE_MASK_S(load,  4, D, D, Load,  uxtl, B, H)
+VECTOR_LOAD_STORE_MASK_S(load,  8, X, D, Load,  uxtl, B, H)
+VECTOR_LOAD_STORE_MASK_S(store, 4, D, D, Store, xtn,  H, B, `, immI_2', size)
+VECTOR_LOAD_STORE_MASK_S(store, 8, D, X, Store, xtn,  H, B, `, immI_2', size)
+undefine(PREDICATE)dnl
+dnl
+define(`PREDICATE', `ifelse($1, load,
+`predicate(n->as_Vector()->length() == $2 &&
+            (n->bottom_type()->is_vect()->element_basic_type() == T_INT ||
+             n->bottom_type()->is_vect()->element_basic_type() == T_FLOAT));',
+`predicate(n->as_Vector()->length() == $2);')')dnl
+dnl
+define(`VECTOR_LOAD_STORE_MASK_I', `
+instruct $1mask$2I`'(vec$3 dst, vec$4 src $12 $13)
+%{
+  PREDICATE($1, $2)
+  match(Set dst (Vector$5Mask src $13));
+  ins_cost(INSN_COST);
+  format %{ "$6  $dst, $src\t# $2$7 to $2$8\n\t"
+            "$6  $dst, $dst\t# $2$8 to $2$9\n\t"
+            "negr   $dst, $dst\t# $1 mask ($2$7 to $2$9)" %}
+  ins_encode %{
+    __ $6(as_FloatRegister($dst$$reg), __ T$10$8, as_FloatRegister($src$$reg), __ T$10$7);
+    __ $6(as_FloatRegister($dst$$reg), __ T$11$9, as_FloatRegister($dst$$reg), __ T$11$8);
+    __ negr(as_FloatRegister($dst$$reg), __ T$11$9, as_FloatRegister($dst$$reg));
+  %}
+  ins_pipe(pipe_slow);
+%}')dnl
+dnl                      $1     $2 $3 $4 $5     $6    $7 $8 $9 $10$11   $12      $13
+VECTOR_LOAD_STORE_MASK_I(load,  2, D, D, Load,  uxtl, B, H, S, 8, 4)
+VECTOR_LOAD_STORE_MASK_I(load,  4, X, D, Load,  uxtl, B, H, S, 8, 4)
+VECTOR_LOAD_STORE_MASK_I(store, 2, D, D, Store, xtn,  S, H, B, 4, 8, `, immI_4', size)
+VECTOR_LOAD_STORE_MASK_I(store, 4, D, X, Store, xtn,  S, H, B, 4, 8, `, immI_4', size)
+undefine(PREDICATE)
+dnl
+instruct loadmask2L(vecX dst, vecD src)
+%{
+  predicate(n->as_Vector()->length() == 2 &&
+            (n->bottom_type()->is_vect()->element_basic_type() == T_LONG ||
+             n->bottom_type()->is_vect()->element_basic_type() == T_DOUBLE));
+  match(Set dst (VectorLoadMask src));
+  ins_cost(INSN_COST);
+  format %{ "uxtl  $dst, $src\t# 2B to 2S\n\t"
+            "uxtl  $dst, $dst\t# 2S to 2I\n\t"
+            "uxtl  $dst, $dst\t# 2I to 2L\n\t"
+            "neg   $dst, $dst\t# load mask (2B to 2L)" %}
+  ins_encode %{
+    __ uxtl(as_FloatRegister($dst$$reg), __ T8H, as_FloatRegister($src$$reg), __ T8B);
+    __ uxtl(as_FloatRegister($dst$$reg), __ T4S, as_FloatRegister($dst$$reg), __ T4H);
+    __ uxtl(as_FloatRegister($dst$$reg), __ T2D, as_FloatRegister($dst$$reg), __ T2S);
+    __ negr(as_FloatRegister($dst$$reg), __ T2D, as_FloatRegister($dst$$reg));
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+instruct storemask2L(vecD dst, vecX src, immI_8 size)
+%{
+  predicate(n->as_Vector()->length() == 2);
+  match(Set dst (VectorStoreMask src size));
+  ins_cost(INSN_COST);
+  format %{ "xtn  $dst, $src\t# 2L to 2I\n\t"
+            "xtn  $dst, $dst\t# 2I to 2S\n\t"
+            "xtn  $dst, $dst\t# 2S to 2B\n\t"
+            "neg  $dst, $dst\t# store mask (2L to 2B)" %}
+  ins_encode %{
+    __ xtn(as_FloatRegister($dst$$reg), __ T2S, as_FloatRegister($src$$reg), __ T2D);
+    __ xtn(as_FloatRegister($dst$$reg), __ T4H, as_FloatRegister($dst$$reg), __ T4S);
+    __ xtn(as_FloatRegister($dst$$reg), __ T8B, as_FloatRegister($dst$$reg), __ T8H);
+    __ negr(as_FloatRegister($dst$$reg), __ T8B, as_FloatRegister($dst$$reg));
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+//-------------------------------- LOAD_IOTA_INDICES----------------------------------
+dnl
+define(`PREDICATE', `ifelse($1, 8,
+`predicate((n->as_Vector()->length() == 2 || n->as_Vector()->length() == 4 ||
+             n->as_Vector()->length() == 8) &&
+             n->bottom_type()->is_vect()->element_basic_type() == T_BYTE);',
+`predicate(n->as_Vector()->length() == 16 && n->bottom_type()->is_vect()->element_basic_type() == T_BYTE);')')dnl
+dnl
+define(`VECTOR_LOAD_CON', `
+instruct loadcon$1B`'(vec$2 dst, immI0 src)
+%{
+  PREDICATE($1)
+  match(Set dst (VectorLoadConst src));
+  ins_cost(INSN_COST);
+  format %{ "ldr $dst, CONSTANT_MEMORY\t# load iota indices" %}
+  ins_encode %{
+    __ lea(rscratch1, ExternalAddress(StubRoutines::aarch64::vector_iota_indices()));
+    __ ldr$3(as_FloatRegister($dst$$reg), rscratch1);
+  %}
+  ins_pipe(pipe_class_memory);
+%}')dnl
+dnl             $1  $2 $3
+VECTOR_LOAD_CON(8,  D, d)
+VECTOR_LOAD_CON(16, X, q)
+undefine(PREDICATE)
+dnl
+//-------------------------------- LOAD_SHUFFLE ----------------------------------
+dnl
+define(`VECTOR_LOAD_SHUFFLE_B', `
+instruct loadshuffle$1B`'(vec$2 dst, vec$2 src)
+%{
+  predicate(n->as_Vector()->length() == $1 &&
+            n->bottom_type()->is_vect()->element_basic_type() == T_BYTE);
+  match(Set dst (VectorLoadShuffle src));
+  ins_cost(INSN_COST);
+  format %{ "mov  $dst, $src\t# get $1B shuffle" %}
+  ins_encode %{
+    __ orr(as_FloatRegister($dst$$reg), __ T$1B,
+           as_FloatRegister($src$$reg), as_FloatRegister($src$$reg));
+  %}
+  ins_pipe(pipe_class_default);
+%}')dnl
+dnl                   $1  $2
+VECTOR_LOAD_SHUFFLE_B(8,  D)
+VECTOR_LOAD_SHUFFLE_B(16, X)
+dnl
+define(`VECTOR_LOAD_SHUFFLE_S', `
+instruct loadshuffle$1S`'(vec$2 dst, vec$3 src)
+%{
+  predicate(n->as_Vector()->length() == $1 &&
+            n->bottom_type()->is_vect()->element_basic_type() == T_SHORT);
+  match(Set dst (VectorLoadShuffle src));
+  ins_cost(INSN_COST);
+  format %{ "uxtl  $dst, $src\t# $1B to $1H" %}
+  ins_encode %{
+    __ uxtl(as_FloatRegister($dst$$reg), __ T8H, as_FloatRegister($src$$reg), __ T8B);
+  %}
+  ins_pipe(pipe_class_default);
+%}')dnl
+dnl                   $1 $2 $3
+VECTOR_LOAD_SHUFFLE_S(4, D, D)
+VECTOR_LOAD_SHUFFLE_S(8, X, D)
+dnl
+
+instruct loadshuffle4I(vecX dst, vecD src)
+%{
+  predicate(n->as_Vector()->length() == 4 &&
+           (n->bottom_type()->is_vect()->element_basic_type() == T_INT ||
+            n->bottom_type()->is_vect()->element_basic_type() == T_FLOAT));
+  match(Set dst (VectorLoadShuffle src));
+  ins_cost(INSN_COST);
+  format %{ "uxtl  $dst, $src\t# 4B to 4H \n\t"
+            "uxtl  $dst, $dst\t# 4H to 4S" %}
+  ins_encode %{
+    __ uxtl(as_FloatRegister($dst$$reg), __ T8H, as_FloatRegister($src$$reg), __ T8B);
+    __ uxtl(as_FloatRegister($dst$$reg), __ T4S, as_FloatRegister($dst$$reg), __ T4H);
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+//-------------------------------- Rearrange -------------------------------------
+// Here is an example that rearranges a NEON vector with 4 ints:
+// Rearrange V1 int[a0, a1, a2, a3] to V2 int[a2, a3, a0, a1]
+//   1. Get the indices of V1 and store them as Vi byte[0, 1, 2, 3].
+//   2. Convert Vi byte[0, 1, 2, 3] to the indices of V2 and also store them as Vi byte[2, 3, 0, 1].
+//   3. Unsigned extend Long Vi from byte[2, 3, 0, 1] to int[2, 3, 0, 1].
+//   4. Multiply Vi int[2, 3, 0, 1] with constant int[0x04040404, 0x04040404, 0x04040404, 0x04040404]
+//      and get tbl base Vm int[0x08080808, 0x0c0c0c0c, 0x00000000, 0x04040404].
+//   5. Add Vm with constant int[0x03020100, 0x03020100, 0x03020100, 0x03020100]
+//      and get tbl index Vm int[0x0b0a0908, 0x0f0e0d0c, 0x03020100, 0x07060504]
+//   6. Use Vm as index register, and use V1 as table register.
+//      Then get V2 as the result by tbl NEON instructions.
+// Notes:
+//   Step 1 matches VectorLoadConst.
+//   Step 3 matches VectorLoadShuffle.
+//   Step 4, 5, 6 match VectorRearrange.
+//   For VectorRearrange short/int, the reason why such complex calculation is
+//   required is because NEON tbl supports bytes table only, so for short/int, we
+//   need to lookup 2/4 bytes as a group. For VectorRearrange long, we use bsl
+//   to implement rearrange.
+define(`VECTOR_REARRANGE_B', `
+instruct rearrange$1B`'(vec$2 dst, vec$2 src, vec$2 shuffle)
+%{
+  predicate(n->as_Vector()->length() == $1 &&
+            n->bottom_type()->is_vect()->element_basic_type() == T_BYTE);
+  match(Set dst (VectorRearrange src shuffle));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst);
+  format %{ "tbl $dst, {$dst}, $shuffle\t# rearrange $1B" %}
+  ins_encode %{
+    __ tbl(as_FloatRegister($dst$$reg), __ T$1B,
+           as_FloatRegister($src$$reg), 1, as_FloatRegister($shuffle$$reg));
+  %}
+  ins_pipe(pipe_slow);
+%}')dnl
+dnl                $1  $2
+VECTOR_REARRANGE_B(8,  D)
+VECTOR_REARRANGE_B(16, X)
+dnl
+define(`VECTOR_REARRANGE_S', `
+instruct rearrange$1S`'(vec$2 dst, vec$2 src, vec$2 shuffle, vec$2 tmp0, vec$2 tmp1)
+%{
+  predicate(n->as_Vector()->length() == $1 &&
+            n->bottom_type()->is_vect()->element_basic_type() == T_SHORT);
+  match(Set dst (VectorRearrange src shuffle));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst, TEMP tmp0, TEMP tmp1);
+  format %{ "mov   $tmp0, CONSTANT\t# constant 0x0202020202020202\n\t"
+            "mov   $tmp1, CONSTANT\t# constant 0x0100010001000100\n\t"
+            "mulv  $dst, T$1H, $shuffle, $tmp0\n\t"
+            "addv  $dst, T$3B, $dst, $tmp1\n\t"
+            "tbl   $dst, {$src}, $dst\t# rearrange $1S" %}
+  ins_encode %{
+    __ mov(as_FloatRegister($tmp0$$reg), __ T$3B, 0x02);
+    __ mov(as_FloatRegister($tmp1$$reg), __ T$1H, 0x0100);
+    __ mulv(as_FloatRegister($dst$$reg), __ T$1H,
+            as_FloatRegister($shuffle$$reg), as_FloatRegister($tmp0$$reg));
+    __ addv(as_FloatRegister($dst$$reg), __ T$3B,
+            as_FloatRegister($dst$$reg), as_FloatRegister($tmp1$$reg));
+    __ tbl(as_FloatRegister($dst$$reg), __ T$3B,
+           as_FloatRegister($src$$reg), 1, as_FloatRegister($dst$$reg));
+  %}
+  ins_pipe(pipe_slow);
+%}')dnl
+dnl                $1 $2 $3
+VECTOR_REARRANGE_S(4, D, 8)
+VECTOR_REARRANGE_S(8, X, 16)
+
+instruct rearrange4I(vecX dst, vecX src, vecX shuffle, vecX tmp0, vecX tmp1)
+%{
+  predicate(n->as_Vector()->length() == 4 &&
+           (n->bottom_type()->is_vect()->element_basic_type() == T_INT ||
+            n->bottom_type()->is_vect()->element_basic_type() == T_FLOAT));
+  match(Set dst (VectorRearrange src shuffle));
+  ins_cost(INSN_COST);
+  effect(TEMP_DEF dst, TEMP tmp0, TEMP tmp1);
+  format %{ "mov   $tmp0, CONSTANT\t# constant 0x0404040404040404\n\t"
+            "mov   $tmp1, CONSTANT\t# constant 0x0302010003020100\n\t"
+            "mulv  $dst, T8H, $shuffle, $tmp0\n\t"
+            "addv  $dst, T16B, $dst, $tmp1\n\t"
+            "tbl   $dst, {$src}, $dst\t# rearrange 4I" %}
+  ins_encode %{
+    __ mov(as_FloatRegister($tmp0$$reg), __ T16B, 0x04);
+    __ mov(as_FloatRegister($tmp1$$reg), __ T4S, 0x03020100);
+    __ mulv(as_FloatRegister($dst$$reg), __ T4S,
+            as_FloatRegister($shuffle$$reg), as_FloatRegister($tmp0$$reg));
+    __ addv(as_FloatRegister($dst$$reg), __ T16B,
+            as_FloatRegister($dst$$reg), as_FloatRegister($tmp1$$reg));
+    __ tbl(as_FloatRegister($dst$$reg), __ T16B,
+           as_FloatRegister($src$$reg), 1, as_FloatRegister($dst$$reg));
+  %}
+  ins_pipe(pipe_slow);
+%}
+
+//-------------------------------- Anytrue/alltrue -----------------------------
+dnl
+define(`ANYTRUE_IN_MASK', `
+instruct anytrue_in_mask$1B`'(iRegINoSp dst, vec$2 src1, vec$2 src2, vec$2 tmp, rFlagsReg cr)
+%{
+  predicate(static_cast(n)->get_predicate() == BoolTest::ne);
+  match(Set dst (VectorTest src1 src2 ));
+  ins_cost(INSN_COST);
+  effect(TEMP tmp, KILL cr);
+  format %{ "addv  $tmp, T$1B, $src1\t# src1 and src2 are the same\n\t"
+            "umov  $dst, $tmp, B, 0\n\t"
+            "cmp   $dst, 0\n\t"
+            "cset  $dst" %}
+  ins_encode %{
+    __ addv(as_FloatRegister($tmp$$reg), __ T$1B, as_FloatRegister($src1$$reg));
+    __ umov($dst$$Register, as_FloatRegister($tmp$$reg), __ B, 0);
+    __ cmpw($dst$$Register, zr);
+    __ csetw($dst$$Register, Assembler::NE);
+  %}
+  ins_pipe(pipe_slow);
+%}')dnl
+dnl             $1  $2
+ANYTRUE_IN_MASK(8,  D)
+ANYTRUE_IN_MASK(16, X)
+dnl
+define(`ALLTRUE_IN_MASK', `
+instruct alltrue_in_mask$1B`'(iRegINoSp dst, vec$2 src1, vec$2 src2, vec$2 tmp, rFlagsReg cr)
+%{
+  predicate(static_cast(n)->get_predicate() == BoolTest::overflow);
+  match(Set dst (VectorTest src1 src2 ));
+  ins_cost(INSN_COST);
+  effect(TEMP tmp, KILL cr);
+  format %{ "andr  $tmp, T$1B, $src1, $src2\t# src2 is maskAllTrue\n\t"
+            "notr  $tmp, T$1B, $tmp\n\t"
+            "addv  $tmp, T$1B, $tmp\n\t"
+            "umov  $dst, $tmp, B, 0\n\t"
+            "cmp   $dst, 0\n\t"
+            "cset  $dst" %}
+  ins_encode %{
+    __ andr(as_FloatRegister($tmp$$reg), __ T$1B,
+            as_FloatRegister($src1$$reg), as_FloatRegister($src2$$reg));
+    __ notr(as_FloatRegister($tmp$$reg), __ T$1B, as_FloatRegister($tmp$$reg));
+    __ addv(as_FloatRegister($tmp$$reg), __ T$1B, as_FloatRegister($tmp$$reg));
+    __ umov($dst$$Register, as_FloatRegister($tmp$$reg), __ B, 0);
+    __ cmpw($dst$$Register, zr);
+    __ csetw($dst$$Register, Assembler::EQ);
+  %}
+  ins_pipe(pipe_slow);
+%}')dnl
+dnl             $1  $2
+ALLTRUE_IN_MASK(8,  D)
+ALLTRUE_IN_MASK(16, X)
+dnl
diff --git a/src/hotspot/share/gc/shared/pretouchTask.cpp b/src/hotspot/share/gc/shared/pretouchTask.cpp
new file mode 100644
index 0000000000000..eb0ffbb5bab29
--- /dev/null
+++ b/src/hotspot/share/gc/shared/pretouchTask.cpp
@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ *
+ */
+
+#include "precompiled.hpp"
+#include "gc/shared/pretouchTask.hpp"
+#include "runtime/atomic.hpp"
+#include "runtime/globals.hpp"
+#include "runtime/os.hpp"
+
+PretouchTask::PretouchTask(const char* task_name, char* start_address, char* end_address, size_t page_size) :
+    AbstractGangTask(task_name),
+    _cur_addr(start_address),
+    _start_addr(start_address),
+    _end_addr(end_address),
+    _page_size(0) {
+#ifdef LINUX
+  _page_size = UseTransparentHugePages ? (size_t)os::vm_page_size(): page_size;
+#else
+  _page_size = page_size;
+#endif
+}
+
+size_t PretouchTask::chunk_size() {
+  return PreTouchParallelChunkSize;
+}
+
+void PretouchTask::work(uint worker_id) {
+  size_t const actual_chunk_size = MAX2(chunk_size(), _page_size);
+
+  while (true) {
+    char* touch_addr = Atomic::fetch_and_add(&_cur_addr, actual_chunk_size);
+    if (touch_addr < _start_addr || touch_addr >= _end_addr) {
+      break;
+    }
+
+    char* end_addr = touch_addr + MIN2(actual_chunk_size, pointer_delta(_end_addr, touch_addr, sizeof(char)));
+
+    os::pretouch_memory(touch_addr, end_addr, _page_size);
+  }
+}
+
+void PretouchTask::pretouch(const char* task_name, char* start_address, char* end_address,
+                            size_t page_size, WorkGang* pretouch_gang) {
+  PretouchTask task(task_name, start_address, end_address, page_size);
+  size_t total_bytes = pointer_delta(end_address, start_address, sizeof(char));
+
+  if (pretouch_gang != NULL) {
+    size_t num_chunks = MAX2((size_t)1, total_bytes / MAX2(PretouchTask::chunk_size(), page_size));
+
+    uint num_workers = MIN2((uint)num_chunks, pretouch_gang->total_workers());
+    log_debug(gc, heap)("Running %s with %u workers for " SIZE_FORMAT " work units pre-touching " SIZE_FORMAT "B.",
+                        task.name(), num_workers, num_chunks, total_bytes);
+
+    pretouch_gang->run_task(&task, num_workers);
+  } else {
+    log_debug(gc, heap)("Running %s pre-touching " SIZE_FORMAT "B.",
+                        task.name(), total_bytes);
+    task.work(0);
+  }
+}
+
diff --git a/src/hotspot/share/gc/shared/pretouchTask.hpp b/src/hotspot/share/gc/shared/pretouchTask.hpp
new file mode 100644
index 0000000000000..1883afa7c4807
--- /dev/null
+++ b/src/hotspot/share/gc/shared/pretouchTask.hpp
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ *
+ */
+
+#ifndef SHARE_GC_SHARED_PRETOUCH_HPP
+#define SHARE_GC_SHARED_PRETOUCH_HPP
+
+#include "gc/shared/workgroup.hpp"
+
+class PretouchTask : public AbstractGangTask {
+  char* volatile _cur_addr;
+  char* const _start_addr;
+  char* const _end_addr;
+  size_t _page_size;
+
+public:
+  PretouchTask(const char* task_name, char* start_address, char* end_address, size_t page_size);
+
+  virtual void work(uint worker_id);
+
+  static size_t chunk_size();
+
+  static void pretouch(const char* task_name, char* start_address, char* end_address,
+                       size_t page_size, WorkGang* pretouch_gang);
+
+};
+
+#endif // SHARE_GC_SHARED_PRETOUCH_HPP
diff --git a/src/hotspot/share/opto/library_call.hpp b/src/hotspot/share/opto/library_call.hpp
new file mode 100644
index 0000000000000..fd4631141844b
--- /dev/null
+++ b/src/hotspot/share/opto/library_call.hpp
@@ -0,0 +1,348 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ *
+ */
+
+#include "ci/ciMethod.hpp"
+#include "classfile/javaClasses.hpp"
+#include "opto/callGenerator.hpp"
+#include "opto/graphKit.hpp"
+#include "opto/castnode.hpp"
+#include "opto/convertnode.hpp"
+#include "opto/intrinsicnode.hpp"
+#include "opto/movenode.hpp"
+
+class LibraryIntrinsic : public InlineCallGenerator {
+  // Extend the set of intrinsics known to the runtime:
+ public:
+ private:
+  bool             _is_virtual;
+  bool             _does_virtual_dispatch;
+  int8_t           _predicates_count;  // Intrinsic is predicated by several conditions
+  int8_t           _last_predicate; // Last generated predicate
+  vmIntrinsics::ID _intrinsic_id;
+
+ public:
+  LibraryIntrinsic(ciMethod* m, bool is_virtual, int predicates_count, bool does_virtual_dispatch, vmIntrinsics::ID id)
+    : InlineCallGenerator(m),
+      _is_virtual(is_virtual),
+      _does_virtual_dispatch(does_virtual_dispatch),
+      _predicates_count((int8_t)predicates_count),
+      _last_predicate((int8_t)-1),
+      _intrinsic_id(id)
+  {
+  }
+  virtual bool is_intrinsic() const { return true; }
+  virtual bool is_virtual()   const { return _is_virtual; }
+  virtual bool is_predicated() const { return _predicates_count > 0; }
+  virtual int  predicates_count() const { return _predicates_count; }
+  virtual bool does_virtual_dispatch()   const { return _does_virtual_dispatch; }
+  virtual JVMState* generate(JVMState* jvms);
+  virtual Node* generate_predicate(JVMState* jvms, int predicate);
+  vmIntrinsics::ID intrinsic_id() const { return _intrinsic_id; }
+};
+
+
+// Local helper class for LibraryIntrinsic:
+class LibraryCallKit : public GraphKit {
+ private:
+  LibraryIntrinsic* _intrinsic;     // the library intrinsic being called
+  Node*             _result;        // the result node, if any
+  int               _reexecute_sp;  // the stack pointer when bytecode needs to be reexecuted
+
+  const TypeOopPtr* sharpen_unsafe_type(Compile::AliasType* alias_type, const TypePtr *adr_type);
+
+ public:
+  LibraryCallKit(JVMState* jvms, LibraryIntrinsic* intrinsic)
+    : GraphKit(jvms),
+      _intrinsic(intrinsic),
+      _result(NULL)
+  {
+    // Check if this is a root compile.  In that case we don't have a caller.
+    if (!jvms->has_method()) {
+      _reexecute_sp = sp();
+    } else {
+      // Find out how many arguments the interpreter needs when deoptimizing
+      // and save the stack pointer value so it can used by uncommon_trap.
+      // We find the argument count by looking at the declared signature.
+      bool ignored_will_link;
+      ciSignature* declared_signature = NULL;
+      ciMethod* ignored_callee = caller()->get_method_at_bci(bci(), ignored_will_link, &declared_signature);
+      const int nargs = declared_signature->arg_size_for_bc(caller()->java_code_at_bci(bci()));
+      _reexecute_sp = sp() + nargs;  // "push" arguments back on stack
+    }
+  }
+
+  virtual LibraryCallKit* is_LibraryCallKit() const { return (LibraryCallKit*)this; }
+
+  ciMethod*         caller()    const    { return jvms()->method(); }
+  int               bci()       const    { return jvms()->bci(); }
+  LibraryIntrinsic* intrinsic() const    { return _intrinsic; }
+  vmIntrinsics::ID  intrinsic_id() const { return _intrinsic->intrinsic_id(); }
+  ciMethod*         callee()    const    { return _intrinsic->method(); }
+
+  bool  try_to_inline(int predicate);
+  Node* try_to_predicate(int predicate);
+
+  void push_result() {
+    // Push the result onto the stack.
+    if (!stopped() && result() != NULL) {
+      BasicType bt = result()->bottom_type()->basic_type();
+      push_node(bt, result());
+    }
+  }
+
+ private:
+  void fatal_unexpected_iid(vmIntrinsics::ID iid) {
+    fatal("unexpected intrinsic %d: %s", iid, vmIntrinsics::name_at(iid));
+  }
+
+  void  set_result(Node* n) { assert(_result == NULL, "only set once"); _result = n; }
+  void  set_result(RegionNode* region, PhiNode* value);
+  Node*     result() { return _result; }
+
+  virtual int reexecute_sp() { return _reexecute_sp; }
+
+  // Helper functions to inline natives
+  Node* generate_guard(Node* test, RegionNode* region, float true_prob);
+  Node* generate_slow_guard(Node* test, RegionNode* region);
+  Node* generate_fair_guard(Node* test, RegionNode* region);
+  Node* generate_negative_guard(Node* index, RegionNode* region,
+                                // resulting CastII of index:
+                                Node* *pos_index = NULL);
+  Node* generate_limit_guard(Node* offset, Node* subseq_length,
+                             Node* array_length,
+                             RegionNode* region);
+  void  generate_string_range_check(Node* array, Node* offset,
+                                    Node* length, bool char_count);
+  Node* generate_current_thread(Node* &tls_output);
+  Node* load_mirror_from_klass(Node* klass);
+  Node* load_klass_from_mirror_common(Node* mirror, bool never_see_null,
+                                      RegionNode* region, int null_path,
+                                      int offset);
+  Node* load_klass_from_mirror(Node* mirror, bool never_see_null,
+                               RegionNode* region, int null_path) {
+    int offset = java_lang_Class::klass_offset();
+    return load_klass_from_mirror_common(mirror, never_see_null,
+                                         region, null_path,
+                                         offset);
+  }
+  Node* load_array_klass_from_mirror(Node* mirror, bool never_see_null,
+                                     RegionNode* region, int null_path) {
+    int offset = java_lang_Class::array_klass_offset();
+    return load_klass_from_mirror_common(mirror, never_see_null,
+                                         region, null_path,
+                                         offset);
+  }
+  Node* generate_access_flags_guard(Node* kls,
+                                    int modifier_mask, int modifier_bits,
+                                    RegionNode* region);
+  Node* generate_interface_guard(Node* kls, RegionNode* region);
+  Node* generate_hidden_class_guard(Node* kls, RegionNode* region);
+  Node* generate_array_guard(Node* kls, RegionNode* region) {
+    return generate_array_guard_common(kls, region, false, false);
+  }
+  Node* generate_non_array_guard(Node* kls, RegionNode* region) {
+    return generate_array_guard_common(kls, region, false, true);
+  }
+  Node* generate_objArray_guard(Node* kls, RegionNode* region) {
+    return generate_array_guard_common(kls, region, true, false);
+  }
+  Node* generate_non_objArray_guard(Node* kls, RegionNode* region) {
+    return generate_array_guard_common(kls, region, true, true);
+  }
+  Node* generate_array_guard_common(Node* kls, RegionNode* region,
+                                    bool obj_array, bool not_array);
+  Node* generate_virtual_guard(Node* obj_klass, RegionNode* slow_region);
+  CallJavaNode* generate_method_call(vmIntrinsics::ID method_id,
+                                     bool is_virtual = false, bool is_static = false);
+  CallJavaNode* generate_method_call_static(vmIntrinsics::ID method_id) {
+    return generate_method_call(method_id, false, true);
+  }
+  CallJavaNode* generate_method_call_virtual(vmIntrinsics::ID method_id) {
+    return generate_method_call(method_id, true, false);
+  }
+  Node * load_field_from_object(Node * fromObj, const char * fieldName, const char * fieldTypeString, bool is_exact, bool is_static, ciInstanceKlass * fromKls);
+  Node * field_address_from_object(Node * fromObj, const char * fieldName, const char * fieldTypeString, bool is_exact, bool is_static, ciInstanceKlass * fromKls);
+
+  Node* make_string_method_node(int opcode, Node* str1_start, Node* cnt1, Node* str2_start, Node* cnt2, StrIntrinsicNode::ArgEnc ae);
+  bool inline_string_compareTo(StrIntrinsicNode::ArgEnc ae);
+  bool inline_string_indexOf(StrIntrinsicNode::ArgEnc ae);
+  bool inline_string_indexOfI(StrIntrinsicNode::ArgEnc ae);
+  Node* make_indexOf_node(Node* src_start, Node* src_count, Node* tgt_start, Node* tgt_count,
+                          RegionNode* region, Node* phi, StrIntrinsicNode::ArgEnc ae);
+  bool inline_string_indexOfChar(StrIntrinsicNode::ArgEnc ae);
+  bool inline_string_equals(StrIntrinsicNode::ArgEnc ae);
+  bool inline_string_toBytesU();
+  bool inline_string_getCharsU();
+  bool inline_string_copy(bool compress);
+  bool inline_string_char_access(bool is_store);
+  Node* round_double_node(Node* n);
+  bool runtime_math(const TypeFunc* call_type, address funcAddr, const char* funcName);
+  bool inline_math_native(vmIntrinsics::ID id);
+  bool inline_math(vmIntrinsics::ID id);
+  bool inline_double_math(vmIntrinsics::ID id);
+  template 
+  bool inline_math_overflow(Node* arg1, Node* arg2);
+  void inline_math_mathExact(Node* math, Node* test);
+  bool inline_math_addExactI(bool is_increment);
+  bool inline_math_addExactL(bool is_increment);
+  bool inline_math_multiplyExactI();
+  bool inline_math_multiplyExactL();
+  bool inline_math_multiplyHigh();
+  bool inline_math_negateExactI();
+  bool inline_math_negateExactL();
+  bool inline_math_subtractExactI(bool is_decrement);
+  bool inline_math_subtractExactL(bool is_decrement);
+  bool inline_min_max(vmIntrinsics::ID id);
+  bool inline_notify(vmIntrinsics::ID id);
+  Node* generate_min_max(vmIntrinsics::ID id, Node* x, Node* y);
+  // This returns Type::AnyPtr, RawPtr, or OopPtr.
+  int classify_unsafe_addr(Node* &base, Node* &offset, BasicType type);
+  Node* make_unsafe_address(Node*& base, Node* offset, DecoratorSet decorators, BasicType type = T_ILLEGAL, bool can_cast = false);
+
+  typedef enum { Relaxed, Opaque, Volatile, Acquire, Release } AccessKind;
+  DecoratorSet mo_decorator_for_access_kind(AccessKind kind);
+  bool inline_unsafe_access(bool is_store, BasicType type, AccessKind kind, bool is_unaligned);
+  static bool klass_needs_init_guard(Node* kls);
+  bool inline_unsafe_allocate();
+  bool inline_unsafe_newArray(bool uninitialized);
+  bool inline_unsafe_writeback0();
+  bool inline_unsafe_writebackSync0(bool is_pre);
+  bool inline_unsafe_copyMemory();
+  bool inline_native_currentThread();
+
+  bool inline_native_time_funcs(address method, const char* funcName);
+#ifdef JFR_HAVE_INTRINSICS
+  bool inline_native_classID();
+  bool inline_native_getEventWriter();
+#endif
+  bool inline_native_Class_query(vmIntrinsics::ID id);
+  bool inline_native_subtype_check();
+  bool inline_native_getLength();
+  bool inline_array_copyOf(bool is_copyOfRange);
+  bool inline_array_equals(StrIntrinsicNode::ArgEnc ae);
+  bool inline_preconditions_checkIndex();
+  void copy_to_clone(Node* obj, Node* alloc_obj, Node* obj_size, bool is_array);
+  bool inline_native_clone(bool is_virtual);
+  bool inline_native_Reflection_getCallerClass();
+  // Helper function for inlining native object hash method
+  bool inline_native_hashcode(bool is_virtual, bool is_static);
+  bool inline_native_getClass();
+
+  // Helper functions for inlining arraycopy
+  bool inline_arraycopy();
+  AllocateArrayNode* tightly_coupled_allocation(Node* ptr,
+                                                RegionNode* slow_region);
+  JVMState* arraycopy_restore_alloc_state(AllocateArrayNode* alloc, int& saved_reexecute_sp);
+  void arraycopy_move_allocation_here(AllocateArrayNode* alloc, Node* dest, JVMState* saved_jvms, int saved_reexecute_sp,
+                                      uint new_idx);
+
+  typedef enum { LS_get_add, LS_get_set, LS_cmp_swap, LS_cmp_swap_weak, LS_cmp_exchange } LoadStoreKind;
+  bool inline_unsafe_load_store(BasicType type,  LoadStoreKind kind, AccessKind access_kind);
+  bool inline_unsafe_fence(vmIntrinsics::ID id);
+  bool inline_onspinwait();
+  bool inline_fp_conversions(vmIntrinsics::ID id);
+  bool inline_number_methods(vmIntrinsics::ID id);
+  bool inline_reference_get();
+  bool inline_Class_cast();
+  bool inline_aescrypt_Block(vmIntrinsics::ID id);
+  bool inline_cipherBlockChaining_AESCrypt(vmIntrinsics::ID id);
+  bool inline_electronicCodeBook_AESCrypt(vmIntrinsics::ID id);
+  bool inline_counterMode_AESCrypt(vmIntrinsics::ID id);
+  Node* inline_cipherBlockChaining_AESCrypt_predicate(bool decrypting);
+  Node* inline_electronicCodeBook_AESCrypt_predicate(bool decrypting);
+  Node* inline_counterMode_AESCrypt_predicate();
+  Node* get_key_start_from_aescrypt_object(Node* aescrypt_object);
+  Node* get_original_key_start_from_aescrypt_object(Node* aescrypt_object);
+  bool inline_ghash_processBlocks();
+  bool inline_base64_encodeBlock();
+  bool inline_digestBase_implCompress(vmIntrinsics::ID id);
+  bool inline_digestBase_implCompressMB(int predicate);
+  bool inline_digestBase_implCompressMB(Node* digestBaseObj, ciInstanceKlass* instklass,
+                                        bool long_state, address stubAddr, const char *stubName,
+                                        Node* src_start, Node* ofs, Node* limit);
+  Node* get_state_from_digest_object(Node *digestBase_object);
+  Node* get_long_state_from_digest_object(Node *digestBase_object);
+  Node* inline_digestBase_implCompressMB_predicate(int predicate);
+  bool inline_encodeISOArray();
+  bool inline_updateCRC32();
+  bool inline_updateBytesCRC32();
+  bool inline_updateByteBufferCRC32();
+  Node* get_table_from_crc32c_class(ciInstanceKlass *crc32c_class);
+  bool inline_updateBytesCRC32C();
+  bool inline_updateDirectByteBufferCRC32C();
+  bool inline_updateBytesAdler32();
+  bool inline_updateByteBufferAdler32();
+  bool inline_multiplyToLen();
+  bool inline_hasNegatives();
+  bool inline_squareToLen();
+  bool inline_mulAdd();
+  bool inline_montgomeryMultiply();
+  bool inline_montgomerySquare();
+  bool inline_bigIntegerShift(bool isRightShift);
+  bool inline_vectorizedMismatch();
+  bool inline_fma(vmIntrinsics::ID id);
+  bool inline_character_compare(vmIntrinsics::ID id);
+  bool inline_fp_min_max(vmIntrinsics::ID id);
+
+  bool inline_profileBoolean();
+  bool inline_isCompileConstant();
+
+  // Vector API support
+  bool inline_vector_nary_operation(int n);
+  bool inline_vector_broadcast_coerced();
+  bool inline_vector_shuffle_to_vector();
+  bool inline_vector_shuffle_iota();
+  bool inline_vector_mem_operation(bool is_store);
+  bool inline_vector_gather_scatter(bool is_scatter);
+  bool inline_vector_reduction();
+  bool inline_vector_test();
+  bool inline_vector_blend();
+  bool inline_vector_rearrange();
+  bool inline_vector_compare();
+  bool inline_vector_broadcast_int();
+  bool inline_vector_convert();
+  bool inline_vector_extract();
+  bool inline_vector_insert();
+  Node* box_vector(Node* in, const TypeInstPtr* vbox_type, BasicType bt, int num_elem);
+  Node* unbox_vector(Node* in, const TypeInstPtr* vbox_type, BasicType bt, int num_elem, bool shuffle_to_vector = false);
+  Node* shift_count(Node* cnt, int shift_op, BasicType bt, int num_elem);
+
+  enum VectorMaskUseType {
+    VecMaskUseLoad,
+    VecMaskUseStore,
+    VecMaskUseAll,
+    VecMaskNotUsed
+  };
+
+  bool arch_supports_vector(int op, int num_elem, BasicType type, VectorMaskUseType mask_use_type, bool has_scalar_args = false);
+
+  void clear_upper_avx() {
+#ifdef X86
+    if (UseAVX >= 2) {
+      C->set_clear_upper_avx(true);
+    }
+#endif
+  }
+};
+
diff --git a/src/hotspot/share/opto/vector.cpp b/src/hotspot/share/opto/vector.cpp
new file mode 100644
index 0000000000000..2bae87acf7dc8
--- /dev/null
+++ b/src/hotspot/share/opto/vector.cpp
@@ -0,0 +1,466 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ *
+ */
+
+#include "precompiled.hpp"
+#include "opto/castnode.hpp"
+#include "opto/graphKit.hpp"
+#include "opto/phaseX.hpp"
+#include "opto/rootnode.hpp"
+#include "opto/vector.hpp"
+#include "utilities/macros.hpp"
+
+void PhaseVector::optimize_vector_boxes() {
+  Compile::TracePhase tp("vector_elimination", &timers[_t_vector_elimination]);
+
+  // Signal GraphKit it's post-parse phase.
+  assert(C->inlining_incrementally() == false, "sanity");
+  C->set_inlining_incrementally(true);
+
+  C->for_igvn()->clear();
+  C->initial_gvn()->replace_with(&_igvn);
+
+  expand_vunbox_nodes();
+  scalarize_vbox_nodes();
+
+  C->inline_vector_reboxing_calls();
+
+  expand_vbox_nodes();
+  eliminate_vbox_alloc_nodes();
+
+  C->set_inlining_incrementally(false);
+
+  do_cleanup();
+}
+
+void PhaseVector::do_cleanup() {
+  if (C->failing())  return;
+  {
+    Compile::TracePhase tp("vector_pru", &timers[_t_vector_pru]);
+    ResourceMark rm;
+    PhaseRemoveUseless pru(C->initial_gvn(), C->for_igvn());
+    if (C->failing())  return;
+  }
+  {
+    Compile::TracePhase tp("incrementalInline_igvn", &timers[_t_vector_igvn]);
+    _igvn = PhaseIterGVN(C->initial_gvn());
+    _igvn.optimize();
+    if (C->failing())  return;
+  }
+  C->print_method(PHASE_ITER_GVN_BEFORE_EA, 3);
+}
+
+void PhaseVector::scalarize_vbox_nodes() {
+  if (C->failing())  return;
+
+  if (!EnableVectorReboxing) {
+    return; // don't scalarize vector boxes
+  }
+
+  int macro_idx = C->macro_count() - 1;
+  while (macro_idx >= 0) {
+    Node * n = C->macro_node(macro_idx);
+    assert(n->is_macro(), "only macro nodes expected here");
+    if (n->Opcode() == Op_VectorBox) {
+      VectorBoxNode* vbox = static_cast(n);
+      scalarize_vbox_node(vbox);
+      if (C->failing())  return;
+      C->print_method(PHASE_SCALARIZE_VBOX, vbox, 3);
+    }
+    if (C->failing())  return;
+    macro_idx = MIN2(macro_idx - 1, C->macro_count() - 1);
+  }
+}
+
+void PhaseVector::expand_vbox_nodes() {
+  if (C->failing())  return;
+
+  int macro_idx = C->macro_count() - 1;
+  while (macro_idx >= 0) {
+    Node * n = C->macro_node(macro_idx);
+    assert(n->is_macro(), "only macro nodes expected here");
+    if (n->Opcode() == Op_VectorBox) {
+      VectorBoxNode* vbox = static_cast(n);
+      expand_vbox_node(vbox);
+      if (C->failing())  return;
+    }
+    if (C->failing())  return;
+    macro_idx = MIN2(macro_idx - 1, C->macro_count() - 1);
+  }
+}
+
+void PhaseVector::expand_vunbox_nodes() {
+  if (C->failing())  return;
+
+  int macro_idx = C->macro_count() - 1;
+  while (macro_idx >= 0) {
+    Node * n = C->macro_node(macro_idx);
+    assert(n->is_macro(), "only macro nodes expected here");
+    if (n->Opcode() == Op_VectorUnbox) {
+      VectorUnboxNode* vec_unbox = static_cast(n);
+      expand_vunbox_node(vec_unbox);
+      if (C->failing())  return;
+      C->print_method(PHASE_EXPAND_VUNBOX, vec_unbox, 3);
+    }
+    if (C->failing())  return;
+    macro_idx = MIN2(macro_idx - 1, C->macro_count() - 1);
+  }
+}
+
+void PhaseVector::eliminate_vbox_alloc_nodes() {
+  if (C->failing())  return;
+
+  int macro_idx = C->macro_count() - 1;
+  while (macro_idx >= 0) {
+    Node * n = C->macro_node(macro_idx);
+    assert(n->is_macro(), "only macro nodes expected here");
+    if (n->Opcode() == Op_VectorBoxAllocate) {
+      VectorBoxAllocateNode* vbox_alloc = static_cast(n);
+      eliminate_vbox_alloc_node(vbox_alloc);
+      if (C->failing())  return;
+      C->print_method(PHASE_ELIMINATE_VBOX_ALLOC, vbox_alloc, 3);
+    }
+    if (C->failing())  return;
+    macro_idx = MIN2(macro_idx - 1, C->macro_count() - 1);
+  }
+}
+
+static JVMState* clone_jvms(Compile* C, SafePointNode* sfpt) {
+  JVMState* new_jvms = sfpt->jvms()->clone_shallow(C);
+  uint size = sfpt->req();
+  SafePointNode* map = new SafePointNode(size, new_jvms);
+  for (uint i = 0; i < size; i++) {
+    map->init_req(i, sfpt->in(i));
+  }
+  new_jvms->set_map(map);
+  return new_jvms;
+}
+
+void PhaseVector::scalarize_vbox_node(VectorBoxNode* vec_box) {
+  Node* vec_value = vec_box->in(VectorBoxNode::Value);
+  PhaseGVN& gvn = *C->initial_gvn();
+
+  // Process merged VBAs
+
+  if (EnableVectorAggressiveReboxing) {
+    Unique_Node_List calls(C->comp_arena());
+    for (DUIterator_Fast imax, i = vec_box->fast_outs(imax); i < imax; i++) {
+      Node* use = vec_box->fast_out(i);
+      if (use->is_CallJava()) {
+        CallJavaNode* call = use->as_CallJava();
+        if (call->has_non_debug_use(vec_box) && vec_box->in(VectorBoxNode::Box)->is_Phi()) {
+          calls.push(call);
+        }
+      }
+    }
+
+    while (calls.size() > 0) {
+      CallJavaNode* call = calls.pop()->as_CallJava();
+      // Attach new VBA to the call and use it instead of Phi (VBA ... VBA).
+
+      JVMState* jvms = clone_jvms(C, call);
+      GraphKit kit(jvms);
+      PhaseGVN& gvn = kit.gvn();
+
+      // Adjust JVMS from post-call to pre-call state: put args on stack
+      uint nargs = call->method()->arg_size();
+      kit.ensure_stack(kit.sp() + nargs);
+      for (uint i = TypeFunc::Parms; i < call->tf()->domain()->cnt(); i++) {
+        kit.push(call->in(i));
+      }
+      jvms = kit.sync_jvms();
+
+      Node* new_vbox = NULL;
+      {
+        PreserveReexecuteState prs(&kit);
+
+        kit.jvms()->set_should_reexecute(true);
+
+        const TypeInstPtr* vbox_type = vec_box->box_type();
+        const TypeVect* vect_type = vec_box->vec_type();
+        Node* vect = vec_box->in(VectorBoxNode::Value);
+
+        VectorBoxAllocateNode* alloc = new VectorBoxAllocateNode(C, vbox_type);
+        kit.set_edges_for_java_call(alloc, /*must_throw=*/false, /*separate_io_proj=*/true);
+        kit.make_slow_call_ex(alloc, C->env()->Throwable_klass(), /*separate_io_proj=*/true, /*deoptimize=*/true);
+        kit.set_i_o(gvn.transform( new ProjNode(alloc, TypeFunc::I_O) ));
+        kit.set_all_memory(gvn.transform( new ProjNode(alloc, TypeFunc::Memory) ));
+        Node* ret = gvn.transform(new ProjNode(alloc, TypeFunc::Parms));
+
+        new_vbox = gvn.transform(new VectorBoxNode(C, ret, vect, vbox_type, vect_type));
+
+        kit.replace_in_map(vec_box, new_vbox);
+      }
+
+      kit.dec_sp(nargs);
+      jvms = kit.sync_jvms();
+
+      call->set_req(TypeFunc::Control , kit.control());
+      call->set_req(TypeFunc::I_O     , kit.i_o());
+      call->set_req(TypeFunc::Memory  , kit.reset_memory());
+      call->set_req(TypeFunc::FramePtr, kit.frameptr());
+      call->replace_edge(vec_box, new_vbox);
+
+      C->record_for_igvn(call);
+    }
+  }
+
+  // Process debug uses at safepoints
+  Unique_Node_List safepoints(C->comp_arena());
+
+  for (DUIterator_Fast imax, i = vec_box->fast_outs(imax); i < imax; i++) {
+    Node* use = vec_box->fast_out(i);
+    if (use->is_SafePoint()) {
+      SafePointNode* sfpt = use->as_SafePoint();
+      if (!sfpt->is_Call() || !sfpt->as_Call()->has_non_debug_use(vec_box)) {
+        safepoints.push(sfpt);
+      }
+    }
+  }
+
+  while (safepoints.size() > 0) {
+    SafePointNode* sfpt = safepoints.pop()->as_SafePoint();
+
+    uint first_ind = (sfpt->req() - sfpt->jvms()->scloff());
+    Node* sobj = new SafePointScalarObjectNode(vec_box->box_type(),
+#ifdef ASSERT
+                                               NULL,
+#endif // ASSERT
+                                               first_ind, /*n_fields=*/1);
+    sobj->init_req(0, C->root());
+    sfpt->add_req(vec_value);
+
+    sobj = gvn.transform(sobj);
+
+    JVMState *jvms = sfpt->jvms();
+
+    jvms->set_endoff(sfpt->req());
+    // Now make a pass over the debug information replacing any references
+    // to the allocated object with "sobj"
+    int start = jvms->debug_start();
+    int end   = jvms->debug_end();
+    sfpt->replace_edges_in_range(vec_box, sobj, start, end);
+
+    C->record_for_igvn(sfpt);
+  }
+}
+
+void PhaseVector::expand_vbox_node(VectorBoxNode* vec_box) {
+  if (vec_box->outcnt() > 0) {
+    Node* vbox = vec_box->in(VectorBoxNode::Box);
+    Node* vect = vec_box->in(VectorBoxNode::Value);
+    Node* result = expand_vbox_node_helper(vbox, vect, vec_box->box_type(), vec_box->vec_type());
+    C->gvn_replace_by(vec_box, result);
+    C->print_method(PHASE_EXPAND_VBOX, vec_box, 3);
+  }
+  C->remove_macro_node(vec_box);
+}
+
+Node* PhaseVector::expand_vbox_node_helper(Node* vbox,
+                                           Node* vect,
+                                           const TypeInstPtr* box_type,
+                                           const TypeVect* vect_type) {
+  if (vbox->is_Phi() && vect->is_Phi()) {
+    assert(vbox->as_Phi()->region() == vect->as_Phi()->region(), "");
+    Node* new_phi = new PhiNode(vbox->as_Phi()->region(), box_type);
+    for (uint i = 1; i < vbox->req(); i++) {
+      Node* new_box = expand_vbox_node_helper(vbox->in(i), vect->in(i), box_type, vect_type);
+      new_phi->set_req(i, new_box);
+    }
+    new_phi = C->initial_gvn()->transform(new_phi);
+    return new_phi;
+  } else if (vbox->is_Proj() && vbox->in(0)->Opcode() == Op_VectorBoxAllocate) {
+    VectorBoxAllocateNode* vbox_alloc = static_cast(vbox->in(0));
+    return expand_vbox_alloc_node(vbox_alloc, vect, box_type, vect_type);
+  } else {
+    assert(!vbox->is_Phi(), "");
+    // TODO: assert that expanded vbox is initialized with the same value (vect).
+    return vbox; // already expanded
+  }
+}
+
+static bool is_vector_mask(ciKlass* klass) {
+  return klass->is_subclass_of(ciEnv::current()->vector_VectorMask_klass());
+}
+
+static bool is_vector_shuffle(ciKlass* klass) {
+  return klass->is_subclass_of(ciEnv::current()->vector_VectorShuffle_klass());
+}
+
+Node* PhaseVector::expand_vbox_alloc_node(VectorBoxAllocateNode* vbox_alloc,
+                                          Node* value,
+                                          const TypeInstPtr* box_type,
+                                          const TypeVect* vect_type) {
+  JVMState* jvms = clone_jvms(C, vbox_alloc);
+  GraphKit kit(jvms);
+  PhaseGVN& gvn = kit.gvn();
+
+  ciInstanceKlass* box_klass = box_type->klass()->as_instance_klass();
+  BasicType bt = vect_type->element_basic_type();
+  int num_elem = vect_type->length();
+
+  bool is_mask = is_vector_mask(box_klass);
+  if (is_mask && bt != T_BOOLEAN) {
+    value = gvn.transform(VectorStoreMaskNode::make(gvn, value, bt, num_elem));
+    // Although type of mask depends on its definition, in terms of storage everything is stored in boolean array.
+    bt = T_BOOLEAN;
+    assert(value->as_Vector()->bottom_type()->is_vect()->element_basic_type() == bt,
+           "must be consistent with mask representation");
+  }
+
+  // Generate array allocation for the field which holds the values.
+  const TypeKlassPtr* array_klass = TypeKlassPtr::make(ciTypeArrayKlass::make(bt));
+  Node* arr = kit.new_array(kit.makecon(array_klass), kit.intcon(num_elem), 1);
+
+  // Store the vector value into the array.
+  // (The store should be captured by InitializeNode and turned into initialized store later.)
+  Node* arr_adr = kit.array_element_address(arr, kit.intcon(0), bt);
+  const TypePtr* arr_adr_type = arr_adr->bottom_type()->is_ptr();
+  Node* arr_mem = kit.memory(arr_adr);
+  Node* vstore = gvn.transform(StoreVectorNode::make(0,
+                                                     kit.control(),
+                                                     arr_mem,
+                                                     arr_adr,
+                                                     arr_adr_type,
+                                                     value,
+                                                     num_elem));
+  kit.set_memory(vstore, arr_adr_type);
+
+  C->set_max_vector_size(MAX2(C->max_vector_size(), vect_type->length_in_bytes()));
+
+  // Generate the allocate for the Vector object.
+  const TypeKlassPtr* klass_type = box_type->as_klass_type();
+  Node* klass_node = kit.makecon(klass_type);
+  Node* vec_obj = kit.new_instance(klass_node);
+
+  // Store the allocated array into object.
+  ciField* field = ciEnv::current()->vector_VectorPayload_klass()->get_field_by_name(ciSymbol::payload_name(),
+                                                                                     ciSymbol::object_signature(),
+                                                                                     false);
+  assert(field != NULL, "");
+  Node* vec_field = kit.basic_plus_adr(vec_obj, field->offset_in_bytes());
+  const TypePtr* vec_adr_type = vec_field->bottom_type()->is_ptr();
+
+  // The store should be captured by InitializeNode and turned into initialized store later.
+  Node* field_store = gvn.transform(kit.access_store_at(vec_obj,
+                                                            vec_field,
+                                                            vec_adr_type,
+                                                            arr,
+                                                            TypeOopPtr::make_from_klass(field->type()->as_klass()),
+                                                            T_OBJECT,
+                                                            IN_HEAP));
+  kit.set_memory(field_store, vec_adr_type);
+
+  kit.replace_call(vbox_alloc, vec_obj, true);
+  C->remove_macro_node(vbox_alloc);
+
+  return vec_obj;
+}
+
+void PhaseVector::expand_vunbox_node(VectorUnboxNode* vec_unbox) {
+  if (vec_unbox->outcnt() > 0) {
+    GraphKit kit;
+    PhaseGVN& gvn = kit.gvn();
+
+    Node* obj = vec_unbox->obj();
+    const TypeInstPtr* tinst = gvn.type(obj)->isa_instptr();
+    ciInstanceKlass* from_kls = tinst->klass()->as_instance_klass();
+    BasicType bt = vec_unbox->vect_type()->element_basic_type();
+    BasicType masktype = bt;
+    BasicType elem_bt;
+
+    if (is_vector_mask(from_kls)) {
+      bt = T_BOOLEAN;
+    } else if (is_vector_shuffle(from_kls)) {
+      if (vec_unbox->is_shuffle_to_vector() == true) {
+        elem_bt = bt;
+      }
+      bt = T_BYTE;
+    }
+
+    ciField* field = ciEnv::current()->vector_VectorPayload_klass()->get_field_by_name(ciSymbol::payload_name(),
+                                                                                       ciSymbol::object_signature(),
+                                                                                       false);
+    assert(field != NULL, "");
+    int offset = field->offset_in_bytes();
+    Node* vec_adr = kit.basic_plus_adr(obj, offset);
+
+    Node* mem = vec_unbox->mem();
+    Node* ctrl = vec_unbox->in(0);
+    Node* vec_field_ld = LoadNode::make(gvn,
+                                        ctrl,
+                                        mem,
+                                        vec_adr,
+                                        vec_adr->bottom_type()->is_ptr(),
+                                        TypeOopPtr::make_from_klass(field->type()->as_klass()),
+                                        T_OBJECT,
+                                        MemNode::unordered);
+    vec_field_ld = gvn.transform(vec_field_ld);
+
+    // For proper aliasing, attach concrete payload type.
+    ciKlass* payload_klass = ciTypeArrayKlass::make(bt);
+    const Type* payload_type = TypeAryPtr::make_from_klass(payload_klass)->cast_to_ptr_type(TypePtr::NotNull);
+    vec_field_ld = gvn.transform(new CastPPNode(vec_field_ld, payload_type));
+
+    Node* adr = kit.array_element_address(vec_field_ld, gvn.intcon(0), bt);
+    const TypePtr* adr_type = adr->bottom_type()->is_ptr();
+    const TypeVect* vt = vec_unbox->bottom_type()->is_vect();
+    int num_elem = vt->length();
+    Node* vec_val_load = LoadVectorNode::make(0,
+                                              ctrl,
+                                              mem,
+                                              adr,
+                                              adr_type,
+                                              num_elem,
+                                              bt);
+    vec_val_load = gvn.transform(vec_val_load);
+
+    C->set_max_vector_size(MAX2(C->max_vector_size(), vt->length_in_bytes()));
+
+    if (is_vector_mask(from_kls) && masktype != T_BOOLEAN) {
+      assert(vec_unbox->bottom_type()->is_vect()->element_basic_type() == masktype, "expect mask type consistency");
+      vec_val_load = gvn.transform(new VectorLoadMaskNode(vec_val_load, TypeVect::make(masktype, num_elem)));
+    } else if (is_vector_shuffle(from_kls)) {
+      if (vec_unbox->is_shuffle_to_vector() == false) {
+        assert(vec_unbox->bottom_type()->is_vect()->element_basic_type() == masktype, "expect shuffle type consistency");
+        vec_val_load = gvn.transform(new VectorLoadShuffleNode(vec_val_load, TypeVect::make(masktype, num_elem)));
+      } else if (elem_bt != T_BYTE) {
+        vec_val_load = gvn.transform(VectorCastNode::make(Op_VectorCastB2X, vec_val_load, elem_bt, num_elem));
+      }
+    }
+
+    gvn.hash_delete(vec_unbox);
+    vec_unbox->disconnect_inputs(C);
+    C->gvn_replace_by(vec_unbox, vec_val_load);
+  }
+  C->remove_macro_node(vec_unbox);
+}
+
+void PhaseVector::eliminate_vbox_alloc_node(VectorBoxAllocateNode* vbox_alloc) {
+  JVMState* jvms = clone_jvms(C, vbox_alloc);
+  GraphKit kit(jvms);
+  // Remove VBA, but leave a safepoint behind.
+  // Otherwise, it may end up with a loop without any safepoint polls.
+  kit.replace_call(vbox_alloc, kit.map(), true);
+  C->remove_macro_node(vbox_alloc);
+}
diff --git a/src/hotspot/share/opto/vector.hpp b/src/hotspot/share/opto/vector.hpp
new file mode 100644
index 0000000000000..067a2280d3092
--- /dev/null
+++ b/src/hotspot/share/opto/vector.hpp
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ *
+ */
+
+#ifndef SHARE_OPTO_VECTOR_HPP
+#define SHARE_OPTO_VECTOR_HPP
+
+#include "opto/node.hpp"
+#include "opto/phaseX.hpp"
+#include "opto/type.hpp"
+#include "opto/vectornode.hpp"
+
+class PhaseVector : public Phase {
+ private:
+  PhaseIterGVN& _igvn;
+
+  void expand_vbox_nodes();
+  void expand_vbox_node(VectorBoxNode* vec_box);
+  Node* expand_vbox_node_helper(Node* vbox,
+                                Node* vect,
+                                const TypeInstPtr* box_type,
+                                const TypeVect* vect_type);
+  Node* expand_vbox_alloc_node(VectorBoxAllocateNode* vbox_alloc,
+                               Node* value,
+                               const TypeInstPtr* box_type,
+                               const TypeVect* vect_type);
+  void scalarize_vbox_nodes();
+  void scalarize_vbox_node(VectorBoxNode* vec_box);
+  void expand_vunbox_nodes();
+  void expand_vunbox_node(VectorUnboxNode* vec_box);
+  void eliminate_vbox_alloc_nodes();
+  void eliminate_vbox_alloc_node(VectorBoxAllocateNode* vbox_alloc);
+  void do_cleanup();
+  void scalarize_vector_boxes();
+  void expand_vector_boxes();
+
+ public:
+  PhaseVector(PhaseIterGVN& igvn) : Phase(Vector), _igvn(igvn) {}
+  void optimize_vector_boxes();
+};
+
+#endif // SHARE_OPTO_VECTOR_HPP
diff --git a/src/hotspot/share/opto/vectorIntrinsics.cpp b/src/hotspot/share/opto/vectorIntrinsics.cpp
new file mode 100644
index 0000000000000..ecb9525152a76
--- /dev/null
+++ b/src/hotspot/share/opto/vectorIntrinsics.cpp
@@ -0,0 +1,1594 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ *
+ */
+
+#include "precompiled.hpp"
+#include "classfile/vmSymbols.hpp"
+#include "opto/library_call.hpp"
+#include "opto/runtime.hpp"
+#include "opto/vectornode.hpp"
+#include "prims/vectorSupport.hpp"
+
+bool LibraryCallKit::arch_supports_vector(int sopc, int num_elem, BasicType type, VectorMaskUseType mask_use_type, bool has_scalar_args) {
+  // Check that the operation is valid.
+  if (sopc <= 0) {
+#ifndef PRODUCT
+    if (C->print_intrinsics()) {
+      tty->print_cr("  ** Rejected intrinsification because no valid vector op could be extracted");
+    }
+#endif
+    return false;
+  }
+
+  // Check that architecture supports this op-size-type combination.
+  if (!Matcher::match_rule_supported_vector(sopc, num_elem, type)) {
+#ifndef PRODUCT
+    if (C->print_intrinsics()) {
+      tty->print_cr("  ** Rejected vector op (%s,%s,%d) because architecture does not support it",
+                    NodeClassNames[sopc], type2name(type), num_elem);
+    }
+#endif
+    return false;
+  } else {
+    assert(Matcher::match_rule_supported(sopc), "must be supported");
+  }
+
+  if (!has_scalar_args && VectorNode::is_vector_shift(sopc) &&
+      Matcher::supports_vector_variable_shifts() == false) {
+    if (C->print_intrinsics()) {
+      tty->print_cr("  ** Rejected vector op (%s,%s,%d) because architecture does not support variable vector shifts",
+                    NodeClassNames[sopc], type2name(type), num_elem);
+    }
+    return false;
+  }
+
+  // Check whether mask unboxing is supported.
+  if (mask_use_type == VecMaskUseAll || mask_use_type == VecMaskUseLoad) {
+    if (!Matcher::match_rule_supported_vector(Op_VectorLoadMask, num_elem, type)) {
+    #ifndef PRODUCT
+      if (C->print_intrinsics()) {
+        tty->print_cr("  ** Rejected vector mask loading (%s,%s,%d) because architecture does not support it",
+                      NodeClassNames[Op_VectorLoadMask], type2name(type), num_elem);
+      }
+    #endif
+      return false;
+    }
+  }
+
+  // Check whether mask boxing is supported.
+  if (mask_use_type == VecMaskUseAll || mask_use_type == VecMaskUseStore) {
+    if (!Matcher::match_rule_supported_vector(Op_VectorStoreMask, num_elem, type)) {
+    #ifndef PRODUCT
+      if (C->print_intrinsics()) {
+        tty->print_cr("Rejected vector mask storing (%s,%s,%d) because architecture does not support it",
+                      NodeClassNames[Op_VectorStoreMask], type2name(type), num_elem);
+      }
+    #endif
+      return false;
+    }
+  }
+
+  return true;
+}
+
+static bool is_vector_mask(ciKlass* klass) {
+  return klass->is_subclass_of(ciEnv::current()->vector_VectorMask_klass());
+}
+
+static bool is_vector_shuffle(ciKlass* klass) {
+  return klass->is_subclass_of(ciEnv::current()->vector_VectorShuffle_klass());
+}
+
+static bool is_klass_initialized(const TypeInstPtr* vec_klass) {
+  assert(vec_klass->const_oop()->as_instance()->java_lang_Class_klass(), "klass instance expected");
+  ciInstanceKlass* klass =  vec_klass->const_oop()->as_instance()->java_lang_Class_klass()->as_instance_klass();
+  return klass->is_initialized();
+}
+
+#ifdef ASSERT
+static bool is_vector(ciKlass* klass) {
+  return klass->is_subclass_of(ciEnv::current()->vector_VectorPayload_klass());
+}
+
+static bool check_vbox(const TypeInstPtr* vbox_type) {
+  assert(vbox_type->klass_is_exact(), "");
+
+  ciInstanceKlass* ik = vbox_type->klass()->as_instance_klass();
+  assert(is_vector(ik), "not a vector");
+
+  ciField* fd1 = ik->get_field_by_name(ciSymbol::ETYPE_name(), ciSymbol::class_signature(), /* is_static */ true);
+  assert(fd1 != NULL, "element type info is missing");
+
+  ciConstant val1 = fd1->constant_value();
+  BasicType elem_bt = val1.as_object()->as_instance()->java_mirror_type()->basic_type();
+  assert(is_java_primitive(elem_bt), "element type info is missing");
+
+  ciField* fd2 = ik->get_field_by_name(ciSymbol::VLENGTH_name(), ciSymbol::int_signature(), /* is_static */ true);
+  assert(fd2 != NULL, "vector length info is missing");
+
+  ciConstant val2 = fd2->constant_value();
+  assert(val2.as_int() > 0, "vector length info is missing");
+
+  return true;
+}
+#endif
+
+Node* LibraryCallKit::box_vector(Node* vector, const TypeInstPtr* vbox_type,
+                                 BasicType elem_bt, int num_elem) {
+  assert(EnableVectorSupport, "");
+  const TypeVect* vec_type = TypeVect::make(elem_bt, num_elem);
+
+  VectorBoxAllocateNode* alloc = new VectorBoxAllocateNode(C, vbox_type);
+  set_edges_for_java_call(alloc, /*must_throw=*/false, /*separate_io_proj=*/true);
+  make_slow_call_ex(alloc, env()->Throwable_klass(), /*separate_io_proj=*/true);
+  set_i_o(gvn().transform( new ProjNode(alloc, TypeFunc::I_O) ));
+  set_all_memory(gvn().transform( new ProjNode(alloc, TypeFunc::Memory) ));
+  Node* ret = gvn().transform(new ProjNode(alloc, TypeFunc::Parms));
+
+  assert(check_vbox(vbox_type), "");
+  VectorBoxNode* vbox = new VectorBoxNode(C, ret, vector, vbox_type, vec_type);
+  return gvn().transform(vbox);
+}
+
+Node* LibraryCallKit::unbox_vector(Node* v, const TypeInstPtr* vbox_type, BasicType elem_bt, int num_elem, bool shuffle_to_vector) {
+  assert(EnableVectorSupport, "");
+  const TypeInstPtr* vbox_type_v = gvn().type(v)->is_instptr();
+  if (vbox_type->klass() != vbox_type_v->klass()) {
+    return NULL; // arguments don't agree on vector shapes
+  }
+  if (vbox_type_v->maybe_null()) {
+    return NULL; // no nulls are allowed
+  }
+  assert(check_vbox(vbox_type), "");
+  const TypeVect* vec_type = TypeVect::make(elem_bt, num_elem);
+  Node* unbox = gvn().transform(new VectorUnboxNode(C, vec_type, v, merged_memory(), shuffle_to_vector));
+  return unbox;
+}
+
+// public static
+// 
+// VM unaryOp(int oprId, Class vmClass, Class elementType, int length,
+//            VM vm,
+//            Function defaultImpl) {
+//
+// public static
+// 
+// VM binaryOp(int oprId, Class vmClass, Class elementType, int length,
+//             VM vm1, VM vm2,
+//             BiFunction defaultImpl) {
+//
+// public static
+// 
+// VM ternaryOp(int oprId, Class vmClass, Class elementType, int length,
+//              VM vm1, VM vm2, VM vm3,
+//              TernaryOperation defaultImpl) {
+//
+bool LibraryCallKit::inline_vector_nary_operation(int n) {
+  const TypeInt* opr              = gvn().type(argument(0))->is_int();
+  const TypeInstPtr* vector_klass = gvn().type(argument(1))->is_instptr();
+  const TypeInstPtr* elem_klass   = gvn().type(argument(2))->is_instptr();
+  const TypeInt* vlen             = gvn().type(argument(3))->is_int();
+
+  if (!opr->is_con() || vector_klass->const_oop() == NULL || elem_klass->const_oop() == NULL || !vlen->is_con()) {
+    if (C->print_intrinsics()) {
+      tty->print_cr("  ** missing constant: opr=%s vclass=%s etype=%s vlen=%s",
+                    NodeClassNames[argument(0)->Opcode()],
+                    NodeClassNames[argument(1)->Opcode()],
+                    NodeClassNames[argument(2)->Opcode()],
+                    NodeClassNames[argument(3)->Opcode()]);
+    }
+    return false; // not enough info for intrinsification
+  }
+  ciType* elem_type = elem_klass->const_oop()->as_instance()->java_mirror_type();
+  if (!elem_type->is_primitive_type()) {
+    if (C->print_intrinsics()) {
+      tty->print_cr("  ** not a primitive bt=%d", elem_type->basic_type());
+    }
+    return false; // should be primitive type
+  }
+  if (!is_klass_initialized(vector_klass)) {
+    if (C->print_intrinsics()) {
+      tty->print_cr("  ** klass argument not initialized");
+    }
+    return false;
+  }
+  BasicType elem_bt = elem_type->basic_type();
+  int num_elem = vlen->get_con();
+  int opc = VectorSupport::vop2ideal(opr->get_con(), elem_bt);
+  int sopc = VectorNode::opcode(opc, elem_bt);
+  ciKlass* vbox_klass = vector_klass->const_oop()->as_instance()->java_lang_Class_klass();
+  const TypeInstPtr* vbox_type = TypeInstPtr::make_exact(TypePtr::NotNull, vbox_klass);
+
+  // TODO When mask usage is supported, VecMaskNotUsed needs to be VecMaskUseLoad.
+  if (!arch_supports_vector(sopc, num_elem, elem_bt, is_vector_mask(vbox_klass) ? VecMaskUseAll : VecMaskNotUsed)) {
+    if (C->print_intrinsics()) {
+      tty->print_cr("  ** not supported: arity=%d opc=%d vlen=%d etype=%s ismask=%d",
+                    n, sopc, num_elem, type2name(elem_bt),
+                    is_vector_mask(vbox_klass) ? 1 : 0);
+    }
+    return false; // not supported
+  }
+
+  Node* opd1 = NULL; Node* opd2 = NULL; Node* opd3 = NULL;
+  switch (n) {
+    case 3: {
+      opd3 = unbox_vector(argument(6), vbox_type, elem_bt, num_elem);
+      if (opd3 == NULL) {
+        if (C->print_intrinsics()) {
+          tty->print_cr("  ** unbox failed v3=%s",
+                        NodeClassNames[argument(6)->Opcode()]);
+        }
+        return false;
+      }
+      // fall-through
+    }
+    case 2: {
+      opd2 = unbox_vector(argument(5), vbox_type, elem_bt, num_elem);
+      if (opd2 == NULL) {
+        if (C->print_intrinsics()) {
+          tty->print_cr("  ** unbox failed v2=%s",
+                        NodeClassNames[argument(5)->Opcode()]);
+        }
+        return false;
+      }
+      // fall-through
+    }
+    case 1: {
+      opd1 = unbox_vector(argument(4), vbox_type, elem_bt, num_elem);
+      if (opd1 == NULL) {
+        if (C->print_intrinsics()) {
+          tty->print_cr("  ** unbox failed v1=%s",
+                        NodeClassNames[argument(4)->Opcode()]);
+        }
+        return false;
+      }
+      break;
+    }
+    default: fatal("unsupported arity: %d", n);
+  }
+
+  Node* operation = NULL;
+  const TypeVect* vt = TypeVect::make(elem_bt, num_elem);
+  switch (n) {
+    case 1:
+    case 2: {
+      operation = gvn().transform(VectorNode::make(sopc, opd1, opd2, vt));
+      break;
+    }
+    case 3: {
+      operation = gvn().transform(VectorNode::make(sopc, opd1, opd2, opd3, vt));
+      break;
+    }
+    default: fatal("unsupported arity: %d", n);
+  }
+  // Wrap it up in VectorBox to keep object type information.
+  Node* vbox = box_vector(operation, vbox_type, elem_bt, num_elem);
+  set_result(vbox);
+  C->set_max_vector_size(MAX2(C->max_vector_size(), (uint)(num_elem * type2aelembytes(elem_bt))));
+  return true;
+}
+
+// ,  E>
+//  Sh ShuffleIota(Class E, Class ShuffleClass, Vector.Species s, int length,
+//                  int start, int step, int wrap, ShuffleIotaOperation defaultImpl)
+bool LibraryCallKit::inline_vector_shuffle_iota() {
+  const TypeInstPtr* shuffle_klass = gvn().type(argument(1))->is_instptr();
+  const TypeInt* vlen             = gvn().type(argument(3))->is_int();
+  Node* start                     = argument(4);
+  const TypeInt* start_val        = gvn().type(start)->is_int();
+  Node* step                      = argument(5);
+  const TypeInt* step_val         = gvn().type(step)->is_int();
+  const TypeInt* wrap             = gvn().type(argument(6))->is_int();
+
+  if (!vlen->is_con() || !is_power_of_2(vlen->get_con()) ||
+      shuffle_klass->const_oop() == NULL || !wrap->is_con()) {
+    return false; // not enough info for intrinsification
+  }
+  if (!is_klass_initialized(shuffle_klass)) {
+    if (C->print_intrinsics()) {
+      tty->print_cr("  ** klass argument not initialized");
+    }
+    return false;
+  }
+
+  int do_wrap = wrap->get_con();
+  int num_elem = vlen->get_con();
+  BasicType elem_bt = T_BYTE;
+
+  if (num_elem < 4)
+    return false;
+
+  if (!arch_supports_vector(VectorNode::replicate_opcode(elem_bt), num_elem, elem_bt, VecMaskNotUsed)) {
+    return false;
+  }
+  if (!arch_supports_vector(Op_AddVB, num_elem, elem_bt, VecMaskNotUsed)) {
+    return false;
+  }
+  if (!arch_supports_vector(Op_AndV, num_elem, elem_bt, VecMaskNotUsed)) {
+    return false;
+  }
+  if (!arch_supports_vector(Op_VectorBlend, num_elem, elem_bt, VecMaskUseLoad)) {
+    return false;
+  }
+  if (!arch_supports_vector(Op_VectorMaskCmp, num_elem, elem_bt, VecMaskUseStore)) {
+    return false;
+  }
+
+  const Type * type_bt = Type::get_const_basic_type(elem_bt);
+  const TypeVect * vt  = TypeVect::make(type_bt, num_elem);
+
+  Node* res =  gvn().transform(new VectorLoadConstNode(gvn().makecon(TypeInt::ZERO), vt));
+
+  if(!step_val->is_con() || !is_power_of_2(step_val->get_con())) {
+    Node* bcast_step     = gvn().transform(VectorNode::scalar2vector(step, num_elem, type_bt));
+    res = gvn().transform(VectorNode::make(Op_MulI, res, bcast_step, num_elem, elem_bt));
+  } else if (step_val->get_con() > 1) {
+    Node* cnt = gvn().makecon(TypeInt::make(log2_int(step_val->get_con())));
+    res = gvn().transform(VectorNode::make(Op_LShiftVB, res, cnt, vt));
+  }
+
+  if (!start_val->is_con() || start_val->get_con() != 0) {
+    Node* bcast_start    = gvn().transform(VectorNode::scalar2vector(start, num_elem, type_bt));
+    res = gvn().transform(VectorNode::make(Op_AddI, res, bcast_start, num_elem, elem_bt));
+  }
+
+  Node * mod_val = gvn().makecon(TypeInt::make(num_elem-1));
+  Node * bcast_mod  = gvn().transform(VectorNode::scalar2vector(mod_val, num_elem, type_bt));
+  if(do_wrap)  {
+    // Wrap the indices greater than lane count.
+    res = gvn().transform(VectorNode::make(Op_AndI, res, bcast_mod, num_elem, elem_bt));
+  } else {
+    ConINode* pred_node = (ConINode*)gvn().makecon(TypeInt::make(1));
+    Node * lane_cnt  = gvn().makecon(TypeInt::make(num_elem));
+    Node * bcast_lane_cnt = gvn().transform(VectorNode::scalar2vector(lane_cnt, num_elem, type_bt));
+    Node* mask = gvn().transform(new VectorMaskCmpNode(BoolTest::ge, bcast_lane_cnt, res, pred_node, vt));
+
+    // Make the indices greater than lane count as -ve values. This matches the java side implementation.
+    res = gvn().transform(VectorNode::make(Op_AndI, res, bcast_mod, num_elem, elem_bt));
+    Node * biased_val = gvn().transform(VectorNode::make(Op_SubI, res, bcast_lane_cnt, num_elem, elem_bt));
+    res = gvn().transform(new VectorBlendNode(biased_val, res, mask));
+  }
+
+  ciKlass* sbox_klass = shuffle_klass->const_oop()->as_instance()->java_lang_Class_klass();
+  const TypeInstPtr* shuffle_box_type = TypeInstPtr::make_exact(TypePtr::NotNull, sbox_klass);
+
+  // Wrap it up in VectorBox to keep object type information.
+  res = box_vector(res, shuffle_box_type, elem_bt, num_elem);
+  set_result(res);
+  C->set_max_vector_size(MAX2(C->max_vector_size(), (uint)(num_elem * type2aelembytes(elem_bt))));
+  return true;
+}
+
+// , E>
+// VM shuffleToVector(Class VecClass, ClassE , Class ShuffleClass, Sh s, int length,
+//                    ShuffleToVectorOperation defaultImpl)
+bool LibraryCallKit::inline_vector_shuffle_to_vector() {
+  const TypeInstPtr* vector_klass  = gvn().type(argument(0))->is_instptr();
+  const TypeInstPtr* elem_klass    = gvn().type(argument(1))->is_instptr();
+  const TypeInstPtr* shuffle_klass = gvn().type(argument(2))->is_instptr();
+  Node* shuffle                    = argument(3);
+  const TypeInt* vlen              = gvn().type(argument(4))->is_int();
+
+  if (!vlen->is_con() || vector_klass->const_oop() == NULL || shuffle_klass->const_oop() == NULL) {
+    return false; // not enough info for intrinsification
+  }
+  if (!is_klass_initialized(shuffle_klass) || !is_klass_initialized(vector_klass) ) {
+    if (C->print_intrinsics()) {
+      tty->print_cr("  ** klass argument not initialized");
+    }
+    return false;
+  }
+
+  int num_elem = vlen->get_con();
+  ciType* elem_type = elem_klass->const_oop()->as_instance()->java_mirror_type();
+  BasicType elem_bt = elem_type->basic_type();
+
+  if (num_elem < 4) {
+    return false;
+  }
+
+  int cast_vopc = VectorCastNode::opcode(T_BYTE); // from shuffle of type T_BYTE
+  // Make sure that cast is implemented to particular type/size combination.
+  if (!arch_supports_vector(cast_vopc, num_elem, elem_bt, VecMaskNotUsed)) {
+    if (C->print_intrinsics()) {
+      tty->print_cr("  ** not supported: arity=1 op=cast#%d/3 vlen2=%d etype2=%s",
+        cast_vopc, num_elem, type2name(elem_bt));
+    }
+    return false;
+  }
+
+  ciKlass* sbox_klass = shuffle_klass->const_oop()->as_instance()->java_lang_Class_klass();
+  const TypeInstPtr* shuffle_box_type = TypeInstPtr::make_exact(TypePtr::NotNull, sbox_klass);
+
+  // Unbox shuffle with true flag to indicate its load shuffle to vector
+  Node* shuffle_vec = unbox_vector(shuffle, shuffle_box_type, elem_bt, num_elem, true);
+
+  ciKlass* vbox_klass = vector_klass->const_oop()->as_instance()->java_lang_Class_klass();
+  const TypeInstPtr* vec_box_type = TypeInstPtr::make_exact(TypePtr::NotNull, vbox_klass);
+
+  // Box vector
+  Node* res = box_vector(shuffle_vec, vec_box_type, elem_bt, num_elem);
+  set_result(res);
+  C->set_max_vector_size(MAX2(C->max_vector_size(), (uint)(num_elem * type2aelembytes(elem_bt))));
+  return true;
+}
+
+// >
+// V broadcastCoerced(Class vectorClass, Class elementType, int vlen,
+//                    long bits,
+//                    LongFunction defaultImpl)
+bool LibraryCallKit::inline_vector_broadcast_coerced() {
+  const TypeInstPtr* vector_klass = gvn().type(argument(0))->is_instptr();
+  const TypeInstPtr* elem_klass   = gvn().type(argument(1))->is_instptr();
+  const TypeInt* vlen             = gvn().type(argument(2))->is_int();
+
+  if (vector_klass->const_oop() == NULL || elem_klass->const_oop() == NULL || !vlen->is_con()) {
+    if (C->print_intrinsics()) {
+      tty->print_cr("  ** missing constant: vclass=%s etype=%s vlen=%s",
+                    NodeClassNames[argument(0)->Opcode()],
+                    NodeClassNames[argument(1)->Opcode()],
+                    NodeClassNames[argument(2)->Opcode()]);
+    }
+    return false; // not enough info for intrinsification
+  }
+
+  if (!is_klass_initialized(vector_klass)) {
+    if (C->print_intrinsics()) {
+      tty->print_cr("  ** klass argument not initialized");
+    }
+    return false;
+  }
+  ciType* elem_type = elem_klass->const_oop()->as_instance()->java_mirror_type();
+  if (!elem_type->is_primitive_type()) {
+    if (C->print_intrinsics()) {
+      tty->print_cr("  ** not a primitive bt=%d", elem_type->basic_type());
+    }
+    return false; // should be primitive type
+  }
+  BasicType elem_bt = elem_type->basic_type();
+  int num_elem = vlen->get_con();
+  ciKlass* vbox_klass = vector_klass->const_oop()->as_instance()->java_lang_Class_klass();
+  const TypeInstPtr* vbox_type = TypeInstPtr::make_exact(TypePtr::NotNull, vbox_klass);
+
+  // TODO When mask usage is supported, VecMaskNotUsed needs to be VecMaskUseLoad.
+  if (!arch_supports_vector(VectorNode::replicate_opcode(elem_bt), num_elem, elem_bt,
+                            (is_vector_mask(vbox_klass) ? VecMaskUseStore : VecMaskNotUsed), true /*has_scalar_args*/)) {
+    if (C->print_intrinsics()) {
+      tty->print_cr("  ** not supported: arity=0 op=broadcast vlen=%d etype=%s ismask=%d",
+                    num_elem, type2name(elem_bt),
+                    is_vector_mask(vbox_klass) ? 1 : 0);
+    }
+    return false; // not supported
+  }
+
+  Node* bits = argument(3); // long
+
+  Node* elem = NULL;
+  switch (elem_bt) {
+    case T_BOOLEAN: // fall-through
+    case T_BYTE:    // fall-through
+    case T_SHORT:   // fall-through
+    case T_CHAR:    // fall-through
+    case T_INT: {
+      elem = gvn().transform(new ConvL2INode(bits));
+      break;
+    }
+    case T_DOUBLE: {
+      elem = gvn().transform(new MoveL2DNode(bits));
+      break;
+    }
+    case T_FLOAT: {
+      bits = gvn().transform(new ConvL2INode(bits));
+      elem = gvn().transform(new MoveI2FNode(bits));
+      break;
+    }
+    case T_LONG: {
+      elem = bits; // no conversion needed
+      break;
+    }
+    default: fatal("%s", type2name(elem_bt));
+  }
+
+  Node* broadcast = VectorNode::scalar2vector(elem, num_elem, Type::get_const_basic_type(elem_bt));
+  broadcast = gvn().transform(broadcast);
+
+  Node* box = box_vector(broadcast, vbox_type, elem_bt, num_elem);
+  set_result(box);
+  C->set_max_vector_size(MAX2(C->max_vector_size(), (uint)(num_elem * type2aelembytes(elem_bt))));
+  return true;
+}
+
+//    >
+//    V load(Class vectorClass, Class elementType, int vlen,
+//           Object base, long offset,
+//           /* Vector.Mask m*/
+//           Object container, int index,
+//           LoadOperation defaultImpl) {
+//
+//    >
+//    void store(Class vectorClass, Class elementType, int vlen,
+//               Object base, long offset,
+//               V v, /*Vector.Mask m*/
+//               Object container, int index,
+//               StoreVectorOperation defaultImpl) {
+
+bool LibraryCallKit::inline_vector_mem_operation(bool is_store) {
+  const TypeInstPtr* vector_klass = gvn().type(argument(0))->is_instptr();
+  const TypeInstPtr* elem_klass   = gvn().type(argument(1))->is_instptr();
+  const TypeInt* vlen             = gvn().type(argument(2))->is_int();
+
+  if (vector_klass->const_oop() == NULL || elem_klass->const_oop() == NULL || !vlen->is_con()) {
+    if (C->print_intrinsics()) {
+      tty->print_cr("  ** missing constant: vclass=%s etype=%s vlen=%s",
+                    NodeClassNames[argument(0)->Opcode()],
+                    NodeClassNames[argument(1)->Opcode()],
+                    NodeClassNames[argument(2)->Opcode()]);
+    }
+    return false; // not enough info for intrinsification
+  }
+  if (!is_klass_initialized(vector_klass)) {
+    if (C->print_intrinsics()) {
+      tty->print_cr("  ** klass argument not initialized");
+    }
+    return false;
+  }
+
+  ciType* elem_type = elem_klass->const_oop()->as_instance()->java_mirror_type();
+  if (!elem_type->is_primitive_type()) {
+    if (C->print_intrinsics()) {
+      tty->print_cr("  ** not a primitive bt=%d", elem_type->basic_type());
+    }
+    return false; // should be primitive type
+  }
+  BasicType elem_bt = elem_type->basic_type();
+  int num_elem = vlen->get_con();
+
+  // TODO When mask usage is supported, VecMaskNotUsed needs to be VecMaskUseLoad.
+  if (!arch_supports_vector(is_store ? Op_StoreVector : Op_LoadVector, num_elem, elem_bt, VecMaskNotUsed)) {
+    if (C->print_intrinsics()) {
+      tty->print_cr("  ** not supported: arity=%d op=%s vlen=%d etype=%s ismask=no",
+                    is_store, is_store ? "store" : "load",
+                    num_elem, type2name(elem_bt));
+    }
+    return false; // not supported
+  }
+
+  ciKlass* vbox_klass = vector_klass->const_oop()->as_instance()->java_lang_Class_klass();
+  bool is_mask = is_vector_mask(vbox_klass);
+
+  Node* base = argument(3);
+  Node* offset = ConvL2X(argument(4));
+  DecoratorSet decorators = C2_UNSAFE_ACCESS;
+  Node* addr = make_unsafe_address(base, offset, decorators, (is_mask ? T_BOOLEAN : elem_bt), true);
+
+  // Can base be NULL? Otherwise, always on-heap access.
+  bool can_access_non_heap = TypePtr::NULL_PTR->higher_equal(gvn().type(base));
+
+  const TypePtr *addr_type = gvn().type(addr)->isa_ptr();
+  const TypeAryPtr* arr_type = addr_type->isa_aryptr();
+
+  // Now handle special case where load/store happens from/to byte array but element type is not byte.
+  bool using_byte_array = arr_type != NULL && arr_type->elem()->array_element_basic_type() == T_BYTE && elem_bt != T_BYTE;
+  // Handle loading masks.
+  // If there is no consistency between array and vector element types, it must be special byte array case or loading masks
+  if (arr_type != NULL && !using_byte_array && elem_bt != arr_type->elem()->array_element_basic_type() && !is_mask) {
+    return false;
+  }
+  // Since we are using byte array, we need to double check that the byte operations are supported by backend.
+  if (using_byte_array) {
+    int byte_num_elem = num_elem * type2aelembytes(elem_bt);
+    if (!arch_supports_vector(is_store ? Op_StoreVector : Op_LoadVector, byte_num_elem, T_BYTE, VecMaskNotUsed)) {
+      if (C->print_intrinsics()) {
+        tty->print_cr("  ** not supported: arity=%d op=%s vlen=%d*8 etype=%s/8 ismask=no",
+                      is_store, is_store ? "store" : "load",
+                      byte_num_elem, type2name(elem_bt));
+      }
+      return false; // not supported
+    }
+  }
+  if (is_mask) {
+    if (!arch_supports_vector(Op_LoadVector, num_elem, T_BOOLEAN, VecMaskNotUsed)) {
+      if (C->print_intrinsics()) {
+        tty->print_cr("  ** not supported: arity=%d op=%s/mask vlen=%d etype=bit ismask=no",
+                      is_store, is_store ? "store" : "load",
+                      num_elem);
+      }
+      return false; // not supported
+    }
+    if (!is_store) {
+      if (!arch_supports_vector(Op_LoadVector, num_elem, elem_bt, VecMaskUseLoad)) {
+        return false; // not supported
+      }
+    } else {
+         if (!arch_supports_vector(Op_StoreVector, num_elem, elem_bt, VecMaskUseStore)) {
+           return false; // not supported
+         }
+    }
+  }
+
+  const TypeInstPtr* vbox_type = TypeInstPtr::make_exact(TypePtr::NotNull, vbox_klass);
+
+  if (can_access_non_heap) {
+    insert_mem_bar(Op_MemBarCPUOrder);
+  }
+
+  if (is_store) {
+    Node* val = unbox_vector(argument(6), vbox_type, elem_bt, num_elem);
+    if (val == NULL) {
+      return false; // operand unboxing failed
+    }
+    set_all_memory(reset_memory());
+
+    // In case the store needs to happen to byte array, reinterpret the incoming vector to byte vector.
+    int store_num_elem = num_elem;
+    if (using_byte_array) {
+      store_num_elem = num_elem * type2aelembytes(elem_bt);
+      const TypeVect* to_vect_type = TypeVect::make(T_BYTE, store_num_elem);
+      val = gvn().transform(new VectorReinterpretNode(val, val->bottom_type()->is_vect(), to_vect_type));
+    }
+
+    Node* vstore = gvn().transform(StoreVectorNode::make(0, control(), memory(addr), addr, addr_type, val, store_num_elem));
+    set_memory(vstore, addr_type);
+  } else {
+    // When using byte array, we need to load as byte then reinterpret the value. Otherwise, do a simple vector load.
+    Node* vload = NULL;
+    if (using_byte_array) {
+      int load_num_elem = num_elem * type2aelembytes(elem_bt);
+      vload = gvn().transform(LoadVectorNode::make(0, control(), memory(addr), addr, addr_type, load_num_elem, T_BYTE));
+      const TypeVect* to_vect_type = TypeVect::make(elem_bt, num_elem);
+      vload = gvn().transform(new VectorReinterpretNode(vload, vload->bottom_type()->is_vect(), to_vect_type));
+    } else {
+      // Special handle for masks
+      if (is_mask) {
+          vload = gvn().transform(LoadVectorNode::make(0, control(), memory(addr), addr, addr_type, num_elem, T_BOOLEAN));
+          const TypeVect* to_vect_type = TypeVect::make(elem_bt, num_elem);
+          vload = gvn().transform(new VectorLoadMaskNode(vload, to_vect_type));
+      } else {
+          vload = gvn().transform(LoadVectorNode::make(0, control(), memory(addr), addr, addr_type, num_elem, elem_bt));
+      }
+    }
+    Node* box = box_vector(vload, vbox_type, elem_bt, num_elem);
+    set_result(box);
+  }
+
+  if (can_access_non_heap) {
+    insert_mem_bar(Op_MemBarCPUOrder);
+  }
+
+  C->set_max_vector_size(MAX2(C->max_vector_size(), (uint)(num_elem * type2aelembytes(elem_bt))));
+  return true;
+}
+
+//   , W extends IntVector, E, S extends VectorSpecies>
+//   void loadWithMap(Class vectorClass, Class E, int length, Class vectorIndexClass,
+//                    Object base, long offset, // Unsafe addressing
+//                    W index_vector,
+//                    C container, int index, int[] indexMap, int indexM, S s, // Arguments for default implementation
+//                    LoadVectorOperationWithMap defaultImpl)
+//
+//    , W extends IntVector>
+//    void storeWithMap(Class vectorClass, Class elementType, int length, Class vectorIndexClass,
+//                      Object base, long offset,    // Unsafe addressing
+//                      W index_vector, V v,
+//                      C container, int index, int[] indexMap, int indexM, // Arguments for default implementation
+//                      StoreVectorOperationWithMap defaultImpl) {
+//
+bool LibraryCallKit::inline_vector_gather_scatter(bool is_scatter) {
+  const TypeInstPtr* vector_klass     = gvn().type(argument(0))->is_instptr();
+  const TypeInstPtr* elem_klass       = gvn().type(argument(1))->is_instptr();
+  const TypeInt* vlen                 = gvn().type(argument(2))->is_int();
+  const TypeInstPtr* vector_idx_klass = gvn().type(argument(3))->is_instptr();
+
+  if (vector_klass->const_oop() == NULL || elem_klass->const_oop() == NULL || vector_idx_klass->const_oop() == NULL || !vlen->is_con()) {
+    if (C->print_intrinsics()) {
+      tty->print_cr("  ** missing constant: vclass=%s etype=%s vlen=%s viclass=%s",
+                    NodeClassNames[argument(0)->Opcode()],
+                    NodeClassNames[argument(1)->Opcode()],
+                    NodeClassNames[argument(2)->Opcode()],
+                    NodeClassNames[argument(3)->Opcode()]);
+    }
+    return false; // not enough info for intrinsification
+  }
+
+  if (!is_klass_initialized(vector_klass) || !is_klass_initialized(vector_idx_klass)) {
+    if (C->print_intrinsics()) {
+      tty->print_cr("  ** klass argument not initialized");
+    }
+    return false;
+  }
+  ciType* elem_type = elem_klass->const_oop()->as_instance()->java_mirror_type();
+  if (!elem_type->is_primitive_type()) {
+    if (C->print_intrinsics()) {
+      tty->print_cr("  ** not a primitive bt=%d", elem_type->basic_type());
+    }
+    return false; // should be primitive type
+  }
+  BasicType elem_bt = elem_type->basic_type();
+  int num_elem = vlen->get_con();
+
+  if (!arch_supports_vector(is_scatter ? Op_StoreVectorScatter : Op_LoadVectorGather, num_elem, elem_bt, VecMaskNotUsed)) {
+    if (C->print_intrinsics()) {
+      tty->print_cr("  ** not supported: arity=%d op=%s vlen=%d etype=%s ismask=no",
+                    is_scatter, is_scatter ? "scatter" : "gather",
+                    num_elem, type2name(elem_bt));
+    }
+    return false; // not supported
+  }
+
+  // Check that the vector holding indices is supported by architecture
+  if (!arch_supports_vector(Op_LoadVector, num_elem, T_INT, VecMaskNotUsed)) {
+      if (C->print_intrinsics()) {
+        tty->print_cr("  ** not supported: arity=%d op=%s/loadindex vlen=%d etype=int ismask=no",
+                      is_scatter, is_scatter ? "scatter" : "gather",
+                      num_elem);
+      }
+      return false; // not supported
+    }
+
+  Node* base = argument(4);
+  Node* offset = ConvL2X(argument(5));
+  Node* addr = make_unsafe_address(base, offset, C2_UNSAFE_ACCESS, elem_bt, true);
+
+  const TypePtr *addr_type = gvn().type(addr)->isa_ptr();
+  const TypeAryPtr* arr_type = addr_type->isa_aryptr();
+
+  // The array must be consistent with vector type
+  if (arr_type == NULL || (arr_type != NULL && elem_bt != arr_type->elem()->array_element_basic_type())) {
+    return false;
+  }
+  ciKlass* vbox_klass = vector_klass->const_oop()->as_instance()->java_lang_Class_klass();
+  const TypeInstPtr* vbox_type = TypeInstPtr::make_exact(TypePtr::NotNull, vbox_klass);
+
+  ciKlass* vbox_idx_klass = vector_idx_klass->const_oop()->as_instance()->java_lang_Class_klass();
+
+  if (vbox_idx_klass == NULL) {
+    return false;
+  }
+
+  const TypeInstPtr* vbox_idx_type = TypeInstPtr::make_exact(TypePtr::NotNull, vbox_idx_klass);
+
+  Node* index_vect = unbox_vector(argument(7), vbox_idx_type, T_INT, num_elem);
+  if (index_vect == NULL) {
+    return false;
+  }
+  const TypeVect* vector_type = TypeVect::make(elem_bt, num_elem);
+  if (is_scatter) {
+    Node* val = unbox_vector(argument(8), vbox_type, elem_bt, num_elem);
+    if (val == NULL) {
+      return false; // operand unboxing failed
+    }
+    set_all_memory(reset_memory());
+
+    Node* vstore = gvn().transform(new StoreVectorScatterNode(control(), memory(addr), addr, addr_type, val, index_vect));
+    set_memory(vstore, addr_type);
+  } else {
+    Node* vload = gvn().transform(new LoadVectorGatherNode(control(), memory(addr), addr, addr_type, vector_type, index_vect));
+
+    Node* box = box_vector(vload, vbox_type, elem_bt, num_elem);
+    set_result(box);
+  }
+
+  C->set_max_vector_size(MAX2(C->max_vector_size(), (uint)(num_elem * type2aelembytes(elem_bt))));
+  return true;
+}
+
+// >
+// long reductionCoerced(int oprId, Class vectorClass, Class elementType, int vlen,
+//                       V v,
+//                       Function defaultImpl)
+
+bool LibraryCallKit::inline_vector_reduction() {
+  const TypeInt* opr              = gvn().type(argument(0))->is_int();
+  const TypeInstPtr* vector_klass = gvn().type(argument(1))->is_instptr();
+  const TypeInstPtr* elem_klass   = gvn().type(argument(2))->is_instptr();
+  const TypeInt* vlen             = gvn().type(argument(3))->is_int();
+
+  if (!opr->is_con() || vector_klass->const_oop() == NULL || elem_klass->const_oop() == NULL || !vlen->is_con()) {
+    if (C->print_intrinsics()) {
+      tty->print_cr("  ** missing constant: opr=%s vclass=%s etype=%s vlen=%s",
+                    NodeClassNames[argument(0)->Opcode()],
+                    NodeClassNames[argument(1)->Opcode()],
+                    NodeClassNames[argument(2)->Opcode()],
+                    NodeClassNames[argument(3)->Opcode()]);
+    }
+    return false; // not enough info for intrinsification
+  }
+  if (!is_klass_initialized(vector_klass)) {
+    if (C->print_intrinsics()) {
+      tty->print_cr("  ** klass argument not initialized");
+    }
+    return false;
+  }
+  ciType* elem_type = elem_klass->const_oop()->as_instance()->java_mirror_type();
+  if (!elem_type->is_primitive_type()) {
+    if (C->print_intrinsics()) {
+      tty->print_cr("  ** not a primitive bt=%d", elem_type->basic_type());
+    }
+    return false; // should be primitive type
+  }
+  BasicType elem_bt = elem_type->basic_type();
+  int num_elem = vlen->get_con();
+
+  int opc  = VectorSupport::vop2ideal(opr->get_con(), elem_bt);
+  int sopc = ReductionNode::opcode(opc, elem_bt);
+
+  // TODO When mask usage is supported, VecMaskNotUsed needs to be VecMaskUseLoad.
+  if (!arch_supports_vector(sopc, num_elem, elem_bt, VecMaskNotUsed)) {
+    if (C->print_intrinsics()) {
+      tty->print_cr("  ** not supported: arity=1 op=%d/reduce vlen=%d etype=%s ismask=no",
+                    sopc, num_elem, type2name(elem_bt));
+    }
+    return false;
+  }
+
+  ciKlass* vbox_klass = vector_klass->const_oop()->as_instance()->java_lang_Class_klass();
+  const TypeInstPtr* vbox_type = TypeInstPtr::make_exact(TypePtr::NotNull, vbox_klass);
+
+  Node* opd = unbox_vector(argument(4), vbox_type, elem_bt, num_elem);
+  if (opd == NULL) {
+    return false; // operand unboxing failed
+  }
+
+  Node* init = ReductionNode::make_reduction_input(gvn(), opc, elem_bt);
+  Node* rn = gvn().transform(ReductionNode::make(opc, NULL, init, opd, elem_bt));
+
+  Node* bits = NULL;
+  switch (elem_bt) {
+    case T_BYTE:
+    case T_SHORT:
+    case T_INT: {
+      bits = gvn().transform(new ConvI2LNode(rn));
+      break;
+    }
+    case T_FLOAT: {
+      rn   = gvn().transform(new MoveF2INode(rn));
+      bits = gvn().transform(new ConvI2LNode(rn));
+      break;
+    }
+    case T_DOUBLE: {
+      bits = gvn().transform(new MoveD2LNode(rn));
+      break;
+    }
+    case T_LONG: {
+      bits = rn; // no conversion needed
+      break;
+    }
+    default: fatal("%s", type2name(elem_bt));
+  }
+  set_result(bits);
+  C->set_max_vector_size(MAX2(C->max_vector_size(), (uint)(num_elem * type2aelembytes(elem_bt))));
+  return true;
+}
+
+// public static  boolean test(int cond, Class vectorClass, Class elementType, int vlen,
+//                                V v1, V v2,
+//                                BiFunction defaultImpl) {
+//
+bool LibraryCallKit::inline_vector_test() {
+  const TypeInt* cond             = gvn().type(argument(0))->is_int();
+  const TypeInstPtr* vector_klass = gvn().type(argument(1))->is_instptr();
+  const TypeInstPtr* elem_klass   = gvn().type(argument(2))->is_instptr();
+  const TypeInt* vlen             = gvn().type(argument(3))->is_int();
+
+  if (!cond->is_con() || vector_klass->const_oop() == NULL || elem_klass->const_oop() == NULL || !vlen->is_con()) {
+    if (C->print_intrinsics()) {
+      tty->print_cr("  ** missing constant: cond=%s vclass=%s etype=%s vlen=%s",
+                    NodeClassNames[argument(0)->Opcode()],
+                    NodeClassNames[argument(1)->Opcode()],
+                    NodeClassNames[argument(2)->Opcode()],
+                    NodeClassNames[argument(3)->Opcode()]);
+    }
+    return false; // not enough info for intrinsification
+  }
+  if (!is_klass_initialized(vector_klass)) {
+    if (C->print_intrinsics()) {
+      tty->print_cr("  ** klass argument not initialized");
+    }
+    return false;
+  }
+  ciType* elem_type = elem_klass->const_oop()->as_instance()->java_mirror_type();
+  if (!elem_type->is_primitive_type()) {
+    if (C->print_intrinsics()) {
+      tty->print_cr("  ** not a primitive bt=%d", elem_type->basic_type());
+    }
+    return false; // should be primitive type
+  }
+  BasicType elem_bt = elem_type->basic_type();
+  int num_elem = vlen->get_con();
+  BoolTest::mask booltest = (BoolTest::mask)cond->get_con();
+  ciKlass* vbox_klass = vector_klass->const_oop()->as_instance()->java_lang_Class_klass();
+  const TypeInstPtr* vbox_type = TypeInstPtr::make_exact(TypePtr::NotNull, vbox_klass);
+
+  if (!arch_supports_vector(Op_VectorTest, num_elem, elem_bt, is_vector_mask(vbox_klass) ? VecMaskUseLoad : VecMaskNotUsed)) {
+    if (C->print_intrinsics()) {
+      tty->print_cr("  ** not supported: arity=2 op=test/%d vlen=%d etype=%s ismask=%d",
+                    cond->get_con(), num_elem, type2name(elem_bt),
+                    is_vector_mask(vbox_klass));
+    }
+    return false;
+  }
+
+  Node* opd1 = unbox_vector(argument(4), vbox_type, elem_bt, num_elem);
+  Node* opd2 = unbox_vector(argument(5), vbox_type, elem_bt, num_elem);
+  if (opd1 == NULL || opd2 == NULL) {
+    return false; // operand unboxing failed
+  }
+  Node* test = new VectorTestNode(opd1, opd2, booltest);
+  test = gvn().transform(test);
+
+  set_result(test);
+  C->set_max_vector_size(MAX2(C->max_vector_size(), (uint)(num_elem * type2aelembytes(elem_bt))));
+  return true;
+}
+
+// public static
+// 
+// V blend(Class vectorClass, Class maskClass, Class elementType, int vlen,
+//         V v1, V v2, M m,
+//         VectorBlendOp defaultImpl) { ...
+//
+bool LibraryCallKit::inline_vector_blend() {
+  const TypeInstPtr* vector_klass = gvn().type(argument(0))->is_instptr();
+  const TypeInstPtr* mask_klass   = gvn().type(argument(1))->is_instptr();
+  const TypeInstPtr* elem_klass   = gvn().type(argument(2))->is_instptr();
+  const TypeInt*     vlen         = gvn().type(argument(3))->is_int();
+
+  if (mask_klass->const_oop() == NULL || vector_klass->const_oop() == NULL ||
+      elem_klass->const_oop() == NULL || !vlen->is_con()) {
+    if (C->print_intrinsics()) {
+      tty->print_cr("  ** missing constant: vclass=%s mclass=%s etype=%s vlen=%s",
+                    NodeClassNames[argument(0)->Opcode()],
+                    NodeClassNames[argument(1)->Opcode()],
+                    NodeClassNames[argument(2)->Opcode()],
+                    NodeClassNames[argument(3)->Opcode()]);
+    }
+    return false; // not enough info for intrinsification
+  }
+  if (!is_klass_initialized(vector_klass) || !is_klass_initialized(mask_klass)) {
+    if (C->print_intrinsics()) {
+      tty->print_cr("  ** klass argument not initialized");
+    }
+    return false;
+  }
+  ciType* elem_type = elem_klass->const_oop()->as_instance()->java_mirror_type();
+  if (!elem_type->is_primitive_type()) {
+    if (C->print_intrinsics()) {
+      tty->print_cr("  ** not a primitive bt=%d", elem_type->basic_type());
+    }
+    return false; // should be primitive type
+  }
+  BasicType elem_bt = elem_type->basic_type();
+  BasicType mask_bt = elem_bt;
+  int num_elem = vlen->get_con();
+
+  if (!arch_supports_vector(Op_VectorBlend, num_elem, elem_bt, VecMaskUseLoad)) {
+    if (C->print_intrinsics()) {
+      tty->print_cr("  ** not supported: arity=2 op=blend vlen=%d etype=%s ismask=useload",
+                    num_elem, type2name(elem_bt));
+    }
+    return false; // not supported
+  }
+  ciKlass* vbox_klass = vector_klass->const_oop()->as_instance()->java_lang_Class_klass();
+  const TypeInstPtr* vbox_type = TypeInstPtr::make_exact(TypePtr::NotNull, vbox_klass);
+
+  ciKlass* mbox_klass = mask_klass->const_oop()->as_instance()->java_lang_Class_klass();
+  const TypeInstPtr* mbox_type = TypeInstPtr::make_exact(TypePtr::NotNull, mbox_klass);
+
+  Node* v1   = unbox_vector(argument(4), vbox_type, elem_bt, num_elem);
+  Node* v2   = unbox_vector(argument(5), vbox_type, elem_bt, num_elem);
+  Node* mask = unbox_vector(argument(6), mbox_type, mask_bt, num_elem);
+
+  if (v1 == NULL || v2 == NULL || mask == NULL) {
+    return false; // operand unboxing failed
+  }
+
+  Node* blend = gvn().transform(new VectorBlendNode(v1, v2, mask));
+
+  Node* box = box_vector(blend, vbox_type, elem_bt, num_elem);
+  set_result(box);
+  C->set_max_vector_size(MAX2(C->max_vector_size(), (uint)(num_elem * type2aelembytes(elem_bt))));
+  return true;
+}
+
+//  public static ,
+//          M extends Vector.Mask,
+//          S extends Vector.Shape, E>
+//  M compare(int cond, Class vectorClass, Class maskClass, Class elementType, int vlen,
+//            V v1, V v2,
+//            VectorCompareOp defaultImpl) { ...
+//
+bool LibraryCallKit::inline_vector_compare() {
+  const TypeInt*     cond         = gvn().type(argument(0))->is_int();
+  const TypeInstPtr* vector_klass = gvn().type(argument(1))->is_instptr();
+  const TypeInstPtr* mask_klass   = gvn().type(argument(2))->is_instptr();
+  const TypeInstPtr* elem_klass   = gvn().type(argument(3))->is_instptr();
+  const TypeInt*     vlen         = gvn().type(argument(4))->is_int();
+
+  if (!cond->is_con() || vector_klass->const_oop() == NULL || mask_klass->const_oop() == NULL ||
+      elem_klass->const_oop() == NULL || !vlen->is_con()) {
+    if (C->print_intrinsics()) {
+      tty->print_cr("  ** missing constant: cond=%s vclass=%s mclass=%s etype=%s vlen=%s",
+                    NodeClassNames[argument(0)->Opcode()],
+                    NodeClassNames[argument(1)->Opcode()],
+                    NodeClassNames[argument(2)->Opcode()],
+                    NodeClassNames[argument(3)->Opcode()],
+                    NodeClassNames[argument(4)->Opcode()]);
+    }
+    return false; // not enough info for intrinsification
+  }
+  if (!is_klass_initialized(vector_klass) || !is_klass_initialized(mask_klass)) {
+    if (C->print_intrinsics()) {
+      tty->print_cr("  ** klass argument not initialized");
+    }
+    return false;
+  }
+  ciType* elem_type = elem_klass->const_oop()->as_instance()->java_mirror_type();
+  if (!elem_type->is_primitive_type()) {
+    if (C->print_intrinsics()) {
+      tty->print_cr("  ** not a primitive bt=%d", elem_type->basic_type());
+    }
+    return false; // should be primitive type
+  }
+
+  int num_elem = vlen->get_con();
+  BasicType elem_bt = elem_type->basic_type();
+  BasicType mask_bt = elem_bt;
+
+  if (!arch_supports_vector(Op_VectorMaskCmp, num_elem, elem_bt, VecMaskUseStore)) {
+    if (C->print_intrinsics()) {
+      tty->print_cr("  ** not supported: arity=2 op=comp/%d vlen=%d etype=%s ismask=usestore",
+                    cond->get_con(), num_elem, type2name(elem_bt));
+    }
+    return false;
+  }
+
+  ciKlass* vbox_klass = vector_klass->const_oop()->as_instance()->java_lang_Class_klass();
+  const TypeInstPtr* vbox_type = TypeInstPtr::make_exact(TypePtr::NotNull, vbox_klass);
+
+  ciKlass* mbox_klass = mask_klass->const_oop()->as_instance()->java_lang_Class_klass();
+  const TypeInstPtr* mbox_type = TypeInstPtr::make_exact(TypePtr::NotNull, mbox_klass);
+
+  Node* v1 = unbox_vector(argument(5), vbox_type, elem_bt, num_elem);
+  Node* v2 = unbox_vector(argument(6), vbox_type, elem_bt, num_elem);
+
+  if (v1 == NULL || v2 == NULL) {
+    return false; // operand unboxing failed
+  }
+  BoolTest::mask pred = (BoolTest::mask)cond->get_con();
+  ConINode* pred_node = (ConINode*)gvn().makecon(cond);
+
+  const TypeVect* vt = TypeVect::make(mask_bt, num_elem);
+  Node* operation = gvn().transform(new VectorMaskCmpNode(pred, v1, v2, pred_node, vt));
+
+  Node* box = box_vector(operation, mbox_type, mask_bt, num_elem);
+  set_result(box);
+  C->set_max_vector_size(MAX2(C->max_vector_size(), (uint)(num_elem * type2aelembytes(elem_bt))));
+  return true;
+}
+
+// public static
+// 
+//  V rearrangeOp(Class vectorClass, Class shuffleClass, Class< ? > elementType, int vlen,
+//    V v1, Sh sh,
+//    VectorSwizzleOp defaultImpl) { ...
+
+bool LibraryCallKit::inline_vector_rearrange() {
+  const TypeInstPtr* vector_klass = gvn().type(argument(0))->is_instptr();
+  const TypeInstPtr* shuffle_klass = gvn().type(argument(1))->is_instptr();
+  const TypeInstPtr* elem_klass = gvn().type(argument(2))->is_instptr();
+  const TypeInt*     vlen = gvn().type(argument(3))->is_int();
+
+  if (shuffle_klass->const_oop() == NULL || vector_klass->const_oop() == NULL ||
+    elem_klass->const_oop() == NULL || !vlen->is_con()) {
+    if (C->print_intrinsics()) {
+      tty->print_cr("  ** missing constant: vclass=%s sclass=%s etype=%s vlen=%s",
+                    NodeClassNames[argument(0)->Opcode()],
+                    NodeClassNames[argument(1)->Opcode()],
+                    NodeClassNames[argument(2)->Opcode()],
+                    NodeClassNames[argument(3)->Opcode()]);
+    }
+    return false; // not enough info for intrinsification
+  }
+  if (!is_klass_initialized(vector_klass) || !is_klass_initialized(shuffle_klass)) {
+    if (C->print_intrinsics()) {
+      tty->print_cr("  ** klass argument not initialized");
+    }
+    return false;
+  }
+  ciType* elem_type = elem_klass->const_oop()->as_instance()->java_mirror_type();
+  if (!elem_type->is_primitive_type()) {
+    if (C->print_intrinsics()) {
+      tty->print_cr("  ** not a primitive bt=%d", elem_type->basic_type());
+    }
+    return false; // should be primitive type
+  }
+  BasicType elem_bt = elem_type->basic_type();
+  BasicType shuffle_bt = elem_bt;
+  int num_elem = vlen->get_con();
+
+  if (!arch_supports_vector(Op_VectorLoadShuffle, num_elem, elem_bt, VecMaskNotUsed)) {
+    if (C->print_intrinsics()) {
+      tty->print_cr("  ** not supported: arity=0 op=load/shuffle vlen=%d etype=%s ismask=no",
+                    num_elem, type2name(elem_bt));
+    }
+    return false; // not supported
+  }
+  if (!arch_supports_vector(Op_VectorRearrange, num_elem, elem_bt, VecMaskNotUsed)) {
+    if (C->print_intrinsics()) {
+      tty->print_cr("  ** not supported: arity=2 op=shuffle/rearrange vlen=%d etype=%s ismask=no",
+                    num_elem, type2name(elem_bt));
+    }
+    return false; // not supported
+  }
+  ciKlass* vbox_klass = vector_klass->const_oop()->as_instance()->java_lang_Class_klass();
+  const TypeInstPtr* vbox_type = TypeInstPtr::make_exact(TypePtr::NotNull, vbox_klass);
+
+  ciKlass* shbox_klass = shuffle_klass->const_oop()->as_instance()->java_lang_Class_klass();
+  const TypeInstPtr* shbox_type = TypeInstPtr::make_exact(TypePtr::NotNull, shbox_klass);
+
+  Node* v1 = unbox_vector(argument(4), vbox_type, elem_bt, num_elem);
+  Node* shuffle = unbox_vector(argument(5), shbox_type, shuffle_bt, num_elem);
+
+  if (v1 == NULL || shuffle == NULL) {
+    return false; // operand unboxing failed
+  }
+
+  Node* rearrange = gvn().transform(new VectorRearrangeNode(v1, shuffle));
+
+  Node* box = box_vector(rearrange, vbox_type, elem_bt, num_elem);
+  set_result(box);
+  C->set_max_vector_size(MAX2(C->max_vector_size(), (uint)(num_elem * type2aelembytes(elem_bt))));
+  return true;
+}
+
+Node* LibraryCallKit::shift_count(Node* cnt, int shift_op, BasicType bt, int num_elem) {
+  assert(bt == T_INT || bt == T_LONG || bt == T_SHORT || bt == T_BYTE, "byte, short, long and int are supported");
+  juint mask = (type2aelembytes(bt) * BitsPerByte - 1);
+  Node* nmask = gvn().transform(ConNode::make(TypeInt::make(mask)));
+  Node* mcnt = gvn().transform(new AndINode(cnt, nmask));
+  return gvn().transform(VectorNode::shift_count(shift_op, mcnt, num_elem, bt));
+}
+
+//  public static
+//  >
+//  V broadcastInt(int opr, Class vectorClass, Class elementType, int vlen,
+//                 V v, int i,
+//                 VectorBroadcastIntOp defaultImpl) {
+//
+bool LibraryCallKit::inline_vector_broadcast_int() {
+  const TypeInt* opr              = gvn().type(argument(0))->is_int();
+  const TypeInstPtr* vector_klass = gvn().type(argument(1))->is_instptr();
+  const TypeInstPtr* elem_klass   = gvn().type(argument(2))->is_instptr();
+  const TypeInt* vlen             = gvn().type(argument(3))->is_int();
+
+  if (!opr->is_con() || vector_klass->const_oop() == NULL || elem_klass->const_oop() == NULL || !vlen->is_con()) {
+    if (C->print_intrinsics()) {
+      tty->print_cr("  ** missing constant: opr=%s vclass=%s etype=%s vlen=%s",
+                    NodeClassNames[argument(0)->Opcode()],
+                    NodeClassNames[argument(1)->Opcode()],
+                    NodeClassNames[argument(2)->Opcode()],
+                    NodeClassNames[argument(3)->Opcode()]);
+    }
+    return false; // not enough info for intrinsification
+  }
+  if (!is_klass_initialized(vector_klass)) {
+    if (C->print_intrinsics()) {
+      tty->print_cr("  ** klass argument not initialized");
+    }
+    return false;
+  }
+  ciType* elem_type = elem_klass->const_oop()->as_instance()->java_mirror_type();
+  if (!elem_type->is_primitive_type()) {
+    if (C->print_intrinsics()) {
+      tty->print_cr("  ** not a primitive bt=%d", elem_type->basic_type());
+    }
+    return false; // should be primitive type
+  }
+  BasicType elem_bt = elem_type->basic_type();
+  int num_elem = vlen->get_con();
+  int opc = VectorSupport::vop2ideal(opr->get_con(), elem_bt);
+  int sopc = VectorNode::opcode(opc, elem_bt);
+  ciKlass* vbox_klass = vector_klass->const_oop()->as_instance()->java_lang_Class_klass();
+  const TypeInstPtr* vbox_type = TypeInstPtr::make_exact(TypePtr::NotNull, vbox_klass);
+
+  if (!arch_supports_vector(sopc, num_elem, elem_bt, VecMaskNotUsed, true /*has_scalar_args*/)) {
+    if (C->print_intrinsics()) {
+      tty->print_cr("  ** not supported: arity=0 op=int/%d vlen=%d etype=%s ismask=no",
+                    sopc, num_elem, type2name(elem_bt));
+    }
+    return false; // not supported
+  }
+  Node* opd1 = unbox_vector(argument(4), vbox_type, elem_bt, num_elem);
+  Node* opd2 = shift_count(argument(5), opc, elem_bt, num_elem);
+  if (opd1 == NULL || opd2 == NULL) {
+    return false;
+  }
+  Node* operation = gvn().transform(VectorNode::make(opc, opd1, opd2, num_elem, elem_bt));
+
+  Node* vbox = box_vector(operation, vbox_type, elem_bt, num_elem);
+  set_result(vbox);
+  C->set_max_vector_size(MAX2(C->max_vector_size(), (uint)(num_elem * type2aelembytes(elem_bt))));
+  return true;
+}
+
+// public static 
+// VOUT convert(int oprId,
+//           Class fromVectorClass, Class fromElementType, int fromVLen,
+//           Class   toVectorClass, Class   toElementType, int   toVLen,
+//           VIN v, S s,
+//           VectorConvertOp defaultImpl) {
+//
+bool LibraryCallKit::inline_vector_convert() {
+  const TypeInt*     opr               = gvn().type(argument(0))->is_int();
+
+  const TypeInstPtr* vector_klass_from = gvn().type(argument(1))->is_instptr();
+  const TypeInstPtr* elem_klass_from   = gvn().type(argument(2))->is_instptr();
+  const TypeInt*     vlen_from         = gvn().type(argument(3))->is_int();
+
+  const TypeInstPtr* vector_klass_to   = gvn().type(argument(4))->is_instptr();
+  const TypeInstPtr* elem_klass_to     = gvn().type(argument(5))->is_instptr();
+  const TypeInt*     vlen_to           = gvn().type(argument(6))->is_int();
+
+  if (!opr->is_con() ||
+      vector_klass_from->const_oop() == NULL || elem_klass_from->const_oop() == NULL || !vlen_from->is_con() ||
+      vector_klass_to->const_oop() == NULL || elem_klass_to->const_oop() == NULL || !vlen_to->is_con()) {
+    if (C->print_intrinsics()) {
+      tty->print_cr("  ** missing constant: opr=%s vclass_from=%s etype_from=%s vlen_from=%s vclass_to=%s etype_to=%s vlen_to=%s",
+                    NodeClassNames[argument(0)->Opcode()],
+                    NodeClassNames[argument(1)->Opcode()],
+                    NodeClassNames[argument(2)->Opcode()],
+                    NodeClassNames[argument(3)->Opcode()],
+                    NodeClassNames[argument(4)->Opcode()],
+                    NodeClassNames[argument(5)->Opcode()],
+                    NodeClassNames[argument(6)->Opcode()]);
+    }
+    return false; // not enough info for intrinsification
+  }
+  if (!is_klass_initialized(vector_klass_from) || !is_klass_initialized(vector_klass_to)) {
+    if (C->print_intrinsics()) {
+      tty->print_cr("  ** klass argument not initialized");
+    }
+    return false;
+  }
+
+  assert(opr->get_con() == VectorSupport::VECTOR_OP_CAST ||
+         opr->get_con() == VectorSupport::VECTOR_OP_REINTERPRET, "wrong opcode");
+  bool is_cast = (opr->get_con() == VectorSupport::VECTOR_OP_CAST);
+
+  ciKlass* vbox_klass_from = vector_klass_from->const_oop()->as_instance()->java_lang_Class_klass();
+  ciKlass* vbox_klass_to = vector_klass_to->const_oop()->as_instance()->java_lang_Class_klass();
+  if (is_vector_shuffle(vbox_klass_from) || is_vector_shuffle(vbox_klass_to)) {
+    return false; // vector shuffles aren't supported
+  }
+  bool is_mask = is_vector_mask(vbox_klass_from);
+
+  ciType* elem_type_from = elem_klass_from->const_oop()->as_instance()->java_mirror_type();
+  if (!elem_type_from->is_primitive_type()) {
+    return false; // should be primitive type
+  }
+  BasicType elem_bt_from = elem_type_from->basic_type();
+  ciType* elem_type_to = elem_klass_to->const_oop()->as_instance()->java_mirror_type();
+  if (!elem_type_to->is_primitive_type()) {
+    return false; // should be primitive type
+  }
+  BasicType elem_bt_to = elem_type_to->basic_type();
+  if (is_mask && elem_bt_from != elem_bt_to) {
+    return false; // type mismatch
+  }
+  int num_elem_from = vlen_from->get_con();
+  int num_elem_to = vlen_to->get_con();
+
+  // Check whether we can unbox to appropriate size. Even with casting, checking for reinterpret is needed
+  // since we may need to change size.
+  if (!arch_supports_vector(Op_VectorReinterpret,
+                            num_elem_from,
+                            elem_bt_from,
+                            is_mask ? VecMaskUseAll : VecMaskNotUsed)) {
+    if (C->print_intrinsics()) {
+      tty->print_cr("  ** not supported: arity=1 op=%s/1 vlen1=%d etype1=%s ismask=%d",
+                    is_cast ? "cast" : "reinterpret",
+                    num_elem_from, type2name(elem_bt_from), is_mask);
+    }
+    return false;
+  }
+
+  // Check whether we can support resizing/reinterpreting to the new size.
+  if (!arch_supports_vector(Op_VectorReinterpret,
+                            num_elem_to,
+                            elem_bt_to,
+                            is_mask ? VecMaskUseAll : VecMaskNotUsed)) {
+    if (C->print_intrinsics()) {
+      tty->print_cr("  ** not supported: arity=1 op=%s/2 vlen2=%d etype2=%s ismask=%d",
+                    is_cast ? "cast" : "reinterpret",
+                    num_elem_to, type2name(elem_bt_to), is_mask);
+    }
+    return false;
+  }
+
+  // At this point, we know that both input and output vector registers are supported
+  // by the architecture. Next check if the casted type is simply to same type - which means
+  // that it is actually a resize and not a cast.
+  if (is_cast && elem_bt_from == elem_bt_to) {
+    is_cast = false;
+  }
+
+  const TypeInstPtr* vbox_type_from = TypeInstPtr::make_exact(TypePtr::NotNull, vbox_klass_from);
+
+  Node* opd1 = unbox_vector(argument(7), vbox_type_from, elem_bt_from, num_elem_from);
+  if (opd1 == NULL) {
+    return false;
+  }
+
+  const TypeVect* src_type = TypeVect::make(elem_bt_from, num_elem_from);
+  const TypeVect* dst_type = TypeVect::make(elem_bt_to,   num_elem_to);
+
+  Node* op = opd1;
+  if (is_cast) {
+    assert(!is_mask, "masks cannot be casted");
+    int cast_vopc = VectorCastNode::opcode(elem_bt_from);
+    // Make sure that cast is implemented to particular type/size combination.
+    if (!arch_supports_vector(cast_vopc, num_elem_to, elem_bt_to, VecMaskNotUsed)) {
+      if (C->print_intrinsics()) {
+        tty->print_cr("  ** not supported: arity=1 op=cast#%d/3 vlen2=%d etype2=%s ismask=%d",
+                      cast_vopc,
+                      num_elem_to, type2name(elem_bt_to), is_mask);
+      }
+      return false;
+    }
+
+    if (num_elem_from < num_elem_to) {
+      // Since input and output number of elements are not consistent, we need to make sure we
+      // properly size. Thus, first make a cast that retains the number of elements from source.
+      // In case the size exceeds the arch size, we do the minimum.
+      int num_elem_for_cast = MIN2(num_elem_from, Matcher::max_vector_size(elem_bt_to));
+
+      // It is possible that arch does not support this intermediate vector size
+      // TODO More complex logic required here to handle this corner case for the sizes.
+      if (!arch_supports_vector(cast_vopc, num_elem_for_cast, elem_bt_to, VecMaskNotUsed)) {
+        if (C->print_intrinsics()) {
+          tty->print_cr("  ** not supported: arity=1 op=cast#%d/4 vlen1=%d etype2=%s ismask=%d",
+                        cast_vopc,
+                        num_elem_for_cast, type2name(elem_bt_to), is_mask);
+        }
+        return false;
+      }
+
+      op = gvn().transform(VectorCastNode::make(cast_vopc, op, elem_bt_to, num_elem_for_cast));
+      // Now ensure that the destination gets properly resized to needed size.
+      op = gvn().transform(new VectorReinterpretNode(op, op->bottom_type()->is_vect(), dst_type));
+    } else if (num_elem_from > num_elem_to) {
+      // Since number elements from input is larger than output, simply reduce size of input (we are supposed to
+      // drop top elements anyway).
+      int num_elem_for_resize = MAX2(num_elem_to, Matcher::min_vector_size(elem_bt_to));
+
+      // It is possible that arch does not support this intermediate vector size
+      // TODO More complex logic required here to handle this corner case for the sizes.
+      if (!arch_supports_vector(Op_VectorReinterpret,
+                                num_elem_for_resize,
+                                elem_bt_from,
+                                VecMaskNotUsed)) {
+        if (C->print_intrinsics()) {
+          tty->print_cr("  ** not supported: arity=1 op=cast/5 vlen2=%d etype1=%s ismask=%d",
+                        num_elem_for_resize, type2name(elem_bt_from), is_mask);
+        }
+        return false;
+      }
+
+      op = gvn().transform(new VectorReinterpretNode(op,
+                                                     src_type,
+                                                     TypeVect::make(elem_bt_from,
+                                                                    num_elem_for_resize)));
+      op = gvn().transform(VectorCastNode::make(cast_vopc, op, elem_bt_to, num_elem_to));
+    } else {
+      // Since input and output number of elements match, and since we know this vector size is
+      // supported, simply do a cast with no resize needed.
+      op = gvn().transform(VectorCastNode::make(cast_vopc, op, elem_bt_to, num_elem_to));
+    }
+  } else if (Type::cmp(src_type, dst_type) != 0) {
+    assert(!is_cast, "must be reinterpret");
+    op = gvn().transform(new VectorReinterpretNode(op, src_type, dst_type));
+  }
+
+  const TypeInstPtr* vbox_type_to = TypeInstPtr::make_exact(TypePtr::NotNull, vbox_klass_to);
+  Node* vbox = box_vector(op, vbox_type_to, elem_bt_to, num_elem_to);
+  set_result(vbox);
+  C->set_max_vector_size(MAX2(C->max_vector_size(), (uint)(num_elem_to * type2aelembytes(elem_bt_to))));
+  return true;
+}
+
+//  public static
+//  >
+//  V insert(Class vectorClass, Class elementType, int vlen,
+//           V vec, int ix, long val,
+//           VecInsertOp defaultImpl) {
+//
+bool LibraryCallKit::inline_vector_insert() {
+  const TypeInstPtr* vector_klass = gvn().type(argument(0))->is_instptr();
+  const TypeInstPtr* elem_klass   = gvn().type(argument(1))->is_instptr();
+  const TypeInt* vlen             = gvn().type(argument(2))->is_int();
+  const TypeInt* idx              = gvn().type(argument(4))->is_int();
+
+  if (vector_klass->const_oop() == NULL || elem_klass->const_oop() == NULL || !vlen->is_con() || !idx->is_con()) {
+    if (C->print_intrinsics()) {
+      tty->print_cr("  ** missing constant: vclass=%s etype=%s vlen=%s idx=%s",
+                    NodeClassNames[argument(0)->Opcode()],
+                    NodeClassNames[argument(1)->Opcode()],
+                    NodeClassNames[argument(2)->Opcode()],
+                    NodeClassNames[argument(4)->Opcode()]);
+    }
+    return false; // not enough info for intrinsification
+  }
+  if (!is_klass_initialized(vector_klass)) {
+    if (C->print_intrinsics()) {
+      tty->print_cr("  ** klass argument not initialized");
+    }
+    return false;
+  }
+  ciType* elem_type = elem_klass->const_oop()->as_instance()->java_mirror_type();
+  if (!elem_type->is_primitive_type()) {
+    if (C->print_intrinsics()) {
+      tty->print_cr("  ** not a primitive bt=%d", elem_type->basic_type());
+    }
+    return false; // should be primitive type
+  }
+  BasicType elem_bt = elem_type->basic_type();
+  int num_elem = vlen->get_con();
+  if (!arch_supports_vector(Op_VectorInsert, num_elem, elem_bt, VecMaskNotUsed)) {
+    if (C->print_intrinsics()) {
+      tty->print_cr("  ** not supported: arity=1 op=insert vlen=%d etype=%s ismask=no",
+                    num_elem, type2name(elem_bt));
+    }
+    return false; // not supported
+  }
+
+  ciKlass* vbox_klass = vector_klass->const_oop()->as_instance()->java_lang_Class_klass();
+  const TypeInstPtr* vbox_type = TypeInstPtr::make_exact(TypePtr::NotNull, vbox_klass);
+
+  Node* opd = unbox_vector(argument(3), vbox_type, elem_bt, num_elem);
+  if (opd == NULL) {
+    return false;
+  }
+
+  Node* insert_val = argument(5);
+  assert(gvn().type(insert_val)->isa_long() != NULL, "expected to be long");
+
+  // Convert insert value back to its appropriate type.
+  switch (elem_bt) {
+    case T_BYTE:
+      insert_val = gvn().transform(new ConvL2INode(insert_val));
+      insert_val = gvn().transform(new CastIINode(insert_val, TypeInt::BYTE));
+      break;
+    case T_SHORT:
+      insert_val = gvn().transform(new ConvL2INode(insert_val));
+      insert_val = gvn().transform(new CastIINode(insert_val, TypeInt::SHORT));
+      break;
+    case T_INT:
+      insert_val = gvn().transform(new ConvL2INode(insert_val));
+      break;
+    case T_FLOAT:
+      insert_val = gvn().transform(new ConvL2INode(insert_val));
+      insert_val = gvn().transform(new MoveI2FNode(insert_val));
+      break;
+    case T_DOUBLE:
+      insert_val = gvn().transform(new MoveL2DNode(insert_val));
+      break;
+    case T_LONG:
+      // no conversion needed
+      break;
+    default: fatal("%s", type2name(elem_bt)); break;
+  }
+
+  Node* operation = gvn().transform(VectorInsertNode::make(opd, insert_val, idx->get_con()));
+
+  Node* vbox = box_vector(operation, vbox_type, elem_bt, num_elem);
+  set_result(vbox);
+  C->set_max_vector_size(MAX2(C->max_vector_size(), (uint)(num_elem * type2aelembytes(elem_bt))));
+  return true;
+}
+
+//  public static
+//  >
+//  long extract(Class vectorClass, Class elementType, int vlen,
+//               V vec, int ix,
+//               VecExtractOp defaultImpl) {
+//
+bool LibraryCallKit::inline_vector_extract() {
+  const TypeInstPtr* vector_klass = gvn().type(argument(0))->is_instptr();
+  const TypeInstPtr* elem_klass   = gvn().type(argument(1))->is_instptr();
+  const TypeInt* vlen             = gvn().type(argument(2))->is_int();
+  const TypeInt* idx              = gvn().type(argument(4))->is_int();
+
+  if (vector_klass->const_oop() == NULL || elem_klass->const_oop() == NULL || !vlen->is_con() || !idx->is_con()) {
+    if (C->print_intrinsics()) {
+      tty->print_cr("  ** missing constant: vclass=%s etype=%s vlen=%s idx=%s",
+                    NodeClassNames[argument(0)->Opcode()],
+                    NodeClassNames[argument(1)->Opcode()],
+                    NodeClassNames[argument(2)->Opcode()],
+                    NodeClassNames[argument(4)->Opcode()]);
+    }
+    return false; // not enough info for intrinsification
+  }
+  if (!is_klass_initialized(vector_klass)) {
+    if (C->print_intrinsics()) {
+      tty->print_cr("  ** klass argument not initialized");
+    }
+    return false;
+  }
+  ciType* elem_type = elem_klass->const_oop()->as_instance()->java_mirror_type();
+  if (!elem_type->is_primitive_type()) {
+    if (C->print_intrinsics()) {
+      tty->print_cr("  ** not a primitive bt=%d", elem_type->basic_type());
+    }
+    return false; // should be primitive type
+  }
+  BasicType elem_bt = elem_type->basic_type();
+  int num_elem = vlen->get_con();
+  int vopc = ExtractNode::opcode(elem_bt);
+  if (!arch_supports_vector(vopc, num_elem, elem_bt, VecMaskNotUsed)) {
+    if (C->print_intrinsics()) {
+      tty->print_cr("  ** not supported: arity=1 op=extract vlen=%d etype=%s ismask=no",
+                    num_elem, type2name(elem_bt));
+    }
+    return false; // not supported
+  }
+
+  ciKlass* vbox_klass = vector_klass->const_oop()->as_instance()->java_lang_Class_klass();
+  const TypeInstPtr* vbox_type = TypeInstPtr::make_exact(TypePtr::NotNull, vbox_klass);
+
+  Node* opd = unbox_vector(argument(3), vbox_type, elem_bt, num_elem);
+  if (opd == NULL) {
+    return false;
+  }
+
+  Node* operation = gvn().transform(ExtractNode::make(opd, idx->get_con(), elem_bt));
+
+  Node* bits = NULL;
+  switch (elem_bt) {
+    case T_BYTE:
+    case T_SHORT:
+    case T_INT: {
+      bits = gvn().transform(new ConvI2LNode(operation));
+      break;
+    }
+    case T_FLOAT: {
+      bits = gvn().transform(new MoveF2INode(operation));
+      bits = gvn().transform(new ConvI2LNode(bits));
+      break;
+    }
+    case T_DOUBLE: {
+      bits = gvn().transform(new MoveD2LNode(operation));
+      break;
+    }
+    case T_LONG: {
+      bits = operation; // no conversion needed
+      break;
+    }
+    default: fatal("%s", type2name(elem_bt));
+  }
+
+  set_result(bits);
+  return true;
+}
+
diff --git a/src/hotspot/share/prims/vectorSupport.cpp b/src/hotspot/share/prims/vectorSupport.cpp
new file mode 100644
index 0000000000000..3d2c1fff59e80
--- /dev/null
+++ b/src/hotspot/share/prims/vectorSupport.cpp
@@ -0,0 +1,429 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ *
+ */
+
+#include "precompiled.hpp"
+#include "jni.h"
+#include "jvm.h"
+#include "classfile/javaClasses.inline.hpp"
+#include "code/location.hpp"
+#include "prims/vectorSupport.hpp"
+#include "runtime/fieldDescriptor.inline.hpp"
+#include "runtime/handles.inline.hpp"
+#include "runtime/interfaceSupport.inline.hpp"
+#include "runtime/jniHandles.inline.hpp"
+#include "runtime/stackValue.hpp"
+
+#ifdef COMPILER2
+#include "opto/matcher.hpp" // Matcher::max_vector_size(BasicType)
+#endif // COMPILER2
+
+bool VectorSupport::is_vector(Klass* klass) {
+  return klass->is_subclass_of(SystemDictionary::vector_VectorPayload_klass());
+}
+
+bool VectorSupport::is_vector_mask(Klass* klass) {
+  return klass->is_subclass_of(SystemDictionary::vector_VectorMask_klass());
+}
+
+bool VectorSupport::is_vector_shuffle(Klass* klass) {
+  return klass->is_subclass_of(SystemDictionary::vector_VectorShuffle_klass());
+}
+
+BasicType VectorSupport::klass2bt(InstanceKlass* ik) {
+  assert(ik->is_subclass_of(SystemDictionary::vector_VectorPayload_klass()), "%s not a VectorPayload", ik->name()->as_C_string());
+  fieldDescriptor fd; // find_field initializes fd if found
+  // static final Class ETYPE;
+  Klass* holder = ik->find_field(vmSymbols::ETYPE_name(), vmSymbols::class_signature(), &fd);
+
+  assert(holder != NULL, "sanity");
+  assert(fd.is_static(), "");
+  assert(fd.offset() > 0, "");
+
+  if (is_vector_shuffle(ik)) {
+    return T_BYTE;
+  } else { // vector and mask
+    oop value = ik->java_mirror()->obj_field(fd.offset());
+    BasicType elem_bt = java_lang_Class::as_BasicType(value);
+    return elem_bt;
+  }
+}
+
+jint VectorSupport::klass2length(InstanceKlass* ik) {
+  fieldDescriptor fd; // find_field initializes fd if found
+  // static final int VLENGTH;
+  Klass* holder = ik->find_field(vmSymbols::VLENGTH_name(), vmSymbols::int_signature(), &fd);
+
+  assert(holder != NULL, "sanity");
+  assert(fd.is_static(), "");
+  assert(fd.offset() > 0, "");
+
+  jint vlen = ik->java_mirror()->int_field(fd.offset());
+  assert(vlen > 0, "");
+  return vlen;
+}
+
+void VectorSupport::init_vector_array(typeArrayOop arr, BasicType elem_bt, int num_elem, address value_addr) {
+  int elem_size = type2aelembytes(elem_bt);
+  for (int i = 0; i < num_elem; i++) {
+    switch (elem_bt) {
+      case T_BYTE: {
+        jbyte elem_value = *(jbyte*) (value_addr + i * elem_size);
+        arr->byte_at_put(i, elem_value);
+        break;
+      }
+      case T_SHORT: {
+        jshort elem_value = *(jshort*) (value_addr + i * elem_size);
+        arr->short_at_put(i, elem_value);
+        break;
+      }
+      case T_INT: {
+        jint elem_value = *(jint*) (value_addr + i * elem_size);
+        arr->int_at_put(i, elem_value);
+        break;
+      }
+      case T_LONG: {
+        jlong elem_value = *(jlong*) (value_addr + i * elem_size);
+        arr->long_at_put(i, elem_value);
+        break;
+      }
+      case T_FLOAT: {
+        jfloat elem_value = *(jfloat*) (value_addr + i * elem_size);
+        arr->float_at_put(i, elem_value);
+        break;
+      }
+      case T_DOUBLE: {
+        jdouble elem_value = *(jdouble*) (value_addr + i * elem_size);
+        arr->double_at_put(i, elem_value);
+        break;
+      }
+      default:
+        fatal("unsupported: %s", type2name(elem_bt));
+    }
+  }
+}
+
+void VectorSupport::init_mask_array(typeArrayOop arr, BasicType elem_bt, int num_elem, address value_addr) {
+  int elem_size = type2aelembytes(elem_bt);
+
+  for (int i = 0; i < num_elem; i++) {
+    switch (elem_bt) {
+      case T_BYTE: {
+        jbyte elem_value = *(jbyte*) (value_addr + i * elem_size);
+        arr->bool_at_put(i, elem_value != 0);
+        break;
+      }
+      case T_SHORT: {
+        jshort elem_value = *(jshort*) (value_addr + i * elem_size);
+        arr->bool_at_put(i, elem_value != 0);
+        break;
+      }
+      case T_INT:   // fall-through
+      case T_FLOAT: {
+        jint elem_value = *(jint*) (value_addr + i * elem_size);
+        arr->bool_at_put(i, elem_value != 0);
+        break;
+      }
+      case T_LONG: // fall-through
+      case T_DOUBLE: {
+        jlong elem_value = *(jlong*) (value_addr + i * elem_size);
+        arr->bool_at_put(i, elem_value != 0);
+        break;
+      }
+      default:
+        fatal("unsupported: %s", type2name(elem_bt));
+    }
+  }
+}
+
+oop VectorSupport::allocate_vector_payload_helper(InstanceKlass* ik, BasicType elem_bt, int num_elem, address value_addr, TRAPS) {
+
+  bool is_mask = is_vector_mask(ik);
+
+  // On-heap vector values are represented as primitive arrays.
+  TypeArrayKlass* tak = TypeArrayKlass::cast(Universe::typeArrayKlassObj(is_mask ? T_BOOLEAN : elem_bt));
+
+  typeArrayOop arr = tak->allocate(num_elem, CHECK_NULL); // safepoint
+
+  if (is_mask) {
+    init_mask_array(arr, elem_bt, num_elem, value_addr);
+  } else {
+    init_vector_array(arr, elem_bt, num_elem, value_addr);
+  }
+  return arr;
+}
+
+oop VectorSupport::allocate_vector(InstanceKlass* ik, frame* fr, RegisterMap* reg_map, ObjectValue* ov, TRAPS) {
+  assert(is_vector(ik), "%s not a vector", ik->name()->as_C_string());
+  assert(ov->field_size() == 1, "%s not a vector", ik->name()->as_C_string());
+
+  // Vector value in an aligned adjacent tuple (1, 2, 4, 8, or 16 slots).
+  LocationValue* loc_value = ov->field_at(0)->as_LocationValue();
+
+  BasicType elem_bt = klass2bt(ik);
+  int num_elem = klass2length(ik);
+
+  Handle vbox = ik->allocate_instance_handle(CHECK_NULL);
+
+  Location loc = loc_value->location();
+
+  oop payload = NULL;
+  if (loc.type() == Location::vector) {
+    address value_addr = loc.is_register()
+        // Value was in a callee-save register
+        ? reg_map->location(VMRegImpl::as_VMReg(loc.register_number()))
+        // Else value was directly saved on the stack. The frame's original stack pointer,
+        // before any extension by its callee (due to Compiler1 linkage on SPARC), must be used.
+        : ((address)fr->unextended_sp()) + loc.stack_offset();
+    payload = allocate_vector_payload_helper(ik, elem_bt, num_elem, value_addr, CHECK_NULL); // safepoint
+  } else {
+    // assert(false, "interesting");
+    StackValue* value = StackValue::create_stack_value(fr, reg_map, loc_value);
+    payload = value->get_obj()();
+  }
+  vector_VectorPayload::set_payload(vbox(), payload);
+  return vbox();
+}
+
+#ifdef COMPILER2
+int VectorSupport::vop2ideal(jint id, BasicType bt) {
+  VectorOperation vop = (VectorOperation)id;
+  switch (vop) {
+    case VECTOR_OP_ADD: {
+      switch (bt) {
+        case T_BYTE:   // fall-through
+        case T_SHORT:  // fall-through
+        case T_INT:    return Op_AddI;
+        case T_LONG:   return Op_AddL;
+        case T_FLOAT:  return Op_AddF;
+        case T_DOUBLE: return Op_AddD;
+        default: fatal("ADD: %s", type2name(bt));
+      }
+      break;
+    }
+    case VECTOR_OP_SUB: {
+      switch (bt) {
+        case T_BYTE:   // fall-through
+        case T_SHORT:  // fall-through
+        case T_INT:    return Op_SubI;
+        case T_LONG:   return Op_SubL;
+        case T_FLOAT:  return Op_SubF;
+        case T_DOUBLE: return Op_SubD;
+        default: fatal("SUB: %s", type2name(bt));
+      }
+      break;
+    }
+    case VECTOR_OP_MUL: {
+      switch (bt) {
+        case T_BYTE:   // fall-through
+        case T_SHORT:  // fall-through
+        case T_INT:    return Op_MulI;
+        case T_LONG:   return Op_MulL;
+        case T_FLOAT:  return Op_MulF;
+        case T_DOUBLE: return Op_MulD;
+        default: fatal("MUL: %s", type2name(bt));
+      }
+      break;
+    }
+    case VECTOR_OP_DIV: {
+      switch (bt) {
+        case T_BYTE:   // fall-through
+        case T_SHORT:  // fall-through
+        case T_INT:    return Op_DivI;
+        case T_LONG:   return Op_DivL;
+        case T_FLOAT:  return Op_DivF;
+        case T_DOUBLE: return Op_DivD;
+        default: fatal("DIV: %s", type2name(bt));
+      }
+      break;
+    }
+    case VECTOR_OP_MIN: {
+      switch (bt) {
+        case T_BYTE:
+        case T_SHORT:
+        case T_INT:    return Op_MinI;
+        case T_LONG:   return Op_MinL;
+        case T_FLOAT:  return Op_MinF;
+        case T_DOUBLE: return Op_MinD;
+        default: fatal("MIN: %s", type2name(bt));
+      }
+      break;
+    }
+    case VECTOR_OP_MAX: {
+      switch (bt) {
+        case T_BYTE:
+        case T_SHORT:
+        case T_INT:    return Op_MaxI;
+        case T_LONG:   return Op_MaxL;
+        case T_FLOAT:  return Op_MaxF;
+        case T_DOUBLE: return Op_MaxD;
+        default: fatal("MAX: %s", type2name(bt));
+      }
+      break;
+    }
+    case VECTOR_OP_ABS: {
+      switch (bt) {
+        case T_BYTE:   // fall-through
+        case T_SHORT:  // fall-through
+        case T_INT:    return Op_AbsI;
+        case T_LONG:   return Op_AbsL;
+        case T_FLOAT:  return Op_AbsF;
+        case T_DOUBLE: return Op_AbsD;
+        default: fatal("ABS: %s", type2name(bt));
+      }
+      break;
+    }
+    case VECTOR_OP_NEG: {
+      switch (bt) {
+        case T_BYTE:   // fall-through
+        case T_SHORT:  // fall-through
+        case T_INT:    return Op_NegI;
+        case T_FLOAT:  return Op_NegF;
+        case T_DOUBLE: return Op_NegD;
+        default: fatal("NEG: %s", type2name(bt));
+      }
+      break;
+    }
+    case VECTOR_OP_AND: {
+      switch (bt) {
+        case T_BYTE:   // fall-through
+        case T_SHORT:  // fall-through
+        case T_INT:    return Op_AndI;
+        case T_LONG:   return Op_AndL;
+        default: fatal("AND: %s", type2name(bt));
+      }
+      break;
+    }
+    case VECTOR_OP_OR: {
+      switch (bt) {
+        case T_BYTE:   // fall-through
+        case T_SHORT:  // fall-through
+        case T_INT:    return Op_OrI;
+        case T_LONG:   return Op_OrL;
+        default: fatal("OR: %s", type2name(bt));
+      }
+      break;
+    }
+    case VECTOR_OP_XOR: {
+      switch (bt) {
+        case T_BYTE:   // fall-through
+        case T_SHORT:  // fall-through
+        case T_INT:    return Op_XorI;
+        case T_LONG:   return Op_XorL;
+        default: fatal("XOR: %s", type2name(bt));
+      }
+      break;
+    }
+    case VECTOR_OP_SQRT: {
+      switch (bt) {
+        case T_FLOAT:  return Op_SqrtF;
+        case T_DOUBLE: return Op_SqrtD;
+        default: fatal("SQRT: %s", type2name(bt));
+      }
+      break;
+    }
+    case VECTOR_OP_FMA: {
+      switch (bt) {
+        case T_FLOAT:  return Op_FmaF;
+        case T_DOUBLE: return Op_FmaD;
+        default: fatal("FMA: %s", type2name(bt));
+      }
+      break;
+    }
+    case VECTOR_OP_LSHIFT: {
+      switch (bt) {
+        case T_BYTE:   // fall-through
+        case T_SHORT:  // fall-through
+        case T_INT:  return Op_LShiftI;
+        case T_LONG: return Op_LShiftL;
+        default: fatal("LSHIFT: %s", type2name(bt));
+      }
+      break;
+    }
+    case VECTOR_OP_RSHIFT: {
+      switch (bt) {
+        case T_BYTE:   // fall-through
+        case T_SHORT:  // fall-through
+        case T_INT:  return Op_RShiftI;
+        case T_LONG: return Op_RShiftL;
+        default: fatal("RSHIFT: %s", type2name(bt));
+      }
+      break;
+    }
+    case VECTOR_OP_URSHIFT: {
+      switch (bt) {
+        case T_BYTE:  return Op_URShiftB;
+        case T_SHORT: return Op_URShiftS;
+        case T_INT:   return Op_URShiftI;
+        case T_LONG:  return Op_URShiftL;
+        default: fatal("URSHIFT: %s", type2name(bt));
+      }
+      break;
+    }
+    default: fatal("unknown op: %d", vop);
+  }
+  return 0; // Unimplemented
+}
+#endif // COMPILER2
+
+/**
+ * Implementation of the jdk.internal.vm.vector.VectorSupport class
+ */
+
+JVM_ENTRY(jint, VectorSupport_GetMaxLaneCount(JNIEnv *env, jclass vsclazz, jobject clazz)) {
+#ifdef COMPILER2
+  oop mirror = JNIHandles::resolve_non_null(clazz);
+  if (java_lang_Class::is_primitive(mirror)) {
+    BasicType bt = java_lang_Class::primitive_type(mirror);
+    return Matcher::max_vector_size(bt);
+  }
+#endif // COMPILER2
+  return -1;
+} JVM_END
+
+// JVM_RegisterVectorSupportMethods
+
+#define LANG "Ljava/lang/"
+#define CLS LANG "Class;"
+
+#define CC (char*)  /*cast a literal from (const char*)*/
+#define FN_PTR(f) CAST_FROM_FN_PTR(void*, &f)
+
+static JNINativeMethod jdk_internal_vm_vector_VectorSupport_methods[] = {
+    {CC "getMaxLaneCount",   CC "(" CLS ")I", FN_PTR(VectorSupport_GetMaxLaneCount)}
+};
+
+#undef CC
+#undef FN_PTR
+
+#undef LANG
+#undef CLS
+
+// This function is exported, used by NativeLookup.
+
+JVM_ENTRY(void, JVM_RegisterVectorSupportMethods(JNIEnv* env, jclass vsclass)) {
+  ThreadToNativeFromVM ttnfv(thread);
+
+  int ok = env->RegisterNatives(vsclass, jdk_internal_vm_vector_VectorSupport_methods, sizeof(jdk_internal_vm_vector_VectorSupport_methods)/sizeof(JNINativeMethod));
+  guarantee(ok == 0, "register jdk.internal.vm.vector.VectorSupport natives");
+} JVM_END
diff --git a/src/hotspot/share/prims/vectorSupport.hpp b/src/hotspot/share/prims/vectorSupport.hpp
new file mode 100644
index 0000000000000..31be129d07b4f
--- /dev/null
+++ b/src/hotspot/share/prims/vectorSupport.hpp
@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ *
+ */
+
+#ifndef SHARE_PRIMS_VECTORSUPPORT_HPP
+#define SHARE_PRIMS_VECTORSUPPORT_HPP
+
+#include "jni.h"
+#include "code/debugInfo.hpp"
+#include "memory/allocation.hpp"
+#include "oops/typeArrayOop.inline.hpp"
+#include "runtime/frame.inline.hpp"
+#include "runtime/registerMap.hpp"
+#include "utilities/exceptions.hpp"
+
+extern "C" {
+  void JNICALL JVM_RegisterVectorSupportMethods(JNIEnv* env, jclass vsclass);
+}
+
+class VectorSupport : AllStatic {
+ private:
+  static void init_mask_array(typeArrayOop arr, BasicType elem_bt, int num_elem, address value_addr);
+  static void init_vector_array(typeArrayOop arr, BasicType elem_bt, int num_elem, address value_addr);
+  static oop  allocate_vector_payload_helper(InstanceKlass* ik, BasicType elem_bt, int num_elem, address value_addr, TRAPS);
+
+  static BasicType klass2bt(InstanceKlass* ik);
+  static jint klass2length(InstanceKlass* ik);
+
+ public:
+
+   // Should be aligned with constants in jdk.internal.vm.vector.VectorSupport
+  enum VectorOperation {
+    // Unary
+    VECTOR_OP_ABS     = 0,
+    VECTOR_OP_NEG     = 1,
+    VECTOR_OP_SQRT    = 2,
+
+    // Binary
+    VECTOR_OP_ADD     = 4,
+    VECTOR_OP_SUB     = 5,
+    VECTOR_OP_MUL     = 6,
+    VECTOR_OP_DIV     = 7,
+    VECTOR_OP_MIN     = 8,
+    VECTOR_OP_MAX     = 9,
+    VECTOR_OP_AND     = 10,
+    VECTOR_OP_OR      = 11,
+    VECTOR_OP_XOR     = 12,
+
+    // Ternary
+    VECTOR_OP_FMA     = 13,
+
+    // Broadcast int
+    VECTOR_OP_LSHIFT  = 14,
+    VECTOR_OP_RSHIFT  = 15,
+    VECTOR_OP_URSHIFT = 16,
+
+    // Convert
+    VECTOR_OP_CAST        = 17,
+    VECTOR_OP_REINTERPRET = 18
+  };
+
+  static int vop2ideal(jint vop, BasicType bt);
+
+  static oop  allocate_vector(InstanceKlass* holder, frame* fr, RegisterMap* reg_map, ObjectValue* sv, TRAPS);
+
+  static bool is_vector(Klass* klass);
+  static bool is_vector_mask(Klass* klass);
+  static bool is_vector_shuffle(Klass* klass);
+};
+#endif // SHARE_PRIMS_VECTORSUPPORT_HPP
diff --git a/src/hotspot/share/utilities/enumIterator.hpp b/src/hotspot/share/utilities/enumIterator.hpp
new file mode 100644
index 0000000000000..b876531207ef0
--- /dev/null
+++ b/src/hotspot/share/utilities/enumIterator.hpp
@@ -0,0 +1,215 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ *
+ */
+
+#ifndef SHARE_UTILITIES_ENUMITERATOR_HPP
+#define SHARE_UTILITIES_ENUMITERATOR_HPP
+
+#include 
+#include 
+#include "memory/allStatic.hpp"
+#include "utilities/debug.hpp"
+
+// Iteration support for enums.
+//
+// E is enum type, U is underlying type of E.
+//
+// case 1:
+// enum has sequential enumerators, with E first and E last (inclusive).
+//
+// case 2:
+// enum has sequential values, with U start and U end (exclusive).
+// WeakProcessorPhases is an example because of oopstorage.
+// This can be mapped onto case 1 by casting start/(end-1).
+//
+// case 3:
+// enum has non-sequential non-duplicate enumerators
+// Iteration could be supported via array or other sequence of enumerators.
+// Don't bother.
+//
+// case 4:
+// enum has non-sequential enumerators with duplicate values
+// Not clear what iteration should mean in this case.
+// Don't bother trying to figure this out.
+//
+//
+// EnumRange -- defines the range of *one specific* iteration loop.
+// EnumIterator -- the current point in the iteration loop.
+
+// Example (see vmSymbols.hpp/cpp)
+//
+// ENUMERATOR_RANGE(vmSymbolID, vmSymbolID::FIRST_SID, vmSymbolID::LAST_SID)
+// constexpr EnumRange vmSymbolsRange;
+// using vmSymbolsIterator = EnumIterator;
+//
+// /* Without range-based for, allowed */
+// for (vmSymbolsIterator it = vmSymbolsRange.begin(); it != vmSymbolsRange.end(); ++it) {
+//  vmSymbolID index = *it; ....
+// }
+//
+// /* With range-base for, not allowed by HotSpot coding style yet */
+// for (vmSymbolID index : vmSymbolsRange) {
+//    ....
+// }
+
+// EnumeratorRange is a traits type supporting iteration over the enumerators of T.
+// Specializations must provide static const data members named
+// "_first" and "_last", whose values are the smallest / largest
+// (resp.) enumerator values for T. For iteration, the enumerators of
+// T must have sequential values in that range.
+template struct EnumeratorRange;
+
+// Specialize EnumeratorRange.
+#define ENUMERATOR_RANGE(T, First, Last)        \
+  template<> struct EnumeratorRange {        \
+    static constexpr T _first = First;          \
+    static constexpr T _last = Last;            \
+  };
+
+// A helper class for EnumIterator, computing some additional information the
+// iterator uses, based on T and EnumeratorRange.
+template
+class EnumIterationTraits : AllStatic {
+  using RangeType = EnumeratorRange;
+
+public:
+  // The underlying type for T.
+  using Underlying = std::underlying_type_t;
+
+  // The first enumerator of T.
+  static constexpr T _first = RangeType::_first;
+
+  // The last enumerator of T.
+  static constexpr T _last = RangeType::_last;
+
+  static_assert(static_cast(_last) <
+                std::numeric_limits::max(),
+                "No one-past-the-end value for enum");
+
+  // The value of the first enumerator of T.
+  static constexpr Underlying _start = static_cast(_first);
+
+  // The one-past-the-end value for T.
+  static constexpr Underlying _end = static_cast(_last) + 1;
+};
+
+template
+class EnumIterator {
+  using Traits = EnumIterationTraits;
+
+  using Underlying = typename Traits::Underlying;
+  Underlying _value;
+
+  constexpr void assert_in_bounds() const {
+    assert(_value < Traits::_end, "beyond the end");
+  }
+
+public:
+  // Return a beyond-the-end iterator.
+  constexpr EnumIterator() : _value(Traits::_end) {}
+
+  // Return an iterator with the indicated value.
+  constexpr explicit EnumIterator(T value) :
+    _value(static_cast(value))
+  {
+    assert(_value >= Traits::_start, "out of range");
+    assert(_value <= Traits::_end, "out of range");
+  }
+
+  // True if the iterators designate the same enumeration value.
+  constexpr bool operator==(EnumIterator other) const {
+    return _value == other._value;
+  }
+
+  // True if the iterators designate different enumeration values.
+  constexpr bool operator!=(EnumIterator other) const {
+    return _value != other._value;
+  }
+
+  // Return the current value.
+  // precondition: this is not beyond the last enumerator.
+  constexpr T operator*() const {
+    assert_in_bounds();
+    return static_cast(_value);
+  }
+
+  // Step this iterator to the next value.
+  // precondition: this is not beyond the last enumerator.
+  constexpr EnumIterator& operator++() {
+    assert_in_bounds();
+    ++_value;
+    return *this;
+  }
+
+  // Return a copy and step this iterator to the next value.
+  // precondition: this is not beyond the last enumerator.
+  constexpr EnumIterator operator++(int) {
+    assert_in_bounds();
+    EnumIterator result = *this;
+    ++_value;
+    return result;
+  }
+};
+
+template
+class EnumRange {
+  using Traits = EnumIterationTraits;
+  using Underlying = typename Traits::Underlying;
+
+  Underlying _start;
+  Underlying _end;
+
+public:
+  using Iterator = EnumIterator;
+
+  // Default constructor gives the full range.
+  constexpr EnumRange() :
+    EnumRange(Traits::_first) {}
+
+  // Range from start to the (exclusive) end of the enumerator range.
+  constexpr explicit EnumRange(T start) :
+    EnumRange(start, static_cast(Traits::_end)) {}
+
+  // Range from start (inclusive) to end (exclusive).
+  // precondition: start <= end.
+  constexpr EnumRange(T start, T end) :
+    _start(static_cast(start)),
+    _end(static_cast(end))
+  {
+    assert(Traits::_start <= _start, "out of range");
+    assert(_end <= Traits::_end, "out of range");
+    assert(_start <= _end, "invalid range");
+  }
+
+  // Return an iterator for the start of the range.
+  constexpr Iterator begin() const {
+    return Iterator(static_cast(_start));
+  }
+
+  // Return an iterator for the end of the range.
+  constexpr Iterator end() const {
+    return Iterator(static_cast(_end));
+  }
+};
+
+#endif // SHARE_UTILITIES_ENUMITERATOR_HPP
diff --git a/src/java.base/share/classes/jdk/internal/vm/vector/VectorSupport.java b/src/java.base/share/classes/jdk/internal/vm/vector/VectorSupport.java
new file mode 100644
index 0000000000000..44d8d6c33a8d7
--- /dev/null
+++ b/src/java.base/share/classes/jdk/internal/vm/vector/VectorSupport.java
@@ -0,0 +1,468 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package jdk.internal.vm.vector;
+
+import jdk.internal.vm.annotation.IntrinsicCandidate;
+import jdk.internal.misc.Unsafe;
+import jdk.internal.vm.annotation.ForceInline;
+
+import java.nio.Buffer;
+import java.nio.ByteBuffer;
+import java.util.Objects;
+import java.util.function.*;
+
+public class VectorSupport {
+    static {
+        registerNatives();
+    }
+
+    private static final Unsafe U = Unsafe.getUnsafe();
+
+    // Unary
+    public static final int VECTOR_OP_ABS  = 0;
+    public static final int VECTOR_OP_NEG  = 1;
+    public static final int VECTOR_OP_SQRT = 2;
+
+    // Binary
+    public static final int VECTOR_OP_ADD  = 4;
+    public static final int VECTOR_OP_SUB  = 5;
+    public static final int VECTOR_OP_MUL  = 6;
+    public static final int VECTOR_OP_DIV  = 7;
+    public static final int VECTOR_OP_MIN  = 8;
+    public static final int VECTOR_OP_MAX  = 9;
+
+    public static final int VECTOR_OP_AND  = 10;
+    public static final int VECTOR_OP_OR   = 11;
+    public static final int VECTOR_OP_XOR  = 12;
+
+    // Ternary
+    public static final int VECTOR_OP_FMA  = 13;
+
+    // Broadcast int
+    public static final int VECTOR_OP_LSHIFT  = 14;
+    public static final int VECTOR_OP_RSHIFT  = 15;
+    public static final int VECTOR_OP_URSHIFT = 16;
+
+    public static final int VECTOR_OP_CAST        = 17;
+    public static final int VECTOR_OP_REINTERPRET = 18;
+
+    // enum BoolTest
+    public static final int BT_eq = 0;
+    public static final int BT_ne = 4;
+    public static final int BT_le = 5;
+    public static final int BT_ge = 7;
+    public static final int BT_lt = 3;
+    public static final int BT_gt = 1;
+    public static final int BT_overflow = 2;
+    public static final int BT_no_overflow = 6;
+
+    // BasicType codes, for primitives only:
+    public static final int
+        T_FLOAT   = 6,
+        T_DOUBLE  = 7,
+        T_BYTE    = 8,
+        T_SHORT   = 9,
+        T_INT     = 10,
+        T_LONG    = 11;
+
+    /* ============================================================================ */
+
+    public static class VectorSpecies {}
+
+    public static class VectorPayload {
+        private final Object payload; // array of primitives
+
+        public VectorPayload(Object payload) {
+            this.payload = payload;
+        }
+
+        protected final Object getPayload() {
+            return VectorSupport.maybeRebox(this).payload;
+        }
+    }
+
+    public static class Vector extends VectorPayload {
+        public Vector(Object payload) {
+            super(payload);
+        }
+    }
+
+    public static class VectorShuffle extends VectorPayload {
+        public VectorShuffle(Object payload) {
+            super(payload);
+        }
+    }
+    public static class VectorMask extends VectorPayload {
+        public VectorMask(Object payload) {
+            super(payload);
+        }
+    }
+
+    /* ============================================================================ */
+    public interface BroadcastOperation> {
+        VM broadcast(long l, S s);
+    }
+
+    @IntrinsicCandidate
+    public static
+    >
+    VM broadcastCoerced(Class vmClass, Class E, int length,
+                                  long bits, S s,
+                                  BroadcastOperation defaultImpl) {
+        assert isNonCapturingLambda(defaultImpl) : defaultImpl;
+        return defaultImpl.broadcast(bits, s);
+    }
+
+    /* ============================================================================ */
+    public interface ShuffleIotaOperation> {
+        VectorShuffle apply(int length, int start, int step, S s);
+    }
+
+    @IntrinsicCandidate
+    public static
+    >
+    VectorShuffle shuffleIota(Class E, Class ShuffleClass, S s, int length,
+                     int start, int step, int wrap, ShuffleIotaOperation defaultImpl) {
+       assert isNonCapturingLambda(defaultImpl) : defaultImpl;
+       return defaultImpl.apply(length, start, step, s);
+    }
+
+    public interface ShuffleToVectorOperation {
+       VM apply(Sh s);
+    }
+
+    @IntrinsicCandidate
+    public static
+    , E>
+    VM shuffleToVector(Class VM, ClassE , Class ShuffleClass, Sh s, int length,
+                       ShuffleToVectorOperation defaultImpl) {
+      assert isNonCapturingLambda(defaultImpl) : defaultImpl;
+      return defaultImpl.apply(s);
+    }
+
+    /* ============================================================================ */
+    public interface IndexOperation, E, S extends VectorSpecies> {
+        V index(V v, int step, S s);
+    }
+
+    //FIXME @IntrinsicCandidate
+    public static
+    , E, S extends VectorSpecies>
+    V indexVector(Class vClass, Class E, int length,
+                  V v, int step, S s,
+                  IndexOperation defaultImpl) {
+        assert isNonCapturingLambda(defaultImpl) : defaultImpl;
+        return defaultImpl.index(v, step, s);
+    }
+
+    /* ============================================================================ */
+
+    @IntrinsicCandidate
+    public static
+    >
+    long reductionCoerced(int oprId, Class vectorClass, Class elementType, int length,
+                          V v,
+                          Function defaultImpl) {
+        assert isNonCapturingLambda(defaultImpl) : defaultImpl;
+        return defaultImpl.apply(v);
+    }
+
+    /* ============================================================================ */
+
+    public interface VecExtractOp {
+        long apply(V v1, int idx);
+    }
+
+    @IntrinsicCandidate
+    public static
+    >
+    long extract(Class vectorClass, Class elementType, int vlen,
+                 V vec, int ix,
+                 VecExtractOp defaultImpl) {
+        assert isNonCapturingLambda(defaultImpl) : defaultImpl;
+        return defaultImpl.apply(vec, ix);
+    }
+
+    /* ============================================================================ */
+
+    public interface VecInsertOp {
+        V apply(V v1, int idx, long val);
+    }
+
+    @IntrinsicCandidate
+    public static
+    >
+    V insert(Class vectorClass, Class elementType, int vlen,
+             V vec, int ix, long val,
+             VecInsertOp defaultImpl) {
+        assert isNonCapturingLambda(defaultImpl) : defaultImpl;
+        return defaultImpl.apply(vec, ix, val);
+    }
+
+    /* ============================================================================ */
+
+    @IntrinsicCandidate
+    public static
+    
+    VM unaryOp(int oprId, Class vmClass, Class elementType, int length,
+               VM vm,
+               Function defaultImpl) {
+        assert isNonCapturingLambda(defaultImpl) : defaultImpl;
+        return defaultImpl.apply(vm);
+    }
+
+    /* ============================================================================ */
+
+    @IntrinsicCandidate
+    public static
+    
+    VM binaryOp(int oprId, Class vmClass, Class elementType, int length,
+                VM vm1, VM vm2,
+                BiFunction defaultImpl) {
+        assert isNonCapturingLambda(defaultImpl) : defaultImpl;
+        return defaultImpl.apply(vm1, vm2);
+    }
+
+    /* ============================================================================ */
+
+    public interface TernaryOperation {
+        V apply(V v1, V v2, V v3);
+    }
+
+    @IntrinsicCandidate
+    public static
+    
+    VM ternaryOp(int oprId, Class vmClass, Class elementType, int length,
+                 VM vm1, VM vm2, VM vm3,
+                 TernaryOperation defaultImpl) {
+        assert isNonCapturingLambda(defaultImpl) : defaultImpl;
+        return defaultImpl.apply(vm1, vm2, vm3);
+    }
+
+    /* ============================================================================ */
+
+    // Memory operations
+
+    public interface LoadOperation> {
+        V load(C container, int index, S s);
+    }
+
+    @IntrinsicCandidate
+    public static
+    >
+    VM load(Class vmClass, Class E, int length,
+           Object base, long offset,    // Unsafe addressing
+           C container, int index, S s,     // Arguments for default implementation
+           LoadOperation defaultImpl) {
+        assert isNonCapturingLambda(defaultImpl) : defaultImpl;
+        return defaultImpl.load(container, index, s);
+    }
+
+    /* ============================================================================ */
+
+    public interface LoadVectorOperationWithMap, E, S extends VectorSpecies> {
+        V loadWithMap(C container, int index, int[] indexMap, int indexM, S s);
+    }
+
+    @IntrinsicCandidate
+    public static
+    , W extends Vector, E, S extends VectorSpecies>
+    V loadWithMap(Class vectorClass, Class E, int length, Class vectorIndexClass,
+                  Object base, long offset, // Unsafe addressing
+                  W index_vector,
+                  C container, int index, int[] indexMap, int indexM, S s, // Arguments for default implementation
+                  LoadVectorOperationWithMap defaultImpl) {
+        assert isNonCapturingLambda(defaultImpl) : defaultImpl;
+        return defaultImpl.loadWithMap(container, index, indexMap, indexM, s);
+    }
+
+    /* ============================================================================ */
+
+    public interface StoreVectorOperation> {
+        void store(C container, int index, V v);
+    }
+
+    @IntrinsicCandidate
+    public static
+    >
+    void store(Class vectorClass, Class elementType, int length,
+               Object base, long offset,    // Unsafe addressing
+               V v,
+               C container, int index,      // Arguments for default implementation
+               StoreVectorOperation defaultImpl) {
+        assert isNonCapturingLambda(defaultImpl) : defaultImpl;
+        defaultImpl.store(container, index, v);
+    }
+
+    /* ============================================================================ */
+
+    public interface StoreVectorOperationWithMap> {
+        void storeWithMap(C container, int index, V v, int[] indexMap, int indexM);
+    }
+
+    @IntrinsicCandidate
+    public static
+    , W extends Vector>
+    void storeWithMap(Class vectorClass, Class elementType, int length, Class vectorIndexClass,
+                      Object base, long offset,    // Unsafe addressing
+                      W index_vector, V v,
+                      C container, int index, int[] indexMap, int indexM, // Arguments for default implementation
+                      StoreVectorOperationWithMap defaultImpl) {
+        assert isNonCapturingLambda(defaultImpl) : defaultImpl;
+        defaultImpl.storeWithMap(container, index, v, indexMap, indexM);
+    }
+
+    /* ============================================================================ */
+
+    @IntrinsicCandidate
+    public static
+    
+    boolean test(int cond, Class vmClass, Class elementType, int length,
+                 VM vm1, VM vm2,
+                 BiFunction defaultImpl) {
+        assert isNonCapturingLambda(defaultImpl) : defaultImpl;
+        return defaultImpl.apply(vm1, vm2);
+    }
+
+    /* ============================================================================ */
+
+    public interface VectorCompareOp {
+        M apply(int cond, V v1, V v2);
+    }
+
+    @IntrinsicCandidate
+    public static ,
+                   M extends VectorMask,
+                   E>
+    M compare(int cond, Class vectorClass, Class maskClass, Class elementType, int length,
+              V v1, V v2,
+              VectorCompareOp defaultImpl) {
+        assert isNonCapturingLambda(defaultImpl) : defaultImpl;
+        return defaultImpl.apply(cond, v1, v2);
+    }
+
+    /* ============================================================================ */
+
+    public interface VectorRearrangeOp,
+            Sh extends VectorShuffle,
+            E> {
+        V apply(V v1, Sh shuffle);
+    }
+
+    @IntrinsicCandidate
+    public static
+    ,
+            Sh extends VectorShuffle,
+            E>
+    V rearrangeOp(Class vectorClass, Class shuffleClass, Class elementType, int vlen,
+                  V v1, Sh sh,
+                  VectorRearrangeOp defaultImpl) {
+        assert isNonCapturingLambda(defaultImpl) : defaultImpl;
+        return defaultImpl.apply(v1, sh);
+    }
+
+    /* ============================================================================ */
+
+    public interface VectorBlendOp,
+            M extends VectorMask,
+            E> {
+        V apply(V v1, V v2, M mask);
+    }
+
+    @IntrinsicCandidate
+    public static
+    ,
+     M extends VectorMask,
+     E>
+    V blend(Class vectorClass, Class maskClass, Class elementType, int length,
+            V v1, V v2, M m,
+            VectorBlendOp defaultImpl) {
+        assert isNonCapturingLambda(defaultImpl) : defaultImpl;
+        return defaultImpl.apply(v1, v2, m);
+    }
+
+    /* ============================================================================ */
+
+    public interface VectorBroadcastIntOp> {
+        V apply(V v, int n);
+    }
+
+    @IntrinsicCandidate
+    public static
+    >
+    V broadcastInt(int opr, Class vectorClass, Class elementType, int length,
+                   V v, int n,
+                   VectorBroadcastIntOp defaultImpl) {
+        assert isNonCapturingLambda(defaultImpl) : defaultImpl;
+        return defaultImpl.apply(v, n);
+    }
+
+    /* ============================================================================ */
+
+    public interface VectorConvertOp {
+        VOUT apply(VIN v, S species);
+    }
+
+    // Users of this intrinsic assume that it respects
+    // REGISTER_ENDIAN, which is currently ByteOrder.LITTLE_ENDIAN.
+    // See javadoc for REGISTER_ENDIAN.
+
+    @IntrinsicCandidate
+    public static >
+    VOUT convert(int oprId,
+              Class fromVectorClass, Class fromElementType, int fromVLen,
+              Class   toVectorClass, Class   toElementType, int   toVLen,
+              VIN v, S s,
+              VectorConvertOp defaultImpl) {
+        assert isNonCapturingLambda(defaultImpl) : defaultImpl;
+        return defaultImpl.apply(v, s);
+    }
+
+    /* ============================================================================ */
+
+    @IntrinsicCandidate
+    public static  V maybeRebox(V v) {
+        // The fence is added here to avoid memory aliasing problems in C2 between scalar & vector accesses.
+        // TODO: move the fence generation into C2. Generate only when reboxing is taking place.
+        U.loadFence();
+        return v;
+    }
+
+    /* ============================================================================ */
+
+    // query the JVM's supported vector sizes and types
+    public static native int getMaxLaneCount(Class etype);
+
+    /* ============================================================================ */
+
+    public static boolean isNonCapturingLambda(Object o) {
+        return o.getClass().getDeclaredFields().length == 0;
+    }
+
+    /* ============================================================================ */
+
+    private static native int registerNatives();
+}
diff --git a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/AbstractMask.java b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/AbstractMask.java
new file mode 100644
index 0000000000000..9bfcc22d0e6a0
--- /dev/null
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/AbstractMask.java
@@ -0,0 +1,290 @@
+/*
+ * Copyright (c) 2017, 2020, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package jdk.incubator.vector;
+
+import jdk.internal.vm.annotation.ForceInline;
+
+import static jdk.incubator.vector.VectorOperators.*;
+
+abstract class AbstractMask extends VectorMask {
+    AbstractMask(boolean[] bits) {
+        super(bits);
+    }
+
+    /*package-private*/
+    abstract boolean[] getBits();
+
+    // Unary operator
+
+    interface MUnOp {
+        boolean apply(int i, boolean a);
+    }
+
+    abstract AbstractMask uOp(MUnOp f);
+
+    // Binary operator
+
+    interface MBinOp {
+        boolean apply(int i, boolean a, boolean b);
+    }
+
+    abstract AbstractMask bOp(VectorMask o, MBinOp f);
+
+    /*package-private*/
+    abstract AbstractSpecies vspecies();
+
+    @Override
+    @ForceInline
+    public final VectorSpecies vectorSpecies() {
+        return vspecies();
+    }
+
+    @Override
+    public boolean laneIsSet(int i) {
+        return getBits()[i];
+    }
+
+    @Override
+    public long toLong() {
+        // FIXME: This should be an intrinsic.
+        if (length() > Long.SIZE) {
+            throw new UnsupportedOperationException("too many lanes for one long");
+        }
+        long res = 0;
+        long set = 1;
+        boolean[] bits = getBits();
+        for (int i = 0; i < bits.length; i++) {
+            res = bits[i] ? res | set : res;
+            set = set << 1;
+        }
+        return res;
+    }
+
+    @Override
+    public void intoArray(boolean[] bits, int i) {
+        System.arraycopy(getBits(), 0, bits, i, length());
+    }
+
+    @Override
+    public boolean[] toArray() {
+        return getBits().clone();
+    }
+
+    @Override
+    @ForceInline
+    @SuppressWarnings("unchecked")
+    public
+     VectorMask check(Class elementType) {
+        if (vectorSpecies().elementType() != elementType) {
+            throw AbstractSpecies.checkFailed(this, elementType);
+        }
+        return (VectorMask) this;
+    }
+
+    @Override
+    @ForceInline
+    @SuppressWarnings("unchecked")
+    public
+     VectorMask check(VectorSpecies species) {
+        if (species != vectorSpecies()) {
+            throw AbstractSpecies.checkFailed(this, species);
+        }
+        return (VectorMask) this;
+    }
+
+    @Override
+    public int trueCount() {
+        //FIXME: use a population count intrinsic here
+        int c = 0;
+        for (boolean i : getBits()) {
+            if (i) c++;
+        }
+        return c;
+    }
+
+    @Override
+    public int firstTrue() {
+        //FIXME: use a count trailing zeros intrinsic here
+        boolean[] bits = getBits();
+        for (int i = 0; i < bits.length; i++) {
+            if (bits[i])  return i;
+        }
+        return bits.length;
+    }
+
+    @Override
+    public int lastTrue() {
+        //FIXME: use a count leading zeros intrinsic here
+        boolean[] bits = getBits();
+        for (int i = bits.length-1; i >= 0; i--) {
+            if (bits[i])  return i;
+        }
+        return -1;
+    }
+
+    @Override
+    public VectorMask eq(VectorMask m) {
+        // FIXME: Generate good code here.
+        return bOp(m, (i, a, b) -> a == b);
+    }
+
+    @Override
+    public VectorMask andNot(VectorMask m) {
+        // FIXME: Generate good code here.
+        return bOp(m, (i, a, b) -> a && !b);
+    }
+
+    /*package-private*/
+    static boolean anyTrueHelper(boolean[] bits) {
+        // FIXME: Maybe use toLong() != 0 here.
+        for (boolean i : bits) {
+            if (i) return true;
+        }
+        return false;
+    }
+
+    /*package-private*/
+    static boolean allTrueHelper(boolean[] bits) {
+        // FIXME: Maybe use not().toLong() == 0 here.
+        for (boolean i : bits) {
+            if (!i) return false;
+        }
+        return true;
+    }
+
+    @Override
+    @ForceInline
+    public VectorMask indexInRange(int offset, int limit) {
+        int vlength = length();
+        Vector iota = vectorSpecies().zero().addIndex(1);
+        VectorMask badMask = checkIndex0(offset, limit, iota, vlength);
+        return this.andNot(badMask);
+    }
+
+    /*package-private*/
+    @ForceInline
+    AbstractVector
+    toVectorTemplate() {
+        AbstractSpecies vsp = vspecies();
+        Vector zero = vsp.broadcast(0);
+        Vector mone = vsp.broadcast(-1);
+        // -1 will result in the most significant bit being set in
+        // addition to some or all other lane bits.
+        // For integral types, *all* lane bits will be set.
+        // The bits for -1.0 are like {0b10111*0000*}.
+        // FIXME: Use a conversion intrinsic for this operation.
+        // https://bugs.openjdk.java.net/browse/JDK-8225740
+        return (AbstractVector) zero.blend(mone, this);
+    }
+
+    /**
+     * Test if a masked memory access at a given offset into an array
+     * of the given length will stay within the array.
+     * The per-lane offsets are iota*esize.
+     */
+    /*package-private*/
+    @ForceInline
+    void checkIndexByLane(int offset, int alength,
+                          Vector iota,
+                          int esize) {
+        if (VectorIntrinsics.VECTOR_ACCESS_OOB_CHECK == 0) {
+            return;
+        }
+        // Although the specification is simple, the implementation is
+        // tricky, because the value iota*esize might possibly
+        // overflow.  So we calculate our test values as scalars,
+        // clipping to the range [-1..VLENGTH], and test them against
+        // the unscaled iota vector, whose values are in [0..VLENGTH-1].
+        int vlength = length();
+        VectorMask badMask;
+        if (esize == 1) {
+            badMask = checkIndex0(offset, alength, iota, vlength);
+        } else if (offset >= 0) {
+            // Masked access to multi-byte lanes in byte array.
+            // It could be aligned anywhere.
+            int elemCount = Math.min(vlength, (alength - offset) / esize);
+            badMask = checkIndex0(0, elemCount, iota, vlength);
+        } else {
+            // This requires a split test.
+            int clipOffset = Math.max(offset, -(vlength * esize));
+            int elemCount = Math.min(vlength, (alength - clipOffset) / esize);
+            badMask = checkIndex0(0, elemCount, iota, vlength);
+            clipOffset &= (esize - 1);  // power of two, so OK
+            VectorMask badMask2 = checkIndex0(clipOffset / esize, vlength,
+                                                 iota, vlength);
+            badMask = badMask.or(badMask2);
+        }
+        badMask = badMask.and(this);
+        if (badMask.anyTrue()) {
+            int badLane = badMask.firstTrue();
+            throw ((AbstractMask)badMask)
+                   .checkIndexFailed(offset, badLane, alength, esize);
+        }
+    }
+
+    private
+    @ForceInline
+    VectorMask checkIndex0(int offset, int alength,
+                              Vector iota, int vlength) {
+        // An active lane is bad if its number is greater than
+        // alength-offset, since when added to offset it will step off
+        // of the end of the array.  To avoid overflow when
+        // converting, clip the comparison value to [0..vlength]
+        // inclusive.
+        int indexLimit = Math.max(0, Math.min(alength - offset, vlength));
+        VectorMask badMask =
+            iota.compare(GE, iota.broadcast(indexLimit));
+        if (offset < 0) {
+            // An active lane is bad if its number is less than
+            // -offset, because when added to offset it will then
+            // address an array element at a negative index.  To avoid
+            // overflow when converting, clip the comparison value at
+            // vlength.  This specific expression works correctly even
+            // when offset is Integer.MIN_VALUE.
+            int firstGoodIndex = -Math.max(offset, -vlength);
+            VectorMask badMask2 =
+                iota.compare(LT, iota.broadcast(firstGoodIndex));
+            if (indexLimit >= vlength) {
+                badMask = badMask2;  // 1st badMask is all true
+            } else {
+                badMask = badMask.or(badMask2);
+            }
+        }
+        return badMask;
+    }
+
+    private IndexOutOfBoundsException checkIndexFailed(int offset, int lane,
+                                                       int alength, int esize) {
+        String msg = String.format("Masked range check failed: "+
+                                   "vector mask %s out of bounds at "+
+                                   "index %d+%d in array of length %d",
+                                   this, offset, lane * esize, alength);
+        if (esize != 1) {
+            msg += String.format(" (each lane spans %d array elements)", esize);
+        }
+        throw new IndexOutOfBoundsException(msg);
+    }
+
+}
diff --git a/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/AbstractShuffle.java b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/AbstractShuffle.java
new file mode 100644
index 0000000000000..21f722b5d168e
--- /dev/null
+++ b/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/AbstractShuffle.java
@@ -0,0 +1,246 @@
+/*
+ * Copyright (c) 2018, 2020, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package jdk.incubator.vector;
+
+import java.util.function.IntUnaryOperator;
+import jdk.internal.vm.annotation.ForceInline;
+
+abstract class AbstractShuffle extends VectorShuffle {
+    static final IntUnaryOperator IDENTITY = i -> i;
+
+    // Internal representation allows for a maximum index of 256
+    // Values are clipped to [-VLENGTH..VLENGTH-1].
+
+    AbstractShuffle(int length, byte[] reorder) {
+        super(reorder);
+        assert(length == reorder.length);
+        assert(indexesInRange(reorder));
+    }
+
+    AbstractShuffle(int length, int[] reorder) {
+        this(length, reorder, 0);
+    }
+
+    AbstractShuffle(int length, int[] reorder, int offset) {
+        super(prepare(length, reorder, offset));
+    }
+
+    AbstractShuffle(int length, IntUnaryOperator f) {
+        super(prepare(length, f));
+    }
+
+    private static byte[] prepare(int length, int[] reorder, int offset) {
+        byte[] a = new byte[length];
+        for (int i = 0; i < length; i++) {
+            int si = reorder[offset + i];
+            si = partiallyWrapIndex(si, length);
+            a[i] = (byte) si;
+        }
+        return a;
+    }
+
+    private static byte[] prepare(int length, IntUnaryOperator f) {
+        byte[] a = new byte[length];
+        for (int i = 0; i < a.length; i++) {
+            int si = f.applyAsInt(i);
+            si = partiallyWrapIndex(si, length);
+            a[i] = (byte) si;
+        }
+        return a;
+    }
+
+    byte[] reorder() {
+        return (byte[])getPayload();
+    }
+
+    /*package-private*/
+    abstract AbstractSpecies vspecies();
+
+    @Override
+    @ForceInline
+    public final VectorSpecies vectorSpecies() {
+        return vspecies();
+    }
+
+    @Override
+    @ForceInline
+    public void intoArray(int[] a, int offset) {
+        byte[] reorder = reorder();
+        int vlen = reorder.length;
+        for (int i = 0; i < vlen; i++) {
+            int sourceIndex = reorder[i];
+            assert(sourceIndex >= -vlen && sourceIndex < vlen);
+            a[offset + i] = sourceIndex;
+        }
+    }
+
+    @Override
+    @ForceInline
+    public int[] toArray() {
+        byte[] reorder = reorder();
+        int[] a = new int[reorder.length];
+        intoArray(a, 0);
+        return a;
+    }
+
+    /*package-private*/
+    @ForceInline
+    final
+    AbstractVector
+    toVectorTemplate() {
+        // Note that the values produced by laneSource
+        // are already clipped.  At this point we convert
+        // them from internal ints (or bytes) into the ETYPE.
+        // FIXME: Use a conversion intrinsic for this operation.
+        // https://bugs.openjdk.java.net/browse/JDK-8225740
+        return (AbstractVector) vspecies().fromIntValues(toArray());
+    }
+
+    @ForceInline
+    public final VectorShuffle checkIndexes() {
+        // FIXME: vectorize this
+        for (int index : reorder()) {
+            if (index < 0) {
+                throw checkIndexFailed(index, length());
+            }
+        }
+        return this;
+    }
+
+    @ForceInline
+    public final VectorShuffle wrapIndexes() {
+        // FIXME: vectorize this
+        byte[] reorder = reorder();
+        int length = reorder.length;
+        for (int index : reorder) {
+            if (index < 0) {
+                return wrapAndRebuild(reorder);
+            }
+        }
+        return this;
+    }
+
+    @ForceInline
+    public final VectorShuffle wrapAndRebuild(byte[] oldReorder) {
+        int length = oldReorder.length;
+        byte[] reorder = new byte[length];
+        for (int i = 0; i < length; i++) {
+            int si = oldReorder[i];
+            // FIXME: This does not work unless it's a power of 2.
+            if ((length & (length - 1)) == 0) {
+                si += si & length;  // power-of-two optimization
+            } else if (si < 0) {
+                // non-POT code requires a conditional add
+                si += length;
+            }
+            assert(si >= 0 && si < length);
+            reorder[i] = (byte) si;
+        }
+        return vspecies().dummyVector().shuffleFromBytes(reorder);
+    }
+
+    @ForceInline
+    public final VectorMask laneIsValid() {
+        // FIXME: vectorize this
+        byte[] reorder = reorder();
+        int length = reorder.length;
+        boolean[] bits = new boolean[length];
+        for (int i = 0; i < length; i++) {
+            if (reorder[i] >= 0) {
+                bits[i] = true;
+            }
+        }
+        return vspecies().dummyVector().maskFromArray(bits);
+    }
+
+    @Override
+    @ForceInline
+    @SuppressWarnings("unchecked")
+    public final
+     VectorShuffle check(VectorSpecies species) {
+        if (species != vectorSpecies()) {
+            throw AbstractSpecies.checkFailed(this, species);
+        }
+        return (VectorShuffle) this;
+    }
+
+    @Override
+    @ForceInline
+    public final int checkIndex(int index) {
+        return checkIndex0(index, length(), (byte)1);
+    }
+
+    @Override
+    @ForceInline
+    public final int wrapIndex(int index) {
+        return checkIndex0(index, length(), (byte)0);
+    }
+
+    /** Return invalid indexes partially wrapped
+     * mod VLENGTH to negative values.
+     */
+    /*package-private*/
+    @ForceInline
+    static
+    int partiallyWrapIndex(int index, int laneCount) {
+        return checkIndex0(index, laneCount, (byte)-1);
+    }
+
+    /*package-private*/
+    @ForceInline
+    static int checkIndex0(int index, int laneCount, byte mode) {
+        int wrapped = VectorIntrinsics.wrapToRange(index, laneCount);
+        if (mode == 0 || wrapped == index) {
+            return wrapped;
+        }
+        if (mode < 0) {
+            return wrapped - laneCount;  // special mode for internal storage
+        }
+        throw checkIndexFailed(index, laneCount);
+    }
+
+    private static IndexOutOfBoundsException checkIndexFailed(int index, int laneCount) {
+        int max = laneCount - 1;
+        String msg = "required an index in [0.."+max+"] but found "+index;
+        return new IndexOutOfBoundsException(msg);
+    }
+
+    static boolean indexesInRange(byte[] reorder) {
+        int length = reorder.length;
+        for (byte si : reorder) {
+            if (si >= length || si < -length) {
+                boolean assertsEnabled = false;
+                assert(assertsEnabled = true);
+                if (assertsEnabled) {
+                    String msg = ("index "+si+"out of range ["+length+"] in "+
+                                  java.util.Arrays.toString(reorder));
+                    throw new AssertionError(msg);
+                }
+                return false;
+            }
+        }
+        return true;
+    }
+}

From 830c5cea306718352cc1b35b28693c9b576b0279 Mon Sep 17 00:00:00 2001
From: Jorn Vernee 
Date: Thu, 15 Oct 2020 18:50:22 +0200
Subject: [PATCH 18/70] Re-add file erroneously deleted (detected as rename)

---
 src/hotspot/share/utilities/vmEnums.hpp | 35 +++++++++++++++++++++++++
 1 file changed, 35 insertions(+)
 create mode 100644 src/hotspot/share/utilities/vmEnums.hpp

diff --git a/src/hotspot/share/utilities/vmEnums.hpp b/src/hotspot/share/utilities/vmEnums.hpp
new file mode 100644
index 0000000000000..2430c37af8d1f
--- /dev/null
+++ b/src/hotspot/share/utilities/vmEnums.hpp
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ *
+ */
+
+#ifndef SHARE_UTILITIES_VMENUMS_HPP
+#define SHARE_UTILITIES_VMENUMS_HPP
+
+// Include this header file if you just need the following enum types and
+// you don't use their members directly. This way you don't need to include the
+// complex header files that have the full definitions of these enums.
+
+enum JVMFlagsEnum : int;
+enum class vmSymbolID : int;
+
+#endif // SHARE_UTILITIES_VMENUMS_HPP

From 6091ed0f9f7b2e242a0cac7ffc7151cee6e58f12 Mon Sep 17 00:00:00 2001
From: Jorn Vernee 
Date: Fri, 16 Oct 2020 12:48:43 +0200
Subject: [PATCH 19/70] Back-port of TestByteBuffer fix

---
 test/jdk/java/foreign/TestByteBuffer.java | 92 +++++++++++++----------
 1 file changed, 51 insertions(+), 41 deletions(-)

diff --git a/test/jdk/java/foreign/TestByteBuffer.java b/test/jdk/java/foreign/TestByteBuffer.java
index 823514a942111..956858ecca0f6 100644
--- a/test/jdk/java/foreign/TestByteBuffer.java
+++ b/test/jdk/java/foreign/TestByteBuffer.java
@@ -61,7 +61,9 @@
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.StandardOpenOption;
+import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 import java.util.function.BiConsumer;
 import java.util.function.BiFunction;
@@ -313,35 +315,27 @@ static void checkByteArrayAlignment(MemoryLayout layout) {
     }
 
     @Test(dataProvider = "bufferOps")
-    public void testScopedBuffer(Function bufferFactory, Map members) {
+    public void testScopedBuffer(Function bufferFactory, @NoInjection Method method, Object[] args) {
         Buffer bb;
         try (MemorySegment segment = MemorySegment.allocateNative(bytes)) {
             bb = bufferFactory.apply(segment.asByteBuffer());
         }
         //outside of scope!!
-        for (Map.Entry e : members.entrySet()) {
-            if ((!e.getKey().getName().contains("get") &&
-                    !e.getKey().getName().contains("put"))
-                    || e.getValue().length > 2) { // skip bulk ops
-                //skip
-                return;
-            }
-            try {
-                e.getKey().invoke(bb, e.getValue());
-                assertTrue(false);
-            } catch (InvocationTargetException ex) {
-                Throwable cause = ex.getCause();
-                if (cause instanceof IllegalStateException) {
-                    //all get/set buffer operation should fail because of the scope check
-                    assertTrue(ex.getCause().getMessage().contains("already closed"));
-                } else {
-                    //all other exceptions were unexpected - fail
-                    assertTrue(false);
-                }
-            } catch (Throwable ex) {
-                //unexpected exception - fail
-                assertTrue(false);
+        try {
+            method.invoke(bb, args);
+            fail("Exception expected");
+        } catch (InvocationTargetException ex) {
+            Throwable cause = ex.getCause();
+            if (cause instanceof IllegalStateException) {
+                //all get/set buffer operation should fail because of the scope check
+                assertTrue(ex.getCause().getMessage().contains("already closed"));
+            } else {
+                //all other exceptions were unexpected - fail
+                fail("Unexpected exception", cause);
             }
+        } catch (Throwable ex) {
+            //unexpected exception - fail
+            fail("Unexpected exception", ex);
         }
     }
 
@@ -380,7 +374,7 @@ public void testScopedBufferAndVarHandle(VarHandle bufferHandle) {
     }
 
     @Test(dataProvider = "bufferOps")
-    public void testDirectBuffer(Function bufferFactory, Map members) {
+    public void testDirectBuffer(Function bufferFactory, @NoInjection Method method, Object[] args) {
         try (MemorySegment segment = MemorySegment.allocateNative(bytes)) {
             Buffer bb = bufferFactory.apply(segment.asByteBuffer());
             assertTrue(bb.isDirect());
@@ -556,29 +550,29 @@ public void testDeadAccessOnClosedBufferSegment() {
 
     @DataProvider(name = "bufferOps")
     public static Object[][] bufferOps() throws Throwable {
-        return new Object[][]{
-                { (Function) bb -> bb, bufferMembers(ByteBuffer.class)},
-                { (Function) ByteBuffer::asCharBuffer, bufferMembers(CharBuffer.class)},
-                { (Function) ByteBuffer::asShortBuffer, bufferMembers(ShortBuffer.class)},
-                { (Function) ByteBuffer::asIntBuffer, bufferMembers(IntBuffer.class)},
-                { (Function) ByteBuffer::asFloatBuffer, bufferMembers(FloatBuffer.class)},
-                { (Function) ByteBuffer::asLongBuffer, bufferMembers(LongBuffer.class)},
-                { (Function) ByteBuffer::asDoubleBuffer, bufferMembers(DoubleBuffer.class)},
-        };
-    }
-
-    static Map bufferMembers(Class bufferClass) {
-        Map members = new HashMap<>();
+        List args = new ArrayList<>();
+        bufferOpsArgs(args, bb -> bb, ByteBuffer.class);
+        bufferOpsArgs(args, ByteBuffer::asCharBuffer, CharBuffer.class);
+        bufferOpsArgs(args, ByteBuffer::asShortBuffer, ShortBuffer.class);
+        bufferOpsArgs(args, ByteBuffer::asIntBuffer, IntBuffer.class);
+        bufferOpsArgs(args, ByteBuffer::asFloatBuffer, FloatBuffer.class);
+        bufferOpsArgs(args, ByteBuffer::asLongBuffer, LongBuffer.class);
+        bufferOpsArgs(args, ByteBuffer::asDoubleBuffer, DoubleBuffer.class);
+        return args.toArray(Object[][]::new);
+    }
+
+    static void bufferOpsArgs(List argsList, Function factory, Class bufferClass) {
         for (Method m : bufferClass.getMethods()) {
             //skip statics and method declared in j.l.Object
-            if (m.getDeclaringClass().equals(Object.class) ||
-                    (m.getModifiers() & Modifier.STATIC) != 0) continue;
+            if (m.getDeclaringClass().equals(Object.class)
+                || ((m.getModifiers() & Modifier.STATIC) != 0)
+                || (!m.getName().contains("get") && !m.getName().contains("put"))
+                || m.getParameterCount() > 2) continue;
             Object[] args = Stream.of(m.getParameterTypes())
                     .map(TestByteBuffer::defaultValue)
                     .toArray();
-            members.put(m, args);
+            argsList.add(new Object[] { factory, m, args });
         }
-        return members;
     }
 
     @DataProvider(name = "bufferHandleOps")
@@ -693,6 +687,22 @@ static Object defaultValue(Class c) {
             } else {
                 throw new IllegalStateException();
             }
+        } else if (c == String.class) {
+            return "asdf";
+        } else if (c == ByteBuffer.class) {
+            return ByteBuffer.wrap(new byte[1]);
+        } else if (c == CharBuffer.class) {
+            return CharBuffer.wrap(new char[1]);
+        } else if (c == ShortBuffer.class) {
+            return ShortBuffer.wrap(new short[1]);
+        } else if (c == IntBuffer.class) {
+            return IntBuffer.wrap(new int[1]);
+        } else if (c == FloatBuffer.class) {
+            return FloatBuffer.wrap(new float[1]);
+        } else if (c == LongBuffer.class) {
+            return LongBuffer.wrap(new long[1]);
+        } else if (c == DoubleBuffer.class) {
+            return DoubleBuffer.wrap(new double[1]);
         } else {
             return null;
         }

From 3167431110979a220cb3abd7bc9337af5c55d80b Mon Sep 17 00:00:00 2001
From: Maurizio Cimadamore 
Date: Mon, 19 Oct 2020 11:30:37 +0100
Subject: [PATCH 20/70] Address CSR comments

---
 .../jdk/incubator/foreign/MemoryAccess.java   | 1548 +++++------------
 test/jdk/java/foreign/TestByteBuffer.java     |   28 +-
 2 files changed, 487 insertions(+), 1089 deletions(-)

diff --git a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MemoryAccess.java b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MemoryAccess.java
index e7bbc6fa10979..bd978c3fbe344 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MemoryAccess.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MemoryAccess.java
@@ -34,18 +34,21 @@
 /**
  * This class defines ready-made static accessors which can be used to dereference memory segments in many ways.
  * 

- * The most primitive accessors (see {@link #getIntAtOffset(MemorySegment, long)}) take a segment and an offset (expressed in bytes).
- * The final address at which the dereference will occur will be computed by offsetting the base address by
- * the specified offset, as if by calling {@link MemoryAddress#addOffset(long)} on the specified base address.
+ * The most primitive accessors (see {@link #getIntAtOffset(MemorySegment, long, ByteOrder)}) take a segment, an offset
+ * (expressed in bytes) and a byte order. The final address at which the dereference will occur will be computed by offsetting
+ * the base address by the specified offset, as if by calling {@link MemoryAddress#addOffset(long)} on the specified base address.
  * 

- * In cases where no offset is required, overloads are provided (see {@link #getInt(MemorySegment)}) so that
+ * In cases where no offset is required, overloads are provided (see {@link #getInt(MemorySegment, ByteOrder)}) so that
  * clients can omit the offset coordinate.
  * 

  * To help dereferencing in array-like use cases (e.g. where the layout of a given memory segment is a sequence
- * layout of given size an element count), higher-level overloads are also provided (see {@link #getIntAtIndex(MemorySegment, long)}),
+ * layout of given size an element count), higher-level overloads are also provided (see {@link #getIntAtIndex(MemorySegment, long, ByteOrder)}),
  * which take a segment and a logical element index. The formula to obtain the byte offset {@code O} from an
  * index {@code I} is given by {@code O = I * S} where {@code S} is the size (expressed in bytes) of the element to
  * be dereferenced.
+ * 

+ * In cases where native byte order is preferred, overloads are provided (see {@link #getIntAtOffset(MemorySegment, long)})
+ * so that clients can omit the byte order parameter.
  */
 public final class MemoryAccess {
 
@@ -53,1138 +56,519 @@ private MemoryAccess() {
         // just the one
     }
 
-    private static final VarHandle byte_LE_handle = indexedHandle(MemoryLayouts.BITS_8_LE, byte.class);
-    private static final VarHandle char_LE_handle = indexedHandle(MemoryLayouts.BITS_16_LE, char.class);
-    private static final VarHandle short_LE_handle = indexedHandle(MemoryLayouts.BITS_16_LE, short.class);
-    private static final VarHandle int_LE_handle = indexedHandle(MemoryLayouts.BITS_32_LE, int.class);
-    private static final VarHandle float_LE_handle = indexedHandle(MemoryLayouts.BITS_32_LE, float.class);
-    private static final VarHandle long_LE_handle = indexedHandle(MemoryLayouts.BITS_64_LE, long.class);
-    private static final VarHandle double_LE_handle = indexedHandle(MemoryLayouts.BITS_64_LE, double.class);
-    private static final VarHandle byte_BE_handle = indexedHandle(MemoryLayouts.BITS_8_BE, byte.class);
-    private static final VarHandle char_BE_handle = indexedHandle(MemoryLayouts.BITS_16_BE, char.class);
-    private static final VarHandle short_BE_handle = indexedHandle(MemoryLayouts.BITS_16_BE, short.class);
-    private static final VarHandle int_BE_handle = indexedHandle(MemoryLayouts.BITS_32_BE, int.class);
-    private static final VarHandle float_BE_handle = indexedHandle(MemoryLayouts.BITS_32_BE, float.class);
-    private static final VarHandle long_BE_handle = indexedHandle(MemoryLayouts.BITS_64_BE, long.class);
-    private static final VarHandle double_BE_handle = indexedHandle(MemoryLayouts.BITS_64_BE, double.class);
-    private static final VarHandle address_handle;
-
-    static {
-        Class carrier = switch ((int) MemoryLayouts.ADDRESS.byteSize()) {
-            case 4 -> int.class;
-            case 8 -> long.class;
-            default -> throw new ExceptionInInitializerError("Unsupported pointer size: " + MemoryLayouts.ADDRESS.byteSize());
-        };
-        address_handle = MemoryHandles.asAddressVarHandle(indexedHandle(MemoryLayouts.ADDRESS, carrier));
-    }
-
-    /**
-     * Read a byte from given segment and offset, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}.
-     * 

-     * This is equivalent to the following code:
-     * 
{@code
-    VarHandle handle = MemoryHandles.withStride(BITS_8_LE.withBitAlignment(8).varHandle(byte.class), 1L);
-    byte value = (byte)handle.get(segment, offset);
-     * }

-     *
-     * @param segment the segment to be dereferenced.
-     * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
-     * @return a byte value read from {@code segment}.
-     */
-    public static byte getByteAtOffset_LE(MemorySegment segment, long offset) {
-        return (byte)byte_LE_handle.get(segment, offset);
-    }
-
-    /**
-     * Writes a byte at given segment and offset, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}.
-     * 

-     * This is equivalent to the following code:
-     * 
{@code
-    VarHandle handle = MemoryHandles.withStride(BITS_8_LE.withBitAlignment(8).varHandle(byte.class), 1L);
-    handle.set(segment, offset, value);
-     * }

-     * @param segment the segment to be dereferenced.
-     * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
-     * @param value the byte value to be written.
-     */
-    public static void setByteAtOffset_LE(MemorySegment segment, long offset, byte value) {
-        byte_LE_handle.set(segment, offset, value);
-    }
-
-    /**
-     * Read a char from given segment and offset, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}.
-     * 

-     * This is equivalent to the following code:
-     * 
{@code
-    VarHandle handle = MemoryHandles.withStride(BITS_16_LE.withBitAlignment(8).varHandle(char.class), 1L);
-    char value = (char)handle.get(segment, offset);
-     * }

-     * @param segment the segment to be dereferenced.
-     * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
-     * @return a char value read from {@code segment}.
-     */
-    public static char getCharAtOffset_LE(MemorySegment segment, long offset) {
-        return (char)char_LE_handle.get(segment, offset);
-    }
-
-    /**
-     * Writes a char at given segment and offset, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}.
-     * 

-     * This is equivalent to the following code:
-     * 
{@code
-    VarHandle handle = MemoryHandles.withStride(BITS_16_LE.withBitAlignment(8).varHandle(char.class), 1L);
-    handle.set(segment, offset, value);
-     * }

-     * @param segment the segment to be dereferenced.
-     * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
-     * @param value the char value to be written.
-     */
-    public static void setCharAtOffset_LE(MemorySegment segment, long offset, char value) {
-        char_LE_handle.set(segment, offset, value);
-    }
-
-    /**
-     * Read a short from given segment and offset, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}.
-     * 

-     * This is equivalent to the following code:
-     * 
{@code
-    VarHandle handle = MemoryHandles.withStride(BITS_16_LE.withBitAlignment(8).varHandle(short.class), 1L);
-    short value = (short)handle.get(segment, offset);
-     * }

-     * @param segment the segment to be dereferenced.
-     * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
-     * @return a short value read from {@code segment}.
-     */
-    public static short getShortAtOffset_LE(MemorySegment segment, long offset) {
-        return (short)short_LE_handle.get(segment, offset);
-    }
-
-    /**
-     * Writes a short at given segment and offset, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}.
-     * 

-     * This is equivalent to the following code:
-     * 
{@code
-    VarHandle handle = MemoryHandles.withStride(BITS_16_LE.withBitAlignment(8).varHandle(short.class), 1L);
-    handle.set(segment, offset, value);
-     * }

-     * @param segment the segment to be dereferenced.
-     * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
-     * @param value the short value to be written.
-     */
-    public static void setShortAtOffset_LE(MemorySegment segment, long offset, short value) {
-        short_LE_handle.set(segment, offset, value);
-    }
-
-    /**
-     * Read an int from given segment and offset, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}.
-     * 

-     * This is equivalent to the following code:
-     * 
{@code
-    VarHandle handle = MemoryHandles.withStride(BITS_32_LE.withBitAlignment(8).varHandle(int.class), 1L);
-    int value = (int)handle.get(segment, offset);
-     * }

-     * @param segment the segment to be dereferenced.
-     * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
-     * @return an int value read from {@code segment}.
-     */
-    public static int getIntAtOffset_LE(MemorySegment segment, long offset) {
-        return (int)int_LE_handle.get(segment, offset);
-    }
-
-    /**
-     * Writes an int at given segment and offset, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}.
-     * 

-     * This is equivalent to the following code:
-     * 
{@code
-    VarHandle handle = MemoryHandles.withStride(BITS_32_LE.withBitAlignment(8).varHandle(int.class), 1L);
-    handle.set(segment, offset, value);
-     * }

-     * @param segment the segment to be dereferenced.
-     * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
-     * @param value the int value to be written.
-     */
-    public static void setIntAtOffset_LE(MemorySegment segment, long offset, int value) {
-        int_LE_handle.set(segment, offset, value);
-    }
-
-    /**
-     * Read a float from given segment and offset, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}.
-     * 

-     * This is equivalent to the following code:
-     * 
{@code
-    VarHandle handle = MemoryHandles.withStride(BITS_32_LE.withBitAlignment(8).varHandle(float.class), 1L);
-    float value = (float)handle.get(segment, offset);
-     * }

-     * @param segment the segment to be dereferenced.
-     * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
-     * @return a float value read from {@code segment}.
-     */
-    public static float getFloatAtOffset_LE(MemorySegment segment, long offset) {
-        return (float)float_LE_handle.get(segment, offset);
-    }
-
-    /**
-     * Writes a float at given segment and offset, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}.
-     * 

-     * This is equivalent to the following code:
-     * 
{@code
-    VarHandle handle = MemoryHandles.withStride(BITS_32_LE.withBitAlignment(8).varHandle(float.class), 1L);
-    handle.set(segment, offset, value);
-     * }

-     * @param segment the segment to be dereferenced.
-     * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
-     * @param value the float value to be written.
-     */
-    public static void setFloatAtOffset_LE(MemorySegment segment, long offset, float value) {
-        float_LE_handle.set(segment, offset, value);
-    }
-
-    /**
-     * Read a long from given segment and offset, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}.
-     * 

-     * This is equivalent to the following code:
-     * 
{@code
-    VarHandle handle = MemoryHandles.withStride(BITS_64_LE.withBitAlignment(8).varHandle(long.class), 1L);
-    long value = (long)handle.get(segment, offset);
-     * }

-     * @param segment the segment to be dereferenced.
-     * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
-     * @return a long value read from {@code segment}.
-     */
-    public static long getLongAtOffset_LE(MemorySegment segment, long offset) {
-        return (long)long_LE_handle.get(segment, offset);
-    }
-
-    /**
-     * Writes a long at given segment and offset, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}.
-     * 

-     * This is equivalent to the following code:
-     * 
{@code
-    VarHandle handle = MemoryHandles.withStride(BITS_64_LE.withBitAlignment(8).varHandle(long.class), 1L);
-    handle.set(segment, offset, value);
-     * }

-     * @param segment the segment to be dereferenced.
-     * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
-     * @param value the long value to be written.
-     */
-    public static void setLongAtOffset_LE(MemorySegment segment, long offset, long value) {
-        long_LE_handle.set(segment, offset, value);
-    }
-
-    /**
-     * Read a double from given segment and offset, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}.
-     * 

-     * This is equivalent to the following code:
-     * 
{@code
-    VarHandle handle = MemoryHandles.withStride(BITS_64_LE.withBitAlignment(8).varHandle(double.class), 1L);
-    double value = (double)handle.get(segment, offset);
-     * }

-     * @param segment the segment to be dereferenced.
-     * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
-     * @return a double value read from {@code segment}.
-     */
-    public static double getDoubleAtOffset_LE(MemorySegment segment, long offset) {
-        return (double)double_LE_handle.get(segment, offset);
-    }
-
-    /**
-     * Writes a double at given segment and offset, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}.
-     * 

-     * This is equivalent to the following code:
-     * 
{@code
-    VarHandle handle = MemoryHandles.withStride(BITS_64_LE.withBitAlignment(8).varHandle(double.class), 1L);
-    handle.set(segment, offset, value);
-     * }

-     * @param segment the segment to be dereferenced.
-     * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
-     * @param value the double value to be written.
-     */
-    public static void setDoubleAtOffset_LE(MemorySegment segment, long offset, double value) {
-        double_LE_handle.set(segment, offset, value);
-    }
-
-    /**
-     * Read a byte from given segment and offset, with byte order set to {@link ByteOrder#BIG_ENDIAN}.
-     * 

-     * This is equivalent to the following code:
-     * 
{@code
-    VarHandle handle = MemoryHandles.withStride(BITS_8_BE.withBitAlignment(8).varHandle(byte.class), 1L);
-    byte value = (byte)handle.get(segment, offset);
-     * }

-     *
-     * @param segment the segment to be dereferenced.
-     * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
-     * @return a byte value read from {@code segment}.
-     */
-    public static byte getByteAtOffset_BE(MemorySegment segment, long offset) {
-        return (byte)byte_BE_handle.get(segment, offset);
-    }
-
-    /**
-     * Writes a byte at given segment and offset, with byte order set to {@link ByteOrder#BIG_ENDIAN}.
-     * 

-     * This is equivalent to the following code:
-     * 
{@code
-    VarHandle handle = MemoryHandles.withStride(BITS_8_BE.withBitAlignment(8).varHandle(byte.class), 1L);
-    handle.set(segment, offset, value);
-     * }

-     * @param segment the segment to be dereferenced.
-     * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
-     * @param value the byte value to be written.
-     */
-    public static void setByteAtOffset_BE(MemorySegment segment, long offset, byte value) {
-        byte_BE_handle.set(segment, offset, value);
-    }
-
-    /**
-     * Read a char from given segment and offset, with byte order set to {@link ByteOrder#BIG_ENDIAN}.
-     * 

-     * This is equivalent to the following code:
-     * 
{@code
-    VarHandle handle = MemoryHandles.withStride(BITS_16_BE.withBitAlignment(8).varHandle(char.class), 1L);
-    char value = (char)handle.get(segment, offset);
-     * }

-     * @param segment the segment to be dereferenced.
-     * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
-     * @return a char value read from {@code segment}.
-     */
-    public static char getCharAtOffset_BE(MemorySegment segment, long offset) {
-        return (char)char_BE_handle.get(segment, offset);
-    }
-
-    /**
-     * Writes a char at given segment and offset, with byte order set to {@link ByteOrder#BIG_ENDIAN}.
-     * 

-     * This is equivalent to the following code:
-     * 
{@code
-    VarHandle handle = MemoryHandles.withStride(BITS_16_BE.withBitAlignment(8).varHandle(char.class), 1L);
-    handle.set(segment, offset, value);
-     * }

-     * @param segment the segment to be dereferenced.
-     * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
-     * @param value the char value to be written.
-     */
-    public static void setCharAtOffset_BE(MemorySegment segment, long offset, char value) {
-        char_BE_handle.set(segment, offset, value);
-    }
-
-    /**
-     * Read a short from given segment and offset, with byte order set to {@link ByteOrder#BIG_ENDIAN}.
-     * 

-     * This is equivalent to the following code:
-     * 
{@code
-    VarHandle handle = MemoryHandles.withStride(BITS_16_BE.withBitAlignment(8).varHandle(short.class), 1L);
-    short value = (short)handle.get(segment, offset);
-     * }

-     * @param segment the segment to be dereferenced.
-     * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
-     * @return a short value read from {@code segment}.
-     */
-    public static short getShortAtOffset_BE(MemorySegment segment, long offset) {
-        return (short)short_BE_handle.get(segment, offset);
-    }
-
-    /**
-     * Writes a short at given segment and offset, with byte order set to {@link ByteOrder#BIG_ENDIAN}.
-     * 

-     * This is equivalent to the following code:
-     * 
{@code
-    VarHandle handle = MemoryHandles.withStride(BITS_16_BE.withBitAlignment(8).varHandle(short.class), 1L);
-    handle.set(segment, offset, value);
-     * }

-     * @param segment the segment to be dereferenced.
-     * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
-     * @param value the short value to be written.
-     */
-    public static void setShortAtOffset_BE(MemorySegment segment, long offset, short value) {
-        short_BE_handle.set(segment, offset, value);
-    }
-
-    /**
-     * Read an int from given segment and offset, with byte order set to {@link ByteOrder#BIG_ENDIAN}.
-     * 

-     * This is equivalent to the following code:
-     * 
{@code
-    VarHandle handle = MemoryHandles.withStride(BITS_32_BE.withBitAlignment(8).varHandle(int.class), 1L);
-    int value = (int)handle.get(segment, offset);
-     * }

-     * @param segment the segment to be dereferenced.
-     * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
-     * @return an int value read from {@code segment}.
-     */
-    public static int getIntAtOffset_BE(MemorySegment segment, long offset) {
-        return (int)int_BE_handle.get(segment, offset);
-    }
-
-    /**
-     * Writes an int at given segment and offset, with byte order set to {@link ByteOrder#BIG_ENDIAN}.
-     * 

-     * This is equivalent to the following code:
-     * 
{@code
-    VarHandle handle = MemoryHandles.withStride(BITS_32_BE.withBitAlignment(8).varHandle(int.class), 1L);
-    handle.set(segment, offset, value);
-     * }

-     * @param segment the segment to be dereferenced.
-     * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
-     * @param value the int value to be written.
-     */
-    public static void setIntAtOffset_BE(MemorySegment segment, long offset, int value) {
-        int_BE_handle.set(segment, offset, value);
-    }
-
-    /**
-     * Read a float from given segment and offset, with byte order set to {@link ByteOrder#BIG_ENDIAN}.
-     * 

-     * This is equivalent to the following code:
-     * 
{@code
-    VarHandle handle = MemoryHandles.withStride(BITS_32_BE.withBitAlignment(8).varHandle(float.class), 1L);
-    float value = (float)handle.get(segment, offset);
-     * }

-     * @param segment the segment to be dereferenced.
-     * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
-     * @return a float value read from {@code segment}.
-     */
-    public static float getFloatAtOffset_BE(MemorySegment segment, long offset) {
-        return (float)float_BE_handle.get(segment, offset);
-    }
-
-    /**
-     * Writes a float at given segment and offset, with byte order set to {@link ByteOrder#BIG_ENDIAN}.
-     * 

-     * This is equivalent to the following code:
-     * 
{@code
-    VarHandle handle = MemoryHandles.withStride(BITS_32_BE.withBitAlignment(8).varHandle(float.class), 1L);
-    handle.set(segment, offset, value);
-     * }

-     * @param segment the segment to be dereferenced.
-     * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
-     * @param value the float value to be written.
-     */
-    public static void setFloatAtOffset_BE(MemorySegment segment, long offset, float value) {
-        float_BE_handle.set(segment, offset, value);
-    }
-
-    /**
-     * Read a long from given segment and offset, with byte order set to {@link ByteOrder#BIG_ENDIAN}.
-     * 

-     * This is equivalent to the following code:
-     * 
{@code
-    VarHandle handle = MemoryHandles.withStride(BITS_64_BE.withBitAlignment(8).varHandle(long.class), 1L);
-    long value = (long)handle.get(segment, offset);
-     * }

-     * @param segment the segment to be dereferenced.
-     * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
-     * @return a long value read from {@code segment}.
-     */
-    public static long getLongAtOffset_BE(MemorySegment segment, long offset) {
-        return (long)long_BE_handle.get(segment, offset);
-    }
-
-    /**
-     * Writes a long at given segment and offset, with byte order set to {@link ByteOrder#BIG_ENDIAN}.
-     * 

-     * This is equivalent to the following code:
-     * 
{@code
-    VarHandle handle = MemoryHandles.withStride(BITS_64_BE.withBitAlignment(8).varHandle(long.class), 1L);
-    handle.set(segment, offset, value);
-     * }

-     * @param segment the segment to be dereferenced.
-     * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
-     * @param value the long value to be written.
-     */
-    public static void setLongAtOffset_BE(MemorySegment segment, long offset, long value) {
-        long_BE_handle.set(segment, offset, value);
-    }
-
-    /**
-     * Read a double from given segment and offset, with byte order set to {@link ByteOrder#BIG_ENDIAN}.
-     * 

-     * This is equivalent to the following code:
-     * 
{@code
-    VarHandle handle = MemoryHandles.withStride(BITS_64_BE.withBitAlignment(8).varHandle(double.class), 1L);
-    double value = (double)handle.get(segment, offset);
-     * }

-     * @param segment the segment to be dereferenced.
-     * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
-     * @return a double value read from {@code segment}.
-     */
-    public static double getDoubleAtOffset_BE(MemorySegment segment, long offset) {
-        return (double)double_BE_handle.get(segment, offset);
-    }
-
-    /**
-     * Writes a double at given segment and offset, with byte order set to {@link ByteOrder#BIG_ENDIAN}.
-     * 

-     * This is equivalent to the following code:
-     * 
{@code
-    VarHandle handle = MemoryHandles.withStride(BITS_64_BE.withBitAlignment(8).varHandle(double.class), 1L);
-    handle.set(segment, offset, value);
-     * }

-     * @param segment the segment to be dereferenced.
-     * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
-     * @param value the double value to be written.
-     */
-    public static void setDoubleAtOffset_BE(MemorySegment segment, long offset, double value) {
-        double_BE_handle.set(segment, offset, value);
-    }
-
-    /**
-     * Read a byte from given segment and offset, with byte order set to {@link ByteOrder#nativeOrder()}.
-     * 

-     * This is equivalent to the following code:
-     * 
{@code
-    VarHandle handle = MemoryHandles.withStride(JAVA_BYTE.withBitAlignment(8).varHandle(byte.class), 1L);
-    byte value = (byte)handle.get(segment, offset);
-     * }

-     *
-     * @param segment the segment to be dereferenced.
-     * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
-     * @return a byte value read from {@code segment}.
-     */
-    public static byte getByteAtOffset(MemorySegment segment, long offset) {
-        return (byte)((ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN) ? byte_BE_handle : byte_LE_handle).get(segment, offset);
-    }
-
-    /**
-     * Writes a byte at given segment and offset, with byte order set to {@link ByteOrder#nativeOrder()}.
-     * 

-     * This is equivalent to the following code:
-     * 
{@code
-    VarHandle handle = MemoryHandles.withStride(JAVA_BYTE.withBitAlignment(8).varHandle(byte.class), 1L);
-    handle.set(segment, offset, value);
-     * }

-     * @param segment the segment to be dereferenced.
-     * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
-     * @param value the byte value to be written.
-     */
-    public static void setByteAtOffset(MemorySegment segment, long offset, byte value) {
-        ((ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN) ? byte_BE_handle : byte_LE_handle).set(segment, offset, value);
-    }
-
-    /**
-     * Read a char from given segment and offset, with byte order set to {@link ByteOrder#nativeOrder()}.
-     * 

-     * This is equivalent to the following code:
-     * 
{@code
-    VarHandle handle = MemoryHandles.withStride(JAVA_CHAR.withBitAlignment(8).varHandle(char.class), 1L);
-    char value = (char)handle.get(segment, offset);
-     * }

-     * @param segment the segment to be dereferenced.
-     * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
-     * @return a char value read from {@code segment}.
-     */
-    public static char getCharAtOffset(MemorySegment segment, long offset) {
-        return (char)((ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN) ? char_BE_handle : char_LE_handle).get(segment, offset);
-    }
-
-    /**
-     * Writes a char at given segment and offset, with byte order set to {@link ByteOrder#nativeOrder()}.
-     * 

-     * This is equivalent to the following code:
-     * 
{@code
-    VarHandle handle = MemoryHandles.withStride(JAVA_CHAR.withBitAlignment(8).varHandle(char.class), 1L);
-    handle.set(segment, offset, value);
-     * }

-     * @param segment the segment to be dereferenced.
-     * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
-     * @param value the char value to be written.
-     */
-    public static void setCharAtOffset(MemorySegment segment, long offset, char value) {
-        ((ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN) ? char_BE_handle : char_LE_handle).set(segment, offset, value);
-    }
-
-    /**
-     * Read a short from given segment and offset, with byte order set to {@link ByteOrder#nativeOrder()}.
-     * 

-     * This is equivalent to the following code:
-     * 
{@code
-    VarHandle handle = MemoryHandles.withStride(JAVA_SHORT.withBitAlignment(8).varHandle(short.class), 1L);
-    short value = (short)handle.get(segment, offset);
-     * }

-     * @param segment the segment to be dereferenced.
-     * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
-     * @return a short value read from {@code segment}.
-     */
-    public static short getShortAtOffset(MemorySegment segment, long offset) {
-        return (short)((ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN) ? short_BE_handle : short_LE_handle).get(segment, offset);
-    }
-
-    /**
-     * Writes a short at given segment and offset, with byte order set to {@link ByteOrder#nativeOrder()}.
-     * 

-     * This is equivalent to the following code:
-     * 
{@code
-    VarHandle handle = MemoryHandles.withStride(JAVA_SHORT.withBitAlignment(8).varHandle(short.class), 1L);
-    handle.set(segment, offset, value);
-     * }

-     * @param segment the segment to be dereferenced.
-     * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
-     * @param value the short value to be written.
-     */
-    public static void setShortAtOffset(MemorySegment segment, long offset, short value) {
-        ((ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN) ? short_BE_handle : short_LE_handle).set(segment, offset, value);
-    }
-
-    /**
-     * Read an int from given segment and offset, with byte order set to {@link ByteOrder#nativeOrder()}.
-     * 

-     * This is equivalent to the following code:
-     * 
{@code
-    VarHandle handle = MemoryHandles.withStride(JAVA_INT.withBitAlignment(8).varHandle(int.class), 1L);
-    int value = (int)handle.get(segment, offset);
-     * }

-     * @param segment the segment to be dereferenced.
-     * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
-     * @return an int value read from {@code segment}.
-     */
-    public static int getIntAtOffset(MemorySegment segment, long offset) {
-        return (int)((ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN) ? int_BE_handle : int_LE_handle).get(segment, offset);
-    }
-
-    /**
-     * Writes an int at given segment and offset, with byte order set to {@link ByteOrder#nativeOrder()}.
-     * 

-     * This is equivalent to the following code:
-     * 
{@code
-    VarHandle handle = MemoryHandles.withStride(JAVA_INT.withBitAlignment(8).varHandle(int.class), 1L);
-    handle.set(segment, offset, value);
-     * }

-     * @param segment the segment to be dereferenced.
-     * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
-     * @param value the int value to be written.
-     */
-    public static void setIntAtOffset(MemorySegment segment, long offset, int value) {
-        ((ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN) ? int_BE_handle : int_LE_handle).set(segment, offset, value);
-    }
-
-    /**
-     * Read a float from given segment and offset, with byte order set to {@link ByteOrder#nativeOrder()}.
-     * 

-     * This is equivalent to the following code:
-     * 
{@code
-    VarHandle handle = MemoryHandles.withStride(JAVA_FLOAT.withBitAlignment(8).varHandle(float.class), 1L);
-    float value = (float)handle.get(segment, offset);
-     * }

-     * @param segment the segment to be dereferenced.
-     * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
-     * @return a float value read from {@code segment}.
-     */
-    public static float getFloatAtOffset(MemorySegment segment, long offset) {
-        return (float)((ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN) ? float_BE_handle : float_LE_handle).get(segment, offset);
-    }
-
-    /**
-     * Writes a float at given segment and offset, with byte order set to {@link ByteOrder#nativeOrder()}.
-     * 

-     * This is equivalent to the following code:
-     * 
{@code
-    VarHandle handle = MemoryHandles.withStride(JAVA_FLOAT.withBitAlignment(8).varHandle(float.class), 1L);
-    handle.set(segment, offset, value);
-     * }

-     * @param segment the segment to be dereferenced.
-     * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
-     * @param value the float value to be written.
-     */
-    public static void setFloatAtOffset(MemorySegment segment, long offset, float value) {
-        ((ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN) ? float_BE_handle : float_LE_handle).set(segment, offset, value);
-    }
-
-    /**
-     * Read a long from given segment and offset, with byte order set to {@link ByteOrder#nativeOrder()}.
-     * 

-     * This is equivalent to the following code:
-     * 
{@code
-    VarHandle handle = MemoryHandles.withStride(JAVA_LONG.withBitAlignment(8).varHandle(long.class), 1L);
-    long value = (long)handle.get(segment, offset);
-     * }

-     * @param segment the segment to be dereferenced.
-     * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
-     * @return a long value read from {@code segment}.
-     */
-    public static long getLongAtOffset(MemorySegment segment, long offset) {
-        return (long)((ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN) ? long_BE_handle : long_LE_handle).get(segment, offset);
-    }
-
-    /**
-     * Writes a long at given segment and offset, with byte order set to {@link ByteOrder#nativeOrder()}.
-     * 

-     * This is equivalent to the following code:
-     * 
{@code
-    VarHandle handle = MemoryHandles.withStride(JAVA_LONG.withBitAlignment(8).varHandle(long.class), 1L);
-    handle.set(segment, offset, value);
-     * }

-     * @param segment the segment to be dereferenced.
-     * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
-     * @param value the long value to be written.
-     */
-    public static void setLongAtOffset(MemorySegment segment, long offset, long value) {
-        ((ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN) ? long_BE_handle : long_LE_handle).set(segment, offset, value);
-    }
-
-    /**
-     * Read a double from given segment and offset, with byte order set to {@link ByteOrder#nativeOrder()}.
-     * 

-     * This is equivalent to the following code:
-     * 
{@code
-    VarHandle handle = MemoryHandles.withStride(JAVA_DOUBLE.withBitAlignment(8).varHandle(double.class), 1L);
-    double value = (double)handle.get(segment, offset);
-     * }

-     * @param segment the segment to be dereferenced.
-     * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
-     * @return a double value read from {@code segment}.
-     */
-    public static double getDoubleAtOffset(MemorySegment segment, long offset) {
-        return (double)((ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN) ? double_BE_handle : double_LE_handle).get(segment, offset);
-    }
-
-    /**
-     * Writes a double at given segment and offset, with byte order set to {@link ByteOrder#nativeOrder()}.
-     * 

-     * This is equivalent to the following code:
-     * 
{@code
-    VarHandle handle = MemoryHandles.withStride(JAVA_DOUBLE.withBitAlignment(8).varHandle(double.class), 1L);
-    handle.set(segment, offset, value);
-     * }

-     * @param segment the segment to be dereferenced.
-     * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
-     * @param value the double value to be written.
-     */
-    public static void setDoubleAtOffset(MemorySegment segment, long offset, double value) {
-        ((ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN) ? double_BE_handle : double_LE_handle).set(segment, offset, value);
-    }
-
-    /**
-     * Read a memory address from given segment and offset, with byte order set to {@link ByteOrder#nativeOrder()}.
-     * 

-     * This is equivalent to the following code:
-     * 
{@code
-    VarHandle handle = MemoryHandles.asAddressHandle(MemoryHandles.withStride(JAVA_LONG.withBitAlignment(8).varHandle(long.class), 1L));
-    MemoryAddress value = (MemoryAddress)handle.get(segment, offset);
-     * }

-     * @param segment the segment to be dereferenced.
-     * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
-     * @return a memory address read from {@code segment}.
-     */
-    public static MemoryAddress getAddressAtOffset(MemorySegment segment, long offset) {
-        return (MemoryAddress)address_handle.get(segment, offset);
-    }
-
-    /**
-     * Writes a memory address at given segment and offset, with byte order set to {@link ByteOrder#nativeOrder()}.
-     * 

-     * This is equivalent to the following code:
-     * 
{@code
-    VarHandle handle = MemoryHandles.asAddressHandle(MemoryHandles.withStride(JAVA_LONG.withBitAlignment(8).varHandle(long.class), 1L));
-    handle.set(segment, offset, value.address());
-     * }

-     * @param segment the segment to be dereferenced.
-     * @param offset offset (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
-     * @param value the memory address to be written (expressed as an {@link Addressable} instance).
-     */
-    public static void setAddressAtOffset(MemorySegment segment, long offset, Addressable value) {
-        address_handle.set(segment, offset, value.address());
+    private static final VarHandle byte_LE_handle = unalignedHandle(MemoryLayouts.BITS_8_LE, byte.class);
+    private static final VarHandle char_LE_handle = unalignedHandle(MemoryLayouts.BITS_16_LE, char.class);
+    private static final VarHandle short_LE_handle = unalignedHandle(MemoryLayouts.BITS_16_LE, short.class);
+    private static final VarHandle int_LE_handle = unalignedHandle(MemoryLayouts.BITS_32_LE, int.class);
+    private static final VarHandle float_LE_handle = unalignedHandle(MemoryLayouts.BITS_32_LE, float.class);
+    private static final VarHandle long_LE_handle = unalignedHandle(MemoryLayouts.BITS_64_LE, long.class);
+    private static final VarHandle double_LE_handle = unalignedHandle(MemoryLayouts.BITS_64_LE, double.class);
+    private static final VarHandle byte_BE_handle = unalignedHandle(MemoryLayouts.BITS_8_BE, byte.class);
+    private static final VarHandle char_BE_handle = unalignedHandle(MemoryLayouts.BITS_16_BE, char.class);
+    private static final VarHandle short_BE_handle = unalignedHandle(MemoryLayouts.BITS_16_BE, short.class);
+    private static final VarHandle int_BE_handle = unalignedHandle(MemoryLayouts.BITS_32_BE, int.class);
+    private static final VarHandle float_BE_handle = unalignedHandle(MemoryLayouts.BITS_32_BE, float.class);
+    private static final VarHandle long_BE_handle = unalignedHandle(MemoryLayouts.BITS_64_BE, long.class);
+    private static final VarHandle double_BE_handle = unalignedHandle(MemoryLayouts.BITS_64_BE, double.class);
+    private static final VarHandle address_handle;
+
+    static {
+        Class carrier = switch ((int) MemoryLayouts.ADDRESS.byteSize()) {
+            case 4 -> int.class;
+            case 8 -> long.class;
+            default -> throw new ExceptionInInitializerError("Unsupported pointer size: " + MemoryLayouts.ADDRESS.byteSize());
+        };
+        address_handle = MemoryHandles.asAddressVarHandle(unalignedHandle(MemoryLayouts.ADDRESS, carrier));
     }
 
-    private static VarHandle indexedHandle(ValueLayout elementLayout, Class carrier) {
+    private static VarHandle unalignedHandle(ValueLayout elementLayout, Class carrier) {
         return MemoryHandles.varHandle(carrier, 1, elementLayout.order());
     }
 
     /**
-     * Read a byte from given segment, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}.
+     * Reads a byte from given segment and offset, with byte order set to {@link ByteOrder#nativeOrder()}.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    byte value = getByteAtOffset_LE(segment, 0L);
+    getByteAtOffset(segment, offset, ByteOrder.nativeOrder());
      * }

      *
      * @param segment the segment to be dereferenced.
+     * @param offset offset in bytes (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
      * @return a byte value read from {@code segment}.
      */
-    public static byte getByte_LE(MemorySegment segment) {
-        return getByteAtOffset_LE(segment, 0L);
+    public static byte getByteAtOffset(MemorySegment segment, long offset) {
+        return getByteAtOffset(segment, offset, ByteOrder.nativeOrder());
     }
 
     /**
-     * Writes a byte at given segment, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}.
+     * Writes a byte at given segment and offset, with byte order set to {@link ByteOrder#nativeOrder()}.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    setByteAtOffset_LE(segment, 0L, value);
+    setByteAtOffset(segment, offset, ByteOrder.nativeOrder(), value);
      * }

      * @param segment the segment to be dereferenced.
+     * @param offset offset in bytes (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
      * @param value the byte value to be written.
      */
-    public static void setByte_LE(MemorySegment segment, byte value) {
-        setByteAtOffset_LE(segment, 0L, value);
+    public static void setByteAtOffset(MemorySegment segment, long offset, byte value) {
+        setByteAtOffset(segment, offset, ByteOrder.nativeOrder(), value);
     }
 
     /**
-     * Read a char from given segment, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}.
+     * Reads a char from given segment and offset, with byte order set to {@link ByteOrder#nativeOrder()}.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    char value = getCharAtOffset_LE(segment, 0L);
+    getCharAtOffset(segment, offset, ByteOrder.nativeOrder());
      * }

      * @param segment the segment to be dereferenced.
+     * @param offset offset in bytes (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
      * @return a char value read from {@code segment}.
      */
-    public static char getChar_LE(MemorySegment segment) {
-        return getCharAtOffset_LE(segment, 0L);
+    public static char getCharAtOffset(MemorySegment segment, long offset) {
+        return getCharAtOffset(segment, offset, ByteOrder.nativeOrder());
     }
 
     /**
-     * Writes a char at given segment, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}.
+     * Writes a char at given segment and offset, with byte order set to {@link ByteOrder#nativeOrder()}.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    setCharAtOffset_LE(segment, 0L, value);
+    setCharAtOffset(segment, offset, ByteOrder.nativeOrder(), value);
      * }

      * @param segment the segment to be dereferenced.
+     * @param offset offset in bytes (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
      * @param value the char value to be written.
      */
-    public static void setChar_LE(MemorySegment segment, char value) {
-        setCharAtOffset_LE(segment, 0L, value);
+    public static void setCharAtOffset(MemorySegment segment, long offset, char value) {
+        setCharAtOffset(segment, offset, ByteOrder.nativeOrder(), value);
     }
 
     /**
-     * Read a short from given segment, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}.
+     * Reads a short from given segment and offset, with byte order set to {@link ByteOrder#nativeOrder()}.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    short value = getShortAtOffset_LE(segment, 0L);
+    getShortAtOffset(segment, offset, ByteOrder.nativeOrder());
      * }

      * @param segment the segment to be dereferenced.
+     * @param offset offset in bytes (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
      * @return a short value read from {@code segment}.
      */
-    public static short getShort_LE(MemorySegment segment) {
-        return getShortAtOffset_LE(segment, 0L);
+    public static short getShortAtOffset(MemorySegment segment, long offset) {
+        return getShortAtOffset(segment, offset, ByteOrder.nativeOrder());
     }
 
     /**
-     * Writes a short at given segment, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}.
+     * Writes a short at given segment and offset, with byte order set to {@link ByteOrder#nativeOrder()}.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    setShortAtOffset_LE(segment, 0L, value);
+    setShortAtOffset(segment, offset, ByteOrder.nativeOrder(), value);
      * }

      * @param segment the segment to be dereferenced.
+     * @param offset offset in bytes (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
      * @param value the short value to be written.
      */
-    public static void setShort_LE(MemorySegment segment, short value) {
-        setShortAtOffset_LE(segment, 0L, value);
+    public static void setShortAtOffset(MemorySegment segment, long offset, short value) {
+        setShortAtOffset(segment, offset, ByteOrder.nativeOrder(), value);
     }
 
     /**
-     * Read an int from given segment, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}.
+     * Reads an int from given segment and offset, with byte order set to {@link ByteOrder#nativeOrder()}.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    int value = getIntAtOffset_LE(segment, 0L);
+    getIntAtOffset(segment, offset, ByteOrder.nativeOrder());
      * }

      * @param segment the segment to be dereferenced.
+     * @param offset offset in bytes (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
      * @return an int value read from {@code segment}.
      */
-    public static int getInt_LE(MemorySegment segment) {
-        return getIntAtOffset_LE(segment, 0L);
+    public static int getIntAtOffset(MemorySegment segment, long offset) {
+        return getIntAtOffset(segment, offset, ByteOrder.nativeOrder());
     }
 
     /**
-     * Writes an int at given segment, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}.
+     * Writes an int at given segment and offset, with byte order set to {@link ByteOrder#nativeOrder()}.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    setIntAtOffset_LE(segment, 0L, value);
+    setIntAtOffset(segment, offset, ByteOrder.nativeOrder(), value);
      * }

      * @param segment the segment to be dereferenced.
+     * @param offset offset in bytes (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
      * @param value the int value to be written.
      */
-    public static void setInt_LE(MemorySegment segment, int value) {
-        setIntAtOffset_LE(segment, 0L, value);
+    public static void setIntAtOffset(MemorySegment segment, long offset, int value) {
+        setIntAtOffset(segment, offset, ByteOrder.nativeOrder(), value);
     }
 
     /**
-     * Read a float from given segment, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}.
+     * Reads a float from given segment and offset, with byte order set to {@link ByteOrder#nativeOrder()}.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    float value = getFloatAtOffset_LE(segment, 0L);
+    getFloatAtOffset(segment, offset, ByteOrder.nativeOrder());
      * }

      * @param segment the segment to be dereferenced.
+     * @param offset offset in bytes (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
      * @return a float value read from {@code segment}.
      */
-    public static float getFloat_LE(MemorySegment segment) {
-        return getFloatAtOffset_LE(segment, 0L);
+    public static float getFloatAtOffset(MemorySegment segment, long offset) {
+        return getFloatAtOffset(segment, offset, ByteOrder.nativeOrder());
     }
 
     /**
-     * Writes a float at given segment, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}.
+     * Writes a float at given segment and offset, with byte order set to {@link ByteOrder#nativeOrder()}.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    setFloatAtOffset_LE(segment, 0L, value);
+    setFloatAtOffset(segment, offset, ByteOrder.nativeOrder(), value);
      * }

      * @param segment the segment to be dereferenced.
+     * @param offset offset in bytes (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
      * @param value the float value to be written.
      */
-    public static void setFloat_LE(MemorySegment segment, float value) {
-        setFloatAtOffset_LE(segment, 0L, value);
+    public static void setFloatAtOffset(MemorySegment segment, long offset, float value) {
+        setFloatAtOffset(segment, offset, ByteOrder.nativeOrder(), value);
     }
 
     /**
-     * Read a long from given segment, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}.
+     * Reads a long from given segment and offset, with byte order set to {@link ByteOrder#nativeOrder()}.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    long value = getLongAtOffset_LE(segment, 0L);
+    getLongAtOffset(segment, offset, ByteOrder.nativeOrder());
      * }

      * @param segment the segment to be dereferenced.
+     * @param offset offset in bytes (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
      * @return a long value read from {@code segment}.
      */
-    public static long getLong_LE(MemorySegment segment) {
-        return getLongAtOffset_LE(segment, 0L);
+    public static long getLongAtOffset(MemorySegment segment, long offset) {
+        return getLongAtOffset(segment, offset, ByteOrder.nativeOrder());
     }
 
     /**
-     * Writes a long at given segment, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}.
+     * Writes a long at given segment and offset, with byte order set to {@link ByteOrder#nativeOrder()}.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    setLongAtOffset_LE(segment, 0L, value);
+    setLongAtOffset(segment, offset, ByteOrder.nativeOrder(), value);
      * }

      * @param segment the segment to be dereferenced.
+     * @param offset offset in bytes (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
      * @param value the long value to be written.
      */
-    public static void setLong_LE(MemorySegment segment, long value) {
-        setLongAtOffset_LE(segment, 0L, value);
+    public static void setLongAtOffset(MemorySegment segment, long offset, long value) {
+        setLongAtOffset(segment, offset, ByteOrder.nativeOrder(), value);
     }
 
     /**
-     * Read a double from given segment, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}.
+     * Reads a double from given segment and offset, with byte order set to {@link ByteOrder#nativeOrder()}.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    double value = getDoubleAtOffset_LE(segment, 0L);
+    getDoubleAtOffset(segment, offset, ByteOrder.nativeOrder());
      * }

      * @param segment the segment to be dereferenced.
+     * @param offset offset in bytes (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
      * @return a double value read from {@code segment}.
      */
-    public static double getDouble_LE(MemorySegment segment) {
-        return getDoubleAtOffset_LE(segment, 0L);
+    public static double getDoubleAtOffset(MemorySegment segment, long offset) {
+        return getDoubleAtOffset(segment, offset, ByteOrder.nativeOrder());
     }
 
     /**
-     * Writes a double at given segment, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}.
+     * Writes a double at given segment and offset, with byte order set to {@link ByteOrder#nativeOrder()}.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    setDoubleAtOffset_LE(segment, 0L, value);
+    setDoubleAtOffset(segment, offset, ByteOrder.nativeOrder(), value);
      * }

      * @param segment the segment to be dereferenced.
+     * @param offset offset in bytes (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
      * @param value the double value to be written.
      */
-    public static void setDouble_LE(MemorySegment segment, double value) {
-        setDoubleAtOffset_LE(segment, 0L, value);
+    public static void setDoubleAtOffset(MemorySegment segment, long offset, double value) {
+        setDoubleAtOffset(segment, offset, ByteOrder.nativeOrder(), value);
+    }
+
+    /**
+     * Reads a memory address from given segment and offset, with byte order set to {@link ByteOrder#nativeOrder()}.
+     * 

+     * This is equivalent (e.g. on a 64-bit platform) to the following code:
+     * 
{@code
+    VarHandle handle = MemoryHandles.asAddressHandle(MemoryHandles.varHandle(long.class, ByteOrder.nativeOrder()));
+    MemoryAddress value = (MemoryAddress)handle.get(segment, offset);
+     * }

+     * @param segment the segment to be dereferenced.
+     * @param offset offset in bytes (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
+     * @return a memory address read from {@code segment}.
+     */
+    public static MemoryAddress getAddressAtOffset(MemorySegment segment, long offset) {
+        return (MemoryAddress)address_handle.get(segment, offset);
+    }
+
+    /**
+     * Writes a memory address at given segment and offset, with byte order set to {@link ByteOrder#nativeOrder()}.
+     * 

+     * This is equivalent (e.g. on a 64-bit platform) to the following code:
+     * 
{@code
+    VarHandle handle = MemoryHandles.asAddressHandle(MemoryHandles.varHandle(long.class, ByteOrder.nativeOrder()));
+    handle.set(segment, offset, value.address());
+     * }

+     * @param segment the segment to be dereferenced.
+     * @param offset offset in bytes (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
+     * @param value the memory address to be written (expressed as an {@link Addressable} instance).
+     */
+    public static void setAddressAtOffset(MemorySegment segment, long offset, Addressable value) {
+        address_handle.set(segment, offset, value.address());
     }
 
     /**
-     * Read a byte from given segment, with byte order set to {@link ByteOrder#BIG_ENDIAN}.
+     * Reads a byte from given segment and offset with given byte order.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    byte value = getByteAtOffset_BE(segment, 0L);
+    VarHandle handle = MemoryHandles.varHandle(byte.class, 1, order);
+    byte value = (byte)handle.get(segment, offset);
      * }

      *
      * @param segment the segment to be dereferenced.
+     * @param offset offset in bytes (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
+     * @param order the specified byte order.
      * @return a byte value read from {@code segment}.
      */
-    public static byte getByte_BE(MemorySegment segment) {
-        return getByteAtOffset_BE(segment, 0L);
+    public static byte getByteAtOffset(MemorySegment segment, long offset, ByteOrder order) {
+        return (byte)((order == ByteOrder.BIG_ENDIAN) ? byte_BE_handle : byte_LE_handle).get(segment, offset);
     }
 
     /**
-     * Writes a byte at given segment, with byte order set to {@link ByteOrder#BIG_ENDIAN}.
+     * Writes a byte at given segment and offset with given byte order.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    setByteAtOffset_BE(segment, 0L, value);
+    VarHandle handle = MemoryHandles.varHandle(byte.class, 1, order);
+    handle.set(segment, offset, value);
      * }

      * @param segment the segment to be dereferenced.
+     * @param offset offset in bytes (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
+     * @param order the specified byte order.
      * @param value the byte value to be written.
      */
-    public static void setByte_BE(MemorySegment segment, byte value) {
-        setByteAtOffset_BE(segment, 0L, value);
+    public static void setByteAtOffset(MemorySegment segment, long offset, ByteOrder order, byte value) {
+        ((order == ByteOrder.BIG_ENDIAN) ? byte_BE_handle : byte_LE_handle).set(segment, offset, value);
     }
 
     /**
-     * Read a char from given segment, with byte order set to {@link ByteOrder#BIG_ENDIAN}.
+     * Reads a char from given segment and offset with given byte order.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    char value = getCharAtOffset_BE(segment, 0L);
+    VarHandle handle = MemoryHandles.varHandle(char.class, 1, order);
+    char value = (char)handle.get(segment, offset);
      * }

      * @param segment the segment to be dereferenced.
+     * @param offset offset in bytes (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
+     * @param order the specified byte order.
      * @return a char value read from {@code segment}.
      */
-    public static char getChar_BE(MemorySegment segment) {
-        return getCharAtOffset_BE(segment, 0L);
+    public static char getCharAtOffset(MemorySegment segment, long offset, ByteOrder order) {
+        return (char)((order == ByteOrder.BIG_ENDIAN) ? char_BE_handle : char_LE_handle).get(segment, offset);
     }
 
     /**
-     * Writes a char at given segment, with byte order set to {@link ByteOrder#BIG_ENDIAN}.
+     * Writes a char at given segment and offset with given byte order.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    setCharAtOffset_BE(segment, 0L, value);
+    VarHandle handle = MemoryHandles.varHandle(char.class, 1, order);
+    handle.set(segment, offset, value);
      * }

      * @param segment the segment to be dereferenced.
+     * @param offset offset in bytes (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
+     * @param order the specified byte order.
      * @param value the char value to be written.
      */
-    public static void setChar_BE(MemorySegment segment, char value) {
-        setCharAtOffset_BE(segment, 0L, value);
+    public static void setCharAtOffset(MemorySegment segment, long offset, ByteOrder order, char value) {
+        ((order == ByteOrder.BIG_ENDIAN) ? char_BE_handle : char_LE_handle).set(segment, offset, value);
     }
 
     /**
-     * Read a short from given segment, with byte order set to {@link ByteOrder#BIG_ENDIAN}.
+     * Reads a short from given segment and offset with given byte order.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    short value = getShortAtOffset_BE(segment, 0L);
+    VarHandle handle = MemoryHandles.varHandle(short.class, 1, order);
+    short value = (short)handle.get(segment, offset);
      * }

      * @param segment the segment to be dereferenced.
+     * @param offset offset in bytes (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
+     * @param order the specified byte order.
      * @return a short value read from {@code segment}.
      */
-    public static short getShort_BE(MemorySegment segment) {
-        return getShortAtOffset_BE(segment, 0L);
+    public static short getShortAtOffset(MemorySegment segment, long offset, ByteOrder order) {
+        return (short)((order == ByteOrder.BIG_ENDIAN) ? short_BE_handle : short_LE_handle).get(segment, offset);
     }
 
     /**
-     * Writes a short at given segment, with byte order set to {@link ByteOrder#BIG_ENDIAN}.
+     * Writes a short at given segment and offset with given byte order.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    setShortAtOffset_BE(segment, 0L, value);
+    VarHandle handle = MemoryHandles.varHandle(short.class, 1, order);
+    handle.set(segment, offset, value);
      * }

      * @param segment the segment to be dereferenced.
+     * @param offset offset in bytes (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
+     * @param order the specified byte order.
      * @param value the short value to be written.
      */
-    public static void setShort_BE(MemorySegment segment, short value) {
-        setShortAtOffset_BE(segment, 0L, value);
+    public static void setShortAtOffset(MemorySegment segment, long offset, ByteOrder order, short value) {
+        ((order == ByteOrder.BIG_ENDIAN) ? short_BE_handle : short_LE_handle).set(segment, offset, value);
     }
 
     /**
-     * Read an int from given segment, with byte order set to {@link ByteOrder#BIG_ENDIAN}.
+     * Reads an int from given segment and offset with given byte order.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    int value = getIntAtOffset_BE(segment, 0L);
+    VarHandle handle = MemoryHandles.varHandle(int.class, 1, order);
+    int value = (int)handle.get(segment, offset);
      * }

      * @param segment the segment to be dereferenced.
+     * @param offset offset in bytes (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
+     * @param order the specified byte order.
      * @return an int value read from {@code segment}.
      */
-    public static int getInt_BE(MemorySegment segment) {
-        return getIntAtOffset_BE(segment, 0L);
+    public static int getIntAtOffset(MemorySegment segment, long offset, ByteOrder order) {
+        return (int)((order == ByteOrder.BIG_ENDIAN) ? int_BE_handle : int_LE_handle).get(segment, offset);
     }
 
     /**
-     * Writes an int at given segment, with byte order set to {@link ByteOrder#BIG_ENDIAN}.
+     * Writes an int at given segment and offset with given byte order.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    setIntAtOffset_BE(segment, 0L, value);
+    VarHandle handle = MemoryHandles.varHandle(int.class, 1, order);
+    handle.set(segment, offset, value);
      * }

      * @param segment the segment to be dereferenced.
+     * @param offset offset in bytes (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
+     * @param order the specified byte order.
      * @param value the int value to be written.
      */
-    public static void setInt_BE(MemorySegment segment, int value) {
-        setIntAtOffset_BE(segment, 0L, value);
+    public static void setIntAtOffset(MemorySegment segment, long offset, ByteOrder order, int value) {
+        ((order == ByteOrder.BIG_ENDIAN) ? int_BE_handle : int_LE_handle).set(segment, offset, value);
     }
 
     /**
-     * Read a float from given segment, with byte order set to {@link ByteOrder#BIG_ENDIAN}.
+     * Reads a float from given segment and offset with given byte order.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    float value = getFloatAtOffset_BE(segment, 0L);
+    VarHandle handle = MemoryHandles.varHandle(float.class, 1, order);
+    float value = (float)handle.get(segment, offset);
      * }

      * @param segment the segment to be dereferenced.
+     * @param offset offset in bytes (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
+     * @param order the specified byte order.
      * @return a float value read from {@code segment}.
      */
-    public static float getFloat_BE(MemorySegment segment) {
-        return getFloatAtOffset_BE(segment, 0L);
+    public static float getFloatAtOffset(MemorySegment segment, long offset, ByteOrder order) {
+        return (float)((order == ByteOrder.BIG_ENDIAN) ? float_BE_handle : float_LE_handle).get(segment, offset);
     }
 
     /**
-     * Writes a float at given segment, with byte order set to {@link ByteOrder#BIG_ENDIAN}.
+     * Writes a float at given segment and offset with given byte order.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    setFloatAtOffset_BE(segment, 0L, value);
+    VarHandle handle = MemoryHandles.varHandle(float.class, 1, order);
+    handle.set(segment, offset, value);
      * }

      * @param segment the segment to be dereferenced.
+     * @param offset offset in bytes (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
+     * @param order the specified byte order.
      * @param value the float value to be written.
      */
-    public static void setFloat_BE(MemorySegment segment, float value) {
-        setFloatAtOffset_BE(segment, 0L, value);
+    public static void setFloatAtOffset(MemorySegment segment, long offset, ByteOrder order, float value) {
+        ((order == ByteOrder.BIG_ENDIAN) ? float_BE_handle : float_LE_handle).set(segment, offset, value);
     }
 
     /**
-     * Read a long from given segment, with byte order set to {@link ByteOrder#BIG_ENDIAN}.
+     * Reads a long from given segment and offset with given byte order.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    long value = getLongAtOffset_BE(segment, 0L);
+    VarHandle handle = MemoryHandles.varHandle(long.class, 1, order);
+    long value = (long)handle.get(segment, offset);
      * }

      * @param segment the segment to be dereferenced.
+     * @param offset offset in bytes (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
+     * @param order the specified byte order.
      * @return a long value read from {@code segment}.
      */
-    public static long getLong_BE(MemorySegment segment) {
-        return getLongAtOffset_BE(segment, 0L);
+    public static long getLongAtOffset(MemorySegment segment, long offset, ByteOrder order) {
+        return (long)((order == ByteOrder.BIG_ENDIAN) ? long_BE_handle : long_LE_handle).get(segment, offset);
     }
 
     /**
-     * Writes a long at given segment, with byte order set to {@link ByteOrder#BIG_ENDIAN}.
+     * Writes a long at given segment and offset with given byte order.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    setLongAtOffset_BE(segment, 0L, value);
+    VarHandle handle = MemoryHandles.varHandle(long.class, 1, order);
+    handle.set(segment, offset, value);
      * }

      * @param segment the segment to be dereferenced.
+     * @param offset offset in bytes (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
+     * @param order the specified byte order.
      * @param value the long value to be written.
      */
-    public static void setLong_BE(MemorySegment segment, long value) {
-        setLongAtOffset_BE(segment, 0L, value);
+    public static void setLongAtOffset(MemorySegment segment, long offset, ByteOrder order, long value) {
+        ((order == ByteOrder.BIG_ENDIAN) ? long_BE_handle : long_LE_handle).set(segment, offset, value);
     }
 
     /**
-     * Read a double from given segment, with byte order set to {@link ByteOrder#BIG_ENDIAN}.
+     * Reads a double from given segment and offset with given byte order.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    double value = getDoubleAtOffset_BE(segment, 0L);
+    VarHandle handle = MemoryHandles.varHandle(double.class, 1, order);
+    double value = (double)handle.get(segment, offset);
      * }

      * @param segment the segment to be dereferenced.
+     * @param offset offset in bytes (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
+     * @param order the specified byte order.
      * @return a double value read from {@code segment}.
      */
-    public static double getDouble_BE(MemorySegment segment) {
-        return getDoubleAtOffset_BE(segment, 0L);
+    public static double getDoubleAtOffset(MemorySegment segment, long offset, ByteOrder order) {
+        return (double)((order == ByteOrder.BIG_ENDIAN) ? double_BE_handle : double_LE_handle).get(segment, offset);
     }
 
     /**
-     * Writes a double at given segment, with byte order set to {@link ByteOrder#BIG_ENDIAN}.
+     * Writes a double at given segment and offset with given byte order.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    setDoubleAtOffset_BE(segment, 0L, value);
+    VarHandle handle = MemoryHandles.varHandle(double.class, 1, order);
+    handle.set(segment, offset, value);
      * }

      * @param segment the segment to be dereferenced.
+     * @param offset offset in bytes (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
+     * @param order the specified byte order.
      * @param value the double value to be written.
      */
-    public static void setDouble_BE(MemorySegment segment, double value) {
-        setDoubleAtOffset_BE(segment, 0L, value);
+    public static void setDoubleAtOffset(MemorySegment segment, long offset, ByteOrder order, double value) {
+        ((order == ByteOrder.BIG_ENDIAN) ? double_BE_handle : double_LE_handle).set(segment, offset, value);
     }
 
     /**
-     * Read a byte from given segment, with byte order set to {@link ByteOrder#nativeOrder()}.
+     * Reads a byte from given segment, with byte order set to {@link ByteOrder#nativeOrder()}.
      * 

      * This is equivalent to the following code:
      * 
{@code
@@ -1213,7 +597,7 @@ public static void setByte(MemorySegment segment, byte value) {
     }
 
     /**
-     * Read a char from given segment, with byte order set to {@link ByteOrder#nativeOrder()}.
+     * Reads a char from given segment, with byte order set to {@link ByteOrder#nativeOrder()}.
      * 

      * This is equivalent to the following code:
      * 
{@code
@@ -1241,7 +625,7 @@ public static void setChar(MemorySegment segment, char value) {
     }
 
     /**
-     * Read a short from given segment, with byte order set to {@link ByteOrder#nativeOrder()}.
+     * Reads a short from given segment, with byte order set to {@link ByteOrder#nativeOrder()}.
      * 

      * This is equivalent to the following code:
      * 
{@code
@@ -1269,7 +653,7 @@ public static void setShort(MemorySegment segment, short value) {
     }
 
     /**
-     * Read an int from given segment, with byte order set to {@link ByteOrder#nativeOrder()}.
+     * Reads an int from given segment, with byte order set to {@link ByteOrder#nativeOrder()}.
      * 

      * This is equivalent to the following code:
      * 
{@code
@@ -1297,7 +681,7 @@ public static void setInt(MemorySegment segment, int value) {
     }
 
     /**
-     * Read a float from given segment, with byte order set to {@link ByteOrder#nativeOrder()}.
+     * Reads a float from given segment, with byte order set to {@link ByteOrder#nativeOrder()}.
      * 

      * This is equivalent to the following code:
      * 
{@code
@@ -1325,7 +709,7 @@ public static void setFloat(MemorySegment segment, float value) {
     }
 
     /**
-     * Read a long from given segment, with byte order set to {@link ByteOrder#nativeOrder()}.
+     * Reads a long from given segment, with byte order set to {@link ByteOrder#nativeOrder()}.
      * 

      * This is equivalent to the following code:
      * 
{@code
@@ -1353,7 +737,7 @@ public static void setLong(MemorySegment segment, long value) {
     }
 
     /**
-     * Read a double from given segment, with byte order set to {@link ByteOrder#nativeOrder()}.
+     * Reads a double from given segment, with byte order set to {@link ByteOrder#nativeOrder()}.
      * 

      * This is equivalent to the following code:
      * 
{@code
@@ -1381,7 +765,7 @@ public static void setDouble(MemorySegment segment, double value) {
     }
 
     /**
-     * Read a memory address from given segment, with byte order set to {@link ByteOrder#nativeOrder()}.
+     * Reads a memory address from given segment, with byte order set to {@link ByteOrder#nativeOrder()}.
      * 

      * This is equivalent to the following code:
      * 
{@code
@@ -1409,666 +793,680 @@ public static void setAddress(MemorySegment segment, Addressable value) {
     }
 
     /**
-     * Read a byte from given segment and element index, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}.
+     * Reads a byte from given segment, with given byte order.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    byte value = getByteAtOffset_LE(segment, index);
+    byte value = getByteAtOffset(segment, 0L, order);
      * }

      *
      * @param segment the segment to be dereferenced.
-     * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index)}.
-     * @return a byte value read from {@code segment} at the element index specified by {@code index}.
+     * @param order the specified byte order.
+     * @return a byte value read from {@code segment}.
      */
-    public static byte getByteAtIndex_LE(MemorySegment segment, long index) {
-        return getByteAtOffset_LE(segment, index);
+    public static byte getByte(MemorySegment segment, ByteOrder order) {
+        return getByteAtOffset(segment, 0L, order);
     }
 
     /**
-     * Writes a byte at given segment and element index, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}.
+     * Writes a byte at given segment, with given byte order.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    setByteAtOffset_LE(segment, index, value);
+    setByteAtOffset(segment, 0L, order, value);
      * }

      * @param segment the segment to be dereferenced.
-     * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index)}.
+     * @param order the specified byte order.
      * @param value the byte value to be written.
      */
-    public static void setByteAtIndex_LE(MemorySegment segment, long index, byte value) {
-        setByteAtOffset_LE(segment, index, value);
+    public static void setByte(MemorySegment segment, ByteOrder order, byte value) {
+        setByteAtOffset(segment, 0L, order, value);
     }
 
     /**
-     * Read a char from given segment and element index, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}.
+     * Reads a char from given segment, with given byte order.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    char value = getCharAtOffset_LE(segment, 2 * index);
+    char value = getCharAtOffset(segment, 0L, order);
      * }

      * @param segment the segment to be dereferenced.
-     * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 2)}.
-     * @return a char value read from {@code segment} at the element index specified by {@code index}.
+     * @param order the specified byte order.
+     * @return a char value read from {@code segment}.
      */
-    public static char getCharAtIndex_LE(MemorySegment segment, long index) {
-        return getCharAtOffset_LE(segment, scale(segment, index, 2));
+    public static char getChar(MemorySegment segment, ByteOrder order) {
+        return getCharAtOffset(segment, 0L, order);
     }
 
     /**
-     * Writes a char at given segment and element index, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}.
+     * Writes a char at given segment, with given byte order.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    setCharAtOffset_LE(segment, 2 * index, value);
+    setCharAtOffset(segment, 0L, order, value);
      * }

      * @param segment the segment to be dereferenced.
-     * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 2)}.
+     * @param order the specified byte order.
      * @param value the char value to be written.
      */
-    public static void setCharAtIndex_LE(MemorySegment segment, long index, char value) {
-        setCharAtOffset_LE(segment, scale(segment, index, 2), value);
+    public static void setChar(MemorySegment segment, ByteOrder order, char value) {
+        setCharAtOffset(segment, 0L, order, value);
     }
 
     /**
-     * Read a short from given segment and element index, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}.
+     * Reads a short from given segment, with given byte order.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    short value = getShortAtOffset_LE(segment, 2 * index);
+    short value = getShortAtOffset(segment, 0L, order);
      * }

      * @param segment the segment to be dereferenced.
-     * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 2)}.
-     * @return a short value read from {@code segment} at the element index specified by {@code index}.
+     * @param order the specified byte order.
+     * @return a short value read from {@code segment}.
      */
-    public static short getShortAtIndex_LE(MemorySegment segment, long index) {
-        return getShortAtOffset_LE(segment, scale(segment, index, 2));
+    public static short getShort(MemorySegment segment, ByteOrder order) {
+        return getShortAtOffset(segment, 0L, order);
     }
 
     /**
-     * Writes a short at given segment and element index, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}.
+     * Writes a short at given segment, with given byte order.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    setShortAtOffset_LE(segment, 2 * index, value);
+    setShortAtOffset(segment, 0L, order, value);
      * }

      * @param segment the segment to be dereferenced.
-     * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 2)}.
+     * @param order the specified byte order.
      * @param value the short value to be written.
      */
-    public static void setShortAtIndex_LE(MemorySegment segment, long index, short value) {
-        setShortAtOffset_LE(segment, scale(segment, index, 2), value);
+    public static void setShort(MemorySegment segment, ByteOrder order, short value) {
+        setShortAtOffset(segment, 0L, order, value);
     }
 
     /**
-     * Read an int from given segment and element index, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}.
+     * Reads an int from given segment, with given byte order.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    int value = getIntAtOffset_LE(segment, 4 * index);
+    int value = getIntAtOffset(segment, 0L, order);
      * }

      * @param segment the segment to be dereferenced.
-     * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 4)}.
-     * @return an int value read from {@code segment} at the element index specified by {@code index}.
+     * @param order the specified byte order.
+     * @return an int value read from {@code segment}.
      */
-    public static int getIntAtIndex_LE(MemorySegment segment, long index) {
-        return getIntAtOffset_LE(segment, scale(segment, index, 4));
+    public static int getInt(MemorySegment segment, ByteOrder order) {
+        return getIntAtOffset(segment, 0L, order);
     }
 
     /**
-     * Writes an int at given segment and element index, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}.
+     * Writes an int at given segment, with given byte order.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    setIntAtOffset_LE(segment, 4 * index, value);
+    setIntAtOffset(segment, 0L, order, value);
      * }

      * @param segment the segment to be dereferenced.
-     * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 4)}.
+     * @param order the specified byte order.
      * @param value the int value to be written.
      */
-    public static void setIntAtIndex_LE(MemorySegment segment, long index, int value) {
-        setIntAtOffset_LE(segment, scale(segment, index, 4), value);
+    public static void setInt(MemorySegment segment, ByteOrder order, int value) {
+        setIntAtOffset(segment, 0L, order, value);
     }
 
     /**
-     * Read a float from given segment and element index, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}.
+     * Reads a float from given segment, with given byte order.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    float value = getFloatAtOffset_LE(segment, 4 * index);
+    float value = getFloatAtOffset(segment, 0L, order);
      * }

      * @param segment the segment to be dereferenced.
-     * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 4)}.
-     * @return a float value read from {@code segment} at the element index specified by {@code index}.
+     * @param order the specified byte order.
+     * @return a float value read from {@code segment}.
      */
-    public static float getFloatAtIndex_LE(MemorySegment segment, long index) {
-        return getFloatAtOffset_LE(segment, scale(segment, index, 4));
+    public static float getFloat(MemorySegment segment, ByteOrder order) {
+        return getFloatAtOffset(segment, 0L, order);
     }
 
     /**
-     * Writes a float at given segment and element index, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}.
+     * Writes a float at given segment, with given byte order.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    setFloatAtOffset_LE(segment, 4 * index, value);
+    setFloatAtOffset(segment, 0L, order, value);
      * }

      * @param segment the segment to be dereferenced.
-     * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 4)}.
+     * @param order the specified byte order.
      * @param value the float value to be written.
      */
-    public static void setFloatAtIndex_LE(MemorySegment segment, long index, float value) {
-        setFloatAtOffset_LE(segment, scale(segment, index, 4), value);
+    public static void setFloat(MemorySegment segment, ByteOrder order, float value) {
+        setFloatAtOffset(segment, 0L, order, value);
     }
 
     /**
-     * Read a long from given segment and element index, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}.
+     * Reads a long from given segment, with given byte order.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    return getLongAtOffset_LE(segment, 8 * index);
+    long value = getLongAtOffset(segment, 0L, order);
      * }

      * @param segment the segment to be dereferenced.
-     * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 8)}.
-     * @return a long value read from {@code segment} at the element index specified by {@code index}.
+     * @param order the specified byte order.
+     * @return a long value read from {@code segment}.
      */
-    public static long getLongAtIndex_LE(MemorySegment segment, long index) {
-        return getLongAtOffset_LE(segment, scale(segment, index, 8));
+    public static long getLong(MemorySegment segment, ByteOrder order) {
+        return getLongAtOffset(segment, 0L, order);
     }
 
     /**
-     * Writes a long at given segment and element index, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}.
+     * Writes a long at given segment, with given byte order.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    setLongAtOffset_LE(segment, 8 * index, value);
+    setLongAtOffset(segment, 0L, order, value);
      * }

      * @param segment the segment to be dereferenced.
-     * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 8)}.
+     * @param order the specified byte order.
      * @param value the long value to be written.
      */
-    public static void setLongAtIndex_LE(MemorySegment segment, long index, long value) {
-        setLongAtOffset_LE(segment, scale(segment, index, 8), value);
+    public static void setLong(MemorySegment segment, ByteOrder order, long value) {
+        setLongAtOffset(segment, 0L, order, value);
     }
 
     /**
-     * Read a double from given segment and element index, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}.
+     * Reads a double from given segment, with given byte order.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    return getDoubleAtOffset_LE(segment, 8 * index);
+    double value = getDoubleAtOffset(segment, 0L, order);
      * }

      * @param segment the segment to be dereferenced.
-     * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 8)}.
-     * @return a double value read from {@code segment} at the element index specified by {@code index}.
+     * @param order the specified byte order.
+     * @return a double value read from {@code segment}.
      */
-    public static double getDoubleAtIndex_LE(MemorySegment segment, long index) {
-        return getDoubleAtOffset_LE(segment, scale(segment, index, 8));
+    public static double getDouble(MemorySegment segment, ByteOrder order) {
+        return getDoubleAtOffset(segment, 0L, order);
     }
 
     /**
-     * Writes a double at given segment and element index, with byte order set to {@link ByteOrder#LITTLE_ENDIAN}.
+     * Writes a double at given segment, with given byte order.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    setDoubleAtOffset_LE(segment, 8 * index, value);
+    setDoubleAtOffset(segment, 0L, order, value);
      * }

      * @param segment the segment to be dereferenced.
-     * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 8)}.
+     * @param order the specified byte order.
      * @param value the double value to be written.
      */
-    public static void setDoubleAtIndex_LE(MemorySegment segment, long index, double value) {
-        setDoubleAtOffset_LE(segment, scale(segment, index, 8), value);
+    public static void setDouble(MemorySegment segment, ByteOrder order, double value) {
+        setDoubleAtOffset(segment, 0L, order, value);
     }
 
     /**
-     * Read a byte from given segment and element index, with byte order set to {@link ByteOrder#BIG_ENDIAN}.
+     * Reads a byte from given segment and element index, with byte order set to {@link ByteOrder#nativeOrder()}.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    byte value = getByteAtOffset_BE(segment, index);
+    byte value = getByteAtOffset(segment, index);
      * }

      *
      * @param segment the segment to be dereferenced.
      * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index)}.
      * @return a byte value read from {@code segment} at the element index specified by {@code index}.
      */
-    public static byte getByteAtIndex_BE(MemorySegment segment, long index) {
-        return getByteAtOffset_BE(segment, index);
+    public static byte getByteAtIndex(MemorySegment segment, long index) {
+        return getByteAtOffset(segment, index);
     }
 
     /**
-     * Writes a byte at given segment and element index, with byte order set to {@link ByteOrder#BIG_ENDIAN}.
+     * Writes a byte at given segment and element index, with byte order set to {@link ByteOrder#nativeOrder()}.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    setByteAtOffset_BE(segment, index, value);
+    setByteAtOffset(segment, index, value);
      * }

      * @param segment the segment to be dereferenced.
      * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index)}.
      * @param value the byte value to be written.
      */
-    public static void setByteAtIndex_BE(MemorySegment segment, long index, byte value) {
-        setByteAtOffset_BE(segment, index, value);
+    public static void setByteAtIndex(MemorySegment segment, long index, byte value) {
+        setByteAtOffset(segment, index, value);
     }
 
     /**
-     * Read a char from given segment and element index, with byte order set to {@link ByteOrder#BIG_ENDIAN}.
+     * Reads a char from given segment and element index, with byte order set to {@link ByteOrder#nativeOrder()}.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    char value = getCharAtOffset_BE(segment, 2 * index);
+    char value = getCharAtOffset(segment, 2 * index);
      * }

      * @param segment the segment to be dereferenced.
      * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 2)}.
      * @return a char value read from {@code segment} at the element index specified by {@code index}.
      */
-    public static char getCharAtIndex_BE(MemorySegment segment, long index) {
-        return getCharAtOffset_BE(segment, scale(segment, index, 2));
+    public static char getCharAtIndex(MemorySegment segment, long index) {
+        return getCharAtOffset(segment, scale(segment, index, 2));
     }
 
     /**
-     * Writes a char at given segment and element index, with byte order set to {@link ByteOrder#BIG_ENDIAN}.
+     * Writes a char at given segment and element index, with byte order set to {@link ByteOrder#nativeOrder()}.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    setCharAtOffset_BE(segment, 2 * index, value);
+    setCharAtOffset(segment, 2 * index, value);
      * }

      * @param segment the segment to be dereferenced.
      * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 2)}.
      * @param value the char value to be written.
      */
-    public static void setCharAtIndex_BE(MemorySegment segment, long index, char value) {
-        setCharAtOffset_BE(segment, scale(segment, index, 2), value);
+    public static void setCharAtIndex(MemorySegment segment, long index, char value) {
+        setCharAtOffset(segment, scale(segment, index, 2), value);
     }
 
     /**
-     * Read a short from given segment and element index, with byte order set to {@link ByteOrder#BIG_ENDIAN}.
+     * Reads a short from given segment and element index, with byte order set to {@link ByteOrder#nativeOrder()}.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    short value = getShortAtOffset_BE(segment, 2 * index);
+    short value = getShortAtOffset(segment, 2 * index);
      * }

      * @param segment the segment to be dereferenced.
      * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 2)}.
      * @return a short value read from {@code segment} at the element index specified by {@code index}.
      */
-    public static short getShortAtIndex_BE(MemorySegment segment, long index) {
-        return getShortAtOffset_BE(segment, scale(segment, index, 2));
+    public static short getShortAtIndex(MemorySegment segment, long index) {
+        return getShortAtOffset(segment, scale(segment, index, 2));
     }
 
     /**
-     * Writes a short at given segment and element index, with byte order set to {@link ByteOrder#BIG_ENDIAN}.
+     * Writes a short at given segment and element index, with byte order set to {@link ByteOrder#nativeOrder()}.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    setShortAtOffset_BE(segment, 2 * index, value);
+    setShortAtOffset(segment, 2 * index, value);
      * }

      * @param segment the segment to be dereferenced.
      * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 2)}.
      * @param value the short value to be written.
      */
-    public static void setShortAtIndex_BE(MemorySegment segment, long index, short value) {
-        setShortAtOffset_BE(segment, scale(segment, index, 2), value);
+    public static void setShortAtIndex(MemorySegment segment, long index, short value) {
+        setShortAtOffset(segment, scale(segment, index, 2), value);
     }
 
     /**
-     * Read an int from given segment and element index, with byte order set to {@link ByteOrder#BIG_ENDIAN}.
+     * Reads an int from given segment and element index, with byte order set to {@link ByteOrder#nativeOrder()}.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    int value = getIntAtOffset_BE(segment, 4 * index);
+    int value = getIntAtOffset(segment, 4 * index);
      * }

      * @param segment the segment to be dereferenced.
      * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 4)}.
      * @return an int value read from {@code segment} at the element index specified by {@code index}.
      */
-    public static int getIntAtIndex_BE(MemorySegment segment, long index) {
-        return getIntAtOffset_BE(segment, scale(segment, index, 4));
+    public static int getIntAtIndex(MemorySegment segment, long index) {
+        return getIntAtOffset(segment, scale(segment, index, 4));
     }
 
     /**
-     * Writes an int at given segment and element index, with byte order set to {@link ByteOrder#BIG_ENDIAN}.
+     * Writes an int at given segment and element index, with byte order set to {@link ByteOrder#nativeOrder()}.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    setIntAtOffset_BE(segment, 4 * index, value);
+    setIntAtOffset(segment, 4 * index, value);
      * }

      * @param segment the segment to be dereferenced.
      * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 4)}.
      * @param value the int value to be written.
      */
-    public static void setIntAtIndex_BE(MemorySegment segment, long index, int value) {
-        setIntAtOffset_BE(segment, scale(segment, index, 4), value);
+    public static void setIntAtIndex(MemorySegment segment, long index, int value) {
+        setIntAtOffset(segment, scale(segment, index, 4), value);
     }
 
     /**
-     * Read a float from given segment and element index, with byte order set to {@link ByteOrder#BIG_ENDIAN}.
+     * Reads a float from given segment and element index, with byte order set to {@link ByteOrder#nativeOrder()}.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    float value = getFloatAtOffset_BE(segment, 4 * index);
+    float value = getFloatAtOffset(segment, 4 * index);
      * }

      * @param segment the segment to be dereferenced.
      * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 4)}.
      * @return a float value read from {@code segment} at the element index specified by {@code index}.
      */
-    public static float getFloatAtIndex_BE(MemorySegment segment, long index) {
-        return getFloatAtOffset_BE(segment, scale(segment, index, 4));
+    public static float getFloatAtIndex(MemorySegment segment, long index) {
+        return getFloatAtOffset(segment, scale(segment, index, 4));
     }
 
     /**
-     * Writes a float at given segment and element index, with byte order set to {@link ByteOrder#BIG_ENDIAN}.
+     * Writes a float at given segment and element index, with byte order set to {@link ByteOrder#nativeOrder()}.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    setFloatAtOffset_BE(segment, 4 * index, value);
+    setFloatAtOffset(segment, 4 * index, value);
      * }

      * @param segment the segment to be dereferenced.
      * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 4)}.
      * @param value the float value to be written.
      */
-    public static void setFloatAtIndex_BE(MemorySegment segment, long index, float value) {
-        setFloatAtOffset_BE(segment, scale(segment, index, 4), value);
+    public static void setFloatAtIndex(MemorySegment segment, long index, float value) {
+        setFloatAtOffset(segment, scale(segment, index, 4), value);
     }
 
     /**
-     * Read a long from given segment and element index, with byte order set to {@link ByteOrder#BIG_ENDIAN}.
+     * Reads a long from given segment and element index, with byte order set to {@link ByteOrder#nativeOrder()}.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    return getLongAtOffset_BE(segment, 8 * index);
+    return getLongAtOffset(segment, 8 * index);
      * }

      * @param segment the segment to be dereferenced.
      * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 8)}.
      * @return a long value read from {@code segment} at the element index specified by {@code index}.
      */
-    public static long getLongAtIndex_BE(MemorySegment segment, long index) {
-        return getLongAtOffset_BE(segment, scale(segment, index, 8));
+    public static long getLongAtIndex(MemorySegment segment, long index) {
+        return getLongAtOffset(segment, scale(segment, index, 8));
     }
 
     /**
-     * Writes a long at given segment and element index, with byte order set to {@link ByteOrder#BIG_ENDIAN}.
+     * Writes a long at given segment and element index, with byte order set to {@link ByteOrder#nativeOrder()}.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    setLongAtOffset_BE(segment, 8 * index, value);
+    setLongAtOffset(segment, 8 * index, value);
      * }

      * @param segment the segment to be dereferenced.
      * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 8)}.
      * @param value the long value to be written.
      */
-    public static void setLongAtIndex_BE(MemorySegment segment, long index, long value) {
-        setLongAtOffset_BE(segment, scale(segment, index, 8), value);
+    public static void setLongAtIndex(MemorySegment segment, long index, long value) {
+        setLongAtOffset(segment, scale(segment, index, 8), value);
     }
 
     /**
-     * Read a double from given segment and element index, with byte order set to {@link ByteOrder#BIG_ENDIAN}.
+     * Reads a double from given segment and element index, with byte order set to {@link ByteOrder#nativeOrder()}.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    return getDoubleAtOffset_BE(segment, 8 * index);
+    return getDoubleAtOffset(segment, 8 * index);
      * }

      * @param segment the segment to be dereferenced.
      * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 8)}.
      * @return a double value read from {@code segment} at the element index specified by {@code index}.
      */
-    public static double getDoubleAtIndex_BE(MemorySegment segment, long index) {
-        return getDoubleAtOffset_BE(segment, scale(segment, index, 8));
+    public static double getDoubleAtIndex(MemorySegment segment, long index) {
+        return getDoubleAtOffset(segment, scale(segment, index, 8));
+    }
+
+    /**
+     * Reads a memory address from given segment and element index, with byte order set to {@link ByteOrder#nativeOrder()}.
+     * 

+     * This is equivalent to the following code:
+     * 
{@code
+    return getAddressAtOffset(segment, index * MemoryLayouts.ADDRESS.byteSize());
+     * }

+     * @param segment the segment to be dereferenced.
+     * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 8)}.
+     * @return a memory address read from {@code segment} at the element index specified by {@code index}.
+     */
+    public static MemoryAddress getAddressAtIndex(MemorySegment segment, long index) {
+        return getAddressAtOffset(segment, scale(segment, index, (int)MemoryLayouts.ADDRESS.byteSize()));
+    }
+
+    /**
+     * Writes a memory address at given segment and element index, with byte order set to {@link ByteOrder#nativeOrder()}.
+     * 

+     * This is equivalent to the following code:
+     * 
{@code
+    setAddressAtOffset(segment, index * MemoryLayouts.ADDRESS.byteSize(), value);
+     * }

+     * @param segment the segment to be dereferenced.
+     * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 8)}.
+     * @param value the memory address to be written (expressed as an {@link Addressable} instance).
+     */
+    public static void setAddressAtIndex(MemorySegment segment, long index, Addressable value) {
+        setAddressAtOffset(segment, scale(segment, index, (int)MemoryLayouts.ADDRESS.byteSize()), value);
     }
 
     /**
-     * Writes a double at given segment and element index, with byte order set to {@link ByteOrder#BIG_ENDIAN}.
+     * Writes a double at given segment and element index, with byte order set to {@link ByteOrder#nativeOrder()}.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    setDoubleAtOffset_BE(segment, 8 * index, value);
+    setDoubleAtOffset(segment, 8 * index, value);
      * }

      * @param segment the segment to be dereferenced.
      * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 8)}.
      * @param value the double value to be written.
      */
-    public static void setDoubleAtIndex_BE(MemorySegment segment, long index, double value) {
-        setDoubleAtOffset_BE(segment, scale(segment, index, 8), value);
+    public static void setDoubleAtIndex(MemorySegment segment, long index, double value) {
+        setDoubleAtOffset(segment, scale(segment, index, 8), value);
     }
 
     /**
-     * Read a byte from given segment and element index, with byte order set to {@link ByteOrder#nativeOrder()}.
+     * Reads a byte from given segment and element index, with given byte order.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    byte value = getByteAtOffset(segment, index);
+    byte value = getByteAtOffset(segment, index, order);
      * }

      *
      * @param segment the segment to be dereferenced.
      * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index)}.
+     * @param order the specified byte order.
      * @return a byte value read from {@code segment} at the element index specified by {@code index}.
      */
-    public static byte getByteAtIndex(MemorySegment segment, long index) {
-        return getByteAtOffset(segment, index);
+    public static byte getByteAtIndex(MemorySegment segment, long index, ByteOrder order) {
+        return getByteAtOffset(segment, index, order);
     }
 
     /**
-     * Writes a byte at given segment and element index, with byte order set to {@link ByteOrder#nativeOrder()}.
+     * Writes a byte at given segment and element index, with given byte order.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    setByteAtOffset(segment, index, value);
+    setByteAtOffset(segment, index, order, value);
      * }

      * @param segment the segment to be dereferenced.
      * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index)}.
+     * @param order the specified byte order.
      * @param value the byte value to be written.
      */
-    public static void setByteAtIndex(MemorySegment segment, long index, byte value) {
-        setByteAtOffset(segment, index, value);
+    public static void setByteAtIndex(MemorySegment segment, long index, ByteOrder order, byte value) {
+        setByteAtOffset(segment, index, order, value);
     }
 
     /**
-     * Read a char from given segment and element index, with byte order set to {@link ByteOrder#nativeOrder()}.
+     * Reads a char from given segment and element index, with given byte order.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    char value = getCharAtOffset(segment, 2 * index);
+    char value = getCharAtOffset(segment, 2 * index, order);
      * }

      * @param segment the segment to be dereferenced.
      * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 2)}.
+     * @param order the specified byte order.
      * @return a char value read from {@code segment} at the element index specified by {@code index}.
      */
-    public static char getCharAtIndex(MemorySegment segment, long index) {
-        return getCharAtOffset(segment, scale(segment, index, 2));
+    public static char getCharAtIndex(MemorySegment segment, long index, ByteOrder order) {
+        return getCharAtOffset(segment, scale(segment, index, 2), order);
     }
 
     /**
-     * Writes a char at given segment and element index, with byte order set to {@link ByteOrder#nativeOrder()}.
+     * Writes a char at given segment and element index, with given byte order.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    setCharAtOffset(segment, 2 * index, value);
+    setCharAtOffset(segment, 2 * index, order, value);
      * }

      * @param segment the segment to be dereferenced.
      * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 2)}.
+     * @param order the specified byte order.
      * @param value the char value to be written.
      */
-    public static void setCharAtIndex(MemorySegment segment, long index, char value) {
-        setCharAtOffset(segment, scale(segment, index, 2), value);
+    public static void setCharAtIndex(MemorySegment segment, long index, ByteOrder order, char value) {
+        setCharAtOffset(segment, scale(segment, index, 2), order, value);
     }
 
     /**
-     * Read a short from given segment and element index, with byte order set to {@link ByteOrder#nativeOrder()}.
+     * Reads a short from given segment and element index, with given byte order.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    short value = getShortAtOffset(segment, 2 * index);
+    short value = getShortAtOffset(segment, 2 * index, order);
      * }

      * @param segment the segment to be dereferenced.
      * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 2)}.
+     * @param order the specified byte order.
      * @return a short value read from {@code segment} at the element index specified by {@code index}.
      */
-    public static short getShortAtIndex(MemorySegment segment, long index) {
-        return getShortAtOffset(segment, scale(segment, index, 2));
+    public static short getShortAtIndex(MemorySegment segment, long index, ByteOrder order) {
+        return getShortAtOffset(segment, scale(segment, index, 2), order);
     }
 
     /**
-     * Writes a short at given segment and element index, with byte order set to {@link ByteOrder#nativeOrder()}.
+     * Writes a short at given segment and element index, with given byte order.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    setShortAtOffset(segment, 2 * index, value);
+    setShortAtOffset(segment, 2 * index, order, value);
      * }

      * @param segment the segment to be dereferenced.
      * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 2)}.
+     * @param order the specified byte order.
      * @param value the short value to be written.
      */
-    public static void setShortAtIndex(MemorySegment segment, long index, short value) {
-        setShortAtOffset(segment, scale(segment, index, 2), value);
+    public static void setShortAtIndex(MemorySegment segment, long index, ByteOrder order, short value) {
+        setShortAtOffset(segment, scale(segment, index, 2), order, value);
     }
 
     /**
-     * Read an int from given segment and element index, with byte order set to {@link ByteOrder#nativeOrder()}.
+     * Reads an int from given segment and element index, with given byte order.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    int value = getIntAtOffset(segment, 4 * index);
+    int value = getIntAtOffset(segment, 4 * index, order);
      * }

      * @param segment the segment to be dereferenced.
      * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 4)}.
+     * @param order the specified byte order.
      * @return an int value read from {@code segment} at the element index specified by {@code index}.
      */
-    public static int getIntAtIndex(MemorySegment segment, long index) {
-        return getIntAtOffset(segment, scale(segment, index, 4));
+    public static int getIntAtIndex(MemorySegment segment, long index, ByteOrder order) {
+        return getIntAtOffset(segment, scale(segment, index, 4), order);
     }
 
     /**
-     * Writes an int at given segment and element index, with byte order set to {@link ByteOrder#nativeOrder()}.
+     * Writes an int at given segment and element index, with given byte order.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    setIntAtOffset(segment, 4 * index, value);
+    setIntAtOffset(segment, 4 * index, order, value);
      * }

      * @param segment the segment to be dereferenced.
      * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 4)}.
+     * @param order the specified byte order.
      * @param value the int value to be written.
      */
-    public static void setIntAtIndex(MemorySegment segment, long index, int value) {
-        setIntAtOffset(segment, scale(segment, index, 4), value);
+    public static void setIntAtIndex(MemorySegment segment, long index, ByteOrder order, int value) {
+        setIntAtOffset(segment, scale(segment, index, 4), order, value);
     }
 
     /**
-     * Read a float from given segment and element index, with byte order set to {@link ByteOrder#nativeOrder()}.
+     * Reads a float from given segment and element index, with given byte order.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    float value = getFloatAtOffset(segment, 4 * index);
+    float value = getFloatAtOffset(segment, 4 * index, order);
      * }

      * @param segment the segment to be dereferenced.
      * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 4)}.
+     * @param order the specified byte order.
      * @return a float value read from {@code segment} at the element index specified by {@code index}.
      */
-    public static float getFloatAtIndex(MemorySegment segment, long index) {
-        return getFloatAtOffset(segment, scale(segment, index, 4));
+    public static float getFloatAtIndex(MemorySegment segment, long index, ByteOrder order) {
+        return getFloatAtOffset(segment, scale(segment, index, 4), order);
     }
 
     /**
-     * Writes a float at given segment and element index, with byte order set to {@link ByteOrder#nativeOrder()}.
+     * Writes a float at given segment and element index, with given byte order.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    setFloatAtOffset(segment, 4 * index, value);
+    setFloatAtOffset(segment, 4 * index, order, value);
      * }

      * @param segment the segment to be dereferenced.
      * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 4)}.
+     * @param order the specified byte order.
      * @param value the float value to be written.
      */
-    public static void setFloatAtIndex(MemorySegment segment, long index, float value) {
-        setFloatAtOffset(segment, scale(segment, index, 4), value);
+    public static void setFloatAtIndex(MemorySegment segment, long index, ByteOrder order, float value) {
+        setFloatAtOffset(segment, scale(segment, index, 4), order, value);
     }
 
     /**
-     * Read a long from given segment and element index, with byte order set to {@link ByteOrder#nativeOrder()}.
+     * Reads a long from given segment and element index, with given byte order.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    return getLongAtOffset(segment, 8 * index);
+    return getLongAtOffset(segment, 8 * index, order);
      * }

      * @param segment the segment to be dereferenced.
      * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 8)}.
+     * @param order the specified byte order.
      * @return a long value read from {@code segment} at the element index specified by {@code index}.
      */
-    public static long getLongAtIndex(MemorySegment segment, long index) {
-        return getLongAtOffset(segment, scale(segment, index, 8));
+    public static long getLongAtIndex(MemorySegment segment, long index, ByteOrder order) {
+        return getLongAtOffset(segment, scale(segment, index, 8), order);
     }
 
     /**
-     * Writes a long at given segment and element index, with byte order set to {@link ByteOrder#nativeOrder()}.
+     * Writes a long at given segment and element index, with given byte order.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    setLongAtOffset(segment, 8 * index, value);
+    setLongAtOffset(segment, 8 * index, order, value);
      * }

      * @param segment the segment to be dereferenced.
      * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 8)}.
+     * @param order the specified byte order.
      * @param value the long value to be written.
      */
-    public static void setLongAtIndex(MemorySegment segment, long index, long value) {
-        setLongAtOffset(segment, scale(segment, index, 8), value);
+    public static void setLongAtIndex(MemorySegment segment, long index, ByteOrder order, long value) {
+        setLongAtOffset(segment, scale(segment, index, 8), order, value);
     }
 
     /**
-     * Read a double from given segment and element index, with byte order set to {@link ByteOrder#nativeOrder()}.
+     * Reads a double from given segment and element index, with given byte order.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    return getDoubleAtOffset(segment, 8 * index);
+    return getDoubleAtOffset(segment, 8 * index, order);
      * }

      * @param segment the segment to be dereferenced.
      * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 8)}.
+     * @param order the specified byte order.
      * @return a double value read from {@code segment} at the element index specified by {@code index}.
      */
-    public static double getDoubleAtIndex(MemorySegment segment, long index) {
-        return getDoubleAtOffset(segment, scale(segment, index, 8));
+    public static double getDoubleAtIndex(MemorySegment segment, long index, ByteOrder order) {
+        return getDoubleAtOffset(segment, scale(segment, index, 8), order);
     }
 
     /**
-     * Writes a double at given segment and element index, with byte order set to {@link ByteOrder#nativeOrder()}.
+     * Writes a double at given segment and element index, with given byte order.
      * 

      * This is equivalent to the following code:
      * 
{@code
-    setDoubleAtOffset(segment, 8 * index, value);
+    setDoubleAtOffset(segment, 8 * index, order, value);
      * }

      * @param segment the segment to be dereferenced.
      * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 8)}.
+     * @param order the specified byte order.
      * @param value the double value to be written.
      */
-    public static void setDoubleAtIndex(MemorySegment segment, long index, double value) {
-        setDoubleAtOffset(segment, scale(segment, index, 8), value);
-    }
-
-    /**
-     * Read a memory address from given segment and element index, with byte order set to {@link ByteOrder#nativeOrder()}.
-     * 

-     * This is equivalent to the following code:
-     * 
{@code
-    return getAddressAtOffset(segment, index * 8);
-     * }

-     * @param segment the segment to be dereferenced.
-     * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 8)}.
-     * @return a memory address read from {@code segment} at the element index specified by {@code index}.
-     */
-    public static MemoryAddress getAddressAtIndex(MemorySegment segment, long index) {
-        return getAddressAtOffset(segment, scale(segment, index, 8));
-    }
-
-    /**
-     * Writes a memory address at given segment and element index, with byte order set to {@link ByteOrder#nativeOrder()}.
-     * 

-     * This is equivalent to the following code:
-     * 
{@code
-    setAddressAtOffset(segment, index * 8, value);
-     * }

-     * @param segment the segment to be dereferenced.
-     * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index * 8)}.
-     * @param value the memory address to be written (expressed as an {@link Addressable} instance).
-     */
-    public static void setAddressAtIndex(MemorySegment segment, long index, Addressable value) {
-        setAddressAtOffset(segment, scale(segment, index, 8), value);
+    public static void setDoubleAtIndex(MemorySegment segment, long index, ByteOrder order, double value) {
+        setDoubleAtOffset(segment, scale(segment, index, 8), order, value);
     }
 
     @ForceInline
diff --git a/test/jdk/java/foreign/TestByteBuffer.java b/test/jdk/java/foreign/TestByteBuffer.java
index 956858ecca0f6..2c5dd5c4f9630 100644
--- a/test/jdk/java/foreign/TestByteBuffer.java
+++ b/test/jdk/java/foreign/TestByteBuffer.java
@@ -606,34 +606,34 @@ static Map varHandleMembers(ByteBuffer bb, VarHandle han
     @DataProvider(name = "resizeOps")
     public Object[][] resizeOps() {
         Consumer byteInitializer =
-                (base) -> initBytes(base, bytes, (addr, pos) -> MemoryAccess.setByteAtIndex_BE(addr, pos, (byte)(long)pos));
+                (base) -> initBytes(base, bytes, (addr, pos) -> MemoryAccess.setByteAtIndex(addr, pos, ByteOrder.BIG_ENDIAN, (byte)(long)pos));
         Consumer charInitializer =
-                (base) -> initBytes(base, chars, (addr, pos) -> MemoryAccess.setCharAtIndex_BE(addr, pos, (char)(long)pos));
+                (base) -> initBytes(base, chars, (addr, pos) -> MemoryAccess.setCharAtIndex(addr, pos, ByteOrder.BIG_ENDIAN, (char)(long)pos));
         Consumer shortInitializer =
-                (base) -> initBytes(base, shorts, (addr, pos) -> MemoryAccess.setShortAtIndex_BE(addr, pos, (short)(long)pos));
+                (base) -> initBytes(base, shorts, (addr, pos) -> MemoryAccess.setShortAtIndex(addr, pos, ByteOrder.BIG_ENDIAN, (short)(long)pos));
         Consumer intInitializer =
-                (base) -> initBytes(base, ints, (addr, pos) -> MemoryAccess.setIntAtIndex_BE(addr, pos, (int)(long)pos));
+                (base) -> initBytes(base, ints, (addr, pos) -> MemoryAccess.setIntAtIndex(addr, pos, ByteOrder.BIG_ENDIAN, (int)(long)pos));
         Consumer floatInitializer =
-                (base) -> initBytes(base, floats, (addr, pos) -> MemoryAccess.setFloatAtIndex_BE(addr, pos, (float)(long)pos));
+                (base) -> initBytes(base, floats, (addr, pos) -> MemoryAccess.setFloatAtIndex(addr, pos, ByteOrder.BIG_ENDIAN, (float)(long)pos));
         Consumer longInitializer =
-                (base) -> initBytes(base, longs, (addr, pos) -> MemoryAccess.setLongAtIndex_BE(addr, pos, (long)pos));
+                (base) -> initBytes(base, longs, (addr, pos) -> MemoryAccess.setLongAtIndex(addr, pos, ByteOrder.BIG_ENDIAN, (long)pos));
         Consumer doubleInitializer =
-                (base) -> initBytes(base, doubles, (addr, pos) -> MemoryAccess.setDoubleAtIndex_BE(addr, pos, (double)(long)pos));
+                (base) -> initBytes(base, doubles, (addr, pos) -> MemoryAccess.setDoubleAtIndex(addr, pos, ByteOrder.BIG_ENDIAN, (double)(long)pos));
 
         Consumer byteChecker =
-                (base) -> checkBytes(base, bytes, Function.identity(), MemoryAccess::getByteAtIndex_BE, ByteBuffer::get);
+                (base) -> checkBytes(base, bytes, Function.identity(), (addr, pos) -> MemoryAccess.getByteAtIndex(addr, pos, ByteOrder.BIG_ENDIAN), ByteBuffer::get);
         Consumer charChecker =
-                (base) -> checkBytes(base, chars, ByteBuffer::asCharBuffer, MemoryAccess::getCharAtIndex_BE, CharBuffer::get);
+                (base) -> checkBytes(base, chars, ByteBuffer::asCharBuffer, (addr, pos) -> MemoryAccess.getCharAtIndex(addr, pos, ByteOrder.BIG_ENDIAN), CharBuffer::get);
         Consumer shortChecker =
-                (base) -> checkBytes(base, shorts, ByteBuffer::asShortBuffer, MemoryAccess::getShortAtIndex_BE, ShortBuffer::get);
+                (base) -> checkBytes(base, shorts, ByteBuffer::asShortBuffer, (addr, pos) -> MemoryAccess.getShortAtIndex(addr, pos, ByteOrder.BIG_ENDIAN), ShortBuffer::get);
         Consumer intChecker =
-                (base) -> checkBytes(base, ints, ByteBuffer::asIntBuffer, MemoryAccess::getIntAtIndex_BE, IntBuffer::get);
+                (base) -> checkBytes(base, ints, ByteBuffer::asIntBuffer, (addr, pos) -> MemoryAccess.getIntAtIndex(addr, pos, ByteOrder.BIG_ENDIAN), IntBuffer::get);
         Consumer floatChecker =
-                (base) -> checkBytes(base, floats, ByteBuffer::asFloatBuffer, MemoryAccess::getFloatAtIndex_BE, FloatBuffer::get);
+                (base) -> checkBytes(base, floats, ByteBuffer::asFloatBuffer, (addr, pos) -> MemoryAccess.getFloatAtIndex(addr, pos, ByteOrder.BIG_ENDIAN), FloatBuffer::get);
         Consumer longChecker =
-                (base) -> checkBytes(base, longs, ByteBuffer::asLongBuffer, MemoryAccess::getLongAtIndex_BE, LongBuffer::get);
+                (base) -> checkBytes(base, longs, ByteBuffer::asLongBuffer, (addr, pos) -> MemoryAccess.getLongAtIndex(addr, pos, ByteOrder.BIG_ENDIAN), LongBuffer::get);
         Consumer doubleChecker =
-                (base) -> checkBytes(base, doubles, ByteBuffer::asDoubleBuffer, MemoryAccess::getDoubleAtIndex_BE, DoubleBuffer::get);
+                (base) -> checkBytes(base, doubles, ByteBuffer::asDoubleBuffer, (addr, pos) -> MemoryAccess.getDoubleAtIndex(addr, pos, ByteOrder.BIG_ENDIAN), DoubleBuffer::get);
 
         return new Object[][]{
                 {byteChecker, byteInitializer, bytes},

From c595a8dd7686e51284aa105fc163e63a5037242e Mon Sep 17 00:00:00 2001
From: Jorn Vernee 
Date: Mon, 19 Oct 2020 14:22:35 +0200
Subject: [PATCH 21/70] Use separate constants for native invoker code size

---
 src/hotspot/cpu/aarch64/universalNativeInvoker_aarch64.cpp | 4 +++-
 src/hotspot/cpu/aarch64/universalUpcallHandler_aarch64.cpp | 4 +++-
 src/hotspot/cpu/x86/universalNativeInvoker_x86.cpp         | 4 +++-
 src/hotspot/cpu/x86/universalUpcallHandler_x86.cpp         | 4 +++-
 4 files changed, 12 insertions(+), 4 deletions(-)

diff --git a/src/hotspot/cpu/aarch64/universalNativeInvoker_aarch64.cpp b/src/hotspot/cpu/aarch64/universalNativeInvoker_aarch64.cpp
index 75b1e565bb3b3..b44d46a072f75 100644
--- a/src/hotspot/cpu/aarch64/universalNativeInvoker_aarch64.cpp
+++ b/src/hotspot/cpu/aarch64/universalNativeInvoker_aarch64.cpp
@@ -34,6 +34,8 @@
 #include "runtime/interfaceSupport.inline.hpp"
 #include "runtime/javaCalls.hpp"
 
+static constexpr CodeBuffer::csize_t native_invoker_size = 1024;
+
 static void generate_invoke_native(MacroAssembler* _masm,
                                    const ABIDescriptor& abi,
                                    const BufferLayout& layout) {
@@ -152,7 +154,7 @@ jlong ProgrammableInvoker::generate_adapter(JNIEnv* env, jobject jabi, jobject j
   const ABIDescriptor abi = parseABIDescriptor(env, jabi);
   const BufferLayout layout = parseBufferLayout(env, jlayout);
 
-  BufferBlob* _invoke_native_blob = BufferBlob::create("invoke_native_blob", MethodHandles::adapter_code_size);
+  BufferBlob* _invoke_native_blob = BufferBlob::create("invoke_native_blob", native_invoker_size);
 
   CodeBuffer code2(_invoke_native_blob);
   ProgrammableInvokerGenerator g2(&code2, &abi, &layout);
diff --git a/src/hotspot/cpu/aarch64/universalUpcallHandler_aarch64.cpp b/src/hotspot/cpu/aarch64/universalUpcallHandler_aarch64.cpp
index 4794d5251ed3d..d464e7b437fed 100644
--- a/src/hotspot/cpu/aarch64/universalUpcallHandler_aarch64.cpp
+++ b/src/hotspot/cpu/aarch64/universalUpcallHandler_aarch64.cpp
@@ -38,6 +38,8 @@
 #include "runtime/javaCalls.hpp"
 #include "runtime/jniHandles.inline.hpp"
 
+static constexpr CodeBuffer::csize_t upcall_stub_size = 1024;
+
 extern struct JavaVM_ main_vm;
 
 static struct {
@@ -121,7 +123,7 @@ static void upcall_helper(jobject rec, address buff) {
 static address generate_upcall_stub(jobject rec, const ABIDescriptor& abi,
                                     const BufferLayout& layout) {
   ResourceMark rm;
-  CodeBuffer buffer("upcall_stub", 1024, 1024);
+  CodeBuffer buffer("upcall_stub", 1024, upcall_stub_size);
 
   MacroAssembler* _masm = new MacroAssembler(&buffer);
 
diff --git a/src/hotspot/cpu/x86/universalNativeInvoker_x86.cpp b/src/hotspot/cpu/x86/universalNativeInvoker_x86.cpp
index c555647b82493..87f2f6776cc1c 100644
--- a/src/hotspot/cpu/x86/universalNativeInvoker_x86.cpp
+++ b/src/hotspot/cpu/x86/universalNativeInvoker_x86.cpp
@@ -38,6 +38,8 @@
 #include "runtime/jniHandles.inline.hpp"
 #include "prims/methodHandles.hpp"
 
+static constexpr CodeBuffer::csize_t native_invoker_size = 1024;
+
 void generate_invoke_native(MacroAssembler* _masm, const ABIDescriptor& abi, const BufferLayout& layout) {
 
 #if 0
@@ -190,7 +192,7 @@ jlong ProgrammableInvoker::generate_adapter(JNIEnv* env, jobject jabi, jobject j
     const ABIDescriptor abi = parseABIDescriptor(env, jabi);
     const BufferLayout layout = parseBufferLayout(env, jlayout);
 
-    BufferBlob* _invoke_native_blob = BufferBlob::create("invoke_native_blob", MethodHandles::adapter_code_size);
+    BufferBlob* _invoke_native_blob = BufferBlob::create("invoke_native_blob", native_invoker_size);
 
     CodeBuffer code2(_invoke_native_blob);
     ProgrammableInvokerGenerator g2(&code2, &abi, &layout);
diff --git a/src/hotspot/cpu/x86/universalUpcallHandler_x86.cpp b/src/hotspot/cpu/x86/universalUpcallHandler_x86.cpp
index 9426d5cdf612a..89b87ad065ac5 100644
--- a/src/hotspot/cpu/x86/universalUpcallHandler_x86.cpp
+++ b/src/hotspot/cpu/x86/universalUpcallHandler_x86.cpp
@@ -39,6 +39,8 @@
 #include "runtime/jniHandles.inline.hpp"
 #include "classfile/symbolTable.hpp"
 
+static constexpr CodeBuffer::csize_t upcall_stub_size = 1024;
+
 extern struct JavaVM_ main_vm;
 
 static struct {
@@ -119,7 +121,7 @@ static void upcall_helper(jobject rec, address buff) {
 
 static address generate_upcall_stub(jobject rec, const ABIDescriptor& abi, const BufferLayout& layout) {
   ResourceMark rm;
-  CodeBuffer buffer("upcall_stub", 1024, 1024);
+  CodeBuffer buffer("upcall_stub", 1024, upcall_stub_size);
 
   MacroAssembler* _masm = new MacroAssembler(&buffer);
   int stack_alignment_C = 16; // bytes

From aee22456ab4168e21931dbd186d9dfc386ff94d8 Mon Sep 17 00:00:00 2001
From: Jorn Vernee 
Date: Mon, 19 Oct 2020 14:06:45 +0200
Subject: [PATCH 22/70] Update copyright years, and add classpath exception to
 files that were missing it

---
 .../cpu/aarch64/foreign_globals_aarch64.cpp   |  2 +-
 .../cpu/aarch64/foreign_globals_aarch64.hpp   |  2 +-
 .../universalNativeInvoker_aarch64.cpp        |  2 +-
 .../universalUpcallHandler_aarch64.cpp        |  2 +-
 src/hotspot/cpu/aarch64/vmreg_aarch64.cpp     |  2 +-
 src/hotspot/cpu/x86/foreign_globals_x86.cpp   |  2 +-
 src/hotspot/cpu/x86/foreign_globals_x86.hpp   |  2 +-
 .../cpu/x86/universalNativeInvoker_x86.cpp    |  2 +-
 .../cpu/x86/universalUpcallHandler_x86.cpp    |  2 +-
 src/hotspot/share/c1/c1_IR.hpp                |  2 +-
 src/hotspot/share/code/compiledMethod.cpp     |  2 +-
 src/hotspot/share/code/debugInfoRec.hpp       |  2 +-
 src/hotspot/share/code/pcDesc.hpp             |  2 +-
 src/hotspot/share/code/scopeDesc.hpp          |  2 +-
 .../share/prims/universalNativeInvoker.cpp    |  2 +-
 .../share/prims/universalNativeInvoker.hpp    |  2 +-
 .../share/prims/universalUpcallHandler.cpp    |  2 +-
 .../share/prims/universalUpcallHandler.hpp    |  2 +-
 src/hotspot/share/prims/upcallStubs.cpp       |  2 +-
 .../access/foreign/NativeLibraryProxy.java    |  2 +-
 src/java.base/share/native/libjava/jni_util.h |  2 +-
 .../unix/native/libjava/jni_util_md.c         |  2 +-
 .../jdk/incubator/foreign/AbstractLayout.java |  2 +-
 .../incubator/foreign/FunctionDescriptor.java |  4 +++-
 .../jdk/incubator/foreign/LibraryLookup.java  |  2 +-
 .../jdk/incubator/foreign/MemorySegment.java  |  2 +-
 .../jdk/incubator/foreign/package-info.java   |  2 +-
 .../internal/foreign/AbstractNativeScope.java | 24 +++++++++++++++++++
 .../jdk/internal/foreign/LayoutPath.java      |  2 +-
 .../jdk/internal/foreign/LibrariesHelper.java |  2 +-
 .../internal/foreign/MemoryAddressImpl.java   |  2 +-
 .../internal/foreign/abi/ABIDescriptor.java   |  4 +++-
 .../internal/foreign/abi/Architecture.java    |  6 +++--
 .../jdk/internal/foreign/abi/Binding.java     |  4 +++-
 .../foreign/abi/BindingInterpreter.java       |  4 +++-
 .../internal/foreign/abi/BufferLayout.java    |  6 +++--
 .../internal/foreign/abi/CallingSequence.java |  4 +++-
 .../foreign/abi/CallingSequenceBuilder.java   |  4 +++-
 .../foreign/abi/ProgrammableInvoker.java      |  4 +++-
 .../abi/ProgrammableUpcallHandler.java        |  6 +++--
 .../internal/foreign/abi/UpcallHandler.java   |  6 +++--
 .../jdk/internal/foreign/abi/UpcallStubs.java |  2 +-
 .../jdk/internal/foreign/abi/VMStorage.java   |  4 +++-
 .../abi/aarch64/AArch64Architecture.java      |  6 +++--
 .../foreign/abi/aarch64/CallArranger.java     |  4 +++-
 .../foreign/abi/x64/X86_64Architecture.java   |  6 +++--
 .../foreign/abi/x64/windows/CallArranger.java |  4 +++-
 test/jdk/java/foreign/TestIllegalLink.java    |  2 +-
 .../jdk/java/foreign/TestLayoutConstants.java |  2 +-
 test/jdk/java/foreign/TestNative.java         |  2 +-
 test/jdk/java/foreign/TestTypeAccess.java     |  2 +-
 test/jdk/java/foreign/libTestDowncall.c       |  2 +-
 test/jdk/java/foreign/libTestDowncall.h       |  2 +-
 test/jdk/java/foreign/libTestUpcall.c         |  2 +-
 test/jdk/java/foreign/libTestUpcall.h         |  2 +-
 test/jdk/java/foreign/libVarArgs.c            |  2 +-
 56 files changed, 117 insertions(+), 61 deletions(-)

diff --git a/src/hotspot/cpu/aarch64/foreign_globals_aarch64.cpp b/src/hotspot/cpu/aarch64/foreign_globals_aarch64.cpp
index 9a527f68f918c..ce8aafb12b160 100644
--- a/src/hotspot/cpu/aarch64/foreign_globals_aarch64.cpp
+++ b/src/hotspot/cpu/aarch64/foreign_globals_aarch64.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
  * Copyright (c) 2019, Arm Limited. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
diff --git a/src/hotspot/cpu/aarch64/foreign_globals_aarch64.hpp b/src/hotspot/cpu/aarch64/foreign_globals_aarch64.hpp
index 0112558f5c51b..978c929fef2dd 100644
--- a/src/hotspot/cpu/aarch64/foreign_globals_aarch64.hpp
+++ b/src/hotspot/cpu/aarch64/foreign_globals_aarch64.hpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
  * Copyright (c) 2019, Arm Limited. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
diff --git a/src/hotspot/cpu/aarch64/universalNativeInvoker_aarch64.cpp b/src/hotspot/cpu/aarch64/universalNativeInvoker_aarch64.cpp
index b44d46a072f75..74a7dcafc9ce8 100644
--- a/src/hotspot/cpu/aarch64/universalNativeInvoker_aarch64.cpp
+++ b/src/hotspot/cpu/aarch64/universalNativeInvoker_aarch64.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
  * Copyright (c) 2019, Arm Limited. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
diff --git a/src/hotspot/cpu/aarch64/universalUpcallHandler_aarch64.cpp b/src/hotspot/cpu/aarch64/universalUpcallHandler_aarch64.cpp
index d464e7b437fed..77fd4875ccbb5 100644
--- a/src/hotspot/cpu/aarch64/universalUpcallHandler_aarch64.cpp
+++ b/src/hotspot/cpu/aarch64/universalUpcallHandler_aarch64.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
  * Copyright (c) 2019, Arm Limited. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
diff --git a/src/hotspot/cpu/aarch64/vmreg_aarch64.cpp b/src/hotspot/cpu/aarch64/vmreg_aarch64.cpp
index d68edf59d4031..3e95168c8df66 100644
--- a/src/hotspot/cpu/aarch64/vmreg_aarch64.cpp
+++ b/src/hotspot/cpu/aarch64/vmreg_aarch64.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2006, 2020, Oracle and/or its affiliates. All rights reserved.
  * Copyright (c) 2014, Red Hat Inc. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
diff --git a/src/hotspot/cpu/x86/foreign_globals_x86.cpp b/src/hotspot/cpu/x86/foreign_globals_x86.cpp
index 71cf407302134..d95bb494b8fe2 100644
--- a/src/hotspot/cpu/x86/foreign_globals_x86.cpp
+++ b/src/hotspot/cpu/x86/foreign_globals_x86.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
diff --git a/src/hotspot/cpu/x86/foreign_globals_x86.hpp b/src/hotspot/cpu/x86/foreign_globals_x86.hpp
index ff813e01add75..d4bb5c3666813 100644
--- a/src/hotspot/cpu/x86/foreign_globals_x86.hpp
+++ b/src/hotspot/cpu/x86/foreign_globals_x86.hpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
diff --git a/src/hotspot/cpu/x86/universalNativeInvoker_x86.cpp b/src/hotspot/cpu/x86/universalNativeInvoker_x86.cpp
index 87f2f6776cc1c..1aacc620291c4 100644
--- a/src/hotspot/cpu/x86/universalNativeInvoker_x86.cpp
+++ b/src/hotspot/cpu/x86/universalNativeInvoker_x86.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018, 2019, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
diff --git a/src/hotspot/cpu/x86/universalUpcallHandler_x86.cpp b/src/hotspot/cpu/x86/universalUpcallHandler_x86.cpp
index 89b87ad065ac5..395147c888314 100644
--- a/src/hotspot/cpu/x86/universalUpcallHandler_x86.cpp
+++ b/src/hotspot/cpu/x86/universalUpcallHandler_x86.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018, 2019, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
diff --git a/src/hotspot/share/c1/c1_IR.hpp b/src/hotspot/share/c1/c1_IR.hpp
index 36fe1ca23ea8a..abf1cfbce5b22 100644
--- a/src/hotspot/share/c1/c1_IR.hpp
+++ b/src/hotspot/share/c1/c1_IR.hpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1999, 2019, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1999, 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
diff --git a/src/hotspot/share/code/compiledMethod.cpp b/src/hotspot/share/code/compiledMethod.cpp
index c189f4c2419fb..454d077be7390 100644
--- a/src/hotspot/share/code/compiledMethod.cpp
+++ b/src/hotspot/share/code/compiledMethod.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, 2019, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2015, 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
diff --git a/src/hotspot/share/code/debugInfoRec.hpp b/src/hotspot/share/code/debugInfoRec.hpp
index d0a9f2b1b6176..a86b35bb85218 100644
--- a/src/hotspot/share/code/debugInfoRec.hpp
+++ b/src/hotspot/share/code/debugInfoRec.hpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2019, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
diff --git a/src/hotspot/share/code/pcDesc.hpp b/src/hotspot/share/code/pcDesc.hpp
index 4def290039964..c799b9e80f675 100644
--- a/src/hotspot/share/code/pcDesc.hpp
+++ b/src/hotspot/share/code/pcDesc.hpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 2019, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
diff --git a/src/hotspot/share/code/scopeDesc.hpp b/src/hotspot/share/code/scopeDesc.hpp
index a60c0fe5f53a3..4543340093cec 100644
--- a/src/hotspot/share/code/scopeDesc.hpp
+++ b/src/hotspot/share/code/scopeDesc.hpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 2019, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
diff --git a/src/hotspot/share/prims/universalNativeInvoker.cpp b/src/hotspot/share/prims/universalNativeInvoker.cpp
index 0373a9aac3f2e..bc681c999bda3 100644
--- a/src/hotspot/share/prims/universalNativeInvoker.cpp
+++ b/src/hotspot/share/prims/universalNativeInvoker.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
diff --git a/src/hotspot/share/prims/universalNativeInvoker.hpp b/src/hotspot/share/prims/universalNativeInvoker.hpp
index d9298cdf5a812..e521a010ba656 100644
--- a/src/hotspot/share/prims/universalNativeInvoker.hpp
+++ b/src/hotspot/share/prims/universalNativeInvoker.hpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018, 2019, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
diff --git a/src/hotspot/share/prims/universalUpcallHandler.cpp b/src/hotspot/share/prims/universalUpcallHandler.cpp
index b80c57597d252..5bcbbb54e432c 100644
--- a/src/hotspot/share/prims/universalUpcallHandler.cpp
+++ b/src/hotspot/share/prims/universalUpcallHandler.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
diff --git a/src/hotspot/share/prims/universalUpcallHandler.hpp b/src/hotspot/share/prims/universalUpcallHandler.hpp
index 43710f128fdac..1b223aa0cd8b4 100644
--- a/src/hotspot/share/prims/universalUpcallHandler.hpp
+++ b/src/hotspot/share/prims/universalUpcallHandler.hpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
diff --git a/src/hotspot/share/prims/upcallStubs.cpp b/src/hotspot/share/prims/upcallStubs.cpp
index d8ae5f2415d77..5763986ba099a 100644
--- a/src/hotspot/share/prims/upcallStubs.cpp
+++ b/src/hotspot/share/prims/upcallStubs.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
diff --git a/src/java.base/share/classes/jdk/internal/access/foreign/NativeLibraryProxy.java b/src/java.base/share/classes/jdk/internal/access/foreign/NativeLibraryProxy.java
index dcd22833adb88..18370d27eaa61 100644
--- a/src/java.base/share/classes/jdk/internal/access/foreign/NativeLibraryProxy.java
+++ b/src/java.base/share/classes/jdk/internal/access/foreign/NativeLibraryProxy.java
@@ -1,5 +1,5 @@
 /*
- *  Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
+ *  Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
  *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  *  This code is free software; you can redistribute it and/or modify it
diff --git a/src/java.base/share/native/libjava/jni_util.h b/src/java.base/share/native/libjava/jni_util.h
index 652a1864e7777..72aa55feb7782 100644
--- a/src/java.base/share/native/libjava/jni_util.h
+++ b/src/java.base/share/native/libjava/jni_util.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 2019, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
diff --git a/src/java.base/unix/native/libjava/jni_util_md.c b/src/java.base/unix/native/libjava/jni_util_md.c
index 7415e03f169d1..dafd0ae6317bf 100644
--- a/src/java.base/unix/native/libjava/jni_util_md.c
+++ b/src/java.base/unix/native/libjava/jni_util_md.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2008, 2018, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2008, 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/AbstractLayout.java b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/AbstractLayout.java
index ca8e1f18209c7..1e7bb8e81ae7d 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/AbstractLayout.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/AbstractLayout.java
@@ -1,5 +1,5 @@
 /*
- *  Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
+ *  Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
  *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  *  This code is free software; you can redistribute it and/or modify it
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/FunctionDescriptor.java b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/FunctionDescriptor.java
index f9d83cb4db36a..5aecf991ec6e1 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/FunctionDescriptor.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/FunctionDescriptor.java
@@ -4,7 +4,9 @@
  *
  *  This code is free software; you can redistribute it and/or modify it
  *  under the terms of the GNU General Public License version 2 only, as
- *  published by the Free Software Foundation.
+ *  published by the Free Software Foundation.  Oracle designates this
+ *  particular file as subject to the "Classpath" exception as provided
+ *  by Oracle in the LICENSE file that accompanied this code.
  *
  *  This code is distributed in the hope that it will be useful, but WITHOUT
  *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/LibraryLookup.java b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/LibraryLookup.java
index c78d451f42cbe..1dc1c6ddab9b9 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/LibraryLookup.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/LibraryLookup.java
@@ -1,5 +1,5 @@
 /*
- *  Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
+ *  Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
  *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  *  This code is free software; you can redistribute it and/or modify it
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MemorySegment.java b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MemorySegment.java
index 2d089809cb408..1ea30b26083e9 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MemorySegment.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MemorySegment.java
@@ -1,5 +1,5 @@
 /*
- *  Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
+ *  Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
  *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  *  This code is free software; you can redistribute it and/or modify it
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/package-info.java b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/package-info.java
index 322da7fcc0a7a..bf79ce9d0f175 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/package-info.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/package-info.java
@@ -1,5 +1,5 @@
 /*
- *  Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
+ *  Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
  *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  *  This code is free software; you can redistribute it and/or modify it
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/AbstractNativeScope.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/AbstractNativeScope.java
index 0f7e89b6b0b77..72473a3f48e35 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/AbstractNativeScope.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/AbstractNativeScope.java
@@ -1,3 +1,27 @@
+/*
+ * copyright (c) 2020 oracle and/or its affiliates. all rights reserved.
+ * do not alter or remove copyright notices or this file header.
+ *
+ * this code is free software; you can redistribute it and/or modify it
+ * under the terms of the gnu general public license version 2 only, as
+ * published by the free software foundation.  oracle designates this
+ * particular file as subject to the "classpath" exception as provided
+ * by oracle in the license file that accompanied this code.
+ *
+ * this code 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
+ * version 2 for more details (a copy is included in the license file that
+ * accompanied this code).
+ *
+ * you should have received a copy of the gnu general public license version
+ * 2 along with this work; if not, write to the free software foundation,
+ * inc., 51 franklin st, fifth floor, boston, ma 02110-1301 usa.
+ *
+ * please contact oracle, 500 oracle parkway, redwood shores, ca 94065 usa
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
 package jdk.internal.foreign;
 
 import jdk.incubator.foreign.MemorySegment;
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/LayoutPath.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/LayoutPath.java
index 393a05e6ff225..cc5a9a0bc86d8 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/LayoutPath.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/LayoutPath.java
@@ -1,5 +1,5 @@
 /*
- *  Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
+ *  Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
  *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  *  This code is free software; you can redistribute it and/or modify it
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/LibrariesHelper.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/LibrariesHelper.java
index 3417dd0c86f59..006374f1617d2 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/LibrariesHelper.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/LibrariesHelper.java
@@ -1,5 +1,5 @@
 /*
- *  Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
+ *  Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
  *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  *  This code is free software; you can redistribute it and/or modify it
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/MemoryAddressImpl.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/MemoryAddressImpl.java
index f7d39bd79448c..e7c22bb7d410a 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/MemoryAddressImpl.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/MemoryAddressImpl.java
@@ -1,5 +1,5 @@
 /*
- *  Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
+ *  Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
  *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  *  This code is free software; you can redistribute it and/or modify it
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/ABIDescriptor.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/ABIDescriptor.java
index 25a00812bf26e..27ad0f21d222f 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/ABIDescriptor.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/ABIDescriptor.java
@@ -4,7 +4,9 @@
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/Architecture.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/Architecture.java
index 4c73d069247ed..09e97b7af2f57 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/Architecture.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/Architecture.java
@@ -1,10 +1,12 @@
 /*
- * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/Binding.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/Binding.java
index 0b7bae3997627..23a7e01b38cca 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/Binding.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/Binding.java
@@ -4,7 +4,9 @@
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/BindingInterpreter.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/BindingInterpreter.java
index fc0d3f5a3ebe7..63d26806df17e 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/BindingInterpreter.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/BindingInterpreter.java
@@ -4,7 +4,9 @@
  *
  *  This code is free software; you can redistribute it and/or modify it
  *  under the terms of the GNU General Public License version 2 only, as
- *  published by the Free Software Foundation.
+ *  published by the Free Software Foundation.  Oracle designates this
+ *  particular file as subject to the "Classpath" exception as provided
+ *  by Oracle in the LICENSE file that accompanied this code.
  *
  *  This code is distributed in the hope that it will be useful, but WITHOUT
  *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/BufferLayout.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/BufferLayout.java
index a34ce2d69e099..f7541dd9fc3e2 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/BufferLayout.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/BufferLayout.java
@@ -1,10 +1,12 @@
 /*
- *  Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
+ *  Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
  *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  *  This code is free software; you can redistribute it and/or modify it
  *  under the terms of the GNU General Public License version 2 only, as
- *  published by the Free Software Foundation.
+ *  published by the Free Software Foundation.  Oracle designates this
+ *  particular file as subject to the "Classpath" exception as provided
+ *  by Oracle in the LICENSE file that accompanied this code.
  *
  *  This code is distributed in the hope that it will be useful, but WITHOUT
  *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/CallingSequence.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/CallingSequence.java
index 4a8045283f47a..0ec8cd9f78a23 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/CallingSequence.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/CallingSequence.java
@@ -4,7 +4,9 @@
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/CallingSequenceBuilder.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/CallingSequenceBuilder.java
index 8b6ac2aa1ef63..a3965820e93c0 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/CallingSequenceBuilder.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/CallingSequenceBuilder.java
@@ -4,7 +4,9 @@
  *
  *  This code is free software; you can redistribute it and/or modify it
  *  under the terms of the GNU General Public License version 2 only, as
- *  published by the Free Software Foundation.
+ *  published by the Free Software Foundation.  Oracle designates this
+ *  particular file as subject to the "Classpath" exception as provided
+ *  by Oracle in the LICENSE file that accompanied this code.
  *
  *  This code is distributed in the hope that it will be useful, but WITHOUT
  *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/ProgrammableInvoker.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/ProgrammableInvoker.java
index 88053db829c4a..b18d1f9645070 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/ProgrammableInvoker.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/ProgrammableInvoker.java
@@ -4,7 +4,9 @@
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/ProgrammableUpcallHandler.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/ProgrammableUpcallHandler.java
index fcc3bbf011337..319f6cb62ed44 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/ProgrammableUpcallHandler.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/ProgrammableUpcallHandler.java
@@ -1,10 +1,12 @@
 /*
- * Copyright (c) 2018, 2019, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/UpcallHandler.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/UpcallHandler.java
index 913dc1d17e018..0adf0d0f6d007 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/UpcallHandler.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/UpcallHandler.java
@@ -1,10 +1,12 @@
 /*
- *  Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
+ *  Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
  *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  *  This code is free software; you can redistribute it and/or modify it
  *  under the terms of the GNU General Public License version 2 only, as
- *  published by the Free Software Foundation.
+ *  published by the Free Software Foundation.  Oracle designates this
+ *  particular file as subject to the "Classpath" exception as provided
+ *  by Oracle in the LICENSE file that accompanied this code.
  *
  *  This code is distributed in the hope that it will be useful, but WITHOUT
  *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/UpcallStubs.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/UpcallStubs.java
index 4db7d77d0334e..731f86a368ba6 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/UpcallStubs.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/UpcallStubs.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/VMStorage.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/VMStorage.java
index 23f3bc3fba70e..60044617fae89 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/VMStorage.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/VMStorage.java
@@ -4,7 +4,9 @@
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/aarch64/AArch64Architecture.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/aarch64/AArch64Architecture.java
index 31fc75fc4367a..fdba12c0439a9 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/aarch64/AArch64Architecture.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/aarch64/AArch64Architecture.java
@@ -1,11 +1,13 @@
 /*
- * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
  * Copyright (c) 2019, Arm Limited. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/aarch64/CallArranger.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/aarch64/CallArranger.java
index 3f07cc920da6d..e33e4c431edbb 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/aarch64/CallArranger.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/aarch64/CallArranger.java
@@ -5,7 +5,9 @@
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/X86_64Architecture.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/X86_64Architecture.java
index eace0ef25ea6a..366703567ca0c 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/X86_64Architecture.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/X86_64Architecture.java
@@ -1,10 +1,12 @@
 /*
- * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/windows/CallArranger.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/windows/CallArranger.java
index 256c835b2de77..200543fd8bad5 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/windows/CallArranger.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/windows/CallArranger.java
@@ -4,7 +4,9 @@
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
diff --git a/test/jdk/java/foreign/TestIllegalLink.java b/test/jdk/java/foreign/TestIllegalLink.java
index 0164794bf98d7..3a054e6b5d9d3 100644
--- a/test/jdk/java/foreign/TestIllegalLink.java
+++ b/test/jdk/java/foreign/TestIllegalLink.java
@@ -1,5 +1,5 @@
 /*
- *  Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
+ *  Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
  *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  *  This code is free software; you can redistribute it and/or modify it
diff --git a/test/jdk/java/foreign/TestLayoutConstants.java b/test/jdk/java/foreign/TestLayoutConstants.java
index 2bd1e06727787..904d03ecceeff 100644
--- a/test/jdk/java/foreign/TestLayoutConstants.java
+++ b/test/jdk/java/foreign/TestLayoutConstants.java
@@ -1,5 +1,5 @@
 /*
- *  Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
+ *  Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
  *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  *  This code is free software; you can redistribute it and/or modify it
diff --git a/test/jdk/java/foreign/TestNative.java b/test/jdk/java/foreign/TestNative.java
index 01a7c0d597a00..d11f25522b7c0 100644
--- a/test/jdk/java/foreign/TestNative.java
+++ b/test/jdk/java/foreign/TestNative.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
  *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  *  This code is free software; you can redistribute it and/or modify it
diff --git a/test/jdk/java/foreign/TestTypeAccess.java b/test/jdk/java/foreign/TestTypeAccess.java
index 8ac8e92026a22..24c311f61928e 100644
--- a/test/jdk/java/foreign/TestTypeAccess.java
+++ b/test/jdk/java/foreign/TestTypeAccess.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
  *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  *  This code is free software; you can redistribute it and/or modify it
diff --git a/test/jdk/java/foreign/libTestDowncall.c b/test/jdk/java/foreign/libTestDowncall.c
index f4ef3aafbf0aa..6c5a6c81f6e04 100644
--- a/test/jdk/java/foreign/libTestDowncall.c
+++ b/test/jdk/java/foreign/libTestDowncall.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
diff --git a/test/jdk/java/foreign/libTestDowncall.h b/test/jdk/java/foreign/libTestDowncall.h
index 4a69ae41772fa..ece38c7a3a2a6 100644
--- a/test/jdk/java/foreign/libTestDowncall.h
+++ b/test/jdk/java/foreign/libTestDowncall.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
diff --git a/test/jdk/java/foreign/libTestUpcall.c b/test/jdk/java/foreign/libTestUpcall.c
index d73bd3c3e034a..28145fe6528df 100644
--- a/test/jdk/java/foreign/libTestUpcall.c
+++ b/test/jdk/java/foreign/libTestUpcall.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
diff --git a/test/jdk/java/foreign/libTestUpcall.h b/test/jdk/java/foreign/libTestUpcall.h
index 6d0937a15ded1..1dd1f585a077b 100644
--- a/test/jdk/java/foreign/libTestUpcall.h
+++ b/test/jdk/java/foreign/libTestUpcall.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
diff --git a/test/jdk/java/foreign/libVarArgs.c b/test/jdk/java/foreign/libVarArgs.c
index f6f1209a60a26..0a6c24fead39b 100644
--- a/test/jdk/java/foreign/libVarArgs.c
+++ b/test/jdk/java/foreign/libVarArgs.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
  *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  *  This code is free software; you can redistribute it and/or modify it

From 7d6eadc7bb4be1b23484c14059015dbe7610fec5 Mon Sep 17 00:00:00 2001
From: Jorn Vernee 
Date: Mon, 19 Oct 2020 16:58:07 +0200
Subject: [PATCH 23/70] Fix incorrect capitalization in one copyright header

---
 .../internal/foreign/AbstractNativeScope.java | 30 +++++++++----------
 1 file changed, 15 insertions(+), 15 deletions(-)

diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/AbstractNativeScope.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/AbstractNativeScope.java
index 72473a3f48e35..515f8c40c8996 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/AbstractNativeScope.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/AbstractNativeScope.java
@@ -1,24 +1,24 @@
 /*
- * copyright (c) 2020 oracle and/or its affiliates. all rights reserved.
- * do not alter or remove copyright notices or this file header.
+ * Copyright (c) 2020 Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
- * this code is free software; you can redistribute it and/or modify it
- * under the terms of the gnu general public license version 2 only, as
- * published by the free software foundation.  oracle designates this
- * particular file as subject to the "classpath" exception as provided
- * by oracle in the license file that accompanied this code.
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
  *
- * this code 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
- * version 2 for more details (a copy is included in the license file that
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
- * you should have received a copy of the gnu general public license version
- * 2 along with this work; if not, write to the free software foundation,
- * inc., 51 franklin st, fifth floor, boston, ma 02110-1301 usa.
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
- * please contact oracle, 500 oracle parkway, redwood shores, ca 94065 usa
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */

From 7cef16f41e22fe1332b7c263aae5a6339a833f32 Mon Sep 17 00:00:00 2001
From: Jorn Vernee 
Date: Wed, 21 Oct 2020 12:40:56 +0200
Subject: [PATCH 24/70] Don't use JNI when generating native wrappers

---
 .../cpu/aarch64/foreign_globals_aarch64.cpp   | 105 +++++-----------
 .../cpu/aarch64/foreign_globals_aarch64.hpp   |   9 +-
 .../universalNativeInvoker_aarch64.cpp        |   7 +-
 .../universalUpcallHandler_aarch64.cpp        |   6 +-
 src/hotspot/cpu/x86/foreign_globals_x86.cpp   | 112 +++++++-----------
 src/hotspot/cpu/x86/foreign_globals_x86.hpp   |   9 +-
 .../cpu/x86/universalNativeInvoker_x86.cpp    |  19 ++-
 .../cpu/x86/universalUpcallHandler_x86.cpp    |   6 +-
 src/hotspot/share/prims/foreign_globals.cpp   |  85 +++++++++++++
 src/hotspot/share/prims/foreign_globals.hpp   |  72 +++++++++++
 .../share/prims/foreign_globals.inline.hpp    |  58 +++++++++
 src/hotspot/share/prims/nativeEntryPoint.cpp  |  17 +--
 .../share/prims/universalNativeInvoker.cpp    |  28 ++---
 .../share/prims/universalNativeInvoker.hpp    |   4 +-
 .../share/prims/universalUpcallHandler.cpp    |  17 +--
 .../share/prims/universalUpcallHandler.hpp    |   4 +-
 src/hotspot/share/prims/upcallStubs.cpp       |  13 +-
 17 files changed, 338 insertions(+), 233 deletions(-)
 create mode 100644 src/hotspot/share/prims/foreign_globals.cpp
 create mode 100644 src/hotspot/share/prims/foreign_globals.hpp
 create mode 100644 src/hotspot/share/prims/foreign_globals.inline.hpp

diff --git a/src/hotspot/cpu/aarch64/foreign_globals_aarch64.cpp b/src/hotspot/cpu/aarch64/foreign_globals_aarch64.cpp
index ce8aafb12b160..4e741d7eab85d 100644
--- a/src/hotspot/cpu/aarch64/foreign_globals_aarch64.cpp
+++ b/src/hotspot/cpu/aarch64/foreign_globals_aarch64.cpp
@@ -23,8 +23,10 @@
  */
 
 #include "precompiled.hpp"
-#include "asm/macroAssembler.hpp"
-#include CPU_HEADER(foreign_globals)
+#include "runtime/jniHandles.hpp"
+#include "runtime/jniHandles.inline.hpp"
+#include "prims/foreign_globals.hpp"
+#include "prims/foreign_globals.inline.hpp"
 
 bool ABIDescriptor::is_volatile_reg(Register reg) const {
   return _integer_argument_registers.contains(reg)
@@ -36,91 +38,48 @@ bool ABIDescriptor::is_volatile_reg(FloatRegister reg) const {
         || _vector_additional_volatile_registers.contains(reg);
 }
 
-#define FOREIGN_ABI "jdk/internal/foreign/abi/"
-
 #define INTEGER_TYPE 0
 #define VECTOR_TYPE 1
-#define X87_TYPE 2
-#define STACK_TYPE 3
-
-template
-void loadArray(JNIEnv* env, jfieldID indexField, jobjectArray jarray,
-               jint type_index, GrowableArray& array, Func converter) {
-  jobjectArray subarray = (jobjectArray) env->GetObjectArrayElement(jarray, type_index);
-  jint subarray_length = env->GetArrayLength(subarray);
-  for (jint i = 0; i < subarray_length; i++) {
-    jobject storage = env->GetObjectArrayElement(subarray, i);
-    jint index = env->GetIntField(storage, indexField);
-    array.push(converter(index));
-  }
-}
-
-const ABIDescriptor parseABIDescriptor(JNIEnv* env, jobject jabi) {
-  jclass jc_ABIDescriptor = env->FindClass(FOREIGN_ABI "ABIDescriptor");
-  jfieldID jfID_inputStorage = env->GetFieldID(jc_ABIDescriptor, "inputStorage", "[[L" FOREIGN_ABI "VMStorage;");
-  jfieldID jfID_outputStorage = env->GetFieldID(jc_ABIDescriptor, "outputStorage", "[[L" FOREIGN_ABI "VMStorage;");
-  jfieldID jfID_volatileStorage = env->GetFieldID(jc_ABIDescriptor, "volatileStorage", "[[L" FOREIGN_ABI "VMStorage;");
-  jfieldID jfID_stackAlignment = env->GetFieldID(jc_ABIDescriptor, "stackAlignment", "I");
-  jfieldID jfID_shadowSpace = env->GetFieldID(jc_ABIDescriptor, "shadowSpace", "I");
-
-  jclass jc_VMStorage = env->FindClass(FOREIGN_ABI "VMStorage");
-  jfieldID jfID_storageIndex = env->GetFieldID(jc_VMStorage, "index", "I");
 
+const ABIDescriptor ForeignGlobals::parseABIDescriptor_impl(jobject jabi) const {
+  oop abi_oop = JNIHandles::resolve_non_null(jabi);
   ABIDescriptor abi;
 
-  jobjectArray inputStorage = (jobjectArray) env->GetObjectField(jabi, jfID_inputStorage);
-  loadArray(env, jfID_storageIndex, inputStorage, INTEGER_TYPE, abi._integer_argument_registers, as_Register);
-  loadArray(env, jfID_storageIndex, inputStorage, VECTOR_TYPE, abi._vector_argument_registers, as_FloatRegister);
+  objArrayOop inputStorage = cast(abi_oop->obj_field(ABI.inputStorage_offset));
+  loadArray(inputStorage, INTEGER_TYPE, abi._integer_argument_registers, as_Register);
+  loadArray(inputStorage, VECTOR_TYPE, abi._vector_argument_registers, as_FloatRegister);
 
-  jobjectArray outputStorage = (jobjectArray) env->GetObjectField(jabi, jfID_outputStorage);
-  loadArray(env, jfID_storageIndex, outputStorage, INTEGER_TYPE, abi._integer_return_registers, as_Register);
-  loadArray(env, jfID_storageIndex, outputStorage, VECTOR_TYPE, abi._vector_return_registers, as_FloatRegister);
+  objArrayOop outputStorage = cast(abi_oop->obj_field(ABI.outputStorage_offset));
+  loadArray(outputStorage, INTEGER_TYPE, abi._integer_return_registers, as_Register);
+  loadArray(outputStorage, VECTOR_TYPE, abi._vector_return_registers, as_FloatRegister);
 
-  jobjectArray volatileStorage = (jobjectArray) env->GetObjectField(jabi, jfID_volatileStorage);
-  loadArray(env, jfID_storageIndex, volatileStorage, INTEGER_TYPE, abi._integer_additional_volatile_registers, as_Register);
-  loadArray(env, jfID_storageIndex, volatileStorage, VECTOR_TYPE, abi._vector_additional_volatile_registers, as_FloatRegister);
+  objArrayOop volatileStorage = cast(abi_oop->obj_field(ABI.volatileStorage_offset));
+  loadArray(volatileStorage, INTEGER_TYPE, abi._integer_additional_volatile_registers, as_Register);
+  loadArray(volatileStorage, VECTOR_TYPE, abi._vector_additional_volatile_registers, as_FloatRegister);
 
-  abi._stack_alignment_bytes = env->GetIntField(jabi, jfID_stackAlignment);
-  abi._shadow_space_bytes = env->GetIntField(jabi, jfID_shadowSpace);
+  abi._stack_alignment_bytes = abi_oop->int_field(ABI.stackAlignment_offset);
+  abi._shadow_space_bytes = abi_oop->int_field(ABI.shadowSpace_offset);
 
   return abi;
 }
 
-const BufferLayout parseBufferLayout(JNIEnv* env, jobject jlayout) {
-  jclass jc_BufferLayout = env->FindClass(FOREIGN_ABI "BufferLayout");
-  jfieldID jfID_size = env->GetFieldID(jc_BufferLayout, "size", "J");
-  jfieldID jfID_arguments_next_pc =
-    env->GetFieldID(jc_BufferLayout, "arguments_next_pc", "J");
-  jfieldID jfID_stack_args_bytes =
-    env->GetFieldID(jc_BufferLayout, "stack_args_bytes", "J");
-  jfieldID jfID_stack_args =
-    env->GetFieldID(jc_BufferLayout, "stack_args", "J");
-  jfieldID jfID_input_type_offsets =
-    env->GetFieldID(jc_BufferLayout, "input_type_offsets", "[J");
-  jfieldID jfID_output_type_offsets =
-    env->GetFieldID(jc_BufferLayout, "output_type_offsets", "[J");
-
+const BufferLayout ForeignGlobals::parseBufferLayout_impl(jobject jlayout) const {
+  oop layout_oop = JNIHandles::resolve_non_null(jlayout);
   BufferLayout layout;
 
-  layout.stack_args_bytes = env->GetLongField(jlayout, jfID_stack_args_bytes);
-  layout.stack_args = env->GetLongField(jlayout, jfID_stack_args);
-  layout.arguments_next_pc = env->GetLongField(jlayout, jfID_arguments_next_pc);
-
-  jlongArray input_offsets =
-    (jlongArray)env->GetObjectField(jlayout, jfID_input_type_offsets);
-  jlong *input_offsets_prim = env->GetLongArrayElements(input_offsets, NULL);
-  layout.arguments_integer = (size_t)input_offsets_prim[INTEGER_TYPE];
-  layout.arguments_vector = (size_t)input_offsets_prim[VECTOR_TYPE];
-  env->ReleaseLongArrayElements(input_offsets, input_offsets_prim, JNI_ABORT);
-
-  jlongArray output_offsets =
-    (jlongArray)env->GetObjectField(jlayout, jfID_output_type_offsets);
-  jlong *output_offsets_prim = env->GetLongArrayElements(output_offsets, NULL);
-  layout.returns_integer = (size_t)output_offsets_prim[INTEGER_TYPE];
-  layout.returns_vector = (size_t)output_offsets_prim[VECTOR_TYPE];
-  env->ReleaseLongArrayElements(output_offsets, output_offsets_prim, JNI_ABORT);
-
-  layout.buffer_size = env->GetLongField(jlayout, jfID_size);
+  layout.stack_args_bytes = layout_oop->long_field(BL.stack_args_bytes_offset);
+  layout.stack_args = layout_oop->long_field(BL.stack_args_offset);
+  layout.arguments_next_pc = layout_oop->long_field(BL.arguments_next_pc_offset);
+
+  typeArrayOop input_offsets = cast(layout_oop->obj_field(BL.input_type_offsets_offset));
+  layout.arguments_integer = (size_t) input_offsets->long_at(INTEGER_TYPE);
+  layout.arguments_vector = (size_t) input_offsets->long_at(VECTOR_TYPE);
+
+  typeArrayOop output_offsets = cast(layout_oop->obj_field(BL.output_type_offsets_offset));
+  layout.returns_integer = (size_t) output_offsets->long_at(INTEGER_TYPE);
+  layout.returns_vector = (size_t) output_offsets->long_at(VECTOR_TYPE);
+
+  layout.buffer_size = layout_oop->long_field(BL.size_offset);
 
   return layout;
 }
diff --git a/src/hotspot/cpu/aarch64/foreign_globals_aarch64.hpp b/src/hotspot/cpu/aarch64/foreign_globals_aarch64.hpp
index 978c929fef2dd..4504087e174ea 100644
--- a/src/hotspot/cpu/aarch64/foreign_globals_aarch64.hpp
+++ b/src/hotspot/cpu/aarch64/foreign_globals_aarch64.hpp
@@ -22,12 +22,12 @@
  * questions.
  */
 
-#include "asm/macroAssembler.hpp"
-#include "utilities/growableArray.hpp"
-
 #ifndef CPU_AARCH64_VM_FOREIGN_GLOBALS_AARCH64_HPP
 #define CPU_AARCH64_VM_FOREIGN_GLOBALS_AARCH64_HPP
 
+#include "asm/macroAssembler.hpp"
+#include "utilities/growableArray.hpp"
+
 #define __ _masm->
 
 struct VectorRegister {
@@ -72,7 +72,4 @@ struct BufferLayout {
   size_t buffer_size;
 };
 
-const ABIDescriptor parseABIDescriptor(JNIEnv* env, jobject jabi);
-const BufferLayout parseBufferLayout(JNIEnv* env, jobject jlayout);
-
 #endif // CPU_AARCH64_VM_FOREIGN_GLOBALS_AARCH64_HPP
diff --git a/src/hotspot/cpu/aarch64/universalNativeInvoker_aarch64.cpp b/src/hotspot/cpu/aarch64/universalNativeInvoker_aarch64.cpp
index 74a7dcafc9ce8..eb6967a40bb75 100644
--- a/src/hotspot/cpu/aarch64/universalNativeInvoker_aarch64.cpp
+++ b/src/hotspot/cpu/aarch64/universalNativeInvoker_aarch64.cpp
@@ -149,10 +149,9 @@ class ProgrammableInvokerGenerator : public StubCodeGenerator {
   }
 };
 
-jlong ProgrammableInvoker::generate_adapter(JNIEnv* env, jobject jabi, jobject jlayout) {
-  ResourceMark rm;
-  const ABIDescriptor abi = parseABIDescriptor(env, jabi);
-  const BufferLayout layout = parseBufferLayout(env, jlayout);
+jlong ProgrammableInvoker::generate_adapter(jobject jabi, jobject jlayout) {
+  const ABIDescriptor abi = ForeignGlobals::parseABIDescriptor(jabi);
+  const BufferLayout layout = ForeignGlobals::parseBufferLayout(jlayout);
 
   BufferBlob* _invoke_native_blob = BufferBlob::create("invoke_native_blob", native_invoker_size);
 
diff --git a/src/hotspot/cpu/aarch64/universalUpcallHandler_aarch64.cpp b/src/hotspot/cpu/aarch64/universalUpcallHandler_aarch64.cpp
index 77fd4875ccbb5..17b5255357952 100644
--- a/src/hotspot/cpu/aarch64/universalUpcallHandler_aarch64.cpp
+++ b/src/hotspot/cpu/aarch64/universalUpcallHandler_aarch64.cpp
@@ -184,9 +184,9 @@ static address generate_upcall_stub(jobject rec, const ABIDescriptor& abi,
   return blob->code_begin();
 }
 
-jlong ProgrammableUpcallHandler::generate_upcall_stub(JNIEnv *env, jobject rec, jobject jabi, jobject jlayout) {
-  const ABIDescriptor abi = parseABIDescriptor(env, jabi);
-  const BufferLayout layout = parseBufferLayout(env, jlayout);
+jlong ProgrammableUpcallHandler::generate_upcall_stub(jobject rec, jobject jabi, jobject jlayout) {
+  const ABIDescriptor abi = ForeignGlobals::parseABIDescriptor(jabi);
+  const BufferLayout layout = ForeignGlobals::parseBufferLayout(jlayout);
 
   return (jlong) ::generate_upcall_stub(rec, abi, layout);
 }
diff --git a/src/hotspot/cpu/x86/foreign_globals_x86.cpp b/src/hotspot/cpu/x86/foreign_globals_x86.cpp
index d95bb494b8fe2..706ff8fce0f7a 100644
--- a/src/hotspot/cpu/x86/foreign_globals_x86.cpp
+++ b/src/hotspot/cpu/x86/foreign_globals_x86.cpp
@@ -22,8 +22,10 @@
  */
 
 #include "precompiled.hpp"
-#include "asm/macroAssembler.hpp"
-#include CPU_HEADER(foreign_globals)
+#include "runtime/jniHandles.hpp"
+#include "runtime/jniHandles.inline.hpp"
+#include "prims/foreign_globals.hpp"
+#include "prims/foreign_globals.inline.hpp"
 
 bool ABIDescriptor::is_volatile_reg(Register reg) const {
     return _integer_argument_registers.contains(reg)
@@ -35,86 +37,52 @@ bool ABIDescriptor::is_volatile_reg(XMMRegister reg) const {
         || _vector_additional_volatile_registers.contains(reg);
 }
 
-#define FOREIGN_ABI "jdk/internal/foreign/abi/"
-
 #define INTEGER_TYPE 0
 #define VECTOR_TYPE 1
 #define X87_TYPE 2
-#define STACK_TYPE 3
-
-template
-void loadArray(JNIEnv* env, jfieldID indexField, jobjectArray jarray, jint type_index, GrowableArray& array, Func converter) {
-    jobjectArray subarray = (jobjectArray) env->GetObjectArrayElement(jarray, type_index);
-    jint subarray_length = env->GetArrayLength(subarray);
-    for (jint i = 0; i < subarray_length; i++) {
-        jobject storage = env->GetObjectArrayElement(subarray, i);
-        jint index = env->GetIntField(storage, indexField);
-        array.push(converter(index));
-    }
-}
 
-const ABIDescriptor parseABIDescriptor(JNIEnv* env, jobject jabi) {
-    jclass jc_ABIDescriptor = env->FindClass(FOREIGN_ABI "ABIDescriptor");
-    jfieldID jfID_inputStorage = env->GetFieldID(jc_ABIDescriptor, "inputStorage", "[[L" FOREIGN_ABI "VMStorage;");
-    jfieldID jfID_outputStorage = env->GetFieldID(jc_ABIDescriptor, "outputStorage", "[[L" FOREIGN_ABI "VMStorage;");
-    jfieldID jfID_volatileStorage = env->GetFieldID(jc_ABIDescriptor, "volatileStorage", "[[L" FOREIGN_ABI "VMStorage;");
-    jfieldID jfID_stackAlignment = env->GetFieldID(jc_ABIDescriptor, "stackAlignment", "I");
-    jfieldID jfID_shadowSpace = env->GetFieldID(jc_ABIDescriptor, "shadowSpace", "I");
+const ABIDescriptor ForeignGlobals::parseABIDescriptor_impl(jobject jabi) const {
+  oop abi_oop = JNIHandles::resolve_non_null(jabi);
+  ABIDescriptor abi;
 
-    jclass jc_VMStorage = env->FindClass(FOREIGN_ABI "VMStorage");
-    jfieldID jfID_storageIndex = env->GetFieldID(jc_VMStorage, "index", "I");
+  objArrayOop inputStorage = cast(abi_oop->obj_field(ABI.inputStorage_offset));
+  loadArray(inputStorage, INTEGER_TYPE, abi._integer_argument_registers, as_Register);
+  loadArray(inputStorage, VECTOR_TYPE, abi._vector_argument_registers, as_XMMRegister);
 
-    ABIDescriptor abi;
+  objArrayOop outputStorage = cast(abi_oop->obj_field(ABI.outputStorage_offset));
+  loadArray(outputStorage, INTEGER_TYPE, abi._integer_return_registers, as_Register);
+  loadArray(outputStorage, VECTOR_TYPE, abi._vector_return_registers, as_XMMRegister);
+  objArrayOop subarray = cast(outputStorage->obj_at(X87_TYPE));
+  abi._X87_return_registers_noof = subarray->length();
 
-    jobjectArray inputStorage = (jobjectArray) env->GetObjectField(jabi, jfID_inputStorage);
-    loadArray(env, jfID_storageIndex, inputStorage, INTEGER_TYPE, abi._integer_argument_registers, as_Register);
-    loadArray(env, jfID_storageIndex, inputStorage, VECTOR_TYPE, abi._vector_argument_registers, as_XMMRegister);
+  objArrayOop volatileStorage = cast(abi_oop->obj_field(ABI.volatileStorage_offset));
+  loadArray(volatileStorage, INTEGER_TYPE, abi._integer_additional_volatile_registers, as_Register);
+  loadArray(volatileStorage, VECTOR_TYPE, abi._vector_additional_volatile_registers, as_XMMRegister);
 
-    jobjectArray outputStorage = (jobjectArray) env->GetObjectField(jabi, jfID_outputStorage);
-    loadArray(env, jfID_storageIndex, outputStorage, INTEGER_TYPE, abi._integer_return_registers, as_Register);
-    loadArray(env, jfID_storageIndex, outputStorage, VECTOR_TYPE, abi._vector_return_registers, as_XMMRegister);
-    jobjectArray subarray = (jobjectArray) env->GetObjectArrayElement(outputStorage, X87_TYPE);
-    abi._X87_return_registers_noof = env->GetArrayLength(subarray);
+  abi._stack_alignment_bytes = abi_oop->int_field(ABI.stackAlignment_offset);
+  abi._shadow_space_bytes = abi_oop->int_field(ABI.shadowSpace_offset);
 
-    jobjectArray volatileStorage = (jobjectArray) env->GetObjectField(jabi, jfID_volatileStorage);
-    loadArray(env, jfID_storageIndex, volatileStorage, INTEGER_TYPE, abi._integer_additional_volatile_registers, as_Register);
-    loadArray(env, jfID_storageIndex, volatileStorage, VECTOR_TYPE, abi._vector_additional_volatile_registers, as_XMMRegister);
+  return abi;
+}
 
-    abi._stack_alignment_bytes = env->GetIntField(jabi, jfID_stackAlignment);
-    abi._shadow_space_bytes = env->GetIntField(jabi, jfID_shadowSpace);
+const BufferLayout ForeignGlobals::parseBufferLayout_impl(jobject jlayout) const {
+  oop layout_oop = JNIHandles::resolve_non_null(jlayout);
+  BufferLayout layout;
 
-    return abi;
-}
+  layout.stack_args_bytes = layout_oop->long_field(BL.stack_args_bytes_offset);
+  layout.stack_args = layout_oop->long_field(BL.stack_args_offset);
+  layout.arguments_next_pc = layout_oop->long_field(BL.arguments_next_pc_offset);
+
+  typeArrayOop input_offsets = cast(layout_oop->obj_field(BL.input_type_offsets_offset));
+  layout.arguments_integer = (size_t) input_offsets->long_at(INTEGER_TYPE);
+  layout.arguments_vector = (size_t) input_offsets->long_at(VECTOR_TYPE);
+
+  typeArrayOop output_offsets = cast(layout_oop->obj_field(BL.output_type_offsets_offset));
+  layout.returns_integer = (size_t) output_offsets->long_at(INTEGER_TYPE);
+  layout.returns_vector = (size_t) output_offsets->long_at(VECTOR_TYPE);
+  layout.returns_x87 = (size_t) output_offsets->long_at(X87_TYPE);
+
+  layout.buffer_size = layout_oop->long_field(BL.size_offset);
 
-const BufferLayout parseBufferLayout(JNIEnv* env, jobject jlayout) {
-    jclass jc_BufferLayout = env->FindClass(FOREIGN_ABI "BufferLayout");
-    jfieldID jfID_size = env->GetFieldID(jc_BufferLayout, "size", "J");
-    jfieldID jfID_arguments_next_pc = env->GetFieldID(jc_BufferLayout, "arguments_next_pc", "J");
-    jfieldID jfID_stack_args_bytes = env->GetFieldID(jc_BufferLayout, "stack_args_bytes", "J");
-    jfieldID jfID_stack_args = env->GetFieldID(jc_BufferLayout, "stack_args", "J");
-    jfieldID jfID_input_type_offsets = env->GetFieldID(jc_BufferLayout, "input_type_offsets", "[J");
-    jfieldID jfID_output_type_offsets = env->GetFieldID(jc_BufferLayout, "output_type_offsets", "[J");
-
-    BufferLayout layout;
-
-    layout.stack_args_bytes = env->GetLongField(jlayout, jfID_stack_args_bytes);
-    layout.stack_args = env->GetLongField(jlayout, jfID_stack_args);
-    layout.arguments_next_pc = env->GetLongField(jlayout, jfID_arguments_next_pc);
-
-    jlongArray input_offsets = (jlongArray) env->GetObjectField(jlayout, jfID_input_type_offsets);
-    jlong* input_offsets_prim = env->GetLongArrayElements(input_offsets, NULL);
-    layout.arguments_integer = (size_t) input_offsets_prim[INTEGER_TYPE];
-    layout.arguments_vector = (size_t) input_offsets_prim[VECTOR_TYPE];
-    env->ReleaseLongArrayElements(input_offsets, input_offsets_prim, JNI_ABORT);
-
-    jlongArray output_offsets = (jlongArray) env->GetObjectField(jlayout, jfID_output_type_offsets);
-    jlong* output_offsets_prim = env->GetLongArrayElements(output_offsets, NULL);
-    layout.returns_integer = (size_t) output_offsets_prim[INTEGER_TYPE];
-    layout.returns_vector = (size_t) output_offsets_prim[VECTOR_TYPE];
-    layout.returns_x87 = (size_t) output_offsets_prim[X87_TYPE];
-    env->ReleaseLongArrayElements(output_offsets, output_offsets_prim, JNI_ABORT);
-
-    layout.buffer_size = env->GetLongField(jlayout, jfID_size);
-
-    return layout;
+  return layout;
 }
diff --git a/src/hotspot/cpu/x86/foreign_globals_x86.hpp b/src/hotspot/cpu/x86/foreign_globals_x86.hpp
index d4bb5c3666813..daf5d71cfbf8b 100644
--- a/src/hotspot/cpu/x86/foreign_globals_x86.hpp
+++ b/src/hotspot/cpu/x86/foreign_globals_x86.hpp
@@ -21,12 +21,12 @@
  * questions.
  */
 
-#include "asm/macroAssembler.hpp"
-#include "utilities/growableArray.hpp"
-
 #ifndef CPU_X86_VM_FOREIGN_GLOBALS_X86_HPP
 #define CPU_X86_VM_FOREIGN_GLOBALS_X86_HPP
 
+#include "asm/macroAssembler.hpp"
+#include "utilities/growableArray.hpp"
+
 #define __ _masm->
 
 struct VectorRegister {
@@ -73,7 +73,4 @@ struct BufferLayout {
   size_t buffer_size;
 };
 
-const ABIDescriptor parseABIDescriptor(JNIEnv* env, jobject jabi);
-const BufferLayout parseBufferLayout(JNIEnv* env, jobject jlayout);
-
 #endif // CPU_X86_VM_FOREIGN_GLOBALS_X86_HPP
diff --git a/src/hotspot/cpu/x86/universalNativeInvoker_x86.cpp b/src/hotspot/cpu/x86/universalNativeInvoker_x86.cpp
index 1aacc620291c4..70d458b16431a 100644
--- a/src/hotspot/cpu/x86/universalNativeInvoker_x86.cpp
+++ b/src/hotspot/cpu/x86/universalNativeInvoker_x86.cpp
@@ -187,17 +187,16 @@ class ProgrammableInvokerGenerator : public StubCodeGenerator {
   }
 };
 
-jlong ProgrammableInvoker::generate_adapter(JNIEnv* env, jobject jabi, jobject jlayout) {
-    ResourceMark rm;
-    const ABIDescriptor abi = parseABIDescriptor(env, jabi);
-    const BufferLayout layout = parseBufferLayout(env, jlayout);
+jlong ProgrammableInvoker::generate_adapter(jobject jabi, jobject jlayout) {
+  const ABIDescriptor abi = ForeignGlobals::parseABIDescriptor(jabi);
+  const BufferLayout layout = ForeignGlobals::parseBufferLayout(jlayout);
 
-    BufferBlob* _invoke_native_blob = BufferBlob::create("invoke_native_blob", native_invoker_size);
+  BufferBlob* _invoke_native_blob = BufferBlob::create("invoke_native_blob", native_invoker_size);
 
-    CodeBuffer code2(_invoke_native_blob);
-    ProgrammableInvokerGenerator g2(&code2, &abi, &layout);
-    g2.generate();
-    code2.log_section_sizes("InvokeNativeBlob");
+  CodeBuffer code2(_invoke_native_blob);
+  ProgrammableInvokerGenerator g2(&code2, &abi, &layout);
+  g2.generate();
+  code2.log_section_sizes("InvokeNativeBlob");
 
-    return (jlong) _invoke_native_blob->code_begin();
+  return (jlong) _invoke_native_blob->code_begin();
 }
diff --git a/src/hotspot/cpu/x86/universalUpcallHandler_x86.cpp b/src/hotspot/cpu/x86/universalUpcallHandler_x86.cpp
index 395147c888314..87318bb927289 100644
--- a/src/hotspot/cpu/x86/universalUpcallHandler_x86.cpp
+++ b/src/hotspot/cpu/x86/universalUpcallHandler_x86.cpp
@@ -236,9 +236,9 @@ static address generate_upcall_stub(jobject rec, const ABIDescriptor& abi, const
   return blob->code_begin();
 }
 
-jlong ProgrammableUpcallHandler::generate_upcall_stub(JNIEnv *env, jobject rec, jobject jabi, jobject jlayout) {
-  const ABIDescriptor abi = parseABIDescriptor(env, jabi);
-  const BufferLayout layout = parseBufferLayout(env, jlayout);
+jlong ProgrammableUpcallHandler::generate_upcall_stub(jobject rec, jobject jabi, jobject jlayout) {
+  const ABIDescriptor abi = ForeignGlobals::parseABIDescriptor(jabi);
+  const BufferLayout layout = ForeignGlobals::parseBufferLayout(jlayout);
 
   return (jlong) ::generate_upcall_stub(rec, abi, layout);
 }
diff --git a/src/hotspot/share/prims/foreign_globals.cpp b/src/hotspot/share/prims/foreign_globals.cpp
new file mode 100644
index 0000000000000..bb9538fdd7c31
--- /dev/null
+++ b/src/hotspot/share/prims/foreign_globals.cpp
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+#include "precompiled.hpp"
+#include "foreign_globals.hpp"
+#include "classfile/symbolTable.hpp"
+#include "memory/resourceArea.hpp"
+#include "runtime/fieldDescriptor.hpp"
+
+#define FOREIGN_ABI "jdk/internal/foreign/abi/"
+
+int ForeignGlobals::field_offset(InstanceKlass* cls, const char* fieldname, Symbol* sigsym) {
+  Symbol* fieldnamesym = SymbolTable::new_symbol(fieldname, (int)strlen(fieldname));
+  fieldDescriptor fd;
+  bool success = cls->find_field(fieldnamesym, sigsym, false, &fd);
+  assert(success, "Field not found");
+  return fd.offset();
+}
+
+InstanceKlass* ForeignGlobals::find_InstanceKlass(const char* name, TRAPS) {
+  Symbol* sym = SymbolTable::new_symbol(name, (int)strlen(name));
+  Klass* k = SystemDictionary::resolve_or_null(sym, Handle(), Handle(), THREAD);
+  assert(k != nullptr, "Can not find class: %s", name);
+  return InstanceKlass::cast(k);
+}
+
+const ForeignGlobals& ForeignGlobals::instance() {
+  static ForeignGlobals globals; // thread-safe lazy init-once (since C++11)
+  return globals;
+}
+
+const ABIDescriptor ForeignGlobals::parseABIDescriptor(jobject jabi) {
+  return instance().parseABIDescriptor_impl(jabi);
+}
+const BufferLayout ForeignGlobals::parseBufferLayout(jobject jlayout) {
+  return instance().parseBufferLayout_impl(jlayout);
+}
+
+ForeignGlobals::ForeignGlobals() {
+  Thread* current_thread = Thread::current();
+  ResourceMark rm(current_thread);
+
+  // ABIDescriptor
+  InstanceKlass* k_ABI = find_InstanceKlass(FOREIGN_ABI "ABIDescriptor", current_thread);
+  const char* strVMSArray = "[[L" FOREIGN_ABI "VMStorage;";
+  Symbol* symVMSArray = SymbolTable::new_symbol(strVMSArray, (int)strlen(strVMSArray));
+  ABI.inputStorage_offset = field_offset(k_ABI, "inputStorage", symVMSArray);
+  ABI.outputStorage_offset = field_offset(k_ABI, "outputStorage", symVMSArray);
+  ABI.volatileStorage_offset = field_offset(k_ABI, "volatileStorage", symVMSArray);
+  ABI.stackAlignment_offset = field_offset(k_ABI, "stackAlignment", vmSymbols::int_signature());
+  ABI.shadowSpace_offset = field_offset(k_ABI, "shadowSpace", vmSymbols::int_signature());
+
+  // VMStorage
+  InstanceKlass* k_VMS = find_InstanceKlass(FOREIGN_ABI "VMStorage", current_thread);
+  VMS.index_offset = field_offset(k_VMS, "index", vmSymbols::int_signature());
+
+  // BufferLayout
+  InstanceKlass* k_BL = find_InstanceKlass(FOREIGN_ABI "BufferLayout", current_thread);
+  BL.size_offset = field_offset(k_BL, "size", vmSymbols::long_signature());
+  BL.arguments_next_pc_offset = field_offset(k_BL, "arguments_next_pc", vmSymbols::long_signature());
+  BL.stack_args_bytes_offset = field_offset(k_BL, "stack_args_bytes", vmSymbols::long_signature());
+  BL.stack_args_offset = field_offset(k_BL, "stack_args", vmSymbols::long_signature());
+  BL.input_type_offsets_offset = field_offset(k_BL, "input_type_offsets", vmSymbols::long_array_signature());
+  BL.output_type_offsets_offset = field_offset(k_BL, "output_type_offsets", vmSymbols::long_array_signature());
+}
diff --git a/src/hotspot/share/prims/foreign_globals.hpp b/src/hotspot/share/prims/foreign_globals.hpp
new file mode 100644
index 0000000000000..419013347dccf
--- /dev/null
+++ b/src/hotspot/share/prims/foreign_globals.hpp
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+#ifndef SHARE_PRIMS_FOREIGN_GLOBALS
+#define SHARE_PRIMS_FOREIGN_GLOBALS
+
+#include CPU_HEADER(foreign_globals)
+
+class ForeignGlobals {
+private:
+  struct {
+    int inputStorage_offset;
+    int outputStorage_offset;
+    int volatileStorage_offset;
+    int stackAlignment_offset;
+    int shadowSpace_offset;
+  } ABI;
+
+  struct {
+    int index_offset;
+  } VMS;
+
+  struct {
+    int size_offset;
+    int arguments_next_pc_offset;
+    int stack_args_bytes_offset;
+    int stack_args_offset;
+    int input_type_offsets_offset;
+    int output_type_offsets_offset;
+  } BL;
+
+  ForeignGlobals();
+
+  static const ForeignGlobals& instance();
+
+  template
+  static R cast(oop theOop);
+
+  template
+  void loadArray(objArrayOop jarray, int type_index, GrowableArray& array, Func converter) const;
+
+  int field_offset(InstanceKlass* cls, const char* fieldname, Symbol* sigsym);
+  InstanceKlass* find_InstanceKlass(const char* name, TRAPS);
+
+  const ABIDescriptor parseABIDescriptor_impl(jobject jabi) const;
+  const BufferLayout parseBufferLayout_impl(jobject jlayout) const;
+public:
+  static const ABIDescriptor parseABIDescriptor(jobject jabi);
+  static const BufferLayout parseBufferLayout(jobject jlayout);
+};
+
+#endif // SHARE_PRIMS_FOREIGN_GLOBALS
diff --git a/src/hotspot/share/prims/foreign_globals.inline.hpp b/src/hotspot/share/prims/foreign_globals.inline.hpp
new file mode 100644
index 0000000000000..1262dfab433a6
--- /dev/null
+++ b/src/hotspot/share/prims/foreign_globals.inline.hpp
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+#ifndef SHARE_PRIMS_FOREIGN_GLOBALS_INLINE_HPP
+#define SHARE_PRIMS_FOREIGN_GLOBALS_INLINE_HPP
+
+#include "precompiled.hpp"
+#include "prims/foreign_globals.hpp"
+#include "oops/oopsHierarchy.hpp"
+#include "oops/objArrayOop.hpp"
+
+template
+static bool check_type(oop theOop) {
+  static_assert(false, "No check_type specialization found for this type");
+}
+template<>
+static bool check_type(oop theOop) { return theOop->is_objArray(); }
+template<>
+static bool check_type(oop theOop) { return theOop->is_typeArray(); }
+
+template
+R ForeignGlobals::cast(oop theOop) {
+  assert(check_type(theOop), "Invalid cast");
+  return (R) theOop;
+}
+
+template
+void ForeignGlobals::loadArray(objArrayOop jarray, int type_index, GrowableArray& array, Func converter) const {
+  objArrayOop subarray = cast(jarray->obj_at(type_index));
+  int subarray_length = subarray->length();
+  for (int i = 0; i < subarray_length; i++) {
+    oop storage = subarray->obj_at(i);
+    jint index = storage->int_field(VMS.index_offset);
+    array.push(converter(index));
+  }
+}
+
+#endif // SHARE_PRIMS_FOREIGN_GLOBALS_INLINE_HPP
\ No newline at end of file
diff --git a/src/hotspot/share/prims/nativeEntryPoint.cpp b/src/hotspot/share/prims/nativeEntryPoint.cpp
index 5dad3be180b81..fd656fe1381a7 100644
--- a/src/hotspot/share/prims/nativeEntryPoint.cpp
+++ b/src/hotspot/share/prims/nativeEntryPoint.cpp
@@ -26,10 +26,8 @@
 #include "runtime/interfaceSupport.inline.hpp"
 #include "code/vmreg.hpp"
 
-JVM_ENTRY(jlong, NEP_vmStorageToVMReg(JNIEnv* env, jclass _unused, jint type, jint index)) {
-  ThreadToNativeFromVM ttnfvm(thread);
+JVM_LEAF(jlong, NEP_vmStorageToVMReg(JNIEnv* env, jclass _unused, jint type, jint index))
   return VMRegImpl::vmStorageToVMReg(type, index)->value();
-}
 JVM_END
 
 #define CC (char*)  /*cast a literal from (const char*)*/
@@ -39,13 +37,8 @@ static JNINativeMethod NEP_methods[] = {
   {CC "vmStorageToVMReg", CC "(II)J", FN_PTR(NEP_vmStorageToVMReg)},
 };
 
-JVM_ENTRY(void, JVM_RegisterNativeEntryPointMethods(JNIEnv *env, jclass NEP_class)) {
-  {
-    ThreadToNativeFromVM ttnfv(thread);
-
-    int status = env->RegisterNatives(NEP_class, NEP_methods, sizeof(NEP_methods)/sizeof(JNINativeMethod));
-    guarantee(status == JNI_OK && !env->ExceptionOccurred(),
-              "register jdk.internal.invoke.NativeEntryPoint natives");
-  }
-}
+JVM_LEAF(void, JVM_RegisterNativeEntryPointMethods(JNIEnv *env, jclass NEP_class))
+  int status = env->RegisterNatives(NEP_class, NEP_methods, sizeof(NEP_methods)/sizeof(JNINativeMethod));
+  guarantee(status == JNI_OK && !env->ExceptionOccurred(),
+            "register jdk.internal.invoke.NativeEntryPoint natives");
 JVM_END
\ No newline at end of file
diff --git a/src/hotspot/share/prims/universalNativeInvoker.cpp b/src/hotspot/share/prims/universalNativeInvoker.cpp
index bc681c999bda3..90807fceb0ce7 100644
--- a/src/hotspot/share/prims/universalNativeInvoker.cpp
+++ b/src/hotspot/share/prims/universalNativeInvoker.cpp
@@ -40,38 +40,28 @@ void ProgrammableInvoker::invoke_native(ProgrammableStub stub, address buff, Jav
   assert(thread->thread_state() == _thread_in_vm, "thread state is: %d", thread->thread_state());
 }
 
-JVM_ENTRY(void, PI_invokeNative(JNIEnv* env, jclass _unused, jlong adapter_stub, jlong buff)) {
+JVM_ENTRY(void, PI_invokeNative(JNIEnv* env, jclass _unused, jlong adapter_stub, jlong buff))
   assert(thread->thread_state() == _thread_in_vm, "thread state is: %d", thread->thread_state());
   ProgrammableStub stub = (ProgrammableStub) adapter_stub;
   address c = (address) buff;
   ProgrammableInvoker::invoke_native(stub, c, thread);
-}
 JVM_END
 
-JVM_ENTRY(jlong, PI_generateAdapter(JNIEnv* env, jclass _unused, jobject abi, jobject layout)) {
-  ThreadToNativeFromVM ttnfvm(thread);
-  return ProgrammableInvoker::generate_adapter(env, abi, layout);
-}
+JVM_ENTRY(jlong, PI_generateAdapter(JNIEnv* env, jclass _unused, jobject abi, jobject layout))
+  return ProgrammableInvoker::generate_adapter(abi, layout);
 JVM_END
 
 #define CC (char*)  /*cast a literal from (const char*)*/
 #define FN_PTR(f) CAST_FROM_FN_PTR(void*, &f)
-#define LANG "Ljava/lang/"
-
 #define FOREIGN_ABI "Ljdk/internal/foreign/abi"
 
 static JNINativeMethod PI_methods[] = {
-  {CC "invokeNative",          CC "(JJ)V",           FN_PTR(PI_invokeNative)},
-  {CC "generateAdapter",       CC "(" FOREIGN_ABI "/ABIDescriptor;" FOREIGN_ABI "/BufferLayout;" ")J",           FN_PTR(PI_generateAdapter)}
+  {CC "invokeNative",    CC "(JJ)V",                                                             FN_PTR(PI_invokeNative)   },
+  {CC "generateAdapter", CC "(" FOREIGN_ABI "/ABIDescriptor;" FOREIGN_ABI "/BufferLayout;" ")J", FN_PTR(PI_generateAdapter)}
 };
 
-JVM_ENTRY(void, JVM_RegisterProgrammableInvokerMethods(JNIEnv *env, jclass PI_class)) {
-  {
-    ThreadToNativeFromVM ttnfv(thread);
-
-    int status = env->RegisterNatives(PI_class, PI_methods, sizeof(PI_methods)/sizeof(JNINativeMethod));
-    guarantee(status == JNI_OK && !env->ExceptionOccurred(),
-              "register jdk.internal.foreign.abi.programmable.ProgrammableInvoker natives");
-  }
-}
+JVM_LEAF(void, JVM_RegisterProgrammableInvokerMethods(JNIEnv *env, jclass PI_class))
+  int status = env->RegisterNatives(PI_class, PI_methods, sizeof(PI_methods)/sizeof(JNINativeMethod));
+  guarantee(status == JNI_OK && !env->ExceptionOccurred(),
+            "register jdk.internal.foreign.abi.programmable.ProgrammableInvoker natives");
 JVM_END
diff --git a/src/hotspot/share/prims/universalNativeInvoker.hpp b/src/hotspot/share/prims/universalNativeInvoker.hpp
index e521a010ba656..3605942f8fe90 100644
--- a/src/hotspot/share/prims/universalNativeInvoker.hpp
+++ b/src/hotspot/share/prims/universalNativeInvoker.hpp
@@ -30,7 +30,7 @@
 #include "runtime/frame.inline.hpp"
 #include "runtime/globals.hpp"
 #include "utilities/macros.hpp"
-#include CPU_HEADER(foreign_globals)
+#include "prims/foreign_globals.hpp"
 
 #ifdef ZERO
 # include "entry_zero.hpp"
@@ -45,7 +45,7 @@ typedef void (*ProgrammableStub)(address);
 class ProgrammableInvoker: AllStatic {
 public:
   static void invoke_native(ProgrammableStub stub, address buff, JavaThread* thread);
-  static jlong generate_adapter(JNIEnv* env, jobject abi, jobject layout);
+  static jlong generate_adapter(jobject abi, jobject layout);
 };
 
 #endif // SHARE_VM_PRIMS_UNIVERSALNATIVEINVOKER_HPP
diff --git a/src/hotspot/share/prims/universalUpcallHandler.cpp b/src/hotspot/share/prims/universalUpcallHandler.cpp
index 5bcbbb54e432c..8057d5857d3cf 100644
--- a/src/hotspot/share/prims/universalUpcallHandler.cpp
+++ b/src/hotspot/share/prims/universalUpcallHandler.cpp
@@ -29,9 +29,7 @@
 JVM_ENTRY(jlong, PUH_AllocateUpcallStub(JNIEnv *env, jobject rec, jobject abi, jobject buffer_layout))
   Handle receiver(THREAD, JNIHandles::resolve(rec));
   jobject global_rec = JNIHandles::make_global(receiver);
-  ThreadToNativeFromVM ttnfvm(thread);
-
-  return ProgrammableUpcallHandler::generate_upcall_stub(env, global_rec, abi, buffer_layout);
+  return ProgrammableUpcallHandler::generate_upcall_stub(global_rec, abi, buffer_layout);
 JVM_END
 
 #define CC (char*)  /*cast a literal from (const char*)*/
@@ -47,13 +45,8 @@ static JNINativeMethod PUH_methods[] = {
 /**
  * This one function is exported, used by NativeLookup.
  */
-JVM_ENTRY(void, JVM_RegisterProgrammableUpcallHandlerMethods(JNIEnv *env, jclass PUH_class)) {
-  {
-    ThreadToNativeFromVM ttnfv(thread);
-
-    int status = env->RegisterNatives(PUH_class, PUH_methods, sizeof(PUH_methods)/sizeof(JNINativeMethod));
-    guarantee(status == JNI_OK && !env->ExceptionOccurred(),
-              "register jdk.internal.foreign.abi.ProgrammableUpcallHandler natives");
-  }
-}
+JVM_LEAF(void, JVM_RegisterProgrammableUpcallHandlerMethods(JNIEnv *env, jclass PUH_class))
+  int status = env->RegisterNatives(PUH_class, PUH_methods, sizeof(PUH_methods)/sizeof(JNINativeMethod));
+  guarantee(status == JNI_OK && !env->ExceptionOccurred(),
+            "register jdk.internal.foreign.abi.ProgrammableUpcallHandler natives");
 JVM_END
diff --git a/src/hotspot/share/prims/universalUpcallHandler.hpp b/src/hotspot/share/prims/universalUpcallHandler.hpp
index 1b223aa0cd8b4..997041a2580c7 100644
--- a/src/hotspot/share/prims/universalUpcallHandler.hpp
+++ b/src/hotspot/share/prims/universalUpcallHandler.hpp
@@ -30,11 +30,11 @@
 #include "runtime/frame.inline.hpp"
 #include "runtime/globals.hpp"
 #include "utilities/macros.hpp"
-#include CPU_HEADER(foreign_globals)
+#include "prims/foreign_globals.hpp"
 
 class ProgrammableUpcallHandler : AllStatic {
 public:
-  static jlong generate_upcall_stub(JNIEnv *env, jobject rec, jobject abi, jobject buffer_layout);
+  static jlong generate_upcall_stub(jobject rec, jobject abi, jobject buffer_layout);
 };
 
 #endif // SHARE_VM_PRIMS_UNIVERSALUPCALLHANDLER_HPP
diff --git a/src/hotspot/share/prims/upcallStubs.cpp b/src/hotspot/share/prims/upcallStubs.cpp
index 5763986ba099a..f1cbec34f2c4e 100644
--- a/src/hotspot/share/prims/upcallStubs.cpp
+++ b/src/hotspot/share/prims/upcallStubs.cpp
@@ -54,14 +54,9 @@ static JNINativeMethod UH_methods[] = {
 /**
  * This one function is exported, used by NativeLookup.
  */
-JVM_ENTRY(void, JVM_RegisterUpcallHandlerMethods(JNIEnv *env, jclass UH_class)) {
-  {
-    ThreadToNativeFromVM ttnfv(thread);
-
-    int status = env->RegisterNatives(UH_class, UH_methods, sizeof(UH_methods)/sizeof(JNINativeMethod));
-    guarantee(status == JNI_OK && !env->ExceptionOccurred(),
-              "register jdk.internal.foreign.abi.UpcallStubs natives");
-  }
-}
+JVM_LEAF(void, JVM_RegisterUpcallHandlerMethods(JNIEnv *env, jclass UH_class))
+  int status = env->RegisterNatives(UH_class, UH_methods, sizeof(UH_methods)/sizeof(JNINativeMethod));
+  guarantee(status == JNI_OK && !env->ExceptionOccurred(),
+            "register jdk.internal.foreign.abi.UpcallStubs natives");
 JVM_END
 

From e543231ff5cc2cd24823a281b66418103901c5ef Mon Sep 17 00:00:00 2001
From: Jorn Vernee 
Date: Thu, 22 Oct 2020 12:06:32 +0200
Subject: [PATCH 25/70] Review comments: - Use TempNewSymbol - JVM_* -> JNI_* -
 rename parseXX -> parse_x_x - remove ref to global function using '::' - make
 2 functions static, instead of ForeignGlobals class members

---
 .../cpu/aarch64/foreign_globals_aarch64.cpp      |  4 ++--
 .../aarch64/universalNativeInvoker_aarch64.cpp   |  4 ++--
 .../aarch64/universalUpcallHandler_aarch64.cpp   | 13 ++++---------
 src/hotspot/cpu/x86/foreign_globals_x86.cpp      |  4 ++--
 .../cpu/x86/universalNativeInvoker_x86.cpp       |  4 ++--
 .../cpu/x86/universalUpcallHandler_x86.cpp       | 12 ++++--------
 src/hotspot/share/prims/foreign_globals.cpp      | 16 ++++++++--------
 src/hotspot/share/prims/foreign_globals.hpp      | 11 ++++-------
 src/hotspot/share/prims/nativeEntryPoint.cpp     |  8 ++++----
 .../share/prims/universalNativeInvoker.cpp       | 12 ++++++------
 .../share/prims/universalUpcallHandler.cpp       | 10 +++++-----
 .../share/prims/universalUpcallHandler.hpp       |  2 +-
 12 files changed, 44 insertions(+), 56 deletions(-)

diff --git a/src/hotspot/cpu/aarch64/foreign_globals_aarch64.cpp b/src/hotspot/cpu/aarch64/foreign_globals_aarch64.cpp
index 4e741d7eab85d..ab04c3a490cdd 100644
--- a/src/hotspot/cpu/aarch64/foreign_globals_aarch64.cpp
+++ b/src/hotspot/cpu/aarch64/foreign_globals_aarch64.cpp
@@ -41,7 +41,7 @@ bool ABIDescriptor::is_volatile_reg(FloatRegister reg) const {
 #define INTEGER_TYPE 0
 #define VECTOR_TYPE 1
 
-const ABIDescriptor ForeignGlobals::parseABIDescriptor_impl(jobject jabi) const {
+const ABIDescriptor ForeignGlobals::parse_abi_descriptor_impl(jobject jabi) const {
   oop abi_oop = JNIHandles::resolve_non_null(jabi);
   ABIDescriptor abi;
 
@@ -63,7 +63,7 @@ const ABIDescriptor ForeignGlobals::parseABIDescriptor_impl(jobject jabi) const
   return abi;
 }
 
-const BufferLayout ForeignGlobals::parseBufferLayout_impl(jobject jlayout) const {
+const BufferLayout ForeignGlobals::parse_buffer_layout_impl(jobject jlayout) const {
   oop layout_oop = JNIHandles::resolve_non_null(jlayout);
   BufferLayout layout;
 
diff --git a/src/hotspot/cpu/aarch64/universalNativeInvoker_aarch64.cpp b/src/hotspot/cpu/aarch64/universalNativeInvoker_aarch64.cpp
index eb6967a40bb75..1ebcbef830b27 100644
--- a/src/hotspot/cpu/aarch64/universalNativeInvoker_aarch64.cpp
+++ b/src/hotspot/cpu/aarch64/universalNativeInvoker_aarch64.cpp
@@ -150,8 +150,8 @@ class ProgrammableInvokerGenerator : public StubCodeGenerator {
 };
 
 jlong ProgrammableInvoker::generate_adapter(jobject jabi, jobject jlayout) {
-  const ABIDescriptor abi = ForeignGlobals::parseABIDescriptor(jabi);
-  const BufferLayout layout = ForeignGlobals::parseBufferLayout(jlayout);
+  const ABIDescriptor abi = ForeignGlobals::parse_abi_descriptor(jabi);
+  const BufferLayout layout = ForeignGlobals::parse_buffer_layout(jlayout);
 
   BufferBlob* _invoke_native_blob = BufferBlob::create("invoke_native_blob", native_invoker_size);
 
diff --git a/src/hotspot/cpu/aarch64/universalUpcallHandler_aarch64.cpp b/src/hotspot/cpu/aarch64/universalUpcallHandler_aarch64.cpp
index 17b5255357952..b813a71908a85 100644
--- a/src/hotspot/cpu/aarch64/universalUpcallHandler_aarch64.cpp
+++ b/src/hotspot/cpu/aarch64/universalUpcallHandler_aarch64.cpp
@@ -120,8 +120,10 @@ static void upcall_helper(jobject rec, address buff) {
                          &args, thread);
 }
 
-static address generate_upcall_stub(jobject rec, const ABIDescriptor& abi,
-                                    const BufferLayout& layout) {
+addres ProgrammableUpcallHandler::generate_upcall_stub(jobject rec, jobject jabi, jobject jlayout) {
+  const ABIDescriptor abi = ForeignGlobals::parse_abi_descriptor(jabi);
+  const BufferLayout layout = ForeignGlobals::parse_buffer_layout(jlayout);
+
   ResourceMark rm;
   CodeBuffer buffer("upcall_stub", 1024, upcall_stub_size);
 
@@ -183,10 +185,3 @@ static address generate_upcall_stub(jobject rec, const ABIDescriptor& abi,
 
   return blob->code_begin();
 }
-
-jlong ProgrammableUpcallHandler::generate_upcall_stub(jobject rec, jobject jabi, jobject jlayout) {
-  const ABIDescriptor abi = ForeignGlobals::parseABIDescriptor(jabi);
-  const BufferLayout layout = ForeignGlobals::parseBufferLayout(jlayout);
-
-  return (jlong) ::generate_upcall_stub(rec, abi, layout);
-}
diff --git a/src/hotspot/cpu/x86/foreign_globals_x86.cpp b/src/hotspot/cpu/x86/foreign_globals_x86.cpp
index 706ff8fce0f7a..20fa4d08f9d13 100644
--- a/src/hotspot/cpu/x86/foreign_globals_x86.cpp
+++ b/src/hotspot/cpu/x86/foreign_globals_x86.cpp
@@ -41,7 +41,7 @@ bool ABIDescriptor::is_volatile_reg(XMMRegister reg) const {
 #define VECTOR_TYPE 1
 #define X87_TYPE 2
 
-const ABIDescriptor ForeignGlobals::parseABIDescriptor_impl(jobject jabi) const {
+const ABIDescriptor ForeignGlobals::parse_abi_descriptor_impl(jobject jabi) const {
   oop abi_oop = JNIHandles::resolve_non_null(jabi);
   ABIDescriptor abi;
 
@@ -65,7 +65,7 @@ const ABIDescriptor ForeignGlobals::parseABIDescriptor_impl(jobject jabi) const
   return abi;
 }
 
-const BufferLayout ForeignGlobals::parseBufferLayout_impl(jobject jlayout) const {
+const BufferLayout ForeignGlobals::parse_buffer_layout_impl(jobject jlayout) const {
   oop layout_oop = JNIHandles::resolve_non_null(jlayout);
   BufferLayout layout;
 
diff --git a/src/hotspot/cpu/x86/universalNativeInvoker_x86.cpp b/src/hotspot/cpu/x86/universalNativeInvoker_x86.cpp
index 70d458b16431a..558e81c92e4d8 100644
--- a/src/hotspot/cpu/x86/universalNativeInvoker_x86.cpp
+++ b/src/hotspot/cpu/x86/universalNativeInvoker_x86.cpp
@@ -188,8 +188,8 @@ class ProgrammableInvokerGenerator : public StubCodeGenerator {
 };
 
 jlong ProgrammableInvoker::generate_adapter(jobject jabi, jobject jlayout) {
-  const ABIDescriptor abi = ForeignGlobals::parseABIDescriptor(jabi);
-  const BufferLayout layout = ForeignGlobals::parseBufferLayout(jlayout);
+  const ABIDescriptor abi = ForeignGlobals::parse_abi_descriptor(jabi);
+  const BufferLayout layout = ForeignGlobals::parse_buffer_layout(jlayout);
 
   BufferBlob* _invoke_native_blob = BufferBlob::create("invoke_native_blob", native_invoker_size);
 
diff --git a/src/hotspot/cpu/x86/universalUpcallHandler_x86.cpp b/src/hotspot/cpu/x86/universalUpcallHandler_x86.cpp
index 87318bb927289..92186eefe0731 100644
--- a/src/hotspot/cpu/x86/universalUpcallHandler_x86.cpp
+++ b/src/hotspot/cpu/x86/universalUpcallHandler_x86.cpp
@@ -119,7 +119,10 @@ static void upcall_helper(jobject rec, address buff) {
   JavaCalls::call_static(&result, upcall_info.upcall_method.klass, upcall_info.upcall_method.name, upcall_info.upcall_method.sig, &args, thread);
 }
 
-static address generate_upcall_stub(jobject rec, const ABIDescriptor& abi, const BufferLayout& layout) {
+address ProgrammableUpcallHandler::generate_upcall_stub(jobject rec, jobject jabi, jobject jlayout) {
+  const ABIDescriptor abi = ForeignGlobals::parse_abi_descriptor(jabi);
+  const BufferLayout layout = ForeignGlobals::parse_buffer_layout(jlayout);
+
   ResourceMark rm;
   CodeBuffer buffer("upcall_stub", 1024, upcall_stub_size);
 
@@ -235,10 +238,3 @@ static address generate_upcall_stub(jobject rec, const ABIDescriptor& abi, const
 
   return blob->code_begin();
 }
-
-jlong ProgrammableUpcallHandler::generate_upcall_stub(jobject rec, jobject jabi, jobject jlayout) {
-  const ABIDescriptor abi = ForeignGlobals::parseABIDescriptor(jabi);
-  const BufferLayout layout = ForeignGlobals::parseBufferLayout(jlayout);
-
-  return (jlong) ::generate_upcall_stub(rec, abi, layout);
-}
diff --git a/src/hotspot/share/prims/foreign_globals.cpp b/src/hotspot/share/prims/foreign_globals.cpp
index bb9538fdd7c31..3e7be1737bb86 100644
--- a/src/hotspot/share/prims/foreign_globals.cpp
+++ b/src/hotspot/share/prims/foreign_globals.cpp
@@ -29,16 +29,16 @@
 
 #define FOREIGN_ABI "jdk/internal/foreign/abi/"
 
-int ForeignGlobals::field_offset(InstanceKlass* cls, const char* fieldname, Symbol* sigsym) {
-  Symbol* fieldnamesym = SymbolTable::new_symbol(fieldname, (int)strlen(fieldname));
+static int field_offset(InstanceKlass* cls, const char* fieldname, Symbol* sigsym) {
+  TempNewSymbol fieldnamesym = SymbolTable::new_symbol(fieldname, (int)strlen(fieldname));
   fieldDescriptor fd;
   bool success = cls->find_field(fieldnamesym, sigsym, false, &fd);
   assert(success, "Field not found");
   return fd.offset();
 }
 
-InstanceKlass* ForeignGlobals::find_InstanceKlass(const char* name, TRAPS) {
-  Symbol* sym = SymbolTable::new_symbol(name, (int)strlen(name));
+static InstanceKlass* find_InstanceKlass(const char* name, TRAPS) {
+  TempNewSymbol sym = SymbolTable::new_symbol(name, (int)strlen(name));
   Klass* k = SystemDictionary::resolve_or_null(sym, Handle(), Handle(), THREAD);
   assert(k != nullptr, "Can not find class: %s", name);
   return InstanceKlass::cast(k);
@@ -49,11 +49,11 @@ const ForeignGlobals& ForeignGlobals::instance() {
   return globals;
 }
 
-const ABIDescriptor ForeignGlobals::parseABIDescriptor(jobject jabi) {
-  return instance().parseABIDescriptor_impl(jabi);
+const ABIDescriptor ForeignGlobals::parse_abi_descriptor(jobject jabi) {
+  return instance().parse_abi_descriptor_impl(jabi);
 }
-const BufferLayout ForeignGlobals::parseBufferLayout(jobject jlayout) {
-  return instance().parseBufferLayout_impl(jlayout);
+const BufferLayout ForeignGlobals::parse_buffer_layout(jobject jlayout) {
+  return instance().parse_buffer_layout_impl(jlayout);
 }
 
 ForeignGlobals::ForeignGlobals() {
diff --git a/src/hotspot/share/prims/foreign_globals.hpp b/src/hotspot/share/prims/foreign_globals.hpp
index 419013347dccf..eed5c8038adbc 100644
--- a/src/hotspot/share/prims/foreign_globals.hpp
+++ b/src/hotspot/share/prims/foreign_globals.hpp
@@ -59,14 +59,11 @@ class ForeignGlobals {
   template
   void loadArray(objArrayOop jarray, int type_index, GrowableArray& array, Func converter) const;
 
-  int field_offset(InstanceKlass* cls, const char* fieldname, Symbol* sigsym);
-  InstanceKlass* find_InstanceKlass(const char* name, TRAPS);
-
-  const ABIDescriptor parseABIDescriptor_impl(jobject jabi) const;
-  const BufferLayout parseBufferLayout_impl(jobject jlayout) const;
+  const ABIDescriptor parse_abi_descriptor_impl(jobject jabi) const;
+  const BufferLayout parse_buffer_layout_impl(jobject jlayout) const;
 public:
-  static const ABIDescriptor parseABIDescriptor(jobject jabi);
-  static const BufferLayout parseBufferLayout(jobject jlayout);
+  static const ABIDescriptor parse_abi_descriptor(jobject jabi);
+  static const BufferLayout parse_buffer_layout(jobject jlayout);
 };
 
 #endif // SHARE_PRIMS_FOREIGN_GLOBALS
diff --git a/src/hotspot/share/prims/nativeEntryPoint.cpp b/src/hotspot/share/prims/nativeEntryPoint.cpp
index fd656fe1381a7..2ec76da7290d0 100644
--- a/src/hotspot/share/prims/nativeEntryPoint.cpp
+++ b/src/hotspot/share/prims/nativeEntryPoint.cpp
@@ -26,9 +26,9 @@
 #include "runtime/interfaceSupport.inline.hpp"
 #include "code/vmreg.hpp"
 
-JVM_LEAF(jlong, NEP_vmStorageToVMReg(JNIEnv* env, jclass _unused, jint type, jint index))
+JNI_LEAF(jlong, NEP_vmStorageToVMReg(JNIEnv* env, jclass _unused, jint type, jint index))
   return VMRegImpl::vmStorageToVMReg(type, index)->value();
-JVM_END
+JNI_END
 
 #define CC (char*)  /*cast a literal from (const char*)*/
 #define FN_PTR(f) CAST_FROM_FN_PTR(void*, &f)
@@ -37,8 +37,8 @@ static JNINativeMethod NEP_methods[] = {
   {CC "vmStorageToVMReg", CC "(II)J", FN_PTR(NEP_vmStorageToVMReg)},
 };
 
-JVM_LEAF(void, JVM_RegisterNativeEntryPointMethods(JNIEnv *env, jclass NEP_class))
+JNI_LEAF(void, JVM_RegisterNativeEntryPointMethods(JNIEnv *env, jclass NEP_class))
   int status = env->RegisterNatives(NEP_class, NEP_methods, sizeof(NEP_methods)/sizeof(JNINativeMethod));
   guarantee(status == JNI_OK && !env->ExceptionOccurred(),
             "register jdk.internal.invoke.NativeEntryPoint natives");
-JVM_END
\ No newline at end of file
+JNI_END
\ No newline at end of file
diff --git a/src/hotspot/share/prims/universalNativeInvoker.cpp b/src/hotspot/share/prims/universalNativeInvoker.cpp
index 90807fceb0ce7..a5b789283827f 100644
--- a/src/hotspot/share/prims/universalNativeInvoker.cpp
+++ b/src/hotspot/share/prims/universalNativeInvoker.cpp
@@ -40,16 +40,16 @@ void ProgrammableInvoker::invoke_native(ProgrammableStub stub, address buff, Jav
   assert(thread->thread_state() == _thread_in_vm, "thread state is: %d", thread->thread_state());
 }
 
-JVM_ENTRY(void, PI_invokeNative(JNIEnv* env, jclass _unused, jlong adapter_stub, jlong buff))
+JNI_ENTRY(void, PI_invokeNative(JNIEnv* env, jclass _unused, jlong adapter_stub, jlong buff))
   assert(thread->thread_state() == _thread_in_vm, "thread state is: %d", thread->thread_state());
   ProgrammableStub stub = (ProgrammableStub) adapter_stub;
   address c = (address) buff;
   ProgrammableInvoker::invoke_native(stub, c, thread);
-JVM_END
+JNI_END
 
-JVM_ENTRY(jlong, PI_generateAdapter(JNIEnv* env, jclass _unused, jobject abi, jobject layout))
+JNI_ENTRY(jlong, PI_generateAdapter(JNIEnv* env, jclass _unused, jobject abi, jobject layout))
   return ProgrammableInvoker::generate_adapter(abi, layout);
-JVM_END
+JNI_END
 
 #define CC (char*)  /*cast a literal from (const char*)*/
 #define FN_PTR(f) CAST_FROM_FN_PTR(void*, &f)
@@ -60,8 +60,8 @@ static JNINativeMethod PI_methods[] = {
   {CC "generateAdapter", CC "(" FOREIGN_ABI "/ABIDescriptor;" FOREIGN_ABI "/BufferLayout;" ")J", FN_PTR(PI_generateAdapter)}
 };
 
-JVM_LEAF(void, JVM_RegisterProgrammableInvokerMethods(JNIEnv *env, jclass PI_class))
+JNI_LEAF(void, JVM_RegisterProgrammableInvokerMethods(JNIEnv *env, jclass PI_class))
   int status = env->RegisterNatives(PI_class, PI_methods, sizeof(PI_methods)/sizeof(JNINativeMethod));
   guarantee(status == JNI_OK && !env->ExceptionOccurred(),
             "register jdk.internal.foreign.abi.programmable.ProgrammableInvoker natives");
-JVM_END
+JNI_END
diff --git a/src/hotspot/share/prims/universalUpcallHandler.cpp b/src/hotspot/share/prims/universalUpcallHandler.cpp
index 8057d5857d3cf..a829b12805481 100644
--- a/src/hotspot/share/prims/universalUpcallHandler.cpp
+++ b/src/hotspot/share/prims/universalUpcallHandler.cpp
@@ -26,11 +26,11 @@
 #include "runtime/jniHandles.inline.hpp"
 #include "runtime/interfaceSupport.inline.hpp"
 
-JVM_ENTRY(jlong, PUH_AllocateUpcallStub(JNIEnv *env, jobject rec, jobject abi, jobject buffer_layout))
+JNI_ENTRY(jlong, PUH_AllocateUpcallStub(JNIEnv *env, jobject rec, jobject abi, jobject buffer_layout))
   Handle receiver(THREAD, JNIHandles::resolve(rec));
   jobject global_rec = JNIHandles::make_global(receiver);
-  return ProgrammableUpcallHandler::generate_upcall_stub(global_rec, abi, buffer_layout);
-JVM_END
+  return (jlong) ProgrammableUpcallHandler::generate_upcall_stub(global_rec, abi, buffer_layout);
+JNI_END
 
 #define CC (char*)  /*cast a literal from (const char*)*/
 #define FN_PTR(f) CAST_FROM_FN_PTR(void*, &f)
@@ -45,8 +45,8 @@ static JNINativeMethod PUH_methods[] = {
 /**
  * This one function is exported, used by NativeLookup.
  */
-JVM_LEAF(void, JVM_RegisterProgrammableUpcallHandlerMethods(JNIEnv *env, jclass PUH_class))
+JNI_LEAF(void, JVM_RegisterProgrammableUpcallHandlerMethods(JNIEnv *env, jclass PUH_class))
   int status = env->RegisterNatives(PUH_class, PUH_methods, sizeof(PUH_methods)/sizeof(JNINativeMethod));
   guarantee(status == JNI_OK && !env->ExceptionOccurred(),
             "register jdk.internal.foreign.abi.ProgrammableUpcallHandler natives");
-JVM_END
+JNI_END
diff --git a/src/hotspot/share/prims/universalUpcallHandler.hpp b/src/hotspot/share/prims/universalUpcallHandler.hpp
index 997041a2580c7..c56c44efef9c4 100644
--- a/src/hotspot/share/prims/universalUpcallHandler.hpp
+++ b/src/hotspot/share/prims/universalUpcallHandler.hpp
@@ -34,7 +34,7 @@
 
 class ProgrammableUpcallHandler : AllStatic {
 public:
-  static jlong generate_upcall_stub(jobject rec, jobject abi, jobject buffer_layout);
+  static address generate_upcall_stub(jobject rec, jobject abi, jobject buffer_layout);
 };
 
 #endif // SHARE_VM_PRIMS_UNIVERSALUPCALLHANDLER_HPP

From 87a55e28b2a075819ffbce5f4916af33e880b41b Mon Sep 17 00:00:00 2001
From: Maurizio Cimadamore 
Date: Thu, 22 Oct 2020 12:17:35 +0100
Subject: [PATCH 26/70] Fix build issues caused by recent refactorings

---
 .../cpu/aarch64/foreign_globals_aarch64.cpp      |  1 +
 src/hotspot/cpu/x86/foreign_globals_x86.cpp      |  1 +
 src/hotspot/share/opto/compile.cpp               |  2 +-
 src/hotspot/share/prims/foreign_globals.cpp      |  2 ++
 src/hotspot/share/prims/foreign_globals.hpp      |  2 ++
 .../share/prims/foreign_globals.inline.hpp       |  7 ++++---
 .../java/lang/invoke/NativeMethodHandle.java     | 16 ++++++++++------
 7 files changed, 21 insertions(+), 10 deletions(-)

diff --git a/src/hotspot/cpu/aarch64/foreign_globals_aarch64.cpp b/src/hotspot/cpu/aarch64/foreign_globals_aarch64.cpp
index 4e741d7eab85d..826b9dbb60116 100644
--- a/src/hotspot/cpu/aarch64/foreign_globals_aarch64.cpp
+++ b/src/hotspot/cpu/aarch64/foreign_globals_aarch64.cpp
@@ -25,6 +25,7 @@
 #include "precompiled.hpp"
 #include "runtime/jniHandles.hpp"
 #include "runtime/jniHandles.inline.hpp"
+#include "oops/typeArrayOop.inline.hpp"
 #include "prims/foreign_globals.hpp"
 #include "prims/foreign_globals.inline.hpp"
 
diff --git a/src/hotspot/cpu/x86/foreign_globals_x86.cpp b/src/hotspot/cpu/x86/foreign_globals_x86.cpp
index 706ff8fce0f7a..90131e03fcf50 100644
--- a/src/hotspot/cpu/x86/foreign_globals_x86.cpp
+++ b/src/hotspot/cpu/x86/foreign_globals_x86.cpp
@@ -24,6 +24,7 @@
 #include "precompiled.hpp"
 #include "runtime/jniHandles.hpp"
 #include "runtime/jniHandles.inline.hpp"
+#include "oops/typeArrayOop.inline.hpp"
 #include "prims/foreign_globals.hpp"
 #include "prims/foreign_globals.inline.hpp"
 
diff --git a/src/hotspot/share/opto/compile.cpp b/src/hotspot/share/opto/compile.cpp
index eb0611bfe7655..46e1de8e5216e 100644
--- a/src/hotspot/share/opto/compile.cpp
+++ b/src/hotspot/share/opto/compile.cpp
@@ -833,7 +833,7 @@ Compile::Compile( ciEnv* ci_env,
     _for_igvn(NULL),
     _warm_calls(NULL),
     _number_of_mh_late_inlines(0),
-    _native_stubs(NULL),
+    _native_stubs(),
     _print_inlining_stream(NULL),
     _print_inlining_list(NULL),
     _print_inlining_idx(0),
diff --git a/src/hotspot/share/prims/foreign_globals.cpp b/src/hotspot/share/prims/foreign_globals.cpp
index bb9538fdd7c31..a5856932b56cc 100644
--- a/src/hotspot/share/prims/foreign_globals.cpp
+++ b/src/hotspot/share/prims/foreign_globals.cpp
@@ -24,8 +24,10 @@
 #include "precompiled.hpp"
 #include "foreign_globals.hpp"
 #include "classfile/symbolTable.hpp"
+#include "classfile/systemDictionary.hpp"
 #include "memory/resourceArea.hpp"
 #include "runtime/fieldDescriptor.hpp"
+#include "runtime/fieldDescriptor.inline.hpp"
 
 #define FOREIGN_ABI "jdk/internal/foreign/abi/"
 
diff --git a/src/hotspot/share/prims/foreign_globals.hpp b/src/hotspot/share/prims/foreign_globals.hpp
index 419013347dccf..fc4893499d1c0 100644
--- a/src/hotspot/share/prims/foreign_globals.hpp
+++ b/src/hotspot/share/prims/foreign_globals.hpp
@@ -24,6 +24,8 @@
 #ifndef SHARE_PRIMS_FOREIGN_GLOBALS
 #define SHARE_PRIMS_FOREIGN_GLOBALS
 
+#include "utilities/macros.hpp"
+
 #include CPU_HEADER(foreign_globals)
 
 class ForeignGlobals {
diff --git a/src/hotspot/share/prims/foreign_globals.inline.hpp b/src/hotspot/share/prims/foreign_globals.inline.hpp
index 1262dfab433a6..39c7de69895e6 100644
--- a/src/hotspot/share/prims/foreign_globals.inline.hpp
+++ b/src/hotspot/share/prims/foreign_globals.inline.hpp
@@ -31,12 +31,13 @@
 
 template
 static bool check_type(oop theOop) {
-  static_assert(false, "No check_type specialization found for this type");
+  static_assert(sizeof(T) == 0, "No check_type specialization found for this type");
+  return false;
 }
 template<>
-static bool check_type(oop theOop) { return theOop->is_objArray(); }
+inline bool check_type(oop theOop) { return theOop->is_objArray(); }
 template<>
-static bool check_type(oop theOop) { return theOop->is_typeArray(); }
+inline bool check_type(oop theOop) { return theOop->is_typeArray(); }
 
 template
 R ForeignGlobals::cast(oop theOop) {
diff --git a/src/java.base/share/classes/java/lang/invoke/NativeMethodHandle.java b/src/java.base/share/classes/java/lang/invoke/NativeMethodHandle.java
index e130b5c3c9538..46c7cd84c34df 100644
--- a/src/java.base/share/classes/java/lang/invoke/NativeMethodHandle.java
+++ b/src/java.base/share/classes/java/lang/invoke/NativeMethodHandle.java
@@ -33,21 +33,25 @@
 import static java.lang.invoke.MethodHandleNatives.Constants.REF_invokeStatic;
 import static java.lang.invoke.MethodHandleStatics.newInternalError;
 
-/** TODO */
+/**
+ * This class models a method handle to a native function. A native method handle is made up of a {@link NativeEntryPoint},
+ * which is used to capture the characteristics of the native call (such as calling convention to be used,
+ * or whether a native transition is required) and a fallback method handle, which can be used
+ * when intrinsification of this method handle is not possible.
+ */
 /*non-public*/ class NativeMethodHandle extends MethodHandle {
     final NativeEntryPoint nep;
     final MethodHandle fallback;
 
-    /**
-     * TODO
-     */
     private NativeMethodHandle(MethodType type, LambdaForm form, MethodHandle fallback, NativeEntryPoint nep) {
         super(type, form);
         this.fallback = fallback;
         this.nep = nep;
     }
 
-    /** TODO */
+    /**
+     * Creates a new native method handle with given {@link NativeEntryPoint} and fallback method handle.
+     */
     public static MethodHandle make(NativeEntryPoint nep, MethodHandle fallback) {
         MethodType type = nep.type();
         if (!allTypesPrimitive(type))
@@ -142,7 +146,6 @@ static MethodHandle internalFallback(Object mh) {
      * Factored in an inner class to delay initialization until first usage.
      */
     private static class Lazy {
-        static Class THIS_CLASS = NativeMethodHandle.class;
 
         static final NamedFunction
                 NF_internalNativeEntryPoint;
@@ -151,6 +154,7 @@ private static class Lazy {
 
         static {
             try {
+                Class THIS_CLASS = NativeMethodHandle.class;
                 NamedFunction[] nfs = new NamedFunction[]{
                         NF_internalNativeEntryPoint = new NamedFunction(
                                 THIS_CLASS.getDeclaredMethod("internalNativeEntryPoint", Object.class)),

From dd202886b22c664e7a772220d26e6e6b0a95dc5b Mon Sep 17 00:00:00 2001
From: Maurizio Cimadamore 
Date: Thu, 22 Oct 2020 12:50:56 +0100
Subject: [PATCH 27/70] Remove spurious include

---
 src/hotspot/share/prims/foreign_globals.inline.hpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/hotspot/share/prims/foreign_globals.inline.hpp b/src/hotspot/share/prims/foreign_globals.inline.hpp
index 39c7de69895e6..7db15f6555a1d 100644
--- a/src/hotspot/share/prims/foreign_globals.inline.hpp
+++ b/src/hotspot/share/prims/foreign_globals.inline.hpp
@@ -24,7 +24,6 @@
 #ifndef SHARE_PRIMS_FOREIGN_GLOBALS_INLINE_HPP
 #define SHARE_PRIMS_FOREIGN_GLOBALS_INLINE_HPP
 
-#include "precompiled.hpp"
 #include "prims/foreign_globals.hpp"
 #include "oops/oopsHierarchy.hpp"
 #include "oops/objArrayOop.hpp"

From 03dbb52c85f14ebef75c10bae5a54874854192ec Mon Sep 17 00:00:00 2001
From: Maurizio Cimadamore 
Date: Thu, 22 Oct 2020 13:02:34 +0100
Subject: [PATCH 28/70] Fix aarch issues

---
 src/hotspot/os_cpu/bsd_x86/thread_bsd_x86.hpp         | 4 ++++
 src/hotspot/os_cpu/linux_x86/thread_linux_x86.hpp     | 4 ++++
 src/hotspot/os_cpu/windows_x86/thread_windows_x86.hpp | 4 ++++
 src/hotspot/share/runtime/thread.hpp                  | 3 ---
 4 files changed, 12 insertions(+), 3 deletions(-)

diff --git a/src/hotspot/os_cpu/bsd_x86/thread_bsd_x86.hpp b/src/hotspot/os_cpu/bsd_x86/thread_bsd_x86.hpp
index 6f4e42e14ff86..76a18fb6cdaeb 100644
--- a/src/hotspot/os_cpu/bsd_x86/thread_bsd_x86.hpp
+++ b/src/hotspot/os_cpu/bsd_x86/thread_bsd_x86.hpp
@@ -37,6 +37,10 @@
     return byte_offset_of(JavaThread, _anchor) + JavaFrameAnchor::last_Java_fp_offset();
   }
 
+  static ByteSize saved_rbp_address_offset() {
+    return byte_offset_of(JavaThread, _anchor) + JavaFrameAnchor::saved_rbp_address_offset();
+  }
+
   bool pd_get_top_frame_for_signal_handler(frame* fr_addr, void* ucontext,
     bool isInJava);
 
diff --git a/src/hotspot/os_cpu/linux_x86/thread_linux_x86.hpp b/src/hotspot/os_cpu/linux_x86/thread_linux_x86.hpp
index 574edc79831be..1b02aadc52570 100644
--- a/src/hotspot/os_cpu/linux_x86/thread_linux_x86.hpp
+++ b/src/hotspot/os_cpu/linux_x86/thread_linux_x86.hpp
@@ -37,6 +37,10 @@
     return byte_offset_of(JavaThread, _anchor) + JavaFrameAnchor::last_Java_fp_offset();
   }
 
+  static ByteSize saved_rbp_address_offset() {
+    return byte_offset_of(JavaThread, _anchor) + JavaFrameAnchor::saved_rbp_address_offset();
+  }
+
   bool pd_get_top_frame_for_signal_handler(frame* fr_addr, void* ucontext,
     bool isInJava);
 
diff --git a/src/hotspot/os_cpu/windows_x86/thread_windows_x86.hpp b/src/hotspot/os_cpu/windows_x86/thread_windows_x86.hpp
index 2157734624662..9cb8bc89682fe 100644
--- a/src/hotspot/os_cpu/windows_x86/thread_windows_x86.hpp
+++ b/src/hotspot/os_cpu/windows_x86/thread_windows_x86.hpp
@@ -44,6 +44,10 @@
     return byte_offset_of(JavaThread, _anchor) + JavaFrameAnchor::last_Java_fp_offset();
   }
 
+  static ByteSize saved_rbp_address_offset() {
+    return byte_offset_of(JavaThread, _anchor) + JavaFrameAnchor::saved_rbp_address_offset();
+  }
+
   bool pd_get_top_frame_for_signal_handler(frame* fr_addr, void* ucontext,
     bool isInJava);
 
diff --git a/src/hotspot/share/runtime/thread.hpp b/src/hotspot/share/runtime/thread.hpp
index d5b8484741039..f235f14c57626 100644
--- a/src/hotspot/share/runtime/thread.hpp
+++ b/src/hotspot/share/runtime/thread.hpp
@@ -1590,9 +1590,6 @@ class JavaThread: public Thread {
   static ByteSize frame_anchor_offset() {
     return byte_offset_of(JavaThread, _anchor);
   }
-  static ByteSize saved_rbp_address_offset() {
-    return byte_offset_of(JavaThread, _anchor) + JavaFrameAnchor::saved_rbp_address_offset();
-  }
 
   static ByteSize callee_target_offset()         { return byte_offset_of(JavaThread, _callee_target); }
   static ByteSize vm_result_offset()             { return byte_offset_of(JavaThread, _vm_result); }

From 9ec4c0ed04d91417ff0fbb8402cd3d620bf8536d Mon Sep 17 00:00:00 2001
From: Maurizio Cimadamore 
Date: Thu, 22 Oct 2020 13:33:06 +0100
Subject: [PATCH 29/70] Fix copyright of AbstractNativeScope

---
 .../classes/jdk/internal/foreign/AbstractNativeScope.java      | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/AbstractNativeScope.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/AbstractNativeScope.java
index 515f8c40c8996..2c11bb09e0259 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/AbstractNativeScope.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/AbstractNativeScope.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -22,6 +22,7 @@
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */
+
 package jdk.internal.foreign;
 
 import jdk.incubator.foreign.MemorySegment;

From 6aec407089e90bf61833fde3894868e8860cf430 Mon Sep 17 00:00:00 2001
From: Maurizio Cimadamore 
Date: Thu, 22 Oct 2020 14:07:48 +0100
Subject: [PATCH 30/70] Fix more copyright headers

---
 .../org/openjdk/bench/jdk/incubator/foreign/CallOverhead.java   | 2 +-
 test/micro/org/openjdk/bench/jdk/incubator/foreign/Upcalls.java | 2 +-
 .../org/openjdk/bench/jdk/incubator/foreign/libCallOverhead.c   | 2 +-
 .../openjdk/bench/jdk/incubator/foreign/libCallOverheadJNI.c    | 2 +-
 test/micro/org/openjdk/bench/jdk/incubator/foreign/libUpcalls.c | 2 +-
 .../org/openjdk/bench/jdk/incubator/foreign/libUpcallsJNI.c     | 2 +-
 .../bench/jdk/incubator/foreign/points/PointsDistance.java      | 2 +-
 .../bench/jdk/incubator/foreign/points/support/libPoint.c       | 2 +-
 8 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/test/micro/org/openjdk/bench/jdk/incubator/foreign/CallOverhead.java b/test/micro/org/openjdk/bench/jdk/incubator/foreign/CallOverhead.java
index 0f3029541064c..ce8649370fba1 100644
--- a/test/micro/org/openjdk/bench/jdk/incubator/foreign/CallOverhead.java
+++ b/test/micro/org/openjdk/bench/jdk/incubator/foreign/CallOverhead.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
diff --git a/test/micro/org/openjdk/bench/jdk/incubator/foreign/Upcalls.java b/test/micro/org/openjdk/bench/jdk/incubator/foreign/Upcalls.java
index 9351b8a664048..80efd81ffec68 100644
--- a/test/micro/org/openjdk/bench/jdk/incubator/foreign/Upcalls.java
+++ b/test/micro/org/openjdk/bench/jdk/incubator/foreign/Upcalls.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
diff --git a/test/micro/org/openjdk/bench/jdk/incubator/foreign/libCallOverhead.c b/test/micro/org/openjdk/bench/jdk/incubator/foreign/libCallOverhead.c
index 01630b4ea67fc..6cd014e86636f 100644
--- a/test/micro/org/openjdk/bench/jdk/incubator/foreign/libCallOverhead.c
+++ b/test/micro/org/openjdk/bench/jdk/incubator/foreign/libCallOverhead.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
diff --git a/test/micro/org/openjdk/bench/jdk/incubator/foreign/libCallOverheadJNI.c b/test/micro/org/openjdk/bench/jdk/incubator/foreign/libCallOverheadJNI.c
index 1344f29f1764e..1d74e90cbabb1 100644
--- a/test/micro/org/openjdk/bench/jdk/incubator/foreign/libCallOverheadJNI.c
+++ b/test/micro/org/openjdk/bench/jdk/incubator/foreign/libCallOverheadJNI.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
diff --git a/test/micro/org/openjdk/bench/jdk/incubator/foreign/libUpcalls.c b/test/micro/org/openjdk/bench/jdk/incubator/foreign/libUpcalls.c
index 92d7cabf8c546..df0d3b25ee7b2 100644
--- a/test/micro/org/openjdk/bench/jdk/incubator/foreign/libUpcalls.c
+++ b/test/micro/org/openjdk/bench/jdk/incubator/foreign/libUpcalls.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
diff --git a/test/micro/org/openjdk/bench/jdk/incubator/foreign/libUpcallsJNI.c b/test/micro/org/openjdk/bench/jdk/incubator/foreign/libUpcallsJNI.c
index 00b4c52b6d332..8a4e16268a59c 100644
--- a/test/micro/org/openjdk/bench/jdk/incubator/foreign/libUpcallsJNI.c
+++ b/test/micro/org/openjdk/bench/jdk/incubator/foreign/libUpcallsJNI.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
diff --git a/test/micro/org/openjdk/bench/jdk/incubator/foreign/points/PointsDistance.java b/test/micro/org/openjdk/bench/jdk/incubator/foreign/points/PointsDistance.java
index e1283b34ba0d7..164d74e4236cb 100644
--- a/test/micro/org/openjdk/bench/jdk/incubator/foreign/points/PointsDistance.java
+++ b/test/micro/org/openjdk/bench/jdk/incubator/foreign/points/PointsDistance.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
diff --git a/test/micro/org/openjdk/bench/jdk/incubator/foreign/points/support/libPoint.c b/test/micro/org/openjdk/bench/jdk/incubator/foreign/points/support/libPoint.c
index 480f54b39a796..5d4a23a8d6f39 100644
--- a/test/micro/org/openjdk/bench/jdk/incubator/foreign/points/support/libPoint.c
+++ b/test/micro/org/openjdk/bench/jdk/incubator/foreign/points/support/libPoint.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it

From 3df6ceefa5b1778df2d3226047ee580c36ab807f Mon Sep 17 00:00:00 2001
From: Maurizio Cimadamore 
Date: Thu, 22 Oct 2020 14:16:51 +0100
Subject: [PATCH 31/70] And more copyright fixes

---
 test/jdk/java/foreign/stackwalk/libStackWalk.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/jdk/java/foreign/stackwalk/libStackWalk.c b/test/jdk/java/foreign/stackwalk/libStackWalk.c
index c1aa0112215f1..4d36dbf5365b1 100644
--- a/test/jdk/java/foreign/stackwalk/libStackWalk.c
+++ b/test/jdk/java/foreign/stackwalk/libStackWalk.c
@@ -1,5 +1,5 @@
 /*
- *  Copyright (c) 2020 Oracle and/or its affiliates. All rights reserved.
+ *  Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
  *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  *  This code is free software; you can redistribute it and/or modify it

From 003614af877557701978a71298ca9e620b77519c Mon Sep 17 00:00:00 2001
From: Maurizio Cimadamore 
Date: Thu, 22 Oct 2020 15:19:01 +0100
Subject: [PATCH 32/70] Fix most review comments Fix Graal intrinsics test
 failure

---
 .../jdk/internal/access/JavaLangAccess.java   |  1 -
 .../jdk/incubator/foreign/CLinker.java        | 61 +++++++++------
 .../incubator/foreign/FunctionDescriptor.java | 12 +--
 .../jdk/incubator/foreign/LibraryLookup.java  |  9 ++-
 .../jdk/incubator/foreign/NativeScope.java    | 78 +++++++++----------
 .../internal/foreign/AbstractNativeScope.java |  8 +-
 .../classes/jdk/internal/foreign/CABI.java    | 17 ++--
 .../foreign/abi/BindingInterpreter.java       |  2 +
 .../internal/foreign/abi/CallingSequence.java |  8 --
 .../foreign/abi/CallingSequenceBuilder.java   | 12 +--
 .../foreign/abi/ProgrammableInvoker.java      |  4 +-
 .../hotspot/test/CheckGraalIntrinsics.java    |  5 ++
 test/jdk/java/foreign/StdLibTest.java         |  2 +-
 .../java/foreign/TestFunctionDescriptor.java  | 10 +--
 test/jdk/java/foreign/TestIntrinsics.java     |  2 +-
 .../callarranger/TestSysVCallArranger.java    | 24 +++---
 16 files changed, 139 insertions(+), 116 deletions(-)

diff --git a/src/java.base/share/classes/jdk/internal/access/JavaLangAccess.java b/src/java.base/share/classes/jdk/internal/access/JavaLangAccess.java
index 630f5e0854374..edcc5ed5caf8d 100644
--- a/src/java.base/share/classes/jdk/internal/access/JavaLangAccess.java
+++ b/src/java.base/share/classes/jdk/internal/access/JavaLangAccess.java
@@ -43,7 +43,6 @@
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.stream.Stream;
 
-import jdk.internal.loader.NativeLibrary;
 import jdk.internal.module.ServicesCatalog;
 import jdk.internal.reflect.ConstantPool;
 import sun.reflect.annotation.AnnotationType;
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/CLinker.java b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/CLinker.java
index b365616012bdb..de3047ee0e909 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/CLinker.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/CLinker.java
@@ -122,11 +122,13 @@ static CLinker getInstance() {
      * Obtain a foreign method handle, with given type, which can be used to call a
      * target foreign function at a given address and featuring a given function descriptor.
      *
+     * @see LibraryLookup#lookup(String)
+     *
      * @param symbol   downcall symbol.
      * @param type     the method type.
      * @param function the function descriptor.
      * @return the downcall method handle.
-     * @throws IllegalArgumentException in the case of a carrier type and memory layout mismatch.
+     * @throws IllegalArgumentException in the case of a method type and function descriptor mismatch.
      */
     MethodHandle downcallHandle(Addressable symbol, MethodType type, FunctionDescriptor function);
 
@@ -142,7 +144,7 @@ static CLinker getInstance() {
      * @param target   the target method handle.
      * @param function the function descriptor.
      * @return the native stub segment.
-     * @throws IllegalArgumentException in the case of a carrier type and memory layout mismatch.
+     * @throws IllegalArgumentException if the target's method type and the function descriptor mismatch.
      */
     MemorySegment upcallStub(MethodHandle target, FunctionDescriptor function);
 
@@ -198,8 +200,8 @@ static  T asVarArg(T ml) {
         return (T) PlatformLayouts.asVarArg(ml);
     }
 
-        /**
-     * Convert a Java string into a null-terminated C string, using the
+    /**
+     * Converts a Java string into a null-terminated C string, using the
      * platform's default charset, storing the result into a new native memory segment.
      * 

      * This method always replaces malformed-input and unmappable-character
@@ -209,7 +211,7 @@ static  T asVarArg(T ml) {
      *
      * @param str the Java string to be converted into a C string.
      * @return a new native memory segment containing the converted C string.
-     * @throws NullPointerException if either {@code str == null}.
+     * @throws NullPointerException if {@code str == null}.
      */
     static MemorySegment toCString(String str) {
         Objects.requireNonNull(str);
@@ -217,7 +219,7 @@ static MemorySegment toCString(String str) {
     }
 
     /**
-     * Convert a Java string into a null-terminated C string, using the given {@linkplain java.nio.charset.Charset charset},
+     * Converts a Java string into a null-terminated C string, using the given {@link java.nio.charset.Charset charset},
      * storing the result into a new native memory segment.
      * 

      * This method always replaces malformed-input and unmappable-character
@@ -226,7 +228,7 @@ static MemorySegment toCString(String str) {
      * control over the encoding process is required.
      *
      * @param str the Java string to be converted into a C string.
-     * @param charset The {@linkplain java.nio.charset.Charset} to be used to compute the contents of the C string.
+     * @param charset The {@link java.nio.charset.Charset} to be used to compute the contents of the C string.
      * @return a new native memory segment containing the converted C string.
      * @throws NullPointerException if either {@code str == null} or {@code charset == null}.
      */
@@ -237,7 +239,7 @@ static MemorySegment toCString(String str, Charset charset) {
     }
 
     /**
-     * Convert a Java string into a null-terminated C string, using the platform's default charset,
+     * Converts a Java string into a null-terminated C string, using the platform's default charset,
      * storing the result into a native memory segment allocated using the provided scope.
      * 

      * This method always replaces malformed-input and unmappable-character
@@ -257,7 +259,7 @@ static MemorySegment toCString(String str, NativeScope scope) {
     }
 
     /**
-     * Convert a Java string into a null-terminated C string, using the given {@linkplain java.nio.charset.Charset charset},
+     * Converts a Java string into a null-terminated C string, using the given {@link java.nio.charset.Charset charset},
      * storing the result into a new native memory segment native memory segment allocated using the provided scope.
      * 

      * This method always replaces malformed-input and unmappable-character
@@ -266,7 +268,7 @@ static MemorySegment toCString(String str, NativeScope scope) {
      * control over the encoding process is required.
      *
      * @param str the Java string to be converted into a C string.
-     * @param charset The {@linkplain java.nio.charset.Charset} to be used to compute the contents of the C string.
+     * @param charset The {@link java.nio.charset.Charset} to be used to compute the contents of the C string.
      * @param scope the scope to be used for the native segment allocation.
      * @return a new native memory segment containing the converted C string.
      * @throws NullPointerException if either {@code str == null}, {@code charset == null} or {@code scope == null}.
@@ -279,7 +281,7 @@ static MemorySegment toCString(String str, Charset charset, NativeScope scope) {
     }
 
     /**
-     * Convert a null-terminated C string stored at given address into a Java string, using the platform's default charset.
+     * Converts a null-terminated C string stored at given address into a Java string, using the platform's default charset.
      * 

      * This method always replaces malformed-input and unmappable-character
      * sequences with this charset's default replacement string.  The {@link
@@ -300,7 +302,7 @@ static String toJavaStringRestricted(MemoryAddress addr) {
     }
 
     /**
-     * Convert a null-terminated C string stored at given address into a Java string, using the given {@linkplain java.nio.charset.Charset charset}.
+     * Converts a null-terminated C string stored at given address into a Java string, using the given {@link java.nio.charset.Charset charset}.
      * 

      * This method always replaces malformed-input and unmappable-character
      * sequences with this charset's default replacement string.  The {@link
@@ -311,18 +313,20 @@ static String toJavaStringRestricted(MemoryAddress addr) {
      * the JVM or, worse, silently result in memory corruption. Thus, clients should refrain from depending on
      * restricted methods, and use safe and supported functionalities, where possible.
      * @param addr the address at which the string is stored.
-     * @param charset The {@linkplain java.nio.charset.Charset} to be used to compute the contents of the Java string.
+     * @param charset The {@link java.nio.charset.Charset} to be used to compute the contents of the Java string.
      * @return a Java string with the contents of the null-terminated C string at given address.
-     * @throws NullPointerException if {@code addr == null}
+     * @throws NullPointerException if {@code addr == null} or {@code charset == null}.
      * @throws IllegalArgumentException if the size of the native string is greater than {@code Integer.MAX_VALUE}.
      */
     static String toJavaStringRestricted(MemoryAddress addr, Charset charset) {
         Utils.checkRestrictedAccess("CLinker.toJavaStringRestricted");
+        Objects.requireNonNull(addr);
+        Objects.requireNonNull(charset);
         return SharedUtils.toJavaStringInternal(NativeMemorySegmentImpl.EVERYTHING, addr.toRawLongValue(), charset);
     }
 
     /**
-     * Convert a null-terminated C string stored at given address into a Java string, using the platform's default charset.
+     * Converts a null-terminated C string stored at given address into a Java string, using the platform's default charset.
      * 

      * This method always replaces malformed-input and unmappable-character
      * sequences with this charset's default replacement string.  The {@link
@@ -336,25 +340,28 @@ static String toJavaStringRestricted(MemoryAddress addr, Charset charset) {
      * associated with {@code addr}, or if {@code addr} is associated with a segment that is not alive.
      */
     static String toJavaString(MemorySegment addr) {
+        Objects.requireNonNull(addr);
         return SharedUtils.toJavaStringInternal(addr, 0L, Charset.defaultCharset());
     }
 
     /**
-     * Convert a null-terminated C string stored at given address into a Java string, using the given {@linkplain java.nio.charset.Charset charset}.
+     * Converts a null-terminated C string stored at given address into a Java string, using the given {@link java.nio.charset.Charset charset}.
      * 

      * This method always replaces malformed-input and unmappable-character
      * sequences with this charset's default replacement string.  The {@link
      * java.nio.charset.CharsetDecoder} class should be used when more control
      * over the decoding process is required.
      * @param addr the address at which the string is stored.
-     * @param charset The {@linkplain java.nio.charset.Charset} to be used to compute the contents of the Java string.
+     * @param charset The {@link java.nio.charset.Charset} to be used to compute the contents of the Java string.
      * @return a Java string with the contents of the null-terminated C string at given address.
-     * @throws NullPointerException if {@code addr == null}
+     * @throws NullPointerException if {@code addr == null} or {@code charset == null}.
      * @throws IllegalArgumentException if the size of the native string is greater than {@code Integer.MAX_VALUE}.
      * @throws IllegalStateException if the size of the native string is greater than the size of the segment
      * associated with {@code addr}, or if {@code addr} is associated with a segment that is not alive.
      */
     static String toJavaString(MemorySegment addr, Charset charset) {
+        Objects.requireNonNull(addr);
+        Objects.requireNonNull(charset);
         return SharedUtils.toJavaStringInternal(addr, 0L, charset);
     }
 
@@ -377,7 +384,7 @@ private static MemorySegment toCString(byte[] bytes, NativeScope scope) {
     }
 
     /**
-     * Allocate memory of given size using malloc.
+     * Allocates memory of given size using malloc.
      * 

      * This method is restricted. Restricted method are unsafe, and, if used incorrectly, their use might crash
      * the JVM or, worse, silently result in memory corruption. Thus, clients should refrain from depending on
@@ -385,23 +392,31 @@ private static MemorySegment toCString(byte[] bytes, NativeScope scope) {
      *
      * @param size memory size to be allocated
      * @return addr memory address of the allocated memory
+     * @throws OutOfMemoryError if malloc could not allocate the required amount of native memory.
      */
     static MemoryAddress allocateMemoryRestricted(long size) {
         Utils.checkRestrictedAccess("CLinker.allocateMemoryRestricted");
-        return SharedUtils.allocateMemoryInternal(size);
+        MemoryAddress addr = SharedUtils.allocateMemoryInternal(size);
+        if (addr.equals(MemoryAddress.NULL)) {
+            throw new OutOfMemoryError();
+        } else {
+            return addr;
+        }
     }
 
     /**
-     * Free the memory pointed by the given memory address.
+     * Frees the memory pointed by the given memory address.
      * 

      * This method is restricted. Restricted method are unsafe, and, if used incorrectly, their use might crash
      * the JVM or, worse, silently result in memory corruption. Thus, clients should refrain from depending on
      * restricted methods, and use safe and supported functionalities, where possible.
      *
      * @param addr memory address of the native memory to be freed
+     * @throws NullPointerException if {@code addr == null}.
      */
     static void freeMemoryRestricted(MemoryAddress addr) {
         Utils.checkRestrictedAccess("CLinker.freeMemoryRestricted");
+        Objects.requireNonNull(addr);
         SharedUtils.freeMemoryInternal(addr);
     }
 
@@ -600,7 +615,7 @@ static VaList ofAddressRestricted(MemoryAddress address) {
          * is called.
          * 

          * Note that when there are no elements added to the created va list,
-         * this method will return the same as {@linkplain #empty()}.
+         * this method will return the same as {@link #empty()}.
          *
          * @param actions a consumer for a builder (see {@link Builder}) which can be used to specify the elements
          *                of the underlying C {@code va_list}.
@@ -620,7 +635,7 @@ static VaList make(Consumer actions) {
          * will be managed by the given {@code NativeScope}, and will be released when the scope is closed.
          * 

          * Note that when there are no elements added to the created va list,
-         * this method will return the same as {@linkplain #empty()}.
+         * this method will return the same as {@link #empty()}.
          *
          * @param actions a consumer for a builder (see {@link Builder}) which can be used to specify the elements
          *                of the underlying C {@code va_list}.
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/FunctionDescriptor.java b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/FunctionDescriptor.java
index 5aecf991ec6e1..d7a40da798ca2 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/FunctionDescriptor.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/FunctionDescriptor.java
@@ -57,7 +57,7 @@ public final class FunctionDescriptor implements Constable {
 
     private FunctionDescriptor(MemoryLayout resLayout, Map attributes, MemoryLayout... argLayouts) {
         this.resLayout = resLayout;
-        this.attributes = Collections.unmodifiableMap(attributes);
+        this.attributes = attributes;
         this.argLayouts = argLayouts;
     }
 
@@ -97,7 +97,7 @@ public FunctionDescriptor withAttribute(String name, Constable value) {
 
     /**
      * Returns the return layout associated with this function.
-     * @return the return
+     * @return the return layout.
      */
     public Optional returnLayout() {
         return Optional.ofNullable(resLayout);
@@ -113,7 +113,7 @@ public List argumentLayouts() {
 
     /**
      * Create a function descriptor with given return and argument layouts.
-     * @param resLayout the return
+     * @param resLayout the return layout.
      * @param argLayouts the argument layouts.
      * @return the new function descriptor.
      * @throws NullPointerException if any of the argument layouts, or the return layout is null.
@@ -142,7 +142,7 @@ public static FunctionDescriptor ofVoid(MemoryLayout... argLayouts) {
      * @return the new function descriptor.
      * @throws NullPointerException if any of the new argument layouts is null.
      */
-    public FunctionDescriptor appendArgumentLayouts(MemoryLayout... addedLayouts) {
+    public FunctionDescriptor withAppendedArgumentLayouts(MemoryLayout... addedLayouts) {
         Arrays.stream(addedLayouts).forEach(Objects::requireNonNull);
         MemoryLayout[] newLayouts = Arrays.copyOf(argLayouts, argLayouts.length + addedLayouts.length);
         System.arraycopy(addedLayouts, 0, newLayouts, argLayouts.length, addedLayouts.length);
@@ -155,7 +155,7 @@ public FunctionDescriptor appendArgumentLayouts(MemoryLayout... addedLayouts) {
      * @return the new function descriptor.
      * @throws NullPointerException if the new return layout is null.
      */
-    public FunctionDescriptor changeReturnLayout(MemoryLayout newReturn) {
+    public FunctionDescriptor withReturnLayout(MemoryLayout newReturn) {
         Objects.requireNonNull(newReturn);
         return new FunctionDescriptor(newReturn, attributes, argLayouts);
     }
@@ -164,7 +164,7 @@ public FunctionDescriptor changeReturnLayout(MemoryLayout newReturn) {
      * Create a new function descriptor with the return layout dropped.
      * @return the new function descriptor.
      */
-    public FunctionDescriptor dropReturnLayout() {
+    public FunctionDescriptor withVoidReturnLayout() {
         return new FunctionDescriptor(null, attributes, argLayouts);
     }
 
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/LibraryLookup.java b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/LibraryLookup.java
index 1dc1c6ddab9b9..3598710f936a9 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/LibraryLookup.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/LibraryLookup.java
@@ -34,7 +34,7 @@
 import java.util.Optional;
 
 /**
- * A native library lookup. Exposes lookup operation for searching symbols, see {@link LibraryLookup#lookup(String)}.
+ * A native library lookup. Exposes a lookup operation for searching symbols, see {@link LibraryLookup#lookup(String)}.
  * A given native library remains loaded as long as there is at least one live library lookup instance referring
  * to it.
  * All symbol instances (see {@link LibraryLookup.Symbol}) generated by a given library lookup object contain a strong reference
@@ -88,7 +88,7 @@ interface Symbol extends Addressable {
     }
 
     /**
-     * Lookups a symbol with given name in this library. The returned symbol maintains a strong reference to this lookup object.
+     * Looks up a symbol with given name in this library. The returned symbol maintains a strong reference to this lookup object.
      * @param name the symbol name.
      * @return the library symbol (if any).
      */
@@ -127,7 +127,10 @@ static LibraryLookup ofPath(Path path) {
     }
 
     /**
-     * Obtain a library lookup object corresponding to a library identified by given library name.
+     * Obtain a library lookup object corresponding to a library identified by given library name. The library name
+     * is decorated according to the platform conventions (e.g. on Linux, the {@code lib} prefix is added,
+     * as well as the {@code .so} extension); the resulting name is then looked up in the standard native
+     * library path (which can be overriden, by setting the java.library.path property).
      * @param libName the library name.
      * @return a library lookup object for given library name.
      */
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/NativeScope.java b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/NativeScope.java
index 09286ac004aca..6a5de40e1b834 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/NativeScope.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/NativeScope.java
@@ -41,7 +41,7 @@
  * This class provides a scope, within which several allocations can be performed. An native scope is backed
  * by off-heap memory. Native scopes can be either bounded or unbounded, depending on whether the size
  * of the native scope is known statically. If an application knows before-hand how much memory it needs to allocate,
- * then using a bounded native scope will typically provide better performances than independently allocating the memory
+ * then using a bounded native scope will typically provide better performance than independently allocating the memory
  * for each value (e.g. using {@link MemorySegment#allocateNative(long)}), or using an unbounded native scope.
  * For this reason, using a bounded native scope is recommended in cases where programs might need to emulate native stack allocation.
  * 

@@ -51,7 +51,7 @@
  * 

  * To allow for more usability, it is possible for a native scope to reclaim ownership of an existing memory segment
  * (see {@link MemorySegment#handoff(NativeScope)}). This might be useful to allow one or more segments which were independently
- * created to share the same life-cycle as a given native scope - which in turns enables client to group all memory
+ * created to share the same life-cycle as a given native scope - which in turns enables a client to group all memory
  * allocation and usage under a single try-with-resources block.
  */
 public interface NativeScope extends AutoCloseable {
@@ -81,8 +81,8 @@ public interface NativeScope extends AutoCloseable {
      * @param layout the layout of the block of memory to be allocated.
      * @param value the value to be set on the newly allocated memory block.
      * @return a segment for the newly allocated memory block.
-     * @throws OutOfMemoryError if there is not enough space left in this native scope, that is, if
-     * {@code limit() - size() < layout.byteSize()}.
+     * @throws OutOfMemoryError if there is not enough space left in this native scope, that is, if this is a
+     * bounded allocation scope, and {@code byteSize().getAsLong() - allocatedBytes() < layout.byteSize()}.
      * @throws IllegalArgumentException if {@code layout.byteSize()} does not conform to the size of a byte value.
      */
     default MemorySegment allocate(ValueLayout layout, byte value) {
@@ -99,8 +99,8 @@ default MemorySegment allocate(ValueLayout layout, byte value) {
      * @param layout the layout of the block of memory to be allocated.
      * @param value the value to be set on the newly allocated memory block.
      * @return a segment for the newly allocated memory block.
-     * @throws OutOfMemoryError if there is not enough space left in this native scope, that is, if
-     * {@code limit() - size() < layout.byteSize()}.
+     * @throws OutOfMemoryError if there is not enough space left in this native scope, that is, if this is a
+     * bounded allocation scope, and {@code byteSize().getAsLong() - allocatedBytes() < layout.byteSize()}.
      * @throws IllegalArgumentException if {@code layout.byteSize()} does not conform to the size of a short value.
      */
     default MemorySegment allocate(ValueLayout layout, short value) {
@@ -117,8 +117,8 @@ default MemorySegment allocate(ValueLayout layout, short value) {
      * @param layout the layout of the block of memory to be allocated.
      * @param value the value to be set on the newly allocated memory block.
      * @return a segment for the newly allocated memory block.
-     * @throws OutOfMemoryError if there is not enough space left in this native scope, that is, if
-     * {@code limit() - size() < layout.byteSize()}.
+     * @throws OutOfMemoryError if there is not enough space left in this native scope, that is, if this is a
+     * bounded allocation scope, and {@code byteSize().getAsLong() - allocatedBytes() < layout.byteSize()}.
      * @throws IllegalArgumentException if {@code layout.byteSize()} does not conform to the size of a int value.
      */
     default MemorySegment allocate(ValueLayout layout, int value) {
@@ -135,8 +135,8 @@ default MemorySegment allocate(ValueLayout layout, int value) {
      * @param layout the layout of the block of memory to be allocated.
      * @param value the value to be set on the newly allocated memory block.
      * @return a segment for the newly allocated memory block.
-     * @throws OutOfMemoryError if there is not enough space left in this native scope, that is, if
-     * {@code limit() - size() < layout.byteSize()}.
+     * @throws OutOfMemoryError if there is not enough space left in this native scope, that is, if this is a
+     * bounded allocation scope, and {@code byteSize().getAsLong() - allocatedBytes() < layout.byteSize()}.
      * @throws IllegalArgumentException if {@code layout.byteSize()} does not conform to the size of a float value.
      */
     default MemorySegment allocate(ValueLayout layout, float value) {
@@ -153,8 +153,8 @@ default MemorySegment allocate(ValueLayout layout, float value) {
      * @param layout the layout of the block of memory to be allocated.
      * @param value the value to be set on the newly allocated memory block.
      * @return a segment for the newly allocated memory block.
-     * @throws OutOfMemoryError if there is not enough space left in this native scope, that is, if
-     * {@code limit() - size() < layout.byteSize()}.
+     * @throws OutOfMemoryError if there is not enough space left in this native scope, that is, if this is a
+     * bounded allocation scope, and {@code byteSize().getAsLong() - allocatedBytes() < layout.byteSize()}.
      * @throws IllegalArgumentException if {@code layout.byteSize()} does not conform to the size of a long value.
      */
     default MemorySegment allocate(ValueLayout layout, long value) {
@@ -171,8 +171,8 @@ default MemorySegment allocate(ValueLayout layout, long value) {
      * @param layout the layout of the block of memory to be allocated.
      * @param value the value to be set on the newly allocated memory block.
      * @return a segment for the newly allocated memory block.
-     * @throws OutOfMemoryError if there is not enough space left in this native scope, that is, if
-     * {@code limit() - size() < layout.byteSize()}.
+     * @throws OutOfMemoryError if there is not enough space left in this native scope, that is, if this is a
+     * bounded allocation scope, and {@code byteSize().getAsLong() - allocatedBytes() < layout.byteSize()}.
      * @throws IllegalArgumentException if {@code layout.byteSize()} does not conform to the size of a double value.
      */
     default MemorySegment allocate(ValueLayout layout, double value) {
@@ -191,8 +191,8 @@ default MemorySegment allocate(ValueLayout layout, double value) {
      * @param layout the layout of the block of memory to be allocated.
      * @param value the value to be set on the newly allocated memory block.
      * @return a segment for the newly allocated memory block.
-     * @throws OutOfMemoryError if there is not enough space left in this native scope, that is, if
-     * {@code limit() - size() < layout.byteSize()}.
+     * @throws OutOfMemoryError if there is not enough space left in this native scope, that is, if this is a
+     * bounded allocation scope, and {@code byteSize().getAsLong() - allocatedBytes() < layout.byteSize()}.
      * @throws IllegalArgumentException if {@code layout.byteSize() != MemoryLayouts.ADDRESS.byteSize()}.
      */
     default MemorySegment allocate(ValueLayout layout, Addressable value) {
@@ -213,8 +213,8 @@ default MemorySegment allocate(ValueLayout layout, Addressable value) {
      * @param elementLayout the element layout of the array to be allocated.
      * @param array the array to be copied on the newly allocated memory block.
      * @return a segment for the newly allocated memory block.
-     * @throws OutOfMemoryError if there is not enough space left in this native scope, that is, if
-     * {@code limit() - size() < (elementLayout.byteSize() * array.length)}.
+     * @throws OutOfMemoryError if there is not enough space left in this native scope, that is, if this is a
+     * bounded allocation scope, and {@code byteSize().getAsLong() - allocatedBytes() < (elementLayout.byteSize() * array.length)}.
      * @throws IllegalArgumentException if {@code elementLayout.byteSize()} does not conform to the size of a byte value.
      */
     default MemorySegment allocateArray(ValueLayout elementLayout, byte[] array) {
@@ -228,8 +228,8 @@ default MemorySegment allocateArray(ValueLayout elementLayout, byte[] array) {
      * @param elementLayout the element layout of the array to be allocated.
      * @param array the array to be copied on the newly allocated memory block.
      * @return a segment for the newly allocated memory block.
-     * @throws OutOfMemoryError if there is not enough space left in this native scope, that is, if
-     * {@code limit() - size() < (elementLayout.byteSize() * array.length)}.
+     * @throws OutOfMemoryError if there is not enough space left in this native scope, that is, if this is a
+     * bounded allocation scope, and {@code byteSize().getAsLong() - allocatedBytes() < (elementLayout.byteSize() * array.length)}.
      * @throws IllegalArgumentException if {@code elementLayout.byteSize()} does not conform to the size of a short value.
      */
     default MemorySegment allocateArray(ValueLayout elementLayout, short[] array) {
@@ -243,8 +243,8 @@ default MemorySegment allocateArray(ValueLayout elementLayout, short[] array) {
      * @param elementLayout the element layout of the array to be allocated.
      * @param array the array to be copied on the newly allocated memory block.
      * @return a segment for the newly allocated memory block.
-     * @throws OutOfMemoryError if there is not enough space left in this native scope, that is, if
-     * {@code limit() - size() < (elementLayout.byteSize() * array.length)}.
+     * @throws OutOfMemoryError if there is not enough space left in this native scope, that is, if this is a
+     * bounded allocation scope, and {@code byteSize().getAsLong() - allocatedBytes() < (elementLayout.byteSize() * array.length)}.
      * @throws IllegalArgumentException if {@code elementLayout.byteSize()} does not conform to the size of a char value.
      */
     default MemorySegment allocateArray(ValueLayout elementLayout, char[] array) {
@@ -258,8 +258,8 @@ default MemorySegment allocateArray(ValueLayout elementLayout, char[] array) {
      * @param elementLayout the element layout of the array to be allocated.
      * @param array the array to be copied on the newly allocated memory block.
      * @return a segment for the newly allocated memory block.
-     * @throws OutOfMemoryError if there is not enough space left in this native scope, that is, if
-     * {@code limit() - size() < (elementLayout.byteSize() * array.length)}.
+     * @throws OutOfMemoryError if there is not enough space left in this native scope, that is, if this is a
+     * bounded allocation scope, and {@code byteSize().getAsLong() - allocatedBytes() < (elementLayout.byteSize() * array.length)}.
      * @throws IllegalArgumentException if {@code elementLayout.byteSize()} does not conform to the size of a int value.
      */
     default MemorySegment allocateArray(ValueLayout elementLayout, int[] array) {
@@ -273,8 +273,8 @@ default MemorySegment allocateArray(ValueLayout elementLayout, int[] array) {
      * @param elementLayout the element layout of the array to be allocated.
      * @param array the array to be copied on the newly allocated memory block.
      * @return a segment for the newly allocated memory block.
-     * @throws OutOfMemoryError if there is not enough space left in this native scope, that is, if
-     * {@code limit() - size() < (elementLayout.byteSize() * array.length)}.
+     * @throws OutOfMemoryError if there is not enough space left in this native scope, that is, if this is a
+     * bounded allocation scope, and {@code byteSize().getAsLong() - allocatedBytes() < (elementLayout.byteSize() * array.length)}.
      * @throws IllegalArgumentException if {@code elementLayout.byteSize()} does not conform to the size of a float value.
      */
     default MemorySegment allocateArray(ValueLayout elementLayout, float[] array) {
@@ -288,8 +288,8 @@ default MemorySegment allocateArray(ValueLayout elementLayout, float[] array) {
      * @param elementLayout the element layout of the array to be allocated.
      * @param array the array to be copied on the newly allocated memory block.
      * @return a segment for the newly allocated memory block.
-     * @throws OutOfMemoryError if there is not enough space left in this native scope, that is, if
-     * {@code limit() - size() < (elementLayout.byteSize() * array.length)}.
+     * @throws OutOfMemoryError if there is not enough space left in this native scope, that is, if this is a
+     * bounded allocation scope, and {@code byteSize().getAsLong() - allocatedBytes() < (elementLayout.byteSize() * array.length)}.
      * @throws IllegalArgumentException if {@code elementLayout.byteSize()} does not conform to the size of a long value.
      */
     default MemorySegment allocateArray(ValueLayout elementLayout, long[] array) {
@@ -303,8 +303,8 @@ default MemorySegment allocateArray(ValueLayout elementLayout, long[] array) {
      * @param elementLayout the element layout of the array to be allocated.
      * @param array the array to be copied on the newly allocated memory block.
      * @return a segment for the newly allocated memory block.
-     * @throws OutOfMemoryError if there is not enough space left in this native scope, that is, if
-     * {@code limit() - size() < (elementLayout.byteSize() * array.length)}.
+     * @throws OutOfMemoryError if there is not enough space left in this native scope, that is, if this is a
+     * bounded allocation scope, and {@code byteSize().getAsLong() - allocatedBytes() < (elementLayout.byteSize() * array.length)}.
      * @throws IllegalArgumentException if {@code elementLayout.byteSize()} does not conform to the size of a double value.
      */
     default MemorySegment allocateArray(ValueLayout elementLayout, double[] array) {
@@ -319,8 +319,8 @@ default MemorySegment allocateArray(ValueLayout elementLayout, double[] array) {
      * @param elementLayout the element layout of the array to be allocated.
      * @param array the array to be copied on the newly allocated memory block.
      * @return a segment for the newly allocated memory block.
-     * @throws OutOfMemoryError if there is not enough space left in this native scope, that is, if
-     * {@code limit() - size() < (elementLayout.byteSize() * array.length)}.
+     * @throws OutOfMemoryError if there is not enough space left in this native scope, that is, if this is a
+     * bounded allocation scope, and {@code byteSize().getAsLong() - allocatedBytes() < (elementLayout.byteSize() * array.length)}.
      * @throws IllegalArgumentException if {@code layout.byteSize() != MemoryLayouts.ADDRESS.byteSize()}.
      */
     default MemorySegment allocateArray(ValueLayout elementLayout, Addressable[] array) {
@@ -355,8 +355,8 @@ private  MemorySegment copyArrayWithSwapIfNeeded(Z array, ValueLayout element
      * associated with a segment which cannot be closed. Moreover, the returned segment must conform to the layout alignment constraints.
      * @param layout the layout of the block of memory to be allocated.
      * @return a segment for the newly allocated memory block.
-     * @throws OutOfMemoryError if there is not enough space left in this native scope, that is, if
-     * {@code limit() - size() < layout.byteSize()}.
+     * @throws OutOfMemoryError if there is not enough space left in this native scope, that is, if this is a
+     * bounded allocation scope, and {@code byteSize().getAsLong() - allocatedBytes() < layout.byteSize()}.
      */
     default MemorySegment allocate(MemoryLayout layout) {
         return allocate(layout.byteSize(), layout.byteAlignment());
@@ -371,13 +371,13 @@ default MemorySegment allocate(MemoryLayout layout) {
     allocate(MemoryLayout.ofSequence(size, elementLayout));
      * }

      * @param elementLayout the array element layout.
-     * @param size the array element count.
+     * @param count the array element count.
      * @return a segment for the newly allocated memory block.
-     * @throws OutOfMemoryError if there is not enough space left in this native scope, that is, if
-     * {@code limit() - size() < (elementLayout.byteSize() * size)}.
+     * @throws OutOfMemoryError if there is not enough space left in this native scope, that is, if this is a
+     * bounded allocation scope, and {@code byteSize().getAsLong() - allocatedBytes() < (elementLayout.byteSize() * count)}.
      */
-    default MemorySegment allocateArray(MemoryLayout elementLayout, long size) {
-        return allocate(MemoryLayout.ofSequence(size, elementLayout));
+    default MemorySegment allocateArray(MemoryLayout elementLayout, long count) {
+        return allocate(MemoryLayout.ofSequence(count, elementLayout));
     }
 
     /**
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/AbstractNativeScope.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/AbstractNativeScope.java
index 2c11bb09e0259..3680606371d6d 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/AbstractNativeScope.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/AbstractNativeScope.java
@@ -39,8 +39,8 @@ public abstract class AbstractNativeScope implements NativeScope {
 
     private static final int SCOPE_MASK = MemorySegment.READ | MemorySegment.WRITE; // no terminal operations allowed
 
-    AbstractNativeScope(Thread ownerThread) {
-        this.ownerThread = ownerThread;
+    AbstractNativeScope() {
+        this.ownerThread = Thread.currentThread();
     }
 
     @Override
@@ -93,7 +93,7 @@ public long allocatedBytes() {
         }
 
         public UnboundedNativeScope() {
-            super(Thread.currentThread());
+            super();
             this.segment = newSegment(BLOCK_SIZE);
         }
 
@@ -137,7 +137,7 @@ public long allocatedBytes() {
         }
 
         public BoundedNativeScope(long size) {
-            super(Thread.currentThread());
+            super();
             this.segment = newSegment(size, 1);
         }
 
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/CABI.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/CABI.java
index 4c24e6d15f386..36d83e6d5f1a4 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/CABI.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/CABI.java
@@ -30,18 +30,25 @@ public enum CABI {
     Win64,
     AArch64;
 
-    public static CABI current() {
+    private static final CABI current;
+
+    static {
         String arch = System.getProperty("os.arch");
         String os = System.getProperty("os.name");
         if (arch.equals("amd64") || arch.equals("x86_64")) {
             if (os.startsWith("Windows")) {
-                return Win64;
+                current = Win64;
             } else {
-                return SysV;
+                current = SysV;
             }
         } else if (arch.equals("aarch64")) {
-            return AArch64;
+            current = AArch64;
+        } else {
+            throw new ExceptionInInitializerError("Unsupported os or arch: " + os + ", " + arch);
         }
-        throw new UnsupportedOperationException("Unsupported os or arch: " + os + ", " + arch);
+    }
+
+    public static CABI current() {
+        return current;
     }
 }
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/BindingInterpreter.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/BindingInterpreter.java
index 63d26806df17e..a6ecce2b8e7b0 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/BindingInterpreter.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/BindingInterpreter.java
@@ -47,10 +47,12 @@ static Object box(List bindings, LoadFunc loadFunc, SharedUtils.Allocat
        return stack.pop();
     }
 
+    @FunctionalInterface
     interface StoreFunc {
         void store(VMStorage storage, Class type, Object o);
     }
 
+    @FunctionalInterface
     interface LoadFunc {
         Object load(VMStorage storage, Class type);
     }
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/CallingSequence.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/CallingSequence.java
index 0ec8cd9f78a23..e9c823fa2bfdc 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/CallingSequence.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/CallingSequence.java
@@ -48,14 +48,6 @@ public CallingSequence(MethodType mt, FunctionDescriptor desc,
         this.argumentBindings = argumentBindings;
     }
 
-    public Stream argBindings() {
-        return argumentBindings.stream().flatMap(List::stream);
-    }
-
-    public Stream retBindings() {
-        return returnBindings().stream();
-    }
-
     public int argumentCount() {
         return argumentBindings.size();
     }
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/CallingSequenceBuilder.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/CallingSequenceBuilder.java
index a3965820e93c0..dac727d5707c3 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/CallingSequenceBuilder.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/CallingSequenceBuilder.java
@@ -59,7 +59,7 @@ public final CallingSequenceBuilder addArgumentBindings(Class carrier, Memory
         verifyBindings(true, carrier, bindings);
         inputBindings.add(bindings);
         mt = mt.appendParameterTypes(carrier);
-        desc = desc.appendArgumentLayouts(layout);
+        desc = desc.withAppendedArgumentLayouts(layout);
         return this;
     }
 
@@ -68,7 +68,7 @@ public CallingSequenceBuilder setReturnBindings(Class carrier, MemoryLayout l
         verifyBindings(false, carrier, bindings);
         this.outputBindings = bindings;
         mt = mt.changeReturnType(carrier);
-        desc = desc.changeReturnLayout(layout);
+        desc = desc.withReturnLayout(layout);
         return this;
     }
 
@@ -91,7 +91,7 @@ private void verifyBindings(boolean forArguments, Class carrier, List unboxTags = EnumSet.of(
+    private static final Set UNBOX_TAGS = EnumSet.of(
         VM_STORE,
         //VM_LOAD,
         //BUFFER_STORE,
@@ -110,7 +110,7 @@ private static void verifyUnboxBindings(Class inType, List bindings)
         stack.push(inType);
 
         for (Binding b : bindings) {
-            if (!unboxTags.contains(b.tag()))
+            if (!UNBOX_TAGS.contains(b.tag()))
                 throw new IllegalArgumentException("Unexpected operator: " + b);
             b.verify(stack);
         }
@@ -120,7 +120,7 @@ private static void verifyUnboxBindings(Class inType, List bindings)
         }
     }
 
-    private static final Set boxTags = EnumSet.of(
+    private static final Set BOX_TAGS = EnumSet.of(
         //VM_STORE,
         VM_LOAD,
         BUFFER_STORE,
@@ -138,7 +138,7 @@ private static void verifyBoxBindings(Class expectedOutType, List bi
         Deque> stack = new ArrayDeque<>();
 
         for (Binding b : bindings) {
-            if (!boxTags.contains(b.tag()))
+            if (!BOX_TAGS.contains(b.tag()))
                 throw new IllegalArgumentException("Unexpected operator: " + b);
             b.verify(stack);
         }
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/ProgrammableInvoker.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/ProgrammableInvoker.java
index b18d1f9645070..c2db9efc41f4d 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/ProgrammableInvoker.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/ProgrammableInvoker.java
@@ -196,13 +196,13 @@ public MethodHandle getBoundMethodHandle() {
     }
 
     private Stream argMoveBindingsStream(CallingSequence callingSequence) {
-        return callingSequence.argBindings()
+        return callingSequence.argumentBindings()
                 .filter(Binding.VMStore.class::isInstance)
                 .map(Binding.VMStore.class::cast);
     }
 
     private Binding.VMLoad[] retMoveBindings(CallingSequence callingSequence) {
-        return callingSequence.retBindings()
+        return callingSequence.returnBindings().stream()
                 .filter(Binding.VMLoad.class::isInstance)
                 .map(Binding.VMLoad.class::cast)
                 .toArray(Binding.VMLoad[]::new);
diff --git a/src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.hotspot.test/src/org/graalvm/compiler/hotspot/test/CheckGraalIntrinsics.java b/src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.hotspot.test/src/org/graalvm/compiler/hotspot/test/CheckGraalIntrinsics.java
index fe4034c768146..400c5434d0f00 100644
--- a/src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.hotspot.test/src/org/graalvm/compiler/hotspot/test/CheckGraalIntrinsics.java
+++ b/src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.hotspot.test/src/org/graalvm/compiler/hotspot/test/CheckGraalIntrinsics.java
@@ -437,6 +437,11 @@ public CheckGraalIntrinsics() {
                             "java/lang/Math.signum(D)D",
                             "java/lang/Math.signum(F)F",
                             "sun/security/provider/MD5.implCompress0([BI)V");
+
+            // Panama
+            add(toBeInvestigated,
+                    // Native method handle intrinsics
+                    "java/lang/invoke/MethodHandle.linkToNative*");
         }
 
         if (!config.inlineNotify()) {
diff --git a/test/jdk/java/foreign/StdLibTest.java b/test/jdk/java/foreign/StdLibTest.java
index 35713b8e6742b..28fe1992b0a7f 100644
--- a/test/jdk/java/foreign/StdLibTest.java
+++ b/test/jdk/java/foreign/StdLibTest.java
@@ -336,7 +336,7 @@ private MethodHandle specializedPrintf(List args) {
             FunctionDescriptor fd = printfBase;
             for (PrintfArg arg : args) {
                 mt = mt.appendParameterTypes(arg.carrier);
-                fd = fd.appendArgumentLayouts(arg.layout);
+                fd = fd.withAppendedArgumentLayouts(arg.layout);
             }
             MethodHandle mh = abi.downcallHandle(printfAddr, mt, fd);
             return mh.asSpreader(1, Object[].class, args.size());
diff --git a/test/jdk/java/foreign/TestFunctionDescriptor.java b/test/jdk/java/foreign/TestFunctionDescriptor.java
index 44e21e5cdaf90..6890f0c06077a 100644
--- a/test/jdk/java/foreign/TestFunctionDescriptor.java
+++ b/test/jdk/java/foreign/TestFunctionDescriptor.java
@@ -88,7 +88,7 @@ public void testAttribute() {
     public void testAppendArgumentLayouts() {
         FunctionDescriptor fd = FunctionDescriptor.of(C_INT, C_DOUBLE, C_LONGLONG)
                                                   .withAttribute(DUMMY_ATTR, true);
-        fd = fd.appendArgumentLayouts(C_POINTER);
+        fd = fd.withAppendedArgumentLayouts(C_POINTER);
 
         assertEquals(fd.argumentLayouts(), List.of(C_DOUBLE, C_LONGLONG, C_POINTER));
         Optional returnLayoutOp = fd.returnLayout();
@@ -101,7 +101,7 @@ public void testAppendArgumentLayouts() {
     public void testChangeReturnLayout() {
         FunctionDescriptor fd = FunctionDescriptor.of(C_INT, C_DOUBLE, C_LONGLONG)
                                                   .withAttribute(DUMMY_ATTR, true);
-        fd = fd.changeReturnLayout(C_INT);
+        fd = fd.withReturnLayout(C_INT);
 
         assertEquals(fd.argumentLayouts(), List.of(C_DOUBLE, C_LONGLONG));
         Optional returnLayoutOp = fd.returnLayout();
@@ -114,7 +114,7 @@ public void testChangeReturnLayout() {
     public void testDropReturnLayout() {
         FunctionDescriptor fd = FunctionDescriptor.of(C_INT, C_DOUBLE, C_LONGLONG)
                                                   .withAttribute(DUMMY_ATTR, true);
-        fd = fd.dropReturnLayout();
+        fd = fd.withVoidReturnLayout();
 
         assertEquals(fd.argumentLayouts(), List.of(C_DOUBLE, C_LONGLONG));
         Optional returnLayoutOp = fd.returnLayout();
@@ -135,13 +135,13 @@ public void testNullReturnLayout() {
     @Test(expectedExceptions = NullPointerException.class)
     public void testNullArgumentLayoutsAppend() {
         FunctionDescriptor fd = FunctionDescriptor.ofVoid(C_INT, C_LONGLONG);
-        fd.appendArgumentLayouts(C_DOUBLE, null); // should throw
+        fd.withAppendedArgumentLayouts(C_DOUBLE, null); // should throw
     }
 
     @Test(expectedExceptions = NullPointerException.class)
     public void testNullReturnLayoutChange() {
         FunctionDescriptor fd = FunctionDescriptor.ofVoid(C_INT, C_LONGLONG);
-        fd.changeReturnLayout(null); // should throw
+        fd.withReturnLayout(null); // should throw
     }
 
 }
diff --git a/test/jdk/java/foreign/TestIntrinsics.java b/test/jdk/java/foreign/TestIntrinsics.java
index 3bb5dbb8011df..c95cea7cf2f45 100644
--- a/test/jdk/java/foreign/TestIntrinsics.java
+++ b/test/jdk/java/foreign/TestIntrinsics.java
@@ -125,7 +125,7 @@ public Object[][] tests() {
             for (int i = 0; i < args.length; i++) {
                 LibraryLookup.Symbol ma = lookup.lookup("invoke_high_arity" + i).orElseThrow();
                 MethodType mt = baseMT.changeReturnType(baseMT.parameterType(i));
-                FunctionDescriptor fd = baseFD.changeReturnLayout(baseFD.argumentLayouts().get(i));
+                FunctionDescriptor fd = baseFD.withReturnLayout(baseFD.argumentLayouts().get(i));
                 Object expected = args[i];
                 tests.add(abi.downcallHandle(ma, mt, fd), expected, args);
                 tests.add(abi.downcallHandle(ma, mt, fd.withAttribute(TRIVIAL_ATTRIBUTE_NAME, true)), expected, args);
diff --git a/test/jdk/java/foreign/callarranger/TestSysVCallArranger.java b/test/jdk/java/foreign/callarranger/TestSysVCallArranger.java
index 88d9bebd57a20..48cef83c86745 100644
--- a/test/jdk/java/foreign/callarranger/TestSysVCallArranger.java
+++ b/test/jdk/java/foreign/callarranger/TestSysVCallArranger.java
@@ -62,7 +62,7 @@ public void testEmpty() {
         assertFalse(bindings.isInMemoryReturn);
         CallingSequence callingSequence = bindings.callingSequence;
         assertEquals(callingSequence.methodType(), mt.appendParameterTypes(long.class));
-        assertEquals(callingSequence.functionDesc(), fd.appendArgumentLayouts(C_LONG));
+        assertEquals(callingSequence.functionDesc(), fd.withAppendedArgumentLayouts(C_LONG));
 
         checkArgumentBindings(callingSequence, new Binding[][]{
             { vmStore(rax, long.class) }
@@ -89,7 +89,7 @@ public void testNestedStructs() {
         assertFalse(bindings.isInMemoryReturn);
         CallingSequence callingSequence = bindings.callingSequence;
         assertEquals(callingSequence.methodType(), mt.appendParameterTypes(long.class));
-        assertEquals(callingSequence.functionDesc(), fd.appendArgumentLayouts(C_LONG));
+        assertEquals(callingSequence.functionDesc(), fd.withAppendedArgumentLayouts(C_LONG));
 
         checkArgumentBindings(callingSequence, new Binding[][]{
                 { dup(), bufferLoad(0, long.class), vmStore(rdi, long.class),
@@ -119,7 +119,7 @@ public void testNestedUnion() {
         assertFalse(bindings.isInMemoryReturn);
         CallingSequence callingSequence = bindings.callingSequence;
         assertEquals(callingSequence.methodType(), mt.appendParameterTypes(long.class));
-        assertEquals(callingSequence.functionDesc(), fd.appendArgumentLayouts(C_LONG));
+        assertEquals(callingSequence.functionDesc(), fd.withAppendedArgumentLayouts(C_LONG));
 
         checkArgumentBindings(callingSequence, new Binding[][]{
                 { dup(), bufferLoad(0, long.class), vmStore(rdi, long.class),
@@ -148,7 +148,7 @@ public void testNestedStructsUnaligned() {
         assertFalse(bindings.isInMemoryReturn);
         CallingSequence callingSequence = bindings.callingSequence;
         assertEquals(callingSequence.methodType(), mt.appendParameterTypes(long.class));
-        assertEquals(callingSequence.functionDesc(), fd.appendArgumentLayouts(C_LONG));
+        assertEquals(callingSequence.functionDesc(), fd.withAppendedArgumentLayouts(C_LONG));
 
         checkArgumentBindings(callingSequence, new Binding[][]{
                 { dup(), bufferLoad(0, long.class), vmStore(stackStorage(0), long.class),
@@ -177,7 +177,7 @@ public void testNestedUnionUnaligned() {
         assertFalse(bindings.isInMemoryReturn);
         CallingSequence callingSequence = bindings.callingSequence;
         assertEquals(callingSequence.methodType(), mt.appendParameterTypes(long.class));
-        assertEquals(callingSequence.functionDesc(), fd.appendArgumentLayouts(C_LONG));
+        assertEquals(callingSequence.functionDesc(), fd.withAppendedArgumentLayouts(C_LONG));
 
         checkArgumentBindings(callingSequence, new Binding[][]{
                 { dup(), bufferLoad(0, long.class), vmStore(stackStorage(0), long.class),
@@ -201,7 +201,7 @@ public void testIntegerRegs() {
         assertFalse(bindings.isInMemoryReturn);
         CallingSequence callingSequence = bindings.callingSequence;
         assertEquals(callingSequence.methodType(), mt.appendParameterTypes(long.class));
-        assertEquals(callingSequence.functionDesc(), fd.appendArgumentLayouts(C_LONG));
+        assertEquals(callingSequence.functionDesc(), fd.withAppendedArgumentLayouts(C_LONG));
 
         checkArgumentBindings(callingSequence, new Binding[][]{
             { vmStore(rdi, int.class) },
@@ -231,7 +231,7 @@ public void testDoubleRegs() {
         assertFalse(bindings.isInMemoryReturn);
         CallingSequence callingSequence = bindings.callingSequence;
         assertEquals(callingSequence.methodType(), mt.appendParameterTypes(long.class));
-        assertEquals(callingSequence.functionDesc(), fd.appendArgumentLayouts(C_LONG));
+        assertEquals(callingSequence.functionDesc(), fd.withAppendedArgumentLayouts(C_LONG));
 
         checkArgumentBindings(callingSequence, new Binding[][]{
             { vmStore(xmm0, double.class) },
@@ -265,7 +265,7 @@ public void testMixed() {
         assertFalse(bindings.isInMemoryReturn);
         CallingSequence callingSequence = bindings.callingSequence;
         assertEquals(callingSequence.methodType(), mt.appendParameterTypes(long.class));
-        assertEquals(callingSequence.functionDesc(), fd.appendArgumentLayouts(C_LONG));
+        assertEquals(callingSequence.functionDesc(), fd.withAppendedArgumentLayouts(C_LONG));
 
         checkArgumentBindings(callingSequence, new Binding[][]{
             { vmStore(rdi, long.class) },
@@ -321,7 +321,7 @@ public void testAbiExample() {
         assertFalse(bindings.isInMemoryReturn);
         CallingSequence callingSequence = bindings.callingSequence;
         assertEquals(callingSequence.methodType(), mt.appendParameterTypes(long.class));
-        assertEquals(callingSequence.functionDesc(), fd.appendArgumentLayouts(C_LONG));
+        assertEquals(callingSequence.functionDesc(), fd.withAppendedArgumentLayouts(C_LONG));
 
         checkArgumentBindings(callingSequence, new Binding[][]{
             { vmStore(rdi, int.class) },
@@ -363,7 +363,7 @@ public void testMemoryAddress() {
         assertFalse(bindings.isInMemoryReturn);
         CallingSequence callingSequence = bindings.callingSequence;
         assertEquals(callingSequence.methodType(), mt.appendParameterTypes(long.class));
-        assertEquals(callingSequence.functionDesc(), fd.appendArgumentLayouts(C_LONG));
+        assertEquals(callingSequence.functionDesc(), fd.withAppendedArgumentLayouts(C_LONG));
 
         checkArgumentBindings(callingSequence, new Binding[][]{
             { unboxAddress(), vmStore(rdi, long.class) },
@@ -384,7 +384,7 @@ public void testStruct(MemoryLayout struct, Binding[] expectedBindings) {
         assertFalse(bindings.isInMemoryReturn);
         CallingSequence callingSequence = bindings.callingSequence;
         assertEquals(callingSequence.methodType(), mt.appendParameterTypes(long.class));
-        assertEquals(callingSequence.functionDesc(), fd.appendArgumentLayouts(C_LONG));
+        assertEquals(callingSequence.functionDesc(), fd.withAppendedArgumentLayouts(C_LONG));
 
         checkArgumentBindings(callingSequence, new Binding[][]{
             expectedBindings,
@@ -442,7 +442,7 @@ public void testReturnRegisterStruct() {
         assertFalse(bindings.isInMemoryReturn);
         CallingSequence callingSequence = bindings.callingSequence;
         assertEquals(callingSequence.methodType(), mt.appendParameterTypes(long.class));
-        assertEquals(callingSequence.functionDesc(), fd.appendArgumentLayouts(C_LONG));
+        assertEquals(callingSequence.functionDesc(), fd.withAppendedArgumentLayouts(C_LONG));
 
         checkArgumentBindings(callingSequence, new Binding[][]{
             { vmStore(rax, long.class) }

From d1c1309a57b42f3698536de61954e5f10f4b6c80 Mon Sep 17 00:00:00 2001
From: Jorn Vernee 
Date: Thu, 22 Oct 2020 16:22:24 +0200
Subject: [PATCH 33/70] Add missing resource marks before parsing descriptors

---
 src/hotspot/cpu/aarch64/universalNativeInvoker_aarch64.cpp | 1 +
 src/hotspot/cpu/aarch64/universalUpcallHandler_aarch64.cpp | 1 +
 src/hotspot/cpu/x86/universalNativeInvoker_x86.cpp         | 1 +
 src/hotspot/cpu/x86/universalUpcallHandler_x86.cpp         | 1 +
 4 files changed, 4 insertions(+)

diff --git a/src/hotspot/cpu/aarch64/universalNativeInvoker_aarch64.cpp b/src/hotspot/cpu/aarch64/universalNativeInvoker_aarch64.cpp
index eb6967a40bb75..7fad3e653e379 100644
--- a/src/hotspot/cpu/aarch64/universalNativeInvoker_aarch64.cpp
+++ b/src/hotspot/cpu/aarch64/universalNativeInvoker_aarch64.cpp
@@ -150,6 +150,7 @@ class ProgrammableInvokerGenerator : public StubCodeGenerator {
 };
 
 jlong ProgrammableInvoker::generate_adapter(jobject jabi, jobject jlayout) {
+  ResourceMark rm;
   const ABIDescriptor abi = ForeignGlobals::parseABIDescriptor(jabi);
   const BufferLayout layout = ForeignGlobals::parseBufferLayout(jlayout);
 
diff --git a/src/hotspot/cpu/aarch64/universalUpcallHandler_aarch64.cpp b/src/hotspot/cpu/aarch64/universalUpcallHandler_aarch64.cpp
index 17b5255357952..3dcf2cf0b9841 100644
--- a/src/hotspot/cpu/aarch64/universalUpcallHandler_aarch64.cpp
+++ b/src/hotspot/cpu/aarch64/universalUpcallHandler_aarch64.cpp
@@ -185,6 +185,7 @@ static address generate_upcall_stub(jobject rec, const ABIDescriptor& abi,
 }
 
 jlong ProgrammableUpcallHandler::generate_upcall_stub(jobject rec, jobject jabi, jobject jlayout) {
+  ResourceMark rm;
   const ABIDescriptor abi = ForeignGlobals::parseABIDescriptor(jabi);
   const BufferLayout layout = ForeignGlobals::parseBufferLayout(jlayout);
 
diff --git a/src/hotspot/cpu/x86/universalNativeInvoker_x86.cpp b/src/hotspot/cpu/x86/universalNativeInvoker_x86.cpp
index 70d458b16431a..eeaa7a56a6a0d 100644
--- a/src/hotspot/cpu/x86/universalNativeInvoker_x86.cpp
+++ b/src/hotspot/cpu/x86/universalNativeInvoker_x86.cpp
@@ -188,6 +188,7 @@ class ProgrammableInvokerGenerator : public StubCodeGenerator {
 };
 
 jlong ProgrammableInvoker::generate_adapter(jobject jabi, jobject jlayout) {
+  ResourceMark rm;
   const ABIDescriptor abi = ForeignGlobals::parseABIDescriptor(jabi);
   const BufferLayout layout = ForeignGlobals::parseBufferLayout(jlayout);
 
diff --git a/src/hotspot/cpu/x86/universalUpcallHandler_x86.cpp b/src/hotspot/cpu/x86/universalUpcallHandler_x86.cpp
index 87318bb927289..e54935983e5cf 100644
--- a/src/hotspot/cpu/x86/universalUpcallHandler_x86.cpp
+++ b/src/hotspot/cpu/x86/universalUpcallHandler_x86.cpp
@@ -237,6 +237,7 @@ static address generate_upcall_stub(jobject rec, const ABIDescriptor& abi, const
 }
 
 jlong ProgrammableUpcallHandler::generate_upcall_stub(jobject rec, jobject jabi, jobject jlayout) {
+  ResourceMark rm;
   const ABIDescriptor abi = ForeignGlobals::parseABIDescriptor(jabi);
   const BufferLayout layout = ForeignGlobals::parseBufferLayout(jlayout);
 

From 33f41435bffab57dbcbe0f6d3560825151399b2b Mon Sep 17 00:00:00 2001
From: Maurizio Cimadamore 
Date: Thu, 22 Oct 2020 15:37:23 +0100
Subject: [PATCH 34/70] Simplify AbstractNativeScope::allocate

---
 .../internal/foreign/AbstractNativeScope.java | 41 ++++++++++++-------
 1 file changed, 27 insertions(+), 14 deletions(-)

diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/AbstractNativeScope.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/AbstractNativeScope.java
index 3680606371d6d..6d7efc8343977 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/AbstractNativeScope.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/AbstractNativeScope.java
@@ -100,25 +100,38 @@ public UnboundedNativeScope() {
         @Override
         public MemorySegment allocate(long bytesSize, long bytesAlignment) {
             checkOwnerThread();
-            if (bytesSize > MAX_ALLOC_SIZE) {
+            if (Utils.alignUp(bytesSize, bytesAlignment) > MAX_ALLOC_SIZE) {
                 MemorySegment segment = newSegment(bytesSize, bytesAlignment);
                 return segment.withAccessModes(SCOPE_MASK);
             }
-            for (int i = 0; i < 2; i++) {
-                long min = segment.address().toRawLongValue();
-                long start = Utils.alignUp(min + sp, bytesAlignment) - min;
-                try {
-                    MemorySegment slice = segment.asSlice(start, bytesSize)
-                            .withAccessModes(SCOPE_MASK);
-                    sp = start + bytesSize;
-                    size += Utils.alignUp(bytesSize, bytesAlignment);
-                    return slice;
-                } catch (IndexOutOfBoundsException ex) {
-                    sp = 0L;
-                    segment = newSegment(BLOCK_SIZE, 1L);
+            // try to slice from current segment first...
+            MemorySegment slice = trySlice(bytesSize, bytesAlignment);
+            if (slice == null) {
+                // ... if that fails, allocate a new segment and slice from there
+                sp = 0L;
+                segment = newSegment(BLOCK_SIZE, 1L);
+                slice = trySlice(bytesSize, bytesAlignment);
+                if (slice == null) {
+                    // this should not be possible - allocations that do not fit in BLOCK_SIZE should get their own
+                    // standalone segment (see above).
+                    throw new AssertionError("Cannot get here!");
                 }
             }
-            throw new AssertionError("Cannot get here!");
+            return slice;
+        }
+
+        private MemorySegment trySlice(long bytesSize, long bytesAlignment) {
+            long min = segment.address().toRawLongValue();
+            long start = Utils.alignUp(min + sp, bytesAlignment) - min;
+            if (segment.byteSize() - start < bytesSize) {
+                return null;
+            } else {
+                MemorySegment slice = segment.asSlice(start, bytesSize)
+                        .withAccessModes(SCOPE_MASK);
+                sp = start + bytesSize;
+                size += Utils.alignUp(bytesSize, bytesAlignment);
+                return slice;
+            }
         }
     }
 

From 7675bbcd6997cdd0a91869830291f183d440776f Mon Sep 17 00:00:00 2001
From: Maurizio Cimadamore 
Date: Thu, 22 Oct 2020 17:29:26 +0100
Subject: [PATCH 35/70] Fix CLinker javadoc

---
 .../share/classes/jdk/incubator/foreign/CLinker.java            | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/CLinker.java b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/CLinker.java
index de3047ee0e909..4d1e7c0958c83 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/CLinker.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/CLinker.java
@@ -137,7 +137,7 @@ static CLinker getInstance() {
      * passed to other foreign functions (as a function pointer); calling such a function pointer
      * from native code will result in the execution of the provided method handle.
      *
-     * 
The returned segment is not thread-confined, and it only features
+     * 
The returned segment is shared, and it only features
      * the {@link MemorySegment#CLOSE} access mode. When the returned segment is closed,
      * the corresponding native stub will be deallocated.

      *

From 2c2d2a709980422903e7003d0451bca1c1763129 Mon Sep 17 00:00:00 2001
From: Maurizio Cimadamore 
Date: Thu, 22 Oct 2020 17:56:57 +0100
Subject: [PATCH 36/70] Fix whitespaces

---
 src/hotspot/cpu/aarch64/universalUpcallHandler_aarch64.cpp | 2 +-
 src/hotspot/cpu/x86/universalUpcallHandler_x86.cpp         | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/hotspot/cpu/aarch64/universalUpcallHandler_aarch64.cpp b/src/hotspot/cpu/aarch64/universalUpcallHandler_aarch64.cpp
index 5621c9e9f5c06..d4eb1236b9919 100644
--- a/src/hotspot/cpu/aarch64/universalUpcallHandler_aarch64.cpp
+++ b/src/hotspot/cpu/aarch64/universalUpcallHandler_aarch64.cpp
@@ -124,7 +124,7 @@ addres ProgrammableUpcallHandler::generate_upcall_stub(jobject rec, jobject jabi
   ResourceMark rm;
   const ABIDescriptor abi = ForeignGlobals::parse_abi_descriptor(jabi);
   const BufferLayout layout = ForeignGlobals::parse_buffer_layout(jlayout);
-  
+
   CodeBuffer buffer("upcall_stub", 1024, upcall_stub_size);
 
   MacroAssembler* _masm = new MacroAssembler(&buffer);
diff --git a/src/hotspot/cpu/x86/universalUpcallHandler_x86.cpp b/src/hotspot/cpu/x86/universalUpcallHandler_x86.cpp
index d24dca3d438d6..93514a48e2a35 100644
--- a/src/hotspot/cpu/x86/universalUpcallHandler_x86.cpp
+++ b/src/hotspot/cpu/x86/universalUpcallHandler_x86.cpp
@@ -119,7 +119,7 @@ static void upcall_helper(jobject rec, address buff) {
   JavaCalls::call_static(&result, upcall_info.upcall_method.klass, upcall_info.upcall_method.name, upcall_info.upcall_method.sig, &args, thread);
 }
 
-address ProgrammableUpcallHandler::generate_upcall_stub(jobject rec, jobject jabi, jobject jlayout) {  
+address ProgrammableUpcallHandler::generate_upcall_stub(jobject rec, jobject jabi, jobject jlayout) {
   ResourceMark rm;
   const ABIDescriptor abi = ForeignGlobals::parse_abi_descriptor(jabi);
   const BufferLayout layout = ForeignGlobals::parse_buffer_layout(jlayout);

From 5d4c8af1898545757690c2e45e2218b8c7beb7b5 Mon Sep 17 00:00:00 2001
From: Maurizio Cimadamore 
Date: Tue, 27 Oct 2020 12:41:42 +0000
Subject: [PATCH 37/70] Address review comment for scoped memory access
 makefile

---
 .../gensrc/GensrcScopedMemoryAccess.gmk        | 18 +++++++-----------
 1 file changed, 7 insertions(+), 11 deletions(-)

diff --git a/make/modules/java.base/gensrc/GensrcScopedMemoryAccess.gmk b/make/modules/java.base/gensrc/GensrcScopedMemoryAccess.gmk
index ec0d8dd6087de..3afd76473feb1 100644
--- a/make/modules/java.base/gensrc/GensrcScopedMemoryAccess.gmk
+++ b/make/modules/java.base/gensrc/GensrcScopedMemoryAccess.gmk
@@ -23,15 +23,11 @@
 # questions.
 #
 
-GENSRC_SCOPED_MEMORY_ACCESS :=
-
-
 SCOPED_MEMORY_ACCESS_GENSRC_DIR := $(SUPPORT_OUTPUTDIR)/gensrc/java.base/jdk/internal/misc
 SCOPED_MEMORY_ACCESS_SRC_DIR := $(TOPDIR)/src/java.base/share/classes/jdk/internal/misc
-
 SCOPED_MEMORY_ACCESS_TEMPLATE := $(SCOPED_MEMORY_ACCESS_SRC_DIR)/X-ScopedMemoryAccess.java.template
 SCOPED_MEMORY_ACCESS_BIN_TEMPLATE := $(SCOPED_MEMORY_ACCESS_SRC_DIR)/X-ScopedMemoryAccess-bin.java.template
-DEST := $(SCOPED_MEMORY_ACCESS_GENSRC_DIR)/ScopedMemoryAccess.java
+SCOPED_MEMORY_ACCESS_DEST := $(SCOPED_MEMORY_ACCESS_GENSRC_DIR)/ScopedMemoryAccess.java
 
 ################################################################################
 # Setup a rule for generating the ScopedMemoryAccess java class
@@ -144,12 +140,12 @@ SCOPE_MEMORY_ACCESS_TYPES := Byte Short Char Int Long Float Double
 $(foreach t, $(SCOPE_MEMORY_ACCESS_TYPES), \
   $(eval $(call GenerateScopedOp,BIN_$t,$t)))
 	
-$(DEST): $(BUILD_TOOLS_JDK) $(SCOPED_MEMORY_ACCESS_TEMPLATE) $(SCOPED_MEMORY_ACCESS_BIN_TEMPLATE)
-	$(MKDIR) -p $(SCOPED_MEMORY_ACCESS_GENSRC_DIR)
-	$(CP) $(SCOPED_MEMORY_ACCESS_TEMPLATE) $(DEST)
+$(SCOPED_MEMORY_ACCESS_DEST): $(BUILD_TOOLS_JDK) $(SCOPED_MEMORY_ACCESS_TEMPLATE) $(SCOPED_MEMORY_ACCESS_BIN_TEMPLATE)
+	$(call MakeDir, $(SCOPED_MEMORY_ACCESS_GENSRC_DIR))
+	$(CP) $(SCOPED_MEMORY_ACCESS_TEMPLATE) $(SCOPED_MEMORY_ACCESS_DEST)
 	$(foreach t, $(SCOPE_MEMORY_ACCESS_TYPES), \
 	  $(TOOL_SPP) -nel -K$(BIN_$t_type) -Dtype=$(BIN_$t_type) -DType=$(BIN_$t_Type) $(BIN_$t_ARGS) \
-	  -i$(SCOPED_MEMORY_ACCESS_BIN_TEMPLATE) -o$(DEST) ;)
-	$(PRINTF) "}\n" >> $(DEST)
+	  -i$(SCOPED_MEMORY_ACCESS_BIN_TEMPLATE) -o$(SCOPED_MEMORY_ACCESS_DEST) ;)
+	$(PRINTF) "}\n" >> $(SCOPED_MEMORY_ACCESS_DEST)
 	
-TARGETS += $(DEST)
+TARGETS += $(SCOPED_MEMORY_ACCESS_DEST)

From dd8896a00b98796b472708f9b21ebfc865b19113 Mon Sep 17 00:00:00 2001
From: Maurizio Cimadamore 
Date: Tue, 27 Oct 2020 14:33:51 +0000
Subject: [PATCH 38/70] Tweak javadoc for MemorySegment::mapFromPath Tweak
 alignment for long/double Java layouts on 32 bits platforms

---
 .../jdk/incubator/foreign/MemoryLayouts.java  | 28 +++++++++++++------
 .../jdk/incubator/foreign/MemorySegment.java  |  7 ++++-
 2 files changed, 26 insertions(+), 9 deletions(-)

diff --git a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MemoryLayouts.java b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MemoryLayouts.java
index fb71e12cf6f23..70a8edbcee804 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MemoryLayouts.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MemoryLayouts.java
@@ -103,6 +103,11 @@ private MemoryLayouts() {
      */
     public static final MemoryLayout PAD_64 = MemoryLayout.ofPaddingBits(64);
 
+    /**
+     * A value layout constant whose size is the same as that of a machine address (e.g. {@code size_t}), and byte order set to {@link ByteOrder#nativeOrder()}.
+     */
+    public static final ValueLayout ADDRESS = MemoryLayout.ofValueBits(Unsafe.ADDRESS_SIZE * 8, ByteOrder.nativeOrder());
+
     /**
      * A value layout constant whose size is the same as that of a Java {@code byte}, and byte order set to {@link ByteOrder#nativeOrder()}.
      */
@@ -125,8 +130,14 @@ private MemoryLayouts() {
 
     /**
      * A value layout constant whose size is the same as that of a Java {@code long}, and byte order set to {@link ByteOrder#nativeOrder()}.
+     * The alignment of this layout (see {@link MemoryLayout#byteAlignment()} is platform-dependent, so that the following
+     * invariant holds:
+     * 
{@code
+    MemoryLayouts.JAVA_LONG.byteAlignment() == MemoryLayouts.ADDRESS.byteSize();
+     * }

      */
-    public static final ValueLayout JAVA_LONG = MemoryLayout.ofValueBits(64, ByteOrder.nativeOrder());
+    public static final ValueLayout JAVA_LONG = MemoryLayout.ofValueBits(64, ByteOrder.nativeOrder())
+            .withBitAlignment(ADDRESS.bitSize());
 
     /**
      * A value layout constant whose size is the same as that of a Java {@code float}, and byte order set to {@link ByteOrder#nativeOrder()}.
@@ -135,11 +146,12 @@ private MemoryLayouts() {
 
     /**
      * A value layout constant whose size is the same as that of a Java {@code double}, and byte order set to {@link ByteOrder#nativeOrder()}.
-     */
-    public static final ValueLayout JAVA_DOUBLE = MemoryLayout.ofValueBits(64, ByteOrder.nativeOrder());
-
-    /**
-     * A value layout constant whose size is the same as that of a machine address (e.g. {@code size_t}), and byte order set to {@link ByteOrder#nativeOrder()}.
-     */
-    public static final ValueLayout ADDRESS = MemoryLayout.ofValueBits(Unsafe.ADDRESS_SIZE * 8, ByteOrder.nativeOrder());
+     * The alignment of this layout (see {@link MemoryLayout#byteAlignment()} is platform-dependent, so that the following
+     * invariant holds:
+     * 
{@code
+    MemoryLayouts.JAVA_DOUBLE.byteAlignment() == MemoryLayouts.ADDRESS.byteSize();
+     * }

+     */
+    public static final ValueLayout JAVA_DOUBLE = MemoryLayout.ofValueBits(64, ByteOrder.nativeOrder())
+            .withBitAlignment(ADDRESS.bitSize());
 }
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MemorySegment.java b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MemorySegment.java
index a79ac33304653..fb3fd60d36fe2 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MemorySegment.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MemorySegment.java
@@ -830,8 +830,13 @@ static MemorySegment allocateNative(long bytesSize) {
      * @return a new confined mapped memory segment.
      * @throws IllegalArgumentException if {@code bytesOffset < 0}.
      * @throws IllegalArgumentException if {@code bytesSize < 0}.
-     * @throws UnsupportedOperationException if an unsupported map mode is specified.
+     * @throws UnsupportedOperationException if an unsupported map mode is specified, or if the {@code path} is associated
+     * with a provider that does not support creating file channels.
      * @throws IOException if the specified path does not point to an existing file, or if some other I/O error occurs.
+     * @throws  SecurityException If a security manager is installed and it denies an unspecified permission required by the implementation.
+     * In the case of the default provider, the {@link SecurityManager#checkRead(String)} method is invoked to check
+     * read access if the file is opened for reading. The {@link SecurityManager#checkWrite(String)} method is invoked to check
+     * write access if the file is opened for writing.
      */
     static MemorySegment mapFromPath(Path path, long bytesOffset, long bytesSize, FileChannel.MapMode mapMode) throws IOException {
         return MappedMemorySegmentImpl.makeMappedSegment(path, bytesOffset, bytesSize, mapMode);

From f844f544b78e292e17193d29ee58e34e6bf2763b Mon Sep 17 00:00:00 2001
From: Maurizio Cimadamore 
Date: Tue, 27 Oct 2020 14:36:24 +0000
Subject: [PATCH 39/70] Remove TestMismatch from 32-bit problem list

---
 test/jdk/ProblemList.txt | 1 -
 1 file changed, 1 deletion(-)

diff --git a/test/jdk/ProblemList.txt b/test/jdk/ProblemList.txt
index 5a2abd7d5e924..84e8af2f71864 100644
--- a/test/jdk/ProblemList.txt
+++ b/test/jdk/ProblemList.txt
@@ -560,7 +560,6 @@ java/beans/XMLEncoder/Test6570354.java 8015593 macosx-all
 # jdk_foreign
 
 java/foreign/TestMismatch.java 8249684 macosx-all
-java/foreign/TestMismatch.java 8255270 generic-i586
 
 ############################################################################
 

From e43f5d76045632db688b7ed73202ac93d91ba942 Mon Sep 17 00:00:00 2001
From: Maurizio Cimadamore 
Date: Tue, 27 Oct 2020 15:49:28 +0000
Subject: [PATCH 40/70] * Add final to MappedByteBuffer::SCOPED_MEMORY_ACCESS
 field * Tweak TestLayouts to make it 32-bit friendly after recent
 MemoryLayouts tweaks

---
 .../share/classes/java/nio/MappedByteBuffer.java      |  2 +-
 test/jdk/java/foreign/TestLayouts.java                | 11 ++++-------
 2 files changed, 5 insertions(+), 8 deletions(-)

diff --git a/src/java.base/share/classes/java/nio/MappedByteBuffer.java b/src/java.base/share/classes/java/nio/MappedByteBuffer.java
index 3d89edec91e9a..c8a0509218a8a 100644
--- a/src/java.base/share/classes/java/nio/MappedByteBuffer.java
+++ b/src/java.base/share/classes/java/nio/MappedByteBuffer.java
@@ -88,7 +88,7 @@ public abstract class MappedByteBuffer
     // determines the behavior of force operations.
     private final boolean isSync;
 
-    static ScopedMemoryAccess SCOPED_MEMORY_ACCESS = ScopedMemoryAccess.getScopedMemoryAccess();
+    static final ScopedMemoryAccess SCOPED_MEMORY_ACCESS = ScopedMemoryAccess.getScopedMemoryAccess();
 
     // This should only be invoked by the DirectByteBuffer constructors
     //
diff --git a/test/jdk/java/foreign/TestLayouts.java b/test/jdk/java/foreign/TestLayouts.java
index aa683a4defe0e..8a94dd56fdf70 100644
--- a/test/jdk/java/foreign/TestLayouts.java
+++ b/test/jdk/java/foreign/TestLayouts.java
@@ -26,16 +26,13 @@
  * @run testng TestLayouts
  */
 
-import jdk.incubator.foreign.MemoryLayouts;
-import jdk.incubator.foreign.MemoryLayout;
+import jdk.incubator.foreign.*;
 
 import java.lang.invoke.VarHandle;
 import java.nio.ByteOrder;
 import java.util.function.LongFunction;
 import java.util.stream.Stream;
 
-import jdk.incubator.foreign.MemorySegment;
-import jdk.incubator.foreign.SequenceLayout;
 import org.testng.annotations.*;
 import static org.testng.Assert.*;
 
@@ -174,7 +171,7 @@ public void testStructSizeAndAlign() {
                 MemoryLayouts.JAVA_LONG
         );
         assertEquals(struct.byteSize(), 1 + 1 + 2 + 4 + 8);
-        assertEquals(struct.byteAlignment(), 8);
+        assertEquals(struct.byteAlignment(), MemoryLayouts.ADDRESS.byteAlignment());
     }
 
     @Test(dataProvider="basicLayouts")
@@ -204,8 +201,8 @@ public void testUnionSizeAndAlign() {
                 MemoryLayouts.JAVA_INT,
                 MemoryLayouts.JAVA_LONG
         );
-        assertEquals(struct.byteSize(), 8);
-        assertEquals(struct.byteAlignment(), 8);
+        assertEquals(struct.byteSize(), MemoryLayouts.ADDRESS.byteSize());
+        assertEquals(struct.byteAlignment(), MemoryLayouts.ADDRESS.byteAlignment());
     }
 
     @Test(dataProvider = "layoutKinds")

From b01af0931776d8bc753310f5c925cfd63cd97c45 Mon Sep 17 00:00:00 2001
From: Maurizio Cimadamore 
Date: Tue, 27 Oct 2020 19:08:12 +0000
Subject: [PATCH 41/70] More 32-bit fixes for TestLayouts

---
 test/jdk/java/foreign/TestLayouts.java | 14 ++++++--------
 1 file changed, 6 insertions(+), 8 deletions(-)

diff --git a/test/jdk/java/foreign/TestLayouts.java b/test/jdk/java/foreign/TestLayouts.java
index 8a94dd56fdf70..d1b2f29b23d87 100644
--- a/test/jdk/java/foreign/TestLayouts.java
+++ b/test/jdk/java/foreign/TestLayouts.java
@@ -201,7 +201,7 @@ public void testUnionSizeAndAlign() {
                 MemoryLayouts.JAVA_INT,
                 MemoryLayouts.JAVA_LONG
         );
-        assertEquals(struct.byteSize(), MemoryLayouts.ADDRESS.byteSize());
+        assertEquals(struct.byteSize(), 8);
         assertEquals(struct.byteAlignment(), MemoryLayouts.ADDRESS.byteAlignment());
     }
 
@@ -214,8 +214,10 @@ public void testPadding(LayoutKind kind) {
     public void testAlignmentString(MemoryLayout layout, long bitAlign) {
         long[] alignments = { 8, 16, 32, 64, 128 };
         for (long a : alignments) {
-            assertFalse(layout.toString().contains("%"));
-            assertEquals(layout.withBitAlignment(a).toString().contains("%"), a != bitAlign);
+            if (layout.bitAlignment() == layout.bitSize()) {
+                assertFalse(layout.toString().contains("%"));
+                assertEquals(layout.withBitAlignment(a).toString().contains("%"), a != bitAlign);
+            }
         }
     }
 
@@ -306,16 +308,12 @@ public Object[][] basicLayouts() {
 
     @DataProvider(name = "layoutsAndAlignments")
     public Object[][] layoutsAndAlignments() {
-        Object[][] layoutsAndAlignments = new Object[basicLayouts.length * 5][];
+        Object[][] layoutsAndAlignments = new Object[basicLayouts.length * 4][];
         int i = 0;
         //add basic layouts
         for (MemoryLayout l : basicLayouts) {
             layoutsAndAlignments[i++] = new Object[] { l, l.bitAlignment() };
         }
-        //add basic layouts wrapped in a sequence with unspecified size
-        for (MemoryLayout l : basicLayouts) {
-            layoutsAndAlignments[i++] = new Object[] { MemoryLayout.ofSequence(l), l.bitAlignment() };
-        }
         //add basic layouts wrapped in a sequence with given size
         for (MemoryLayout l : basicLayouts) {
             layoutsAndAlignments[i++] = new Object[] { MemoryLayout.ofSequence(4, l), l.bitAlignment() };

From e3ec6b4c9497a82756178969c519c880fe7562cc Mon Sep 17 00:00:00 2001
From: Maurizio Cimadamore 
Date: Thu, 29 Oct 2020 14:09:10 +0000
Subject: [PATCH 42/70] Fix issues with derived buffers and IO operations

---
 .../java/nio/Direct-X-Buffer.java.template    | 12 +++++
 .../misc/X-ScopedMemoryAccess.java.template   |  2 +
 .../jdk/incubator/foreign/MemorySegment.java  | 12 ++++-
 .../jdk/internal/foreign/MemoryScope.java     |  6 +--
 test/jdk/java/foreign/TestByteBuffer.java     | 53 +++++++++++++++++++
 5 files changed, 81 insertions(+), 4 deletions(-)

diff --git a/src/java.base/share/classes/java/nio/Direct-X-Buffer.java.template b/src/java.base/share/classes/java/nio/Direct-X-Buffer.java.template
index 270fb8f41adc3..3ab4a5a52b98b 100644
--- a/src/java.base/share/classes/java/nio/Direct-X-Buffer.java.template
+++ b/src/java.base/share/classes/java/nio/Direct-X-Buffer.java.template
@@ -31,6 +31,7 @@ import java.io.FileDescriptor;
 import java.lang.ref.Reference;
 import java.util.Objects;
 import jdk.internal.access.foreign.MemorySegmentProxy;
+import jdk.internal.misc.ScopedMemoryAccess.Scope;
 import jdk.internal.misc.VM;
 import jdk.internal.ref.Cleaner;
 import sun.nio.ch.DirectBuffer;
@@ -264,6 +265,17 @@ class Direct$Type$Buffer$RW$$BO$
 #if[rw]
 
     public long address() {
+        Scope scope = scope();
+        if (scope != null) {
+            if (scope.ownerThread() == null) {
+                throw new UnsupportedOperationException("ByteBuffer derived from shared segments not supported");
+            }
+            try {
+                scope.checkValidState();
+            } catch (Scope.ScopedAccessError e) {
+                throw new IllegalStateException("This segment is already closed");
+            }
+        }
         return address;
     }
 
diff --git a/src/java.base/share/classes/jdk/internal/misc/X-ScopedMemoryAccess.java.template b/src/java.base/share/classes/jdk/internal/misc/X-ScopedMemoryAccess.java.template
index 81c61fc47dbba..2bf948d33d6ea 100644
--- a/src/java.base/share/classes/jdk/internal/misc/X-ScopedMemoryAccess.java.template
+++ b/src/java.base/share/classes/jdk/internal/misc/X-ScopedMemoryAccess.java.template
@@ -99,6 +99,8 @@ public class ScopedMemoryAccess {
     public interface Scope {
         void checkValidState();
 
+        Thread ownerThread();
+
         /**
          * Error thrown when memory access fails because the memory has already been released.
          * Note: for performance reasons, this exception is never created by client; instead a shared instance
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MemorySegment.java b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MemorySegment.java
index fb3fd60d36fe2..8f0efc1e20cec 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MemorySegment.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MemorySegment.java
@@ -551,11 +551,21 @@ default MemorySegment asSlice(MemoryAddress newBase) {
      * (see {@link ByteBuffer#isReadOnly()}. Additionally, if this is a native memory segment, the resulting buffer is
      * direct (see {@link ByteBuffer#isDirect()}).
      * 

+     * The returned buffer's position (see {@link ByteBuffer#position()} is initially set to zero, while
+     * the returned buffer's capacity and limit (see {@link ByteBuffer#capacity()} and {@link ByteBuffer#limit()}, respectively)
+     * are set to this segment' size (see {@link MemorySegment#byteSize()}). For this reason, a byte buffer cannot be
+     * returned if this segment' size is greater than {@link Integer#MAX_VALUE}.
+     * 

      * The life-cycle of the returned buffer will be tied to that of this segment. That means that if the this segment
      * is closed (see {@link MemorySegment#close()}, accessing the returned
      * buffer will throw an {@link IllegalStateException}.
      * 

-     * The resulting buffer's byte order is {@link java.nio.ByteOrder#BIG_ENDIAN}; this can be changed using
+     * If this segment is shared, calling certain I/O operations on the resulting buffer might result in
+     * an unspecified exception being thrown. Examples of such problematic operations are {@link FileChannel#read(ByteBuffer)},
+     * {@link FileChannel#write(ByteBuffer)}, {@link java.nio.channels.SocketChannel#read(ByteBuffer)} and
+     * {@link java.nio.channels.SocketChannel#write(ByteBuffer)}.
+     * 

+     * Finally, the resulting buffer's byte order is {@link java.nio.ByteOrder#BIG_ENDIAN}; this can be changed using
      * {@link ByteBuffer#order(java.nio.ByteOrder)}.
      *
      * @return a {@link ByteBuffer} view of this memory segment.
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/MemoryScope.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/MemoryScope.java
index 3d093e76778c4..624e5e5ba7ca4 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/MemoryScope.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/MemoryScope.java
@@ -164,7 +164,7 @@ final MemoryScope cleanable(Cleaner cleaner) {
      * Returns "owner" thread of this scope.
      * @return owner thread (or null for a shared scope)
      */
-    abstract Thread ownerThread();
+    public abstract Thread ownerThread();
 
     /**
      * Returns true, if this scope is still alive. This method may be called in any thread.
@@ -221,7 +221,7 @@ void justClose() {
         }
 
         @Override
-        Thread ownerThread() {
+        public Thread ownerThread() {
             return owner;
         }
     }
@@ -261,7 +261,7 @@ static class SharedScope extends MemoryScope {
         }
 
         @Override
-        Thread ownerThread() {
+        public Thread ownerThread() {
             return null;
         }
 
diff --git a/test/jdk/java/foreign/TestByteBuffer.java b/test/jdk/java/foreign/TestByteBuffer.java
index 2c5dd5c4f9630..2aab323e43444 100644
--- a/test/jdk/java/foreign/TestByteBuffer.java
+++ b/test/jdk/java/foreign/TestByteBuffer.java
@@ -529,6 +529,16 @@ public void testBufferToSegment(ByteBuffer bb, Predicate segmentC
         assertEquals(bb.capacity(), segment.byteSize());
     }
 
+    @Test(dataProvider="bufferSources")
+    public void bufferProperties(ByteBuffer bb, Predicate _unused) {
+        try (MemorySegment segment = MemorySegment.ofByteBuffer(bb)) {
+            ByteBuffer buffer = segment.asByteBuffer();
+            assertEquals(buffer.position(), 0);
+            assertEquals(buffer.capacity(), segment.byteSize());
+            assertEquals(buffer.limit(), segment.byteSize());
+        }
+    }
+
     @Test
     public void testRoundTripAccess() {
         try(MemorySegment ms = MemorySegment.allocateNative(4)) {
@@ -548,6 +558,49 @@ public void testDeadAccessOnClosedBufferSegment() {
         MemoryAccess.setInt(s2, 10); // Dead access!
     }
 
+    @Test(expectedExceptions = UnsupportedOperationException.class)
+    public void testIOOnSharedSegmentBuffer() throws IOException {
+        File tmp = File.createTempFile("tmp", "txt");
+        tmp.deleteOnExit();
+        try (FileChannel channel = FileChannel.open(tmp.toPath(), StandardOpenOption.WRITE)) {
+            MemorySegment segment = MemorySegment.allocateNative(10).share();
+            for (int i = 0; i < 10; i++) {
+                MemoryAccess.setByteAtIndex(segment, i, (byte) i);
+            }
+            ByteBuffer bb = segment.asByteBuffer();
+            segment.close();
+            channel.write(bb);
+        }
+    }
+
+    @Test(expectedExceptions = IllegalStateException.class)
+    public void testIOOnClosedConfinedSegmentBuffer() throws IOException {
+        File tmp = File.createTempFile("tmp", "txt");
+        tmp.deleteOnExit();
+        try (FileChannel channel = FileChannel.open(tmp.toPath(), StandardOpenOption.WRITE)) {
+            MemorySegment segment = MemorySegment.allocateNative(10);
+            for (int i = 0; i < 10; i++) {
+                MemoryAccess.setByteAtIndex(segment, i, (byte) i);
+            }
+            ByteBuffer bb = segment.asByteBuffer();
+            segment.close();
+            channel.write(bb);
+        }
+    }
+
+    public void testIOOnClosedConfinedSegment() throws IOException {
+        File tmp = File.createTempFile("tmp", "txt");
+        tmp.deleteOnExit();
+        try (FileChannel channel = FileChannel.open(tmp.toPath(), StandardOpenOption.WRITE)) {
+            MemorySegment segment = MemorySegment.allocateNative(10);
+            for (int i = 0; i < 10; i++) {
+                MemoryAccess.setByteAtIndex(segment, i, (byte) i);
+            }
+            ByteBuffer bb = segment.asByteBuffer();
+            channel.write(bb);
+        }
+    }
+
     @DataProvider(name = "bufferOps")
     public static Object[][] bufferOps() throws Throwable {
         List args = new ArrayList<>();

From 059d3abbcb6239bb2101ba2d5c26c220cab838a2 Mon Sep 17 00:00:00 2001
From: Maurizio Cimadamore 
Date: Fri, 30 Oct 2020 11:05:29 +0000
Subject: [PATCH 43/70] Address CSR feedback

---
 .../jdk/incubator/foreign/CLinker.java        |  8 +--
 .../jdk/incubator/foreign/NativeScope.java    | 24 +++++++-
 .../jdk/internal/foreign/PlatformLayouts.java | 12 ++--
 .../jdk/internal/foreign/abi/SharedUtils.java |  2 +-
 test/jdk/java/foreign/StdLibTest.java         |  2 +-
 test/jdk/java/foreign/TestCondy.java          |  4 +-
 .../java/foreign/TestFunctionDescriptor.java  | 36 ++++++------
 test/jdk/java/foreign/TestIntrinsics.java     |  8 +--
 test/jdk/java/foreign/TestNativeScope.java    | 12 ++++
 .../callarranger/TestWindowsCallArranger.java | 10 ++--
 test/jdk/java/foreign/valist/VaListTest.java  | 56 +++++++++----------
 .../jdk/incubator/foreign/CallOverhead.java   | 10 ++--
 .../bench/jdk/incubator/foreign/VaList.java   |  6 +-
 13 files changed, 111 insertions(+), 79 deletions(-)

diff --git a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/CLinker.java b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/CLinker.java
index 4d1e7c0958c83..8e1b73a57d2b6 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/CLinker.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/CLinker.java
@@ -165,9 +165,9 @@ static CLinker getInstance() {
      */
     ValueLayout C_LONG = pick(SysV.C_LONG, Win64.C_LONG, AArch64.C_LONG);
     /**
-     * The {@code long long} native type.
+     * The layout for the {@code long long} C type.
      */
-    ValueLayout C_LONGLONG = pick(SysV.C_LONGLONG, Win64.C_LONGLONG, AArch64.C_LONGLONG);
+    ValueLayout C_LONG_LONG = pick(SysV.C_LONG_LONG, Win64.C_LONG_LONG, AArch64.C_LONG_LONG);
     /**
      * The layout for the {@code float} C type
      */
@@ -177,9 +177,9 @@ static CLinker getInstance() {
      */
     ValueLayout C_DOUBLE = pick(SysV.C_DOUBLE, Win64.C_DOUBLE, AArch64.C_DOUBLE);
     /**
-     * The {@code long double} native type.
+     * The layout for the {@code long double} C type.
      */
-    ValueLayout C_LONGDOUBLE = pick(SysV.C_LONGDOUBLE, Win64.C_LONGDOUBLE, AArch64.C_LONGDOUBLE);
+    ValueLayout C_LONG_DOUBLE = pick(SysV.C_LONG_DOUBLE, Win64.C_LONG_DOUBLE, AArch64.C_LONG_DOUBLE);
     /**
      * The {@code T*} native type.
      */
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/NativeScope.java b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/NativeScope.java
index 6a5de40e1b834..0508c9390d1d3 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/NativeScope.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/NativeScope.java
@@ -38,7 +38,7 @@
 import java.util.stream.Stream;
 
 /**
- * This class provides a scope, within which several allocations can be performed. An native scope is backed
+ * A native scope is an abstraction which provides shared temporal bounds for one or more allocations, backed
  * by off-heap memory. Native scopes can be either bounded or unbounded, depending on whether the size
  * of the native scope is known statically. If an application knows before-hand how much memory it needs to allocate,
  * then using a bounded native scope will typically provide better performance than independently allocating the memory
@@ -53,6 +53,10 @@
  * (see {@link MemorySegment#handoff(NativeScope)}). This might be useful to allow one or more segments which were independently
  * created to share the same life-cycle as a given native scope - which in turns enables a client to group all memory
  * allocation and usage under a single try-with-resources block.
+ *
+ * @apiNote In the future, if the Java language permits, {@link NativeScope}
+ * may become a {@code sealed} interface, which would prohibit subclassing except by
+ * explicitly permitted types.
  */
 public interface NativeScope extends AutoCloseable {
 
@@ -92,6 +96,24 @@ default MemorySegment allocate(ValueLayout layout, byte value) {
         return addr;
     }
 
+    /**
+     * Allocate a block of memory in this native scope with given layout and initialize it with given char value.
+     * The segment returned by this method is associated with a segment which cannot be closed. Moreover, the returned
+     * segment must conform to the layout alignment constraints.
+     * @param layout the layout of the block of memory to be allocated.
+     * @param value the value to be set on the newly allocated memory block.
+     * @return a segment for the newly allocated memory block.
+     * @throws OutOfMemoryError if there is not enough space left in this native scope, that is, if this is a
+     * bounded allocation scope, and {@code byteSize().getAsLong() - allocatedBytes() < layout.byteSize()}.
+     * @throws IllegalArgumentException if {@code layout.byteSize()} does not conform to the size of a char value.
+     */
+    default MemorySegment allocate(ValueLayout layout, char value) {
+        VarHandle handle = layout.varHandle(char.class);
+        MemorySegment addr = allocate(layout);
+        handle.set(addr, value);
+        return addr;
+    }
+
     /**
      * Allocate a block of memory in this native scope with given layout and initialize it with given short value.
      * The segment returned by this method is associated with a segment which cannot be closed. Moreover, the returned
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/PlatformLayouts.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/PlatformLayouts.java
index 10fa96f64b30b..dc8ef6389fe91 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/PlatformLayouts.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/PlatformLayouts.java
@@ -131,7 +131,7 @@ private SysV() {
         /**
          * The {@code long long} native type.
          */
-        public static final ValueLayout C_LONGLONG = ofLongLong(LITTLE_ENDIAN, 64);
+        public static final ValueLayout C_LONG_LONG = ofLongLong(LITTLE_ENDIAN, 64);
 
         /**
          * The {@code float} native type.
@@ -146,7 +146,7 @@ private SysV() {
         /**
          * The {@code long double} native type.
          */
-        public static final ValueLayout C_LONGDOUBLE = ofLongDouble(LITTLE_ENDIAN, 128);
+        public static final ValueLayout C_LONG_DOUBLE = ofLongDouble(LITTLE_ENDIAN, 128);
 
         /**
          * The {@code T*} native type.
@@ -196,7 +196,7 @@ private Win64() {
         /**
          * The {@code long long} native type.
          */
-        public static final ValueLayout C_LONGLONG = ofLongLong(LITTLE_ENDIAN, 64);
+        public static final ValueLayout C_LONG_LONG = ofLongLong(LITTLE_ENDIAN, 64);
 
         /**
          * The {@code float} native type.
@@ -211,7 +211,7 @@ private Win64() {
         /**
          * The {@code long double} native type.
          */
-        public static final ValueLayout C_LONGDOUBLE = ofLongDouble(LITTLE_ENDIAN, 64);
+        public static final ValueLayout C_LONG_DOUBLE = ofLongDouble(LITTLE_ENDIAN, 64);
 
         /**
          * The {@code T*} native type.
@@ -266,7 +266,7 @@ private AArch64() {
         /**
          * The {@code long long} native type.
          */
-        public static final ValueLayout C_LONGLONG = ofLongLong(LITTLE_ENDIAN, 64);
+        public static final ValueLayout C_LONG_LONG = ofLongLong(LITTLE_ENDIAN, 64);
 
         /**
          * The {@code float} native type.
@@ -281,7 +281,7 @@ private AArch64() {
         /**
          * The {@code long double} native type.
          */
-        public static final ValueLayout C_LONGDOUBLE = ofLongDouble(LITTLE_ENDIAN, 128);
+        public static final ValueLayout C_LONG_DOUBLE = ofLongDouble(LITTLE_ENDIAN, 128);
 
         /**
          * The {@code T*} native type.
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/SharedUtils.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/SharedUtils.java
index 1f402d1bfa0ac..f9b1cad4ab57d 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/SharedUtils.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/SharedUtils.java
@@ -271,7 +271,7 @@ private static class AllocHolder {
 
         final static MethodHandle MH_MALLOC = getSystemLinker().downcallHandle(LOOKUP.lookup("malloc").get(),
                         MethodType.methodType(MemoryAddress.class, long.class),
-                FunctionDescriptor.of(C_POINTER, C_LONGLONG));
+                FunctionDescriptor.of(C_POINTER, C_LONG_LONG));
 
         final static MethodHandle MH_FREE = getSystemLinker().downcallHandle(LOOKUP.lookup("free").get(),
                         MethodType.methodType(void.class, MemoryAddress.class),
diff --git a/test/jdk/java/foreign/StdLibTest.java b/test/jdk/java/foreign/StdLibTest.java
index 28fe1992b0a7f..39d6c37eeb8f5 100644
--- a/test/jdk/java/foreign/StdLibTest.java
+++ b/test/jdk/java/foreign/StdLibTest.java
@@ -176,7 +176,7 @@ static class StdLibHelper {
 
         final static MethodHandle qsort = abi.downcallHandle(lookup.lookup("qsort").get(),
                 MethodType.methodType(void.class, MemoryAddress.class, long.class, long.class, MemoryAddress.class),
-                FunctionDescriptor.ofVoid(C_POINTER, C_LONGLONG, C_LONGLONG, C_POINTER));
+                FunctionDescriptor.ofVoid(C_POINTER, C_LONG_LONG, C_LONG_LONG, C_POINTER));
 
         final static FunctionDescriptor qsortComparFunction = FunctionDescriptor.of(C_INT, C_POINTER, C_POINTER);
 
diff --git a/test/jdk/java/foreign/TestCondy.java b/test/jdk/java/foreign/TestCondy.java
index f802f94161f06..8399ad60b46e8 100644
--- a/test/jdk/java/foreign/TestCondy.java
+++ b/test/jdk/java/foreign/TestCondy.java
@@ -57,10 +57,10 @@ public void testPublicResolve(Constable constable) throws ReflectiveOperationExc
         C_SHORT,
         C_INT,
         C_LONG,
-        C_LONGLONG,
+            C_LONG_LONG,
         C_FLOAT,
         C_DOUBLE,
-        C_LONGDOUBLE,
+            C_LONG_DOUBLE,
         C_POINTER
     };
 
diff --git a/test/jdk/java/foreign/TestFunctionDescriptor.java b/test/jdk/java/foreign/TestFunctionDescriptor.java
index 6890f0c06077a..37b2f0b34f979 100644
--- a/test/jdk/java/foreign/TestFunctionDescriptor.java
+++ b/test/jdk/java/foreign/TestFunctionDescriptor.java
@@ -32,15 +32,13 @@
 import org.testng.annotations.Test;
 
 import java.lang.constant.Constable;
-import java.lang.constant.ConstantDesc;
-import java.lang.invoke.MethodHandles;
 import java.util.List;
 import java.util.Optional;
 import java.util.stream.Collectors;
 
 import static jdk.incubator.foreign.CLinker.C_DOUBLE;
 import static jdk.incubator.foreign.CLinker.C_INT;
-import static jdk.incubator.foreign.CLinker.C_LONGLONG;
+import static jdk.incubator.foreign.CLinker.C_LONG_LONG;
 import static jdk.incubator.foreign.CLinker.C_POINTER;
 import static org.testng.Assert.assertEquals;
 import static org.testng.Assert.assertFalse;
@@ -52,9 +50,9 @@ public class TestFunctionDescriptor {
 
     @Test
     public void testOf() {
-        FunctionDescriptor fd = FunctionDescriptor.of(C_INT, C_DOUBLE, C_LONGLONG);
+        FunctionDescriptor fd = FunctionDescriptor.of(C_INT, C_DOUBLE, C_LONG_LONG);
 
-        assertEquals(fd.argumentLayouts(), List.of(C_DOUBLE, C_LONGLONG));
+        assertEquals(fd.argumentLayouts(), List.of(C_DOUBLE, C_LONG_LONG));
         Optional returnLayoutOp = fd.returnLayout();
         assertTrue(returnLayoutOp.isPresent());
         assertEquals(returnLayoutOp.get(), C_INT);
@@ -62,19 +60,19 @@ public void testOf() {
 
     @Test
     public void testOfVoid() {
-        FunctionDescriptor fd = FunctionDescriptor.ofVoid(C_DOUBLE, C_LONGLONG);
+        FunctionDescriptor fd = FunctionDescriptor.ofVoid(C_DOUBLE, C_LONG_LONG);
 
-        assertEquals(fd.argumentLayouts(), List.of(C_DOUBLE, C_LONGLONG));
+        assertEquals(fd.argumentLayouts(), List.of(C_DOUBLE, C_LONG_LONG));
         Optional returnLayoutOp = fd.returnLayout();
         assertFalse(returnLayoutOp.isPresent());
     }
 
     @Test
     public void testAttribute() {
-        FunctionDescriptor fd = FunctionDescriptor.of(C_INT, C_DOUBLE, C_LONGLONG);
+        FunctionDescriptor fd = FunctionDescriptor.of(C_INT, C_DOUBLE, C_LONG_LONG);
         fd = fd.withAttribute(DUMMY_ATTR, true);
 
-        assertEquals(fd.argumentLayouts(), List.of(C_DOUBLE, C_LONGLONG));
+        assertEquals(fd.argumentLayouts(), List.of(C_DOUBLE, C_LONG_LONG));
         Optional returnLayoutOp = fd.returnLayout();
         assertTrue(returnLayoutOp.isPresent());
         assertEquals(returnLayoutOp.get(), C_INT);
@@ -86,11 +84,11 @@ public void testAttribute() {
 
     @Test
     public void testAppendArgumentLayouts() {
-        FunctionDescriptor fd = FunctionDescriptor.of(C_INT, C_DOUBLE, C_LONGLONG)
+        FunctionDescriptor fd = FunctionDescriptor.of(C_INT, C_DOUBLE, C_LONG_LONG)
                                                   .withAttribute(DUMMY_ATTR, true);
         fd = fd.withAppendedArgumentLayouts(C_POINTER);
 
-        assertEquals(fd.argumentLayouts(), List.of(C_DOUBLE, C_LONGLONG, C_POINTER));
+        assertEquals(fd.argumentLayouts(), List.of(C_DOUBLE, C_LONG_LONG, C_POINTER));
         Optional returnLayoutOp = fd.returnLayout();
         assertTrue(returnLayoutOp.isPresent());
         assertEquals(returnLayoutOp.get(), C_INT);
@@ -99,11 +97,11 @@ public void testAppendArgumentLayouts() {
 
     @Test
     public void testChangeReturnLayout() {
-        FunctionDescriptor fd = FunctionDescriptor.of(C_INT, C_DOUBLE, C_LONGLONG)
+        FunctionDescriptor fd = FunctionDescriptor.of(C_INT, C_DOUBLE, C_LONG_LONG)
                                                   .withAttribute(DUMMY_ATTR, true);
         fd = fd.withReturnLayout(C_INT);
 
-        assertEquals(fd.argumentLayouts(), List.of(C_DOUBLE, C_LONGLONG));
+        assertEquals(fd.argumentLayouts(), List.of(C_DOUBLE, C_LONG_LONG));
         Optional returnLayoutOp = fd.returnLayout();
         assertTrue(returnLayoutOp.isPresent());
         assertEquals(returnLayoutOp.get(), C_INT);
@@ -112,11 +110,11 @@ public void testChangeReturnLayout() {
 
     @Test
     public void testDropReturnLayout() {
-        FunctionDescriptor fd = FunctionDescriptor.of(C_INT, C_DOUBLE, C_LONGLONG)
+        FunctionDescriptor fd = FunctionDescriptor.of(C_INT, C_DOUBLE, C_LONG_LONG)
                                                   .withAttribute(DUMMY_ATTR, true);
         fd = fd.withVoidReturnLayout();
 
-        assertEquals(fd.argumentLayouts(), List.of(C_DOUBLE, C_LONGLONG));
+        assertEquals(fd.argumentLayouts(), List.of(C_DOUBLE, C_LONG_LONG));
         Optional returnLayoutOp = fd.returnLayout();
         assertFalse(returnLayoutOp.isPresent());
         assertEquals(fd.attributes().collect(Collectors.toList()), List.of(DUMMY_ATTR));
@@ -124,23 +122,23 @@ public void testDropReturnLayout() {
 
     @Test(expectedExceptions = NullPointerException.class)
     public void testNullArgumentLayout() {
-        FunctionDescriptor.ofVoid(C_INT, null, C_LONGLONG);
+        FunctionDescriptor.ofVoid(C_INT, null, C_LONG_LONG);
     }
 
     @Test(expectedExceptions = NullPointerException.class)
     public void testNullReturnLayout() {
-        FunctionDescriptor.of(null, C_INT, C_LONGLONG);
+        FunctionDescriptor.of(null, C_INT, C_LONG_LONG);
     }
 
     @Test(expectedExceptions = NullPointerException.class)
     public void testNullArgumentLayoutsAppend() {
-        FunctionDescriptor fd = FunctionDescriptor.ofVoid(C_INT, C_LONGLONG);
+        FunctionDescriptor fd = FunctionDescriptor.ofVoid(C_INT, C_LONG_LONG);
         fd.withAppendedArgumentLayouts(C_DOUBLE, null); // should throw
     }
 
     @Test(expectedExceptions = NullPointerException.class)
     public void testNullReturnLayoutChange() {
-        FunctionDescriptor fd = FunctionDescriptor.ofVoid(C_INT, C_LONGLONG);
+        FunctionDescriptor fd = FunctionDescriptor.ofVoid(C_INT, C_LONG_LONG);
         fd.withReturnLayout(null); // should throw
     }
 
diff --git a/test/jdk/java/foreign/TestIntrinsics.java b/test/jdk/java/foreign/TestIntrinsics.java
index c95cea7cf2f45..925fabe73a337 100644
--- a/test/jdk/java/foreign/TestIntrinsics.java
+++ b/test/jdk/java/foreign/TestIntrinsics.java
@@ -100,8 +100,8 @@ public Object[][] tests() {
         tests.add(linkIndentity("identity_short", short.class, C_SHORT, true), (short) 10, (short) 10);
         tests.add(linkIndentity("identity_int", int.class, C_INT, false), 10, 10);
         tests.add(linkIndentity("identity_int", int.class, C_INT, true), 10, 10);
-        tests.add(linkIndentity("identity_long", long.class, C_LONGLONG, false), 10L, 10L);
-        tests.add(linkIndentity("identity_long", long.class, C_LONGLONG, true), 10L, 10L);
+        tests.add(linkIndentity("identity_long", long.class, C_LONG_LONG, false), 10L, 10L);
+        tests.add(linkIndentity("identity_long", long.class, C_LONG_LONG, true), 10L, 10L);
         tests.add(linkIndentity("identity_float", float.class, C_FLOAT, false), 10F, 10F);
         tests.add(linkIndentity("identity_float", float.class, C_FLOAT, true), 10F, 10F);
         tests.add(linkIndentity("identity_double", double.class, C_DOUBLE, false), 10D, 10D);
@@ -111,7 +111,7 @@ public Object[][] tests() {
             LibraryLookup.Symbol ma = lookup.lookup("identity_va").orElseThrow();
             MethodType mt = methodType(int.class, int.class, double.class, int.class, float.class, long.class);
             FunctionDescriptor fd = FunctionDescriptor.of(C_INT, C_INT, asVarArg(C_DOUBLE),
-                    asVarArg(C_INT), asVarArg(C_FLOAT), asVarArg(C_LONGLONG));
+                    asVarArg(C_INT), asVarArg(C_FLOAT), asVarArg(C_LONG_LONG));
             tests.add(abi.downcallHandle(ma, mt, fd), 1, 1, 10D, 2, 3F, 4L);
             tests.add(abi.downcallHandle(ma, mt, fd.withAttribute(TRIVIAL_ATTRIBUTE_NAME, true)), 1, 1, 10D, 2, 3F, 4L);
         }
@@ -119,7 +119,7 @@ public Object[][] tests() {
         { // high_arity
             MethodType baseMT = methodType(void.class, int.class, double.class, long.class, float.class, byte.class,
                     short.class, char.class);
-            FunctionDescriptor baseFD = FunctionDescriptor.ofVoid(C_INT, C_DOUBLE, C_LONGLONG, C_FLOAT, C_CHAR,
+            FunctionDescriptor baseFD = FunctionDescriptor.ofVoid(C_INT, C_DOUBLE, C_LONG_LONG, C_FLOAT, C_CHAR,
                     C_SHORT, C_SHORT);
             Object[] args = {1, 10D, 2L, 3F, (byte) 0, (short) 13, 'a'};
             for (int i = 0; i < args.length; i++) {
diff --git a/test/jdk/java/foreign/TestNativeScope.java b/test/jdk/java/foreign/TestNativeScope.java
index fc0ebc1bb46f2..4231a23e2fd36 100644
--- a/test/jdk/java/foreign/TestNativeScope.java
+++ b/test/jdk/java/foreign/TestNativeScope.java
@@ -208,6 +208,9 @@ static Object[][] nativeScopes() {
                 { (short)42, (ScopeFactory) NativeScope::boundedScope, MemoryLayouts.BITS_16_BE,
                         (AllocationFunction) NativeScope::allocate,
                         (Function)l -> l.varHandle(short.class) },
+                { (char)42, (ScopeFactory) NativeScope::boundedScope, MemoryLayouts.BITS_16_BE,
+                        (AllocationFunction) NativeScope::allocate,
+                        (Function)l -> l.varHandle(char.class) },
                 { 42, (ScopeFactory) NativeScope::boundedScope,
                         MemoryLayouts.BITS_32_BE,
                         (AllocationFunction) NativeScope::allocate,
@@ -231,6 +234,9 @@ static Object[][] nativeScopes() {
                 { (short)42, (ScopeFactory) NativeScope::boundedScope, MemoryLayouts.BITS_16_LE,
                         (AllocationFunction) NativeScope::allocate,
                         (Function)l -> l.varHandle(short.class) },
+                { (char)42, (ScopeFactory) NativeScope::boundedScope, MemoryLayouts.BITS_16_LE,
+                        (AllocationFunction) NativeScope::allocate,
+                        (Function)l -> l.varHandle(char.class) },
                 { 42, (ScopeFactory) NativeScope::boundedScope,
                         MemoryLayouts.BITS_32_LE,
                         (AllocationFunction) NativeScope::allocate,
@@ -254,6 +260,9 @@ static Object[][] nativeScopes() {
                 { (short)42, (ScopeFactory)size -> NativeScope.unboundedScope(), MemoryLayouts.BITS_16_BE,
                         (AllocationFunction) NativeScope::allocate,
                         (Function)l -> l.varHandle(short.class) },
+                { (char)42, (ScopeFactory)size -> NativeScope.unboundedScope(), MemoryLayouts.BITS_16_BE,
+                        (AllocationFunction) NativeScope::allocate,
+                        (Function)l -> l.varHandle(char.class) },
                 { 42, (ScopeFactory)size -> NativeScope.unboundedScope(),
                         MemoryLayouts.BITS_32_BE,
                         (AllocationFunction) NativeScope::allocate,
@@ -277,6 +286,9 @@ static Object[][] nativeScopes() {
                 { (short)42, (ScopeFactory)size -> NativeScope.unboundedScope(), MemoryLayouts.BITS_16_LE,
                         (AllocationFunction) NativeScope::allocate,
                         (Function)l -> l.varHandle(short.class) },
+                { (char)42, (ScopeFactory)size -> NativeScope.unboundedScope(), MemoryLayouts.BITS_16_LE,
+                        (AllocationFunction) NativeScope::allocate,
+                        (Function)l -> l.varHandle(char.class) },
                 { 42, (ScopeFactory)size -> NativeScope.unboundedScope(),
                         MemoryLayouts.BITS_32_LE,
                         (AllocationFunction) NativeScope::allocate,
diff --git a/test/jdk/java/foreign/callarranger/TestWindowsCallArranger.java b/test/jdk/java/foreign/callarranger/TestWindowsCallArranger.java
index f5e68e5c56897..8580fc97b7547 100644
--- a/test/jdk/java/foreign/callarranger/TestWindowsCallArranger.java
+++ b/test/jdk/java/foreign/callarranger/TestWindowsCallArranger.java
@@ -113,7 +113,7 @@ public void testMixed() {
         MethodType mt = MethodType.methodType(void.class,
                 long.class, long.class, float.class, float.class, long.class, long.class, float.class, float.class);
         FunctionDescriptor fd = FunctionDescriptor.ofVoid(
-                C_LONGLONG, C_LONGLONG, C_FLOAT, C_FLOAT, C_LONGLONG, C_LONGLONG, C_FLOAT, C_FLOAT);
+                C_LONG_LONG, C_LONG_LONG, C_FLOAT, C_FLOAT, C_LONG_LONG, C_LONG_LONG, C_FLOAT, C_FLOAT);
         CallArranger.Bindings bindings = CallArranger.getBindings(mt, fd, false);
 
         assertFalse(bindings.isInMemoryReturn);
@@ -208,7 +208,7 @@ public void testAbiExampleVarargs() {
      */
     @Test
     public void testStructRegister() {
-        MemoryLayout struct = MemoryLayout.ofStruct(C_LONGLONG);
+        MemoryLayout struct = MemoryLayout.ofStruct(C_LONG_LONG);
 
         MethodType mt = MethodType.methodType(void.class, MemorySegment.class);
         FunctionDescriptor fd = FunctionDescriptor.ofVoid(struct);
@@ -237,7 +237,7 @@ public void testStructRegister() {
      */
     @Test
     public void testStructReference() {
-        MemoryLayout struct = MemoryLayout.ofStruct(C_LONGLONG, C_LONGLONG);
+        MemoryLayout struct = MemoryLayout.ofStruct(C_LONG_LONG, C_LONG_LONG);
 
         MethodType mt = MethodType.methodType(void.class, MemorySegment.class);
         FunctionDescriptor fd = FunctionDescriptor.ofVoid(struct);
@@ -288,7 +288,7 @@ public void testMemoryAddress() {
 
     @Test
     public void testReturnRegisterStruct() {
-        MemoryLayout struct = MemoryLayout.ofStruct(C_LONGLONG);
+        MemoryLayout struct = MemoryLayout.ofStruct(C_LONG_LONG);
 
         MethodType mt = MethodType.methodType(MemorySegment.class);
         FunctionDescriptor fd = FunctionDescriptor.of(struct);
@@ -310,7 +310,7 @@ public void testReturnRegisterStruct() {
 
     @Test
     public void testIMR() {
-        MemoryLayout struct = MemoryLayout.ofStruct(C_LONGLONG, C_LONGLONG);
+        MemoryLayout struct = MemoryLayout.ofStruct(C_LONG_LONG, C_LONG_LONG);
 
         MethodType mt = MethodType.methodType(MemorySegment.class);
         FunctionDescriptor fd = FunctionDescriptor.of(struct);
diff --git a/test/jdk/java/foreign/valist/VaListTest.java b/test/jdk/java/foreign/valist/VaListTest.java
index de68bd61631eb..a53bdad48fb63 100644
--- a/test/jdk/java/foreign/valist/VaListTest.java
+++ b/test/jdk/java/foreign/valist/VaListTest.java
@@ -55,7 +55,7 @@
 import static jdk.incubator.foreign.CLinker.C_DOUBLE;
 import static jdk.incubator.foreign.CLinker.C_FLOAT;
 import static jdk.incubator.foreign.CLinker.C_INT;
-import static jdk.incubator.foreign.CLinker.C_LONGLONG;
+import static jdk.incubator.foreign.CLinker.C_LONG_LONG;
 import static jdk.incubator.foreign.CLinker.C_POINTER;
 import static jdk.incubator.foreign.CLinker.C_VA_LIST;
 import static jdk.incubator.foreign.MemoryLayout.PathElement.groupElement;
@@ -84,10 +84,10 @@ public class VaListTest {
             FunctionDescriptor.of(C_INT, C_VA_LIST));
     private static final MethodHandle MH_sumBigStruct = link("sumBigStruct",
             MethodType.methodType(long.class, VaList.class),
-            FunctionDescriptor.of(C_LONGLONG, C_VA_LIST));
+            FunctionDescriptor.of(C_LONG_LONG, C_VA_LIST));
     private static final MethodHandle MH_sumHugeStruct = link("sumHugeStruct",
             MethodType.methodType(long.class, VaList.class),
-            FunctionDescriptor.of(C_LONGLONG, C_VA_LIST));
+            FunctionDescriptor.of(C_LONG_LONG, C_VA_LIST));
     private static final MethodHandle MH_sumFloatStruct = link("sumFloatStruct",
             MethodType.methodType(float.class, VaList.class),
             FunctionDescriptor.of(C_FLOAT, C_VA_LIST));
@@ -294,10 +294,10 @@ public static Object[][] bigStructs() {
                     BigPoint_LAYOUT, VH_BigPoint_x, VH_BigPoint_y  };
         };
         return new Object[][]{
-                argsFact.apply(winVaListFactory,      Win64.C_LONGLONG,   sumStructJavaFact),
-                argsFact.apply(sysvVaListFactory,     SysV.C_LONGLONG,    sumStructJavaFact),
-                argsFact.apply(aarch64VaListFactory,  AArch64.C_LONGLONG, sumStructJavaFact),
-                argsFact.apply(platformVaListFactory, C_LONGLONG,         sumStructNativeFact),
+                argsFact.apply(winVaListFactory,      Win64.C_LONG_LONG,   sumStructJavaFact),
+                argsFact.apply(sysvVaListFactory,     SysV.C_LONG_LONG,    sumStructJavaFact),
+                argsFact.apply(aarch64VaListFactory,  AArch64.C_LONG_LONG, sumStructJavaFact),
+                argsFact.apply(platformVaListFactory, C_LONG_LONG,         sumStructNativeFact),
         };
     }
 
@@ -405,10 +405,10 @@ public static Object[][] hugeStructs() {
                     HugePoint_LAYOUT, VH_HugePoint_x, VH_HugePoint_y, VH_HugePoint_z  };
         };
         return new Object[][]{
-                argsFact.apply(winVaListFactory,      Win64.C_LONGLONG,   sumStructJavaFact),
-                argsFact.apply(sysvVaListFactory,     SysV.C_LONGLONG,    sumStructJavaFact),
-                argsFact.apply(aarch64VaListFactory,  AArch64.C_LONGLONG, sumStructJavaFact),
-                argsFact.apply(platformVaListFactory, C_LONGLONG,         sumStructNativeFact),
+                argsFact.apply(winVaListFactory,      Win64.C_LONG_LONG,   sumStructJavaFact),
+                argsFact.apply(sysvVaListFactory,     SysV.C_LONG_LONG,    sumStructJavaFact),
+                argsFact.apply(aarch64VaListFactory,  AArch64.C_LONG_LONG, sumStructJavaFact),
+                argsFact.apply(platformVaListFactory, C_LONG_LONG,         sumStructNativeFact),
         };
     }
 
@@ -458,10 +458,10 @@ public static Object[][] sumStack() {
             }
         };
         return new Object[][]{
-                { winVaListFactory,      sumStackJavaFact.apply(Win64.C_LONGLONG, Win64.C_DOUBLE),     Win64.C_LONGLONG,   Win64.C_DOUBLE   },
-                { sysvVaListFactory,     sumStackJavaFact.apply(SysV.C_LONGLONG, SysV.C_DOUBLE),       SysV.C_LONGLONG,    SysV.C_DOUBLE    },
-                { aarch64VaListFactory,  sumStackJavaFact.apply(AArch64.C_LONGLONG, AArch64.C_DOUBLE), AArch64.C_LONGLONG, AArch64.C_DOUBLE },
-                { platformVaListFactory, sumStackNative,                                               C_LONGLONG,         C_DOUBLE         },
+                { winVaListFactory,      sumStackJavaFact.apply(Win64.C_LONG_LONG, Win64.C_DOUBLE),     Win64.C_LONG_LONG,   Win64.C_DOUBLE   },
+                { sysvVaListFactory,     sumStackJavaFact.apply(SysV.C_LONG_LONG, SysV.C_DOUBLE),       SysV.C_LONG_LONG,    SysV.C_DOUBLE    },
+                { aarch64VaListFactory,  sumStackJavaFact.apply(AArch64.C_LONG_LONG, AArch64.C_DOUBLE), AArch64.C_LONG_LONG, AArch64.C_DOUBLE },
+                { platformVaListFactory, sumStackNative, C_LONG_LONG,         C_DOUBLE         },
         };
     }
 
@@ -648,8 +648,8 @@ public void testCopyUnusableAfterOriginalClosedScope(Function {
                     // skip all registers
                     for (long l = 1; l <= 16; l++) {
-                        assertEquals(vaList.vargAsLong(C_LONGLONG), l);
+                        assertEquals(vaList.vargAsLong(C_LONG_LONG), l);
                     }
                     for (double d = 1; d <= 16; d++) {
                         assertEquals(vaList.vargAsDouble(C_DOUBLE), d);
@@ -746,14 +746,14 @@ public static Object[][] upcalls() {
                     assertEquals((char) vaList.vargAsInt(C_INT), 'a');
                     assertEquals((short) vaList.vargAsInt(C_INT), (short) 3);
                     assertEquals(vaList.vargAsInt(C_INT), 4);
-                    assertEquals(vaList.vargAsLong(C_LONGLONG), 5L);
+                    assertEquals(vaList.vargAsLong(C_LONG_LONG), 5L);
                     assertEquals((float) vaList.vargAsDouble(C_DOUBLE), 6.0F);
                     assertEquals(vaList.vargAsDouble(C_DOUBLE), 7.0D);
                     assertEquals((byte) vaList.vargAsInt(C_INT), (byte) 8);
                     assertEquals((char) vaList.vargAsInt(C_INT), 'b');
                     assertEquals((short) vaList.vargAsInt(C_INT), (short) 10);
                     assertEquals(vaList.vargAsInt(C_INT), 11);
-                    assertEquals(vaList.vargAsLong(C_LONGLONG), 12L);
+                    assertEquals(vaList.vargAsLong(C_LONG_LONG), 12L);
                     assertEquals((float) vaList.vargAsDouble(C_DOUBLE), 13.0F);
                     assertEquals(vaList.vargAsDouble(C_DOUBLE), 14.0D);
 
@@ -779,11 +779,11 @@ public static Object[][] upcalls() {
                 })},
                 // test skip
                 { linkVaListCB("upcallStack"), VaListConsumer.mh(vaList -> {
-                    vaList.skip(C_LONGLONG, C_LONGLONG, C_LONGLONG, C_LONGLONG);
-                    assertEquals(vaList.vargAsLong(C_LONGLONG), 5L);
-                    vaList.skip(C_LONGLONG, C_LONGLONG, C_LONGLONG, C_LONGLONG);
-                    assertEquals(vaList.vargAsLong(C_LONGLONG), 10L);
-                    vaList.skip(C_LONGLONG, C_LONGLONG, C_LONGLONG, C_LONGLONG, C_LONGLONG, C_LONGLONG);
+                    vaList.skip(C_LONG_LONG, C_LONG_LONG, C_LONG_LONG, C_LONG_LONG);
+                    assertEquals(vaList.vargAsLong(C_LONG_LONG), 5L);
+                    vaList.skip(C_LONG_LONG, C_LONG_LONG, C_LONG_LONG, C_LONG_LONG);
+                    assertEquals(vaList.vargAsLong(C_LONG_LONG), 10L);
+                    vaList.skip(C_LONG_LONG, C_LONG_LONG, C_LONG_LONG, C_LONG_LONG, C_LONG_LONG, C_LONG_LONG);
                     assertEquals(vaList.vargAsDouble(C_DOUBLE), 1.0D);
                     vaList.skip(C_DOUBLE, C_DOUBLE, C_DOUBLE, C_DOUBLE);
                     assertEquals(vaList.vargAsDouble(C_DOUBLE), 6.0D);
diff --git a/test/micro/org/openjdk/bench/jdk/incubator/foreign/CallOverhead.java b/test/micro/org/openjdk/bench/jdk/incubator/foreign/CallOverhead.java
index ce8649370fba1..5f58e52973270 100644
--- a/test/micro/org/openjdk/bench/jdk/incubator/foreign/CallOverhead.java
+++ b/test/micro/org/openjdk/bench/jdk/incubator/foreign/CallOverhead.java
@@ -43,7 +43,7 @@
 
 import static jdk.incubator.foreign.CLinker.C_DOUBLE;
 import static jdk.incubator.foreign.CLinker.C_INT;
-import static jdk.incubator.foreign.CLinker.C_LONGLONG;
+import static jdk.incubator.foreign.CLinker.C_LONG_LONG;
 import static jdk.incubator.foreign.CLinker.C_POINTER;
 
 @BenchmarkMode(Mode.AverageTime)
@@ -66,7 +66,7 @@ public class CallOverhead {
     static final MethodHandle identity_trivial;
 
     static final MemoryLayout POINT_LAYOUT = MemoryLayout.ofStruct(
-        C_LONGLONG, C_LONGLONG
+            C_LONG_LONG, C_LONG_LONG
     );
 
     static final MemorySegment point = MemorySegment.allocateNative(POINT_LAYOUT);
@@ -97,12 +97,12 @@ public class CallOverhead {
                 FunctionDescriptor.of(C_POINTER, C_POINTER));
         args5 = abi.downcallHandle(ll.lookup("args5").get(),
                 MethodType.methodType(void.class, long.class, double.class, long.class, double.class, long.class),
-                FunctionDescriptor.ofVoid(C_LONGLONG, C_DOUBLE, C_LONGLONG, C_DOUBLE, C_LONGLONG));
+                FunctionDescriptor.ofVoid(C_LONG_LONG, C_DOUBLE, C_LONG_LONG, C_DOUBLE, C_LONG_LONG));
         args10 = abi.downcallHandle(ll.lookup("args10").get(),
                 MethodType.methodType(void.class, long.class, double.class, long.class, double.class, long.class,
                                                   double.class, long.class, double.class, long.class, double.class),
-                FunctionDescriptor.ofVoid(C_LONGLONG, C_DOUBLE, C_LONGLONG, C_DOUBLE, C_LONGLONG,
-                                          C_DOUBLE, C_LONGLONG, C_DOUBLE, C_LONGLONG, C_DOUBLE));
+                FunctionDescriptor.ofVoid(C_LONG_LONG, C_DOUBLE, C_LONG_LONG, C_DOUBLE, C_LONG_LONG,
+                                          C_DOUBLE, C_LONG_LONG, C_DOUBLE, C_LONG_LONG, C_DOUBLE));
     }
 
     static native void blank();
diff --git a/test/micro/org/openjdk/bench/jdk/incubator/foreign/VaList.java b/test/micro/org/openjdk/bench/jdk/incubator/foreign/VaList.java
index 33ebe88160e61..c1823fef49b44 100644
--- a/test/micro/org/openjdk/bench/jdk/incubator/foreign/VaList.java
+++ b/test/micro/org/openjdk/bench/jdk/incubator/foreign/VaList.java
@@ -40,7 +40,7 @@
 
 import static jdk.incubator.foreign.CLinker.C_DOUBLE;
 import static jdk.incubator.foreign.CLinker.C_INT;
-import static jdk.incubator.foreign.CLinker.C_LONGLONG;
+import static jdk.incubator.foreign.CLinker.C_LONG_LONG;
 import static jdk.incubator.foreign.CLinker.C_VA_LIST;
 import static jdk.incubator.foreign.CLinker.asVarArg;
 
@@ -61,7 +61,7 @@ public class VaList {
     static {
         MH_ellipsis = linker.downcallHandle(lookup.lookup("ellipsis").get(),
                 MethodType.methodType(void.class, int.class, int.class, double.class, long.class),
-                FunctionDescriptor.ofVoid(C_INT, asVarArg(C_INT), asVarArg(C_DOUBLE), asVarArg(C_LONGLONG)));
+                FunctionDescriptor.ofVoid(C_INT, asVarArg(C_INT), asVarArg(C_DOUBLE), asVarArg(C_LONG_LONG)));
         MH_vaList = linker.downcallHandle(lookup.lookup("vaList").get(),
                 MethodType.methodType(void.class, int.class, VaList.class),
                 FunctionDescriptor.ofVoid(C_INT, C_VA_LIST));
@@ -78,7 +78,7 @@ public void vaList() throws Throwable {
         try (CLinker.VaList vaList = CLinker.VaList.make(b ->
             b.vargFromInt(C_INT, 1)
              .vargFromDouble(C_DOUBLE, 2D)
-             .vargFromLong(C_LONGLONG, 3L)
+             .vargFromLong(C_LONG_LONG, 3L)
         )) {
             MH_vaList.invokeExact(3,
                                   vaList);

From 987188661e2011e852c1722ec4ffe06de9a4bb34 Mon Sep 17 00:00:00 2001
From: Maurizio Cimadamore 
Date: Fri, 30 Oct 2020 12:11:55 +0000
Subject: [PATCH 44/70] Fix typo in upcall helper for aarch64

---
 src/hotspot/cpu/aarch64/universalUpcallHandler_aarch64.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/hotspot/cpu/aarch64/universalUpcallHandler_aarch64.cpp b/src/hotspot/cpu/aarch64/universalUpcallHandler_aarch64.cpp
index d4eb1236b9919..be729fb3060d9 100644
--- a/src/hotspot/cpu/aarch64/universalUpcallHandler_aarch64.cpp
+++ b/src/hotspot/cpu/aarch64/universalUpcallHandler_aarch64.cpp
@@ -120,7 +120,7 @@ static void upcall_helper(jobject rec, address buff) {
                          &args, thread);
 }
 
-addres ProgrammableUpcallHandler::generate_upcall_stub(jobject rec, jobject jabi, jobject jlayout) {
+address ProgrammableUpcallHandler::generate_upcall_stub(jobject rec, jobject jabi, jobject jlayout) {
   ResourceMark rm;
   const ABIDescriptor abi = ForeignGlobals::parse_abi_descriptor(jabi);
   const BufferLayout layout = ForeignGlobals::parse_buffer_layout(jlayout);

From 8225bf2eeae0caabb9b63b896baee4d4737ed3d5 Mon Sep 17 00:00:00 2001
From: Maurizio Cimadamore 
Date: Mon, 2 Nov 2020 11:55:46 +0000
Subject: [PATCH 45/70] Address comments from @AlanBateman

---
 .../java/nio/Direct-X-Buffer.java.template    | 11 ++--
 .../classes/java/nio/X-Buffer.java.template   | 17 +++---
 .../foreign/MappedMemorySegments.java         | 10 ++--
 .../jdk/incubator/foreign/MemoryAccess.java   | 52 ++-----------------
 .../jdk/incubator/foreign/MemorySegment.java  | 48 ++++++++++-------
 .../foreign/AbstractMemorySegmentImpl.java    |  4 +-
 .../foreign/MappedMemorySegmentImpl.java      |  4 +-
 test/jdk/java/foreign/TestByteBuffer.java     | 26 +++++-----
 .../foreign/LoopOverNonConstantMapped.java    |  3 +-
 9 files changed, 68 insertions(+), 107 deletions(-)

diff --git a/src/java.base/share/classes/java/nio/Direct-X-Buffer.java.template b/src/java.base/share/classes/java/nio/Direct-X-Buffer.java.template
index 3ab4a5a52b98b..a12b07a6f78f7 100644
--- a/src/java.base/share/classes/java/nio/Direct-X-Buffer.java.template
+++ b/src/java.base/share/classes/java/nio/Direct-X-Buffer.java.template
@@ -481,11 +481,9 @@ class Direct$Type$Buffer$RW$$BO$
                                           (long)1 << $LG_BYTES_PER_VALUE$);
                 else
 #end[!byte]
-                    SCOPED_MEMORY_ACCESS.copyMemory(scope(), null, src,
-                                      srcOffset,
-                                      null,
-                                      ix(index),
-                                      (long)length << $LG_BYTES_PER_VALUE$);
+                    SCOPED_MEMORY_ACCESS.copyMemory(
+                            scope(), null, src,
+                            srcOffset, null, ix(index), (long)length << $LG_BYTES_PER_VALUE$);
             } finally {
                 Reference.reachabilityFence(this);
             }
@@ -505,7 +503,8 @@ class Direct$Type$Buffer$RW$$BO$
         assert (pos <= lim);
         int rem = (pos <= lim ? lim - pos : 0);
         try {
-            SCOPED_MEMORY_ACCESS.copyMemory(scope(), null, null, ix(pos), null, ix(0), (long)rem << $LG_BYTES_PER_VALUE$);
+            SCOPED_MEMORY_ACCESS.copyMemory(scope(), null, null,
+                    ix(pos), null, ix(0), (long)rem << $LG_BYTES_PER_VALUE$);
         } finally {
             Reference.reachabilityFence(this);
         }
diff --git a/src/java.base/share/classes/java/nio/X-Buffer.java.template b/src/java.base/share/classes/java/nio/X-Buffer.java.template
index c431e2dfdfaf9..50dd54f6f1321 100644
--- a/src/java.base/share/classes/java/nio/X-Buffer.java.template
+++ b/src/java.base/share/classes/java/nio/X-Buffer.java.template
@@ -975,11 +975,9 @@ public abstract class $Type$Buffer
             if (this.order() == src.order()) {
 #end[!byte]
                 try {
-                    SCOPED_MEMORY_ACCESS.copyMemory(scope(), src.scope(), srcBase,
-                                      srcAddr,
-                                      base,
-                                      addr,
-                                      len);
+                    SCOPED_MEMORY_ACCESS.copyMemory(
+                            scope(), src.scope(), srcBase,
+                            srcAddr, base, addr, len);
                 } finally {
                     Reference.reachabilityFence(src);
                     Reference.reachabilityFence(this);
@@ -987,12 +985,9 @@ public abstract class $Type$Buffer
 #if[!byte]
             } else {
                 try {
-                    SCOPED_MEMORY_ACCESS.copySwapMemory(scope(), src.scope(), srcBase,
-                                          srcAddr,
-                                          base,
-                                          addr,
-                                          len,
-                                          (long)1 << $LG_BYTES_PER_VALUE$);
+                    SCOPED_MEMORY_ACCESS.copySwapMemory(
+                            scope(), src.scope(), srcBase,
+                            srcAddr, base, addr, len, (long)1 << $LG_BYTES_PER_VALUE$);
                 } finally {
                     Reference.reachabilityFence(src);
                     Reference.reachabilityFence(this);
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MappedMemorySegments.java b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MappedMemorySegments.java
index 04cccaf5f79c4..21a49dc0cd96d 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MappedMemorySegments.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MappedMemorySegments.java
@@ -73,7 +73,7 @@ private MappedMemorySegments() {
      * @throws IllegalStateException if the given segment is not alive, or if the given segment is confined
      * and this method is called from a thread other than the segment's owner thread.
      * @throws UnsupportedOperationException if the given segment is not a mapped memory segment, e.g. if
-     * {@code segment.fileDescriptor().isEmpty()}.
+     * {@code segment.isMapped() == false}.
      */
     public static boolean isLoaded(MemorySegment segment) {
         return toMappedSegment(segment).isLoaded();
@@ -92,7 +92,7 @@ public static boolean isLoaded(MemorySegment segment) {
      * @throws IllegalStateException if the given segment is not alive, or if the given segment is confined
      * and this method is called from a thread other than the segment's owner thread.
      * @throws UnsupportedOperationException if the given segment is not a mapped memory segment, e.g. if
-     * {@code segment.fileDescriptor().isEmpty()}.
+     * {@code segment.isMapped() == false}.
      */
     public static void load(MemorySegment segment) {
         toMappedSegment(segment).load();
@@ -111,7 +111,7 @@ public static void load(MemorySegment segment) {
      * @throws IllegalStateException if the given segment is not alive, or if the given segment is confined
      * and this method is called from a thread other than the segment's owner thread.
      * @throws UnsupportedOperationException if the given segment is not a mapped memory segment, e.g. if
-     * {@code segment.fileDescriptor().isEmpty()}.
+     * {@code segment.isMapped() == false}.
      */
     public static void unload(MemorySegment segment) {
         toMappedSegment(segment).unload();
@@ -119,7 +119,7 @@ public static void unload(MemorySegment segment) {
 
     /**
      * Forces any changes made to the contents of the given segment to be written to the
-     * storage device described by the segment's file descriptor (see {@link MemorySegment#fileDescriptor()}).
+     * storage device described by the mapped segment's file descriptor.
      *
      * 
 If this mapping's file descriptor resides on a local storage
      * device then when this method returns it is guaranteed that all changes
@@ -143,7 +143,7 @@ public static void unload(MemorySegment segment) {
      * @throws IllegalStateException if the given segment is not alive, or if the given segment is confined
      * and this method is called from a thread other than the segment's owner thread.
      * @throws UnsupportedOperationException if the given segment is not a mapped memory segment, e.g. if
-     * {@code segment.fileDescriptor().isEmpty()}.
+     * {@code segment.isMapped() == false}.
      */
     public static void force(MemorySegment segment) {
         toMappedSegment(segment).force();
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MemoryAccess.java b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MemoryAccess.java
index bd978c3fbe344..ccd62f88a9f83 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MemoryAccess.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MemoryAccess.java
@@ -86,12 +86,7 @@ private static VarHandle unalignedHandle(ValueLayout elementLayout, Class car
     }
 
     /**
-     * Reads a byte from given segment and offset, with byte order set to {@link ByteOrder#nativeOrder()}.
-     * 

-     * This is equivalent to the following code:
-     * 
{@code
-    getByteAtOffset(segment, offset, ByteOrder.nativeOrder());
-     * }

+     * Reads a byte from given segment and offset.
      *
      * @param segment the segment to be dereferenced.
      * @param offset offset in bytes (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
@@ -102,12 +97,8 @@ public static byte getByteAtOffset(MemorySegment segment, long offset) {
     }
 
     /**
-     * Writes a byte at given segment and offset, with byte order set to {@link ByteOrder#nativeOrder()}.
-     * 

-     * This is equivalent to the following code:
-     * 
{@code
-    setByteAtOffset(segment, offset, ByteOrder.nativeOrder(), value);
-     * }

+     * Writes a byte at given segment and offset.
+     *
      * @param segment the segment to be dereferenced.
      * @param offset offset in bytes (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(offset)}.
      * @param value the byte value to be written.
@@ -1004,7 +995,7 @@ public static void setDouble(MemorySegment segment, ByteOrder order, double valu
     }
 
     /**
-     * Reads a byte from given segment and element index, with byte order set to {@link ByteOrder#nativeOrder()}.
+     * Reads a byte from given segment and element index.
      * 

      * This is equivalent to the following code:
      * 
{@code
@@ -1020,7 +1011,7 @@ public static byte getByteAtIndex(MemorySegment segment, long index) {
     }
 
     /**
-     * Writes a byte at given segment and element index, with byte order set to {@link ByteOrder#nativeOrder()}.
+     * Writes a byte at given segment and element index.
      * 

      * This is equivalent to the following code:
      * 
{@code
@@ -1244,39 +1235,6 @@ public static void setDoubleAtIndex(MemorySegment segment, long index, double va
         setDoubleAtOffset(segment, scale(segment, index, 8), value);
     }
 
-    /**
-     * Reads a byte from given segment and element index, with given byte order.
-     * 

-     * This is equivalent to the following code:
-     * 
{@code
-    byte value = getByteAtOffset(segment, index, order);
-     * }

-     *
-     * @param segment the segment to be dereferenced.
-     * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index)}.
-     * @param order the specified byte order.
-     * @return a byte value read from {@code segment} at the element index specified by {@code index}.
-     */
-    public static byte getByteAtIndex(MemorySegment segment, long index, ByteOrder order) {
-        return getByteAtOffset(segment, index, order);
-    }
-
-    /**
-     * Writes a byte at given segment and element index, with given byte order.
-     * 

-     * This is equivalent to the following code:
-     * 
{@code
-    setByteAtOffset(segment, index, order, value);
-     * }

-     * @param segment the segment to be dereferenced.
-     * @param index element index (relative to {@code segment}). The final address of this read operation can be expressed as {@code segment.address().addOffset(index)}.
-     * @param order the specified byte order.
-     * @param value the byte value to be written.
-     */
-    public static void setByteAtIndex(MemorySegment segment, long index, ByteOrder order, byte value) {
-        setByteAtOffset(segment, index, order, value);
-    }
-
     /**
      * Reads a char from given segment and element index, with given byte order.
      * 

diff --git a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MemorySegment.java b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MemorySegment.java
index 8f0efc1e20cec..76303bb58facc 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MemorySegment.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MemorySegment.java
@@ -76,9 +76,8 @@
  * by native memory.
  * 

  * Finally, it is also possible to obtain a memory segment backed by a memory-mapped file using the factory method
- * {@link MemorySegment#mapFromPath(Path, long, long, FileChannel.MapMode)}. Such memory segments are called mapped memory segments;
- * mapped memory segments are associated with a {@link FileDescriptor} instance which can be obtained calling the
- * {@link #fileDescriptor()} method. For more operations on mapped memory segments, please refer to the
+ * {@link MemorySegment#mapFile(Path, long, long, FileChannel.MapMode)}. Such memory segments are called mapped memory segments;
+ * mapped memory segments are associated with an underlying file descriptor. For more operations on mapped memory segments, please refer to the
  * {@link MappedMemorySegments} class.
  * 

  * Array and buffer segments are effectively views over existing memory regions which might outlive the
@@ -377,12 +376,12 @@ default MemorySegment asSlice(MemoryAddress newBase) {
     }
 
     /**
-     * Obtain the file descriptor with this memory segment, assuming this segment is a mapped memory segment,
-     * created using the {@link #mapFromPath(Path, long, long, FileChannel.MapMode)} factory, or a buffer segment
+     * Is this a mapped segment? Returns true if this segment is a mapped memory segment,
+     * created using the {@link #mapFile(Path, long, long, FileChannel.MapMode)} factory, or a buffer segment
      * derived from a {@link java.nio.MappedByteBuffer} using the {@link #ofByteBuffer(ByteBuffer)} factory.
-     * @return the file descriptor associated with this memory segment (if any).
+     * @return {@code true} if this segment is a mapped segment.
      */
-    Optional fileDescriptor();
+    boolean isMapped();
 
     /**
      * Is this segment alive?
@@ -392,10 +391,20 @@ default MemorySegment asSlice(MemoryAddress newBase) {
     boolean isAlive();
 
     /**
-     * Closes this memory segment. This is a terminal operation; as a side-effect, this segment will be marked
-     * as not alive, and subsequent operations on this segment will fail with {@link IllegalStateException}.
+     * Closes this memory segment. This is a terminal operation; as a side-effect, if this operation completes
+     * without exceptions, this segment will be marked as not alive, and subsequent operations on this segment
+     * will fail with {@link IllegalStateException}.
+     * 

      * Depending on the kind of memory segment being closed, calling this method further triggers deallocation of all the resources
      * associated with the memory segment.
+     *
+     * @apiNote This operation is not idempotent; that is, closing an already closed segment always results in an
+     * exception being thrown. This reflects a deliberate design choice: segment state transitions should be
+     * manifest in the client code; a failure in any of these transitions reveals a bug in the underlying application
+     * logic. This is especially useful when reasoning about the lifecycle of dependent segment views (see {@link #asSlice(MemoryAddress)},
+     * where closing one segment might side-effect multiple segments. In such cases it might in fact not be obvious, looking
+     * at the code, as to whether a given segment is alive or not.
+     *
      * @throws IllegalStateException if this segment is not alive, or if access occurs from a thread other than the
      * thread owning this segment, or if this segment is shared and the segment is concurrently accessed while this method is
      * called.
@@ -408,8 +417,9 @@ default MemorySegment asSlice(MemoryAddress newBase) {
      * be confined on the specified thread, and will feature the same spatial bounds and access modes (see {@link #accessModes()})
      * as this segment.
      * 

-     * This is a terminal operation; as a side-effect, this segment will be
-     * marked as not alive, and subsequent operations on this segment will fail with {@link IllegalStateException}.
+     * This is a terminal operation; as a side-effect, if this operation completes
+     * without exceptions, this segment will be marked as not alive, and subsequent operations on this segment
+     * will fail with {@link IllegalStateException}.
      * 

      * In case where the owner thread of the returned segment differs from that of this segment, write accesses to this
      * segment's content happens-before
@@ -431,8 +441,9 @@ default MemorySegment asSlice(MemoryAddress newBase) {
      * returned segment will feature the same spatial bounds and access modes (see {@link #accessModes()})
      * as this segment.
      * 

-     * This is a terminal operation; as a side-effect, this segment will be
-     * marked as not alive, and subsequent operations on this segment will fail with {@link IllegalStateException}.
+     * This is a terminal operation; as a side-effect, if this operation completes
+     * without exceptions, this segment will be marked as not alive, and subsequent operations on this segment
+     * will fail with {@link IllegalStateException}.
      * 

      * Write accesses to this segment's content happens-before
      * hand-over from the current owner thread to the new owner thread, which in turn happens before read accesses
@@ -441,7 +452,6 @@ default MemorySegment asSlice(MemoryAddress newBase) {
      * @return a new memory shared segment backed by the same underlying memory region as this segment.
      * @throws IllegalStateException if this segment is not alive, or if access occurs from a thread other than the
      * thread owning this segment.
-     * @throws NullPointerException if {@code thread == null}
      */
     MemorySegment share();
 
@@ -452,8 +462,9 @@ default MemorySegment asSlice(MemoryAddress newBase) {
      * will be associated with the specified {@link Cleaner} object; this allows for the segment to be closed
      * as soon as it becomes unreachable, which might be helpful in preventing native memory leaks.
      * 

-     * This is a terminal operation; as a side-effect, this segment will be
-     * marked as not alive, and subsequent operations on this segment will fail with {@link IllegalStateException}.
+     * This is a terminal operation; as a side-effect, if this operation completes
+     * without exceptions, this segment will be marked as not alive, and subsequent operations on this segment
+     * will fail with {@link IllegalStateException}.
      * 

      * The implicit deallocation behavior associated with the returned segment will be preserved under terminal
      * operations such as {@link #handoff(Thread)} and {@link #share()}.
@@ -464,7 +475,6 @@ default MemorySegment asSlice(MemoryAddress newBase) {
      * @throws IllegalStateException if this segment is not alive, or if access occurs from a thread other than the
      * thread owning this segment, or if this segment is already associated with a cleaner.
      * @throws UnsupportedOperationException if this segment does not support the {@link #CLOSE} access mode.
-     * @throws NullPointerException if {@code thread == null}
      */
     MemorySegment registerCleaner(Cleaner cleaner);
 
@@ -506,7 +516,7 @@ default MemorySegment asSlice(MemoryAddress newBase) {
      * 

      * The result of a bulk copy is unspecified if, in the uncommon case, the source segment and this segment
      * do not overlap, but refer to overlapping regions of the same backing storage using different addresses.
-     * For example, this may occur if the same file is {@link MemorySegment#mapFromPath mapped} to two segments.
+     * For example, this may occur if the same file is {@link MemorySegment#mapFile mapped} to two segments.
      *
      * @param src the source segment.
      * @throws IndexOutOfBoundsException if {@code src.byteSize() > this.byteSize()}.
@@ -848,7 +858,7 @@ static MemorySegment allocateNative(long bytesSize) {
      * read access if the file is opened for reading. The {@link SecurityManager#checkWrite(String)} method is invoked to check
      * write access if the file is opened for writing.
      */
-    static MemorySegment mapFromPath(Path path, long bytesOffset, long bytesSize, FileChannel.MapMode mapMode) throws IOException {
+    static MemorySegment mapFile(Path path, long bytesOffset, long bytesSize, FileChannel.MapMode mapMode) throws IOException {
         return MappedMemorySegmentImpl.makeMappedSegment(path, bytesOffset, bytesSize, mapMode);
     }
 
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/AbstractMemorySegmentImpl.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/AbstractMemorySegmentImpl.java
index 53278d6fbb5a5..2833f406b3fb8 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/AbstractMemorySegmentImpl.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/AbstractMemorySegmentImpl.java
@@ -313,8 +313,8 @@ public final void close() {
     }
 
     @Override
-    public Optional fileDescriptor() {
-        return Optional.empty();
+    public boolean isMapped() {
+        return false;
     }
 
     @Override
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/MappedMemorySegmentImpl.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/MappedMemorySegmentImpl.java
index 4e644906d6c96..0607bf5e3e3e6 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/MappedMemorySegmentImpl.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/MappedMemorySegmentImpl.java
@@ -80,8 +80,8 @@ public MappedMemorySegmentImpl withAccessModes(int accessModes) {
     }
 
     @Override
-    public Optional fileDescriptor() {
-        return Optional.of(unmapper.fileDescriptor());
+    public boolean isMapped() {
+        return true;
     }
 
     // support for mapped segments
diff --git a/test/jdk/java/foreign/TestByteBuffer.java b/test/jdk/java/foreign/TestByteBuffer.java
index 2aab323e43444..ec4b2bb74e5d9 100644
--- a/test/jdk/java/foreign/TestByteBuffer.java
+++ b/test/jdk/java/foreign/TestByteBuffer.java
@@ -228,12 +228,12 @@ public void testChannel() throws Throwable {
 
     @Test
     public void testDefaultAccessModesMappedSegment() throws Throwable {
-        try (MemorySegment segment = MemorySegment.mapFromPath(tempPath, 0L, 8, FileChannel.MapMode.READ_WRITE)) {
+        try (MemorySegment segment = MemorySegment.mapFile(tempPath, 0L, 8, FileChannel.MapMode.READ_WRITE)) {
             assertTrue(segment.hasAccessModes(ALL_ACCESS));
             assertEquals(segment.accessModes(), ALL_ACCESS);
         }
 
-        try (MemorySegment segment = MemorySegment.mapFromPath(tempPath, 0L, 8, FileChannel.MapMode.READ_ONLY)) {
+        try (MemorySegment segment = MemorySegment.mapFile(tempPath, 0L, 8, FileChannel.MapMode.READ_ONLY)) {
             assertTrue(segment.hasAccessModes(ALL_ACCESS & ~WRITE));
             assertEquals(segment.accessModes(), ALL_ACCESS & ~WRITE);
         }
@@ -246,13 +246,13 @@ public void testMappedSegment() throws Throwable {
         f.deleteOnExit();
 
         //write to channel
-        try (MemorySegment segment = MemorySegment.mapFromPath(f.toPath(), 0L, tuples.byteSize(), FileChannel.MapMode.READ_WRITE)) {
+        try (MemorySegment segment = MemorySegment.mapFile(f.toPath(), 0L, tuples.byteSize(), FileChannel.MapMode.READ_WRITE)) {
             initTuples(segment, tuples.elementCount().getAsLong());
             MappedMemorySegments.force(segment);
         }
 
         //read from channel
-        try (MemorySegment segment = MemorySegment.mapFromPath(f.toPath(), 0L, tuples.byteSize(), FileChannel.MapMode.READ_ONLY)) {
+        try (MemorySegment segment = MemorySegment.mapFile(f.toPath(), 0L, tuples.byteSize(), FileChannel.MapMode.READ_ONLY)) {
             checkTuples(segment, segment.asByteBuffer(), tuples.elementCount().getAsLong());
         }
     }
@@ -263,8 +263,8 @@ public void testMappedSegmentOperations(MappedSegmentOp mappedBufferOp) throws T
         f.createNewFile();
         f.deleteOnExit();
 
-        MemorySegment segment = MemorySegment.mapFromPath(f.toPath(), 0L, 8, FileChannel.MapMode.READ_WRITE);
-        assertTrue(segment.fileDescriptor().isPresent());
+        MemorySegment segment = MemorySegment.mapFile(f.toPath(), 0L, 8, FileChannel.MapMode.READ_WRITE);
+        assertTrue(segment.isMapped());
         segment.close();
         mappedBufferOp.apply(segment);
     }
@@ -280,7 +280,7 @@ public void testMappedSegmentOffset() throws Throwable {
         // write one at a time
         for (int i = 0 ; i < tuples.byteSize() ; i += tupleLayout.byteSize()) {
             //write to channel
-            try (MemorySegment segment = MemorySegment.mapFromPath(f.toPath(), i, tuples.byteSize(), FileChannel.MapMode.READ_WRITE)) {
+            try (MemorySegment segment = MemorySegment.mapFile(f.toPath(), i, tuples.byteSize(), FileChannel.MapMode.READ_WRITE)) {
                 initTuples(segment, 1);
                 MappedMemorySegments.force(segment);
             }
@@ -289,7 +289,7 @@ public void testMappedSegmentOffset() throws Throwable {
         // check one at a time
         for (int i = 0 ; i < tuples.byteSize() ; i += tupleLayout.byteSize()) {
             //read from channel
-            try (MemorySegment segment = MemorySegment.mapFromPath(f.toPath(), 0L, tuples.byteSize(), FileChannel.MapMode.READ_ONLY)) {
+            try (MemorySegment segment = MemorySegment.mapFile(f.toPath(), 0L, tuples.byteSize(), FileChannel.MapMode.READ_ONLY)) {
                 checkTuples(segment, segment.asByteBuffer(), 1);
             }
         }
@@ -453,7 +453,7 @@ public void testBadMapNegativeSize() throws IOException {
         File f = new File("testNeg1.out");
         f.createNewFile();
         f.deleteOnExit();
-        MemorySegment.mapFromPath(f.toPath(), 0L, -1, FileChannel.MapMode.READ_WRITE);
+        MemorySegment.mapFile(f.toPath(), 0L, -1, FileChannel.MapMode.READ_WRITE);
     }
 
     @Test(expectedExceptions = IllegalArgumentException.class)
@@ -461,14 +461,14 @@ public void testBadMapNegativeOffset() throws IOException {
         File f = new File("testNeg2.out");
         f.createNewFile();
         f.deleteOnExit();
-        MemorySegment.mapFromPath(f.toPath(), -1, 1, FileChannel.MapMode.READ_WRITE);
+        MemorySegment.mapFile(f.toPath(), -1, 1, FileChannel.MapMode.READ_WRITE);
     }
 
     public void testMapZeroSize() throws IOException {
         File f = new File("testPos1.out");
         f.createNewFile();
         f.deleteOnExit();
-        try (MemorySegment segment = MemorySegment.mapFromPath(f.toPath(), 0L, 0L, FileChannel.MapMode.READ_WRITE)) {
+        try (MemorySegment segment = MemorySegment.mapFile(f.toPath(), 0L, 0L, FileChannel.MapMode.READ_WRITE)) {
             assertEquals(segment.byteSize(), 0);
         }
     }
@@ -659,7 +659,7 @@ static Map varHandleMembers(ByteBuffer bb, VarHandle han
     @DataProvider(name = "resizeOps")
     public Object[][] resizeOps() {
         Consumer byteInitializer =
-                (base) -> initBytes(base, bytes, (addr, pos) -> MemoryAccess.setByteAtIndex(addr, pos, ByteOrder.BIG_ENDIAN, (byte)(long)pos));
+                (base) -> initBytes(base, bytes, (addr, pos) -> MemoryAccess.setByteAtIndex(addr, pos, (byte)(long)pos));
         Consumer charInitializer =
                 (base) -> initBytes(base, chars, (addr, pos) -> MemoryAccess.setCharAtIndex(addr, pos, ByteOrder.BIG_ENDIAN, (char)(long)pos));
         Consumer shortInitializer =
@@ -674,7 +674,7 @@ public Object[][] resizeOps() {
                 (base) -> initBytes(base, doubles, (addr, pos) -> MemoryAccess.setDoubleAtIndex(addr, pos, ByteOrder.BIG_ENDIAN, (double)(long)pos));
 
         Consumer byteChecker =
-                (base) -> checkBytes(base, bytes, Function.identity(), (addr, pos) -> MemoryAccess.getByteAtIndex(addr, pos, ByteOrder.BIG_ENDIAN), ByteBuffer::get);
+                (base) -> checkBytes(base, bytes, Function.identity(), (addr, pos) -> MemoryAccess.getByteAtIndex(addr, pos), ByteBuffer::get);
         Consumer charChecker =
                 (base) -> checkBytes(base, chars, ByteBuffer::asCharBuffer, (addr, pos) -> MemoryAccess.getCharAtIndex(addr, pos, ByteOrder.BIG_ENDIAN), CharBuffer::get);
         Consumer shortChecker =
diff --git a/test/micro/org/openjdk/bench/jdk/incubator/foreign/LoopOverNonConstantMapped.java b/test/micro/org/openjdk/bench/jdk/incubator/foreign/LoopOverNonConstantMapped.java
index 651e8c7390121..96f404fc6170e 100644
--- a/test/micro/org/openjdk/bench/jdk/incubator/foreign/LoopOverNonConstantMapped.java
+++ b/test/micro/org/openjdk/bench/jdk/incubator/foreign/LoopOverNonConstantMapped.java
@@ -23,7 +23,6 @@
 package org.openjdk.bench.jdk.incubator.foreign;
 
 import jdk.incubator.foreign.MemoryAccess;
-import jdk.incubator.foreign.MemoryAddress;
 import jdk.incubator.foreign.MemoryLayout;
 import jdk.incubator.foreign.MemorySegment;
 import org.openjdk.jmh.annotations.Benchmark;
@@ -96,7 +95,7 @@ public void setup() throws IOException {
             }
             ((MappedByteBuffer)byteBuffer).force();
         }
-        segment = MemorySegment.mapFromPath(tempPath, 0L, ALLOC_SIZE, FileChannel.MapMode.READ_WRITE);
+        segment = MemorySegment.mapFile(tempPath, 0L, ALLOC_SIZE, FileChannel.MapMode.READ_WRITE);
         unsafe_addr = segment.address().toRawLongValue();
     }
 

From e2f69ec05be649f0b9ff15b75543e1bf3b4b6d85 Mon Sep 17 00:00:00 2001
From: Maurizio Cimadamore 
Date: Mon, 2 Nov 2020 14:13:45 +0000
Subject: [PATCH 46/70] Addess remaining feedback from @AlanBateman and @mrserb

---
 .../classes/jdk/incubator/foreign/MappedMemorySegments.java   | 3 ++-
 test/jdk/java/foreign/TestCleaner.java                        | 4 +---
 2 files changed, 3 insertions(+), 4 deletions(-)

diff --git a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MappedMemorySegments.java b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MappedMemorySegments.java
index 21a49dc0cd96d..5613a2f6be6de 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MappedMemorySegments.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/MappedMemorySegments.java
@@ -43,7 +43,8 @@
  * {@link MemoryAddress#ofLong(long)} and {@link MemoryAddress#asSegmentRestricted(long, Runnable, Object)}.
  *
  * @implNote
- * The behavior of the methods in this class is highly platform-dependent; as a result, calling these methods might
+ * The behavior of some the methods in this class (see {@link #load(MemorySegment)}, {@link #unload(MemorySegment)} and
+ * {@link #isLoaded(MemorySegment)}) is highly platform-dependent; as a result, calling these methods might
  * be a no-op on certain platforms.
  */
 public final class MappedMemorySegments {
diff --git a/test/jdk/java/foreign/TestCleaner.java b/test/jdk/java/foreign/TestCleaner.java
index fc54c201d1496..8ec8e9e0c721c 100644
--- a/test/jdk/java/foreign/TestCleaner.java
+++ b/test/jdk/java/foreign/TestCleaner.java
@@ -4,9 +4,7 @@
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.  Oracle designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
+ * published by the Free Software Foundation.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

From 02f9e251c3c0beab68d6da549ec9574f13c5589f Mon Sep 17 00:00:00 2001
From: Maurizio Cimadamore 
Date: Thu, 5 Nov 2020 17:07:00 +0000
Subject: [PATCH 47/70] Fix post-merge issues caused by 8219014

---
 .../share/classes/java/nio/Direct-X-Buffer.java.template        | 1 -
 .../share/classes/java/nio/Heap-X-Buffer.java.template          | 2 +-
 2 files changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/java.base/share/classes/java/nio/Direct-X-Buffer.java.template b/src/java.base/share/classes/java/nio/Direct-X-Buffer.java.template
index 6deb2d4d09483..81a40c8bd404f 100644
--- a/src/java.base/share/classes/java/nio/Direct-X-Buffer.java.template
+++ b/src/java.base/share/classes/java/nio/Direct-X-Buffer.java.template
@@ -423,7 +423,6 @@ class Direct$Type$Buffer$RW$$BO$
 
     public $Type$Buffer put(int index, $Type$Buffer src, int offset, int length) {
 #if[rw]
-        checkSegment();
         super.put(index, src, offset, length);
         return this;
 #else[rw]
diff --git a/src/java.base/share/classes/java/nio/Heap-X-Buffer.java.template b/src/java.base/share/classes/java/nio/Heap-X-Buffer.java.template
index 4ca496cf6eca5..4646db35ca548 100644
--- a/src/java.base/share/classes/java/nio/Heap-X-Buffer.java.template
+++ b/src/java.base/share/classes/java/nio/Heap-X-Buffer.java.template
@@ -249,7 +249,7 @@ class Heap$Type$Buffer$RW$
 
     public $Type$Buffer put(int index, $Type$Buffer src, int offset, int length) {
 #if[rw]
-        checkSegment();
+        checkScope();
         super.put(index, src, offset, length);
         return this;
 #else[rw]

From 719224ca9dc70fce6d28885acfb362fee715ebbd Mon Sep 17 00:00:00 2001
From: Jorn Vernee 
Date: Tue, 20 Oct 2020 15:39:45 +0200
Subject: [PATCH 48/70] - Use lazy constant for upcall_info - Reduce copied
 code between platforms - Clean up includes - Split thread attach from
 upcall_helper

---
 .../universalNativeInvoker_aarch64.cpp        |  90 +++++----------
 .../universalUpcallHandler_aarch64.cpp        | 100 +----------------
 .../cpu/x86/universalNativeInvoker_x86.cpp    | 104 +++++-------------
 .../cpu/x86/universalUpcallHandler_x86.cpp    | 100 +----------------
 .../share/prims/universalNativeInvoker.cpp    |  15 +--
 .../share/prims/universalNativeInvoker.hpp    |  33 +++---
 .../share/prims/universalUpcallHandler.cpp    |  65 ++++++++++-
 .../share/prims/universalUpcallHandler.hpp    |  23 ++--
 8 files changed, 167 insertions(+), 363 deletions(-)

diff --git a/src/hotspot/cpu/aarch64/universalNativeInvoker_aarch64.cpp b/src/hotspot/cpu/aarch64/universalNativeInvoker_aarch64.cpp
index afad6cf3c51e0..2d5c34352e3d5 100644
--- a/src/hotspot/cpu/aarch64/universalNativeInvoker_aarch64.cpp
+++ b/src/hotspot/cpu/aarch64/universalNativeInvoker_aarch64.cpp
@@ -24,36 +24,11 @@
 
 #include "precompiled.hpp"
 #include "asm/macroAssembler.hpp"
-#include "include/jvm.h"
-#include "logging/log.hpp"
-#include "logging/logStream.hpp"
-#include "memory/resourceArea.hpp"
-#include "oops/arrayOop.inline.hpp"
-#include "prims/methodHandles.hpp"
 #include "prims/universalNativeInvoker.hpp"
-#include "runtime/interfaceSupport.inline.hpp"
-#include "runtime/javaCalls.hpp"
-
-static constexpr CodeBuffer::csize_t native_invoker_size = 1024;
-
-static void generate_invoke_native(MacroAssembler* _masm,
-                                   const ABIDescriptor& abi,
-                                   const BufferLayout& layout) {
-  /**
-   * invoke_native_stub(struct ShuffleDowncallContext* ctxt) {
-   *   rbx = ctxt;
-   *
-   *   stack = alloca(ctxt->arguments.stack_args_bytes);
-   *
-   *   load_all_registers();
-   *   memcpy(stack, ctxt->arguments.stack_args, arguments.stack_args_bytes);
-   *
-   *   (*ctxt->arguments.next_pc)();
-   *
-   *   store_all_registers();
-   * }
-   */
+#include "memory/resourceArea.hpp"
+#include "code/codeBlob.hpp"
 
+void ProgrammableInvoker::Generator::generate() {
   __ enter();
 
   // Name registers used in the stub code. These are all caller-save so
@@ -74,17 +49,17 @@ static void generate_invoke_native(MacroAssembler* _masm,
   __ mov(Rctx, c_rarg0);
   __ str(Rctx, Address(__ pre(sp, -2 * wordSize)));
 
-  assert(abi._stack_alignment_bytes % 16 == 0, "stack must be 16 byte aligned");
+  assert(_abi->_stack_alignment_bytes % 16 == 0, "stack must be 16 byte aligned");
 
   __ block_comment("allocate_stack");
-  __ ldr(Rstack_size, Address(Rctx, (int) layout.stack_args_bytes));
-  __ add(rscratch2, Rstack_size, abi._stack_alignment_bytes - 1);
-  __ andr(rscratch2, rscratch2, -abi._stack_alignment_bytes);
+  __ ldr(Rstack_size, Address(Rctx, (int) _layout->stack_args_bytes));
+  __ add(rscratch2, Rstack_size, _abi->_stack_alignment_bytes - 1);
+  __ andr(rscratch2, rscratch2, -_abi->_stack_alignment_bytes);
   __ sub(sp, sp, rscratch2);
 
   __ block_comment("load_arguments");
 
-  __ ldr(Rsrc_ptr, Address(Rctx, (int) layout.stack_args));
+  __ ldr(Rsrc_ptr, Address(Rctx, (int) _layout->stack_args));
   __ lsr(Rwords, Rstack_size, LogBytesPerWord);
   __ mov(Rdst_ptr, sp);
 
@@ -97,35 +72,35 @@ static void generate_invoke_native(MacroAssembler* _masm,
   __ b(Lnext);
   __ bind(Ldone);
 
-  for (int i = 0; i < abi._vector_argument_registers.length(); i++) {
-    ssize_t offs = layout.arguments_vector + i * sizeof(VectorRegister);
-    __ ldrq(abi._vector_argument_registers.at(i), Address(Rctx, offs));
+  for (int i = 0; i < _abi->_vector_argument_registers.length(); i++) {
+    ssize_t offs = _layout->arguments_vector + i * sizeof(VectorRegister);
+    __ ldrq(_abi->_vector_argument_registers.at(i), Address(Rctx, offs));
   }
 
-  for (int i = 0; i < abi._integer_argument_registers.length(); i++) {
-    ssize_t offs = layout.arguments_integer + i * sizeof(uintptr_t);
-    __ ldr(abi._integer_argument_registers.at(i), Address(Rctx, offs));
+  for (int i = 0; i < _abi->_integer_argument_registers.length(); i++) {
+    ssize_t offs = _layout->arguments_integer + i * sizeof(uintptr_t);
+    __ ldr(_abi->_integer_argument_registers.at(i), Address(Rctx, offs));
   }
 
-  assert(abi._shadow_space_bytes == 0, "shadow space not supported on AArch64");
+  assert(_abi->_shadow_space_bytes == 0, "shadow space not supported on AArch64");
 
   // call target function
   __ block_comment("call target function");
-  __ ldr(rscratch2, Address(Rctx, (int) layout.arguments_next_pc));
+  __ ldr(rscratch2, Address(Rctx, (int) _layout->arguments_next_pc));
   __ blr(rscratch2);
 
   __ ldr(Rctx, Address(rfp, -2 * wordSize));   // Might have clobbered Rctx
 
   __ block_comment("store_registers");
 
-  for (int i = 0; i < abi._integer_return_registers.length(); i++) {
-    ssize_t offs = layout.returns_integer + i * sizeof(uintptr_t);
-    __ str(abi._integer_return_registers.at(i), Address(Rctx, offs));
+  for (int i = 0; i < _abi->_integer_return_registers.length(); i++) {
+    ssize_t offs = _layout->returns_integer + i * sizeof(uintptr_t);
+    __ str(_abi->_integer_return_registers.at(i), Address(Rctx, offs));
   }
 
-  for (int i = 0; i < abi._vector_return_registers.length(); i++) {
-    ssize_t offs = layout.returns_vector + i * sizeof(VectorRegister);
-    __ strq(abi._vector_return_registers.at(i), Address(Rctx, offs));
+  for (int i = 0; i < _abi->_vector_return_registers.length(); i++) {
+    ssize_t offs = _layout->returns_vector + i * sizeof(VectorRegister);
+    __ strq(_abi->_vector_return_registers.at(i), Address(Rctx, offs));
   }
 
   __ leave();
@@ -134,22 +109,7 @@ static void generate_invoke_native(MacroAssembler* _masm,
   __ flush();
 }
 
-class ProgrammableInvokerGenerator : public StubCodeGenerator {
-private:
-  const ABIDescriptor* _abi;
-  const BufferLayout* _layout;
-public:
-  ProgrammableInvokerGenerator(CodeBuffer* code, const ABIDescriptor* abi, const BufferLayout* layout)
-    : StubCodeGenerator(code, PrintMethodHandleStubs),
-      _abi(abi),
-      _layout(layout) {}
-
-  void generate() {
-    generate_invoke_native(_masm, *_abi, *_layout);
-  }
-};
-
-jlong ProgrammableInvoker::generate_adapter(jobject jabi, jobject jlayout) {
+address ProgrammableInvoker::generate_adapter(jobject jabi, jobject jlayout) {
   ResourceMark rm;
   const ABIDescriptor abi = ForeignGlobals::parse_abi_descriptor(jabi);
   const BufferLayout layout = ForeignGlobals::parse_buffer_layout(jlayout);
@@ -157,9 +117,9 @@ jlong ProgrammableInvoker::generate_adapter(jobject jabi, jobject jlayout) {
   BufferBlob* _invoke_native_blob = BufferBlob::create("invoke_native_blob", native_invoker_size);
 
   CodeBuffer code2(_invoke_native_blob);
-  ProgrammableInvokerGenerator g2(&code2, &abi, &layout);
+  ProgrammableInvoker::Generator g2(&code2, &abi, &layout);
   g2.generate();
   code2.log_section_sizes("InvokeNativeBlob");
 
-  return (jlong) _invoke_native_blob->code_begin();
+  return _invoke_native_blob->code_begin();
 }
diff --git a/src/hotspot/cpu/aarch64/universalUpcallHandler_aarch64.cpp b/src/hotspot/cpu/aarch64/universalUpcallHandler_aarch64.cpp
index be729fb3060d9..3c4e3fd11af15 100644
--- a/src/hotspot/cpu/aarch64/universalUpcallHandler_aarch64.cpp
+++ b/src/hotspot/cpu/aarch64/universalUpcallHandler_aarch64.cpp
@@ -24,102 +24,14 @@
 
 #include "precompiled.hpp"
 #include "asm/macroAssembler.hpp"
-#include "classfile/javaClasses.inline.hpp"
-#include "classfile/symbolTable.hpp"
-#include "include/jvm.h"
-#include "jni.h"
-#include "logging/log.hpp"
-#include "logging/logStream.hpp"
-#include "memory/allocation.inline.hpp"
 #include "memory/resourceArea.hpp"
-#include "oops/arrayOop.inline.hpp"
 #include "prims/universalUpcallHandler.hpp"
-#include "runtime/interfaceSupport.inline.hpp"
-#include "runtime/javaCalls.hpp"
-#include "runtime/jniHandles.inline.hpp"
-
-static constexpr CodeBuffer::csize_t upcall_stub_size = 1024;
-
-extern struct JavaVM_ main_vm;
-
-static struct {
-  bool inited;
-  struct {
-    Klass* klass;
-    Symbol* name;
-    Symbol* sig;
-  } upcall_method;  // jdk.internal.foreign.abi.UniversalUpcallHandler::invoke
-} upcall_info;
-
-// FIXME: This should be initialized explicitly instead of lazily/racily
-static void upcall_init() {
-#if 0
-  fprintf(stderr, "upcall_init()\n");
-#endif
-
-  TRAPS = Thread::current();
-  ResourceMark rm;
-
-  const char* cname = "jdk/internal/foreign/abi/ProgrammableUpcallHandler";
-  const char* mname = "invoke";
-  const char* mdesc = "(Ljdk/internal/foreign/abi/ProgrammableUpcallHandler;J)V";
-  Symbol* cname_sym = SymbolTable::new_symbol(cname, (int)strlen(cname));
-  Symbol* mname_sym = SymbolTable::new_symbol(mname, (int)strlen(mname));
-  Symbol* mdesc_sym = SymbolTable::new_symbol(mdesc, (int)strlen(mdesc));
-
-#if 0
-  ::fprintf(stderr, "cname_sym: %p\n", cname_sym);
-  ::fprintf(stderr, "mname_sym: %p\n", mname_sym);
-  ::fprintf(stderr, "mdesc_sym: %p\n", mdesc_sym);
-#endif
-
-  Klass* k = SystemDictionary::resolve_or_null(cname_sym, THREAD);
-#if 0
-  ::fprintf(stderr, "Klass: %p\n", k);
-#endif
-
-  Method* method = k->lookup_method(mname_sym, mdesc_sym);
-#if 0
-  ::fprintf(stderr, "Method: %p\n", method);
-#endif
-
-  upcall_info.upcall_method.klass = k;
-  upcall_info.upcall_method.name = mname_sym;
-  upcall_info.upcall_method.sig = mdesc_sym;
-
-  upcall_info.inited = true;
-}
-
-static void upcall_helper(jobject rec, address buff) {
-  void *p_env = NULL;
-
-  Thread* thread = Thread::current_or_null();
-  if (thread == NULL) {
-    JavaVM_ *vm = (JavaVM *)(&main_vm);
-    vm -> functions -> AttachCurrentThreadAsDaemon(vm, &p_env, NULL);
-    thread = Thread::current();
-  }
-
-  assert(thread->is_Java_thread(), "really?");
-
-  ThreadInVMfromNative __tiv((JavaThread *)thread);
-
-  if (!upcall_info.inited) {
-    upcall_init();
-  }
-
-  ResourceMark rm;
-  JavaValue result(T_VOID);
-  JavaCallArguments args(2); // long = 2 slots
-
-  args.push_jobject(rec);
-  args.push_long((jlong) buff);
-
-  JavaCalls::call_static(&result, upcall_info.upcall_method.klass,
-                         upcall_info.upcall_method.name, upcall_info.upcall_method.sig,
-                         &args, thread);
-}
 
+// 1. Create buffer according to layout
+// 2. Load registers & stack args into buffer
+// 3. Call upcall helper with upcall handler instance & buffer pointer (C++ ABI)
+// 4. Load return value from buffer into foreign ABI registers
+// 5. Return
 address ProgrammableUpcallHandler::generate_upcall_stub(jobject rec, jobject jabi, jobject jlayout) {
   ResourceMark rm;
   const ABIDescriptor abi = ForeignGlobals::parse_abi_descriptor(jabi);
@@ -162,7 +74,7 @@ address ProgrammableUpcallHandler::generate_upcall_stub(jobject rec, jobject jab
   // Call upcall helper
   __ ldr(c_rarg0, rec_adr);
   __ mov(c_rarg1, sp);
-  __ movptr(rscratch1, CAST_FROM_FN_PTR(uint64_t, upcall_helper));
+  __ movptr(rscratch1, CAST_FROM_FN_PTR(uint64_t, ProgrammableUpcallHandler::attach_thread_and_do_upcall));
   __ blr(rscratch1);
 
   for (int i = 0; i < abi._integer_return_registers.length(); i++) {
diff --git a/src/hotspot/cpu/x86/universalNativeInvoker_x86.cpp b/src/hotspot/cpu/x86/universalNativeInvoker_x86.cpp
index 206fbd192887d..5689ef6385dad 100644
--- a/src/hotspot/cpu/x86/universalNativeInvoker_x86.cpp
+++ b/src/hotspot/cpu/x86/universalNativeInvoker_x86.cpp
@@ -23,44 +23,11 @@
 
 #include "precompiled.hpp"
 #include "asm/macroAssembler.hpp"
-#include "classfile/javaClasses.inline.hpp"
-#include "interpreter/interpreter.hpp"
-#include "interpreter/interpreterRuntime.hpp"
-#include "memory/allocation.inline.hpp"
-#include "memory/resourceArea.hpp"
-#include "include/jvm.h"
 #include "prims/universalNativeInvoker.hpp"
-#include "runtime/javaCalls.hpp"
-#include "runtime/interfaceSupport.inline.hpp"
-#include "logging/log.hpp"
-#include "logging/logStream.hpp"
-#include "oops/arrayOop.inline.hpp"
-#include "runtime/jniHandles.inline.hpp"
-#include "prims/methodHandles.hpp"
-
-static constexpr CodeBuffer::csize_t native_invoker_size = 1024;
-
-void generate_invoke_native(MacroAssembler* _masm, const ABIDescriptor& abi, const BufferLayout& layout) {
-
-#if 0
-  fprintf(stderr, "generate_invoke_native()\n");
-#endif
-
-  /**
-   * invoke_native_stub(struct ShuffleDowncallContext* ctxt) {
-   *   rbx = ctxt;
-   *
-   *   stack = alloca(ctxt->arguments.stack_args_bytes);
-   *
-   *   load_all_registers();
-   *   memcpy(stack, ctxt->arguments.stack_args, arguments.stack_args_bytes);
-   *
-   *   (*ctxt->arguments.next_pc)();
-   *
-   *   store_all_registers();
-   * }
-   */
+#include "memory/resourceArea.hpp"
+#include "code/codeBlob.hpp"
 
+void ProgrammableInvoker::Generator::generate() {
   __ enter();
 
   // Put the context pointer in ebx/rbx - it's going to be heavily used below both before and after the call
@@ -70,7 +37,7 @@ void generate_invoke_native(MacroAssembler* _masm, const ABIDescriptor& abi, con
 
   for (size_t i = 0; i < sizeof(used_regs)/sizeof(Register); i++) {
     Register used_reg = used_regs[i];
-    if (!abi.is_volatile_reg(used_reg)) {
+    if (!_abi->is_volatile_reg(used_reg)) {
       preserved_regs.push(used_reg);
     }
   }
@@ -84,9 +51,9 @@ void generate_invoke_native(MacroAssembler* _masm, const ABIDescriptor& abi, con
   __ movptr(ctxt_reg, c_rarg0); // FIXME c args? or java?
 
   __ block_comment("allocate_stack");
-  __ movptr(rcx, Address(ctxt_reg, (int) layout.stack_args_bytes));
+  __ movptr(rcx, Address(ctxt_reg, (int) _layout->stack_args_bytes));
   __ subptr(rsp, rcx);
-  __ andptr(rsp, -abi._stack_alignment_bytes);
+  __ andptr(rsp, -_abi->_stack_alignment_bytes);
 
   // Note: rcx is used below!
 
@@ -94,19 +61,19 @@ void generate_invoke_native(MacroAssembler* _masm, const ABIDescriptor& abi, con
   __ block_comment("load_arguments");
 
   __ shrptr(rcx, LogBytesPerWord); // bytes -> words
-  __ movptr(rsi, Address(ctxt_reg, (int) layout.stack_args));
+  __ movptr(rsi, Address(ctxt_reg, (int) _layout->stack_args));
   __ movptr(rdi, rsp);
   __ rep_mov();
 
 
-  for (int i = 0; i < abi._vector_argument_registers.length(); i++) {
+  for (int i = 0; i < _abi->_vector_argument_registers.length(); i++) {
     // [1] -> 64 bit -> xmm
     // [2] -> 128 bit -> xmm
     // [4] -> 256 bit -> ymm
     // [8] -> 512 bit -> zmm
 
-    XMMRegister reg = abi._vector_argument_registers.at(i);
-    size_t offs = layout.arguments_vector + i * sizeof(VectorRegister);
+    XMMRegister reg = _abi->_vector_argument_registers.at(i);
+    size_t offs = _layout->arguments_vector + i * sizeof(VectorRegister);
     if (UseAVX >= 3) {
       __ evmovdqul(reg, Address(ctxt_reg, (int)offs), Assembler::AVX_512bit);
     } else if (UseAVX >= 1) {
@@ -116,39 +83,39 @@ void generate_invoke_native(MacroAssembler* _masm, const ABIDescriptor& abi, con
     }
   }
 
-  for (int i = 0; i < abi._integer_argument_registers.length(); i++) {
-    size_t offs = layout.arguments_integer + i * sizeof(uintptr_t);
-    __ movptr(abi._integer_argument_registers.at(i), Address(ctxt_reg, (int)offs));
+  for (int i = 0; i < _abi->_integer_argument_registers.length(); i++) {
+    size_t offs = _layout->arguments_integer + i * sizeof(uintptr_t);
+    __ movptr(_abi->_integer_argument_registers.at(i), Address(ctxt_reg, (int)offs));
   }
 
-  if (abi._shadow_space_bytes != 0) {
+  if (_abi->_shadow_space_bytes != 0) {
     __ block_comment("allocate shadow space for argument register spill");
-    __ subptr(rsp, abi._shadow_space_bytes);
+    __ subptr(rsp, _abi->_shadow_space_bytes);
   }
 
   // call target function
   __ block_comment("call target function");
-  __ call(Address(ctxt_reg, (int) layout.arguments_next_pc));
+  __ call(Address(ctxt_reg, (int) _layout->arguments_next_pc));
 
-  if (abi._shadow_space_bytes != 0) {
+  if (_abi->_shadow_space_bytes != 0) {
     __ block_comment("pop shadow space");
-    __ addptr(rsp, abi._shadow_space_bytes);
+    __ addptr(rsp, _abi->_shadow_space_bytes);
   }
 
   __ block_comment("store_registers");
-  for (int i = 0; i < abi._integer_return_registers.length(); i++) {
-    ssize_t offs = layout.returns_integer + i * sizeof(uintptr_t);
-    __ movptr(Address(ctxt_reg, offs), abi._integer_return_registers.at(i));
+  for (int i = 0; i < _abi->_integer_return_registers.length(); i++) {
+    ssize_t offs = _layout->returns_integer + i * sizeof(uintptr_t);
+    __ movptr(Address(ctxt_reg, offs), _abi->_integer_return_registers.at(i));
   }
 
-  for (int i = 0; i < abi._vector_return_registers.length(); i++) {
+  for (int i = 0; i < _abi->_vector_return_registers.length(); i++) {
     // [1] -> 64 bit -> xmm
     // [2] -> 128 bit -> xmm (SSE)
     // [4] -> 256 bit -> ymm (AVX)
     // [8] -> 512 bit -> zmm (AVX-512, aka AVX3)
 
-    XMMRegister reg = abi._vector_return_registers.at(i);
-    size_t offs = layout.returns_vector + i * sizeof(VectorRegister);
+    XMMRegister reg = _abi->_vector_return_registers.at(i);
+    size_t offs = _layout->returns_vector + i * sizeof(VectorRegister);
     if (UseAVX >= 3) {
       __ evmovdqul(Address(ctxt_reg, (int)offs), reg, Assembler::AVX_512bit);
     } else if (UseAVX >= 1) {
@@ -158,8 +125,8 @@ void generate_invoke_native(MacroAssembler* _masm, const ABIDescriptor& abi, con
     }
   }
 
-  for (size_t i = 0; i < abi._X87_return_registers_noof; i++) {
-    size_t offs = layout.returns_x87 + i * (sizeof(long double));
+  for (size_t i = 0; i < _abi->_X87_return_registers_noof; i++) {
+    size_t offs = _layout->returns_x87 + i * (sizeof(long double));
     __ fstp_x(Address(ctxt_reg, (int)offs)); //pop ST(0)
   }
 
@@ -174,20 +141,7 @@ void generate_invoke_native(MacroAssembler* _masm, const ABIDescriptor& abi, con
   __ flush();
 }
 
-class ProgrammableInvokerGenerator : public StubCodeGenerator {
-private:
-  const ABIDescriptor* _abi;
-  const BufferLayout* _layout;
-public:
-  ProgrammableInvokerGenerator(CodeBuffer* code, const ABIDescriptor* abi, const BufferLayout* layout)
-   : StubCodeGenerator(code, PrintMethodHandleStubs), _abi(abi), _layout(layout) {}
-
-  void generate() {
-      generate_invoke_native(_masm, *_abi, *_layout);
-  }
-};
-
-jlong ProgrammableInvoker::generate_adapter(jobject jabi, jobject jlayout) {
+address ProgrammableInvoker::generate_adapter(jobject jabi, jobject jlayout) {
   ResourceMark rm;
   const ABIDescriptor abi = ForeignGlobals::parse_abi_descriptor(jabi);
   const BufferLayout layout = ForeignGlobals::parse_buffer_layout(jlayout);
@@ -195,9 +149,9 @@ jlong ProgrammableInvoker::generate_adapter(jobject jabi, jobject jlayout) {
   BufferBlob* _invoke_native_blob = BufferBlob::create("invoke_native_blob", native_invoker_size);
 
   CodeBuffer code2(_invoke_native_blob);
-  ProgrammableInvokerGenerator g2(&code2, &abi, &layout);
+  ProgrammableInvoker::Generator g2(&code2, &abi, &layout);
   g2.generate();
   code2.log_section_sizes("InvokeNativeBlob");
 
-  return (jlong) _invoke_native_blob->code_begin();
+  return _invoke_native_blob->code_begin();
 }
diff --git a/src/hotspot/cpu/x86/universalUpcallHandler_x86.cpp b/src/hotspot/cpu/x86/universalUpcallHandler_x86.cpp
index 93514a48e2a35..1e7ddd036d045 100644
--- a/src/hotspot/cpu/x86/universalUpcallHandler_x86.cpp
+++ b/src/hotspot/cpu/x86/universalUpcallHandler_x86.cpp
@@ -23,102 +23,14 @@
 
 #include "precompiled.hpp"
 #include "asm/macroAssembler.hpp"
-#include "classfile/javaClasses.inline.hpp"
-#include "interpreter/interpreter.hpp"
-#include "interpreter/interpreterRuntime.hpp"
-#include "memory/allocation.inline.hpp"
 #include "memory/resourceArea.hpp"
-#include "include/jvm.h"
-#include "jni.h"
 #include "prims/universalUpcallHandler.hpp"
-#include "runtime/javaCalls.hpp"
-#include "runtime/interfaceSupport.inline.hpp"
-#include "logging/log.hpp"
-#include "logging/logStream.hpp"
-#include "oops/arrayOop.inline.hpp"
-#include "runtime/jniHandles.inline.hpp"
-#include "classfile/symbolTable.hpp"
-
-static constexpr CodeBuffer::csize_t upcall_stub_size = 1024;
-
-extern struct JavaVM_ main_vm;
-
-static struct {
-  bool inited;
-  struct {
-    Klass* klass;
-    Symbol* name;
-    Symbol* sig;
-  } upcall_method;  // jdk.internal.foreign.abi.UniversalUpcallHandler::invoke
-} upcall_info;
-
-// FIXME: This should be initialized explicitly instead of lazily/racily
-static void upcall_init() {
-#if 0
-  fprintf(stderr, "upcall_init()\n");
-#endif
-
-  TRAPS = Thread::current();
-  ResourceMark rm;
-
-  const char* cname = "jdk/internal/foreign/abi/ProgrammableUpcallHandler";
-  const char* mname = "invoke";
-  const char* mdesc = "(Ljdk/internal/foreign/abi/ProgrammableUpcallHandler;J)V";
-  Symbol* cname_sym = SymbolTable::new_symbol(cname, (int)strlen(cname));
-  Symbol* mname_sym = SymbolTable::new_symbol(mname, (int)strlen(mname));
-  Symbol* mdesc_sym = SymbolTable::new_symbol(mdesc, (int)strlen(mdesc));
-
-#if 0
-  ::fprintf(stderr, "cname_sym: %p\n", cname_sym);
-  ::fprintf(stderr, "mname_sym: %p\n", mname_sym);
-  ::fprintf(stderr, "mdesc_sym: %p\n", mdesc_sym);
-#endif
-
-  Klass* k = SystemDictionary::resolve_or_null(cname_sym, THREAD);
-#if 0
-  ::fprintf(stderr, "Klass: %p\n", k);
-#endif
-
-  Method* method = k->lookup_method(mname_sym, mdesc_sym);
-#if 0
-  ::fprintf(stderr, "Method: %p\n", method);
-#endif
-
-  upcall_info.upcall_method.klass = k;
-  upcall_info.upcall_method.name = mname_sym;
-  upcall_info.upcall_method.sig = mdesc_sym;
-
-  upcall_info.inited = true;
-}
-
-static void upcall_helper(jobject rec, address buff) {
-  void *p_env = NULL;
-
-  Thread* thread = Thread::current_or_null();
-  if (thread == NULL) {
-    JavaVM_ *vm = (JavaVM *)(&main_vm);
-    vm -> functions -> AttachCurrentThreadAsDaemon(vm, &p_env, NULL);
-    thread = Thread::current();
-  }
-
-  assert(thread->is_Java_thread(), "really?");
-
-  ThreadInVMfromNative __tiv((JavaThread *)thread);
-
-  if (!upcall_info.inited) {
-    upcall_init();
-  }
-
-  ResourceMark rm;
-  JavaValue result(T_VOID);
-  JavaCallArguments args(2); // long = 2 slots
-
-  args.push_jobject(rec);
-  args.push_long((jlong) buff);
-
-  JavaCalls::call_static(&result, upcall_info.upcall_method.klass, upcall_info.upcall_method.name, upcall_info.upcall_method.sig, &args, thread);
-}
 
+// 1. Create buffer according to layout
+// 2. Load registers & stack args into buffer
+// 3. Call upcall helper with upcall handler instance & buffer pointer (C++ ABI)
+// 4. Load return value from buffer into foreign ABI registers
+// 5. Return
 address ProgrammableUpcallHandler::generate_upcall_stub(jobject rec, jobject jabi, jobject jlayout) {
   ResourceMark rm;
   const ABIDescriptor abi = ForeignGlobals::parse_abi_descriptor(jabi);
@@ -195,7 +107,7 @@ address ProgrammableUpcallHandler::generate_upcall_stub(jobject rec, jobject jab
   __ subptr(rsp, 32);
 #endif
 
-  __ call(RuntimeAddress(CAST_FROM_FN_PTR(address, upcall_helper)));
+  __ call(RuntimeAddress(CAST_FROM_FN_PTR(address, ProgrammableUpcallHandler::attach_thread_and_do_upcall)));
 
 #ifdef _WIN64
   __ block_comment("pop shadow space");
diff --git a/src/hotspot/share/prims/universalNativeInvoker.cpp b/src/hotspot/share/prims/universalNativeInvoker.cpp
index a5b789283827f..326833882a540 100644
--- a/src/hotspot/share/prims/universalNativeInvoker.cpp
+++ b/src/hotspot/share/prims/universalNativeInvoker.cpp
@@ -22,14 +22,15 @@
  */
 
 #include "precompiled.hpp"
-#include "code/codeBlob.hpp"
 #include "prims/universalNativeInvoker.hpp"
 #include "runtime/interfaceSupport.inline.hpp"
-#include "runtime/jniHandles.inline.hpp"
-#include "runtime/stubCodeGenerator.hpp"
-#include "prims/methodHandles.hpp"
 
-void ProgrammableInvoker::invoke_native(ProgrammableStub stub, address buff, JavaThread* thread) {
+ProgrammableInvoker::Generator::Generator(CodeBuffer* code, const ABIDescriptor* abi, const BufferLayout* layout)
+  : StubCodeGenerator(code),
+    _abi(abi),
+    _layout(layout) {}
+
+void ProgrammableInvoker::invoke_native(Stub stub, address buff, JavaThread* thread) {
   {
     assert(thread->thread_state() == _thread_in_vm, "thread state is: %d", thread->thread_state());
     ThreadToNativeFromVM ttnfvm(thread);
@@ -42,13 +43,13 @@ void ProgrammableInvoker::invoke_native(ProgrammableStub stub, address buff, Jav
 
 JNI_ENTRY(void, PI_invokeNative(JNIEnv* env, jclass _unused, jlong adapter_stub, jlong buff))
   assert(thread->thread_state() == _thread_in_vm, "thread state is: %d", thread->thread_state());
-  ProgrammableStub stub = (ProgrammableStub) adapter_stub;
+  ProgrammableInvoker::Stub stub = (ProgrammableInvoker::Stub) adapter_stub;
   address c = (address) buff;
   ProgrammableInvoker::invoke_native(stub, c, thread);
 JNI_END
 
 JNI_ENTRY(jlong, PI_generateAdapter(JNIEnv* env, jclass _unused, jobject abi, jobject layout))
-  return ProgrammableInvoker::generate_adapter(abi, layout);
+  return (jlong) ProgrammableInvoker::generate_adapter(abi, layout);
 JNI_END
 
 #define CC (char*)  /*cast a literal from (const char*)*/
diff --git a/src/hotspot/share/prims/universalNativeInvoker.hpp b/src/hotspot/share/prims/universalNativeInvoker.hpp
index 3605942f8fe90..1541b45822742 100644
--- a/src/hotspot/share/prims/universalNativeInvoker.hpp
+++ b/src/hotspot/share/prims/universalNativeInvoker.hpp
@@ -24,28 +24,27 @@
 #ifndef SHARE_VM_PRIMS_UNIVERSALNATIVEINVOKER_HPP
 #define SHARE_VM_PRIMS_UNIVERSALNATIVEINVOKER_HPP
 
-#include "classfile/javaClasses.hpp"
-#include "classfile/vmSymbols.hpp"
-#include "include/jvm.h"
-#include "runtime/frame.inline.hpp"
-#include "runtime/globals.hpp"
-#include "utilities/macros.hpp"
+#include "runtime/stubCodeGenerator.hpp"
 #include "prims/foreign_globals.hpp"
 
-#ifdef ZERO
-# include "entry_zero.hpp"
-#endif
-
-class MacroAssembler;
-class Label;
-class ShuffleRecipe;
+class ProgrammableInvoker: AllStatic {
+private:
+  static constexpr CodeBuffer::csize_t native_invoker_size = 1024;
 
-typedef void (*ProgrammableStub)(address);
+  class Generator : StubCodeGenerator {
+  private:
+    const ABIDescriptor* _abi;
+    const BufferLayout* _layout;
+  public:
+    Generator(CodeBuffer* code, const ABIDescriptor* abi, const BufferLayout* layout);
 
-class ProgrammableInvoker: AllStatic {
+    void generate();
+  };
 public:
-  static void invoke_native(ProgrammableStub stub, address buff, JavaThread* thread);
-  static jlong generate_adapter(jobject abi, jobject layout);
+  using Stub = void(*)(address);
+
+  static void invoke_native(Stub stub, address buff, JavaThread* thread);
+  static address generate_adapter(jobject abi, jobject layout);
 };
 
 #endif // SHARE_VM_PRIMS_UNIVERSALNATIVEINVOKER_HPP
diff --git a/src/hotspot/share/prims/universalUpcallHandler.cpp b/src/hotspot/share/prims/universalUpcallHandler.cpp
index a829b12805481..a863df1b77152 100644
--- a/src/hotspot/share/prims/universalUpcallHandler.cpp
+++ b/src/hotspot/share/prims/universalUpcallHandler.cpp
@@ -25,6 +25,66 @@
 #include "prims/universalUpcallHandler.hpp"
 #include "runtime/jniHandles.inline.hpp"
 #include "runtime/interfaceSupport.inline.hpp"
+#include "runtime/javaCalls.hpp"
+#include "classfile/symbolTable.hpp"
+
+#define FOREIGN_ABI "jdk/internal/foreign/abi/"
+
+extern struct JavaVM_ main_vm;
+
+JNI_ENTRY(void, ProgrammableUpcallHandler::upcall_helper(JNIEnv* env, jobject rec, address buff))
+  const UpcallMethod& upcall_method = instance().upcall_method;
+
+  ResourceMark rm(thread);
+  JavaValue result(T_VOID);
+  JavaCallArguments args(2); // long = 2 slots
+
+  args.push_jobject(rec);
+  args.push_long((jlong) buff);
+
+  JavaCalls::call_static(&result, upcall_method.klass, upcall_method.name, upcall_method.sig, &args, thread);
+JNI_END
+
+void ProgrammableUpcallHandler::attach_thread_and_do_upcall(jobject rec, address buff) {
+  Thread* thread = Thread::current_or_null();
+  bool should_detach = false;
+  JNIEnv* p_env = nullptr;
+  if (thread == nullptr) {
+    JavaVM_ *vm = (JavaVM *)(&main_vm);
+    vm->functions->AttachCurrentThread(vm, (void**) &p_env, nullptr);
+    should_detach = true;
+    thread = Thread::current();
+  } else {
+    p_env = thread->as_Java_thread()->jni_environment();
+  }
+
+  upcall_helper(p_env, rec, buff);
+
+  if (should_detach) {
+    JavaVM_ *vm = (JavaVM *)(&main_vm);
+    vm->functions->DetachCurrentThread(vm);
+  }
+}
+
+const ProgrammableUpcallHandler& ProgrammableUpcallHandler::instance() {
+  static ProgrammableUpcallHandler handler;
+  return handler;
+}
+
+ProgrammableUpcallHandler::ProgrammableUpcallHandler() {
+  Symbol* sym = SymbolTable::new_symbol(FOREIGN_ABI "ProgrammableUpcallHandler");
+  Thread* THREAD = Thread::current();
+  Klass* k = SystemDictionary::resolve_or_null(sym, Handle(), Handle(), CATCH);
+  k->initialize(CATCH);
+
+  upcall_method.klass = k;
+  upcall_method.name = SymbolTable::new_symbol("invoke");
+  upcall_method.sig = SymbolTable::new_symbol("(L" FOREIGN_ABI "ProgrammableUpcallHandler;J)V");
+
+  assert(upcall_method.klass->lookup_method(upcall_method.name, upcall_method.sig) != nullptr,
+    "Could not find upcall method: %s.%s%s", upcall_method.klass->external_name(),
+    upcall_method.name->as_C_string(), upcall_method.sig->as_C_string());
+}
 
 JNI_ENTRY(jlong, PUH_AllocateUpcallStub(JNIEnv *env, jobject rec, jobject abi, jobject buffer_layout))
   Handle receiver(THREAD, JNIHandles::resolve(rec));
@@ -34,12 +94,9 @@ JNI_END
 
 #define CC (char*)  /*cast a literal from (const char*)*/
 #define FN_PTR(f) CAST_FROM_FN_PTR(void*, &f)
-#define LANG "Ljava/lang/"
-
-#define FOREIGN_ABI "Ljdk/internal/foreign/abi"
 
 static JNINativeMethod PUH_methods[] = {
-  {CC "allocateUpcallStub", CC "(" FOREIGN_ABI "/ABIDescriptor;" FOREIGN_ABI "/BufferLayout;" ")J", FN_PTR(PUH_AllocateUpcallStub)},
+  {CC "allocateUpcallStub", CC "(L" FOREIGN_ABI "ABIDescriptor;L" FOREIGN_ABI "BufferLayout;" ")J", FN_PTR(PUH_AllocateUpcallStub)},
 };
 
 /**
diff --git a/src/hotspot/share/prims/universalUpcallHandler.hpp b/src/hotspot/share/prims/universalUpcallHandler.hpp
index c56c44efef9c4..3ba8aa9b80edd 100644
--- a/src/hotspot/share/prims/universalUpcallHandler.hpp
+++ b/src/hotspot/share/prims/universalUpcallHandler.hpp
@@ -24,15 +24,24 @@
 #ifndef SHARE_VM_PRIMS_UNIVERSALUPCALLHANDLER_HPP
 #define SHARE_VM_PRIMS_UNIVERSALUPCALLHANDLER_HPP
 
-#include "classfile/javaClasses.hpp"
-#include "classfile/vmSymbols.hpp"
-#include "include/jvm.h"
-#include "runtime/frame.inline.hpp"
-#include "runtime/globals.hpp"
-#include "utilities/macros.hpp"
 #include "prims/foreign_globals.hpp"
 
-class ProgrammableUpcallHandler : AllStatic {
+class ProgrammableUpcallHandler {
+private:
+  static constexpr CodeBuffer::csize_t upcall_stub_size = 1024;
+
+  struct UpcallMethod {
+    Klass* klass;
+    Symbol* name;
+    Symbol* sig;
+  } upcall_method;
+
+  ProgrammableUpcallHandler();
+
+  static const ProgrammableUpcallHandler& instance();
+
+  static void upcall_helper(JNIEnv* env, jobject rec, address buff);
+  static void attach_thread_and_do_upcall(jobject rec, address buff);
 public:
   static address generate_upcall_stub(jobject rec, jobject abi, jobject buffer_layout);
 };

From 9960b3d7cf66822624edcb924fc214397555ab17 Mon Sep 17 00:00:00 2001
From: Maurizio Cimadamore 
Date: Tue, 10 Nov 2020 12:06:33 +0000
Subject: [PATCH 49/70] Address more CSR feedback

---
 .../jdk/incubator/foreign/CLinker.java        | 34 +++++++------------
 .../jdk/internal/foreign/PlatformLayouts.java | 22 +-----------
 .../foreign/abi/aarch64/TypeClass.java        |  4 +--
 .../foreign/abi/x64/sysv/TypeClass.java       |  3 +-
 .../foreign/abi/x64/windows/TypeClass.java    |  4 +--
 test/jdk/java/foreign/TestCondy.java          |  3 +-
 6 files changed, 20 insertions(+), 50 deletions(-)

diff --git a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/CLinker.java b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/CLinker.java
index 8e1b73a57d2b6..0c29f115aa6d9 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/CLinker.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/CLinker.java
@@ -176,10 +176,6 @@ static CLinker getInstance() {
      * The layout for the {@code double} C type
      */
     ValueLayout C_DOUBLE = pick(SysV.C_DOUBLE, Win64.C_DOUBLE, AArch64.C_DOUBLE);
-    /**
-     * The layout for the {@code long double} C type.
-     */
-    ValueLayout C_LONG_DOUBLE = pick(SysV.C_LONG_DOUBLE, Win64.C_LONG_DOUBLE, AArch64.C_LONG_DOUBLE);
     /**
      * The {@code T*} native type.
      */
@@ -294,7 +290,7 @@ static MemorySegment toCString(String str, Charset charset, NativeScope scope) {
      * @param addr the address at which the string is stored.
      * @return a Java string with the contents of the null-terminated C string at given address.
      * @throws NullPointerException if {@code addr == null}
-     * @throws IllegalArgumentException if the size of the native string is greater than {@code Integer.MAX_VALUE}.
+     * @throws IllegalArgumentException if the size of the native string is greater than the largest string supported by the platform.
      */
     static String toJavaStringRestricted(MemoryAddress addr) {
         Utils.checkRestrictedAccess("CLinker.toJavaStringRestricted");
@@ -316,7 +312,7 @@ static String toJavaStringRestricted(MemoryAddress addr) {
      * @param charset The {@link java.nio.charset.Charset} to be used to compute the contents of the Java string.
      * @return a Java string with the contents of the null-terminated C string at given address.
      * @throws NullPointerException if {@code addr == null} or {@code charset == null}.
-     * @throws IllegalArgumentException if the size of the native string is greater than {@code Integer.MAX_VALUE}.
+     * @throws IllegalArgumentException if the size of the native string is greater than the largest string supported by the platform.
      */
     static String toJavaStringRestricted(MemoryAddress addr, Charset charset) {
         Utils.checkRestrictedAccess("CLinker.toJavaStringRestricted");
@@ -335,7 +331,7 @@ static String toJavaStringRestricted(MemoryAddress addr, Charset charset) {
      * @param addr the address at which the string is stored.
      * @return a Java string with the contents of the null-terminated C string at given address.
      * @throws NullPointerException if {@code addr == null}
-     * @throws IllegalArgumentException if the size of the native string is greater than {@code Integer.MAX_VALUE}.
+     * @throws IllegalArgumentException if the size of the native string is greater than the largest string supported by the platform.
      * @throws IllegalStateException if the size of the native string is greater than the size of the segment
      * associated with {@code addr}, or if {@code addr} is associated with a segment that is not alive.
      */
@@ -355,7 +351,7 @@ static String toJavaString(MemorySegment addr) {
      * @param charset The {@link java.nio.charset.Charset} to be used to compute the contents of the Java string.
      * @return a Java string with the contents of the null-terminated C string at given address.
      * @throws NullPointerException if {@code addr == null} or {@code charset == null}.
-     * @throws IllegalArgumentException if the size of the native string is greater than {@code Integer.MAX_VALUE}.
+     * @throws IllegalArgumentException if the size of the native string is greater than the largest string supported by the platform.
      * @throws IllegalStateException if the size of the native string is greater than the size of the segment
      * associated with {@code addr}, or if {@code addr} is associated with a segment that is not alive.
      */
@@ -727,39 +723,35 @@ interface Builder {
      */
     enum TypeKind {
         /**
-         * A kind corresponding to the C {@code char} type
+         * A kind corresponding to the integral C {@code char} type
          */
         CHAR(true),
         /**
-         * A kind corresponding to the C {@code short} type
+         * A kind corresponding to the integral C {@code short} type
          */
         SHORT(true),
         /**
-         * A kind corresponding to the C {@code int} type
+         * A kind corresponding to the integral C {@code int} type
          */
         INT(true),
         /**
-         * A kind corresponding to the C {@code long} type
+         * A kind corresponding to the integral C {@code long} type
          */
         LONG(true),
         /**
-         * A kind corresponding to the C {@code long long} type
+         * A kind corresponding to the integral C {@code long long} type
          */
-        LONGLONG(true),
+        LONG_LONG(true),
         /**
-         * A kind corresponding to the C {@code float} type
+         * A kind corresponding to the floating-point C {@code float} type
          */
         FLOAT(false),
         /**
-         * A kind corresponding to the C {@code double} type
+         * A kind corresponding to the floating-point C {@code double} type
          */
         DOUBLE(false),
         /**
-         * A kind corresponding to the C {@code long double} type
-         */
-        LONGDOUBLE(false),
-        /**
-         * A kind corresponding to the a C pointer type
+         * A kind corresponding to the an integral C pointer type
          */
         POINTER(false);
 
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/PlatformLayouts.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/PlatformLayouts.java
index dc8ef6389fe91..bc17271a7e566 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/PlatformLayouts.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/PlatformLayouts.java
@@ -72,7 +72,7 @@ private static ValueLayout ofLong(ByteOrder order, long bitSize) {
 
     private static ValueLayout ofLongLong(ByteOrder order, long bitSize) {
         return MemoryLayout.ofValueBits(bitSize, order)
-                .withAttribute(CLinker.TypeKind.ATTR_NAME, CLinker.TypeKind.LONGLONG);
+                .withAttribute(CLinker.TypeKind.ATTR_NAME, CLinker.TypeKind.LONG_LONG);
     }
 
     private static ValueLayout ofFloat(ByteOrder order, long bitSize) {
@@ -85,11 +85,6 @@ private static ValueLayout ofDouble(ByteOrder order, long bitSize) {
                 .withAttribute(CLinker.TypeKind.ATTR_NAME, CLinker.TypeKind.DOUBLE);
     }
 
-    private static ValueLayout ofLongDouble(ByteOrder order, long bitSize) {
-        return MemoryLayout.ofValueBits(bitSize, order)
-                .withAttribute(CLinker.TypeKind.ATTR_NAME, CLinker.TypeKind.LONGDOUBLE);
-    }
-
     private static ValueLayout ofPointer(ByteOrder order, long bitSize) {
         return MemoryLayout.ofValueBits(bitSize, order)
                 .withAttribute(CLinker.TypeKind.ATTR_NAME, CLinker.TypeKind.POINTER);
@@ -143,11 +138,6 @@ private SysV() {
          */
         public static final ValueLayout C_DOUBLE = ofDouble(LITTLE_ENDIAN, 64);
 
-        /**
-         * The {@code long double} native type.
-         */
-        public static final ValueLayout C_LONG_DOUBLE = ofLongDouble(LITTLE_ENDIAN, 128);
-
         /**
          * The {@code T*} native type.
          */
@@ -208,11 +198,6 @@ private Win64() {
          */
         public static final ValueLayout C_DOUBLE = ofDouble(LITTLE_ENDIAN, 64);
 
-        /**
-         * The {@code long double} native type.
-         */
-        public static final ValueLayout C_LONG_DOUBLE = ofLongDouble(LITTLE_ENDIAN, 64);
-
         /**
          * The {@code T*} native type.
          */
@@ -278,11 +263,6 @@ private AArch64() {
          */
         public static final ValueLayout C_DOUBLE = ofDouble(LITTLE_ENDIAN, 64);
 
-        /**
-         * The {@code long double} native type.
-         */
-        public static final ValueLayout C_LONG_DOUBLE = ofLongDouble(LITTLE_ENDIAN, 128);
-
         /**
          * The {@code T*} native type.
          */
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/aarch64/TypeClass.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/aarch64/TypeClass.java
index 5d33e282eb1e9..81b496c62853d 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/aarch64/TypeClass.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/aarch64/TypeClass.java
@@ -43,9 +43,9 @@ enum TypeClass {
 
     private static TypeClass classifyValueType(ValueLayout type) {
         return switch (PlatformLayouts.getKind(type)) {
-            case CHAR, SHORT, INT, LONG, LONGLONG -> INTEGER;
+            case CHAR, SHORT, INT, LONG, LONG_LONG -> INTEGER;
             case POINTER -> POINTER;
-            case FLOAT, DOUBLE, LONGDOUBLE -> FLOAT;
+            case FLOAT, DOUBLE -> FLOAT;
         };
     }
 
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/sysv/TypeClass.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/sysv/TypeClass.java
index 59d737bd2234e..568b3d6378a4d 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/sysv/TypeClass.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/sysv/TypeClass.java
@@ -108,9 +108,8 @@ private static List createMemoryClassArray(long size) {
 
     private static ArgumentClassImpl argumentClassFor(MemoryLayout layout) {
         return switch (PlatformLayouts.getKind(layout)) {
-            case CHAR, SHORT, INT, LONG, LONGLONG -> ArgumentClassImpl.INTEGER;
+            case CHAR, SHORT, INT, LONG, LONG_LONG -> ArgumentClassImpl.INTEGER;
             case FLOAT, DOUBLE -> ArgumentClassImpl.SSE;
-            case LONGDOUBLE -> ArgumentClassImpl.X87;
             case POINTER -> ArgumentClassImpl.POINTER;
         };
     }
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/windows/TypeClass.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/windows/TypeClass.java
index d1b78f44f28e6..5a96c1b008ef2 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/windows/TypeClass.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/windows/TypeClass.java
@@ -50,9 +50,9 @@ private static TypeClass classifyValueType(ValueLayout type) {
         // https://docs.microsoft.com/en-us/cpp/build/x64-calling-convention?view=vs-2019
 
         return switch (PlatformLayouts.getKind(type)) {
-            case CHAR, SHORT, INT, LONG, LONGLONG -> INTEGER;
+            case CHAR, SHORT, INT, LONG, LONG_LONG -> INTEGER;
             case POINTER -> POINTER;
-            case FLOAT, DOUBLE, LONGDOUBLE -> {
+            case FLOAT, DOUBLE -> {
                  if (type.attribute(VARARGS_ATTRIBUTE_NAME)
                         .map(Boolean.class::cast).orElse(false)) {
                     yield VARARG_FLOAT;
diff --git a/test/jdk/java/foreign/TestCondy.java b/test/jdk/java/foreign/TestCondy.java
index 8399ad60b46e8..bb332c20048e0 100644
--- a/test/jdk/java/foreign/TestCondy.java
+++ b/test/jdk/java/foreign/TestCondy.java
@@ -57,10 +57,9 @@ public void testPublicResolve(Constable constable) throws ReflectiveOperationExc
         C_SHORT,
         C_INT,
         C_LONG,
-            C_LONG_LONG,
+        C_LONG_LONG,
         C_FLOAT,
         C_DOUBLE,
-            C_LONG_DOUBLE,
         C_POINTER
     };
 

From bd932cde77e37d9867df2ecc6476cc4568303dfa Mon Sep 17 00:00:00 2001
From: Jorn Vernee 
Date: Tue, 10 Nov 2020 11:18:06 +0000
Subject: [PATCH 50/70] remove blank line in thread.hpp

---
 src/hotspot/share/runtime/thread.hpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/hotspot/share/runtime/thread.hpp b/src/hotspot/share/runtime/thread.hpp
index 53b4f306b907c..6c6f6a3af177e 100644
--- a/src/hotspot/share/runtime/thread.hpp
+++ b/src/hotspot/share/runtime/thread.hpp
@@ -1571,7 +1571,6 @@ class JavaThread: public Thread {
   static ByteSize frame_anchor_offset() {
     return byte_offset_of(JavaThread, _anchor);
   }
-
   static ByteSize callee_target_offset()         { return byte_offset_of(JavaThread, _callee_target); }
   static ByteSize vm_result_offset()             { return byte_offset_of(JavaThread, _vm_result); }
   static ByteSize vm_result_2_offset()           { return byte_offset_of(JavaThread, _vm_result_2); }

From 28e7a83001f67187118f9d169bfa858542810c54 Mon Sep 17 00:00:00 2001
From: Jorn Vernee 
Date: Tue, 10 Nov 2020 11:19:07 +0000
Subject: [PATCH 51/70] Remove os::is_MP() check

---
 src/hotspot/cpu/x86/sharedRuntime_x86_64.cpp | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/src/hotspot/cpu/x86/sharedRuntime_x86_64.cpp b/src/hotspot/cpu/x86/sharedRuntime_x86_64.cpp
index 024c7261913df..0b81aaa0b0bb5 100644
--- a/src/hotspot/cpu/x86/sharedRuntime_x86_64.cpp
+++ b/src/hotspot/cpu/x86/sharedRuntime_x86_64.cpp
@@ -3518,12 +3518,10 @@ void NativeInvokerGenerator::generate() {
 
   __ movl(Address(r15_thread, JavaThread::thread_state_offset()), _thread_in_native_trans);
 
-  if (os::is_MP()) {
-    // Force this write out before the read below
-    __ membar(Assembler::Membar_mask_bits(
-            Assembler::LoadLoad | Assembler::LoadStore |
-            Assembler::StoreLoad | Assembler::StoreStore));
-  }
+  // Force this write out before the read below
+  __ membar(Assembler::Membar_mask_bits(
+          Assembler::LoadLoad | Assembler::LoadStore |
+          Assembler::StoreLoad | Assembler::StoreStore));
 
   Label L_after_safepoint_poll;
   Label L_safepoint_poll_slow_path;

From 969fb3d9cca039e3b4ad0f641a66b66c22e68c70 Mon Sep 17 00:00:00 2001
From: Jorn Vernee 
Date: Tue, 10 Nov 2020 11:20:18 +0000
Subject: [PATCH 52/70] remove excessive asserts in
 ProgrammableInvoker::invoke_native

---
 src/hotspot/share/prims/universalNativeInvoker.cpp | 10 ++--------
 1 file changed, 2 insertions(+), 8 deletions(-)

diff --git a/src/hotspot/share/prims/universalNativeInvoker.cpp b/src/hotspot/share/prims/universalNativeInvoker.cpp
index 326833882a540..b4a97a1693a99 100644
--- a/src/hotspot/share/prims/universalNativeInvoker.cpp
+++ b/src/hotspot/share/prims/universalNativeInvoker.cpp
@@ -31,14 +31,8 @@ ProgrammableInvoker::Generator::Generator(CodeBuffer* code, const ABIDescriptor*
     _layout(layout) {}
 
 void ProgrammableInvoker::invoke_native(Stub stub, address buff, JavaThread* thread) {
-  {
-    assert(thread->thread_state() == _thread_in_vm, "thread state is: %d", thread->thread_state());
-    ThreadToNativeFromVM ttnfvm(thread);
-    assert(thread->thread_state() == _thread_in_native, "thread state is: %d", thread->thread_state());
-    stub(buff);
-    assert(thread->thread_state() == _thread_in_native, "thread state is: %d", thread->thread_state());
-  }
-  assert(thread->thread_state() == _thread_in_vm, "thread state is: %d", thread->thread_state());
+  ThreadToNativeFromVM ttnfvm(thread);
+  stub(buff);
 }
 
 JNI_ENTRY(void, PI_invokeNative(JNIEnv* env, jclass _unused, jlong adapter_stub, jlong buff))

From 033a7c8ffbd5e8b57e217b422b681a08cbb66af2 Mon Sep 17 00:00:00 2001
From: Jorn Vernee 
Date: Tue, 10 Nov 2020 11:20:57 +0000
Subject: [PATCH 53/70] Extra space after if

---
 src/java.base/windows/native/libjava/jni_util_md.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/java.base/windows/native/libjava/jni_util_md.c b/src/java.base/windows/native/libjava/jni_util_md.c
index 92619d9fdc67f..47c5e5ebc011d 100644
--- a/src/java.base/windows/native/libjava/jni_util_md.c
+++ b/src/java.base/windows/native/libjava/jni_util_md.c
@@ -48,7 +48,7 @@ void* findEntryInProcess(const char* name) {
     DWORD cbNeeded; // array size in bytes
 
     // first come, first served
-    if(EnumProcessModules(hProcess, hMods, sizeof(hMods), &cbNeeded)) {
+    if (EnumProcessModules(hProcess, hMods, sizeof(hMods), &cbNeeded)) {
         for (int i = 0; i < (cbNeeded / sizeof(HMODULE)); i++) {
             HMODULE mod = hMods[i];
             FARPROC proc = GetProcAddress(mod, name);

From 39a040ab08a885bc840b988cf1a0760755a965a2 Mon Sep 17 00:00:00 2001
From: Jorn Vernee 
Date: Tue, 10 Nov 2020 11:22:27 +0000
Subject: [PATCH 54/70] Relax ret_addr_offset() assert

---
 src/hotspot/share/opto/output.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/hotspot/share/opto/output.cpp b/src/hotspot/share/opto/output.cpp
index f67f645020f65..3d11173a982ca 100644
--- a/src/hotspot/share/opto/output.cpp
+++ b/src/hotspot/share/opto/output.cpp
@@ -1694,7 +1694,7 @@ void PhaseOutput::fill_buffer(CodeBuffer* cb, uint* blk_starts) {
       n->emit(*cb, C->regalloc());
       current_offset = cb->insts_size();
 
-      assert(!is_mcall || (call_returns[block->_pre_order] == (uint) current_offset), "ret_addr_offset() did not match size of emitted code");
+      assert(!is_mcall || (call_returns[block->_pre_order] <= (uint) current_offset), "ret_addr_offset() not within emitted code");
 
       // Above we only verified that there is enough space in the instruction section.
       // However, the instruction may emit stubs that cause code buffer expansion.

From 1d3a5ca6e5710faeaaf58e2b236a42435e867ad2 Mon Sep 17 00:00:00 2001
From: Jorn Vernee 
Date: Tue, 10 Nov 2020 12:20:33 +0000
Subject: [PATCH 55/70] Sort includes alphabetically

---
 src/hotspot/cpu/aarch64/universalNativeInvoker_aarch64.cpp | 4 ++--
 src/hotspot/cpu/x86/universalNativeInvoker_x86.cpp         | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/hotspot/cpu/aarch64/universalNativeInvoker_aarch64.cpp b/src/hotspot/cpu/aarch64/universalNativeInvoker_aarch64.cpp
index 2d5c34352e3d5..d048baf2a934f 100644
--- a/src/hotspot/cpu/aarch64/universalNativeInvoker_aarch64.cpp
+++ b/src/hotspot/cpu/aarch64/universalNativeInvoker_aarch64.cpp
@@ -24,9 +24,9 @@
 
 #include "precompiled.hpp"
 #include "asm/macroAssembler.hpp"
-#include "prims/universalNativeInvoker.hpp"
-#include "memory/resourceArea.hpp"
 #include "code/codeBlob.hpp"
+#include "memory/resourceArea.hpp"
+#include "prims/universalNativeInvoker.hpp"
 
 void ProgrammableInvoker::Generator::generate() {
   __ enter();
diff --git a/src/hotspot/cpu/x86/universalNativeInvoker_x86.cpp b/src/hotspot/cpu/x86/universalNativeInvoker_x86.cpp
index 5689ef6385dad..3a84cf7d8809c 100644
--- a/src/hotspot/cpu/x86/universalNativeInvoker_x86.cpp
+++ b/src/hotspot/cpu/x86/universalNativeInvoker_x86.cpp
@@ -23,9 +23,9 @@
 
 #include "precompiled.hpp"
 #include "asm/macroAssembler.hpp"
-#include "prims/universalNativeInvoker.hpp"
-#include "memory/resourceArea.hpp"
 #include "code/codeBlob.hpp"
+#include "memory/resourceArea.hpp"
+#include "prims/universalNativeInvoker.hpp"
 
 void ProgrammableInvoker::Generator::generate() {
   __ enter();

From bb75026dbbeb6d47901a87ce992c420b736b41a1 Mon Sep 17 00:00:00 2001
From: Jorn Vernee 
Date: Tue, 10 Nov 2020 12:34:38 +0000
Subject: [PATCH 56/70] Check result of AttachCurrentThread

---
 src/hotspot/share/prims/universalUpcallHandler.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/hotspot/share/prims/universalUpcallHandler.cpp b/src/hotspot/share/prims/universalUpcallHandler.cpp
index a863df1b77152..bc4e3874c365d 100644
--- a/src/hotspot/share/prims/universalUpcallHandler.cpp
+++ b/src/hotspot/share/prims/universalUpcallHandler.cpp
@@ -51,7 +51,8 @@ void ProgrammableUpcallHandler::attach_thread_and_do_upcall(jobject rec, address
   JNIEnv* p_env = nullptr;
   if (thread == nullptr) {
     JavaVM_ *vm = (JavaVM *)(&main_vm);
-    vm->functions->AttachCurrentThread(vm, (void**) &p_env, nullptr);
+    jint result = vm->functions->AttachCurrentThread(vm, (void**) &p_env, nullptr);
+    guarantee(result == JNI_OK, "Could not attach thread for upcall. JNI error code: %d", result);
     should_detach = true;
     thread = Thread::current();
   } else {

From 18f0e2d168f65f3fdce6b52fd777c8d4215f029d Mon Sep 17 00:00:00 2001
From: Jorn Vernee 
Date: Tue, 10 Nov 2020 14:36:02 +0100
Subject: [PATCH 57/70] Set copyright year for added files to 2020

---
 src/hotspot/cpu/aarch64/foreign_globals_aarch64.cpp             | 2 +-
 src/hotspot/cpu/aarch64/foreign_globals_aarch64.hpp             | 2 +-
 src/hotspot/cpu/aarch64/universalNativeInvoker_aarch64.cpp      | 2 +-
 src/hotspot/cpu/aarch64/universalUpcallHandler_aarch64.cpp      | 2 +-
 src/hotspot/cpu/x86/foreign_globals_x86.cpp                     | 2 +-
 src/hotspot/cpu/x86/foreign_globals_x86.hpp                     | 2 +-
 src/hotspot/cpu/x86/universalNativeInvoker_x86.cpp              | 2 +-
 src/hotspot/cpu/x86/universalUpcallHandler_x86.cpp              | 2 +-
 src/hotspot/share/prims/universalNativeInvoker.cpp              | 2 +-
 src/hotspot/share/prims/universalNativeInvoker.hpp              | 2 +-
 src/hotspot/share/prims/universalUpcallHandler.cpp              | 2 +-
 src/hotspot/share/prims/universalUpcallHandler.hpp              | 2 +-
 src/hotspot/share/prims/upcallStubs.cpp                         | 2 +-
 .../classes/jdk/internal/access/foreign/NativeLibraryProxy.java | 2 +-
 .../share/classes/jdk/incubator/foreign/FunctionDescriptor.java | 2 +-
 .../share/classes/jdk/incubator/foreign/LibraryLookup.java      | 2 +-
 .../share/classes/jdk/internal/foreign/LibrariesHelper.java     | 2 +-
 .../share/classes/jdk/internal/foreign/abi/ABIDescriptor.java   | 2 +-
 .../share/classes/jdk/internal/foreign/abi/Architecture.java    | 2 +-
 .../share/classes/jdk/internal/foreign/abi/Binding.java         | 2 +-
 .../classes/jdk/internal/foreign/abi/BindingInterpreter.java    | 2 +-
 .../share/classes/jdk/internal/foreign/abi/BufferLayout.java    | 2 +-
 .../share/classes/jdk/internal/foreign/abi/CallingSequence.java | 2 +-
 .../jdk/internal/foreign/abi/CallingSequenceBuilder.java        | 2 +-
 .../classes/jdk/internal/foreign/abi/ProgrammableInvoker.java   | 2 +-
 .../jdk/internal/foreign/abi/ProgrammableUpcallHandler.java     | 2 +-
 .../share/classes/jdk/internal/foreign/abi/SharedUtils.java     | 2 +-
 .../share/classes/jdk/internal/foreign/abi/UpcallHandler.java   | 2 +-
 .../share/classes/jdk/internal/foreign/abi/UpcallStubs.java     | 2 +-
 .../share/classes/jdk/internal/foreign/abi/VMStorage.java       | 2 +-
 .../jdk/internal/foreign/abi/aarch64/AArch64Architecture.java   | 2 +-
 .../classes/jdk/internal/foreign/abi/aarch64/AArch64Linker.java | 2 +-
 .../classes/jdk/internal/foreign/abi/aarch64/CallArranger.java  | 2 +-
 .../jdk/internal/foreign/abi/x64/X86_64Architecture.java        | 2 +-
 .../classes/jdk/internal/foreign/abi/x64/sysv/CallArranger.java | 2 +-
 .../jdk/internal/foreign/abi/x64/sysv/SysVx64Linker.java        | 2 +-
 .../jdk/internal/foreign/abi/x64/windows/CallArranger.java      | 2 +-
 .../jdk/internal/foreign/abi/x64/windows/Windowsx64Linker.java  | 2 +-
 test/jdk/java/foreign/CallGeneratorHelper.java                  | 2 +-
 test/jdk/java/foreign/NativeTestHelper.java                     | 2 +-
 test/jdk/java/foreign/StdLibTest.java                           | 2 +-
 test/jdk/java/foreign/TestDowncall.java                         | 2 +-
 test/jdk/java/foreign/TestIllegalLink.java                      | 2 +-
 test/jdk/java/foreign/TestUpcall.java                           | 2 +-
 test/jdk/java/foreign/TestVarArgs.java                          | 2 +-
 test/jdk/java/foreign/libLookupTest.c                           | 2 +-
 test/jdk/java/foreign/libTestDowncall.c                         | 2 +-
 test/jdk/java/foreign/libTestDowncall.h                         | 2 +-
 test/jdk/java/foreign/libTestUpcall.c                           | 2 +-
 test/jdk/java/foreign/libTestUpcall.h                           | 2 +-
 test/jdk/java/foreign/libVarArgs.c                              | 2 +-
 51 files changed, 51 insertions(+), 51 deletions(-)

diff --git a/src/hotspot/cpu/aarch64/foreign_globals_aarch64.cpp b/src/hotspot/cpu/aarch64/foreign_globals_aarch64.cpp
index e0f644e5ce8ce..d2c40478261fc 100644
--- a/src/hotspot/cpu/aarch64/foreign_globals_aarch64.cpp
+++ b/src/hotspot/cpu/aarch64/foreign_globals_aarch64.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
  * Copyright (c) 2019, Arm Limited. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
diff --git a/src/hotspot/cpu/aarch64/foreign_globals_aarch64.hpp b/src/hotspot/cpu/aarch64/foreign_globals_aarch64.hpp
index 4504087e174ea..f7441641a894d 100644
--- a/src/hotspot/cpu/aarch64/foreign_globals_aarch64.hpp
+++ b/src/hotspot/cpu/aarch64/foreign_globals_aarch64.hpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
  * Copyright (c) 2019, Arm Limited. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
diff --git a/src/hotspot/cpu/aarch64/universalNativeInvoker_aarch64.cpp b/src/hotspot/cpu/aarch64/universalNativeInvoker_aarch64.cpp
index d048baf2a934f..288f5dadc2578 100644
--- a/src/hotspot/cpu/aarch64/universalNativeInvoker_aarch64.cpp
+++ b/src/hotspot/cpu/aarch64/universalNativeInvoker_aarch64.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
  * Copyright (c) 2019, Arm Limited. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
diff --git a/src/hotspot/cpu/aarch64/universalUpcallHandler_aarch64.cpp b/src/hotspot/cpu/aarch64/universalUpcallHandler_aarch64.cpp
index 3c4e3fd11af15..3cb524ca9a592 100644
--- a/src/hotspot/cpu/aarch64/universalUpcallHandler_aarch64.cpp
+++ b/src/hotspot/cpu/aarch64/universalUpcallHandler_aarch64.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
  * Copyright (c) 2019, Arm Limited. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
diff --git a/src/hotspot/cpu/x86/foreign_globals_x86.cpp b/src/hotspot/cpu/x86/foreign_globals_x86.cpp
index 228a7b64b71da..dcdb05d8421bf 100644
--- a/src/hotspot/cpu/x86/foreign_globals_x86.cpp
+++ b/src/hotspot/cpu/x86/foreign_globals_x86.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
diff --git a/src/hotspot/cpu/x86/foreign_globals_x86.hpp b/src/hotspot/cpu/x86/foreign_globals_x86.hpp
index daf5d71cfbf8b..ffc53f25a6add 100644
--- a/src/hotspot/cpu/x86/foreign_globals_x86.hpp
+++ b/src/hotspot/cpu/x86/foreign_globals_x86.hpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
diff --git a/src/hotspot/cpu/x86/universalNativeInvoker_x86.cpp b/src/hotspot/cpu/x86/universalNativeInvoker_x86.cpp
index 3a84cf7d8809c..d3a45dc3d2811 100644
--- a/src/hotspot/cpu/x86/universalNativeInvoker_x86.cpp
+++ b/src/hotspot/cpu/x86/universalNativeInvoker_x86.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
diff --git a/src/hotspot/cpu/x86/universalUpcallHandler_x86.cpp b/src/hotspot/cpu/x86/universalUpcallHandler_x86.cpp
index 1e7ddd036d045..b26871dc57f2d 100644
--- a/src/hotspot/cpu/x86/universalUpcallHandler_x86.cpp
+++ b/src/hotspot/cpu/x86/universalUpcallHandler_x86.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
diff --git a/src/hotspot/share/prims/universalNativeInvoker.cpp b/src/hotspot/share/prims/universalNativeInvoker.cpp
index b4a97a1693a99..bb1bbcd4ecaae 100644
--- a/src/hotspot/share/prims/universalNativeInvoker.cpp
+++ b/src/hotspot/share/prims/universalNativeInvoker.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
diff --git a/src/hotspot/share/prims/universalNativeInvoker.hpp b/src/hotspot/share/prims/universalNativeInvoker.hpp
index 1541b45822742..49d0fd7447552 100644
--- a/src/hotspot/share/prims/universalNativeInvoker.hpp
+++ b/src/hotspot/share/prims/universalNativeInvoker.hpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
diff --git a/src/hotspot/share/prims/universalUpcallHandler.cpp b/src/hotspot/share/prims/universalUpcallHandler.cpp
index bc4e3874c365d..6183748eddb0a 100644
--- a/src/hotspot/share/prims/universalUpcallHandler.cpp
+++ b/src/hotspot/share/prims/universalUpcallHandler.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
diff --git a/src/hotspot/share/prims/universalUpcallHandler.hpp b/src/hotspot/share/prims/universalUpcallHandler.hpp
index 3ba8aa9b80edd..24868e71ec193 100644
--- a/src/hotspot/share/prims/universalUpcallHandler.hpp
+++ b/src/hotspot/share/prims/universalUpcallHandler.hpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
diff --git a/src/hotspot/share/prims/upcallStubs.cpp b/src/hotspot/share/prims/upcallStubs.cpp
index f1cbec34f2c4e..e6f3af44494eb 100644
--- a/src/hotspot/share/prims/upcallStubs.cpp
+++ b/src/hotspot/share/prims/upcallStubs.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
diff --git a/src/java.base/share/classes/jdk/internal/access/foreign/NativeLibraryProxy.java b/src/java.base/share/classes/jdk/internal/access/foreign/NativeLibraryProxy.java
index 18370d27eaa61..72249660f5704 100644
--- a/src/java.base/share/classes/jdk/internal/access/foreign/NativeLibraryProxy.java
+++ b/src/java.base/share/classes/jdk/internal/access/foreign/NativeLibraryProxy.java
@@ -1,5 +1,5 @@
 /*
- *  Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
+ *  Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
  *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  *  This code is free software; you can redistribute it and/or modify it
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/FunctionDescriptor.java b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/FunctionDescriptor.java
index d7a40da798ca2..e384ad4a88b39 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/FunctionDescriptor.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/FunctionDescriptor.java
@@ -1,5 +1,5 @@
 /*
- *  Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
+ *  Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
  *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  *  This code is free software; you can redistribute it and/or modify it
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/LibraryLookup.java b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/LibraryLookup.java
index 3598710f936a9..28a1a469db669 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/LibraryLookup.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/incubator/foreign/LibraryLookup.java
@@ -1,5 +1,5 @@
 /*
- *  Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
+ *  Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
  *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  *  This code is free software; you can redistribute it and/or modify it
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/LibrariesHelper.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/LibrariesHelper.java
index 006374f1617d2..054996094e400 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/LibrariesHelper.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/LibrariesHelper.java
@@ -1,5 +1,5 @@
 /*
- *  Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
+ *  Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
  *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  *  This code is free software; you can redistribute it and/or modify it
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/ABIDescriptor.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/ABIDescriptor.java
index 27ad0f21d222f..a6d2c4004d3ba 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/ABIDescriptor.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/ABIDescriptor.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/Architecture.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/Architecture.java
index 09e97b7af2f57..b37fc0a806796 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/Architecture.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/Architecture.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/Binding.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/Binding.java
index 23a7e01b38cca..e0771ddb7aeb3 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/Binding.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/Binding.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/BindingInterpreter.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/BindingInterpreter.java
index a6ecce2b8e7b0..019ccbbe0401c 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/BindingInterpreter.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/BindingInterpreter.java
@@ -1,5 +1,5 @@
 /*
- *  Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
+ *  Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
  *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  *  This code is free software; you can redistribute it and/or modify it
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/BufferLayout.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/BufferLayout.java
index f7541dd9fc3e2..ac5ca419ca75a 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/BufferLayout.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/BufferLayout.java
@@ -1,5 +1,5 @@
 /*
- *  Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
+ *  Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
  *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  *  This code is free software; you can redistribute it and/or modify it
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/CallingSequence.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/CallingSequence.java
index e9c823fa2bfdc..1412304a4cb03 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/CallingSequence.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/CallingSequence.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/CallingSequenceBuilder.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/CallingSequenceBuilder.java
index dac727d5707c3..bdc8474d2b949 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/CallingSequenceBuilder.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/CallingSequenceBuilder.java
@@ -1,5 +1,5 @@
 /*
- *  Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
+ *  Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
  *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  *  This code is free software; you can redistribute it and/or modify it
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/ProgrammableInvoker.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/ProgrammableInvoker.java
index c2db9efc41f4d..d2aa871040f27 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/ProgrammableInvoker.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/ProgrammableInvoker.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/ProgrammableUpcallHandler.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/ProgrammableUpcallHandler.java
index 319f6cb62ed44..810e69a65b011 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/ProgrammableUpcallHandler.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/ProgrammableUpcallHandler.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/SharedUtils.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/SharedUtils.java
index f9b1cad4ab57d..32530d57341e9 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/SharedUtils.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/SharedUtils.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/UpcallHandler.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/UpcallHandler.java
index 0adf0d0f6d007..a2e9c3ea2b9c4 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/UpcallHandler.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/UpcallHandler.java
@@ -1,5 +1,5 @@
 /*
- *  Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
+ *  Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
  *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  *  This code is free software; you can redistribute it and/or modify it
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/UpcallStubs.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/UpcallStubs.java
index 731f86a368ba6..d64300e533d0a 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/UpcallStubs.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/UpcallStubs.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/VMStorage.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/VMStorage.java
index 60044617fae89..cd85a183dd508 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/VMStorage.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/VMStorage.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/aarch64/AArch64Architecture.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/aarch64/AArch64Architecture.java
index fdba12c0439a9..64811bf2c859c 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/aarch64/AArch64Architecture.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/aarch64/AArch64Architecture.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
  * Copyright (c) 2019, Arm Limited. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/aarch64/AArch64Linker.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/aarch64/AArch64Linker.java
index fcfbf300b68f9..963cf561e2c50 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/aarch64/AArch64Linker.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/aarch64/AArch64Linker.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
  * Copyright (c) 2019, 2020, Arm Limited. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/aarch64/CallArranger.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/aarch64/CallArranger.java
index e33e4c431edbb..6824b5c751f77 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/aarch64/CallArranger.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/aarch64/CallArranger.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
  * Copyright (c) 2019, 2020, Arm Limited. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/X86_64Architecture.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/X86_64Architecture.java
index 366703567ca0c..98c777add1b88 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/X86_64Architecture.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/X86_64Architecture.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/sysv/CallArranger.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/sysv/CallArranger.java
index 638c12660c552..d748f3e414554 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/sysv/CallArranger.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/sysv/CallArranger.java
@@ -1,5 +1,5 @@
 /*
- *  Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
+ *  Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
  *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  *  This code is free software; you can redistribute it and/or modify it
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/sysv/SysVx64Linker.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/sysv/SysVx64Linker.java
index 58f20b7d20053..3a80695f05137 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/sysv/SysVx64Linker.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/sysv/SysVx64Linker.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/windows/CallArranger.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/windows/CallArranger.java
index 200543fd8bad5..8e8be4bc5728e 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/windows/CallArranger.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/windows/CallArranger.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/windows/Windowsx64Linker.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/windows/Windowsx64Linker.java
index a695ddc4138da..bbd01e77fca19 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/windows/Windowsx64Linker.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/windows/Windowsx64Linker.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
diff --git a/test/jdk/java/foreign/CallGeneratorHelper.java b/test/jdk/java/foreign/CallGeneratorHelper.java
index bc9cc7a181fca..f9eced368d7ec 100644
--- a/test/jdk/java/foreign/CallGeneratorHelper.java
+++ b/test/jdk/java/foreign/CallGeneratorHelper.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
  *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  *  This code is free software; you can redistribute it and/or modify it
diff --git a/test/jdk/java/foreign/NativeTestHelper.java b/test/jdk/java/foreign/NativeTestHelper.java
index 71f580329283f..9eba210d3304b 100644
--- a/test/jdk/java/foreign/NativeTestHelper.java
+++ b/test/jdk/java/foreign/NativeTestHelper.java
@@ -1,5 +1,5 @@
 /*
- *  Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
+ *  Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
  *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  *  This code is free software; you can redistribute it and/or modify it
diff --git a/test/jdk/java/foreign/StdLibTest.java b/test/jdk/java/foreign/StdLibTest.java
index 39d6c37eeb8f5..12997b69ad69a 100644
--- a/test/jdk/java/foreign/StdLibTest.java
+++ b/test/jdk/java/foreign/StdLibTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
diff --git a/test/jdk/java/foreign/TestDowncall.java b/test/jdk/java/foreign/TestDowncall.java
index 956d46a0ea693..20775bcc78039 100644
--- a/test/jdk/java/foreign/TestDowncall.java
+++ b/test/jdk/java/foreign/TestDowncall.java
@@ -1,5 +1,5 @@
 /*
- *  Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
+ *  Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
  *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  *  This code is free software; you can redistribute it and/or modify it
diff --git a/test/jdk/java/foreign/TestIllegalLink.java b/test/jdk/java/foreign/TestIllegalLink.java
index 3a054e6b5d9d3..2beba8a925b59 100644
--- a/test/jdk/java/foreign/TestIllegalLink.java
+++ b/test/jdk/java/foreign/TestIllegalLink.java
@@ -1,5 +1,5 @@
 /*
- *  Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
+ *  Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
  *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  *  This code is free software; you can redistribute it and/or modify it
diff --git a/test/jdk/java/foreign/TestUpcall.java b/test/jdk/java/foreign/TestUpcall.java
index 04fa3f96ec8b7..044dc1292b1df 100644
--- a/test/jdk/java/foreign/TestUpcall.java
+++ b/test/jdk/java/foreign/TestUpcall.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
  *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  *  This code is free software; you can redistribute it and/or modify it
diff --git a/test/jdk/java/foreign/TestVarArgs.java b/test/jdk/java/foreign/TestVarArgs.java
index 87032561d3cb9..701069e662c03 100644
--- a/test/jdk/java/foreign/TestVarArgs.java
+++ b/test/jdk/java/foreign/TestVarArgs.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
  *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  *  This code is free software; you can redistribute it and/or modify it
diff --git a/test/jdk/java/foreign/libLookupTest.c b/test/jdk/java/foreign/libLookupTest.c
index 31451d74ce4ca..5eab5048caf14 100644
--- a/test/jdk/java/foreign/libLookupTest.c
+++ b/test/jdk/java/foreign/libLookupTest.c
@@ -1,5 +1,5 @@
 /*
- *  Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
+ *  Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
  *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  *  This code is free software; you can redistribute it and/or modify it
diff --git a/test/jdk/java/foreign/libTestDowncall.c b/test/jdk/java/foreign/libTestDowncall.c
index 6c5a6c81f6e04..ded08649e493e 100644
--- a/test/jdk/java/foreign/libTestDowncall.c
+++ b/test/jdk/java/foreign/libTestDowncall.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
diff --git a/test/jdk/java/foreign/libTestDowncall.h b/test/jdk/java/foreign/libTestDowncall.h
index ece38c7a3a2a6..7028050e24182 100644
--- a/test/jdk/java/foreign/libTestDowncall.h
+++ b/test/jdk/java/foreign/libTestDowncall.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
diff --git a/test/jdk/java/foreign/libTestUpcall.c b/test/jdk/java/foreign/libTestUpcall.c
index 28145fe6528df..82e1d24022ff2 100644
--- a/test/jdk/java/foreign/libTestUpcall.c
+++ b/test/jdk/java/foreign/libTestUpcall.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
diff --git a/test/jdk/java/foreign/libTestUpcall.h b/test/jdk/java/foreign/libTestUpcall.h
index 1dd1f585a077b..fa7be96bfd285 100644
--- a/test/jdk/java/foreign/libTestUpcall.h
+++ b/test/jdk/java/foreign/libTestUpcall.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
diff --git a/test/jdk/java/foreign/libVarArgs.c b/test/jdk/java/foreign/libVarArgs.c
index 0a6c24fead39b..e92f88e1575b6 100644
--- a/test/jdk/java/foreign/libVarArgs.c
+++ b/test/jdk/java/foreign/libVarArgs.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
  *  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  *  This code is free software; you can redistribute it and/or modify it

From 64c3a16113df0024acb18c16a54efe445978460c Mon Sep 17 00:00:00 2001
From: Jorn Vernee 
Date: Tue, 10 Nov 2020 14:08:06 +0000
Subject: [PATCH 58/70] Revert System.java changes

---
 src/java.base/share/classes/java/lang/System.java | 15 ++++++++++++---
 1 file changed, 12 insertions(+), 3 deletions(-)

diff --git a/src/java.base/share/classes/java/lang/System.java b/src/java.base/share/classes/java/lang/System.java
index 47ebb20b50a00..7581b07154f67 100644
--- a/src/java.base/share/classes/java/lang/System.java
+++ b/src/java.base/share/classes/java/lang/System.java
@@ -2051,6 +2051,7 @@ private static void initPhase1() {
      * @return JNI_OK for success, JNI_ERR for failure
      */
     private static int initPhase2(boolean printToStderr, boolean printStackTrace) {
+
         try {
             bootLayer = ModuleBootstrap.boot();
         } catch (Exception | Error e) {
@@ -2067,15 +2068,23 @@ private static int initPhase2(boolean printToStderr, boolean printStackTrace) {
 
     /*
      * Invoked by VM.  Phase 3 is the final system initialization:
-     * 1. set security manager
-     * 2. set system class loader
-     * 3. set TCCL
+     * 1. eagerly initialize bootstrap method factories that might interact
+     *    negatively with custom security managers and custom class loaders
+     * 2. set security manager
+     * 3. set system class loader
+     * 4. set TCCL
      *
      * This method must be called after the module system initialization.
      * The security manager and system class loader may be a custom class from
      * the application classpath or modulepath.
      */
     private static void initPhase3() {
+
+        // Initialize the StringConcatFactory eagerly to avoid potential
+        // bootstrap circularity issues that could be caused by a custom
+        // SecurityManager
+        Unsafe.getUnsafe().ensureClassInitialized(StringConcatFactory.class);
+
         String smProp = System.getProperty("java.security.manager");
         if (smProp != null) {
             switch (smProp) {

From 2ed0f1702b7c0b60061c3c87505f477fc6ea4604 Mon Sep 17 00:00:00 2001
From: Jorn Vernee 
Date: Wed, 11 Nov 2020 11:39:22 +0000
Subject: [PATCH 59/70] Add ResourceMark to ProgrammableUpcallHandler
 constructor

---
 src/hotspot/share/prims/universalUpcallHandler.cpp | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/hotspot/share/prims/universalUpcallHandler.cpp b/src/hotspot/share/prims/universalUpcallHandler.cpp
index 6183748eddb0a..33ba631e61603 100644
--- a/src/hotspot/share/prims/universalUpcallHandler.cpp
+++ b/src/hotspot/share/prims/universalUpcallHandler.cpp
@@ -22,11 +22,12 @@
  */
 
 #include "precompiled.hpp"
+#include "classfile/symbolTable.hpp"
+#include "memory/resourceArea.hpp"
 #include "prims/universalUpcallHandler.hpp"
-#include "runtime/jniHandles.inline.hpp"
 #include "runtime/interfaceSupport.inline.hpp"
 #include "runtime/javaCalls.hpp"
-#include "classfile/symbolTable.hpp"
+#include "runtime/jniHandles.inline.hpp"
 
 #define FOREIGN_ABI "jdk/internal/foreign/abi/"
 
@@ -73,8 +74,9 @@ const ProgrammableUpcallHandler& ProgrammableUpcallHandler::instance() {
 }
 
 ProgrammableUpcallHandler::ProgrammableUpcallHandler() {
-  Symbol* sym = SymbolTable::new_symbol(FOREIGN_ABI "ProgrammableUpcallHandler");
   Thread* THREAD = Thread::current();
+  ResourceMark rm(THREAD);
+  Symbol* sym = SymbolTable::new_symbol(FOREIGN_ABI "ProgrammableUpcallHandler");
   Klass* k = SystemDictionary::resolve_or_null(sym, Handle(), Handle(), CATCH);
   k->initialize(CATCH);
 

From e3d62ee79c6378593b14c74d56ed15f638c96c9f Mon Sep 17 00:00:00 2001
From: Maurizio Cimadamore 
Date: Thu, 12 Nov 2020 18:02:04 +0000
Subject: [PATCH 60/70] Fix whitespaces

---
 .../org/graalvm/compiler/hotspot/test/CheckGraalIntrinsics.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.hotspot.test/src/org/graalvm/compiler/hotspot/test/CheckGraalIntrinsics.java b/src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.hotspot.test/src/org/graalvm/compiler/hotspot/test/CheckGraalIntrinsics.java
index 41707ae21e1b4..ffd9540467991 100644
--- a/src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.hotspot.test/src/org/graalvm/compiler/hotspot/test/CheckGraalIntrinsics.java
+++ b/src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.hotspot.test/src/org/graalvm/compiler/hotspot/test/CheckGraalIntrinsics.java
@@ -445,7 +445,7 @@ public CheckGraalIntrinsics() {
                 add(ignore,
                             "java/util/Base64$Decoder.decodeBlock([BII[BIZ)I");
             }
-	    // Panama
+            // Panama
             add(toBeInvestigated,
                     // Native method handle intrinsics
                     "java/lang/invoke/MethodHandle.linkToNative*");

From 0ab509e0d6b6915e10dd0dbeb877dc8d87e6d3d4 Mon Sep 17 00:00:00 2001
From: Jorn Vernee 
Date: Wed, 11 Nov 2020 17:33:49 +0000
Subject: [PATCH 61/70] Address Vlad's review comments

---
 .../cpu/aarch64/foreign_globals_aarch64.hpp   | 17 +-----
 .../universalNativeInvoker_aarch64.cpp        |  6 +-
 .../universalUpcallHandler_aarch64.cpp        |  6 +-
 src/hotspot/cpu/aarch64/vmreg_aarch64.cpp     |  1 -
 src/hotspot/cpu/x86/foreign_globals_x86.hpp   | 17 +-----
 src/hotspot/cpu/x86/sharedRuntime_x86_64.cpp  | 10 ++--
 .../cpu/x86/universalNativeInvoker_x86.cpp    | 22 ++-----
 .../cpu/x86/universalUpcallHandler_x86.cpp    | 24 +++-----
 src/hotspot/share/ci/ciEnv.cpp                |  5 +-
 src/hotspot/share/ci/ciEnv.hpp                |  3 +-
 src/hotspot/share/code/codeCache.cpp          |  2 +-
 src/hotspot/share/code/nmethod.cpp            | 58 ++++++++++++-------
 src/hotspot/share/code/nmethod.hpp            | 17 +++---
 src/hotspot/share/code/vmreg.cpp              |  6 ++
 src/hotspot/share/jvmci/jvmciRuntime.cpp      |  2 +-
 src/hotspot/share/opto/callnode.cpp           | 28 ++++-----
 src/hotspot/share/opto/compile.cpp            |  8 +--
 src/hotspot/share/opto/compile.hpp            |  6 +-
 src/hotspot/share/opto/graphKit.cpp           | 42 +++++---------
 src/hotspot/share/opto/lcm.cpp                |  4 +-
 src/hotspot/share/opto/output.cpp             | 17 ++----
 src/hotspot/share/opto/type.cpp               |  8 ---
 src/hotspot/share/opto/type.hpp               |  1 -
 src/hotspot/share/runtime/sharedRuntime.hpp   |  8 +--
 src/hotspot/share/utilities/growableArray.hpp | 25 ++++++--
 src/hotspot/share/utilities/print.hpp         | 48 +++++++++++++++
 .../foreign/abi/x64/X86_64Architecture.java   |  2 +-
 27 files changed, 203 insertions(+), 190 deletions(-)
 create mode 100644 src/hotspot/share/utilities/print.hpp

diff --git a/src/hotspot/cpu/aarch64/foreign_globals_aarch64.hpp b/src/hotspot/cpu/aarch64/foreign_globals_aarch64.hpp
index f7441641a894d..f3748e20b1476 100644
--- a/src/hotspot/cpu/aarch64/foreign_globals_aarch64.hpp
+++ b/src/hotspot/cpu/aarch64/foreign_globals_aarch64.hpp
@@ -28,22 +28,7 @@
 #include "asm/macroAssembler.hpp"
 #include "utilities/growableArray.hpp"
 
-#define __ _masm->
-
-struct VectorRegister {
-  static const size_t VECTOR_MAX_WIDTH_BITS = 128;
-  static const size_t VECTOR_MAX_WIDTH_BYTES = VECTOR_MAX_WIDTH_BITS / 8;
-  static const size_t VECTOR_MAX_WIDTH_U64S = VECTOR_MAX_WIDTH_BITS / 64;
-  static const size_t VECTOR_MAX_WIDTH_FLOATS = VECTOR_MAX_WIDTH_BITS / 32;
-  static const size_t VECTOR_MAX_WIDTH_DOUBLES = VECTOR_MAX_WIDTH_BITS / 64;
-
-  union {
-    uint8_t bits[VECTOR_MAX_WIDTH_BYTES];
-    uint64_t u64[VECTOR_MAX_WIDTH_U64S];
-    float f[VECTOR_MAX_WIDTH_FLOATS];
-    double d[VECTOR_MAX_WIDTH_DOUBLES];
-  };
-};
+constexpr size_t float_reg_size = 16; // bytes
 
 struct ABIDescriptor {
   GrowableArray _integer_argument_registers;
diff --git a/src/hotspot/cpu/aarch64/universalNativeInvoker_aarch64.cpp b/src/hotspot/cpu/aarch64/universalNativeInvoker_aarch64.cpp
index 288f5dadc2578..8139b700cf746 100644
--- a/src/hotspot/cpu/aarch64/universalNativeInvoker_aarch64.cpp
+++ b/src/hotspot/cpu/aarch64/universalNativeInvoker_aarch64.cpp
@@ -28,6 +28,8 @@
 #include "memory/resourceArea.hpp"
 #include "prims/universalNativeInvoker.hpp"
 
+#define __ _masm->
+
 void ProgrammableInvoker::Generator::generate() {
   __ enter();
 
@@ -73,7 +75,7 @@ void ProgrammableInvoker::Generator::generate() {
   __ bind(Ldone);
 
   for (int i = 0; i < _abi->_vector_argument_registers.length(); i++) {
-    ssize_t offs = _layout->arguments_vector + i * sizeof(VectorRegister);
+    ssize_t offs = _layout->arguments_vector + i * float_reg_size;
     __ ldrq(_abi->_vector_argument_registers.at(i), Address(Rctx, offs));
   }
 
@@ -99,7 +101,7 @@ void ProgrammableInvoker::Generator::generate() {
   }
 
   for (int i = 0; i < _abi->_vector_return_registers.length(); i++) {
-    ssize_t offs = _layout->returns_vector + i * sizeof(VectorRegister);
+    ssize_t offs = _layout->returns_vector + i * float_reg_size;
     __ strq(_abi->_vector_return_registers.at(i), Address(Rctx, offs));
   }
 
diff --git a/src/hotspot/cpu/aarch64/universalUpcallHandler_aarch64.cpp b/src/hotspot/cpu/aarch64/universalUpcallHandler_aarch64.cpp
index 3cb524ca9a592..598364d2ec888 100644
--- a/src/hotspot/cpu/aarch64/universalUpcallHandler_aarch64.cpp
+++ b/src/hotspot/cpu/aarch64/universalUpcallHandler_aarch64.cpp
@@ -27,6 +27,8 @@
 #include "memory/resourceArea.hpp"
 #include "prims/universalUpcallHandler.hpp"
 
+#define __ _masm->
+
 // 1. Create buffer according to layout
 // 2. Load registers & stack args into buffer
 // 3. Call upcall helper with upcall handler instance & buffer pointer (C++ ABI)
@@ -63,7 +65,7 @@ address ProgrammableUpcallHandler::generate_upcall_stub(jobject rec, jobject jab
 
   for (int i = 0; i < abi._vector_argument_registers.length(); i++) {
     FloatRegister reg = abi._vector_argument_registers.at(i);
-    ssize_t offset = layout.arguments_vector + i * sizeof(VectorRegister);
+    ssize_t offset = layout.arguments_vector + i * float_reg_size;
     __ strq(reg, Address(sp, offset));
   }
 
@@ -84,7 +86,7 @@ address ProgrammableUpcallHandler::generate_upcall_stub(jobject rec, jobject jab
 
   for (int i = 0; i < abi._vector_return_registers.length(); i++) {
     FloatRegister reg = abi._vector_return_registers.at(i);
-    ssize_t offs = layout.returns_vector + i * sizeof(VectorRegister);
+    ssize_t offs = layout.returns_vector + i * float_reg_size;
     __ ldrq(reg, Address(sp, offs));
   }
 
diff --git a/src/hotspot/cpu/aarch64/vmreg_aarch64.cpp b/src/hotspot/cpu/aarch64/vmreg_aarch64.cpp
index 3e95168c8df66..1cf7bdb553a17 100644
--- a/src/hotspot/cpu/aarch64/vmreg_aarch64.cpp
+++ b/src/hotspot/cpu/aarch64/vmreg_aarch64.cpp
@@ -54,7 +54,6 @@ void VMRegImpl::set_regName() {
 
 #define INTEGER_TYPE 0
 #define VECTOR_TYPE 1
-#define X87_TYPE 2
 #define STACK_TYPE 3
 
 VMReg VMRegImpl::vmStorageToVMReg(int type, int index) {
diff --git a/src/hotspot/cpu/x86/foreign_globals_x86.hpp b/src/hotspot/cpu/x86/foreign_globals_x86.hpp
index ffc53f25a6add..aa25c454c42f4 100644
--- a/src/hotspot/cpu/x86/foreign_globals_x86.hpp
+++ b/src/hotspot/cpu/x86/foreign_globals_x86.hpp
@@ -27,22 +27,7 @@
 #include "asm/macroAssembler.hpp"
 #include "utilities/growableArray.hpp"
 
-#define __ _masm->
-
-struct VectorRegister {
-  static const size_t VECTOR_MAX_WIDTH_BITS = 512; // AVX-512 (64-byte) vector types
-  static const size_t VECTOR_MAX_WIDTH_BYTES = VECTOR_MAX_WIDTH_BITS / 8;
-  static const size_t VECTOR_MAX_WIDTH_U64S = VECTOR_MAX_WIDTH_BITS / 64;
-  static const size_t VECTOR_MAX_WIDTH_FLOATS = VECTOR_MAX_WIDTH_BITS / 32;
-  static const size_t VECTOR_MAX_WIDTH_DOUBLES = VECTOR_MAX_WIDTH_BITS / 64;
-
-  union {
-    uint8_t bits[VECTOR_MAX_WIDTH_BYTES];
-    uint64_t u64[VECTOR_MAX_WIDTH_U64S];
-    float f[VECTOR_MAX_WIDTH_FLOATS];
-    double d[VECTOR_MAX_WIDTH_DOUBLES];
-  };
-};
+constexpr size_t xmm_reg_size = 16; // size of XMM reg
 
 struct ABIDescriptor {
     GrowableArray _integer_argument_registers;
diff --git a/src/hotspot/cpu/x86/sharedRuntime_x86_64.cpp b/src/hotspot/cpu/x86/sharedRuntime_x86_64.cpp
index 0b81aaa0b0bb5..0de0e5eb98398 100644
--- a/src/hotspot/cpu/x86/sharedRuntime_x86_64.cpp
+++ b/src/hotspot/cpu/x86/sharedRuntime_x86_64.cpp
@@ -3462,10 +3462,10 @@ bool target_uses_register(VMReg reg) {
 #endif
 };
 
-address SharedRuntime::make_native_invoker(address call_target,
-                                           int shadow_space_bytes,
-                                           const GrowableArray& input_registers,
-                                           const GrowableArray& output_registers) {
+BufferBlob* SharedRuntime::make_native_invoker(address call_target,
+                                               int shadow_space_bytes,
+                                               const GrowableArray& input_registers,
+                                               const GrowableArray& output_registers) {
   BufferBlob* _invoke_native_blob = BufferBlob::create("nep_invoker_blob", native_invoker_code_size);
   if (_invoke_native_blob == NULL)
     return NULL; // allocation failure
@@ -3475,7 +3475,7 @@ address SharedRuntime::make_native_invoker(address call_target,
   g.generate();
   code.log_section_sizes("nep_invoker_blob");
 
-  return _invoke_native_blob->code_begin();
+  return _invoke_native_blob;
 }
 
 void NativeInvokerGenerator::generate() {
diff --git a/src/hotspot/cpu/x86/universalNativeInvoker_x86.cpp b/src/hotspot/cpu/x86/universalNativeInvoker_x86.cpp
index d3a45dc3d2811..ec1f1575dcb95 100644
--- a/src/hotspot/cpu/x86/universalNativeInvoker_x86.cpp
+++ b/src/hotspot/cpu/x86/universalNativeInvoker_x86.cpp
@@ -27,6 +27,8 @@
 #include "memory/resourceArea.hpp"
 #include "prims/universalNativeInvoker.hpp"
 
+#define __ _masm->
+
 void ProgrammableInvoker::Generator::generate() {
   __ enter();
 
@@ -73,14 +75,8 @@ void ProgrammableInvoker::Generator::generate() {
     // [8] -> 512 bit -> zmm
 
     XMMRegister reg = _abi->_vector_argument_registers.at(i);
-    size_t offs = _layout->arguments_vector + i * sizeof(VectorRegister);
-    if (UseAVX >= 3) {
-      __ evmovdqul(reg, Address(ctxt_reg, (int)offs), Assembler::AVX_512bit);
-    } else if (UseAVX >= 1) {
-      __ vmovdqu(reg, Address(ctxt_reg, (int)offs));
-    } else {
-      __ movdqu(reg, Address(ctxt_reg, (int)offs));
-    }
+    size_t offs = _layout->arguments_vector + i * xmm_reg_size;
+    __ movdqu(reg, Address(ctxt_reg, (int)offs));
   }
 
   for (int i = 0; i < _abi->_integer_argument_registers.length(); i++) {
@@ -115,14 +111,8 @@ void ProgrammableInvoker::Generator::generate() {
     // [8] -> 512 bit -> zmm (AVX-512, aka AVX3)
 
     XMMRegister reg = _abi->_vector_return_registers.at(i);
-    size_t offs = _layout->returns_vector + i * sizeof(VectorRegister);
-    if (UseAVX >= 3) {
-      __ evmovdqul(Address(ctxt_reg, (int)offs), reg, Assembler::AVX_512bit);
-    } else if (UseAVX >= 1) {
-      __ vmovdqu(Address(ctxt_reg, (int)offs), reg);
-    } else {
-      __ movdqu(Address(ctxt_reg, (int)offs), reg);
-    }
+    size_t offs = _layout->returns_vector + i * xmm_reg_size;
+    __ movdqu(Address(ctxt_reg, (int)offs), reg);
   }
 
   for (size_t i = 0; i < _abi->_X87_return_registers_noof; i++) {
diff --git a/src/hotspot/cpu/x86/universalUpcallHandler_x86.cpp b/src/hotspot/cpu/x86/universalUpcallHandler_x86.cpp
index b26871dc57f2d..0cbf716d32785 100644
--- a/src/hotspot/cpu/x86/universalUpcallHandler_x86.cpp
+++ b/src/hotspot/cpu/x86/universalUpcallHandler_x86.cpp
@@ -26,6 +26,8 @@
 #include "memory/resourceArea.hpp"
 #include "prims/universalUpcallHandler.hpp"
 
+#define __ _masm->
+
 // 1. Create buffer according to layout
 // 2. Load registers & stack args into buffer
 // 3. Call upcall helper with upcall handler instance & buffer pointer (C++ ABI)
@@ -41,7 +43,7 @@ address ProgrammableUpcallHandler::generate_upcall_stub(jobject rec, jobject jab
   MacroAssembler* _masm = new MacroAssembler(&buffer);
   int stack_alignment_C = 16; // bytes
   int register_size = sizeof(uintptr_t);
-  int buffer_alignment = sizeof(VectorRegister);
+  int buffer_alignment = xmm_reg_size;
 
   // stub code
   __ enter();
@@ -76,14 +78,8 @@ address ProgrammableUpcallHandler::generate_upcall_stub(jobject rec, jobject jab
 
   for (int i = 0; i < abi._vector_argument_registers.length(); i++) {
     XMMRegister reg = abi._vector_argument_registers.at(i);
-    size_t offs = buffer_offset + layout.arguments_vector + i * sizeof(VectorRegister);
-    if (UseAVX >= 3) {
-      __ evmovdqul(Address(rsp, (int)offs), reg, Assembler::AVX_512bit);
-    } else if (UseAVX >= 1) {
-      __ vmovdqu(Address(rsp, (int)offs), reg);
-    } else {
-      __ movdqu(Address(rsp, (int)offs), reg);
-    }
+    size_t offs = buffer_offset + layout.arguments_vector + i * xmm_reg_size;
+    __ movdqu(Address(rsp, (int)offs), reg);
   }
 
   // Capture prev stack pointer (stack arguments base)
@@ -121,14 +117,8 @@ address ProgrammableUpcallHandler::generate_upcall_stub(jobject rec, jobject jab
 
   for (int i = 0; i < abi._vector_return_registers.length(); i++) {
     XMMRegister reg = abi._vector_return_registers.at(i);
-    size_t offs = buffer_offset + layout.returns_vector + i * sizeof(VectorRegister);
-    if (UseAVX >= 3) {
-      __ evmovdqul(reg, Address(rsp, (int)offs), Assembler::AVX_512bit);
-    } else if (UseAVX >= 1) {
-      __ vmovdqu(reg, Address(rsp, (int)offs));
-    } else {
-      __ movdqu(reg, Address(rsp, (int)offs));
-    }
+    size_t offs = buffer_offset + layout.returns_vector + i * xmm_reg_size;
+    __ movdqu(reg, Address(rsp, (int)offs));
   }
 
   for (size_t i = abi._X87_return_registers_noof; i > 0 ; i--) {
diff --git a/src/hotspot/share/ci/ciEnv.cpp b/src/hotspot/share/ci/ciEnv.cpp
index 948020a7d119d..1467967969333 100644
--- a/src/hotspot/share/ci/ciEnv.cpp
+++ b/src/hotspot/share/ci/ciEnv.cpp
@@ -970,8 +970,7 @@ void ciEnv::register_method(ciMethod* target,
                             bool has_unsafe_access,
                             bool has_wide_vectors,
                             RTMState  rtm_state,
-                            address* native_stubs,
-                            int num_stubs) {
+                            const GrowableArrayView& native_invokers) {
   VM_ENTRY_MARK;
   nmethod* nm = NULL;
   {
@@ -1061,7 +1060,7 @@ void ciEnv::register_method(ciMethod* target,
                                frame_words, oop_map_set,
                                handler_table, inc_table,
                                compiler, task()->comp_level(),
-                               native_stubs, num_stubs);
+                               native_invokers);
 
     // Free codeBlobs
     code_buffer->free_blob();
diff --git a/src/hotspot/share/ci/ciEnv.hpp b/src/hotspot/share/ci/ciEnv.hpp
index a435d1bc76028..041c23fdb2e89 100644
--- a/src/hotspot/share/ci/ciEnv.hpp
+++ b/src/hotspot/share/ci/ciEnv.hpp
@@ -381,8 +381,7 @@ class ciEnv : StackObj {
                        bool                      has_unsafe_access,
                        bool                      has_wide_vectors,
                        RTMState                  rtm_state = NoRTM,
-                       address*                  native_stubs = NULL,
-                       int                       num_stubs = 0);
+                       const GrowableArrayView& native_invokers = GrowableArrayView::EMPTY);
 
 
   // Access to certain well known ciObjects.
diff --git a/src/hotspot/share/code/codeCache.cpp b/src/hotspot/share/code/codeCache.cpp
index e2af7f6007ef9..a0c42c6dd8395 100644
--- a/src/hotspot/share/code/codeCache.cpp
+++ b/src/hotspot/share/code/codeCache.cpp
@@ -564,7 +564,7 @@ void CodeCache::free(CodeBlob* cb) {
     if (ptr->has_dependencies()) {
       _number_of_nmethods_with_dependencies--;
     }
-    ptr->free_native_stubs();
+    ptr->free_native_invokers();
   }
   if (cb->is_adapter_blob()) {
     heap->set_adapter_count(heap->adapter_count() - 1);
diff --git a/src/hotspot/share/code/nmethod.cpp b/src/hotspot/share/code/nmethod.cpp
index 96201c7890d1f..80332015b5d15 100644
--- a/src/hotspot/share/code/nmethod.cpp
+++ b/src/hotspot/share/code/nmethod.cpp
@@ -65,6 +65,7 @@
 #include "runtime/sweeper.hpp"
 #include "runtime/vmThread.hpp"
 #include "utilities/align.hpp"
+#include "utilities/copy.hpp"
 #include "utilities/dtrace.hpp"
 #include "utilities/events.hpp"
 #include "utilities/resourceHash.hpp"
@@ -497,8 +498,7 @@ nmethod* nmethod::new_nmethod(const methodHandle& method,
   ImplicitExceptionTable* nul_chk_table,
   AbstractCompiler* compiler,
   int comp_level,
-  address* native_stubs,
-  int num_stubs
+  const GrowableArrayView& native_invokers
 #if INCLUDE_JVMCI
   , char* speculations,
   int speculations_len,
@@ -520,6 +520,7 @@ nmethod* nmethod::new_nmethod(const methodHandle& method,
       CodeBlob::allocation_size(code_buffer, sizeof(nmethod))
       + adjust_pcs_size(debug_info->pcs_size())
       + align_up((int)dependencies->size_in_bytes(), oopSize)
+      + align_up(native_invokers.data_size_in_bytes() , oopSize)
       + align_up(handler_table->size_in_bytes()    , oopSize)
       + align_up(nul_chk_table->size_in_bytes()    , oopSize)
 #if INCLUDE_JVMCI
@@ -536,8 +537,7 @@ nmethod* nmethod::new_nmethod(const methodHandle& method,
             nul_chk_table,
             compiler,
             comp_level,
-            native_stubs,
-            num_stubs
+            native_invokers
 #if INCLUDE_JVMCI
             , speculations,
             speculations_len,
@@ -601,8 +601,7 @@ nmethod::nmethod(
   : CompiledMethod(method, "native nmethod", type, nmethod_size, sizeof(nmethod), code_buffer, offsets->value(CodeOffsets::Frame_Complete), frame_size, oop_maps, false),
   _is_unloading_state(0),
   _native_receiver_sp_offset(basic_lock_owner_sp_offset),
-  _native_basic_lock_sp_offset(basic_lock_sp_offset),
-  _native_stubs(NULL), _num_stubs(0)
+  _native_basic_lock_sp_offset(basic_lock_sp_offset)
 {
   {
     int scopes_data_offset   = 0;
@@ -626,7 +625,8 @@ nmethod::nmethod(
     scopes_data_offset       = _metadata_offset     + align_up(code_buffer->total_metadata_size(), wordSize);
     _scopes_pcs_offset       = scopes_data_offset;
     _dependencies_offset     = _scopes_pcs_offset;
-    _handler_table_offset    = _dependencies_offset;
+    _native_invokers_offset     = _dependencies_offset;
+    _handler_table_offset    = _native_invokers_offset;
     _nul_chk_table_offset    = _handler_table_offset;
 #if INCLUDE_JVMCI
     _speculations_offset     = _nul_chk_table_offset;
@@ -723,8 +723,7 @@ nmethod::nmethod(
   ImplicitExceptionTable* nul_chk_table,
   AbstractCompiler* compiler,
   int comp_level,
-  address* native_stubs,
-  int num_stubs
+  const GrowableArrayView& native_invokers
 #if INCLUDE_JVMCI
   , char* speculations,
   int speculations_len,
@@ -734,8 +733,7 @@ nmethod::nmethod(
   : CompiledMethod(method, "nmethod", type, nmethod_size, sizeof(nmethod), code_buffer, offsets->value(CodeOffsets::Frame_Complete), frame_size, oop_maps, false),
   _is_unloading_state(0),
   _native_receiver_sp_offset(in_ByteSize(-1)),
-  _native_basic_lock_sp_offset(in_ByteSize(-1)),
-  _native_stubs(native_stubs), _num_stubs(num_stubs)
+  _native_basic_lock_sp_offset(in_ByteSize(-1))
 {
   assert(debug_info->oop_recorder() == code_buffer->oop_recorder(), "shared OR");
   {
@@ -802,7 +800,8 @@ nmethod::nmethod(
 
     _scopes_pcs_offset       = scopes_data_offset    + align_up(debug_info->data_size       (), oopSize);
     _dependencies_offset     = _scopes_pcs_offset    + adjust_pcs_size(debug_info->pcs_size());
-    _handler_table_offset    = _dependencies_offset  + align_up((int)dependencies->size_in_bytes (), oopSize);
+    _native_invokers_offset  = _dependencies_offset  + align_up((int)dependencies->size_in_bytes(), oopSize);
+    _handler_table_offset    = _native_invokers_offset + align_up(native_invokers.data_size_in_bytes(), oopSize);
     _nul_chk_table_offset    = _handler_table_offset + align_up(handler_table->size_in_bytes(), oopSize);
 #if INCLUDE_JVMCI
     _speculations_offset     = _nul_chk_table_offset + align_up(nul_chk_table->size_in_bytes(), oopSize);
@@ -824,6 +823,13 @@ nmethod::nmethod(
     code_buffer->copy_values_to(this);
     debug_info->copy_to(this);
     dependencies->copy_to(this);
+    if (native_invokers.is_nonempty()) { // can not get address of zero-length array
+      // Copy native stubs
+      assert(native_invokers.data_size_in_bytes() % sizeof(HeapWord) == 0, "unexpected array size");
+      Copy::disjoint_words((HeapWord*) native_invokers.adr_at(0),
+                          (HeapWord*) native_invokers_begin(),
+                          native_invokers.data_size_in_bytes() / sizeof(HeapWord));
+    }
     clear_unloading_state();
 
     Universe::heap()->register_nmethod(this);
@@ -986,6 +992,10 @@ void nmethod::print_nmethod(bool printmethod) {
       print_dependencies();
       tty->print_cr("- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ");
     }
+    if (printmethod) {
+      print_native_invokers();
+      tty->print_cr("- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ");
+    }
     if (printmethod || PrintExceptionHandlers) {
       print_handler_table();
       tty->print_cr("- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ");
@@ -1046,14 +1056,9 @@ void nmethod::copy_values(GrowableArray* array) {
   }
 }
 
-void nmethod::free_native_stubs() {
-  if (_native_stubs != NULL) {
-    for (int i = 0; i < _num_stubs; i++) {
-      CodeBlob* cb = CodeCache::find_blob((char*)  _native_stubs[i]);
-      assert(cb != NULL, "Expected to find blob");
-      CodeCache::free(cb);
-    }
-    FREE_C_HEAP_ARRAY(address, _native_stubs);
+void nmethod::free_native_invokers() {
+  for (BufferBlob** it = native_invokers_begin(); it < native_invokers_end(); it++) {
+    CodeCache::free(*it);
   }
 }
 
@@ -2689,6 +2694,19 @@ void nmethod::print_pcs_on(outputStream* st) {
   }
 }
 
+void nmethod::print_native_invokers() {
+  ResourceMark m;       // in case methods get printed via debugger
+  tty->print("Native invokers:");
+  if (native_invokers_begin() < native_invokers_end()) {
+    tty->cr();
+    for (BufferBlob** itt = native_invokers_begin(); itt < native_invokers_end(); itt++) {
+      (*itt)->print_on(tty);
+    }
+  } else {
+    tty->print_cr(" ");
+  }
+}
+
 void nmethod::print_handler_table() {
   ExceptionHandlerTable(this).print();
 }
diff --git a/src/hotspot/share/code/nmethod.hpp b/src/hotspot/share/code/nmethod.hpp
index 62be8b8e94cd1..592fa8f7017fa 100644
--- a/src/hotspot/share/code/nmethod.hpp
+++ b/src/hotspot/share/code/nmethod.hpp
@@ -207,6 +207,7 @@ class nmethod : public CompiledMethod {
   int _scopes_data_offset;
   int _scopes_pcs_offset;
   int _dependencies_offset;
+  int _native_invokers_offset;
   int _handler_table_offset;
   int _nul_chk_table_offset;
 #if INCLUDE_JVMCI
@@ -282,9 +283,6 @@ class nmethod : public CompiledMethod {
   ByteSize _native_receiver_sp_offset;
   ByteSize _native_basic_lock_sp_offset;
 
-  address* _native_stubs;
-  int _num_stubs;
-
   friend class nmethodLocker;
 
   // For native wrappers
@@ -316,8 +314,7 @@ class nmethod : public CompiledMethod {
           ImplicitExceptionTable* nul_chk_table,
           AbstractCompiler* compiler,
           int comp_level,
-          address* native_stubs,
-          int num_stubs
+          const GrowableArrayView& native_invokers
 #if INCLUDE_JVMCI
           , char* speculations,
           int speculations_len,
@@ -366,8 +363,7 @@ class nmethod : public CompiledMethod {
                               ImplicitExceptionTable* nul_chk_table,
                               AbstractCompiler* compiler,
                               int comp_level,
-                              address* native_stubs = NULL,
-                              int num_stubs = 0
+                              const GrowableArrayView& native_invokers = GrowableArrayView::EMPTY
 #if INCLUDE_JVMCI
                               , char* speculations = NULL,
                               int speculations_len = 0,
@@ -416,7 +412,9 @@ class nmethod : public CompiledMethod {
   PcDesc* scopes_pcs_begin      () const          { return (PcDesc*)(header_begin() + _scopes_pcs_offset   ); }
   PcDesc* scopes_pcs_end        () const          { return (PcDesc*)(header_begin() + _dependencies_offset) ; }
   address dependencies_begin    () const          { return           header_begin() + _dependencies_offset  ; }
-  address dependencies_end      () const          { return           header_begin() + _handler_table_offset ; }
+  address dependencies_end      () const          { return           header_begin() + _native_invokers_offset ; }
+  BufferBlob** native_invokers_begin() const         { return (BufferBlob**)(header_begin() + _native_invokers_offset) ; }
+  BufferBlob** native_invokers_end  () const         { return (BufferBlob**)(header_begin() + _handler_table_offset); }
   address handler_table_begin   () const          { return           header_begin() + _handler_table_offset ; }
   address handler_table_end     () const          { return           header_begin() + _nul_chk_table_offset ; }
   address nul_chk_table_begin   () const          { return           header_begin() + _nul_chk_table_offset ; }
@@ -532,7 +530,7 @@ class nmethod : public CompiledMethod {
   void copy_values(GrowableArray* oops);
   void copy_values(GrowableArray* metadata);
 
-  void free_native_stubs();
+  void free_native_invokers();
 
   // Relocation support
 private:
@@ -670,6 +668,7 @@ class nmethod : public CompiledMethod {
   void print_scopes() { print_scopes_on(tty); }
   void print_scopes_on(outputStream* st)          PRODUCT_RETURN;
   void print_value_on(outputStream* st) const;
+  void print_native_invokers();
   void print_handler_table();
   void print_nul_chk_table();
   void print_recorded_oops();
diff --git a/src/hotspot/share/code/vmreg.cpp b/src/hotspot/share/code/vmreg.cpp
index d7541d8a22668..1e30fc50b7162 100644
--- a/src/hotspot/share/code/vmreg.cpp
+++ b/src/hotspot/share/code/vmreg.cpp
@@ -25,6 +25,7 @@
 #include "precompiled.hpp"
 #include "asm/assembler.hpp"
 #include "code/vmreg.hpp"
+#include "utilities/print.hpp"
 
 // First VMReg value that could refer to a stack slot
 VMReg VMRegImpl::stack0 = (VMReg)(intptr_t)((ConcreteRegisterImpl::number_of_registers + 7) & ~7);
@@ -50,3 +51,8 @@ void VMRegImpl::print_on(outputStream* st) const {
 }
 
 void VMRegImpl::print() const { print_on(tty); }
+
+template<>
+void Print::print_on(const VMReg& value, outputStream* st) {
+  value->print_on(st);
+}
diff --git a/src/hotspot/share/jvmci/jvmciRuntime.cpp b/src/hotspot/share/jvmci/jvmciRuntime.cpp
index 6dc14feecb590..ca8c2a4051ee6 100644
--- a/src/hotspot/share/jvmci/jvmciRuntime.cpp
+++ b/src/hotspot/share/jvmci/jvmciRuntime.cpp
@@ -1626,7 +1626,7 @@ JVMCI::CodeInstallResult JVMCIRuntime::register_method(JVMCIEnv* JVMCIENV,
                                  debug_info, dependencies, code_buffer,
                                  frame_words, oop_map_set,
                                  handler_table, implicit_exception_table,
-                                 compiler, comp_level, NULL, 0,
+                                 compiler, comp_level, GrowableArrayView::EMPTY,
                                  speculations, speculations_len,
                                  nmethod_mirror_index, nmethod_mirror_name, failed_speculations);
 
diff --git a/src/hotspot/share/opto/callnode.cpp b/src/hotspot/share/opto/callnode.cpp
index cf53ae81c754c..664bce0110314 100644
--- a/src/hotspot/share/opto/callnode.cpp
+++ b/src/hotspot/share/opto/callnode.cpp
@@ -1138,15 +1138,9 @@ Node* CallNativeNode::match(const ProjNode *proj, const Matcher *matcher) {
     case TypeFunc::ReturnAdr:
     case TypeFunc::FramePtr:
       ShouldNotReachHere();
-    case TypeFunc::Parms:
-    default: {
-      if(tf()->range()->field_at(proj->_con) == Type::HALF) {
-        assert(_ret_regs.at(proj->_con - TypeFunc::Parms) == VMRegImpl::Bad(), "Unexpected register for Type::HALF");
-        // 2nd half of doubles and longs
-        return new MachProjNode(this,proj->_con, RegMask::Empty, (uint)OptoReg::Bad);
-      }
-
-      const BasicType bt = tf()->range()->field_at(proj->_con)->basic_type();
+    case TypeFunc::Parms: {
+      const Type* field_at_con = tf()->range()->field_at(proj->_con);
+      const BasicType bt = field_at_con->basic_type();
       OptoReg::Name optoreg = OptoReg::as_OptoReg(_ret_regs.at(proj->_con - TypeFunc::Parms));
       OptoRegPair regs;
       if (bt == T_DOUBLE || bt == T_LONG) {
@@ -1155,10 +1149,18 @@ Node* CallNativeNode::match(const ProjNode *proj, const Matcher *matcher) {
         regs.set1(optoreg);
       }
       RegMask rm = RegMask(regs.first());
-      if( OptoReg::is_valid(regs.second()) )
-        rm.Insert( regs.second() );
-      return new MachProjNode(this,proj->_con,rm,tf()->range()->field_at(proj->_con)->ideal_reg());
+      if(OptoReg::is_valid(regs.second()))
+        rm.Insert(regs.second());
+      return new MachProjNode(this, proj->_con, rm, field_at_con->ideal_reg());
+    }
+    case TypeFunc::Parms + 1: {
+      assert(tf()->range()->field_at(proj->_con) == Type::HALF, "Expected HALF");
+      assert(_ret_regs.at(proj->_con - TypeFunc::Parms) == VMRegImpl::Bad(), "Unexpected register for Type::HALF");
+      // 2nd half of doubles and longs
+      return new MachProjNode(this, proj->_con, RegMask::Empty, (uint) OptoReg::Bad);
     }
+    default:
+      ShouldNotReachHere();
   }
   return NULL;
 }
@@ -1181,7 +1183,7 @@ void CallRuntimeNode::calling_convention( BasicType* sig_bt, VMRegPair *parm_reg
 
 void CallNativeNode::calling_convention( BasicType* sig_bt, VMRegPair *parm_regs, uint argcnt ) const {
   assert((tf()->domain()->cnt() - TypeFunc::Parms) == argcnt, "arg counts must match!");
-#ifndef PRODUCT
+#ifdef ASSERT
   for (uint i = 0; i < argcnt; i++) {
     assert(tf()->domain()->field_at(TypeFunc::Parms + i)->basic_type() == sig_bt[i], "types must match!");
   }
diff --git a/src/hotspot/share/opto/compile.cpp b/src/hotspot/share/opto/compile.cpp
index 9082d68c58244..251ac7a4b34fa 100644
--- a/src/hotspot/share/opto/compile.cpp
+++ b/src/hotspot/share/opto/compile.cpp
@@ -536,7 +536,7 @@ Compile::Compile( ciEnv* ci_env, ciMethod* target, int osr_bci,
                   _vector_reboxing_late_inlines(comp_arena(), 2, 0, NULL),
                   _late_inlines_pos(0),
                   _number_of_mh_late_inlines(0),
-                  _native_stubs(comp_arena(), 1, 0, NULL),
+                  _native_invokers(comp_arena(), 1, 0, NULL),
                   _print_inlining_stream(NULL),
                   _print_inlining_list(NULL),
                   _print_inlining_idx(0),
@@ -833,7 +833,7 @@ Compile::Compile( ciEnv* ci_env,
     _for_igvn(NULL),
     _warm_calls(NULL),
     _number_of_mh_late_inlines(0),
-    _native_stubs(),
+    _native_invokers(),
     _print_inlining_stream(NULL),
     _print_inlining_list(NULL),
     _print_inlining_idx(0),
@@ -4699,6 +4699,6 @@ void Compile::igv_print_method_to_network(const char* phase_name) {
 }
 #endif
 
-void Compile::add_native_stub(address stubAddress) {
-  _native_stubs.append(stubAddress);
+void Compile::add_native_invoker(BufferBlob* stub) {
+  _native_invokers.append(stub);
 }
diff --git a/src/hotspot/share/opto/compile.hpp b/src/hotspot/share/opto/compile.hpp
index 603ada28b49b0..583ebdbfafefd 100644
--- a/src/hotspot/share/opto/compile.hpp
+++ b/src/hotspot/share/opto/compile.hpp
@@ -384,7 +384,7 @@ class Compile : public Phase {
   int                           _late_inlines_pos;    // Where in the queue should the next late inlining candidate go (emulate depth first inlining)
   uint                          _number_of_mh_late_inlines; // number of method handle late inlining still pending
 
-  GrowableArray
        _native_stubs;
+  GrowableArray    _native_invokers;
 
   // Inlining may not happen in parse order which would make
   // PrintInlining output confusing. Keep track of PrintInlining
@@ -936,9 +936,9 @@ class Compile : public Phase {
     _vector_reboxing_late_inlines.push(cg);
   }
 
-  void add_native_stub(address stub);
+  void add_native_invoker(BufferBlob* stub);
 
-  const GrowableArray
& native_stubs() const { return _native_stubs; }
+  const GrowableArray& native_invokers() const { return _native_invokers; }
 
   void remove_useless_late_inlines(GrowableArray* inlines, Unique_Node_List &useful);
   void remove_useless_nodes       (GrowableArray&        node_list, Unique_Node_List &useful);
diff --git a/src/hotspot/share/opto/graphKit.cpp b/src/hotspot/share/opto/graphKit.cpp
index 6cc6a193bc369..3921eae5007ff 100644
--- a/src/hotspot/share/opto/graphKit.cpp
+++ b/src/hotspot/share/opto/graphKit.cpp
@@ -2581,7 +2581,7 @@ Node* GraphKit::make_native_call(const TypeFunc* call_type, uint nargs, ciNative
   uint n_filtered_args = nargs - 2; // -fallback, -nep;
   ResourceMark rm;
   Node** argument_nodes = NEW_RESOURCE_ARRAY(Node*, n_filtered_args);
-  const Type** arg_types = NEW_RESOURCE_ARRAY(const Type*, n_filtered_args);
+  const Type** arg_types = TypeTuple::fields(n_filtered_args);
   GrowableArray arg_regs(C->comp_arena(), n_filtered_args, n_filtered_args, VMRegImpl::Bad());
 
   VMReg* argRegs = nep->argMoves();
@@ -2596,14 +2596,14 @@ Node* GraphKit::make_native_call(const TypeFunc* call_type, uint nargs, ciNative
         : argRegs[java_arg_read_pos++];
 
       argument_nodes[vm_arg_pos] = node;
-      arg_types[vm_arg_pos] = type;
+      arg_types[TypeFunc::Parms + vm_arg_pos] = type;
       arg_regs.at_put(vm_arg_pos, reg);
     }
   }
 
   uint n_returns = call_type->range()->cnt() - TypeFunc::Parms;
   GrowableArray ret_regs(C->comp_arena(), n_returns, n_returns, VMRegImpl::Bad());
-  const Type** ret_types = NEW_RESOURCE_ARRAY(const Type*, n_returns);
+  const Type** ret_types = TypeTuple::fields(n_returns);
 
   VMReg* retRegs = nep->returnMoves();
   {
@@ -2615,22 +2615,23 @@ Node* GraphKit::make_native_call(const TypeFunc* call_type, uint nargs, ciNative
         : retRegs[java_ret_read_pos++];
 
       ret_regs.at_put(vm_ret_pos, reg);
-      ret_types[vm_ret_pos] = type;
+      ret_types[TypeFunc::Parms + vm_ret_pos] = type;
     }
   }
 
   const TypeFunc* new_call_type = TypeFunc::make(
-    TypeTuple::make_func(n_filtered_args, arg_types),
-    TypeTuple::make_func(n_returns, ret_types)
+    TypeTuple::make(TypeFunc::Parms + n_filtered_args, arg_types),
+    TypeTuple::make(TypeFunc::Parms + n_returns, ret_types)
   );
 
   address call_addr = nep->entry_point();
   if (nep->need_transition()) {
-    call_addr = SharedRuntime::make_native_invoker(call_addr,
-                                                   nep->shadow_space(),
-                                                   arg_regs, ret_regs);
-    if (call_addr == NULL) return NULL;
-    C->add_native_stub(call_addr);
+    BufferBlob* invoker = SharedRuntime::make_native_invoker(call_addr,
+                                                             nep->shadow_space(),
+                                                             arg_regs, ret_regs);
+    if (invoker == NULL) return NULL;
+    C->add_native_invoker(invoker);
+    call_addr = invoker->code_begin();
   }
   assert(call_addr != NULL, "sanity");
 
@@ -2659,33 +2660,22 @@ Node* GraphKit::make_native_call(const TypeFunc* call_type, uint nargs, ciNative
   if (method() == NULL || method()->return_type()->basic_type() == T_VOID) {
     ret = top();
   } else {
-    Node* current_value = NULL;
-    for (uint vm_ret_pos = 0; vm_ret_pos < n_returns; vm_ret_pos++) {
-      if (new_call_type->range()->field_at(TypeFunc::Parms + vm_ret_pos)  == Type::HALF) {
-        // FIXME is this needed?
-        gvn().transform(new ProjNode(call, TypeFunc::Parms + vm_ret_pos));
-      } else {
-        assert(current_value == NULL, "Must not overwrite");
-        current_value = gvn().transform(new ProjNode(call, TypeFunc::Parms + vm_ret_pos));
-      }
-    }
-    assert(current_value != NULL, "Should not be null");
+    ret =  gvn().transform(new ProjNode(call, TypeFunc::Parms));
     // Unpack native results if needed
     // Need this method type since it's unerased
     switch (nep->method_type()->rtype()->basic_type()) {
       case T_CHAR:
-        current_value = _gvn.transform(new AndINode(current_value, _gvn.intcon(0xFFFF)));
+        ret = _gvn.transform(new AndINode(ret, _gvn.intcon(0xFFFF)));
         break;
       case T_BYTE:
-        current_value = sign_extend_byte(current_value);
+        ret = sign_extend_byte(ret);
         break;
       case T_SHORT:
-        current_value = sign_extend_short(current_value);
+        ret = sign_extend_short(ret);
         break;
       default: // do nothing
         break;
     }
-    ret = current_value;
   }
 
   push_node(method()->return_type()->basic_type(), ret);
diff --git a/src/hotspot/share/opto/lcm.cpp b/src/hotspot/share/opto/lcm.cpp
index 8b8a3a5fa861e..2b554df8ac427 100644
--- a/src/hotspot/share/opto/lcm.cpp
+++ b/src/hotspot/share/opto/lcm.cpp
@@ -863,7 +863,9 @@ uint PhaseCFG::sched_call(Block* block, uint node_cnt, Node_List& worklist, Grow
       save_policy = _matcher._register_save_policy;
       break;
     case Op_CallNative:
-      // FIXME compute actual save policy based on nep->abi
+      // We use the c reg save policy here since Panama
+      // only supports the C ABI currently.
+      // TODO compute actual save policy based on nep->abi
       save_policy = _matcher._c_reg_save_policy;
       break;
 
diff --git a/src/hotspot/share/opto/output.cpp b/src/hotspot/share/opto/output.cpp
index 3d11173a982ca..681cd20504497 100644
--- a/src/hotspot/share/opto/output.cpp
+++ b/src/hotspot/share/opto/output.cpp
@@ -1003,6 +1003,7 @@ void PhaseOutput::Process_OopMap_Node(MachNode *mach, int current_offset) {
 
   int safepoint_pc_offset = current_offset;
   bool is_method_handle_invoke = false;
+  bool is_opt_native = false;
   bool return_oop = false;
   bool has_ea_local_in_scope = sfn->_has_ea_local_in_scope;
   bool arg_escape = false;
@@ -1021,6 +1022,8 @@ void PhaseOutput::Process_OopMap_Node(MachNode *mach, int current_offset) {
         is_method_handle_invoke = true;
       }
       arg_escape = mcall->as_MachCallJava()->_arg_escape;
+    } else if (mcall->is_MachCallNative()) {
+      is_opt_native = true;
     }
 
     // Check if a call returns an object.
@@ -1141,7 +1144,6 @@ void PhaseOutput::Process_OopMap_Node(MachNode *mach, int current_offset) {
     // Now we can describe the scope.
     methodHandle null_mh;
     bool rethrow_exception = false;
-    bool is_opt_native = mach->is_MachCallNative();
     C->debug_info()->describe_scope(
       safepoint_pc_offset,
       null_mh,
@@ -3391,16 +3393,6 @@ void PhaseOutput::install_code(ciMethod*         target,
       _code_offsets.set_value(CodeOffsets::OSR_Entry, 0);
     }
 
-    address* native_stubs = NULL;
-    int num_stubs = 0;
-    if (!C->native_stubs().is_empty()) {
-      num_stubs = C->native_stubs().length();
-      native_stubs = NEW_C_HEAP_ARRAY(address, num_stubs, mtInternal);
-      for (int i = 0; i < num_stubs; i++) {
-        native_stubs[i] = C->native_stubs().at(i);
-      }
-    }
-
     C->env()->register_method(target,
                                      entry_bci,
                                      &_code_offsets,
@@ -3414,8 +3406,7 @@ void PhaseOutput::install_code(ciMethod*         target,
                                      has_unsafe_access,
                                      SharedRuntime::is_wide_vector(C->max_vector_size()),
                                      C->rtm_state(),
-                                     native_stubs,
-                                     num_stubs);
+                                     C->native_invokers());
 
     if (C->log() != NULL) { // Print code cache state into compiler log
       C->log()->code_cache_state();
diff --git a/src/hotspot/share/opto/type.cpp b/src/hotspot/share/opto/type.cpp
index a3e1c952e2e7a..ff26780f7866c 100644
--- a/src/hotspot/share/opto/type.cpp
+++ b/src/hotspot/share/opto/type.cpp
@@ -1993,14 +1993,6 @@ const TypeTuple *TypeTuple::make( uint cnt, const Type **fields ) {
   return (TypeTuple*)(new TypeTuple(cnt,fields))->hashcons();
 }
 
-const TypeTuple *TypeTuple::make_func( uint arg_cnt, const Type **arg_fields ) {
-  const Type** field_array = fields(arg_cnt);
-  for (uint i = 0; i < arg_cnt; i++) {
-    field_array[i + TypeFunc::Parms] = arg_fields[i];
-  }
-  return make(arg_cnt + TypeFunc::Parms, field_array);
-}
-
 //------------------------------fields-----------------------------------------
 // Subroutine call type with space allocated for argument types
 // Memory for Control, I_O, Memory, FramePtr, and ReturnAdr is allocated implicitly
diff --git a/src/hotspot/share/opto/type.hpp b/src/hotspot/share/opto/type.hpp
index 9d78e9918d52b..51a48c04e4b78 100644
--- a/src/hotspot/share/opto/type.hpp
+++ b/src/hotspot/share/opto/type.hpp
@@ -675,7 +675,6 @@ class TypeTuple : public Type {
   static const TypeTuple *make( uint cnt, const Type **fields );
   static const TypeTuple *make_range(ciSignature *sig);
   static const TypeTuple *make_domain(ciInstanceKlass* recv, ciSignature *sig);
-  static const TypeTuple *make_func(uint arg_cnt, const Type **arg_fields);
 
   // Subroutine call type with space allocated for argument types
   // Memory for Control, I_O, Memory, FramePtr, and ReturnAdr is allocated implicitly
diff --git a/src/hotspot/share/runtime/sharedRuntime.hpp b/src/hotspot/share/runtime/sharedRuntime.hpp
index e62ff4b4f6d53..8ef36761a9f8f 100644
--- a/src/hotspot/share/runtime/sharedRuntime.hpp
+++ b/src/hotspot/share/runtime/sharedRuntime.hpp
@@ -513,10 +513,10 @@ class SharedRuntime: AllStatic {
 
   static address handle_unsafe_access(JavaThread* thread, address next_pc);
 
-  static address make_native_invoker(address call_target,
-                                     int shadow_space_bytes,
-                                     const GrowableArray& input_registers,
-                                     const GrowableArray& output_registers);
+  static BufferBlob* make_native_invoker(address call_target,
+                                         int shadow_space_bytes,
+                                         const GrowableArray& input_registers,
+                                         const GrowableArray& output_registers);
 
 #ifndef PRODUCT
 
diff --git a/src/hotspot/share/utilities/growableArray.hpp b/src/hotspot/share/utilities/growableArray.hpp
index 2a86a30d4319c..7ae4a4626cf41 100644
--- a/src/hotspot/share/utilities/growableArray.hpp
+++ b/src/hotspot/share/utilities/growableArray.hpp
@@ -31,6 +31,7 @@
 #include "utilities/globalDefinitions.hpp"
 #include "utilities/ostream.hpp"
 #include "utilities/powerOfTwo.hpp"
+#include "utilities/print.hpp"
 
 // A growable array.
 
@@ -124,6 +125,8 @@ class GrowableArrayView : public GrowableArrayBase {
   ~GrowableArrayView() {}
 
 public:
+  const static GrowableArrayView EMPTY;
+
   bool operator==(const GrowableArrayView& rhs) const {
     if (_len != rhs._len)
       return false;
@@ -310,16 +313,28 @@ class GrowableArrayView : public GrowableArrayBase {
     return min;
   }
 
-  void print() {
-    tty->print("Growable Array " INTPTR_FORMAT, p2i(this));
-    tty->print(": length %d (_max %d) { ", _len, _max);
+  size_t data_size_in_bytes() const {
+    return _len * sizeof(E);
+  }
+
+  void print() const {
+    print_on(tty);
+  }
+
+  void print_on(outputStream* st) const {
+    st->print("Growable Array " INTPTR_FORMAT, p2i(this));
+    st->print(": length %d (_max %d) { ", _len, _max);
     for (int i = 0; i < _len; i++) {
-      tty->print(INTPTR_FORMAT " ", *(intptr_t*)&(_data[i]));
+      Print::print_on(_data[i], st);
+      st->print(", ");
     }
-    tty->print("}\n");
+    st->print("}\n");
   }
 };
 
+template
+const GrowableArrayView GrowableArrayView::EMPTY(nullptr, 0, 0);
+
 // GrowableArrayWithAllocator extends the "view" with
 // the capability to grow and deallocate the data array.
 //
diff --git a/src/hotspot/share/utilities/print.hpp b/src/hotspot/share/utilities/print.hpp
new file mode 100644
index 0000000000000..ac6d2552d302c
--- /dev/null
+++ b/src/hotspot/share/utilities/print.hpp
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ *
+ */
+
+#ifndef SHARE_UTILITIES_PRINT_HPP
+#define SHARE_UTILITIES_PRINT_HPP
+
+#include "memory/allStatic.hpp"
+#include "utilities/ostream.hpp"
+
+class Print : AllStatic {
+public:
+  template
+  static void print(const T& value) {
+    print_on(value, tty);
+  }
+
+  // For use from generic code.
+  // Types that want better printing output should define specializations
+  // of this function template for the particular type.
+  template
+  static void print_on(const T& value, outputStream* st) {
+    // Print the first word of an object
+    st->print(INTPTR_FORMAT, *((intptr_t*) &value));
+  }
+};
+
+#endif // SHARE_UTILITIES_PRINT_HPP
diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/X86_64Architecture.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/X86_64Architecture.java
index 98c777add1b88..5793eb7729f8d 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/X86_64Architecture.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/x64/X86_64Architecture.java
@@ -33,7 +33,7 @@
 public class X86_64Architecture implements Architecture {
     public static final Architecture INSTANCE = new X86_64Architecture();
     private static final int INTEGER_REG_SIZE = 8; // bytes
-    private static final int VECTOR_REG_SIZE = 64; // sizeof(VectorRegister)
+    private static final int VECTOR_REG_SIZE = 16; // size of XMM register
     private static final int X87_REG_SIZE = 16;
     private static final int STACK_SLOT_SIZE = 8;
 

From a9384a0c8cb153908629d49358f46d2c59f014ff Mon Sep 17 00:00:00 2001
From: Maurizio Cimadamore 
Date: Fri, 13 Nov 2020 11:10:36 +0000
Subject: [PATCH 62/70] Fix build failure with disabled precompiled headers

---
 src/hotspot/share/prims/universalUpcallHandler.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/hotspot/share/prims/universalUpcallHandler.cpp b/src/hotspot/share/prims/universalUpcallHandler.cpp
index 6183748eddb0a..85a30a435b0de 100644
--- a/src/hotspot/share/prims/universalUpcallHandler.cpp
+++ b/src/hotspot/share/prims/universalUpcallHandler.cpp
@@ -22,6 +22,7 @@
  */
 
 #include "precompiled.hpp"
+#include "memory/resourceArea.hpp"
 #include "prims/universalUpcallHandler.hpp"
 #include "runtime/jniHandles.inline.hpp"
 #include "runtime/interfaceSupport.inline.hpp"

From cd7d3f7ea915a16ed3bb18a28eb4e8245c513b12 Mon Sep 17 00:00:00 2001
From: Maurizio Cimadamore 
Date: Fri, 13 Nov 2020 11:11:17 +0000
Subject: [PATCH 63/70] Fix high arity test for aarch64

---
 .../foreign/abi/aarch64/CallArranger.java     |  5 +--
 .../callarranger/TestAarch64CallArranger.java | 36 +++++++++++++++++++
 2 files changed, 39 insertions(+), 2 deletions(-)

diff --git a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/aarch64/CallArranger.java b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/aarch64/CallArranger.java
index 6824b5c751f77..4b19004ec505b 100644
--- a/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/aarch64/CallArranger.java
+++ b/src/jdk.incubator.foreign/share/classes/jdk/internal/foreign/abi/aarch64/CallArranger.java
@@ -310,7 +310,7 @@ List getBindings(Class carrier, MemoryLayout layout) {
                             .baseAddress()
                             .unboxAddress();
                     VMStorage storage = storageCalculator.nextStorage(
-                        StorageClasses.INTEGER, layout);
+                        StorageClasses.INTEGER, AArch64.C_POINTER);
                     bindings.vmStore(storage, long.class);
                     break;
                 }
@@ -405,7 +405,8 @@ List getBindings(Class carrier, MemoryLayout layout) {
                 }
                 case STRUCT_REFERENCE: {
                     assert carrier == MemorySegment.class;
-                    VMStorage storage = storageCalculator.nextStorage(StorageClasses.INTEGER, layout);
+                    VMStorage storage = storageCalculator.nextStorage(
+                        StorageClasses.INTEGER, AArch64.C_POINTER);
                     bindings.vmLoad(storage, long.class)
                             .boxAddress()
                             .toSegment(layout);
diff --git a/test/jdk/java/foreign/callarranger/TestAarch64CallArranger.java b/test/jdk/java/foreign/callarranger/TestAarch64CallArranger.java
index 8b5288b1d6fc0..f9de8b71e5eb8 100644
--- a/test/jdk/java/foreign/callarranger/TestAarch64CallArranger.java
+++ b/test/jdk/java/foreign/callarranger/TestAarch64CallArranger.java
@@ -344,4 +344,40 @@ public void testStructHFA3() {
 
         checkReturnBindings(callingSequence, new Binding[]{});
     }
+
+    @Test
+    public void testStructStackSpill() {
+        // A large (> 16 byte) struct argument that is spilled to the
+        // stack should be passed as a pointer to a copy and occupy one
+        // stack slot.
+
+        MemoryLayout struct = MemoryLayout.ofStruct(C_INT, C_INT, C_DOUBLE, C_INT);
+
+        MethodType mt = MethodType.methodType(
+            void.class, MemorySegment.class, MemorySegment.class, int.class, int.class,
+            int.class, int.class, int.class, int.class, MemorySegment.class, int.class);
+        FunctionDescriptor fd = FunctionDescriptor.ofVoid(
+            struct, struct, C_INT, C_INT, C_INT, C_INT, C_INT, C_INT, struct, C_INT);
+        CallArranger.Bindings bindings = CallArranger.getBindings(mt, fd, false);
+
+        assertFalse(bindings.isInMemoryReturn);
+        CallingSequence callingSequence = bindings.callingSequence;
+        assertEquals(callingSequence.methodType(), mt);
+        assertEquals(callingSequence.functionDesc(), fd);
+
+        checkArgumentBindings(callingSequence, new Binding[][]{
+            { copy(struct), baseAddress(), unboxAddress(), vmStore(r0, long.class) },
+            { copy(struct), baseAddress(), unboxAddress(), vmStore(r1, long.class) },
+            { vmStore(r2, int.class) },
+            { vmStore(r3, int.class) },
+            { vmStore(r4, int.class) },
+            { vmStore(r5, int.class) },
+            { vmStore(r6, int.class) },
+            { vmStore(r7, int.class) },
+            { copy(struct), baseAddress(), unboxAddress(), vmStore(stackStorage(0), long.class) },
+            { vmStore(stackStorage(1), int.class) },
+        });
+
+        checkReturnBindings(callingSequence, new Binding[]{});
+    }
 }

From 15ab3647a48802499c78b07742e40aa326e59254 Mon Sep 17 00:00:00 2001
From: Maurizio Cimadamore 
Date: Fri, 13 Nov 2020 11:18:19 +0000
Subject: [PATCH 64/70] Fix crashes on aarch64 due to lack of intrinsics
 support

---
 src/hotspot/cpu/aarch64/methodHandles_aarch64.cpp | 12 +++++++++++-
 src/hotspot/cpu/aarch64/sharedRuntime_aarch64.cpp |  2 +-
 src/hotspot/share/opto/graphKit.cpp               |  5 ++++-
 test/jdk/java/foreign/TestIntrinsics.java         |  1 +
 4 files changed, 17 insertions(+), 3 deletions(-)

diff --git a/src/hotspot/cpu/aarch64/methodHandles_aarch64.cpp b/src/hotspot/cpu/aarch64/methodHandles_aarch64.cpp
index db9b1507a655f..a2c9053e5b6df 100644
--- a/src/hotspot/cpu/aarch64/methodHandles_aarch64.cpp
+++ b/src/hotspot/cpu/aarch64/methodHandles_aarch64.cpp
@@ -178,6 +178,13 @@ address MethodHandles::generate_method_handle_interpreter_entry(MacroAssembler*
     return NULL;
   }
 
+  // No need in interpreter entry for linkToNative for now.
+  // Interpreter calls compiled entry through i2c.
+  if (iid == vmIntrinsics::_linkToNative) {
+    __ hlt(0);
+    return NULL;
+  }
+
   // r13: sender SP (must preserve; see prepare_to_jump_from_interpreted)
   // rmethod: Method*
   // r3: argument locator (parameter slot count, added to rsp)
@@ -272,7 +279,10 @@ void MethodHandles::generate_method_handle_dispatch(MacroAssembler* _masm,
   assert_different_registers(temp1, temp2, temp3, receiver_reg);
   assert_different_registers(temp1, temp2, temp3, member_reg);
 
-  if (iid == vmIntrinsics::_invokeBasic) {
+  if (iid == vmIntrinsics::_invokeBasic || iid == vmIntrinsics::_linkToNative) {
+    if (iid == vmIntrinsics::_linkToNative) {
+      assert(for_compiler_entry, "only compiler entry is supported");
+    }
     // indirect through MH.form.vmentry.vmtarget
     jump_to_lambda_form(_masm, receiver_reg, rmethod, temp1, for_compiler_entry);
 
diff --git a/src/hotspot/cpu/aarch64/sharedRuntime_aarch64.cpp b/src/hotspot/cpu/aarch64/sharedRuntime_aarch64.cpp
index 40da30f69700f..b9dff404d3f54 100644
--- a/src/hotspot/cpu/aarch64/sharedRuntime_aarch64.cpp
+++ b/src/hotspot/cpu/aarch64/sharedRuntime_aarch64.cpp
@@ -1194,7 +1194,7 @@ static void gen_special_dispatch(MacroAssembler* masm,
     member_arg_pos = method->size_of_parameters() - 1;  // trailing MemberName argument
     member_reg = r19;  // known to be free at this point
     has_receiver = MethodHandles::ref_kind_has_receiver(ref_kind);
-  } else if (iid == vmIntrinsics::_invokeBasic) {
+  } else if (iid == vmIntrinsics::_invokeBasic || iid == vmIntrinsics::_linkToNative) {
     has_receiver = true;
   } else {
     fatal("unexpected intrinsic id %d", iid);
diff --git a/src/hotspot/share/opto/graphKit.cpp b/src/hotspot/share/opto/graphKit.cpp
index 6cc6a193bc369..7a3ba50896e7e 100644
--- a/src/hotspot/share/opto/graphKit.cpp
+++ b/src/hotspot/share/opto/graphKit.cpp
@@ -2629,7 +2629,10 @@ Node* GraphKit::make_native_call(const TypeFunc* call_type, uint nargs, ciNative
     call_addr = SharedRuntime::make_native_invoker(call_addr,
                                                    nep->shadow_space(),
                                                    arg_regs, ret_regs);
-    if (call_addr == NULL) return NULL;
+    if (call_addr == NULL) {
+      C->record_failure("native invoker not implemented on this platform");
+      return NULL;
+    }
     C->add_native_stub(call_addr);
   }
   assert(call_addr != NULL, "sanity");
diff --git a/test/jdk/java/foreign/TestIntrinsics.java b/test/jdk/java/foreign/TestIntrinsics.java
index 925fabe73a337..6c3a2b96db7d1 100644
--- a/test/jdk/java/foreign/TestIntrinsics.java
+++ b/test/jdk/java/foreign/TestIntrinsics.java
@@ -23,6 +23,7 @@
 
 /*
  * @test
+ * @requires os.arch=="amd64" | os.arch=="x86_64"
  * @run testng/othervm
  *   -Djdk.internal.foreign.ProgrammableInvoker.USE_SPEC=true
  *   -Djdk.internal.foreign.ProgrammableInvoker.USE_INTRINSICS=true

From 0f0b972db12f8204e556aca3f7a041f1cdd87e41 Mon Sep 17 00:00:00 2001
From: Jorn Vernee 
Date: Fri, 13 Nov 2020 12:41:55 +0000
Subject: [PATCH 65/70] Simplify print code

---
 src/hotspot/share/code/vmreg.cpp              |  6 ---
 src/hotspot/share/opto/callnode.cpp           | 15 +++++-
 src/hotspot/share/opto/callnode.hpp           |  2 +
 src/hotspot/share/opto/machnode.cpp           |  4 +-
 src/hotspot/share/opto/machnode.hpp           |  1 +
 src/hotspot/share/utilities/growableArray.hpp | 14 ++----
 src/hotspot/share/utilities/print.hpp         | 48 -------------------
 7 files changed, 22 insertions(+), 68 deletions(-)
 delete mode 100644 src/hotspot/share/utilities/print.hpp

diff --git a/src/hotspot/share/code/vmreg.cpp b/src/hotspot/share/code/vmreg.cpp
index 1e30fc50b7162..d7541d8a22668 100644
--- a/src/hotspot/share/code/vmreg.cpp
+++ b/src/hotspot/share/code/vmreg.cpp
@@ -25,7 +25,6 @@
 #include "precompiled.hpp"
 #include "asm/assembler.hpp"
 #include "code/vmreg.hpp"
-#include "utilities/print.hpp"
 
 // First VMReg value that could refer to a stack slot
 VMReg VMRegImpl::stack0 = (VMReg)(intptr_t)((ConcreteRegisterImpl::number_of_registers + 7) & ~7);
@@ -51,8 +50,3 @@ void VMRegImpl::print_on(outputStream* st) const {
 }
 
 void VMRegImpl::print() const { print_on(tty); }
-
-template<>
-void Print::print_on(const VMReg& value, outputStream* st) {
-  value->print_on(st);
-}
diff --git a/src/hotspot/share/opto/callnode.cpp b/src/hotspot/share/opto/callnode.cpp
index 664bce0110314..4fdc5e2958efc 100644
--- a/src/hotspot/share/opto/callnode.cpp
+++ b/src/hotspot/share/opto/callnode.cpp
@@ -1165,13 +1165,24 @@ Node* CallNativeNode::match(const ProjNode *proj, const Matcher *matcher) {
   return NULL;
 }
 #ifndef PRODUCT
+void CallNativeNode::print_regs(const GrowableArray& regs, outputStream* st) {
+  st->print("{ ");
+  for (int i = 0; i < regs.length(); i++) {
+    regs.at(i)->print_on(st);
+    if (i < regs.length() - 1) {
+      st->print(", ");
+    }
+  }
+  st->print(" } ");
+}
+
 void CallNativeNode::dump_spec(outputStream *st) const {
   st->print("# ");
   st->print("%s ", _name);
   st->print("_arg_regs: ");
-  _arg_regs.print_on(st);
+  print_regs(_arg_regs, st);
   st->print("_ret_regs: ");
-  _ret_regs.print_on(st);
+  print_regs(_ret_regs, st);
   CallNode::dump_spec(st);
 }
 #endif
diff --git a/src/hotspot/share/opto/callnode.hpp b/src/hotspot/share/opto/callnode.hpp
index 5f3f44a2a7915..0ca117e21c959 100644
--- a/src/hotspot/share/opto/callnode.hpp
+++ b/src/hotspot/share/opto/callnode.hpp
@@ -812,8 +812,10 @@ class CallLeafNode : public CallRuntimeNode {
 // Make a direct call into a foreign function with an arbitrary ABI
 // safepoints
 class CallNativeNode : public CallNode {
+  friend class MachCallNativeNode;
   virtual bool cmp( const Node &n ) const;
   virtual uint size_of() const;
+  static void print_regs(const GrowableArray& regs, outputStream* st);
 public:
   GrowableArray _arg_regs;
   GrowableArray _ret_regs;
diff --git a/src/hotspot/share/opto/machnode.cpp b/src/hotspot/share/opto/machnode.cpp
index 5f7645138e996..09e4cfde42923 100644
--- a/src/hotspot/share/opto/machnode.cpp
+++ b/src/hotspot/share/opto/machnode.cpp
@@ -828,9 +828,9 @@ bool MachCallNativeNode::cmp( const Node &n ) const {
 void MachCallNativeNode::dump_spec(outputStream *st) const {
   st->print("%s ",_name);
   st->print("_arg_regs: ");
-  _arg_regs.print_on(st);
+  CallNativeNode::print_regs(_arg_regs, st);
   st->print("_ret_regs: ");
-  _ret_regs.print_on(st);
+  CallNativeNode::print_regs(_ret_regs, st);
   MachCallNode::dump_spec(st);
 }
 #endif
diff --git a/src/hotspot/share/opto/machnode.hpp b/src/hotspot/share/opto/machnode.hpp
index 1e317f55b34f6..72d1284a178d4 100644
--- a/src/hotspot/share/opto/machnode.hpp
+++ b/src/hotspot/share/opto/machnode.hpp
@@ -1013,6 +1013,7 @@ class MachCallLeafNode: public MachCallRuntimeNode {
 class MachCallNativeNode: public MachCallNode {
   virtual bool cmp( const Node &n ) const;
   virtual uint size_of() const;
+  void print_regs(const GrowableArray& regs, outputStream* st) const;
 public:
   const char *_name;
   GrowableArray _arg_regs;
diff --git a/src/hotspot/share/utilities/growableArray.hpp b/src/hotspot/share/utilities/growableArray.hpp
index 7ae4a4626cf41..edee4c8a431a3 100644
--- a/src/hotspot/share/utilities/growableArray.hpp
+++ b/src/hotspot/share/utilities/growableArray.hpp
@@ -31,7 +31,6 @@
 #include "utilities/globalDefinitions.hpp"
 #include "utilities/ostream.hpp"
 #include "utilities/powerOfTwo.hpp"
-#include "utilities/print.hpp"
 
 // A growable array.
 
@@ -318,17 +317,12 @@ class GrowableArrayView : public GrowableArrayBase {
   }
 
   void print() const {
-    print_on(tty);
-  }
-
-  void print_on(outputStream* st) const {
-    st->print("Growable Array " INTPTR_FORMAT, p2i(this));
-    st->print(": length %d (_max %d) { ", _len, _max);
+    tty->print("Growable Array " INTPTR_FORMAT, p2i(this));
+    tty->print(": length %d (_max %d) { ", _len, _max);
     for (int i = 0; i < _len; i++) {
-      Print::print_on(_data[i], st);
-      st->print(", ");
+      tty->print(INTPTR_FORMAT " ", *(intptr_t*)&(_data[i]));
     }
-    st->print("}\n");
+    tty->print("}\n");
   }
 };
 
diff --git a/src/hotspot/share/utilities/print.hpp b/src/hotspot/share/utilities/print.hpp
deleted file mode 100644
index ac6d2552d302c..0000000000000
--- a/src/hotspot/share/utilities/print.hpp
+++ /dev/null
@@ -1,48 +0,0 @@
-/*
- * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.
- *
- * This code 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
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have any
- * questions.
- *
- */
-
-#ifndef SHARE_UTILITIES_PRINT_HPP
-#define SHARE_UTILITIES_PRINT_HPP
-
-#include "memory/allStatic.hpp"
-#include "utilities/ostream.hpp"
-
-class Print : AllStatic {
-public:
-  template
-  static void print(const T& value) {
-    print_on(value, tty);
-  }
-
-  // For use from generic code.
-  // Types that want better printing output should define specializations
-  // of this function template for the particular type.
-  template
-  static void print_on(const T& value, outputStream* st) {
-    // Print the first word of an object
-    st->print(INTPTR_FORMAT, *((intptr_t*) &value));
-  }
-};
-
-#endif // SHARE_UTILITIES_PRINT_HPP

From c8dafc65c7df2a4b8910d0e7e71a81b04874e87e Mon Sep 17 00:00:00 2001
From: Jorn Vernee 
Date: Fri, 13 Nov 2020 14:20:35 +0000
Subject: [PATCH 66/70] - Don't print anything in nmehtod debug output for
 native invoker if there are none. - Use memcpy to copy native stubs to
 nmethod data

---
 src/hotspot/share/code/nmethod.cpp | 18 +++++-------------
 1 file changed, 5 insertions(+), 13 deletions(-)

diff --git a/src/hotspot/share/code/nmethod.cpp b/src/hotspot/share/code/nmethod.cpp
index 80332015b5d15..561e82d194328 100644
--- a/src/hotspot/share/code/nmethod.cpp
+++ b/src/hotspot/share/code/nmethod.cpp
@@ -825,10 +825,7 @@ nmethod::nmethod(
     dependencies->copy_to(this);
     if (native_invokers.is_nonempty()) { // can not get address of zero-length array
       // Copy native stubs
-      assert(native_invokers.data_size_in_bytes() % sizeof(HeapWord) == 0, "unexpected array size");
-      Copy::disjoint_words((HeapWord*) native_invokers.adr_at(0),
-                          (HeapWord*) native_invokers_begin(),
-                          native_invokers.data_size_in_bytes() / sizeof(HeapWord));
+      memcpy(native_invokers_begin(), native_invokers.adr_at(0), native_invokers.data_size_in_bytes());
     }
     clear_unloading_state();
 
@@ -992,7 +989,7 @@ void nmethod::print_nmethod(bool printmethod) {
       print_dependencies();
       tty->print_cr("- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ");
     }
-    if (printmethod) {
+    if (printmethod && native_invokers_begin() < native_invokers_end()) {
       print_native_invokers();
       tty->print_cr("- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ");
     }
@@ -2696,14 +2693,9 @@ void nmethod::print_pcs_on(outputStream* st) {
 
 void nmethod::print_native_invokers() {
   ResourceMark m;       // in case methods get printed via debugger
-  tty->print("Native invokers:");
-  if (native_invokers_begin() < native_invokers_end()) {
-    tty->cr();
-    for (BufferBlob** itt = native_invokers_begin(); itt < native_invokers_end(); itt++) {
-      (*itt)->print_on(tty);
-    }
-  } else {
-    tty->print_cr(" ");
+  tty->print_cr("Native invokers:");
+  for (BufferBlob** itt = native_invokers_begin(); itt < native_invokers_end(); itt++) {
+    (*itt)->print_on(tty);
   }
 }
 

From 7407874d27e9da2576c1a1f8189a054c78527367 Mon Sep 17 00:00:00 2001
From: Jorn Vernee 
Date: Sat, 14 Nov 2020 14:31:31 +0100
Subject: [PATCH 67/70] Fix warnings on MSVC

---
 src/hotspot/share/code/nmethod.cpp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/hotspot/share/code/nmethod.cpp b/src/hotspot/share/code/nmethod.cpp
index 561e82d194328..9a54ca7706112 100644
--- a/src/hotspot/share/code/nmethod.cpp
+++ b/src/hotspot/share/code/nmethod.cpp
@@ -68,6 +68,7 @@
 #include "utilities/copy.hpp"
 #include "utilities/dtrace.hpp"
 #include "utilities/events.hpp"
+#include "utilities/globalDefinitions.hpp"
 #include "utilities/resourceHash.hpp"
 #include "utilities/xmlstream.hpp"
 #if INCLUDE_JVMCI
@@ -520,7 +521,7 @@ nmethod* nmethod::new_nmethod(const methodHandle& method,
       CodeBlob::allocation_size(code_buffer, sizeof(nmethod))
       + adjust_pcs_size(debug_info->pcs_size())
       + align_up((int)dependencies->size_in_bytes(), oopSize)
-      + align_up(native_invokers.data_size_in_bytes() , oopSize)
+      + align_up(checked_cast(native_invokers.data_size_in_bytes()), oopSize)
       + align_up(handler_table->size_in_bytes()    , oopSize)
       + align_up(nul_chk_table->size_in_bytes()    , oopSize)
 #if INCLUDE_JVMCI
@@ -801,7 +802,7 @@ nmethod::nmethod(
     _scopes_pcs_offset       = scopes_data_offset    + align_up(debug_info->data_size       (), oopSize);
     _dependencies_offset     = _scopes_pcs_offset    + adjust_pcs_size(debug_info->pcs_size());
     _native_invokers_offset  = _dependencies_offset  + align_up((int)dependencies->size_in_bytes(), oopSize);
-    _handler_table_offset    = _native_invokers_offset + align_up(native_invokers.data_size_in_bytes(), oopSize);
+    _handler_table_offset    = _native_invokers_offset + align_up(checked_cast(native_invokers.data_size_in_bytes()), oopSize);
     _nul_chk_table_offset    = _handler_table_offset + align_up(handler_table->size_in_bytes(), oopSize);
 #if INCLUDE_JVMCI
     _speculations_offset     = _nul_chk_table_offset + align_up(nul_chk_table->size_in_bytes(), oopSize);

From 3999a188b8013ed932d5235d971d0896a2c8bcbb Mon Sep 17 00:00:00 2001
From: Maurizio Cimadamore 
Date: Mon, 16 Nov 2020 13:01:18 +0000
Subject: [PATCH 68/70] Fix signature mismatch on aarch64

---
 src/hotspot/cpu/aarch64/sharedRuntime_aarch64.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/hotspot/cpu/aarch64/sharedRuntime_aarch64.cpp b/src/hotspot/cpu/aarch64/sharedRuntime_aarch64.cpp
index b9dff404d3f54..2b0c1af22b441 100644
--- a/src/hotspot/cpu/aarch64/sharedRuntime_aarch64.cpp
+++ b/src/hotspot/cpu/aarch64/sharedRuntime_aarch64.cpp
@@ -3062,7 +3062,7 @@ void OptoRuntime::generate_exception_blob() {
 }
 #endif // COMPILER2
 
-address SharedRuntime::make_native_invoker(address call_target,
+BufferBlob* SharedRuntime::make_native_invoker(address call_target,
                                            int shadow_space_bytes,
                                            const GrowableArray& input_registers,
                                            const GrowableArray& output_registers) {

From a836cc324916d7c6f0e4c9a8c0501d25e3d70c81 Mon Sep 17 00:00:00 2001
From: Maurizio Cimadamore 
Date: Mon, 16 Nov 2020 15:30:39 +0000
Subject: [PATCH 69/70] Fix aarch64 test failure

---
 src/hotspot/share/opto/graphKit.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/hotspot/share/opto/graphKit.cpp b/src/hotspot/share/opto/graphKit.cpp
index a6c0aee48eebe..166933525a1a3 100644
--- a/src/hotspot/share/opto/graphKit.cpp
+++ b/src/hotspot/share/opto/graphKit.cpp
@@ -2629,7 +2629,7 @@ Node* GraphKit::make_native_call(const TypeFunc* call_type, uint nargs, ciNative
     BufferBlob* invoker = SharedRuntime::make_native_invoker(call_addr,
                                                              nep->shadow_space(),
                                                              arg_regs, ret_regs);
-    if (call_addr == NULL) {
+    if (invoker == NULL) {
       C->record_failure("native invoker not implemented on this platform");
       return NULL;
     }

From a71d51a03707b459f323c241c05d81b5c0b1ffa9 Mon Sep 17 00:00:00 2001
From: Maurizio Cimadamore 
Date: Mon, 16 Nov 2020 18:47:34 +0000
Subject: [PATCH 70/70] Add `final` modifier on NativeLibraries.defaultLookup

---
 .../share/classes/jdk/internal/loader/NativeLibraries.java      | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/java.base/share/classes/jdk/internal/loader/NativeLibraries.java b/src/java.base/share/classes/jdk/internal/loader/NativeLibraries.java
index 425d1ec1ea7c9..07cdeacd73161 100644
--- a/src/java.base/share/classes/jdk/internal/loader/NativeLibraries.java
+++ b/src/java.base/share/classes/jdk/internal/loader/NativeLibraries.java
@@ -384,7 +384,7 @@ boolean open() {
         }
     }
 
-    public static NativeLibrary defaultLibrary = new NativeLibraryImpl(Object.class, "", true, true) {
+    public static final NativeLibrary defaultLibrary = new NativeLibraryImpl(Object.class, "", true, true) {
 
         @Override
         boolean open() {